DEV Community: TinkerNews

TinkerNews Podcast #58: MatTris, MirrorBallBot, and the ESP32 Science Tricorder

TinkerNews — Mon, 19 Oct 2026 19:53:54 +0000

The TinkerNews podcast has a new episode: TinkerNews Podcast #58: MatTris, MirrorBallBot, and the ESP32 Science Tricorder.

TinkerNews, a free weekly DIY electronics newsletter. Every Sunday's issue curates the best DIY electronics builds on the web (ESP32, Arduino, Raspberry Pi, robotics, IoT), and this podcast is its audio edition.

🎧 Listen to the episode: https://www.tinkernews.com/issues/58-mattris-mirrorballbot-and-the-esp32-science-tricorder?utm_source=devto&utm_campaign=podcast

TinkerNews #58: MatTris, MirrorBallBot, and the ESP32 Science Tricorder

TinkerNews — Mon, 19 Oct 2026 19:46:47 +0000

Originally published in TinkerNews Issue #58 — free weekly DIY electronics.

MatTris, MirrorBallBot, and the ESP32 Science Tricorder

Issue 58 brings hands-on builds spanning a pocket Arduino arcade, a Raspberry Pi robot balancing on a ball, and an open-source ESP32 science tricorder—plus practical projects for…

🌐 Lead build: Build an ESP32 SHT41 Temperature and Humidity Monitor

An ESP32 and SHT41 form a compact environmental monitor with simple four wire I2C connections. The Arduino IDE can send readings to the Serial Monitor or an OLED. With factory calibration, useful accuracy, low power needs, and SHT4x compatibility, this build provides a practical base for larger IoT projects.

Read the build → (via randomnerdtutorials.com)

🖨️ 3D Printing

M3-CRETE: A Meter Scale Paste Printing Reference

M3-CRETE gives qualified teams a documented starting point for meter scale cementitious paste printing. It covers mechanical design, low voltage interfaces, configuration, and BOM information, while leaving high risk electrical work, material validation, safety engineering, and construction compliance to each builder and their own controlled facility.

Read the build → (via github.com)

⚡ Arduino

Self Contained PIR Trigger for Halloween Props

A small 9V module gives Halloween animatronics a portable motion trigger. An HC-SR501 senses movement, while a PC817 optocoupler separates that sensor circuit from the prop control wiring. A custom two part enclosure protects the electronics, holds the battery hardware, and keeps the assembly easy to place.

Read the build → (via blog.adafruit.com)

Pocket Tetris Arcade with Arduino and LED Matrix

A familiar block game becomes a real tabletop object in MatTris Arcade. An Arduino-compatible controller runs the game, an LED matrix shows the playfield, and physical buttons handle play. The 21-step build follows the enclosure, wiring, assembly, programming, and testing needed to make the console feel complete.

Read the build → (via instructables.com)

🔧 DIY Electronics

Build a Knock Activated Monster Box

A tiny knock becomes a surprisingly expressive Halloween reaction. This child friendly box uses an electret microphone, a one transistor amplifier, an Arduino, and a servo to sense sound and move a monster. Its schematic and construction notes also teach biasing, AC coupling, threshold detection, and servo control through one playful build.

Read the build → (via build-electronic-circuits.com)

OnePage: Build an ESP32 C61 E Reader

OnePage turns an ESP32 C61 board into the center of a complete DIY e reader project. Its repository connects electronics, firmware, enclosure files, a board SDK, and browser tools, giving makers a practical way to inspect, source, fabricate, assemble, and adapt a wireless handheld reading device.

Read the build → (via github.com)

Building a PYNQ-Z2 Mixed-Signal Oscilloscope

A custom PCB turns the PYNQ-Z2 into an open measurement platform with a dual channel, 16 bit oscilloscope, logic analyzer connection, and arbitrary waveform generator. FPGA logic handles acquisition and processing, while ngscopeclient provides a desktop view. The repository also documents planned AI integration, though implementation details remain limited.

Read the build → (via pcbway.com)

RP1 Opens the Full Humanoid Robot Stack

RP1 treats a humanoid robot as a reproducible system, not a sealed demonstration. Its repository connects structure, joints, electronics, firmware, control, and learning tools, while publishing CAD, schematics, PCB layouts, Gerbers, BOM data, and assembly notes for builders with serious fabrication and robotics experience.

Read the build → (via github.com)

OnePage: Build an ESP32 C61 E Reader

Read the build → (via github.com)

📶 ESP32

Give an Arduino Wired Ethernet with ENC28J60

Getting a low-cost ENC28J60 board working with an Arduino Nano takes more than connecting an Ethernet cable. SPI wiring, chip-select settings, library choice, and voltage checks all matter. Once configured, the small controller can join a LAN for web pages or data exchange, though ESP32 users need different pins and software.

Read the build → (via tweaking4all.com)

Build 16 Expandable GPIO Channels for ESP32

Running short on ESP32 pins is common when a project adds relays, buttons, sensors, and indicators. This compact MCP23017 board moves those signals onto I²C, provides 16 terminal connections, and supports eight addressable modules. Reverse polarity protection, 5 V regulation, and clear address LEDs keep the hardware practical.

Read the build → (via elektormagazine.com)

Connect a Zehnder ComfoAir Q to Home Assistant

An ESP32 and CAN transceiver give a Zehnder ComfoAir Q a practical link to Home Assistant. This ESPHome project carries ventilation data and airflow commands from the unit’s CAN bus to the ESPHome API, with board choices, wiring guides, power notes, and OTA updates included.

Read the build → (via github.com)

Building an Open Source ESP32 Science Tricorder

This handheld cyberdeck packs an ESP32, custom sensor boards, a microspectrometer, a magnetometer, and a Python interface into a 3D printed enclosure. Its open repository includes firmware, PCB layouts, print files, assembly guidance, and design history, giving makers a practical reference for building portable scientific instruments.

