Reddit:Electronics

I spent few days trying to make z80 cpu based computer clone. As in every good project first step was performing Hello World output to serial for starters. I got completely stuck as I was getting only letter H and nothing else. I rewired chip selection logic several times, replaced RAM chip, scoped everything I could and only then noticed that top power rails are not connected (you can see top rails are not bridged) meaning RAM was never powered in a first place. I feel like a complete moron…

Having a particular plan for the power supply (as described in the posts before part 2 - Planning and part 1 - Idea) it's possible to start schematics itself. I use and really enjoy KiCAD - it has everything I need for my skills and projects I create.

As the first step with the schematics (see - github.com/condevtion/i2c-pps-hw) I decided mostly to transform the diagram from the previous post to a set of pages and define networks and busses to connect them. You can see a screenshot of the root page in the first picture with the result. The second picture contains everything from the rest of the pages. It's not much for now - the controller's symbol, and a bunch of network and hierarchical labels to enable so called "sheet pins".

I made the symbol starting from one for BQ25798 existed in KiCAD's global library. The chip is quite different but it can be easily transformed by majorly editing pins. While the footprint and 3D model can be requested from Ultra Librarian site by like provided on TI page for BQ25758S. All symbols and footprints I usually add to local projects libraries just not to mess with global library.

In KiCAD its a bit tricky to create nice, short names for busses. You need to create aliases in "File" > "Schematic Setup" > "Bus Alias Definitions" and then you can use them across all pages of a project. For now I came up with following networks and busses:

• VIN - positive input voltage. The master switch page should contain an input connector and protection circuit (fuse, TVS diode) after which the network starts. As well is used to power the digital I/O and indication block
• VINP - positive input voltage after the master switch itself (goes to the input filter)
• EN - master switch control signal (should be high to turn the switch on and low to turn it OFF)
• VINN - output of the input filter
• VOUT - the output voltages bus (contains power stage output and whole device output networks, goes to the output filter)
• CSIN - the input current sensor bus (goes to ACN and ACP pins of the controller)
• CSOUT - the output current sensor bus (goes to SRN and SRP pins)
• I2C - I2C bus itself (connected to SCL and SDA pins)
• GPIO - groups digital I/O lines: interrupt, power good, status, and chip enable
• PROG - groups the rest of analog input lines which should be connected to the programming block to set operating mode and limits for the controller Maybe, going through detailed design these will require changes.

The next step is to draft every page with actual design probably skipping at first particular values for components.

First and foremost what are reflections?

Reflections in PCB are like echoes on a road for electrons. Imagine a PCB trace (the thin copper line) is a highway. A signal is a tiny super-fast car zooming down that highway. Now…

If the road suddenly changes, the trace gets thinner or wider, it hits a connector or the layer changes, it’s like the car suddenly hit a speed bump or a wall. Instead of all the signal energy moving forward nicely, some of it bounces back. This bounce is a reflection.

Why does it happen?

Because of impedance mismatch.

If the trace impedance (say 50Ω) suddenly meets something that is not 50Ω, the signal doesn't have enough voltage or current to pass through and reflects back.

What are the three types of impedances a signal encounters?

Source impedance, Characteristic impedance and Load Impedance.

• Source Impedance (Zₛ) : This is the output resistance of the driver. It's what the signal encounters at the chip pin sending the signal (before it's launched onto the trace). Inside that chip, there’s some internal resistance. That’s the source impedance.
• Characteristic Impedance ( Z₀): This is the natural impedance of the trace itself. This is NOT resistance like a resistor. It’s the ratio of voltage to current for a wave traveling down the trace. Which is affected by the trace width, thickness, distance to ground plane (return path), dielectric material etc.
• Load Impedance (Zₗ): This is the input impedance of the receiving device. It’s the chip pin at the other end of the trace. The load decides what happens when the signal arrives.

The Golden Rule (No Reflection Condition)

Maximum happiness is achieved when:

Zₛ = Z₀ = Zₗ

