A simple case of not enough alcohol… accompanying blog post here.

Blog post here.

Accompanying blog post here.

You can find an accompanying blog post here.

You can buy your own one here.

But out of the box it has two “features”:

• It’s unbelievably loud (the kind of loud you don’t want in your living room for more than 30 seconds)

• It eats the four AA batteries living in the coal car

You can listen to the noise in all its glory at the start of this video:

So this was an excuse for a bit of train surgery: make it rechargeable, and give it a proper volume control.

What we’re starting with

The power pack lives in the coal car and holds 4×AA. Before changing anything, I wanted to know what voltage the train actually expects.

With the existing batteries already a bit tired, the output measured about 5.1 V. With fresh alkalines you’d expect something closer to ~6 V.

Quick teardown

Opening the locomotive was pretty straightforward - we have the legendary visible screws.

Inside the engine is a small PCB with the usual blob IC, plus a whole bunch of wires:

• Two wires to the speaker

• Wires to the power switch

• Two wires to the motor

• Two wires to the front LED

Parts used

This is very much a “what’s in the parts drawer?” mod. The final setup was:

• 18650 Li‑ion cell (single cell, 3.7 V nominal, 2200mAh)

• A combined charger + protection + boost module (with an adjustable output voltage)

• A potentiometer used as a simple volume control in series with the speaker

• Wire, solder, and a quantity of hot glue that we’ll call “structural”

Making it rechargeable

The plan was simple:

1. Put the 18650 cell in the coal car

2. Boost it up to roughly “4×AA voltage”

3. Feed the train through the existing power connector

Fitting it was the main challenge. The coal car has an internal red plastic compartment that needed to be… re-engineered… to make room for the cell.

Once there was space, the wiring was straightforward:

• Battery → charge/protect/boost module input

• Module output adjusted to around ~5.5 V

• Module output → connected to the plug coming out of the coal cart

I set the output to around 5.5 V — nicely in the middle between “fresh AAs” and “nearly flat AAs”.

One surprisingly nice thing is they did include a PTC fuse inline with the batteries - a nice soft start/safety feature.

Before plugging anything in, I did a quick polarity sanity check because toy wiring colour conventions are often a work of fiction. In this case the connector was centre positive.

With the speaker temporarily disconnected (to preserve my hearing), I plugged it in and… the wheels on the train went round and round. Success!

Adding a volume knob

Next problem: the speaker. The easy way to make something quieter is to disconnect it, but a volume control is much nicer.

The simplest approach here is to put a potentiometer in series with one speaker lead, using it as a variable resistor. With the pot turned up you get full volume; turned down it becomes civilised.

This worked immediately on the bench: at minimum it’s almost silent (you mainly hear the motor), and at maximum it’s back to the original “wow that’s a lot”.

Please don’t judge my glue

An internal pot is only useful if you can actually reach it. I wanted the knob accessible from the outside.

So I:

• Chopped the top off an existing plastic piece to use as a knob cap

• Stuck the top I chopped off onto the top of the potentiometer

• Glued it all together

In the end a combination of a lot of hot glue along with superglue and patience made it all work.

I did spend a lot of time with my fingers stuck together…

In the end it’s slightly wonky, but it works, it’s solid, and a bit of gold paint hides the terrible workmanship.

Result (and one remaining annoyance)

The end result is exactly what I wanted:

• Rechargeable power (no more burning through AAs)

• Adjustable volume (from “barely there” to “festival headliner”)

The only thing I didn’t solve is the drivetrain noise: it uses plastic gears and the mechanical clatter is now the loudest thing at low volume.

Watch the full build

If you want to see the teardown, the battery conversion, and the volume knob bodging in real time, the full video is here:

We’ve got three units that have failed QA in different ways:

• One had no sound

• One had a dodgy keyboard

• One had no USB connection

None of these were design issues. They were all the sort of subtle manufacturing or assembly faults you only discover once real boards are powered up and tested.

Let’s take a look at each failure, what caused it, and how it can (or should) be fixed.

Manufacturing & QA

The ESP32 Rainbow PCBs are manufactured by PCBWay, who handle:

