Community projects

A colour-copying mood lamp built on the TCS34725 RGB sensor: twice a second the sketch pulls raw red/green/blue/clear counts over I2C, normalizes them against the clear channel, classifies the dominant colour (RED, CYAN, MAGENTA...), computes colour temperature and lux with the real Adafruit formulas, and paints the whole 16-pixel NeoPixel ring in the matched colour while the OLED shows the name, RGB values, kelvin and lux. In the Lab, click the TCS34725 to reveal three R/G/B sliders and feed it any colour yourself - or leave it in auto mode and watch it sweep a full rainbow every 12 seconds. The button on GPIO 14 freezes (holds) the ring colour so you can capture a shade you like.

A bench power monitor built on the INA219 high-side sensor: every second the sketch reads the bus voltage, load current and power over I2C, integrates power into a running energy counter (mWh), tracks the peak current, and redraws an OLED dashboard with volts and milliamps in large digits. When the load pulls more than 800 mA an OVERLOAD banner appears and the red LED on GPIO 4 lights — and because the emulated supply has realistic source resistance you can watch the bus voltage sag as the current climbs. The button on GPIO 14 resets the energy and peak counters. In the Lab, click the INA219 module to reveal a 0–2000 mA load slider and try tripping the overload alarm yourself.

A dashboard speedometer built on the TinyGPS++ NMEA parser: every byte the NEO-6M sends over UART2 (module TX → GPIO 16/RX2) is pumped through gps.encode(), which validates sentence checksums and commits parsed $GPGGA/$GPRMC fields into gps.location, gps.speed, gps.satellites and gps.altitude. When location.isUpdated() reports a fresh fix the OLED redraws with the speed in large digits, satellites in view, altitude and a running trip odometer summed from TinyGPSPlus::distanceBetween() between consecutive fixes. Above 50 km/h a SPEEDING banner appears and the green LED on GPIO 4 lights; the button on GPIO 14 resets the trip. In the Lab the module behaves like a real receiver — no fix for the first couple of seconds, then a satellite count that climbs as the almanac fills in — and clicking the GPS module reveals a speed slider so you can “drive” the simulated car yourself.

The MFRC522v2 library, demonstrated properly. Where the Coffee Card and Arcade Token demos use the classic miguelbalboa MFRC522 API, this attendance station is written against the OSSLibraries MFRC522v2 rewrite: chip-select lives in a MFRC522DriverPinSimple, the bus in a MFRC522DriverSPI, the reader brace-initializes around the driver (no RST pin - v2 never drives reset), and the debug helpers are static MFRC522Debug:: calls. Every badge UID is packed into a 32-bit code and logged to an in-RAM roster: first tap checks you in with a green LED and a running head-count on the OLED, a repeat tap flags ALREADY IN with the red LED, and the button wipes the roster to start a fresh session.

MIFARE value blocks done properly. Where the Coffee Card demo stores its balance as raw bytes, this arcade token dispenser uses the real MIFARE Classic value-block machinery: tokens live in value block 6 (value + complement + copy, self-verifying), each play runs an atomic MIFARE_Decrement + MIFARE_Transfer, the bench button arms a +5 token MIFARE_Increment, fresh cards are formatted with MIFARE_SetValue, and after every transaction the balance is mirrored into backup block 5 with the classic MIFARE_Restore → MIFARE_Transfer idiom that real turnstiles use to survive power loss mid-write. Card A and card B each keep their own token balance.

A whole menu UI driven by a single pushbutton, using the OneButton library’s event state machine instead of hand-rolled debounce timers: btn.tick() in loop() debounces GPIO 14 and dispatches the callbacks registered with attachClick, attachDoubleClick and attachLongPressStart. A single click cycles through four menu items on the SSD1306 OLED, a double-click toggles the highlighted item on/off (the green LED on GPIO 4 mirrors the state), and holding the button for more than 800 ms jumps back to the home entry. The callbacks just update state and set a redraw flag — loop() does the drawing — the same keep-callbacks-short discipline you’d use on real hardware. In the Lab, try quick clicks vs. a slow hold on the bench button to see the three event types fire in the serial monitor.

