DEV Community: circuitrocks

Build a Palm-Vein Biometric Door Lock with an ESP32 and IR Camera

circuitrocks — Tue, 01 Sep 2026 04:06:37 +0000

Clear a weekend and a bench, and here is the shopping list: an ESP32-WROOM-32E, a DFRobot dual-camera palm-vein module, a 5V relay board, a 12V solenoid lock, a 0.96-inch I2C OLED, and a separate barrel jack for the 12V rail. Sachin Soni of Techiesms put that exact stack on one custom PCB and ended up with a door lock that reads the veins inside your hand.

What the build actually does

Fingerprint readers get fooled by lifted prints. Face unlock gets fooled by a good photo. Palm-vein scanning sits in a harder category, because the pattern it reads is under your skin. The module floods your palm with near-infrared light at roughly 940nm. Haemoglobin in the veins swallows that wavelength while surrounding tissue bounces it back, so the camera sees a dark vein map against a bright background. Copying that pattern means imaging someone's palm without them noticing, which is a much taller order than dusting a doorknob for prints.

Wiring and firmware notes

The DFRobot sensor carries its own SoC, so the ESP32 never touches raw image data. Enrolment and matching both happen on the module, and only the verdict travels to the ESP32 over UART as a short serial message. On the ESP32 side that is two GPIO pins for RX and TX on a second hardware UART, plus SDA and SCL on GPIO 21 and 22 for the OLED at I2C address 0x3C. Watch your levels here: the ESP32 is a 3.3V part, so a 5V relay board wants an opto-isolated input or a small transistor to drive the coil. Keep the 12V solenoid on its own supply and share only ground. Skip that and the inrush current when the plunger fires will brown out the microcontroller in the middle of a match.

Where it stays honest

The biometrics hold up better than the enclosure will. Anyone who reaches the PCB can jump the relay contacts and walk straight in, and anyone who reaches the sensor cable can replay the approved byte on the UART line. Mount the board on the secure side of the door, run the sensor lead through a sealed grommet, and checksum the serial messages if you want the firmware half to match the hardware half. Soni's full walkthrough and PCB files are on Hackster.io. Bench-test the whole chain on a loose solenoid before you cut a single hole in a real door.

Originally published on blog.circuit.rocks.

esp32 #esp8266 #iot #wifi #circuitrocks

ATtiny816 PCB Business Card Runs 21 LEDs on Harvested NFC Power

circuitrocks — Mon, 31 Aug 2026 22:07:03 +0000

Battery-free is not the same thing as unpowered. A card you can tap against a phone and watch light up, with no cell to die and no port to charge, runs on energy the phone's own NFC field is already radiating. Wilson Harper built exactly that into a PCB business card, and the detail worth stealing is that it runs a real microcontroller off harvested power, not just a static tag.

What the card does

Tap it to a phone and 21 LEDs come alive. Harper started the project to learn KiCad and ended up with a credit-card-thin board carrying an NXP NTAG I2C Plus alongside a 3mm x 3mm ATtiny816. The NTAG chip is the clever half: on top of serving the record your phone reads, it routes surplus harvested DC out to external hardware, which is what keeps the ATtiny running. The ATtiny816 got picked for its QFN package and its 17 GPIOs, and thirty RoHS-compliant boards came back from JLCPCB.

The antenna is the hard part

A rectangular spiral fills the entire card, sized with STMicro's inductance calculator to land near 2.75uH so it resonates at 13.56MHz. No existing KiCad plug-in could draw that shape, so the repo ships a Python script that generates it. Two routing decisions keep the thing alive: no closed loop, and no ground plane, because eddy currents would otherwise swallow the field before the chip sees it. Six GPIO pins drive 20 Charlieplexed LEDs plus one indicator, and the firmware is bare-metal C clocked down to 1MHz to keep the flicker invisible. Every trace is mirrored onto the back silkscreen next to a block diagram and the BOM.

Build it yourself

Three exposed pads sit on the back at breadboard spacing, so programming happens over UPDI with a pogo-pin clip rather than a soldered header. A TVS diode guards the MCU against the static your wallet builds up. One gotcha is worth the price of admission: a Pico-based UPDI programmer produced nothing at all on the scope, and an Adafruit UPDI Friend worked on the first try, so budget for the known-good tool before you spend an evening probing. The tag itself was written with NXP TagWriter. A second revision with different LED colors and a button or two for arcade-style games is on the table.

