Microcontrollers & firmware

The chips

• ATmega328P (the Nano and the Arduino Uno): 16 MHz AVR, 5 V logic. Runs bundled bare-metal examples or any Intel HEX you export from the Arduino IDE (Sketch → Export Compiled Binary), pasted or uploaded in the Inspector.
• Raspberry Pi Pico: RP2040, Cortex-M0+ at 125 MHz, 3.3 V logic with a real onboard regulator. Takes UF2 uploads (MicroPython included) and bundled examples.
• ESP32 (classic): dual-core Xtensa LX6 at 240 MHz. Boots unmodified ESP-IDF apps, MicroPython, and compiled Arduino-ESP32 sketches from .bin images, through the genuine Espressif boot ROM.
• ESP32-C3: RISC-V at 160 MHz. Same firmware formats as the classic ESP32, single RISC-V core.
• ESP32-S3: dual-core Xtensa LX7 at 240 MHz, validated instruction-by-instruction against Espressif's QEMU. Same firmware formats as the C3, with FreeRTOS scheduling across both cores.
• ESP32-C6: single RISC-V RV32IMAC core at 160 MHz with 512 KB SRAM. Same firmware formats as the C3, and the busiest radio bench of the family: Wi-Fi 6, Bluetooth LE, and an 802.15.4 radio that runs real Zigbee and OpenThread firmware. Its Inspector gets a tab per radio.

The serial monitor

The Serial panel opens itself the moment a board prints. Multi-board benches get a tab per board; the input row types to the active tab or to all boards (toggle next to it). This is a real UART (start bits, baud timing and all), so a MicroPython board gives you its actual REPL prompt to type at.

The Code tab: whole scripts