• PCB fabrication

• UV silkscreen printing

• Partial component assembly

Final assembly, inspection, and full QA are done here in Scotland.

That QA step is important - it’s where issues like these show up before a board ever reaches a customer.

Failure #1: No sound output

Symptom:
The board has been flashed and everything runs correctly, but there is no audio from the speaker.

Debugging

Applying gentle pressure to the headphone jack caused sound to briefly return - which is a strong hint that this is a mechanical or soldering issue.

Root cause

Under the microscope, the problem was obvious:

• Multiple pads on the headphone jack had lifted

• Only one electrical connection remained intact

This meant the speaker signal was effectively disconnected.

Resolution

This is a reasonably easy fix. We just need to reflow the solder joints, and there’s just about enough copper to reconnect the lifted pads to the ground plane. However, given the damage, this board can’t be sent out to a paying customer - we’ll use it for spare parts.

Failure #2: USB not enumerating

Symptom:
The board powers up correctly (3.3 V present), but the ESP32 does not appear over USB.

Debugging

The USB path is fairly simple:

ESP32 → ESD protection IC → USB socket

Using a continuity test, I checked each stage:

• ESP32 USB pins → protection chip → OK

• Protection chip → USB socket → OK (?)

Root cause

One pin on the ESD protection IC was not properly seated on its footprint.

Visually it looked almost fine - but one of the pins was not actually connected.

Fix

Reflow the solder and nudge the IC into the correct position. With that done, we have continuity from the ESP32 USB pins → USB socket.

The board now appears over USB and can be flashed. Everything else works perfectly - we can ship this board to a paying customer.

Failure #3: Dodgy keyboard (A–G not working; maybe other keys failing as well)

Symptom:
Several keys on the touch keyboard - specifically A through G - did not register correctly. Other keys behave strangely. The ESP32 Rainbow keyboard uses analogue multiplexers connected to the ESP32 module.

Root Cause

• Several pins along the bottom of one ESP32 module had poor solder joints

Fix

A straightforward rework:

• Retouch all the pins with fresh solder

After this, everything works fine - all keys work and the board is fully functional. We can ship this out to a paying customer.

Watch the full debugging process

If you want to see the full diagnosis and repair process - including microscope work, probing, and rework - the full video is here:

You can also read this post on the blog.

The Big One: ESP32 Rainbow Goes Live

If you’d asked me in early 2024 what my biggest achievement would be in 2025, “successfully completing a crowdfunding campaign” wouldn’t have been on the list. But here we are.

What is the ESP32 Rainbow?

It’s a recreation of the iconic Sinclair Spectrum, but with modern internals: an ESP32-S3 brain, full-color UV silk screen printing, capacitive touch keys, and a built-in display and speaker.

The Journey: 13 Months from Idea to Shipping

• June 2024: The idea sparked - what if we could do full-color silk screen on a PCB?

• November 2024: Campaign launched on Crowd Supply

• December 2024: Hit 146% funding - 118 backers plus a crucial 118-unit house order

• January 2025: Funds received, production started

• July 2025: All orders shipped to backers worldwide

• Novemebr 2025: Follow-up order deliverd to Mouser deliverd (100 additional units)

• December 2025: Additional follow-up order sent to production (40 additional units)

The Numbers

Let’s pull back the curtain on what a “successful” crowdfunding campaign actually looks like:

• Total Revenue: £12,839.57

• Cost of Goods Sold: £8,565.66 (for 280 sellable units)

• Gross Profit: £4,273.91

• Labor Hours: 436 hours (that’s 54 eight-hour days)

• True Profit After Labor: -£1,049.65 (or +£1,000.35 if remaining stock sells)

Not exactly retirement money, but that was never the point.

The Real Challenges

Pricing: Wanted to charge £49.99 (very Clive Sinclair), but the economics forced £99. Bottom-up pricing (£30.60 COGS + margin) met top-down pricing (what people would pay) somewhere in the middle.

Certification: £506.05 for CE/UKCA certification. Turns out selling to consumers requires actual compliance, even if you’re using a pre-certified module. Thanks to Smander’s Simple Start service for making this painless.

