Reddit:Electronics

Took the laser PCB process a bit further and pushed this one to a fully working board.

The vias are drilled with a sub-mm bit and stitched manually with wire to tie the planes together. It’s basically sewing the board to keep the return path tight.

Main goal here was reducing loop inductance as much as possible since this is driving a SiC switching stage.

Not trying to replace fab boards, but for fast iteration this is actually way more capable than I expected.

Still experimenting with how far this approach can go in terms of switching performance vs a proper manufactured board.

Hey, I built a Bluetooth audio amp based around the TPA3110. The QCC5125 uses differential audio signals for the TPA. I had to cut some ground lanes on the PCB for it to work because those cheap TPA boards use the same ground. USB trigger board for a 12V linear reg to an isolated 5V converter. Works really good; I only hear a quiet noise about 2-3cm in front of the speaker. I have 2x 15W 4-ohm speakers. What do you think? Anything to add, or just finish it with a case?

I wish I had been smart and careful enough not to use a freerouter.

I'm honestly so happy I finally got it to work. I'm new to his but I love figuring out the ins and outs.

Not sure how you all feel about LLMs, but I have been letting Claude get involved in my electronics projects recently.

After a great deal of experimentation using Rigol DS1054Z over LAN with Claude Code, I've built a small MCP server that lets Claude fully drive the scope.

It exposes things like:

• configuring channels / trigger / timebase
• running measurements (Vpp, frequency, etc.)
• downloading waveform data with basic heuristics for Claude to plan around
• capturing screenshots that Claude can view

It's just SCPI with Python, but wrapping it as MCP tools makes it surprisingly usable for iterative diagnosis!

Repo: https://github.com/erebusnz/rigol-mcp

Curious if anyone else is using Claude for their electrical engineering. Claude is surprisingly good.

Example use:

Here's a real example with a frequency generator + LCR connected to Channel 2 but with Channel 1 set up (incorrectly). Claude was able to get the waveform visible and correctly guess what it was seeing.

using my rigol scope figure out how to get a clean measurement

● rigol.idn RIGOL TECHNOLOGIES,DS1104Z,...

● rigol.get_scope_state CH1 active, 10x probe, 1V/div, DC Scope STOPped Trigger level: 0V Channel offset: ~1.68V

→ Trigger mismatch → unstable/dirty capture

→ Running autoscale...

● rigol.autoscale

→ Signal detected on CH2 (not CH1) → Trigger locked (TD) on CH2 ~0V

● rigol.measure(CH2, FREQUENCY) 1.298701e+06 Hz

● rigol.measure(CH2, VPP) 5.08 V

● rigol.measure(CH2, VRMS) 0.723 V

● rigol.screenshot [captured]

✓ Clean measurement achieved

Results: Frequency: ~1.30 MHz Vpp: ~5.08 V Vrms: ~721 mV

Waveform: Step response with damped ringing → square wave exciting an LC resonance

Since i'm planning to build a bigger batch of USBpwrMe i actually need to test each unit in a fast and repeatable way. Therefore i have designed a test jig that will measure all functions.

There are 2 voltage regulators that will supply the test jig itself with 5V but also a 6V regulator to be able to make a test of an over voltage circuit with a threshold of 5.6-5.7V.

INA139 will monitor the current of the DUT thru a shunt of 0.5 ohm or less. This will be optimized depending on what the DUT will actually consume.

On the test jig board a PIC Mcu will control and manage the whole test and test instructions and results will be presented on a 2x16lcd display. The test is not high tech but the DUT must be manipulated with external resistors and voltages to be tested. This is mostly handled by 3 relays.

Connection to the DUT will be easy using the banana connectors and the USB outputs which has corresponding mating connectors on the test jig.

Following steps will be performed

1 It will measure the current consumption of the board to see if there is excessive power consumption

2 It will change polarity on the DUT and measure if there is any voltage on the output.

3 It will will apply resistors on the D+ and D- lines och the USB-A connector and measure so that expected voltage appears.

4 It will apply resistors on the CC1 and CC2 line for the USB-C connector. Vbus1, Vbus2, CC1 and CC2 are measured. If negotiation is correct it will enable Vbus.

5 It will change input voltage from 5V to 6V and test so that the OVP protection works.

6 Finally it will test the OVP mode switch by telling user to turn of OVP. And measures that Vbus goes on.

The test will hopefully test a unit under 5s.

The Gerber files are already sent to manufacturer and are in production. Now you might wonder why a choose a to small board that won't fit the display. Well at first i did. And when i uploaded the gerbers files it was around 40Usd to get it manufactured and shipped. By reducing the height of the board with 3cm the cost was 12Usd. Since it's only a testjigg and will be put into a casing i rather save some money!!!

The PCB has 4 layer stack up. Not really needed but it's much easier to route the signals and takes less time. The schematic and routing took around 5hours.

Funny thing is that the test jig is way more advanced than the product it is itended to test :) :)

About once a year or so I have to solder up a smallish stripboard. I designed them on paper, which is kind of annoying if you make a mistake or want to change something. So this time I tried finding a simple stripboard editor but couldn't really find one that's easy and fast to use for simple projects. Therefore I just decided to create my own.

It uses a split-screen layout with a very basic schematic editor on the left and a stripboard editor on the right. You first design a schematic and then place the components on the stripboard. Having the schematic allows for conflict detection, strip colouring and checking for unfinished nets on the stripboard.

You can check it out here: https://stripboard-editor.com

My goal was to create a fast, simple to use editor for small projects where it's not worth the trouble to use a complex editor but hard enough where using paper or your head only would be annoying. (I dont make any money of this in anyway, its just a personal hobby project I think could be useful)

If you have any feedback, Id love to hear it.

Greetings, Karl

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