The full writeup, the antenna generator script, and the BOM are at wilsonharper.net. If you want to try the idea on a breadboard first, an NTAG I2C Plus breakout and any UPDI-programmable ATtiny will get you to the energy-harvesting part without waiting on a board order.

Originally published on blog.circuit.rocks.

pcbdesign #kicad #electronics #hardwareengineering #circuitrocks

An ATmega Robot Arm That Serves Badminton Shuttlecocks

circuitrocks — Mon, 31 Aug 2026 09:07:02 +0000

What you'd need on the bench

A shuttlecock server breaks down into three subsystems you can price out separately: a feeder that isolates one shuttle at a time, a pair of counter-rotating wheels that grip and fling it, and a microcontroller keeping the timing honest. For a first attempt, budget an ATmega328P board, two motors with speed controllers, a 12V supply rated around 5A, a solenoid valve if you want a pneumatic gripper, and a hopper cut from acrylic. Everything after that is tuning.

Travis Mitchell spent years circling this problem before landing on an unusual answer: bolt the job onto a retired industrial robot arm. He converted a Denso VS050, a compact 6-axis arm small enough to sit on a height-adjustable desk, and gave it two duties. First, pluck a fresh shuttlecock from the hopper with a pneumatic grabber. Second, feed it into the spinning discs that do the launching. Denso publishes a CAD model of the arm, which meant the mounting brackets could be designed against real geometry instead of caliper guesses.

The part that decides whether it works

Mitchell started with a Raspberry Pi Pico and switched to an ATmega AVR partway through. The reason was pin count and I/O behaviour, not raw speed: talking to an industrial arm means juggling handshake lines, limit signals, and valve triggers at the same time, and the AVR gave him the headroom. That is a useful gotcha for anyone planning a build around a Pico because it is cheap. Count your GPIO needs on paper first.

The other make-or-break detail was the launch discs. Two wheels spinning at high speed have to be balanced against each other, and any material that stretches under load throws the shuttle off line. A rigid plastic disc with a silicone strip bonded to the rim ended up as the winning combination — grip from the silicone, dimensional stability from the disc underneath.

Where to take it next

Most makers do not have a spare Denso arm, but the launcher half of this project scales down cleanly. Two 775 DC motors, a pair of PWM-driven ESCs, and a gravity-fed chute will serve shuttles well enough to drill footwork, and the whole control loop fits in a few hundred lines on an Uno. Add an ultrasonic or IR sensor at the chute to confirm a shuttle actually dropped before firing, otherwise you get dry cycles that look like a jam. Watch the full build writeup and video, then wire up two motors and a hall sensor on a breadboard and see how repeatable your throw speed is before you commit to a frame.

Originally published on blog.circuit.rocks.

arduino #arduinoprojects #electronics #embedded #circuitrocks

This ESP32 CHIP-8 Computer Runs on a Flame and a Stirling Engine

circuitrocks — Mon, 31 Aug 2026 04:07:05 +0000

Power is the quiet constraint on every portable build. You size a battery, budget your current draw, and then quietly decide what the project will never do. PicketCode went the other way and removed the battery entirely: this desktop machine runs on the heat of an open flame.

A Stirling engine as the power supply

A small Stirling engine sits over a burner. Heated air in the chamber expands and pushes a piston; a flywheel carries the cycle around while cooler air is pushed back in. The output shaft spins a small DC motor in reverse, so the motor acts as a dynamo rather than a load. A panel voltmeter sits in-line, which turns the whole rig into a live demo of the thermal-to-electrical chain. Everything downstream is ordinary hobby gear: an ESP32 dev board, an OLED, and a 16-key keypad.

Why 16 keys and not a keyboard

The ESP32 runs a CHIP-8 interpreter, a virtual machine written in the mid-1970s for exactly that layout: 16 hex keys, 0 through F. CHIP-8 asks for 4KB of addressable memory and a 64x32 monochrome display, and its programs conventionally load at address 0x200. That is a rounding error against a 240 MHz dual-core ESP32 with a few hundred KB of SRAM, and the mismatch is the reason the build works. A 1970s VM leaves so much headroom that the chip can sit at a low clock and still keep frame rate when the dynamo output sags. Whether a microcontroller counts as a computer is a fair argument, but this one has a CPU, memory, persistent storage, a display, and an input device, and the CHIP-8 homebrew scene is still shipping games for it.

