Reddit:Electronics

Hey everyone,
I am currently developing a custom tracker using the lighthouse trackers from a VR headset (HTC vive). The end goal is tracking small robots indoors for ~$10-15 per unit.

For that I built a custom PCB in the simplest way possible, as I am still quite a beginner in electronics.

I am using 2 BPW-34 photodiodes - they have no IR filter built in, so i'm using floppy disk film as a cheap IR bandpass which works surprisingly well.

To amplify and filter the signal i used an op-amp as somehow better options such as the TS4231 were not sourceable easily for me. It seems like most of these chips are sold out or hard to get by.

But even with just that a very basic tracking that captures the laser pulses from the lighthouse worked!
For the future I will try to use at least 3 sensors to be able to maybe position objects in space as well.

https://youtu.be/bWUpHzh0yHs

Let me tell you a story about how a simple idea turned into a 10 year obsession. The end result is a tiny (4cm x 4cm) battery-powered node that syncs its clock to other nodes over the air with sub-PPB accuracy. No cables between them. You drop them wherever you want and they self-synchronize. I use it for phase-coherent Wi-Fi measurements across multiple receivers, which lets you do things like angle-of-arrival estimation and indoor localization. But getting here was not pretty.

Board 0: The Aliexpress dev kit.

I just finished my master's thesis and I've never made a PCB. I grab two ESP32 dev kits, learn how to flash them, learn how to capture Wi-Fi phase data. The data is pure noise. I spend months staring at random numbers before I understand why. Turns out a 10 ppm crystal gives you about 24 full phase rotations between consecutive Wi-Fi frames. Indistinguishable from random. Cool.

Board 1: The Chinese flasher board.

Before spending real money on a custom PCB I want to make sure I can flash bare ESP32 modules. Got this little Chinese jig, drop the chip in, flash over UART. Works first try. Good confidence boost. Still a garbage clock though.

Board 2: First custom PCB ever.

This is the big jump. Real money, real components, real chance of screwing up. EasyEDA, auto-router, fingers crossed. I try hand soldering the first batch and destroy every single one. Switched to solder paste and a $30 hot plate. Suddenly everything works beautifully. Same garbage data, but at least I stopped burning money on dead boards. Baby steps.

Board 3: The "just share the clock" idea.

Upgraded to a 0.5 ppm TCXO and tried to share it between two chips via jumper wires. Seemed so obvious. The parasitic capacitance of even short wires killed the signal dead. Touching a finger near the wire did the same thing. On the plus side, I discovered that the ESP32-C3 has hidden nanosecond RX timestamps buried in the firmware structs. That discovery ended up being the foundation of everything later.

Board 4: The SMA cable attempt.

Proper 50 ohm coax should fix the clock distribution problem, right? Somehow worse than bare wire. Also picked a clock buffer where the oscillator output was below the CMOS input threshold, so the buffer did literally nothing. Most expensive useless board of the project.

Board 5: Two chips, one PCB, as close as physically possible.

If cables don't work, just put the oscillator millimeters from both chips. No wires, no connectors, just traces. And it worked! First time I ever saw coherent phase. But the PCB antenna couldn't transmit (2-layer board, matching was completely wrong), and I measured about 1 ppb drift between two chips sitting 5mm apart. Thermal gradients. They're not at exactly the same temperature even when they're neighbors.

Board 6: Scale to four chips.

Got ambitious. Shared the voltage regulators because I didn't know you can't parallel LDOs. Only 2 out of 4 would boot. External SMA antennas made it the size of a shoebox. Back to the drawing board.

Board 7: Remove the ground plane under the clock.

Read somewhere online that ground pour causes interference near clock lines. Removed it. Everything got worse. Missing edges on the scope. Noise everywhere. Put it back. Don't believe everything you read.

Board 8: Four layers, proper matching.

