Arduino, running the sketch you wrote
arduino-cli compiles it, an AVR8 core executes it instruction by instruction, and the LCD shows what the ATmega328P actually put on the bus. Uno, Nano, Mega and ATtiny85, no board on your desk.

Hardware is all about iteration. Velxio lets you wire a circuit, program the board and run it in seconds, real firmware on a real solver, right in the browser.
DFRobot · M5Stack links on this page are affiliate links: a purchase through them earns Velxio a small commission at no extra cost to you.
Nothing on this page is a scripted animation: the firmware is compiled and executed, and the circuit around it is solved.
arduino-cli compiles it, an AVR8 core executes it instruction by instruction, and the LCD shows what the ATmega328P actually put on the bus. Uno, Nano, Mega and ATtiny85, no board on your desk.

arduino-cli or ESP-IDF compiles the sketch, then AVR8, RP2040, RISC-V, Xtensa or ARM executes it instruction by instruction. What the OLED draws and what the serial monitor prints is what the chip actually did.

ngspice compiled to WebAssembly runs a full nodal analysis about 60 times a second. GPIO pins drive real nets, ADC inputs read solved node voltages, and probes report RMS, DC and current wherever you drop them.

Adders, comparators, decoders, flip-flops and a 1-bit ALU slice: no microcontroller anywhere, just gates, switches and LEDs solved as a real net. The classroom half of electronics, without the breadboard.

The M5Stack Cardputer with its keyboard, Seeed's round display keeping time, Pimoroni's Badger 2350 driving e-paper, and DFRobot's UNIHIKER M10 in the catalogue alongside them. Their makers sent the hardware so the emulation could be checked against the real thing.




35 boards across 6 CPU architectures — AVR8, ARM Cortex-M, ARM Cortex-A, RISC-V, Xtensa, and Linux. Including partner boards from Pimoroni, M5Stack, Seeed Studio and DFRobot. All running locally, no cloud needed.
One institution contract gives every student in the class a full Pro account. No per-seat checkout, no card details in a classroom.
Private projects, BOM and schematic exports, GitHub Sync and the offline desktop app, for everyone enrolled.
Billed once to your institution, per semester or per year. Volume pricing on request for large cohorts.
Arduino, ESP32, RP2040, STM32, ATtiny and Raspberry Pi, with SPICE analog solved alongside the firmware. Not a sandboxed mock.
The simulator stays free forever, WiFi with internet included. Paid plans unlock the Linux and STM32 boards, custom WiFi networks, the local network gateway and the offline desktop app. Maker and Pro add the AI agent; No AI leaves it out.
Discover the simulator + light AI help.
The full workbench, zero AI. You write every line.
For makers shipping real circuits with AI help.
Private projects, GitHub Sync and BOM exports.
Questions, bugs and ideas: the Discord and the issue tracker are open, and so is every line of the simulator.
Dual-ESP32 build: a DevKit V1 dashboard reading DHT22, sound and GPS on a 2.8" ILI9341, plus an ESP32-CAM sending mock vision results over UART.
An interactive ESP32 circuit simulation you can run free in your browser on Velxio, by seabecyber.
/*
* Mopane Monitor - MAIN node (ESP32 DevKit V1)
*
* Sensors : DHT22 (D4), Grove sound sensor (D34), Grove GPS (Serial2: RX2/TX2)
* Link : ESP32-CAM results arrive on Serial1 (D25 = RX, D26 = TX)
* Display : ILI9341 2.8" on hardware SPI (display only, touch pins unused)
*
* Camera link protocol (one line per second from the CAM board):
* CAM,<detected 0/1>,<stage 0-2>,<confidence 0-100>
* stage: 0 = no worms, 1 = early growth, 2 = advanced growth
*
* Reply to the CAM (one line per second, over D26):
* MAIN,<state 0-2>,<confidence 0-100>,<uncertain 0/1>
*
* Fusion: optical (60 %) + acoustic (40 %) weighted vote. Low confidence is
* shown as UNCERTAIN, never as a confirmed harvest recommendation.
* If the camera is offline the node falls back to acoustic-only.
*/
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include <DHT.h>
#include <TinyGPSPlus.h>
// ----------------------------------------------------------------- Pins
#define TFT_CS 5
#define TFT_DC 32
#define TFT_RST 33
// SCK = D18, MOSI = D23, MISO = D19 (default SPI, not listed in code)
#define DHT_PIN 4
#define DHT_TYPE DHT22
#define MIC_PIN 34
#define GPS_RX 16 // GPS TX -> D16 (RX2)
#define GPS_TX 17 // GPS RX <- D17 (TX2)
#define CAM_RX 25 // CAM TX -> D25
#define CAM_TX 26 // CAM RX <- D26
// ----------------------------------------------------------------- Tuning
const uint32_t DHT_MS = 2000;
const uint32_t MIC_MS = 200;
const uint32_t SCREEN_MS = 500;
const uint32_t CAM_TIMEOUT = 5000; // ms without a CAM line = offline
const float MIC_LOW = 10.0f; // % below this: no feeding activity
const float MIC_HIGH = 40.0f; // % above this: vigorous activity
const float UNCERTAIN_BELOW = 70.0f;
// ----------------------------------------------------------------- Objects
Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);
DHT dht(DHT_PIN, DHT_TYPE);
TinyGPSPlus gps;
// ----------------------------------------------------------------- State
float tempC = NAN, hum = NAN;
float micLevel = 0; // 0-100 %
float micBaseline = -1;
struct CamData {
int detected = 0;
int stage = 0;
int conf = 0;
uint32_t lastMs = 0;
} cam;
int acStage = 0; float acConf = 0; // acoustic-only result
int opStage = 0; float opConf = 0; // optical-only result
int fusedStage = 0; float fusedConf = 0;
bool camOnline = false;
bool uncertain = true;
uint32_t tDht = 0, tMic = 0, tScreen = 0, tStatus = 0;
const uint32_t STATUS_MS = 1000; // how often the result is sent back to the CAM
char camBuf[48];
uint8_t camLen = 0;
const char* stageName(int s) {
return s == 0 ? "No worms" : (s == 1 ? "Early growth" : "Advanced growth");
}
// ----------------------------------------------------------------- Display helpers
void printLine(int x, int y, const char* s, uint16_t color, uint8_t size = 1, int width = 24) {
char buf[40];
snprintf(buf, sizeof(