slvDev's esp32-ai firmware, cloud-compilable here as-is: a 28.9-million-parameter TinyStories language model running fully offline on a $8 ESP32-S3 N16R8 at ~9.5 tokens/sec. 4-bit weights memory-mapped from a custom 14.9 MB flash partition, int8 output head in PSRAM, dual-core matvec, optional OLED/TFT story display. Note: the author has not published the trained weights — the firmware compiles and flashes, but you must train + export model.bin per the repo README before the board can generate text. MIT, github.com/slvDev/esp32-ai.

An interrupt-driven time-lapse controller that uses the DS3231’s SQW/INT pin the way battery-powered rigs do: alarm 1 is armed in DS3231_A1_PerSecond mode, the RTC pulls the INT line (wired to GPIO 27) LOW on every match, and attachInterrupt(..., FALLING) delivers the tick — no polling loop asking the RTC if it fired. Press the bench button (GPIO 14) to start rolling: every 5 seconds the rig “takes a frame”, flashing the white LED on GPIO 4 for 150 ms and logging “SHOT n @ HH:MM:SS” with the RTC’s own timestamp. The OLED shows ROLLING/PAUSED, the live RTC clock, the frame tally and a countdown to the next shot; press the button again to pause.

A productivity timer that leans on the DS3231’s real hardware alarm registers instead of millis() math: setAlarm1() arms alarm 1, the sketch polls the latched flag with rtc.alarmFired(1) and resets it with clearAlarm(1) — the exact battery-backed pattern used on real hardware. Press the bench button (GPIO 14) to start a 25-minute focus block (demo speed: 1 s = 1 min, so it rings after 25 s with three buzzer beeps on GPIO 4), then a 5-minute break follows automatically and the cycle repeats; press the button mid-phase to skip ahead. The OLED shows the phase, a live countdown from the RTC clock and a tally of completed focus blocks, and the green LED on GPIO 26 is lit while you should be focusing.

A knob-driven menu system on a 16x2 character LCD - the classic control panel combo. The ESP32Encoder library counts KY-040 quadrature pulses with the ESP32 hardware pulse counter (CLK GPIO 26, DT GPIO 27, half-quad = 2 counts per detent), so every detent scrolls the menu exactly one item, in either direction. Push the shaft (GPIO 14) to run the highlighted action: switch the LED on GPIO 4 on or off, blink it three times, show the live encoder count, or an about screen. In the Lab, hover the encoder knob and scroll to rotate it, click the knob to press it, and watch the LCD panel update.

A stored-value loyalty card where the balance lives on the card itself. The sketch authenticates MIFARE Classic block 4 through the MFRC522 reader, reads the stored balance, charges $0.75 per coffee (green LED) and writes the new balance back to the card. Fresh cards are initialized with $3.00 starter credit on first tap; when the credit runs out the red LED flashes DECLINED, and pressing the bench button arms a $1.00 top-up for the next tap. Card A and card B on the reader panel each keep their own independent balance for the whole run.

A motorized camera slider that glides between four rail positions with real acceleration ramps. AccelStepper drives a NEMA 17 through an A4988 driver (STEP GPIO 26, DIR GPIO 25) in non-blocking mode - slider.run() in loop() - so the button on GPIO 14 can pause and resume mid-move and the OLED keeps updating while the carriage travels. The display shows position in mm (20T GT2 pulley: 200 steps = 40 mm), waypoint number, state and a progress bar; the LED on GPIO 4 is lit while moving. Watch the NEMA 17 shaft turn in the Lab as the carriage glides.

Control an LED with a TV-style infrared remote. A VS1838B IR receiver (OUT on GPIO 14) picks up NEC-protocol button codes via the IRremote library: UP/DOWN arrows step the brightness of the green LED on GPIO 4 (analogWrite PWM), OK toggles power, and keys 1/2/3 jump to dim/medium/full presets. A 128x64 OLED shows the last key, the brightness value, and a bar graph. While the sketch runs, a clickable Virtual IR remote panel appears in the Lab - or leave Auto demo presses on and watch it drive itself.