Build it yourself

The electronics half is a weekend of breadboard work. An SSD1306 128x64 OLED goes on SDA and SCL, a 4x4 matrix keypad eats 8 GPIO (or one ADC pin if you build a resistor ladder), and the CHIP-8 core is a few hundred lines of C. The tricky part is the rail. A small dynamo gives you a wobbling, load-dependent voltage, so put a buck-boost regulator and a fat capacitor bank between it and the board, and switch the Wi-Fi radio off in software: those transmit bursts pull 250 mA and up, which will drop you below the ESP32 brownout threshold every time the flywheel stutters. Start with a bench supply, get CHIP-8 running first, then swap the flame in. Build notes and video are on the original writeup at Hackster.

Originally published on blog.circuit.rocks.

esp32 #esp8266 #iot #wifi #circuitrocks

Wireless ESP32 Bike Brakes: ABS From Car Door Lock Actuators

circuitrocks — Sun, 30 Aug 2026 22:06:21 +0000

Cutting the cable on a bicycle brake sounds like a bad idea until you see what the ESP32 does with the freedom. Berm Peak strapped a radio link between the levers and the calipers of a fat-tire bike, and the result is a brake that can do anti-lock, adjustable bite point, and a parent-controlled speed limiter on a kid's bike across the trail.

The mechanical trick is that the calipers are pulled by 12 V car door lock actuators instead of a hydraulic line. Those actuators are cheap, punchy, and completely wrong for the job out of the box, so the build went through several prototype rounds: better calipers, a steeper actuator mounting angle, and longer lever arms to trade the actuator's short throw for usable clamping force. The stock caliper return springs stayed in place and do the releasing.

What the radio link actually does

Each lever, each caliper, and the handlebar display runs its own ESP32, all talking on 2.4 GHz. ESP-NOW is the sensible protocol here because it skips the Wi-Fi association handshake entirely and pushes a payload of up to 250 bytes straight to a peer MAC address, with round trips in the low single-digit milliseconds. That latency budget is what makes ABS possible: read wheel speed, notice lockup, pulse the actuator, repeat.

Two gotchas will bite you here. The ESP32 runs 3.3 V logic and the actuators want 12 V at a few amps, so an H-bridge or a MOSFET driver sits between them, never a bare GPIO pin. And a brake that fails silent is not a brake, so the caliper node needs a watchdog: if no packet arrives within a set window, clamp by default rather than coast.

Build a safer version on the bench

Do not put your first attempt on a bike. Wire two ESP32 dev boards on a breadboard, put a pull-up on the lever switch, and drive a 5 V linear actuator or a hobby servo as a stand-in load while you tune the mapping curve. The espressif ESP-NOW library ships with the Arduino core, so a working transmitter sketch is about thirty lines. Add a hall sensor and a magnet on the wheel to get the RPM signal your ABS loop needs.

An ESP32 dev board runs around PHP 350 at circuit.rocks, and a hall sensor module is under PHP 100, so a bench rig costs less than a single hydraulic brake bleed kit. Watch the full build at Hackaday's writeup, then start with the watchdog before you touch the actuator code.

Originally published on blog.circuit.rocks.

esp32 #esp8266 #iot #wifi #circuitrocks

Banana Pi's BPI-AI2N Packs 15 TOPS of Vision AI Into a Module

circuitrocks — Sun, 30 Aug 2026 09:07:50 +0000

Sending every camera frame to a cloud API costs you a round trip. You pay for latency, you pay per call, and every frame of your lab or your factory floor leaves the building. Banana Pi's new BPI-AI2N aims at that problem directly: a system-on-module that runs the inference locally and hands your carrier board a result instead of an image.

What Banana Pi actually shipped

The BPI-AI2N is a 69.6 x 45 mm core module built around the Renesas RZ/V2N, sold with a separate carrier board whose layout borrows heavily from NVIDIA's Jetson dev kits. Module and carrier talk through a 260-pin SO-DIMM connector, so you can prototype on the reference carrier now and design your own PCB later without redoing the compute side. Banana Pi published schematics, assembly files, Linux images, and both Yocto and Armbian support at launch, which matters a lot when your thesis panel asks to see the source.