Read the build → (via github.com)

🌐 IoT

This ESP32 Bin Tracks Fill Levels and Collection Routes

Fixed collection schedules send crews to bins that may be empty while busy locations overflow. This project uses an HC-SR04, ESP32, Wi-Fi, MQTT, and a dashboard to measure fill levels, report alerts, and suggest collection routes. It offers a clear, practical IoT example for campuses, canteens, and municipal services.

Read the build → (via projectech.in)

ESPHome Bridge Reads JK-BMS Data

Battery packs often contain useful data that stays trapped inside the BMS. This ESPHome component places an ESP32 between a JK-BMS and Home Assistant, using UART-TTL or BLE to decode pack and cell readings. It adds dashboards, alerts, and automations without replacing the battery system’s safety functions.

Read the build → (via github.com)

Build a Wi-Fi to Ethernet ESP32 Router

An ESP32 with a W5500 Ethernet interface can share an existing Wi-Fi connection with wired devices. This project provides a separate LAN, DHCP, NAT, routed mode, and optional WireGuard protection. It suits home labs, isolated IoT testing, and devices that cannot join enterprise Wi-Fi directly.

Read the build → (via github.com)

Turning a CYD into a Wireless Security Toolkit

A $7 ESP32 Cheap Yellow Display can become a handheld wireless security tester with HaleHound CYD firmware. Its touchscreen groups more than 40 modules in one interface, while browser flashing keeps setup simple. Some functions need extra radios, so check the hardware notes before building and testing in an authorized lab.

Read the build → (via github.com)

Building an ESP32 Audio Bridge for Beolab Speakers

Vintage Beolab speakers need a quieter signal than a PCM5102A normally provides. This ESP32-S3 bridge handles TV and network audio with careful attenuation, 32-bit processing, source trims, startup muting, and practical fault finding. Its lessons cover Ethernet timing, PCB footprints, power cleanup, and diagnosing audio task underruns.

Read the build → (via hackaday.io)

ESP32 Field Camera Meets Reality

A low-cost camera node can capture images on a workbench, yet field use exposes weak links. This build connects an ESP32-S3, OV5640, Android phone, Flutter app, and cloud AI, then examines communication, image quality, app boundaries, and code maintenance.

Read the build → (via note.com)

🍓 Raspberry Pi

13 Games on a $5 Raspberry Pi Pico 2

A breadboard, a small color display, physical switches, and a speaker turn a roughly $5 Raspberry Pi Pico 2 into a playable 13 game arcade. Pico2Arcade uses the RP2350 to handle graphics, controls, sound, and game timing at a claimed 60 frames per second. Its open source code and build notes are on GitHub.

Read the build → (via icode.com)

A Raspberry Pi Robot That Balances on a Ball

MirrorBallBot replaces wheels with one spherical contact point, using motorized rollers to keep its body upright and moving. A custom Raspberry Pi HAT connects the electronics, while camera feedback and Python software guide corrections. Demonstrations include finger following, disturbance recovery, and travel along predefined paths.

Read the build → (via instructables.com)

Run a Local AI Assistant on Raspberry Pi

ZeroClaw provides a Rust-based, self-hosted agent runtime for Raspberry Pi projects. It can connect natural-language requests with software tools and interfaces such as GPIO, I2C, SPI, and USB. This is a software foundation, not a finished robot, so wiring, model setup, permissions, and safety rules remain your responsibility.

Read the build → (via github.com)

🤖 Robotics

Build a PID Line Following Robot

At the front of this small robot, several IR sensors read the floor while two motors make constant steering corrections. The project links sensing, position estimates, feedback code, motor control, calibration, and mechanical design in one machine that immediately shows whether each part is working.

Read the build → (via gra.ge)

Arduino PT100 and PT1000 PID Controller PCB

Stable temperature control starts with good feedback. TSRCT-PCB-01 pairs an Arduino Nano Every with PT100 and PT1000 inputs, PID firmware, and two 5 V SSR outputs. The KiCad board provides a practical base for experimental heaters, while details such as calibration, display hardware, and temperature range need confirmation.

Read the build → (via pcbway.com)

🔩 Recommended reads

ESP32 Snake Game with MPU6050 and OLED

Embedded Nerd's motion-controlled build: MPU6050, OLED and a complete Arduino sketch. The tutorial we picked for this swap, wired end to end.

Read the build → (via embeddednerd.com)

Tindie Blog

What makers actually sell: new gear, seller stories and open hardware news.

Read the build → (via blog.tindie.com)

Circuit Cellar

Embedded design articles from the magazine that has covered microcontrollers since 1988.

Read the build → (via circuitcellar.com)

🔩 From the bench

Voltage drop and wire gauge

One of 15 free no-signup bench tools for the projects in this issue.

Read the build → (via )

TinkerNews is a free weekly newsletter with the best DIY electronics builds:
ESP32, Arduino, Raspberry Pi, IoT, robotics and 3D printing.
Subscribe free → https://www.tinkernews.com

How to pick the right wire gauge for a low voltage project

TinkerNews — Thu, 15 Oct 2026 10:39:44 +0000

Thin wire is the quiet killer of DIY projects. The build works on the bench, then the LED strip dims at the far end, the motor stalls under load, or a connector gets warm for no obvious reason. Nothing is broken. The wire is just too thin for the current it carries over that distance.

Here is the whole decision, in the order it actually matters.

The two rules that matter

Voltage drop, not wire temperature. People pick wire gauge by the ampacity chart, which is a fire-safety number for mains wiring in a wall. On a 5 V or 12 V project, the failure you actually hit is drop: the resistance of the run eats the volts before they arrive. A 5 V LED strip on a 5 m run of thin wire can arrive with 3.9 V and visibly dim.