Two distance sensors measure side by side so you can compare how they behave: an HC-SR04 ultrasonic sensor (NewPing library, TRIG GPIO 26 / ECHO GPIO 14) that times a sound echo in whole centimetres, and a VL53L0X time-of-flight laser (I2C) that times light in millimetres. A 128x64 OLED shows both readings, their difference, and a verdict - AGREE, SONIC FAR, or LASER FAR - and the green LED on GPIO 4 lights when the two sensors agree within 5 cm. Click each sensor on the bench and drag its own distance slider while the sketch runs.

A barometric altimeter: a BMP280 pressure sensor (Adafruit BMP280 library, I2C) converts air pressure into altitude - roughly 1 hPa lower for every 8 meters you climb. A 128x64 OLED shows the height above a baseline in big digits (meters and feet), a CLIMBING / DESCENDING / LEVEL trend, and the raw pressure. Click the BMP280 on the bench and drag its P slider to fly up and down - the green LED on GPIO 4 lights while you climb - and press the button on GPIO 14 to zero the altimeter.

A tap-to-open door lock built on the classic miguelbalboa MFRC522 SPI RFID reader. Tapping the authorized card (UID 9A:2F:C4:1B - card A on the bench panel, and the built-in auto tag) retracts a servo deadbolt for 3 seconds, lights the green LED and shows WELCOME plus a running open count on the OLED. Any other card (try card B) is rejected with the red LED and a DENIED screen. The reader panel appears on the bench while the sketch runs.

A motorized photo turntable: a 28BYJ-48 geared stepper motor (driven through a ULN2003 board with the classic Arduino Stepper library) rotates a platform in precise 45-degree moves at 12 RPM, pausing after each move so a camera could take a shot. A 128x64 OLED shows the platform angle in big digits plus the direction (CW / CCW), and the button on GPIO 4 reverses the direction. Watch the red shaft marker on the bench motor rotate with every move.

A 16-bit bench voltmeter: an ADS1115 precision ADC is read over I2C with the Adafruit ADS1X15 library (GAIN_ONE, 125 microvolts per bit), and the voltage on channel A0 is shown in big digits on a 128x64 OLED with a live bar graph and a LOW / OK / HIGH zone word. Click the ADS1115 on the bench and drag its A0 slider while the sketch runs: the display follows in real time, and the red LED on GPIO 4 lights as an over-voltage warning above 3.00 V.

A desk weather station: a BME280 environment sensor is read with the Adafruit BME280 library (temperature, humidity and barometric pressure over I2C), shown on a 128x64 OLED with a simple barometer forecast - RAIN below 1000 hPa, CHANGE up to 1020, FAIR above - plus a comfort word (HOT / COLD / MUGGY / COMFY). Click the BME280 on the bench and drag its T / H / P sliders while the sketch runs: the display follows, and the red LED on GPIO 4 lights as a storm warning when you drop the pressure below 1000 hPa.

A contactless tape measure: a VL53L0X time-of-flight laser sensor is read with the standard VL53L0X library (init + continuous ranging), and the distance is shown in big digits on a 128x64 OLED in centimetres with a live proximity bar. Click the VL53L0X on the bench and drag its distance slider while the sketch runs - the display follows, the zone word changes CLEAR / NEAR / TOO CLOSE, and the red LED on GPIO 4 lights when a target comes within 10 cm.

A working kitchen scale: an HX711 load-cell amplifier is read with the standard HX711 library (set_scale + tare), and the weight is shown in big digits on a 128x64 OLED in grams and ounces. Click the HX711 on the bench and drag its weight slider while the sketch runs - the display follows, the red LED on GPIO 4 lights with an OVERLOAD warning above 500 g, and pressing the button on GPIO 26 tares (zeroes) the scale so you can weigh into a container.

A digital spirit level: raw accelerometer reads from an MPU6050 over I2C are turned into pitch and roll angles and drawn as a bubble inside a circle on a 128x64 OLED. Click the MPU6050 on the bench and drag its X / Y tilt sliders while the sketch runs - the bubble slides around, the numbers update and the green LED on GPIO 4 lights when you are level within 3 degrees. The sketch talks to the sensor with plain Wire register reads (wake 0x6B, burst-read 0x3B), so it runs on real hardware with no extra libraries.

