Reddit:Electronics

This is the final update on the I2C-PPS project. For more details see its repository - github.com/condevtion/i2c-pps. Pictures show a load test example, the load test setup, load emulator (set of 30 each 360 Ohm resistors), voltage regulation errors for 3.3v and 26v, efficiency at 3.3v. output current at 4.5v and input current at 26v (both with current limiting to 5A).

I planned the load test as a final step before wrapping up active work on the power supply project. Let's see where it's ended up. First of all, I mounted all devices on a plexiglass sheet to make the setup handling easier. It consists of MeanWell AC/DC 5V 35W source, Raspberry PI 2 Zero W, NUCLEO-474 and adjustable voltage divider as a 4-channel voltmeter, I2C-PPS itself, load, and a screw terminal to connect all the boards. Additionally, I used two multimeters to independently measure input and output currents. As it appeared later they both had pretty significant resistance to affect high current operation of the power supply.

Initial specification limited output to 25W or 5A (what came first) in 3.3 to 26V range and input current to 5A at 5V. It's pretty demanding numbers. For example, you need just 660 mOhm load to get 5A at 3.3V. As well you'd like to make it adjustable to cover the output current range at different voltages. I decided to hack it with several sets of 2W resistors. Set of 20 Ohm resistors (30 count) covers 3.3-6V range, 43 Ohm - 6-9V, 91 Ohm - 9-13V, 180 Ohm - 13-18V, and 360 Ohm - 18-26V. Each set soldered to a half of a pretty standard 30 position breadboard. Ordinary 100mil jumpers were used to connect necessary number of resistors. Unfortunately, with no active cooling this design becomes really hot within a minute. So I didn't really test reliability of the power supply under significant load.

Still results are quite good for the first revision. The power supply provides requested voltage with around 2% accuracy for 3.3V as controller's datasheet states. Frankly, I got a bit higher than 2% error while the datasheet limited it to 2%, but it's still the first revision. Peak efficiency is 94% at 3.3V and 1.5A down to 87% at 26V and 0.6A. Being overloaded the power supply switches to current limiting mode and properly holds both input and output currents under 5A.

Internal ADC doesn't look that good and shows even higher error (up to 6%) for output voltage. Current sensors disappoint even more. They aren't sensitive to current under 400mA (for analog IIN and IOUT pins) and to current under 1.2A for digital readings. Both showing 10% to 70% error for low currents (but the error goes down significantly for values above 1A). As far as I've dived in it, it works for current limiting within controller specifications but doesn't really suits for measurements. Also the datasheet doesn't mention ADC accuracy so I'd like to think that this is what the controller is designed for - high current applications and safety in the case.

So it really works! And close to what's expected from the controller's datasheet. While doesn't really suit my small projects needs - lack of output below 3.3V and inaccurate internal sensors for most of my projects, it was really interesting project which put to test my HW design abilities and revealed a lot of fascinating things at every stage from discovering KiCAD features, through selecting parts, ordering and assembling PCB, to emulating load and measuring characteristics of the power supply.

First fully working assembly of a 6x IN-14 Nixie board I've been putting together. Sharing the build because I'm happy with how the layout and the HV section came out.

Quick rundown of the circuit:

• 6x IN-14 tubes, multiplexed
• HV supply generating ~170V DC from 12V input via a boost stage (MC34063-based), anodes through current-limiting resistors
• Cathode driving via 74141 / K155ID1 decoders
• Logic level shifting between the low-voltage control side and the HV cathode side
• A separate OLED handles the non-numeric characters since the tubes only render 0–9

The part I spent the most time on was the HV rail. Under load, when all six tubes switch digits simultaneously, there's a bit more ripple than I'd like, so I reworked the filtering on the output cap stage. Multiplexing refresh rate also took some tuning to kill the visible flicker on the lower cathodes.

Data comes in over GPIO from a small controller, but the interesting part here is really the analog HV side and the cathode switching, which is what most of the board real estate goes to.