The 3% rule. Keep the total drop, out and back, under 3% of the supply. For 5 V that is 0.15 V. For 12 V it is 0.36 V. Below that, and most electronics behaves like it does on the bench.

The math, once

Copper has a resistance per metre that depends only on its cross section:

drop = 2 × length × current × resistance_per_metre

The 2 is there because current travels out along one conductor and back along the other. Both halves drop volts, and both count.

A worked example: 5 A over 5 m of 18 AWG.

18 AWG is 0.021 ohms per metre
drop = 2 × 5 m × 5 A × 0.021 = 1.05 V

On a 12 V rail that is 8.8% and clearly too much. Moving to 14 AWG (0.0083 ohms per metre) gives 0.42 V, about 3.5%, close enough that the next size up removes all doubt.

Gauge, current and distance, together

The useful way to hold this in your head is that every three gauge steps roughly halves the resistance. So a run that is twice as long needs about three sizes thicker for the same drop. That is also why long runs surprise people: doubling the distance is not a 2x problem in practice, it is a step change in what wire you need.

Practical bands for low voltage projects:

Small signals and sensor runs: 22 to 26 AWG is fine, drop is irrelevant at milliamps.
Short runs of a few amps (LED strips, small servos): 18 to 20 AWG.
A metre or two at 5 to 10 A: 16 AWG at minimum.
Anything longer, or anything that a motor starts and stalls on: 14 AWG and up, and think about where the power enters the strip.

The traps that bite

Daisy chaining power into an LED strip. The wire between segments carries the current of every segment after it. Feed the strip from both ends, or inject power every few metres, and the last pixel stops being a dimmer cousin of the first.

Connectors, not wire. A cheap barrel jack or a Dupont run can add more resistance than two metres of decent cable. If a joint is warm, that is where the loss is. The paper amp rating is a starting point, not a guarantee.

Battery projects. The wire from cell to regulator is often the thinnest part of the build and the one carrying the highest current. Shorten it before you thicken it, and keep the ground return in mind: the drop is in both legs.

Grounding on mixed-voltage builds. A shared ground that has visible drop between two boards turns into signals that read wrong, not just power that sags.

Do the sum for the exact build

Rules of thumb get you close. For a specific rail and length, put the real numbers in and read the answer: the voltage drop and wire gauge calculator takes the volts, the one-way length, the current and the gauge, and returns the drop in volts and percent, the 3% check, and the smallest gauge that passes. Every result is a link, with the inputs in the query string, so you can send the exact scenario to whoever is wiring it.

Free, no signup, no ads. It is one of the bench tools we keep for the builds we write about weekly at TinkerNews.

The wire gauge trap: why 18 AWG carries 16 A and your LED strip still browns out

TinkerNews — Tue, 13 Oct 2026 22:27:40 +0000

Your LED strip works at the bench. Then you mount it behind a shelf, run it off a 5 m reel, and the far end comes out pink.

You check the power supply: 12 V, 5 A, plenty. You check the wire: 18 AWG. The ampacity table says 18 AWG is good for 16 amps. Five amps is nothing. So why is the far end wrong?

Because ampacity and voltage drop are two different limits, and the table only tells you one of them.

The heat limit vs the delivery limit

Ampacity answers: will this wire melt or catch fire? It is about heat. 18 AWG in free air is rated around 16 A. That number assumes a short run, normal insulation, and an acceptable temperature rise.

Voltage drop answers: will the devices at the far end still get the voltage they need? It is about resistance. Every metre of copper has resistance, and the current you push through it turns into a voltage you lose along the way.

A wire can pass the ampacity check and fail the voltage drop check at the same time. That is the trap.

The numbers for a real strip

Take a common setup: 5 metres of LED strip drawing 5 A at 12 V, wired with 18 AWG.

The current does not travel 5 metres. It travels to the far end and back: 10 metres of round trip.

At 18 AWG, that run costs you roughly 9.6% of your voltage (our voltage drop calculator puts it there at 5 A). You paid for 12 volts and delivered about 10.8 to the last LEDs. A tenth of a volt at a time is fine; nearly a volt and a half is not.

And the current does not spread evenly along the strip. The first section carries the whole load; the last section carries the least. The far end sits at the lowest voltage in the system, which is why it changes colour first.

Why colour, specifically

An LED is a diode: it starts conducting at a threshold voltage (its forward voltage). Drop the supply and the current through it falls — fast. A small voltage change becomes a large brightness change, and on RGB strips the channels do not shift equally, so the mix drifts. Pink at the end is a red channel that kept working and a blue or green channel that faded.

The strip is not broken. The wiring is under-delivering, and the symptom just happens to be visible as colour.

What actually fixes it

Go up in gauge. Every three steps (18 → 15 → 12) roughly doubles the copper and halves the resistance. Going 18 → 15 alone cuts the drop to about half.
Inject power at both ends — or every metre or two on longer runs. Parallel feeding halves the effective round trip and evens out the current along the strip.
Run higher voltage where the LEDs allow it. The same watts at 24 V is half the current, so the same wire drops half the volts.
Keep the target in mind: under 3%. That is the number where the far end still looks and behaves like the near end. Our wire gauge chart carries both the ampacity columns and the drop maths on one page, because you need both to pick a wire honestly.

How to measure instead of guessing

You do not need to trust a table. Put a multimeter on the far end under full load — a strip with nothing connected pulls almost no current, so its voltage reads healthy and lies to you. With the strip lit at the brightness you actually run, measure:

the supply voltage at the strip's input,
the voltage at the far end,
the difference as a percentage of the supply.

Above 3%: thicker wire or more injection points. Under 3%: you are done, and the colours at both ends should match.