Finally understood why every app note says 4 layers. On a 2-layer board the signal-to-ground distance is too large, coupling is loose, trace dimensions make no sense. On 4 layers everything behaves like the textbook. All 4 chips synced. But all 4 PCB antennas were coupled through the shared ground plane. PCB antennas use the ground as part of the radiating structure. Shared ground = shared antenna. Touching one killed the others. 20 dB down from a reference module.

Board 9: Stop sharing clocks entirely.

The breakthrough. Give each node its own voltage-controlled oscillator. Measure drift over the air using Wi-Fi timing exchanges. Correct with a DAC on the oscillator's tuning pin. One DAC got me to 10 ppb but each step was too coarse. Added a second DAC in a 1:30 ratio, coarse to get close, fine to hold steady. Sub-PPB. No shared ground, no coupled antennas, no cables. Each node is 4cm x 4cm and battery powered.

Board 10: ESP-PPB.

A few more boards in between with minor tweaks, but the big addition was the dual-DAC setup. 1 ppb typical in the open. 0.1 ppb in a stable enclosure, which is the measurement floor of the hardware.

Oh and one more fun discovery: the radio silently compensates for frequency mismatch between sender and receiver internally. If two boards don't land on the same correction value, your data is garbage and you won't know why. With synced clocks they always agree. With unsynced clocks it's a coin flip. That one cost me months.

Everything is open source. Firmware, schematics, Gerbers, BOM, 3D model. There's a story.md in the repo with photos of every board and what went wrong each time: https://github.com/jonathanmuller/esp-ppb

What was hardest, what was easiest, what I'd redo completely. This has been my side project for a decade and I'm happy to talk about any of it.

Every connector under the sun is here. Plus it has IC interconnects so this post is technically not breaking the rules :)

Thanks Davide for this great resource!

This is a quick prototype HV DC buck board I built using the fiber-laser PCB process I posted earlier.

Still experimenting with trace limits and thermal performance, but it's working surprisingly well so far.

This is V2 of my e-ink DAP project, it has :

• a high quality TI DAC (TAD5212)
• physical controls with a physical wheel (with a hall effect sensor)
• a haptic motor
• 24h battery (even more if I put a larger battery in it)
• BLE audio
• a small 41x73x14mm form factor.
• the nRF53 as its main MCU
• microSD slot

V1 horribly failed, here is what changed since then:

• No more Wi-Fi, this is a bummer, I plan to add this back in V3
• Way longer battery life, V1 used a much more power hungry chip
• Different DAC, it's better in some sense, and worse in others, but not hearable to the human ear

The firmware is still in very early stages, I still haven't implemented a ton of features that the hardware is capable of, like DSP, Bluetooth, etc.

I also need 3D print the case in resin, so it doesn't look like this, I want to use transparent resin

The whole project is open source: GitHub
And the whole process was journaled and documented from beginning to end: V1 journal, V2 journal