A DHT22 temperature/humidity sensor feeding a 128x64 OLED weather readout with min/max tracking and a comfort alert LED. Click the DHT22 on the bench and drag its two sliders while the sketch runs - the OLED, the serial monitor and the red alert LED on GPIO 4 all react live. Comfort window is 18-28 °C and 30-60 %RH; step outside it and the display calls out too hot / too cold / too humid / too dry. Plain DHT + Adafruit_SSD1306 calls, so the same sketch runs on real hardware unchanged.

Three animations on a 16-LED WS2812B NeoPixel ring: a rotating rainbow, a cyan comet with a fading tail, and a purple breathe effect. Click the bench push button (GPIO 14) to cycle rainbow → comet → breathe → off, and drag the potentiometer (GPIO 34) to set the animation speed live — the virtual ring on the bench and the pixel strip panel both animate in real time. Everything runs on plain Adafruit_NeoPixel calls, so the same sketch drops straight onto real hardware.

A web form served straight from the ESP32 controls an LED on the breadboard: type a brightness (0-255), pick steady / blink / off and press Apply — the values travel to the sketch through server.arg(). In the simulator a virtual browser opens the page about 2.5 seconds after server.begin(); submit the form or click the quick-pick links right in the browser panel and watch the LED on GPIO4 dim, blink or switch off. On real hardware, fill in your WiFi details and open the printed IP address on your phone.

The ESP32 serves its own live dashboard page straight from the chip: sensor voltage from the bench potentiometer on GPIO34, an LED toggle link, and a page-hit counter. In the simulator a virtual browser starts visiting / and /led about 2.5 seconds after server.begin() (one request every 4 seconds), so you can watch requests arrive in the serial monitor and see the onboard LED toggle — no network needed. On real hardware, put in your WiFi name and password and open the printed IP address in your phone's browser.

A battery-powered data logger pattern: the ESP32 wakes every 5 seconds, reads the battery voltage on GPIO34, prints a reading with a rising/falling trend, then deep-sleeps again — and RTC_DATA_ATTR variables keep the boot count and last reading alive across sleeps. In the simulator the bench potentiometer stands in for the battery pack (wiper to GPIO34): drag it below about 45% and the low-battery warning fires. Watch millis() restart at 0 on every wake and the onboard LED pulse once per boot. Only the timer wake source is modeled in simulation; on real hardware this pattern runs for months on a battery.

Control an LED over Bluetooth LE from a phone - the first nRF52 demo in the gallery. The XIAO nRF52840 advertises a BLE UART (Nordic UART Service); in the simulator a virtual phone connects about 2 seconds after boot and sends "led on", "blink" and "led off" every 3 seconds, so you can watch the LED react and the serial monitor echo each command without any hardware. On the real board, open Bluefruit Connect or nRF Connect, attach to FluxBench-BLE and type the same commands. Note the nRF52 gotcha the sketch handles for you: Serial needs #include <Adafruit_TinyUSB.h> on this core or the build fails to link.

Connects to WiFi, fetches a live stock quote over HTTP and shows the price and daily change on a 128x64 OLED. In the simulator there is no real network: WiFi "connects" after about a second with a fake IP address, and the Yahoo Finance URL returns realistic simulated quote JSON, so you can watch the whole connect-fetch-parse-display flow work end to end. The sketch parses the JSON by hand with indexOf/substring - no ArduinoJson needed. On real hardware, just set your own WiFi name and password at the top.

Drives a MAX7219 8x8 LED matrix with nothing but raw SPI.transfer() calls - no LedControl or MD_MAX72xx library. The sketch pulls the chip-select line low, clocks out a 16-bit register/data frame and releases CS, exactly like a datasheet example, with the MAX7219 register map explained in the comments. A heart and a smiley face alternate on the matrix every second. Great for learning what a driver library actually does under the hood.