Tariffs: The specter of Trump’s tariff talk loomed large. Shipping everything to the US as DDP (Delivered Duty Paid) meant I paid import duties. Fortunately, I could argue UK Country of Origin, but that was pure luck.

International Shipping: A month-long odyssey of mysterious tracking pages, support tickets, and boxes that wouldn’t move. If you’re shipping from the UK, get yourself an EORI number before you start.

What did I learn?

This project taught me:

• Crowd funded hardware prices aren’t a rip-off - there are real costs behind every product

• Building an audience before launch is crucial (thanks YouTube/blog/newsletter)

• AI tooling made the impossible possible (emscripten? no way without AI help)

• Open source builds community - people love your terrible code

• Working with a distributor (Crowd Supply/Mouser) handles complexity but eats margin

Would I do it again? Maybe. With a very compelling idea and a large customer base. But for now, the ESP32 Rainbow is real, it’s shipping, and there’s a community forming around it. That’s the achievement.

• 📺 Watch the full crowdfunding retrospective video

• 📝 Read the detailed crowdfunding breakdown

Other 2025 Highlights

While the ESP32 Rainbow dominated the year, there were plenty of other projects worth mentioning:

🔌 High Voltage Adventures

What started with failed LED lightbulbs turned into a series of high-voltage experiments. Salvaged LED filaments, 800V DC-DC converters with spectacular failures, and eventually a $2 board generating 787V. The pinnacle was a 27V Joule thief running from a CR2025 coin cell, eventually becoming a drop-in replacement for broken Bistable Choldesteric writing tablet.

🎵 The 10¢ Microcontroller Series

The CH32V003 RISC-V chip costs ten cents. Ten. Cents. With 16K flash and 2K RAM, it shouldn’t be capable of much. But it turns out you can:

• Play polyphonic music on a piezo buzzer powered by a coin cell

• Perform brain surgery on Halloween toys to make them scream

• Synthesize speech using 2-bit ADPCM and LPC

All running on deep sleep drawing just 7µA between beeps. The future is ridiculously cheap.

🐛 Escaping Printf Hell

After years of Serial.println("Here 1") and blinking LEDs, I finally embraced proper debugging. The ESP32-S3’s built-in USB/JTAG support means you can set breakpoints, inspect variables, and use conditional debugging right in the Arduino IDE. The Six Stages of Debugging post captures the journey from “That can’t happen” to “How did this ever work?”

Bonus discovery: That serial baud rate number does nothing on ESP32-S3 with native USB. It’s actually running at 7MB/s, not 115200.

🛠️ Repairs, Teardowns, and Bodge Wires

• Oops I Did It Again: Mixed up common anode vs cathode LEDs, requiring creative bodge wire repairs

• Red Arcade Thing: Diagnosed and fixed a dodgy AliExpress handheld with a failed voltage regulator

• Bistable Cholesteric Display: Teardown of an LCD writing tablet, discovering it needs 27V to clear

🤖 AI-Assisted Hardware Development

Two experiments with AI generating hardware:

• Vibe-coded one-button keyboard: ESP32-S3 mechanical keyboard with AI-assisted firmware

• Atopile-generated dev board: Claude AI selected components and generated schematics

Surprisingly not terrible.

🌐 Web Serial Plotter

Forget the Arduino Serial Plotter - this browser-based version offers real-time graphing, zoom, export, and a signal generator. No installation required.

2025 By The Numbers

• 26 blog posts (plus this one)

• 32 YouTube videos

• Busiest months: August, September, October

• Top topics: ESP32/ESP32-S3 (14), High Voltage (6), CH32V003 (4), Repairs (6), PCB Design (5)

• 1 successful crowdfunding campaign ✅

Looking Forward to 2026

2025 proved that one person can still build real hardware products and ship them worldwide. The economics are brutal, the challenges are real, but the satisfaction of seeing your creation in the wild makes it worthwhile.

For 2026? More ESP32 experiments, more ridiculous high-voltage projects, and probably more bodge wires than I’d like to admit. The ESP32 Rainbow continues to be available on Crowd Supply - I’ve had to do two follow up production runs - so keep on ordering!