The rule to take away

Ampacity tells you the wire survives. Voltage drop tells you the project works. Size for the drop, then sanity-check the amps. The wire that passes the heat test can still be the reason your build looks broken, and that is a wiring decision — not a mystery.

The free tools used here (wire gauge chart, voltage drop calculator, battery life and LED current calculators) all work without signup, because looking up the numbers should be faster than the mistake.

TinkerNews #57: Duck Robots, OpenScopes, and ESP32 Haldex Controllers

TinkerNews — Mon, 12 Oct 2026 19:14:09 +0000

Originally published in TinkerNews Issue #57 — free weekly DIY electronics.

Duck Robots, OpenScopes, and ESP32 Haldex Controllers

Issue 57 explores a printable fifteen-servo duck robot, reverse-engineered FNIRSI OpenScope firmware, and an ESP32-S3 controller for VAG Haldex systems—plus practical Raspberry…

🍓 Lead build: Python GPIO Projects for Raspberry Pi LEDs and Buttons

A small Raspberry Pi lab starts with a blinking LED, then adds button input, event responses, and brightness control. The guide compares gpiozero, lgpio, and RPi.GPIO, explains Pi 5 compatibility, and includes wiring advice, installation steps, runnable Python examples, interrupts, and PWM for practical physical computing.

Read the build → (via raspberry.tips)

🔧 DIY Electronics

Build a Low Cost Solar Car That Moves

Sunlight can move a lightweight homemade car when a small photovoltaic panel feeds a DC motor directly. This quick build uses inexpensive parts, then becomes a useful test platform for light levels, panel angles, wheel sizes, friction, and gearing. Record speed, compare results, and present the evidence with simple graphs.

Read the build → (via spheralsolar.com)

OpenScope Replaces Buggy FNIRSI 2C53T Firmware

Live waveforms now appear from a FNIRSI 2C53T running software built from scratch through reverse engineering. OpenScope brings up the AT32 microcontroller, configures the Gowin FPGA, captures real probe signals, and renders them without the factory firmware. Flashing still carries serious risks, including lost calibration and unusable hardware.

Read the build → (via github.com)

Build a ROS 2 Rover with ESP32 or Pico

Linorobot2 puts the electronics and firmware for a ROS 2 mobile robot on familiar ESP32s and Raspberry Pi Picos. It links motor control and odometry to ROS 2, with USB or Wi-Fi communication, OTA updates, and network diagnostics. The repository still expects its wiki for wiring and bring-up details.

Read the build → (via github.com)

Build an ESP32-S3 Haldex Controller for VAG Cars

Factory Haldex systems can be difficult to inspect or tune. OpenHaldex-S3 uses an ESP32-S3, an inline harness, and public firmware to add browser-based setup, diagnostics, logging, and tuning for supported VAG vehicles. This MIT-licensed project is separate from the newer proprietary OpenHaldex SS application and its installer.

Read the build → (via github.com)

Build a Printable Duck Robot for Motion Experiments

Print a duck-shaped biped, fit its fifteen serial servos, and connect the controller board to make XGO-Duck move. The open hardware project guides builders from parts and electronics preparation through assembly, browser-based calibration, and reinforcement-learning experiments with balance, walking, and custom robot behaviors.

Read the build → (via github.com)

Arduino Metal Detector with Target Classification and Depth

A hand wound coil, paired oscillators, and an Arduino turn small frequency shifts into a useful metal detection display. The project separates likely ferrous and non ferrous targets, estimates depth zones, and keeps the sensing process visible through calibration data, an LCD, and practical tests.

Read the build → (via projectech.in)

📶 ESP32

Build Room by Room Home Assistant Touch Panels

Tessera turns affordable ESP32 color touchscreens into dedicated Home Assistant panels for each room. Choose a supported display, install its Screen Manager add-on, design a shared dashboard, and deploy it across your home. Lights, climate, media, locks, blinds, weather, and vacuum controls can all fit in one interface.

Read the build → (via github.com)

Rewire a SmallTV for Stocks, Claude, and Planes

Replace a GeekMagic SmallTV’s stock software and its tiny color screen becomes a Wi-Fi dashboard for prices, Claude usage, and nearby aircraft. One codebase supports several ESP variants, while a web interface handles settings, mode selection, and wireless updates. The result is a compact, practical firmware project.

Read the build → (via github.com)

Turn Waveshare Industrial I/O Into a Network Controller

Eight isolated inputs, eight outputs, Ethernet, and PoE give Waveshare’s ESP32-S3 I/O boards a solid hardware base. Open firmware adds MQTT, Modbus RTU, CAN bus, local JavaScript rules, web settings, and an optional Matter build, while separate applications keep memory limits manageable.

Read the build → (via github.com)

🌐 IoT

ESP32-C6 RMT Drives a Reliable WS2812 LED

On an ESP32-C6-DevKitC-1, the onboard WS2812 LED receives a carefully timed 24-bit color frame from the RMT peripheral. This hardware approach keeps sub-microsecond pulses steady while FreeRTOS and wireless handlers run, then checks the frame timing through the serial console for a practical embedded IoT test.

Read the build → (via hubble.com)

ESP32 Arduino IDE Troubleshooting Checklist

When an ESP32 refuses to appear, compile, or accept a sketch, this practical guide helps separate IDE setup, upload, power, and silicon revision problems. It covers current Arduino IDE installation across Windows, macOS, and Linux, plus board selection and errata. It is not a complete device build.

Read the build → (via randomnerdtutorials.com)

🍓 Raspberry Pi

Find and Reclaim Raspberry Pi Storage

A Raspberry Pi can fail quietly when its SD card or SSD fills up. This guide gives you a safe sequence using df -h, sudo ncdu -x /, and sudo apt clean, then covers logs, packages, project files, inodes, and hidden open files so you can clean the right data.