The numbers under the heatsink

A quad-core Arm Cortex-A55 at 1.8 GHz runs Linux while Renesas' DRP-AI3 accelerator does the model work: 15 TOPS on sparse networks, 4 TOPS on dense ones. Read that gap carefully, because the headline figure assumes you have already pruned and quantized your model. A Cortex-M33 core sits alongside for real-time tasks, and a Mali-G31 GPU covers OpenGL ES 3.2. The module carries 8 GB of LPDDR4x, 32 GB of eMMC, 64 MB of SPI flash, and two Gigabit Ethernet controllers. Banana Pi rates it from -40°C to 85°C, which is the spec that decides whether your build survives a rooftop enclosure or an un-airconditioned shop.

Build it yourself

The carrier board exposes two MIPI CSI camera inputs, a MIPI DSI display connector, an M.2 Key-M slot for an NVMe SSD, a microSD slot, two USB 3.0 Type-A ports, a USB-C port for OTG and power, and a 40-pin GPIO header that will feel familiar to anyone who has wired a sensor to a Raspberry Pi. A realistic first build: one CSI camera over a conveyor or a seedling tray, inference on-module, and results published over MQTT from the second Ethernet port so the camera network stays off your campus LAN. If you hang I2C sensors on that 40-pin header, check the pull-ups first, because the module runs 3.3 V logic and most 5 V breakout boards need a level shifter.

Pricing is $293 for the BPI-AI2N-Core and $29 for the carrier, so this is a capstone-budget board rather than a weekend impulse buy. If you are scoping an edge vision project around it, size your model against the 4 TOPS dense number, not the 15 TOPS headline. Full spec breakdown at Hackster.

Originally published on blog.circuit.rocks.

edgeai #tinyml #machinelearning #ai #circuitrocks

WeatherXM D2 Mesh: A Solar LoRa Weather Station With No Wi-Fi

circuitrocks — Sun, 30 Aug 2026 04:07:24 +0000

A rain gauge sitting 6 km up a hill has no business needing a Wi-Fi password. That distance kills 2.4 GHz outright, and paying a monthly SIM plan for one sensor is hard to justify. WeatherXM's new D2 Mesh takes the third road: it hops readings home over a LoRa mesh, running on a small solar panel and nothing else.

What the D2 Mesh actually does

The kit is a complete off-grid station. One unit logs temperature, humidity, barometric pressure, rainfall, wind speed and direction, gusts, light, solar radiation, and UV. An SX1262 transceiver pushes those observations several kilometres with clear line of sight, and multi-hop routing stretches it further. Drop a second solar node on a ridge and you relay past the terrain that blocked the first link.

The other half of the kit is the gateway: an ESP32-S3, its own SX1262 radio, and a 4-inch touchscreen showing live readings. History lands on a microSD card, while local MQTT and REST endpoints hand the data straight to Home Assistant or whatever you self-host. WeatherXM's cloud stays optional rather than acting as a gate.

What's inside

The station runs an nRF5340 dual-core MCU with 16 MB of external flash, a u-blox MAX-M10S GNSS receiver for positioning, and a QMI8658A accelerometer and gyro that flags tilt, tampering, or somebody walking off with the mast. Power comes from a 6.5 V, 60 mA panel backed by batteries and a supercapacitor. A single firmware image speaks WeatherXM's own protocol, Meshtastic, or MeshCore, and the active transport switches at runtime with no reflash. Reporting adapts as well: hourly when conditions sit flat, every 5 minutes once the barometer starts moving.

Build it yourself

You don't need the kit to copy the idea. A BME280 on I2C (SDA/SCL, plus 4.7 kOhm pull-ups if your breakout leaves them off) and an RFM95 or E22 SX1262 module wired to an ESP32 gets you a working LoRa sensor node on a breadboard. RadioLib drives the radio. A tipping-bucket rain gauge is just a reed switch, so give it one GPIO with an interrupt and debounce it in software rather than adding an RC network. The gotcha most people hit is duty cycle: at SF12 a chatty node blows past regional airtime limits fast, so transmit less often and pack more readings into each packet.

