6502 Puts On An SDR Hat

The legendary 6502 microprocessor recently turned 50 years old, and to celebrate this venerable chip which brought affordable computing and video gaming to the masses [AndersBNielsen] decided to put one to work doing something well outside its comfort zone. Called the PhaseLoom, this project uses a few other components to bring the world of software-defined radio (SDR) to this antique platform.

The PhaseLoom is built around an Si5351 clock generator chip, which is configurable over I2C. This chip is what creates the phase-locked loop (PLL) for the radio. The rest of the components, including antenna connectors and various filters, are in an Arduino-compatible form factor that let it work as a shield or hat for the 65uino platform, an Arduino-form-factor 6502 board. The current version [Anders] has been working on is dialed in to the 40-meter ham band, with some buttons on the PCB that allow the user to tune around within that band. He reports that it’s a little bit rough around the edges and somewhat noisy, but the fact that the 6502 is working as an SDR at all is impressive on its own.

For those looking to build their own, all of the schematics and code are available on the project’s GitHub page. [Anders] has some future improvements in the pipe for this project as well, noting that with slightly better filters and improved software even more SDR goodness can be squeezed out of this microprocessor. If you’re looking to experiment with SDR using something a little bit more modern, though, this 10-band multi-mode SDR based on the Teensy microcontroller gets a lot done without breaking the bank.

 

 

Quieting That Radio

If you are casually listening to the radio, you probably tune into a local station and with modern receivers and FM modulation, the sound quality is good. But if you are trying to listen to distant or low-powered station, there’s a lot of competition. Our modern world is awash in a soup of electronic interference. [Electronics Unmessed] tells — and shows — us how much noise can show up on a SDR setup and what simple things you can do to improve it, sometimes tremendously.

According to the video, the main culprit in these cases is the RF ground path. If you have a single antenna wire, there still has to be a ground path somewhere and that may be through the power line or through, for example, a USB cable, the host computer, and its power supply. Unsurprisingly, the computer is full of RF noise which then gets into your receiver.

Adding a counterpoise makes a marked difference. A low inductance ground connection can also help. The counterpoise, of course, won’t be perfect, so to further turn down the noise, ferrite cores go around wires to block them from being ground paths for RF.

The common cores you see are encased in plastic and allow you to snap them on. However, using a bare core and winding through it multiple times can provide better results. Again, thanks to the SDR’s display, you can see the difference this makes in his setup.

None of this is new information, of course. But the explanation is clear, and being able to see the results in a spectrum display is quite enlightening. Those cores essentially turn your wire into a choke. People think that grounding is simple, but it is anything but.

Continue reading “Quieting That Radio”

Roll Your Own SSB Receiver

[Paul Maine] was experimenting with GNU Radio and an RTL-SDR dongle. He created an SSB receiver and, lucky for us, he documented it all in a video you can see below. He walks through how to generate SSB, too. If videos aren’t your thing, you can go back to the blog post from [Gary Schafer] that inspired him to make the video, which is also a wealth of information.

There is a little math — you almost can’t avoid it when talking about this topic. But [Paul] does a good job of explaining it all as painlessly as possible. The intuitive part is simple: An AM signal has most of its power in the carrier and half of what’s left in a redundant sideband. So if you can strip all those parts out and amplify just one sideband, you get better performance.

Continue reading “Roll Your Own SSB Receiver”

Screenshot of audio noise graph

Whispers From The Void, Transcribed With AI

‘Hearing voices’ doesn’t have to be worrisome, for instance when software-defined radio (SDR) happens to be your hobby. It can take quite some of your time and attention to pull voices from the ether and decode them. Therefore, [theckid] came up with a nifty solution: RadioTranscriptor. It’s a homebrew Python script that captures SDR audio and transcribes it using OpenAI’s Whisper model, running on your GPU if available. It’s lean and geeky, and helps you hear ‘the voice in the noise’ without actively listening to it yourself.

This tool goes beyond the basic listening and recording. RadioTranscriptor combines SDR, voice activity detection (VAD), and deep learning. It resamples 48kHz audio to 16kHz in real time. It keeps a rolling buffer, and only transcribes actual voice detected from the air. It continuously writes to a daily log, so you can comb through yesterday’s signal hauntings while new findings are being logged. It offers GPU support with CUDA, with fallback to CPU.