A real alarm clock built on the DS3231 real-time clock: an SSD1306 OLED shows the date, big zero-padded HH:MM:SS time and the alarm status, and a piezo buzzer on GPIO 4 beeps at 1600 Hz when the alarm fires. The simulator RTC starts at 12:00:00, so the alarm (12:00:15) rings 15 seconds after you press Run — then click the bench push button (GPIO 14) to snooze it for 20 seconds, or click it while quiet to toggle the alarm on/off. Comments in the sketch show the two lines to change for real hardware: set the RTC from the compile time, and use a 5-minute snooze.

A stock ticker for the LilyGo T-Display S3 AMOLED (536×240): big color-coded price, change line and a live sparkline, all drawn with the flicker-free full-screen sprite pattern and pushed in one shot with pushColors(). Cycles QQQ → SPY → BTC-USD every 6 seconds — or on the GPIO 21 button: the bench has a push button wired to GPIO 21, so click it in the Lab to skip ahead (it works the same as the side button on the real board). Prices are a simulated random walk so the whole screen runs live in the Lab simulator — the comments show exactly how to swap in a real Yahoo Finance fetch on hardware.

An HC-SR04 ultrasonic ranger (TRIG GPIO5, ECHO GPIO18) measures the distance to the "car" while a 3-LED bar (green GPIO25, yellow GPIO26, red GPIO27) and a piezo buzzer on GPIO4 mimic a garage parking assistant: green means clear, yellow joins in as you approach, the buzzer beeps faster the closer you get, and under 15 cm the red LED and a solid 880 Hz tone say STOP. Drag the distance slider on the HC-SR04 in the Lab to drive the whole thing live. Bundled Lab bench, schematic and routed PCB included.

A MAX6675 amplifier reads a K-type kiln thermocouple over SPI (SCK GPIO18, CS GPIO5, SO GPIO19) in real 0.25 °C steps. Every second the sketch samples the probe, tracks the peak temperature, renders both on an SSD1306 OLED (I2C on GPIO21/22) and lights a red alarm LED on GPIO4 whenever the kiln crosses 226 °C. The simulator drives the probe with a slow firing-curve drift around ~221 °C, so you can watch the readout climb, trip the alarm and fall back. Bundled Lab bench, schematic and routed PCB included.

The classic CS proof, live on a breadboard: five NAND gates - and nothing else - rebuild NOT, AND and OR. NAND(A,A) makes an inverter, a double NAND makes AND, and De Morgan turns two inverters plus a NAND into OR. The ESP32 drives A and B, reads all three derived outputs back and checks every truth-table row in the serial monitor while yellow, red and green LEDs show NOT, AND and OR on the bench. Pull one wire and watch exactly the right rows fail. Bundled Lab bench, schematic and routed PCB included.

An INMP441 MEMS microphone streams 16-bit audio into the ESP32 over I2S (SCK GPIO32, WS GPIO25, SD GPIO33). Every 100 ms the sketch reads a 256-sample block with the ESP-IDF i2s_read() driver, computes the RMS level, converts it to dBFS and lights a proportional 5-LED VU bar (2 green, 2 yellow, 1 red) while printing a matching serial bar graph. The simulator feeds the mic a synthetic ambient tone whose loudness slowly rises and falls, so the VU bar sweeps up and down just like a real room. Bundled Lab bench, schematic and routed PCB included.

Analog in, motion out: a 10k potentiometer forms a real voltage divider into GPIO34 and the solver computes the wiper voltage live, so analogRead() maps the knob straight to an SG90 servo angle on GPIO25. Press the tactile button (GPIO14, internal pull-up) to toggle an auto-sweep mode that glides the horn 0-180-0 while a blue LED on GPIO26 signals sweep is active. Watch the horn track the knob in the Lab, then break the wiper wire and see the angle drop to zero. Bundled Lab bench, schematic and routed PCB included.

The next step after the half adder: a 1-bit FULL adder built from five 74HC-style gate modules — two XORs, two ANDs and an OR — where gate outputs feed other gate inputs through a depth-3 network that the Lab solves from real voltages. The ESP32 drives A, B and carry-in from three GPIOs, reads SUM and CARRY back, and verifies all eight truth-table rows live; two LEDs show the result on the bench. Pull any wire mid-run and the chain genuinely breaks. Bundled Lab bench, schematic and routed PCB included.