WeatherXM plans to publish schematics, the bill of materials, packet specs, and firmware sources before its Crowd Supply campaign opens. Full details are in the Hackster write-up.

Originally published on blog.circuit.rocks.

esp32 #esp8266 #iot #wifi #circuitrocks

An Arduino Nano ESP32 Robot Flips All 666 Pixels of This Display

circuitrocks — Sat, 29 Aug 2026 22:07:28 +0000

Mechanical displays are having a moment. Flip-disc panels, split-flaps, and solenoid-driven pixel walls keep turning up at maker fairs, mostly because a display you can hear beats one that only glows. They all share one expensive habit, though: every single pixel needs its own actuator. Zimm's P.A.R. (Pixel Art Robot) throws that assumption out, and the workaround is worth stealing for your own matrix project.

One robot instead of 666 solenoids

A conventional flip-disc pixel pairs a permanent magnet with a solenoid. Pulse the coil one way and the disc shows its light face; reverse the polarity and the dark face comes up. That scales fine for eight pixels. P.A.R. has 666 square discs, which Zimm calls squisks, arranged in a 37 by 18 grid. Built the usual way, that is 666 coils, 666 driver channels, and a power budget nobody wants to size.

So the panel got a gantry instead. A two-axis robot rides behind the display like a pen plotter, driven by an Arduino Nano ESP32. A servo pushes a pin out to prod each squisk and flip it, while a color sensor reads whether that tile is currently light or dark. The robot only touches the squisks that actually need to change, and it can prod a stubborn one twice.

The tradeoff, and why it lands

Refresh time goes from milliseconds to minutes. That would be fatal for a train departure board. For an art piece it is the whole appeal, because you get to watch the image assemble tile by tile. The Nano ESP32 has Wi-Fi on the module, so Zimm put P.A.R. on the internet: a web form takes a drawing from anyone, queues it, and the robot renders it. Past submissions sit in a public gallery.

What to try next

The transferable idea here is closed-loop state sensing. Most matrix builds fire commands blind and trust that the hardware agreed. Reading a pixel back with a color sensor over I2C turns an open-loop guess into something self-correcting, which helps on any actuator array where a missed step is invisible until someone looks at it.

Start at an 8 by 8 grid, not 666 tiles. One hobby servo on a GPIO pin and a TCS34725-class color sensor is a weekend of gantry math and a defensible capstone demo.
The Nano ESP32 runs 3.3V logic on its GPIO, so check your servo driver and sensor breakout before wiring SDA and SCL straight across.
Watch the I2C pull-ups if you chain the color sensor with anything else on the bus. Two breakouts each carrying their own 4.7k resistors will drag the line harder than you planned.

Zimm's full write-up, including the submission site, is on Hackster: This Flip-Squisk Display Is Nothing Like a Flip-Disc Display.

Originally published on blog.circuit.rocks.

arduino #arduinoprojects #electronics #embedded #circuitrocks

Never Buy the Same L298N Twice: An Arduino UNO Q Parts Tracker

circuitrocks — Sat, 29 Aug 2026 09:07:50 +0000

You need one L298N dual H-bridge to spin a motor. A pack of 5 costs barely more than a single module, so you buy the pack, use one, and drop the rest in the parts bin. Do that three times and suddenly you own 8 of them. Akashdeep Singh of The Wrench got tired of that arithmetic and built a bench appliance that answers one question before he opens a shopping cart: do I already have this?

A parts database with a knob on it

The device sits on the workbench and shows a full-color TFT list of components sorted by category. Scroll to the drivers group, see that 8 L298N boards are already on the shelf, and the order never happens. Take one off the shelf and a twist of the dial drops the count to 7. Buy another pack and the count goes back up. No phone, no spreadsheet tab, no app that you forget to open. The whole thing lives in a printed enclosure with an unapologetically iPod-flavored shape.

What is actually inside

The host board is an Arduino UNO Q, which carries a Linux-capable application processor next to a companion microcontroller. That split matters for this build: the parts database, the search, and the interface all run as ordinary Linux software instead of being squeezed into a few kilobytes of MCU RAM. A flat file or a small SQLite table holds every part, its category, and its quantity, and rewriting a record is a normal file write rather than an EEPROM wear calculation.