Every time i want to do an experiment in the lab and use USB power to my DUT i need to find a cabler with correct connector and thick wires enough for the purpose and then cut it :(:( to be able to connect it to my bench power supply.

So finally i decided to solve this reoccurring issue with a universal adaptor that will solve all my challenges and stopping me cutting cable after cable.

This led up to designing the small adaptor that fits most power boxes since it has moveable banana binding posts. I have added polarity protection and over voltage protection that can be disabled to make it flexible and pass thru voltages from 3-20V out to the USB-A and USB-C connector.

I have also added charging negotiation circuits for both USB-A (up to 10W @ 5V) and USB-C (up to 15W@ 5V).

The adaptor can handle up to 6A so it will work for most application!! I have worked a lot with heat managment and tried to keep low resistance in the current paths. When loading max the hottest component reaches around 85 degrees C in room temp

I’m attempting to make an LED scoreboard for my cricket team using large 7‑segment LED displays. I want it to be battery powered, so I’m trying to reduce the power needed to run 6+ digits at once by using multiplexing. Each segment is connected to a high‑side switch, and the digits to the low‑side. That way I can turn on each digit by pulling it low, and only the segments held high will activate.

The code I’m using runs on an Arduino, which talks to a cheap PCA8695 PWM board. That board connects to a custom MOSFET driver board that handles the high‑ and low‑side switching.

Running code that worked fine in my prototype setup just gave me an epileptic strobing effect on all segments, which completely threw me. I spent hours probing with a multimeter, using the oscilloscope at work, and eventually started cutting “non‑essential” components off the board. Instead of getting an inverted 12 V PWM signal like I expected, I was constantly getting a square wave oscillating between 12 V and 11.5 V no matter what I did.

I was about to post on r/AskElectronics for help, but I wanted to be 110% sure I wasn’t missing something obvious. So I went to falstad.com and built the circuit in the simulator. Sure enough, it behaved exactly how I expected. Then I noticed a little checkbox for “Swap D/S,” and out of curiosity I clicked it… bingo.

For testing, I’m going to desolder the PFETs I’ve got and jankily wire them in upside‑down just to confirm that’s the issue before ordering new ones.

Moral of the story: make sure you’re using the right datasheet for your parts, because manufacturers love reusing part numbers even when the pinouts are completely different.

(p.s. pls don't be too mean about diagram conventions, signal noise, etc. cos this is a self-taught learning exercise and I'm trying my best)

I've been experimenting with using a fiber laser to fabricate prototype PCBs.

Current workflow:

- design PCB

- laser isolate traces

- drill vias

- clean

- solder

Total time from design to board is about 30 minutes.

Trace pitch so far is around ___ mil and I've been able to do reliable double-sided boards.

I made a video showing the full process and the relaxation oscillator circuit I designed for it:

www.youtube.com/@Electronics_with_Joe

The goal was to find where to buy electronics that i need(STM32F103C8T6 and STM32F401RET6), but figured it will be cool if i put all that in one post. Maybe someone finds it interesting.

I designed the case myself. Use esp32-c3 with WifiManager library. The time updates automatically:)

Yes, I will try to build a precise voltage/current measurment equipment from scratch just for fun. Wish me luck.

One step at a time: - 5-digit multiplexed display with the К176ИД2 driver - MC34063 negative rail DC-DC converter - 555 timer 120kHz click source - REF3333 precise voltage reference

There are a lot of "AI generates hardware" claims floating around, and most of them produce garbage. I've been working on a tool called boardsmith that I think does something actually useful, and I want to show what it really outputs rather than making abstract claims.

Here's what happens when you run boardsmith build -p "ESP32 with BME280 temperature sensor, SSD1306 OLED, and DRV8833 motor driver" --no-llm:

You get a KiCad 8 schematic with actual nets wired between component pins. The I2C bus has computed pull-up resistors (value based on bus capacitance with all connected devices factored in). Each IC has decoupling caps with values per the datasheet recommendations. The power section has a voltage regulator sized for the total current budget. I2C addresses are assigned to avoid conflicts. The schematic passes KiCad's ERC clean.

You also get a BOM with JLCPCB part numbers (191 LCSC mappings), Gerber files ready for fab upload, and firmware that compiles for the target MCU.

The ERCAgent automatically repairs ERC violations after generation. boardsmith modify lets you patch existing schematics ("add battery management") without rebuilding. And boardsmith verify runs 6 semantic verification tools against the design intent (connectivity, bootability, power, components, BOM, PCB).

The tool has a --no-llm mode that's fully deterministic — no AI, no API key, no network. The synthesis pipeline has 9 stages and 11 constraint checks. It's computing the design, not asking a language model to guess at it.

Where it falls short: 212 components in the knowledge base (covers common embedded parts, but you'll hit limits). No high-speed digital design — no impedance matching, no differential pairs. No analog circuits — no op-amp topologies, no filter design. Auto-placed PCB layout is a starting point, not a finished board. It's fundamentally a tool for the "boring" part of embedded design — the standard sensor-to-MCU wiring that experienced engineers can do in their sleep but still takes 30 minutes.

Open source (AGPL-3.0), built by a small team at ForestHub.ai. I'd love feedback from people who actually design circuits — is this solving a real annoyance, or am I in a bubble?