Read the build → (via raspberry.tips)

Run Embedded Boards in Your Browser

Velxio brings embedded coding and circuit testing into a browser window. Pick a board, write Arduino C++, MicroPython, ESP-IDF, or Python, connect virtual parts, and run the program through CPU emulation. It is useful for lessons, early firmware checks, and experiments when physical hardware is unavailable.

Read the build → (via github.com)

🤖 Robotics

Build an Open Source Robot Vacuum for $200

A work in progress called OOMWOO breaks a robot vacuum into affordable, replaceable parts: drive modules, a caster, suction hardware, sensors, and Raspberry Pi control. Its roughly $200 parts goal is promising, but matching commercial navigation and cleaning still depends on mechanical fit, electronics, software, and testing.

Read the build → (via github.com)

🔩 Recommended reads

ESP32 Snake Game with MPU6050 and OLED

Embedded Nerd's motion-controlled build: MPU6050, OLED and a complete Arduino sketch. The tutorial we picked for this swap, wired end to end.

Read the build → (via embeddednerd.com)

Tindie Blog

What makers actually sell: new gear, seller stories and open hardware news.

Read the build → (via blog.tindie.com)

Circuit Cellar

Embedded design articles from the magazine that has covered microcontrollers since 1988.

Read the build → (via circuitcellar.com)

🔩 From the bench

WS2812B power calculator

One of 15 free no-signup bench tools for the projects in this issue.

Read the build → (via )

TinkerNews is a free weekly newsletter with the best DIY electronics builds —
ESP32, Arduino, Raspberry Pi, IoT, robotics and 3D printing.
Subscribe free → https://www.tinkernews.com

The Pinout Traps of Cheap Dev Boards

TinkerNews — Mon, 12 Oct 2026 10:47:21 +0000

A dev board that refuses to boot, an analog reading that works on the bench and vanishes the moment WiFi joins, a sensor that reads fine until you add a pullup. Most of these are not broken boards. They are pin choices. The silkscreen prints GPIO numbers and nothing about what those pins are doing behind your back.

The four pins that decide how the ESP32 boots

On the ESP32 DevKit V1 (the 38 pin WROOM board everyone buys first), four pins are sampled while the chip resets:

GPIO 0 low at reset means download mode. That is what the BOOT button does. A peripheral that holds it low turns your board into one that "bricked after I added the sensor".
GPIO 2 must be low or floating at reset for a normal serial flash. Driving it high during boot is a common boot loop.
GPIO 12 is the flash voltage strap. High at reset tells the chip its flash runs at 1.8 V. Most modules expect 3.3 V, so a pullup or a peripheral holding GPIO 12 high can put the board into a brownout loop that looks exactly like dead hardware.
GPIO 15 affects boot timing and the boot log. It is the mildest of the four, but it is still not a free pin.

The rule that saves weekends: treat 0, 2, 12 and 15 as outputs you drive late in setup, or avoid them entirely. If a project must use one, make sure nothing pulls it the wrong way during reset.

ADC2 belongs to the WiFi radio

GPIO 0, 2, 4, 12 through 15 and 25 through 27 are ADC2 pins. While WiFi is active, ADC2 is handed to the radio. Your readings return zero, noise, or nothing at all. This is the single most common "my sensor works until I add WiFi" bug on the classic ESP32.

The fix is boring: put analog sensors on ADC1 pins (GPIO 32 through 39), or sample before the radio starts. On the ESP32-C3 there is one ADC block, so the conflict does not exist there.

Input only really means input only

GPIO 34 through 39 are input only. No output, and no internal pullups or pulldowns either. If you wire a button to GPIO 34 and expect the internal pullup to hold it high, you get floating garbage. Add the resistor.

Also worth remembering: GPIO 6 through 11 connect the module's flash. They are exposed on some boards as holes or test points. Leave them alone.

The C3 SuperMini's smaller trap set

The 2 dollar ESP32-C3 SuperMini shrinks the problem but does not remove it. Its strapping pins are GPIO 2, GPIO 8 and GPIO 9:

GPIO 9 is the BOOT button. Hold it low at reset and you are in download mode. Sensors or LEDs on GPIO 9 are a boot hazard.
GPIO 8 and GPIO 2 are sampled too. GPIO 8 in particular wants a defined level at reset on many modules.

And the two pins you never think about: GPIO 18 and 19 are the USB D minus and D plus lines. Use them for something else and your USB connection disappears right when you want to reflash.

A pin budget before the first wire

Before soldering anything, write down four things: which pins the boot process reads (strap pins), which pins the radio owns when connected (ADC2 on the classic chip), which pins are input only, and which pins the flash needs. Everything left is genuinely yours.

That is the whole trick. Cheap boards are not random, they just do not tell you the rules on the silkscreen.

Full per-pin references with ADC, touch and PWM flags, strapping warnings and per-pin anchors: ESP32 DevKit V1 pinout and ESP32-C3 SuperMini pinout. More free calculators and references at tinkernews.com/tools.

We catalogued 3,046 dev boards. Here is what the data says about pin documentation

TinkerNews — Tue, 06 Oct 2026 16:10:14 +0000

While curating weekly DIY electronics builds, the same failure keeps coming back: a project says "wire it up like this", and the board's actual pinout is either unfindable or exists only as a photo shot through a fishbowl. So we did the boring thing and collected board definitions instead of complaining.

What the dataset is

3,046 board definitions, imported from open upstream projects (Zephyr, Arduino, CircuitPython, Armbian and friends) and normalised to one shape: name, maker, chip, software support records, and pin data where the upstream project provides it. It is open at github.com/tinkernews/boards and browsable at tinkernews.com/boards.

The numbers (as of today)