What happens when one is higher or lower than the other?

Now we’re getting into the “who wins the fight” part of signal integrity.

Case 1: Z₀ > Zₛ (Trace impedance is bigger than source impedance)

The source is “stronger” (lower resistance) than what the trace expects. When the signal hits the load and reflects back, the reflection at the source will be positive. That means, the returning wave adds to the original signal, we will see overshoot and possible ringing as well. We may see the waveform jump higher than it should before settling.

Case 2: Z₀ < Zₛ (Trace impedance is smaller than source impedance)

Now the source is “weaker” compared to the trace. When the reflection returns to the source, the reflection at the source becomes negative. We may see undershoot, slower settling and reflected wave subtracting from the signal. The signal may dip below expected levels before stabilizing.

Image Credits: Right the first time by Lee Ritchey . Best book I have read on signal integrity and design.

I was trying to identify some IC's recently and found out that ChatGPT is incredibly good at identifying IC parts from their markings with some extra context information.

It can require some prodding and trial and error and giving it some hints helps e.g. a description about what you think it does, component footprint, visible marking, the device you found it on. and force it to list number of alternatives. You can also give it a picture and let it find the layout context.

Example I was trying to identify the component marked: KP05 5MES. I gave it the picture and the prompt:

""
Help me find this component: The packaging has these markings:
KP05 5MES
It has aSOIC-8 package
It is a high speed component that operates in the GHz range.
Found on the front end of a GigaWave 6400
Give me a list of possible alternatives.

""

One of the suggested components is the MC10EP05 and I could then verify it by looking at the datasheet

That's pretty cool

1206 resistor for scale, and it works! This is a led driver TPS92201a, those legs are now antennas.

A few months back I shared a board I designed here. I loved the support from the community so I will be open sourcing the design for everyone to enjoy this.

Open source link - https://github.com/NoamanKhalil/Keyboard-pico

Thyratron inside a Varian EDGE (linear accelerator).

Not exactly a keyboard, but the plan is to hook this up to a Pi pico whenever it arrives and use it as the F1 - F24 keys for a CCTV project I'm working on as a "Camera Control Panel"

With all the IO ports on a pico I'm pretty sure I could have gave each switch it's own dedicated IO, but this felt more fun lol

Continuing from the idea published a couple of days before - Building a programmable DC-DC Power Supply with I2C Interface (I2C-PPS). Part 1 - Idea.

I decided to get some intuition about overall device structure before gathering its schematics. As I sketched it in the picture the buck-boost converter can be seen as the set of several blocks - a power stage, input and output filters with respective current sensors, a set of programming resistors, a digital I/O plus indication circuit, and a master switch. The power stage consist of 4 power MOSFETs and the inductor. The input and output filters are sets of capacitors mixed with current sensing resistors. The converter's operation mode and HW limits on voltage and current are set by programming resistors. And digital I/O with indication circuit provides interface for RPI and some leds for us - humans. The master switch makes it possible to start or shutdown the thing as it needed independently by RPI as it's needed. Normally, it should stay off and should go off if RPI goes down turning the converter off when input voltage is here without running RPI.

For the switcher TI provides a design calculator in form of an excel spreadsheet and schematic design checklist which allow to select values for main components with desired input and output specs in mind. As for now I decided to go with 4-6V input window but it really should stay at 5V and set HW input and output current limits at 5A. With 250kHz switching frequency many 10uH inductors with Isat > 7A and DCR in recommended range should work along with set of recommended power MOSFETs. More details you can find in the project repo - github.com/condevtion/i2c-pps.

Looks like it's time to pull KiCAD into the project.

Didnt think it was a thing! Would have expected some mandatory SMT ICs

I also wrote about it here https://boxart.lt/en/blog/diy_digital_clock