Input is a Modulino Knob, an encoder-plus-button node that talks I2C over a Qwiic-style connector, so the interface adds zero solder joints. The screen rides on SPI. Between the two buses the wiring stays short, which is what makes a project like this survive on a crowded bench.

Build it yourself

Brain: an Arduino UNO Q, or any Linux SBC you already own. A Raspberry Pi Zero 2 W runs the same Python and the same SQLite file.
Screen: a 2.4-inch SPI TFT on an ST7789 or ILI9341 controller. Check whether your module is 3.3 V-only before wiring it to a 5 V board.
Input: a Modulino Knob on SDA/SCL, or a plain EC11 encoder on two GPIO pins with 10k pull-ups.
Data: three columns are enough. Category, part name, quantity.

The tricky part is not the hardware, it is discipline: the count is only correct if you turn the dial every time you pull a part. Start the database with the components you reach for weekly, not with all 200 items in the bin. If you want the original build notes, Singh's write-up is on Hackster, and the L298 datasheet is worth a read while you count how many you own: 2 channels, up to 2 A each, and a motor supply that tolerates 35 V.

Originally published on blog.circuit.rocks.

arduino #arduinoprojects #electronics #embedded #circuitrocks

A Parody Apple Laptop Reborn: The RP2350 Mactini Actually Works

circuitrocks — Sat, 29 Aug 2026 04:08:19 +0000

Joke hardware keeps turning into a serious way to learn embedded firmware. Makers have spent the last few years rebuilding gadgets that only ever existed in ads, films and cartoons, and the results keep landing harder than the punchline. A fake product hands you a fixed spec sheet you cannot argue with, which is exactly the constraint most hobby projects lack. Tucker Osman's Mactini is the sharpest example yet, and its parts list reads like a semester of coursework.

The build

The Mactini began as a spoof Apple commercial nearly 20 years ago, advertising a computer so small it shipped with a single input key. Osman built the real thing around a Waveshare RP2350 board, a color SPI display, a heap of salvaged parts and a printed shell. Speakers pulled from dead iPads handle audio, driven by an amplifier board harvested from a water-damaged security camera. Even the illuminated logo reuses diffuser layers cut out of broken third-generation iPod nano screens.

The one-key interface is the clever bit. Instead of a tactile switch, Osman made a capacitive pad from conductive filament, then wrote firmware that measures how long each press lasts and how much time passes between taps, sorting every interval into short, medium or long. When you pause, the finished rhythm is matched against a lookup table that resolves to a letter, a punctuation mark or a system command. Morse code with extra steps, and it works.

The technical takeaway

Two decisions here are worth stealing for your own project. Pushing every pixel through the CPU choked the display, so Osman moved screen writes to DMA and let the transfer run in the background while the cores got on with other work. Then, once gesture recognition, rendering and audio all shared one super loop, input lag crept in; splitting them into separate FreeRTOS tasks cleared it up. The RP2350 has headroom for that approach, with dual Cortex-M33 cores at 150 MHz, 520 KB of on-chip SRAM and 12 PIO state machines ready to bit-bang whatever protocol your display expects.

The ceiling shows too. The chip has no hardware video decoding, so a 90-second clip had to be converted to Motion JPEG, and it plays back at 12 fps.

What to try next

You do not need the whole Mactini to get the lesson out of it. Wire a 1.3-inch SPI display to a Pico 2, render a frame counter inside a plain loop, then move the buffer transfer to DMA and time both versions. The difference is obvious on a scope or even a serial print. Add a second task under FreeRTOS after that and watch the jitter drop. If your screen stays dark, check that CS and DC sit on the pins your driver library actually expects, because that one costs every student an afternoon. Full build writeup at Hackster.

Originally published on blog.circuit.rocks.

maker #electronics #diy #engineering #circuitrocks

Build a Digital Nose: an SGP30 Sensor That Sniffs Out Spoiled Milk

circuitrocks — Fri, 28 Aug 2026 22:08:02 +0000

A carton of milk that smells fine to one person can smell off to another, and if a cold has knocked out your nose entirely you get no vote at all. Adafruit's freshness checker turns that judgment call into a number on a screen, and the whole build is one Saturday afternoon of wiring and CircuitPython.

What the build actually does