But the biggest lesson from 2025 wasn’t about hardware or firmware or certification. It was this: build things that bring joy, share your process (even the failures), and don’t be afraid to show your terrible code. The community that forms around that honesty is worth more than any profit margin.

Here’s to 2026. Let’s see what catches fire next.

And read the short blog post here.

You can read the full post here. Or just watch the video above ^^.

You can read the full details here: https://www.atomic14.com/2025/11/07/27v-pcb

Full details on cramming audio data in to 16KB of flash and recreating the Speak and Spell experience here.

You can view the full post with schematics here.

We’re going to take a slightly different approach to the newsletter posts - generally the write up ends up being quite long, so we’re going to move the meat of the content over to the blog.

So, you can read all the details of this project here: https://www.atomic14.com/2025/10/12/CH32V003-music

In the last post we were testing out the audio on my new board. There something in the code that piqued my interest.

We’re using a standard I2S PDM microphone - which has the normal pins you’d expect for I2S.

Here’s my schematic:

And here’s the datasheet to confirm I haven’t made a silly error:

You’re probably thinking - yes yes, all very interesting, that’s the standard pins for I2S - CLK, Data, L/R and power.

Well, what confused me was the I2S code in the latest ESP-IDF version.

There is no way to specify the LR pin! The gpio_cfg structure for PDM microphones doesn’t have an entry for it.

For PCM microphones the LR clock is pretty important - particularly if you want to have a stereo signal.

Looking back at one of my ancient YouTube videos you can see the waveforms:

And if we look at the structure used to initialise I2S for PCM the pin is definitely there.

So, what’s going on with PDM microphones? What are we supposed to do with the LR pin?

A quick question to the ESP32 forums set me straight with a very friendly - look again at the data sheet for your microphone.

And looking a bit more closely we find these example IO timing diagrams:

If the LR pin is held high - the data is valid for the high to low transition of the clock and then the data pin goes high impedance.

If the LR pin is held low - the data is valid for the low to high transition of the clock and then the data pin goes low impedance.

This means that if you want to have two microphones (for stereo recording) you just need to tie one high and one low - and they will happily coexist on the same data line.

I’d recently purchased some fancy probes, so I decided to check this out.

These are really nice - they have a pogo needle on the end so you can get into very small places on the PCB. They are also hands free. Pretty cool - you can pick up you own set here (affiliate link!).

I monkeyed around with the code a bit and changed the data pin so that it had a pull down resistor and made it so I could toggle the LR pin between high and low.

Here’s what we see when the LR pin is held low:

And here’s what we see when the LR pin is held high:

Hopefully you can see the difference. With the LR pin low, the signal starts to decay when the clock is high, and with the LR pin high, the signal starts to decay when the clock is low.

We’ve only got the internal pull down resistor pulling it down so it doesn’t go to zero that quickly. If there was another microphone driving the pin then it would fall straight to zero if needed.

So, all in all pretty interesting. One thing that is quite useful is that we don’t need to connect the LR pin to a GPIO - we can save a pin in our next design!

I’ve been testing out my new boards - so far everything is going well.

First Tests – LEDs, Sensors, and Battery Charging

So far, so good:

• The RGB LED needed a small ninja fix. I put in a common cathode LED when it should have been common anode (or was it the other way round? Either way… fixed!).

• The accelerometer and gyroscope worked nicely, letting me build a digital twin of the board.

• The battery charger worked perfectly – no wires required while moving the board around for testing.

With that out of the way, it was time for the fun part: microphone and speaker tests.

Testing the Microphone

The board has:

• An I²S PDM microphone

• An I²S PCM amplifier

• A tiny speaker

My first thought: make it into a Bluetooth audio device. Unfortunately, the ESP32-S3 only supports Bluetooth Low Energy, not Bluetooth Classic – and BLE doesn’t do audio streaming.

So instead, I pushed audio over USB serial. Turns out you can send a lot of data that way – around 7 Mbps in previous tests. For audio, I only needed ~32.2 KB/s (16 kHz, 16-bit samples).

And it worked beautifully.