It sure has its quirks, too: ghost logs, duplicate words – but it’s dead useful and hackable to your liking. Want to change the model, tweak the threshold, add speaker detection: the code is here to fork and extend. And why not go the extra mile, and turn it into art?

Real-Time Beamforming With Software-Defined Radio

It is perhaps humanity’s most defining trait that we are always striving to build things better, stronger, faster, or bigger than that which came before. Taller skyscrapers, longer bridges, and computers with more processors, all advance thanks to this relentless persistence.

In the world of radio, we might assume that a better signal simply means adding more power, but performance can also improve by adding more antennas. Not only do more antennas increase gain but they can also be electronically steered, and [MAKA] demonstrates how to do this with a software-defined radio (SDR) phased array.

The project comes to us in two parts. In the first part, two ADALM-Pluto SDR modules are used, with one set to transmit and the other to receive. The transmitting SDR has two channels, one of which has the phase angle of the transmitted radio wave fixed while the other is swept from -180° to 180°. These two waves will interfere with each other at various points along this sweep, with one providing much higher gain to the receiver. This information is all provided to the user via a GUI.

The second part works a bit like the first, but in reverse. By using the two antennas as receivers instead of transmitters, the phased array can calculate the precise angle of arrival of a particular radio wave, allowing the user to pinpoint the direction it is being transmitted from. These principles form the basis of things like phased array radar, and if you’d like more visual representations of how these systems work take a look at this post from a few years ago.

Continue reading “Real-Time Beamforming With Software-Defined Radio”

The one-tube radio setup, in front of a PC monitor

Single Tube SDR Is A Delightful Mix Of Old And New

Software Defined Radio (SDR) is the big thing these days, and why not? A single computer can get rid of a room full of boat anchors, and give you better signal discrimination than all but the best kit. Any SDR project needs an RF receiver, and in this project [mircemk] used a single 6J1 vaccum tube to produce an SSB SDR that combines the best of old and new. 

Single-tube radios are a classic hack, and where a lot of hams got started back in the day, but there is a reason more complicated circuits tend to be used. On the other hand, if you can throw a PC worth of signal processing at the output, it looks like you can get a very sensitive and selective single-sideband (SSB) receiver. 

The 6J1 tube is convenient, since it can run on only 6 V (or down to 3.7 as [mircemk] demonstrates). Here it is used as a mixer, with the oscillator signal injected via the screen grid. Aside from that, the simple circuit consists of a receiving coil, a few resistors and a variable capacitor. How well does it work? Quite well, when paired with a PC; you can judge for yourself in the video embedded below.

We’ve featured a lot of [mircemk]’s projects over the years, like this handsome OLED VU meter, or this frequency analyzer with a VFD  and even a virtual pinball cabinet made from scraps, among many others.

Continue reading “Single Tube SDR Is A Delightful Mix Of Old And New”

Writing A GPS Receiver From Scratch

GPS is an incredible piece of modern technology. Not only does it allow for locating objects precisely anywhere on the planet, but it also enables the turn-by-turn directions we take for granted these days — all without needing anything more than a radio receiver and some software to decode the signals constantly being sent down from space. [Chris] took that last bit bit as somewhat of a challenge and set off to write a software-defined GPS receiver from the ground up.

As GPS started as a military technology, the level of precision needed for things like turn-by-turn navigation wasn’t always available to civilians. The “coarse” positioning is only capable of accuracy within a few hundred meters so this legacy capability is the first thing that [Chris] tackles here. It is pretty fast, though, with the system able to resolve a location in 24 seconds from cold start and then displaying its information in a browser window. Everything in this build is done in Python as well, meaning that it’s a great starting point for investigating how GPS works and for building other projects from there.

The other thing that makes this project accessible is that the only other hardware needed besides a computer that runs Python is an RTL-SDR dongle. These inexpensive TV dongles ushered in a software-defined radio revolution about a decade ago when it was found that they could receive a wide array of radio signals beyond just TV.