Posting it as a show-and-tell. Always nice to see this old Soviet hardware still glowing decades later.

More details here: https://www.eevblog.com/forum/projects/diy-1980s-style-autoranging-dc-voltmeter-(icl7107cmosne555)//)

Im aware this is a very bulky (and very open) smart watch but its just a simple side project i made for fun with the few resources i had left around. I currently dont have a 3d printer so I chose to just leave it open with all the electronics out and about and tbh I think it gives it some personality. Im currently working on the Bluetooth connection aspect of it so it can tell me when I get a notification but even then just by itself it has a few games, some productivity apps like notes, checklist, etc. and some simple apps used in engineering such as a calculator, resistor color code calculator, and other useful apps when it comes to building projects.

Here's some info for the nerds:

Microcontroller: esp32

Display: 0.96 in oled

Other features: 4 buttons, 2 indicator leds used in certain apps and games as well as a tiny vibration motor used for small noise and alerts.

I wanted a "real" quantum random number generator, something where every bit is an actual physical quantum event.

First attempt was a 1970s Canon FD 55mm f1.2 with a thoriated rear element. It's pretty radioactive (the Geiger counter make scary noises). But radioactive decay gives you when an atom popped, which is timing-random, not the which-path coin flip I was after.

The build that actually worked is optical: attenuate a light source down to single photons, fire them at a 50:50 UV beam splitter, and read which way each photon went with two detectors. Through → bit 0. Bounce → bit 1.

The detectors are two Hamamatsu PMT modules a friend gave me, pulled out of a dead lab instrument. I tore it down, yanked the dichroic mirror, and dropped in a UV 50:50 splitter. For a fluorescent source I ended up using 3D-printer filament — it's faintly fluorescent at the right wavelength and doubles as a light-tight cover.

All the detection and conditioning runs on a Red Pitaya (FPGA + fast ADCs):

• Op-amp + transistor LED current sink, reed-relay LED gate, PMT gain via dividers, all driven by the Red Pitaya's slow DACs so I could sweep everything in software instead of hand-twiddling pots.
• VHDL threshold + edge detection on the 14-bit ADC, a coincidence veto (kills double-fires / cosmic rays), and a symmetric "global blank" after every event — that last one matters, because per-channel dead time secretly biases the stream.
• A timestamped debug FIFO that was a chunk of fabric to build but caught a bunch of detector-memory artifacts I'd otherwise have shipped.

The hard part genuinely wasn't generating random-looking bits, but it was proving they were real random bits from the optical system and not other noise sources. Most of the project ended up being diagnostics...