Four I2C devices share one two-wire bus (SDA GPIO21 / SCL GPIO22): a BME280 environment sensor at 0x76, a BH1750 light meter at 0x23, an MPU-6050 IMU at 0x68 and an SSD1306 OLED at 0x3C. The sketch scans the bus at boot and lists every address it finds, then streams a live serial dashboard while the OLED rotates between environment, light and motion pages. The simulator answers real register reads - chip IDs, WHO_AM_I and measurement registers - so the bus scan and every library call behave like real silicon. Bundled Lab bench, schematic and routed PCB included.

Code-entry door lock: a 4×4 membrane keypad drives an SG90 servo latch — type 2468 then # and the latch swings open for 5 seconds, with buzzer feedback on every key and a lock-state LED. In the Lab simulator you can click the keypad keys live. Bundled Lab bench, schematic and routed PCB included.

Two-node CAN bus bench on a single ESP32: one MCP2515 module plays the engine ECU broadcasting RPM (0x100), coolant temp (0x200) and a chatty infotainment frame (0x300), while a second MCP2515 is the dashboard node whose acceptance mask/filters admit only the two engine IDs — in the Lab simulator the paired nodes exchange frames and the filtered 0x300 frame surfaces as a rejection warning. Bundled Lab bench, schematic and routed PCB included.

Long-range wireless telemetry bench on a single ESP32: one RFM95 radio plays a remote weather station transmitting 4-byte binary packets (sequence, temperature, humidity) every 2 seconds, while a second RFM95 is the base station that receives and prints the readings with RSSI. Both radios share sync word 0xF3 — midway the remote is deliberately misconfigured to 0x34 so you can watch the link drop and recover, with the Lab simulator explaining the sync-word filtering. Bundled Lab bench, schematic and routed PCB included.

Temperature/humidity logger: a DHT22 sampled every 2 seconds, appended as CSV to a MicroSD card over SPI, with a status LED blip per sample and periodic file read-back on the serial monitor. The simulator models the SD card as a real in-memory filesystem — watch /datalog.csv grow. Bundled Lab bench, schematic and routed PCB included.

Tap-to-enter access reader: a PN532 NFC module (I2C) enrolls the first card tapped as a 3-use visitor pass, then answers each tap with a green "granted" or red "denied" LED and buzzer chirps — in the Lab simulator a virtual tag taps the antenna every few seconds, or use the reader panel to tap two virtual cards yourself and watch the pass get enrolled, used up and a foreign card rejected. Bundled Lab bench, schematic and routed PCB included.

Digital-logic starter bench: a 1-bit half adder built from two 74HC-style gate modules — an XOR gate computes SUM and an AND gate computes CARRY. The ESP32 walks the inputs through the full truth table, reads the gate outputs back, and verifies them live; each output also drives an LED so you can watch the adder count. The gates are solved from real voltages in the Lab, so pulling a power wire mid-run genuinely breaks the adder and the sketch reports the mismatch. Bundled Lab bench, schematic and routed PCB included.

Classic NE555 astable multivibrator blinking a red LED, fully simulated on the Lab breadboard. Drag the RA trimpot to sweep the blink rate live (≈4.8–9 Hz) and drag the CTRL-pin trimpot to bend frequency and duty via pin-5 modulation. Bundled schematic and a routed PCB included — fork it and make it yours.

Wireless remote control bench on a single ESP32: one nRF24L01+ radio plays a handheld controller sending a Command struct (sequence, throttle, steer) once a second to pipe address ROVR1, while a second nRF24L01+ is the rover receiver that prints each command. Midway the remote is deliberately misconfigured to write to pipe GHOST so you can watch write() fail and the packet get lost — the Lab simulator explains the pipe-address routing — then the pipe is restored. Bundled Lab bench, schematic and routed PCB included.

Flagship demo: a GC9A01 1.28" round display drawing a smooth analog speed gauge from a potentiometer on GPIO34. Flicker-free canvas rendering, colored zone arcs and live serial telemetry for the plotter. Fork it and make it yours.