3,046 boards, 565 makers
2,644 microcontroller boards, 402 single board computers
Biggest silicon families: ESP32 (504 boards), RP2040 (145), SAMD21G18 (112), nRF52840 (99)
Most represented vendors: STMicroelectronics (220), Adafruit (187), NXP (115)
The number four "vendor" is generic: 106 boards with no brand to name at all
Software support is tracked well: 97% of boards carry at least one support record (Zephyr 1,146, Arduino 863, CircuitPython 674)
Pin data is not: only 591 boards (19%) expose machine-readable pins. The other 2,455 do not. Where pin data exists it averages 26 pins per board

What that says

The ecosystem documents software extensively and hardware pins barely at all. The pin table is the first thing a beginner needs and the last thing anyone maintains. It is also where a large share of bench failures start: a GPIO that looks free, a strapping pin that is not, a 3.3V rail that browns out.

So the dataset stays open (per-board JSON, a schema, corrections welcome via the repo), and we build the missing layer on top: printable pinout charts for the boards people actually hold (ESP32 DevKit, ESP32-C3 SuperMini), plus the bench calculators that catch the classic traps (voltage drop, WS2812B power, battery life) at tinkernews.com/tools.

If you have an upstream board definition we are missing, the repo is the place. If you just want one solid build in your inbox every week, TinkerNews is free.

TinkerNews Podcast #56: ESP32 Fall Detectors, Aircraft Radar, and Gesture Gloves

TinkerNews — Tue, 06 Oct 2026 09:08:23 +0000

The TinkerNews podcast has a new episode: TinkerNews Podcast #56: ESP32 Fall Detectors, Aircraft Radar, and Gesture Gloves.

🎧 Listen to the episode: https://www.tinkernews.com/issues/56-esp32-fall-detectors-aircraft-radar-and-gesture-gloves?utm_source=devto&utm_campaign=podcast

TinkerNews #56: ESP32 Fall Detectors, Aircraft Radar, and Gesture Gloves

TinkerNews — Mon, 05 Oct 2026 21:35:17 +0000

Originally published in TinkerNews Issue #56 — free weekly DIY electronics.

ESP32 Fall Detectors, Aircraft Radar, and Gesture Gloves

Issue 56 brings hands-on ESP32 builds into the real world: a wearable fall detector that sends WhatsApp alerts, a standalone aircraft radar console, and a gesture-controlled…

⚡ Lead build: Wearable ESP32 Fall Detector Sends WhatsApp Alerts

A wearable XIAO ESP32-S3 pairs with an MPU6050 to spot likely falls, confirm ten seconds of immobility, and send a WhatsApp message through CircuitDigest Cloud. This hands-free build includes wiring, firmware, parts, and a 3D-printed case, while noting limits such as connectivity, calibration, and false alarms.

Read the build → (via circuitdigest.com)

🖨️ 3D Printing

Set Up Automatic Multi-Color Printing on a QIDI Q2

Four loaded spools, one heated box, and QIDI Studio handle the color changes for a QIDI Q2. This walkthrough covers wiring, drying, spool checks, slicing, waste, material limits, and recovery when an automatic filament change fails during a long print.

Read the build → (via qidi3d.com)

⚡ Arduino

Wall-Mounted ESP32 Touchscreen with Wireless Relay Control

A VIEWE ESP32-S3 touchscreen forms the wall-mounted interface, while a second ESP32 runs four relays and reads a DHT22. ESP-NOW links both boards without a dedicated cable. ESPHome brings local temperature and humidity, OpenWeather forecasts, Open-Meteo UV data, and NTP time into one practical control panel.

Read the build → (via maker.pro)

Build an ESP32 Aircraft Radar Console

A small ESP32, 1.8-inch TFT, and Wi-Fi connection form FlyRadar32, a desktop aircraft display fed by OpenSky data. The build covers verified wiring, breadboard testing, browser-based firmware installation, resilient telemetry handling, weather and diagnostics screens, and a FreeCAD-designed printed case for the finished console.

Read the build → (via skrelectronicslab.com)

Arduino Five-Antenna Selector Uses CAT and BCD

Manual antenna changes become tedious when an operator moves across HF bands. This Arduino controller accepts either CAT serial data or BCD signals, selects one of five antenna paths, shows the result on a seven-segment display, and sounds a buzzer when the band changes. Check the full design before transmitting.

Read the build → (via pcbway.com)

Use a BJT to Drive a 12V MOSFET from Arduino

A 5V Arduino pin is not a power switch. This circuit uses a BJT as an intermediate level-shifting stage, then lets a MOSFET handle current from a separate 12V supply. The arrangement suits lights, fans, relays, and other loads while keeping heavy current away from the microcontroller.

Read the build → (via homemade-circuits.com)

Build an Uno with a Built-In MPU-6050

A custom KiCad board combines the familiar Arduino Uno R3 SMD-compatible layout with an onboard MPU-6050 six-axis IMU. The design handles 5 V-to-3.3 V I²C signaling, keeps the sensor underneath the PCB, and removes the separate breakout board, loose wires, and mounting work from compact motion projects.

Read the build → (via elecrow.com)

🔧 DIY Electronics

FaderBuddy Makes Motorized Faders Modular

Motorized faders often need custom drivers and timing code. FaderBuddy puts that work on an ATtiny1616, turning a 60 mm slider into an I2C peripheral. A host can read positions, set targets, add virtual detents or haptic feedback, and connect several boards to one bus.

Read the build → (via github.com)

Build a $10 ESP32 Flock Camera Detector

An ESP32 listens to nearby Wi-Fi traffic without joining the network, then checks documented signatures linked to Flock Safety cameras. The project offers a $9–11 solderless build, optional custom PCB, configurable alerts, and GPS mapping. Results still need local testing, and wireless monitoring laws and privacy rules apply.