Payoff demo is a Quantum Magic 8-Ball: hit a button, it pulls fresh quantum bits and gives you one answer (and, if you're an Everettian, every other answer somewhere in the multiverse).

Full build log with schematics, scope shots, and the FPGA stuff: https://dnhkng.github.io/posts/building-the-beam-universe-splitter/

Happy to answer questions on the analog front end or the FPGA fabric — the analog side is honestly my weakest area, so I'd welcome the critique.

TL;DR, and just want to play with the Quantum Magic 8-Ball? -> https://quantumlever.stream/oracle

Hello r/electronics,

In this post, I want to share my project that I’ve been working on in the past few months. It’s a custom-built lab bench power supply. Such a project is common in the DIY community, so what makes this one different? The custom-designed SMPS board that I engineered from scratch isn’t your typical “let’s put this power supply module into a case” approach. So let’s dive into the working principles, design decisions, and in-depth test results.

The Forwarder 1kW is the SMPS board that I designed and used in this project. It’s based on a hard-switch, half bridge topology. The full features of this power supply are as follow:

• 1000W maximum continuous output capacity.
• Configurable from 50V/20A up to 400V/2.5A.
• CC/CV mode with mode signal and indicator.
• Tuneable operating frequency and dead-time.
• Dedicated power stage enable pin.
• Analog reference interface for output voltage/current control.
• Analog signal output interface for monitoring voltage/current.
• Dedicated fan port with optional automatic power-on.
• Simple construction, less than 130 components on board.
• Easy to build with mostly THT components.
• Curated component selection for high accessibility.

The working principle of this design is about as simple as it can get for a switched-mode power supply. I talked about the working principle of my design over on r/AskElectronics, so I’m not going to repeat it here. Most of the concepts stay the same, just with some design adjustments and the numbers changed.

https://www.reddit.com/r/AskElectronics/comments/1s8ll9g/

Now, I want to go in detail about the design decisions that led into this design that you may find interesting.

1. The lack of active PFC (Power Factor Correction) was determined after I reviewed many existing designs and products in the same power level and after noticing many of them get away without one, I decided to omit this feature. For my first SMPS design, I want to focus solely on the DC to DC conversion power stage. For my next iteration, I’m more likely to resort to a simple boost PFC to achieve tighter regulation.
2. Double-ended hard-switch topology (half-bridge in particular) was chosen due to its suitability and simplicity in this application. Flyback is out of the question due to power requirement, single-ended topologies have poorer core utilisation and the high favour for current mode control, and resonant topologies don’t seem like a good choice for my first SMPS design (duh).
3. An SG3525 with LM324 was chosen to generate the PWM signal and achieve regulation. SG3525 is quite popular for double-ended converters with plenty of documentation online, while the LM324 provides CC+CV regulation with two of its op-amps (because SG3525 only features one error amplifier). This effectively forms a setup based on voltage mode control.
4. Voltage mode control was inherently chosen as the result of using SG3525 and it was favoured due to its “arguably” simpler implementation over current mode control. However, I find the better regulation and inherent cycle-by-cycle overcurrent protection offered in current mode control very enticing. I probably would resort to this approach for my next iteration.
5. My galvanic isolation strategy was to have the entire control circuit on the secondary side and have the PWM signal driven to the primary through a gate drive transformer. This way, I can have simpler and more precise control over the voltage and current regulation without the nonlinearity issues of using optocouplers.
6. ETD49 cores were used for both transformer and output inductor. I like the round bobbin that makes winding easier, and the calculations prove it’s suitable for power of 1kW at 64kHz. The gapped version was used for the output inductor because the high inductance requirement requires high turn number, and that gets complicated real quick with toroidal cores.

After I finished the board, I wanted to know how my design performs in real-life. So, I conducted a few tests that are relevant for a power supply. The testing rig was pretty simple:

1. A power meter at the input and four DS18B20 were used to track the energy consumption and component thermal profile over time.
2. An electrolysis tank with electrodes that can be spaced accordingly was used to simulate multiple load profiles at power up to 1kW.
3. A third positive electrode connected through a toggle switch was used to abruptly step the load in the dynamic tests.
4. Hantek DSO2D10 was used to capture the waveforms in various tests.

The test conducted, along with their results are as follow:

1. The stress test was conducted for one hour and each component temperatures peaked at the following temperatures: half-bridge N-MOS 75°C / 167°F, main transformer 55°C / 131°F, output rectifier 69°C / 156°F, output inductor 44°C / 111°F.
2. The efficiency characterisation was conducted at 50V and 1, 2, 5, 10, and 20 amps. 89% efficiency was achieved at 5A load or more. Maximum recorded efficiency was 90.3% at 50V 10A load, and efficiency at maximum load was 89.1%.
3. The output ripple test was done with direct on-trace probing with a ground spring, 20M BW limit, 1x probe, and no added capacitor. No load ripple showed at 40mVpp, 1A load at 34mVpp, and maxes out at 94mVpp at full load.
4. The turn-on curve tests showed that under loaded condition, it’s bound to the SG3525 soft start function and takes a second to reach the full 50V. At no load and lower setpoints, the voltage overshoots by a few volts.
5. The load step tests showed about 3% voltage deviation going from no load to 10A and vice-versa. Going from 5A to 10A and vice-versa showed no sign of voltage deviation.
6. CV to CC transition took 3ms to begin responding and a full 7ms until the voltage settled. CC to CV transition began immediately and took 3ms to settle. 50V CV to 10A dead-short showed 10App oscillation at 2.2kHz.
7. The input bulk capacitor showed 24Vpp ripple and the DC blocking capacitor showed 14.2Vpp ripple. The primary side of the transformer showed about 75% overshoot that settled within 2 cycles.
8. The N-MOS at conduction showed 184nS fall time for Vds and 572nS rise time for Vgs. At disconduction, the Vds rise time showed as 56nS and 556nS for Vgs fall time.

I’m here not to glaze over my design. After reviewing the results and doing a retrospective, here are my critical opinions about this design.

What I like about this design:

• Good efficiency figure (89.1% at full-load)
• Excellent ripple even without a second-stage filtration (94mVpp at full load)
• Good power density for an almost-fully THT build.

What I don’t like about this design:

• The overcurrent protection is too slow, though it somehow works at preventing the half-bridge from exploding on the dead-short test.
• The compensator design fails in certain conditions (DCM/CCM transitions, output dead short), which results in output oscillation.
• The output diodes are hard to access or replace.

The full schematic, gerber files, KiCAD save files, spreadsheet calculation, and full-res images are available on my Github repository: https://github.com/Luq1308/Forwarder1kW

The build process and the in-depth testing are available in my YouTube video: https://youtu.be/MGMqqtXgwRg

That’s all I have about this project. I hope this post is informative and can be used as a reference or for benchmarking purposes, in which I had difficulty in researching previously. If you have any unanswered questions, let me know and I’ll try to answer them. Thank you for reading, and I'll see you next time.

I'm designing a DIY remote intended as a soldering kit.

My design requirements were:

1. Use a few parts as possible
2. Make easy to assemble (so THT parts only)
3. Make it modular so that main parts can be taken out and used in other projects.

First I had to think about power management, microcontroller and RF module. I'll start with the RF module first... I chose the popular nRF24L01, although the version I am using has a can on it and has FCC/IC. I prefer this version over the generic one that is everywhere. Works well and has a ton of support! The range it can achieve is also more than sufficient for the intended applications.

Since this RF module does not officially support 5V (Yes, I contacted the manufacturer .. there are some versions of the nRF24L01 that *do* support 5V, but this module does not), I had to stick with 3.3V. As my first design goal was to use as few parts as possible, I did not want to use a logic level shifter (LLS). So I needed a microcontroller that operates on 3.3V. Like the Pro Mini, but in my case a Nano form factor running on 3.3V (I had to drop the clock frequency a bit to remain within manufacturer suggested conditions). Even at reduced clock speed, the ATmega328 running at 8MHz and the nRF2401 module combined are still quite fast... at least for the human mind. (more on that below)

Both the RF module and the microcontroller can operate well at 3V, so I figured I just use two AA batteries. Then I only need some filters but no other real power management components like a linear regulator. Perfect for what I was trying to design. Also, I wanted to pick batteries that are super common, cheap enough and can be recharged.

I made a 3D printed base for this remote as well and it now hold very well. I used the remote as a general HID controller for a couple custom games I made and it works great. Response time is super (no lag or delay that is noticeable) and the battery lasts more than a day.

All the parts are THT (through-hole) and therefore easy to solder together (second design goal). I mounted the RF module and the microcontroller using female headers. They are secure enough but this allows them to be removed easily and used in other projects. This was my third design goal.

I am working on a remote car and drone (under 250g), both of which can also be controlled with this remote. So there are quite some applications.

Hey guys I just made my first ever PCB at college. I designed it online and then cut it out with a PCB-CNC machine. We didn’t have time for the teachers to show me the masking process so we just did it without. \\

The red wire is because I made a mistake with the design but it worked out in the end.
\\
It’s a traffic light if you couldn’t tell with an AtMega

This is my version of qron0b. Meet takku:b, a BCD wristwatch which uses CR2032.

It uses 0.6uA during sleep and when awake uses around 4mA - 4.5mA depending on the amount of LED is turned on.

It is made using STM32L010C6

It currently displays following info on each cyclic display:

1. Time in Hours and Minutes
2. Weekday and Date
3. Month and Year

Will be adding alarm soon.

I've been building an open-source embedded systems simulator called Velxio.

It supports:

• Arduino, ESP32, Raspberry Pi Pico and Raspberry Pi emulation
• Multi-board systems communicating over UART, I2C and SPI
• SPICE-based analog circuit simulation with ngspice
• Retro CPUs including Z80, Intel 8080, 4004 and 8086
• MicroSD and ePaper emulation
• An AI agent that can generate circuits and firmware from natural language

Everything runs directly in the browser. No installation, no account required.

You can try it at http://velxio.dev

A regular poster here exhorted us to reduce tantalum usage, especially now that X5U ceramic capacitors are so good.

Here's link showing how some of that tantalum is mined, and the associated landslides:

https://www.bellingcat.com/news/africa/2026/05/12/congos-coltan-belt-verifying-deadly-landslides-at-mines-under-m23-control/

I have some nimo tubes, so i'm just showcasing them here.

About a month ago I posted my credit-card sized computer project here and was honestly overwhelmed by the response - and thanks for all the encouraging feedback, that really helped a lot!

One thing that came up repeatedly was people asking how it was actually built, so here I have some more details on the actual process. It's actually a bit of a hassle to take photos while working with dangerous chemicals, but it was worth it for sure!

Honestly, my first thought after seeng this first picture was like "dang, this is nowhere as clean as I thought..." to the naked eye, everything looks precise and flawless, until you take photos with macro lens mounted on a mirrorless camera. But honestly, this kind of is satisfying too: Not only you can see all the impurities, but also every single overflow of solder paste, which doesn't even look like paste anymore as you can see the microscopic solder balls swimming in flux.

Some areas needed some manual rework with additional solder paste, and the bridge over there was a result of my single layer limitation for now. And yes, I see it's almost shorting with another net but it luckily turned out fine.

And regarding the actual etching process, that was described in my GitHub repo, but it was basically the normal method of etching PCBs with the difference of using copper foil with kapton tape as substrate. Curing the photoresist layer, developing it with a 5% sodium carbonate solution, etching it with ferric chloride, and lastly stripping the remaining photoresist with a 2% sodium hydroxide solution. Optionally solder mask if needed, but I skipped that step with this one.

It's somewhat workable to get fast iterations but has the drawbacks of being extremely fragile. On some photos you can see how uneven the PCB is even though I taped it stretched onto a flat, rigid surface.

Note that the pictures of each step is made on different runs, so you might spot some differences as result of trying different techniques. I already ordered a proper PCB from a fab, once that arrives, the Muxcard will be actually durable enough to be used as a daily driver.

And for those who asked: Yes, I do plan to launch this soon. And if you're interested, you can find more details on the GitHub page :)

But this post is more about these cool pictures I wanted to share here first, I'll add them into the repo as well as reddit doesn't seem to support including pictures in the text body.

If there's anything you're curious about, feel free to ask - I'll try my best to answer every comment! :)

Sound meter with tower light and projector message device for classroom a teacher is buying

I am really autistic about the precision of temperature in my projects, and I found a cheap toaster oven for 14$ the perfect size for my work space, decided to replace the bimetallic thermostat with custom electronics and control circuitry, it was an amazingly fun project!

hope you all enjoy this dumb project! and remember, if you mess with 120V BE CAREFUL!

programming listed on github,
video of process posted to youtube

https://github.com/EleriLove/pwm-pid-control-of-relay-

https://youtu.be/Qr83flDN-Bk