But that’s underselling it.

Because under the hood, this thing is a fully capable STM32 development board that just happens to have industrial-grade differential transceivers attached.

And that changes everything.

The Core: A Real MCU, Not a Bridge Chip

FalCAN Probe is built around the STM32F042C6Tx — not a USB bridge, not a fixed-function CAN controller.

That means:

• Native USB FS device
• Flexible firmware architecture
• Direct control over peripherals
• Access to GPIOs
• SWD programming header
• Real-time performance under your control

This isn’t a “dongle.”
It’s an embedded system that ships as a tool.

It’s a Development Board in Disguise

Because the MCU is fully exposed and programmable, FalCAN Probe can double as:

• A general STM32 development board
• A USB device prototyping platform
• A CAN firmware sandbox
• A serial protocol analyzer
• A bus traffic generator
• A custom USB instrument

You have access to:

• USART (PB6/PB7 exposed)
• GPIOs via headers
• Boot configuration pins
• SWD for full debugging access

Need a quick USB-controlled relay?
Need a CAN bootloader test platform?
Need a custom USB descriptor experiment?

You already have the hardware in your hand.

Could It Be an ST-Link?

The fun thought experiment:
With the right firmware, could FalCAN Probe act as an ST-Link compatible programmer?

The STM32F042C6Tx absolutely has the capability to implement:

• SWD signaling
• USB composite devices
• Debug transport protocols

An official ST-Link uses a more powerful STM32 variant, but architecturally there’s nothing preventing a firmware implementation of a CMSIS-DAP or similar debugger stack on this hardware.

Meaning:

• It could program other STM32 targets
• It could become a debug bridge
• It could act as a USB-to-SWD tool
• It could be a lab emergency programmer

The hardware already exposes the right primitives.

That’s the beauty of building your own tools.

Mode Switching: Intentional and Clean

At reset:

• JP4 closed → USB enumerates as CDC (USART1 → RS-422/485)
• JP4 open → USB enumerates as GS_USB CAN

After reset, jumpers can be reconfigured freely.

Default RS-422 full duplex:

Short JP3 & JP4

And when in CAN mode, USART1 (PB6/PB7) is still accessible externally.

So even in “CAN adapter” mode, you still effectively have a development board with serial IO available.

Hardware That Supports the Ambition

This isn’t a breadboard hack.

CAN transceiver: SN65HVD230
RS-485/422 transceivers: SP3485EN (x2)
LDO: MIC5504-3.3
Board: 4-layer FR4 (~1.6 mm)
EDA: KiCad 9

You get:

• Controlled impedance routing
• Solid ground planes
• Clean USB layout
• Industrial-grade differential signaling
• Production-ready manufacturing files

It’s engineered like a deployable product — not just a lab experiment.

Endless Possibilities

When you combine:

• Native USB device
• CAN + RS-485 + RS-422 hardware
• Exposed GPIO
• SWD header
• Bootloader access
• Open hardware design

You get a platform that can evolve.

Today:

• USB-to-CAN
• USB-to-RS-485
• USB-to-RS-422

Tomorrow:

• Custom CAN protocol analyzer
• Firmware-based CAN bridge
• USB composite device (CDC + CAN)
• Field firmware updater
• Bus intrusion test tool
• Portable automation interface
• Emergency ST-Link-style programmer

Or something no one has thought of yet.

Why This Is Actually Cool

Most adapters are fixed-purpose appliances.

FalCAN Probe is a tool platform.

It reduces lab clutter.
It collapses multiple dongles into one device.
It exposes its internals instead of hiding them.
It invites firmware experimentation.

And if you’re the kind of engineer who likes understanding — and controlling — your tools, that’s the real win.

Because the best hardware tools aren’t just interfaces.

They’re multipliers.

Get all the hardware and software sources on Github:
And buy one here: https://www.imania.dk/index.php?cPath=204&sort=5a&language=en

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