I was lurking through DigiKey catalog and found a TI buck-boost controller with I²C interface - BQ25758S. The controller allows to create a programmable power supply with quite impressive output specs - voltage 3.3-26V and current up to 20A. Decided to give it a try and create a compact board for my RPI Zero. I don't think I'll go above 3A input (which means only 500mA@26V give or take some efficiency) and it's a bit of a shame that the controller doesn't go below 3.3V (much better would be at least 1.8V). For starter created an umbrella repository - github.com/condevtion/i2c-pps. Any "well, actually" are very welcome!

I really like motorcycles, specially old sports bikes, but, they do come with a terrible thing, they don't have any safety electronics at all, ABS, TCS, nothing, completely barebones, and I consider myself a pretty new rider, so I'm starting a project where I'm gonna make my own traction control, using hall effect sensors and laser cut tone wheels for sensing both of the wheels rotation, so the ESP32 inside the main PCB can do the math, alongside the MPU6050 GY-512, so it correct the "slipage rate" as the bike inclines from side to side into turns in the twisties, it's definitely not gonna be perfect from the get go, but I'm really hopeful that this thing can work properly.

If you're wondering, they don't act directly on the brakes, but rather using the relay to shut off the ignition coil for a few microseconds as the bikes takes grip again, hopefully this will be able to help both me and several other riders ride their dream bikes more safely!

Everything is at a very starting phase, but I did already order all the PCBs from JLCPCB and the components I bought locally, so excited to see how it turns out!

I’d like to share my experience building a "rough gauge" for my LiFePO4 battery pack. Instead of using an off-the-shelf Smart BMS, I chose the DIY route to better understand the underlying physics and processes.

Stock INA226 modules come with a 100 mΩ shunt resistor, which limits the current measurement to a measly 800 mA. This is far too low for a power battery.

• Shunt Replacement: I replaced the stock resistor with a custom 5 mΩ constantan wire shunt. This should theoretically expand the measurement range to 16 A.
• Reinforcement: Since handling 16 A+ is serious business, I added copper shims (8x0.15 mm) and performed heavy tinning to ensure the high current doesn't rely solely on the thin PCB copper foil.
• Hardware: The system is powered by an ESP32 (Cheap Yellow Display - CYD).

To find the exact resistance value, I ran a series of tests and compared the readings with a UNI-T UT61 multi meter. The calculated precision value is 4.392 mΩ.

• Comparison with UT61: https://youtu.be/3OMUGPUffBk
• Accuracy: The deviation from the UT61 is only 30–40 mA at a 10 A load.

The biggest challenge is heat. At currents above 10 A, the shunt begins to warm up noticeably. This creates Therm-EMF (the Seebeck effect), which causes "phantom" readings of about 50 mA on the screen for several minutes after the load is disconnected, until the node cools down.

More details here: https://en.neonhero.dev/2026/02/modifying-ina226-from-08a-to-high-power.html

A long anticipated update for "Silly power supply for a lone lamp" post :)

The original post showed a simple set of low power batteries connected in parallel supplying a 12V/50mA lamp. The schematic featured a diode per battery to prevent them from feeding each other.

Here, I decided to check experimentally if the diodes indeed work as expected. I used an STM32F103 module as multichannel ADC, a set of resistors to scale down from 0-18V to 0-3V and a RPi Zero 2W as a 5V power supply and to collect data. Potentiometers were set to 20k creating 6 100k/20k voltage dividers (pic 3).

First, measured lamp and batteries voltages with a fresh set batteries. They held around 3 hours 45 minutes. The set had voltage around 12.6V fresh without load. Upon switching on the load they immediately dropped to 12V and then spent most of the time going from 10.5 to 8.5V as the pic 4 shows. The diodes took about 350mV so lamp's voltage went clearly below batteries.

Then I mixed 3 fresh and 3 used batteries and actually was really surprised with how clearly it showed when used batteries kicked in. The last pic shows voltage drop across diodes and comparing with the previous one you can see that the diodes for used batteries open as voltage reaches around 200mV. Which is a great real-world demo of how low is cut-in (or knee) voltage for a Schottky diode can be (here SD103A used).