The device pairs an SGP30 air-quality sensor with an Adafruit CLUE. The SGP30 reports two channels: total volatile organic compounds in ppb, and an equivalent CO2 figure in ppm, both derived from a heated metal-oxide element. Spoiling milk throws off VOCs as bacteria break down lactose and fat, so the TVOC number climbs as the carton ages. The CLUE's 240x240 IPS screen shows the reading, and its nRF52840 runs the whole loop in CircuitPython with no laptop attached.

The experiment in the guide is the honest part: fresh milk against milk deliberately left out, same sensor, same headspace over the carton. That comparison matters more than any single reading, because the SGP30 carries no absolute calibration for "spoiled." You are watching a delta, not reading a verdict.

Parts and cost reality

The SGP30 talks I2C at address 0x58, so it comes down to four wires: SDA, SCL, 3.3V, GND. The breakout carries its own regulator and pull-ups, so you can hang it off a 5V board without level shifting. Two gotchas worth knowing before you solder anything: the sensor needs roughly 15 seconds after power-up before its output means anything, and its baseline algorithm expects a steady 1 Hz sample rate. Poll it irregularly and the eCO2 figure drifts. The driver lets you save a baseline after 12 hours of running and reload it on boot, which is the difference between a demo and something you trust.

You do not need a CLUE for this. An ESP32 with a 0.96" 128x32 OLED covers the same job on a breadboard for a fraction of the cost, and the I2C wiring is identical. To rehearse the pattern while the gas sensor is still in transit, a BME280 uses the same four wires and the same import style in code.

Spend your Sunday on this

Log TVOC every 10 minutes against one carton for three days and plot the curve. That chart is a defensible data set for a science fair board or an ECE instrumentation report, and it costs one sensor plus patience. Full wiring diagram and code live at learn.adafruit.com/digital-nose-gas-sensor-milk-freshness-checker.

Originally published on blog.circuit.rocks.

sensors #iot #electronics #dataacquisition #circuitrocks

A XIAO ESP32-S3 Clock Hiding Inside a Fake Linksys WRT Router

circuitrocks — Fri, 28 Aug 2026 09:10:38 +0000

Desk clocks built out of dead consumer hardware have quietly turned into their own genre. Makers have packed displays into old cable modems, rotary phones, and rack switches, and the reason is always the same: the shell already looks like it belongs on a shelf, so the board inside can stay tiny. Glen Akins' newest build sits right in that lane, rebuilding the blue-and-black Linksys WRT router of the mid-2000s as a network clock that never needs setting.

The build itself

Akins started from an earlier Ars Technica clock that ran on a Raspberry Pi Zero 2 W, then dropped the Linux board for a Seeed Studio XIAO ESP32-S3. That module is 21 x 17.5 mm, carries a dual-core 240 MHz chip with 8 MB of PSRAM, and wakes up in under a second instead of booting a full OS just to read the time. Digits come from a large seven-segment LED backpack sitting behind a semi-translucent acrylic window, and a vinyl logo on the lid finishes the disguise. The time itself arrives over NTP on the LAN, so the clock is right the instant Wi-Fi associates and stays right after a power cut.

The part worth stealing

Wi-Fi provisioning is the real lesson here. A headless ESP32 has no keyboard, so Akins wired a button through a QWIIC connector to kick the board into access point mode. You join that temporary AP from a phone, hand over your SSID and password, and the board reboots onto the real network. QWIIC is just I2C at 3.3 V on a 4-pin JST-SH connector, which means the same port style feeds the HT16K33 display driver at address 0x70. Two devices, one bus, no extra holes drilled in the enclosure. If you have ever fought a captive portal sketch on a breadboard, that button-plus-AP pattern is the shortcut.

What to try next

Start smaller than a full router replica. Wire a XIAO ESP32-S3 to any I2C display, pull the SDA and SCL lines to 3.3 V through 4.7k pull-ups if your module lacks them, and get NTP working with the Arduino configTime() call before you touch CAD. Set your offset to 28800 seconds for Manila time and skip the daylight saving string entirely. Once the digits are correct, the enclosure becomes the fun part rather than the blocker. Akins' full write-up and photos are on Hackster, and a XIAO ESP32-S3 plus a seven-segment backpack will run you well under PHP 1,500 at circuit.rocks.

Originally published on blog.circuit.rocks.

esp32 #esp8266 #iot #wifi #circuitrocks