13 |
65 |
14 |
15 |
18 | 404 :(
19 |
20 |
21 |
64 |
22 |
46 |
60 |
62 |
63 | .default})
35 |
36 | Wokwi stores the uploaded files for you, alongside with your project. Anyone who opens your project and starts the simulation will have to wait for all the micro SD card files to download before the simulation starts.
37 |
38 | Example: [microSD Card project with a custom bitmap file](https://wokwi.com/projects/319810932695892564)
39 |
40 | ## Arduino code example
41 |
42 | The example below uses the popular _SdFat_ Arduino library. It prints a list of all the files in the card. The code assumes the following connections:
43 |
44 | | SD card pin | Arduino Uno pin |
45 | | ----------- | --------------- |
46 | | SCK | 13 |
47 | | DO | 12 |
48 | | DI | 11 |
49 | | CS | 10 |
50 |
51 | ```cpp
52 | #include "SdFat.h"
53 |
54 | #define SPI_SPEED SD_SCK_MHZ(4)
55 | #define CS_PIN 10
56 |
57 | SdFat sd;
58 |
59 | void setup() {
60 | Serial.begin(115200);
61 | if (!sd.begin(CS_PIN, SPI_SPEED)) {
62 | if (sd.card()->errorCode()) {
63 | Serial.println("SD initialization failed.");
64 | } else if (sd.vol()->fatType() == 0) {
65 | Serial.println("Can't find a valid FAT16/FAT32 partition.");
66 | } else {
67 | Serial.println("Can't determine error type");
68 | }
69 | return;
70 | }
71 |
72 | Serial.println("Files on card:");
73 | Serial.println(" Size Name");
74 |
75 | sd.ls(LS_R | LS_SIZE);
76 | }
77 |
78 | void loop() {
79 | }
80 | ```
81 |
82 | [Run this example on Wokwi](https://wokwi.com/projects/310692660849410626)
83 |
84 | ## Simulator examples
85 |
86 | - [SD library example](https://wokwi.com/projects/310542489623724609)
87 | - [SdFat library example](https://wokwi.com/projects/310692660849410626)
88 |
--------------------------------------------------------------------------------
/docs/parts/board-st-nucleo-l031k6.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: STM32 Nucleo32 L031K6
3 | sidebar_label: board-st-nucleo-l031k6
4 | ---
5 |
6 | A Nucleo-32 development board with STM32L031K6 MCU: ARM Cortex-M0+ processor, 32 KB Flash, 8 KB RAM, 1 KB EEPROM running at 32 MHz.
7 |
8 | 
9 |
10 | ### Onboard LED
11 |
12 | The Nucleo-L031K6 has an onboard user LED (LD3), attached to GPIO pin PB3 (D13). The LED is lit when the pin is driven high.
13 |
14 | You can also use the `LED_BUILTIN` constant to reference the LED in your Arduino code:
15 |
16 | ```cpp
17 | pinMode(LED_BUILTIN, OUTPUT);
18 | digitalWrite(LED_BUILTIN, HIGH);
19 | ```
20 |
21 | See [Blink](https://wokwi.com/projects/367243685392886785) for a complete code example.
22 |
23 | ## Simulation features
24 |
25 | This table summarizes the current status of the STM32L031K6 MCU simulation features:
26 |
27 | | Feature | Status | Notes |
28 | | -------------- | ------ | ----------------------------------------------- |
29 | | Processor core | ✔️ | Cortex M0+ core |
30 | | SysTick timer | ✔️ | |
31 | | EERPOM | ✔️ | |
32 | | GPIO | ✔️ | |
33 | | USART | ✔️ | |
34 | | I2C | ✔️ | Master mode only |
35 | | SPI | ✔️ | Master mode only |
36 | | ADC | ✔️ | Used by analogRead() |
37 | | STM32 timers | ❌ | TIM2/21/22 |
38 | | Comparator | ❌ | |
39 | | CRC | ✔️ | 32, 16, and 8 bits (7 bits not supported) |
40 | | DBG | ❌ | |
41 | | DMA | ❌ | |
42 | | EXTI | ✔️ | |
43 | | IWDG | ❌ | |
44 | | LPTIM | ❌ | Low power timer |
45 | | LPUART | ❌ | Low power USART |
46 | | PWR | ❌ | |
47 | | RCC | ✔️ | |
48 | | RTC | ❌ | |
49 | | SYSCFG | 🟡 | Only EXTICRn registers |
50 | | WWDG | 🟡 | Implemented, not tested yet |
51 | | GDB Debugging | ✔️ | See the [GDB Debugging guide](../gdb-debugging) |
52 |
53 | Legend:
54 | ✔️ Simulated
55 | 🟡 Partial implementation/work in progress
56 | ❌ Not implemented
57 |
58 | ## Simulator examples
59 |
60 | - [Nucleo-L031K6 STM32 HAL Example](https://wokwi.com/projects/367244067477216257)
61 | - [Nucleo-L031K6 and I2C LCD1602](https://wokwi.com/projects/367245102561225729)
62 | - [Nucleo-L031K6 and ILI9341 SPI LCD Display](https://wokwi.com/projects/367245384072432641)
63 | - [GPIO Interrupts on Nucleo-L031K6](https://wokwi.com/projects/367245698833985537)
64 |
--------------------------------------------------------------------------------
/sidebars.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | main: {
3 | 'Getting Started': ['welcome', 'getting-started/supported-hardware', 'faq'],
4 | Guides: [
5 | 'guides/diagram-editor',
6 | 'keyboard-shortcuts',
7 | 'guides/debugger',
8 | 'gdb-debugging',
9 | 'guides/serial-monitor',
10 | 'guides/logic-analyzer',
11 | 'guides/libraries',
12 | 'guides/micropython',
13 | 'guides/circuitpython',
14 | 'guides/esp32',
15 | 'guides/esp32-wifi',
16 | 'guides/custom-chips-to-wasm'
17 | ],
18 | 'Diagram Reference': [
19 | 'diagram-format',
20 | 'parts/board-franzininho-wifi',
21 | 'parts/board-grove-oled-sh1107',
22 | 'parts/board-ssd1306',
23 | 'parts/board-st-nucleo-c031c6',
24 | 'parts/board-st-nucleo-l031k6',
25 | 'parts/wokwi-74hc165',
26 | 'parts/wokwi-74hc595',
27 | 'parts/wokwi-7segment',
28 | 'parts/wokwi-a4988',
29 | 'parts/wokwi-analog-joystick',
30 | 'parts/wokwi-arduino-mega',
31 | 'parts/wokwi-arduino-nano',
32 | 'parts/wokwi-arduino-uno',
33 | 'parts/wokwi-attiny85',
34 | 'parts/wokwi-biaxial-stepper',
35 | 'parts/wokwi-buzzer',
36 | 'parts/wokwi-dht22',
37 | 'parts/wokwi-dip-switch-8',
38 | 'parts/wokwi-ds1307',
39 | 'parts/wokwi-franzininho',
40 | 'parts/wokwi-gas-sensor',
41 | 'parts/wokwi-hc-sr04',
42 | 'parts/wokwi-hx711',
43 | 'parts/wokwi-ili9341',
44 | 'parts/wokwi-ir-receiver',
45 | 'parts/wokwi-ir-remote',
46 | 'parts/wokwi-ks2e-m-dc5',
47 | 'parts/wokwi-ky-040',
48 | 'parts/wokwi-lcd1602',
49 | 'parts/wokwi-lcd2004',
50 | 'parts/wokwi-led',
51 | 'parts/wokwi-led-bar-graph',
52 | 'parts/wokwi-logic-analyzer',
53 | 'parts/wokwi-max7219-matrix',
54 | 'parts/wokwi-membrane-keypad',
55 | 'parts/wokwi-microsd-card',
56 | 'parts/wokwi-mpu6050',
57 | 'parts/wokwi-nlsf595',
58 | 'parts/wokwi-nokia-5110-screen',
59 | 'parts/wokwi-ntc-temperature-sensor',
60 | 'parts/wokwi-photoresistor-sensor',
61 | 'parts/wokwi-pi-pico',
62 | 'parts/wokwi-pir-motion-sensor',
63 | 'parts/wokwi-potentiometer',
64 | 'parts/wokwi-pushbutton',
65 | 'parts/wokwi-pushbutton-6mm',
66 | 'parts/wokwi-relay-module',
67 | 'parts/wokwi-resistor',
68 | 'parts/wokwi-rgb-led',
69 | 'parts/wokwi-servo',
70 | 'parts/wokwi-slide-potentiometer',
71 | 'parts/wokwi-slide-switch',
72 | 'parts/wokwi-stepper-motor',
73 | 'parts/wokwi-text',
74 | 'parts/wokwi-tm1637-7segment',
75 | 'parts/wokwi-tv',
76 | ],
77 | 'Chips API': [
78 | 'chips-api/getting-started',
79 | 'chips-api/tutorial-7seg',
80 | 'chips-api/chip-json',
81 | 'chips-api/gpio',
82 | 'chips-api/analog',
83 | 'chips-api/time',
84 | 'chips-api/uart',
85 | 'chips-api/i2c',
86 | 'chips-api/spi',
87 | 'chips-api/attributes',
88 | 'chips-api/framebuffer',
89 | ],
90 | 'VS Code Extension': [
91 | 'vscode/getting-started',
92 | 'vscode/project-config',
93 | 'vscode/diagram-editor',
94 | 'vscode/debugging',
95 | 'vscode/offline-mode',
96 | 'vscode/migrating',
97 | 'vscode/vscode-micropython',
98 | ],
99 | 'Wokwi CI': [
100 | 'wokwi-ci/getting-started',
101 | 'wokwi-ci/cli-installation',
102 | 'wokwi-ci/cli-usage',
103 | 'wokwi-ci/github-actions',
104 | 'wokwi-ci/automation-scenarios',
105 | 'wokwi-ci/mcp-support',
106 | ],
107 | 'Contributing': [
108 | 'contributing/docs',
109 | 'contributing/translating',
110 | ]
111 | },
112 | };
113 |
--------------------------------------------------------------------------------
/docs/chips-api/spi.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: SPI Device API
3 | sidebar_label: SPI API
4 | ---
5 |
6 | # SPI Device API
7 |
8 | To create an SPI device, first call `spi_init`, passing in an `spi_config_t` struct. This struct defines the clock and MOSI/MISO pins, the SPI mode, and the `done` callback.
9 |
10 | ### spi_dev_t spi_init(spi_config_t \*config)
11 |
12 | Initializes an SPI device interface. The `config` argument defines the pins, mode, and callbacks for the SPI device. It contains the following fields:
13 |
14 | | Field | Type | Description |
15 | | ----------- | ---------- | --------------------------------------------------------------------- |
16 | | `sck` | `pin_t` | The clock pin |
17 | | `mosi` | `pin_t` | The MOSI data pin (or `NO_PIN` to disable MOSI) |
18 | | `miso` | `pin_t` | The MISO data pin (or `NO_PIN` to disable MISO) |
19 | | `mode` | `uint32_t` | SPI mode: `0`, `1`, `2`, or `3` (default: `0`) |
20 | | `done` | `callback` | Called when an SPI transaction finishes (see below) |
21 | | `user_data` | `void *` | Data that will be passed in the first argument of the `done` callback |
22 |
23 | The API does not support a CS/SS pin: it is up to the user to select/deselect the SPI interface by calling `spi_start()` and `spi_stop()`.
24 |
25 | :::warning
26 |
27 | Note: `spi_init` can only be called from `chip_init()`. Do not call it at a later time.
28 |
29 | :::
30 |
31 | Example:
32 |
33 | ```cpp
34 | const spi_config_t spi1 = {
35 | .sck = pin_init("SCK", INPUT),
36 | .mosi = pin_init("MOSI", INPUT),
37 | .miso = pin_init("MISO", INPUT),
38 | .mode = 0,
39 | .done = chip_spi_done, // See the example below
40 | .user_data = chip,
41 | };
42 | ```
43 |
44 | ### void spi_start(spi_dev_t spi, uint8_t \*buffer, uint32_t count)
45 |
46 | Starts an SPI transaction, sending and receiving `count` bytes to/from the given `buffer`.
47 |
48 | You will usually listen for the CS (chip select) pin with `pin_watch`. Call `spi_start()` when the CS pin goes low, and `spi_stop()` when the CS pin goes high.
49 |
50 | When creating a device that transfers large amounts of data (e.g. an LCD display), it's recommended to use a large buffer size (few kilobytes). The simulator can use the larger buffer to optimize DMA-controlled SPI transfer and speed up the simulation.
51 |
52 | For simple devices that transfer small amounts of data, you can use a single-byte buffer, and process each byte as it arrives in the `done` callback.
53 |
54 | ### void spi_stop(spi_dev_t spi)
55 |
56 | Stops the SPI interface. Usually, you'd call this method when the CS pin goes high.
57 |
58 | ### The `done` callback
59 |
60 | The signature for the `done` callback is as follows:
61 |
62 | ```cpp
63 | static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
64 | // 1. process the received data (optional)
65 | // 2. if the CS pin is still low, schedule the next SPI transaction using `spi_start`
66 | }
67 | ```
68 |
69 | The `done` callback runs when an SPI transaction finishes: either when the buffer provided to `spi_start` is full, or when `spi_stop` was called. The `buffer` contains the data received (it is the same buffer given to `spi_start`), and `count` is the number of bytes that have been transferred (or `0` if `spi_stop` was called before a complete byte has been transferred).
70 |
71 | Your `done` callback should check the status of the CS pin, and if it is still low, it should call `spi_start()` again to receive the next chunk of data from the microcontroller.
72 |
73 | ## Simulator examples
74 |
75 | - [SPI ROT13 Chip Example](https://wokwi.com/projects/330669951756010068)
76 |
--------------------------------------------------------------------------------
/docs/chips-api/gpio.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: GPIO pins API
3 | sidebar_label: GPIO API
4 | ---
5 |
6 | # GPIO pins API
7 |
8 | Chips interact with the simulator using digital pins. The pins are defined in a JSON file, called `{chip-name}.chip.json` (replace `{chip-name}` with the actual name of the chip). For instance, the following JSON file defines a chip with 4 pins (`IN`, `OUT`, `VCC`, `GND`):
9 |
10 | ```json
11 | {
12 | "name": "Inverter",
13 | "author": "Uri Shaked",
14 | "pins": ["OUT", "IN", "VCC", "GND"]
15 | }
16 | ```
17 |
18 | The GPIO pins API allows your chip implementation code to interact with the GPIO pins:
19 |
20 | ### pin_t pin_init(const char \*name, uint32_t mode)
21 |
22 | Initializes the given pin, and returns a pin identifier for use with the other pin methods. The `mode` parameters configure the initial state of the pin. The following values are available:
23 |
24 | - `INPUT` - configures the pin as a digital input
25 | - `INPUT_PULLUP` - configures the pin as a digital input, and attaches a pull-up register to the pin.
26 | - `INPUT_PULLDOWN` - configures the pin as a digital input, and attaches a pull-down register to the pin.
27 | - `OUTPUT` - configures the pin as a digital output
28 | - `OUTPUT_LOW` - configures the pin as a digital output, sets the value of the pin to LOW
29 | - `OUTPUT_HIGH` - configures the pin as a digital output, sets the value of the pin to HIGH
30 | - `ANALOG` - configures the pin as an analog pin. See the [Analog API](analog) section for more detail.
31 |
32 | :::warning
33 |
34 | Note: `pin_init()` can only be called from `chip_init()`. Do not call it at a later time. You can use `pin_mode()` to change the mode of a pin at any time.
35 |
36 | :::
37 |
38 | ### void pin_mode(pin_t pin, uint32_t mode)
39 |
40 | Configures the given `pin` as digital input or output. The valid values for `mode` are the same as `pin_init()`: `INPUT`, `INPUT_PULLUP`, `INPUT_PULLDOWN`, `OUTPUT`, `OUTPUT_LOW`, `OUTPUT_HIGH`, and `ANALOG`.
41 |
42 | ### void pin_write(pin_t pin, uint32_t value)
43 |
44 | Set the output value for a digital pin. Use the `LOW` and `HIGH` constants for `value`.
45 |
46 | ### uint32_t pin_read(pin_t pin)
47 |
48 | Reads the current digital value of the pin, returns either `LOW` or `HIGH`.
49 |
50 | ### bool pin_watch(pin_t pin, pin_watch_config_t \*config)
51 |
52 | Listens for changes in the digital value of the given pin. The config structure contains the following fields:
53 |
54 | | Field | Type | Description |
55 | | ------------ | ---------- | -------------------------------------------------------------------- |
56 | | `edge` | `uint32_t` | What pin value changes we listen for (`RISING`, `FALLING` or `BOTH`) |
57 | | `pin_change` | callback | Called when the pin value changes (see below) |
58 | | `user_data` | `void *` | Data that will be passed in the first argument to `pin_change` |
59 |
60 | The valid values for edge are:
61 |
62 | - `BOTH` - Listen for any value change
63 | - `FALLING` - Listen for `HIGH` to `LOW` changes
64 | - `RISING` - Listen for `LOW` to `HIGH` changes
65 |
66 | You can only have one watch for a pin at any given time. The function returns `true` if the watch was successfully set, or `false` in case there is already a watch defined for this pin (and thus the new watch was not set).
67 |
68 | The `pin_change` callback signature is as follows:
69 |
70 | ```cpp
71 | void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
72 | // value will either be HIGH or LOW
73 | }
74 | ```
75 |
76 | Usage example:
77 |
78 | ```cpp
79 | const pin_watch_config_t watch_config = {
80 | .edge = FALLING,
81 | .pin_change = chip_pin_change,
82 | .user_data = chip,
83 | };
84 | pin_watch(pin, &watch_config);
85 | ```
86 |
87 | ### void pin_watch_stop(pin_t pin)
88 |
89 | Stops watching for changes on the given pin.
90 |
--------------------------------------------------------------------------------
/docs/parts/wokwi-led.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: wokwi-led Reference
3 | sidebar_label: wokwi-led
4 | ---
5 |
6 | Standard 5mm LED.
7 |
8 |