I even had AI generate a little Web Serial Audio Studio for me:

• Oscilloscope

• Gain control

• Spectrogram (looks pretty, not sure it’s correct…)

• A glorious 1980s-style bar chart

• Pitch tuner

Hooking up a piano confirmed the pitch tuner was picking up notes correctly. Microphone test: ✅

Moving to USB Audio (UAC)

Sending audio over serial worked fine, but then I remembered – the ESP32-S3 has native USB.

So why not make it into a USB Audio Class (UAC) device, like a USB headset or speaker?

And yes, it turns out you can.

The API gives you callbacks for:

• Output

• Input

• Mute

• Volume

The only catch: I couldn’t get the Arduino libraries to work. I had to switch over to ESP-IDF.

Thankfully, the ESP-IDF VS Code plugin makes that a lot easier with its explorer, build, and flash tools.

Limitations: Mac vs Windows

One big drawback:

• Tick “Support macOS” → Works on Mac, but not Windows.

• Untick it → Works on Windows, but not Mac.

Pretty annoying, but let’s see how it performs anyway.

Microphone Over USB

Switching back to my audio studio, the ESP32-S3 appeared as a new USB UAC device.

Connected up, the audio streamed in just fine:

I recorded a test, pulled it into Audacity, and amplified it a bit (these microphones are sensitive, so raw audio often looks quiet).

Result: very clean! 🎤

Speaker Over USB

The speaker was a different story.

At first, it worked – but the sound was very crackly when streaming via USB UAC. After a lot of head scratching, I still couldn’t fix it.

So I went back to basics: playing a WAV file directly from SPIFFS over I²S.

That sounded perfectly clean:

So clearly the hardware is fine – it’s the USB UAC speaker code that’s the problem. Microphone = great. Speaker = not quite there yet.

Final Verdict

So where are we?

• ✅ LED fixed

• ✅ Sensors working

• ✅ Battery charging fine

• ✅ Microphone excellent (both serial + USB)

• ⚠️ Speaker fine via I²S, but problematic via USB UAC

That’s good enough for me – this board has passed quality assurance.

There’s a full video here where you can listen to the audio: YouTube Link

A while back, we tore down one of those fun bistable LCD displays—it was pretty interesting, but unfortunately, while experimenting, I blew up the PCB.

The PCB generates around 27 volts from the coin cell. There’s a mystery IC used to achieve this.

You can read all about it in this post.

Since I broke it, I decided that I should try to fix it. I missed out on all the Joule thief excitement that seemed to be around on YouTube about 8 years ago, but I thought, why not give one a go - you can get quite high voltages out of them, and we don’t need much current to reset the display.

The actual Joule thief circuit is surprisingly simple—and there’s a great Wikipedia page that gives you a lot of details on how it works.

Here’s my initial circuit:

I’m using quite a large base resistor of 10K - normally you’d use around 1K. I’ve also got a series resistor in line with the battery to limit how much current we draw.

Apart from that, it’s a pretty standard Joule thief circuit.

On the output side, we have a 27V Zener diode to cap the voltage, a small capacitor that gets charged up, and a 1M bleed resistor so the voltage goes down after power is removed.

For the coils, I used two 1mH inductors. I could have taken a choke and wound some wire around it, but I got good results just from using two inductors.

The circuit works nicely—we get 27V out of it without any problems!

This is more than enough to clear the bistable display.

One thing I was interested in is how much current we are drawing from the coin cell, so I hooked up my Nordic power monitor and gave it a test.

When we hold the button down, we draw around 10mA—which is not too bad for a coin cell - provided you don’t draw that much current for too long.

In theory (according to ChatGPT) we should be able to get 40-50,000 button presses out of one coin cell…

You can go a bit further with the Joule thief and create a regulated version — you just need another transistor.

This is a really efficient circuit—as soon as we hit 27V, we don’t need to provide power. This is perfect for our use case, where the output doesn’t really draw any current.

The power profile for this new circuit is really nice.

We have the initial spike up to 10mA and then almost immediately drop down. The average current for this version is 1.53mA—that’s pretty impressive!

You can watch the full exploration in this video here: