Foundations of Amateur Radio

Recently I built a first attempt at a noise cancelling circuit, on my couch, in GNU Radio, without holding a soldering iron and running the risk of the room smelling like burnt chicken, because if you believe the Internet, sometimes holding a hot piece of metal by the hot end is not the best way.

The idea behind the circuit, or more accurately, flowgraph, is that you take a signal from two sources, invert one, combine them, and they cancel each other out. If the signal with the noise only contains noise, then you can, at least theoretically, remove the noise from the actual signal.

Before you think that I'm inventing something new, I'm not. I'm merely attempting to recreate the same notion I came across decades ago, where you combine the signals from two microphones, preferably identical, reversing the wiring in one and talking into a microphone whilst holding the other one away from your mouth.

I did essentially the same thing using RF signals from two RTL-SDR dongles.

Randall VK6WR pointed out that, aside from misusing the word "mix", which in electronics really means multiply, but in audio means combine, Randall suggested I use "add" and "subtract". I'm still working out how best to name things, because we're talking about audio and RF, sometimes at the same time. Perhaps that's where I went wrong. I'm currently using "combine" as my technology neutral word, but I'm happy to take suggestions.

All that was the side show, because as Randall points out, doing this in RF is much harder than in audio. This is already something I knew. At the time I didn't really know how to get two different but the same sources of audio to experiment with, so I started in the deep end at the RTL-SDR dongle side.

Now, armed with the encouragement from Randall I built a horrible thing, which is easy when you just drag and drop blocks on a screen. I built two independent FM decoders that use the exact same parameters, so they're tuned to the same frequency, they're amplified and tweaked identically. The only difference is that they each decode a different dongle. I then piped each of those into my magic noise cancelling circuit and tried again.

Aside from dealing with hardware restrictions, causing things like buffer under-, and over-run, that's when the computer isn't processing all your samples, or is getting ahead of itself and is running out of samples, I can make audio come out of the speaker in my computer. I can prove that there are two signals, by setting the amplification of either to zero, and still get sound from the other source, however, noise cancelling, no matter what I tried, didn't work.

Then I decided to simplify, rather than trying to cancel out "the Heat is on", word of honour, I'm not making that up, that's the song that was playing, I went back to basics starting with a tone. I fed the same tone into the noise cancelling block twice, once as signal, once as noise. Magic, the cancelling works.

I also learned that changing the frequency of the noise and changing it back gets you into all kinds of problems and even if you send the same tone, one shifted in phase by a known amount, getting the two to cancel each other out is non-trivial.

You might think that this was all a complete waste of time and if you're just driving past it looks like a swollen electrolytic capacitor about to burst your bubble, but it's not that bad.

Here's what I learned from this little adventure.

I can make hierarchical blocks out of flowgraphs. This is important because at some point all the functionality associated with Bald Yak will likely end up being implemented like this. I also learned that such a block can contain user interface elements, which means that we can build blocks that know how to do stuff and tweak how they operate without having to build a user interface every time we use such a block.

I learned that we can implement an idea that would be hard using physical components and test it really quickly, in this case my available time was the limiting factor, not the testing. If I'd done this with components I'd still be trying to figure out where to get them from, let alone turn up the heat. Another bonus is that I didn't spend a single dime and I can dispose of it with the click of a button, rather than trying to figure out how to recycle components and circuit boards.

I also learned that the idea as I built it doesn't work quite as I expected and that things that I didn't anticipate, like changing the frequency, buffer under-, and over-runs, impacted my efforts in unexpected ways. There's a delay between making a change on the user interface and the effect becoming audible, and I learned I can make a dongle work on my computer and that installing GNU Radio is a challenge at the best of times.

In other words, even though I'm unlikely to use the noise cancelling efforts in their current form, there was plenty I learned from the experience.

From my perspective, this was a success. What have you experimented with and learned?

On a completely unrelated matter, long overdue, and music to the ears of some, can you spell SKCC, I've finally put all the Morse Code versions of my podcast on a thumb drive and plugged it into my car. During the week I've managed to listen to about two hours of Morse. While I don't know most of the letters of the alphabet, I can still detect letter and word boundaries.

I'm Onno VK6FLAB