Read the build → (via github.com)

Project Hydra: An Open 1 W LoRa PCB for Meshtastic

Project Hydra gives makers an editable KiCad design for a minimalist 1 W LoRa board intended for Meshtastic. The public repository includes schematic, layout, and revision history, making it useful for study or adaptation. Check today’s files, hardware details, regulations, and GPL-3.0 requirements before building.

Read the build → (via protoflow.ai)

📶 ESP32

A Gesture-Controlled ESP32 Glove for 3D Building

Away from a desk, a phone can still become a 3D workspace with Aloft: a glove uses MPU-6050 sensors and two ESP32 boards to send hand motion over Bluetooth. Tilting moves through X, Y, or Z, while aiming and tapping place pieces or carve shapes in the browser or iPhone app.

Read the build → (via devpost.com)

Build an ESP32-S3 Bambu Lab Printer Monitor

A small color screen beside the printer can show temperatures, progress, and events without opening a phone or browser. BambuHelper pairs an ESP32-S3 with an ST7789 TFT, MQTT, and optional buzzer, offering LAN or cloud connections, browser setup, several board choices, and clear credential trade-offs.

Read the build → (via github.com)

How FlipDeFlock Maps Nearby Surveillance Signals

Pairing a Flipper Zero with an ESP32 lets FlipDeFlock listen for several kinds of surveillance equipment without transmitting. Probe-request fingerprints can point to likely randomized-MAC cameras, while Remote ID, BLE, and other broadcasts add context. Results remain clues, so visual checks and authorized use are essential.

Read the build → (via github.com)

🌐 IoT

WiFi Sensing Turns Routers Into Room Monitors

Radio reflections become the input for RuView, an open-source WiFi sensing project that estimates presence, movement, breathing, and heart rate without cameras or wearables. Its visualization and smart-home links make it interesting for makers, but hardware support, accuracy, privacy, and medical limits need careful checking before deployment.

Read the build → (via github.com)

🍓 Raspberry Pi

Build a Raspberry Pi MQTT Hub with Mosquitto

A Raspberry Pi can serve as the local message hub for ESP32s, Shelly devices, and home-automation tools. Install Mosquitto, secure its broker, and use MQTT Explorer to check traffic. Home Assistant, Node-RED, and new sensors can share data without custom point-to-point links.

Read the build → (via raspberry.tips)

TinkerNews is a free weekly newsletter with the best DIY electronics builds —
ESP32, Arduino, Raspberry Pi, IoT, robotics and 3D printing.
Subscribe free → https://www.tinkernews.com

The GPIO numbers that brick an ESP32 (before your code ever runs)

TinkerNews — Mon, 05 Oct 2026 09:25:55 +0000

The GPIO numbers that brick an ESP32 (before your code ever runs)

The ESP32 has somewhere around thirty usable GPIOs depending on which package you bought, and roughly a dozen of them are traps. Some of them stop the board from booting at all. The rest only break in the field, on battery power, weeks after the firmware is flashed and you have gone home. Here is the list that has cost me the most weekends.

GPIO 6 through 11 are the flash bus. Those six pins run between the ESP32 and the SPI flash die sitting next to it on the module, and the ROM bootloader reads your firmware over them. Wire an SD card or a display to pins 9 and 10 and you get anything from a boot loop to a corrupted NVS partition. The cruel part is that the pins are still broken out on the WROOM headers, so they look free and people pick them. If you genuinely need more than twenty-odd pins, move to an ESP32-S3 or hang an I2C IO expander off two pins you trust.

Strapping pins are read at reset, before your code runs. GPIO 0, 2, 5, 12, and 15 are sampled by the ROM while EN rises. Your sketch can drive them freely afterwards, which is exactly why the bug hides: everything works on the bench where you power up with a button, and the unit fails the first time a supervisor chip or a battery switch does a cold start.

GPIO 0 low at reset drops the chip into the serial bootloader instead of your firmware. That is how flashing works, and it is also how a floating sensor line turns into a unit that never boots. GPIO 2 has to be low or floating for a download boot to work at all. GPIO 5 changes SDIO timing and rarely matters outside SDIO designs. GPIO 15 high silences the ROM bootloader log, which is great in production and miserable when a dead board is trying to tell you why over UART.

GPIO 12 is the trap that actually bricks things. The ROM calls it MTDI, and at reset it selects the flash I/O voltage: low means 3.3V, high means 1.8V. Your flash module runs at 3.3V. Hold GPIO 12 high during reset and the chip talks to flash at 1.8V levels, reads garbage, and reset-loops forever. Pull the offending resistor and the board wakes up again, which is the only comforting thing about this pin.

I built a battery-powered camera trigger for a friend's wildlife rig. It ran for two days on my desk, powered through the USB-UART adapter. He carried it out to the trail, connected the battery pack, and it never booted once. The villain was a 10k pull-up on GPIO 12 feeding the gate of a load-switch MOSFET, and that pull-up went to a rail which only existed on battery power. With the USB adapter attached, the rail sat at 0V and GPIO 12 read low at every reset. On battery it read high. Four hours of scope traces for a resistor that needed to live on GPIO 13. After that one, the full strapping table moved to a sheet of paper above the bench, and our ESP32 pinout chart is the same sheet if you want it.

Pins 34 to 39 are input only and have no pull-ups. Reads work. Writes silently do nothing. Put a button on GPIO 34 with INPUT_PULLUP and the pin floats, so you read phantom presses or a button that reports permanently closed when the air is humid enough. Use a real 10k to 3.3V and plain INPUT mode. Those pins are also the ADC1 channels, which is convenient until you remember the ESP32 ADC needs calibration before its numbers mean anything.

