Source code and design files: https://github.com/AndersBNielsen/PhaseLatchMini

If you’d told me a few years ago I’d be designing and building my own modular Software Defined Radio platform, I’d have laughed. Radio has always felt like electronics magic to me—no matter how much I learn, the sense of wonder never goes away. In the previous video, we explored the bare-minimum concept of an SDR: mixing a radio signal down to IQ baseband and handing it off for digital processing. And yes, I did that with a 50-year-old CPU, the 6502.

For a quick refresher on what SDR means at the circuit level, check out the first video in this series. Back then, my 65uino didn’t have a usable ADC, so the only real option was the classic 1990s approach—pipe the baseband into a computer sound card. In 2025, that makes it one of the lowest bandwidth SDR setups imaginable: stuck at 44.1 kHz, which is roughly 1/72 of what a cheap RTL-SDR can do. It can’t even decode FM. And since my long-term goal is far beyond a few megasamples per second, I needed something better.

Before jumping into high-end territory, I wanted to explore an affordable middle ground. Enter the STM32 “Blue Pill”—a dirt-cheap board I’d had sitting in a drawer for years. Despite its price, the STM32F103 MCU has a surprisingly ideal feature set for SDR use: USB, DMA, and, crucially, dual ADCs that can sample simultaneously. That last part is essential for properly digitizing I/Q channels, and it’s something many MCUs lack.

My expectations weren’t high, but after experimenting with the dev board, I got enough usable bandwidth to justify designing my own custom board. Huge thanks to this video’s sponsor, JLCPCB, who handled fabrication and assembly. I’ve used them long before ever being sponsored—they’re affordable, fast, and the boards come out great every time.

Since ADC performance depends heavily on layout, I upgraded the board to include a proper ground plane and clean separation between the sensitive analog input and noisy USB lines. The design is simple: capture I and Q through a passive LC low-pass filter for anti-aliasing, then feed them straight into the MCU’s ADCs.

After verifying power rails, programming via SWD, and confirming the 8 MHz clock, I wired the board into my existing PhaseLoom IQ mixer. A single USB cable powers everything. Connected to my 40-meter antenna, the system immediately picked up AM, CW, and FT8—though with some aliasing and imperfect image rejection. Increasing the gain in the mixer helped, but only after carefully matching resistor pairs to avoid I/Q imbalance.

Once the hardware side looked solid, I tackled the firmware. The result is the PhaseLatch Mini: an STM32-based direct-conversion SDR front-end paired with simple Python host scripts. GQRX reads samples through a USB FIFO, and tuning is handled on the hardware side through the si5351 synthesizer. With this setup, I was able to cleanly receive HF, FM broadcast, and even experiment (with mixed success) around 144 MHz.

The PhaseLatch Mini isn’t the final destination—it’s a fun and capable side project on the path to a much more advanced 6502-powered SDR. But it’s already a surprisingly usable 200 kHz-bandwidth receiver, and I’ve made boards, kits, and files available for anyone who wants to experiment.

If you’re curious or want to dive deeper, come hang out on the Hackerspace Clubhouse Discord. More samples and a sneak peek at what’s next are at the end of the video up top.

Discord: https://discord.gg/kmhbxAjQc3
Buy a PhaseLoom and PhaseLatch Mini at my store iMania.dk

Source code and design files: https://github.com/AndersBNielsen/PhaseLatchMini

Part 1: A 6502 Software Defined Radio (video), PhaseLoom Github project, this post, buy one here
Part 2: 6502 + STM32 join forces as cheap SDR! (video), PhaseLatch Mini (Github), Building the “PhaseLatch Mini”: A Detour Into Modular SDR Design (blog post), buy one here

Part 3: 6502 + 20MHz ADC!

I just built what might be the coolest gadget of the year: a Software Defined Radio (SDR) powered by none other than the legendary MOS Technology 6502 CPU. And the timing couldn’t be better – this chip turns 50 years old on September 8th!

If you already know what SDRs and 6502s are, your jaw may have just dropped. But if not, don’t worry. I’ll catch you up.

The source code for everything is on Github: https://github.com/AndersBNielsen/PhaseLoom
You can also jump straight over to my store and buy one: https://www.imania.dk/index.php?currency=EUR&cPath=204&sort=5a&language=en

What’s an SDR Anyway?

Think of an SDR as the Swiss Army knife of radios. Instead of filling a workbench with dedicated devices, like a garage door opener, a satellite receiver, and a shortwave set, you just plug in an SDR and let software do the heavy lifting. Tuning, filtering, demodulating is all handled by code.

With an SDR, you can:

• Pull down data from satellites
• Decode airplane transponders
• Listen to ham radio or shortwave broadcasts
• Experiment with frequencies you didn’t even know existed

They come in all shapes and sizes, from cheap USB dongles to professional-grade equipment worth thousands. Some just receive, others transmit. But they all share the same principle: turn analog radio waves into digital data, then let software handle the magic.

And the 6502?

Ah, the 6502. This little 8-bit CPU powered the Apple I & II, Commodore 64, Atari consoles, and even the NES. For many, it was the chip that introduced the world to affordable personal computing. And now, half a century later, it’s back—this time running the front end of my homemade SDR.

Meet the PhaseLoom

I call my creation the PhaseLoom: a Quadrature Sampling Detector Phase-Locked Loop SDR frontend. Don’t worry about the jargon—what matters is that it’s a custom circuit that converts radio signals into the digital I/Q streams needed for software processing.

In practice, it works like this:

RF Frontend – A simple low-pass filter to clean up incoming signals.

Quadrature Sampling Detector – Uses clever switching to split the signal into in-phase (I) and quadrature (Q) components.

Local Oscillator – Generated by an SI5351 clock chip, controlled by 6502 assembly code.

Output – The I/Q signals can be piped into a sound card, oscilloscope, or eventually a higher-speed ADC for real SDR processing.

When I first powered it up, I wasn’t sure what to expect. But sure enough, with an antenna hooked up, I could tune into the 40-meter ham band. It’s rough, noisy, and very much a prototype—but it works. A 6502-powered SDR is alive.

Why This Matters

Most SDRs today rely on powerful modern processors or FPGAs. Running one from a CPU designed in 1975 is absolutely ridiculous—and that’s exactly why it’s so fun. The 6502 may not be doing the heavy DSP (yet), but it’s orchestrating the whole show. And with more development, I plan to push it further—maybe even squeezing in some real signal processing routines on that ancient silicon.

The Road Ahead

This is just the beginning. Better filters, wider bandwidth ADCs, and smarter software are all on the horizon. And yes, the PhaseLoom will be open hardware—schematics, code, and boards are already available.

The 6502 started a revolution 50 years ago. Today, it’s tuning in the airwaves. And I can’t wait to see how far this project goes.

For now you can buy one here: https://www.imania.dk/index.php?currency=EUR&cPath=204&sort=5a&language=en