The Code tab runs complete MicroPython scripts on the board: write (or load an example's prefilled script), press Run on board, and the script is injected through the REPL. The run status tracks completion, and a traceback anywhere surfaces as an error banner with the offending line. Scripts re-run automatically on every boot: restart the sim and your program starts with it, exactly like flashed firmware.

from machine import Pin, I2C
import time

led = Pin(2, Pin.OUT)
for n in range(10):
    led.value(n % 2)
    print('blink', n)
    time.sleep_ms(250)

Arduino C++: compiled on the server

Switch the Code tab to Arduino C++ and the same editor holds a real sketch. Press Compile & upload (or Ctrl Enter) and the sketch is built by the cloud compile service and flashed onto the bench board seconds later; compile errors come back with the failing lines marked in the editor. Signed-in accounts only. The target board follows the bench automatically when a single MCU is present.

Alongside the Arduino AVR and ESP32 cores (Wire, SPI, WiFi, Zigbee, OpenThread and friends), the compiler ships a curated set of popular libraries, each pinned to a known version and chosen because the bench actually has the hardware it drives:

• Adafruit GFX Library 1.12.6: drawing primitives for the Adafruit display drivers
• Adafruit BusIO 1.17.4: I2C/SPI helper the Adafruit drivers build on
• Adafruit SSD1306 2.5.17: the 128x64 / 128x32 OLED panels
• Adafruit SH110X 2.1.14: the SH1106 and SH1107 OLED panels
• Adafruit ST7735 and ST7789 Library 1.11.0: the 1.8" color TFT
• U8g2 2.36.19: the monochrome OLEDs and LCD, alternative API
• LiquidCrystal 1.0.7: the HD44780 16x2 character LCD
• LedControl 1.0.6: MAX7219 LED matrices and 7-segment drivers
• MD_MAX72XX 3.5.1: MAX7219 matrix cascades
• MD_Parola 3.7.5: scrolling-text effects on MAX7219 cascades
• GxEPD2 1.6.9: the SSD1681 e-paper panels (heavyweight: needs a Pro build budget)
• Adafruit NeoPixel 1.15.5: WS2812 addressable LEDs
• FastLED 3.10.5: WS2812 addressable LEDs, effects-oriented API (heavyweight: needs a Pro build budget)
• DHT sensor library 1.4.7: the DHT11 climate sensor
• Adafruit Unified Sensor 1.1.15: shared sensor base for the Adafruit drivers
• Adafruit BME280 Library 2.3.0: the BME280 environment sensor
• Adafruit MPU6050 2.2.9: the MPU-6050 accelerometer/gyro
• RTClib 2.1.4: the DS3231 real-time clock
• NewPing 1.9.7: the HC-SR04 ultrasonic ranger
• Sensirion I2C SEN5X 0.3.0: the SEN55 air-quality sensor
• Sensirion Core 0.7.3: shared base for the Sensirion drivers
• Servo 1.3.0: hobby servos (Arduino Uno only)
• ESP32Servo 3.2.1: hobby servos via LEDC (ESP32 boards only)
• Keypad 3.1.1: the 4x4 matrix keypad
• ArduinoJson 7.4.3: JSON parsing for the Wi-Fi/HTTP examples
• SD 1.3.0: the microSD card over hardware SPI (FAT files) (Arduino Uno and ESP32 (C6/C3 — call SPI.begin(6, 2, 7) first))

Builds are metered in build minutes: each build costs its wall-clock time rounded up to whole minutes, so a quick Uno sketch costs 1 and a heavyweight library build costs a few. Free accounts get 15 minutes a day (100 a month) with up to 150 seconds per build; Pro raises that to 100 a day (250 a month) and 480 seconds per build, which is what the heavyweight libraries marked above need.

Sketches are not limited to one file: the Code tab's + file button adds .h/.cpp headers and sources (and extra .ino tabs) that compile together, exactly like tabs in the Arduino IDE. The same works for MicroPython — extra .py modules are importable from main.py. Files save, share, and export with the project.

Pro accounts can additionally attach up to four custom libraries from a .zip (the Libraries row in the Code tab): source-only Arduino libraries (headers plus .cpp, up to 40 files each) that are compiled with the sketch and carried inside the project document, so a shared project still builds for whoever opens it. A custom library with the same name as a built-in one takes priority.

Flashing real hardware

A compiled sketch doesn't have to stay in the simulator. ⚡ Flash device… next to the Compile button writes the exact same firmware onto a real board over USB — no toolchain install, no agent. This uses WebSerial, which only Chromium browsers support on desktop: Chrome, Edge, Opera and Brave work; Firefox, Safari and all mobile browsers don't (the button stays visible there, disabled, and says why).

Today the ESP32-C6 family flashes (its build produces a complete flash image — bootloader, partition table and app); compile for a C6 on the bench, click Flash, pick the board's USB port, and the dialog erases, writes, verifies the result against an MD5 of the image, reboots the board and streams its serial output so you can watch your sketch boot for real. ESP32-C3 and Uno support are on the roadmap.

Two serial ports, one console

A C6 DevKit exposes two USB consoles: the native USB-Serial-JTAG port and, on dual-port boards, a USB-UART bridge. C6 sketches are built with USB CDC on boot, so Serial is the native-port console — which is why prints show up in the flash boot tail even on native-USB-only boards like the C6-Zero. Serial0 is still UART0, on the bridge port. The simulator merges both into the one Serial panel, so a sketch shows the same output on the bench as on the desk.

The onboard RGB LED

C6 DevKits carry an addressable WS2812 on GPIO8, and the simulated board has it too: rgbLedWrite(8, r, g, b) lights it on the board sprite exactly as it lights the real one, without wiring anything up. Colours follow the WS2812 datasheet, so if a particular board renders them shifted (some Waveshare pixels read our red as green-ish), that is the board's own channel order, not the simulator's.

Powering a board

Boards are electrical citizens: an ESP32 needs ~5 V on vin (its onboard LDO makes the 3.3 V rail, which can power your sensors), the Pico wants vsys, the Uno takes vin or 5v. Undervolt a board and it browns out; the en pin really resets the chip.