ADC2 disappears the moment WiFi starts. On the original ESP32, ADC2 covers GPIO 0, 2, 4, 12 through 15, and 25 through 27, and the WiFi subsystem shares the block. I put a soil moisture sensor on GPIO 25 in a greenhouse controller. Readings were perfect in setup(), the MQTT connection came up, and every read after that returned frozen or noisy garbage. If you need an analog channel and WiFi at the same time, stay on ADC1 (GPIO 32 through 39) or bolt on an external ADC. While you are deciding which signal lands on which pin, the calculators on our tools page will tell you what a divider draws all day and what your pull-ups should be, and that conversation happens before the PCB order instead of after it.

Almost every ESP32 field failure I have debugged came down to a pin doing something special at reset or at power-up. This is the second piece in a series about ESP32 mistakes we have paid for ourselves, and TinkerNews sends it out weekly (free, small but growing). Mark the strapping pins in red on the schematic, keep GPIO 6 through 11 empty, and give the input-only pins real resistors before the board goes to fab.

Three maker newsletters we actually read

TinkerNews — Sat, 03 Oct 2026 17:00:29 +0000

Short and sincere: three newsletters/shows we actually read, recommended with nothing attached. We told each of them we'd do this — here it is, with tracked links so they can see exactly what it sends.

Python on Microcontrollers (Adafruit)

The daily CircuitPython & microcontroller newsletter. If you build on the boards we cover, this is the canonical source for the Python side of that world — the community around it is half the value.

👉 Python on Microcontrollers

The Bootloader

Nadia and Greg's maker podcast — the listen that pairs perfectly with a weekly builds roundup. Smart, funny, genuinely about making things.

👉 The Bootloader

Hardware FYI

Hardware news written for people who actually build with hardware. The rare newsletter where the coverage assumes you own a soldering iron.

👉 Hardware FYI

We run TinkerNews, a free weekly roundup of DIY electronics builds — recommending these is the easiest yes in the world. They'll also appear in issue #56's recommendations slot with the same tracked links.

Twelve free electronics tools we built because the datasheets lie

TinkerNews — Sat, 03 Oct 2026 14:28:54 +0000

We keep hitting the same wall in maker projects: the reference material is either a 900-page datasheet, a decade-old calculator on a domain that now sells something else, or a forum thread with three contradicting answers. So we started building the tools we needed. Free, no signup, no tracking. The set started at six; it is twelve now, and here is what building them taught us.

The tools

ESP32 DevKit V1 pinout (38-pin): interactive per-pin reference with the warnings the datasheet buries. GPIO 6-11 are wired to flash (using them crashes the board), strapping pins (0, 2, 5, 12, 15) get read at reset, and GPIO 12 pulled high can stop 3.3V flash boards booting entirely. Per-pin anchors so a forum answer can deep-link exactly the pin in question. Prints clean for the bench.

ESP32-C3 SuperMini pinout: the $2 RISC-V board's own traps. GPIO 2/8/9 strapping, the flash bus at 11+, and why "my board won't flash" is almost always BOOT pulled by your circuit.

USB-C pinout (24-pin): the 5.1k resistor rule that makes chargers output 5V, all 24 pins, the four VBUS and four GND pins, and what USB 2.0-only breakouts leave out.

Resistor color code calculator: 4/5/6-band decoder with tolerance range and nearest E-series value. The result is saved in the URL, so pasting it into a forum answer reproduces the exact numbers.

Capacitor code calculator: the three-digit ceramic codes (104 is 100nF), RKM notation like 4n7, and the tolerance letters. It also explains the MMFD trap in the old tables.

SMD resistor code calculator: the tiny codes on 0603 parts, E24 and E96, RKM notation, and the zero-ohm jumper.

LED resistor calculator: supply, forward voltage and current in, the resistor out, with the nearest standard value and the wattage check that stops the smoke.

Voltage divider calculator: pick R1 and R2 for an output, see the current drawn and how much a load pulls the output down.

IoT battery life calculator: the "how long will my ESP32 run on this LiPo?" tool, duty-cycle aware with deep-sleep presets. This is the one we could not find anywhere. Generic battery calculators do not model wake and sleep cycles.

WS2812B / NeoPixel power calculator: PSU size with headroom, fuse rating, injection points. Realistic 20mA average vs the 60mA worst-case toggle every LED-strip thread ends up re-deriving.

Voltage drop & wire gauge: 12V wiring with the 3% rule, round-trip modeled. 5A over 5m of 18 AWG is 9.6% drop, and the calculator says undersized before the LEDs do.

Wire gauge (AWG) chart: the AWG table with mm2, resistance per metre and both ampacity columns, plus the rules worth memorising: three gauges doubles the cross-section, six doubles the diameter, ten multiplies resistance by ten. The worked example shows why 18 AWG can carry 16 A and still brown out a 5 m strip.

All twelve, free, no signup: tinkernews.com/tools

What building them taught us

Unit bugs hide in plain sight. Our battery calculator was 1000x off on first build, milliseconds converted to seconds where the formula wanted hours. The fix was a one-line change; proving it took an evening of hand math. Every calculator now gets click-tested against hand math before it ships.

Shareable state is the killer feature. Forum answers need a canonical URL that reproduces numbers. Putting the inputs in the query string turns every answer that cites the tool into a permanent, verifiable reference.

"When not to use this" earns citations. The battery calculator publishes its assumptions (regulator quiescent current, cold-weather loss, retry storms) and says when to trust it instead. That is what makes writers comfortable linking a tool.

Safe-GPIO warnings are content. The pinout pages get read because they say "never use GPIO 6-11" at the top, not in a footnote. The warnings are the product; the pin grid is the reference.

We run TinkerNews, a free weekly roundup of DIY electronics builds, and these tools came out of the issues. If any of them are wrong, tell us and we'll fix that first.