Low Parts Count ARM SDR

[Alberto di Bene] wanted to build an SDR for relatively low frequencies. Usually, you’d start with some front end to get the radio frequency signal down where you can work with it. But [Alberto] practically just fed an antenna into an STM32F429 Discovery board and did all the radio processing in the onboard ARM chip.

There is a little more to it than that, but only a little. If you open the PDF file on [Alberto’s] site, you’ll see there is a simple front end filter (a transformer, along with a few capacitors and inductors). This low pass filter prevents high frequencies from reaching the ARM processor’s analog to digital converter. In addition, a capacitor and a couple of resistors ensure the converter only sees positive voltages.

The CPU digitizes the incoming signal and processes it, demodulating several different types of radio transmission. The recovered audio is sent through the onboard digital to analog converter.

In addition to an input filter, the output also needs a filter to prevent high frequencies from reaching the speaker. Unlike the input filter, this one is a bit more complicated. The inductors needed for a passive filter were too large to be practical, so the output filter is an active one with a few transistors. The only other external circuitry is the power supply for the Discovery board.

The document does a great job of explaining the rationale behind the design choices and how the whole system works. It also includes simulations of both analog and digital filters used in the design.

This is really bare metal SDR and reading the code is educational. However, if you want to start with something simpler, consider GNU Radio and either an SDRPlay or a cheap RTL-SDR dongle.


Your First GNU Radio Receiver with SDRPlay

Although GRC (the GNU Radio Companion) uses the word radio, it is really a graphical tool for building DSP applications. In the last post, I showed you how you could experiment with it just by using a sound card (or even less). However, who can resist the lure of building an actual radio by dragging blocks around on a computer screen?

For this post and the accompanying video, I used an SDRPlay. This little black box has an antenna jack on one end and a USB port on the other. You can ask it to give you data about a certain area of the RF spectrum and it will send complex (IQ) data out in a form that GRC (or other DSP tools) can process.

The SDRPlay is a great deal (about $150) but if you don’t want to invest in one there are other options. Some are about the same price (like the HackRF or AirSpy) and have different features. However, you can also use cheap TV dongles, with some limitations. The repurposed dongles are not as sensitive and won’t work at lower frequencies without some external help. On the other hand, they are dirt cheap, so you can overlook a few little wrinkles. You just can’t expect the performance you’ll get out of a more expensive SDR box. Some people add amplifiers and converters to overcome these problems, but at some point it would be more cost effective to just spring for a more expensive converter.

Continue reading “Your First GNU Radio Receiver with SDRPlay”

Improving WiFi Throughput with FM Radio

WiFi networking is one of those things that is reasonably simple to use, but has a lot of complex hidden features (dare we say, hacks) that make it work, or work better. For example, consider the Distributed Coordination Function (DCF) specified in the standard. Before a station can send, it has to listen for a certain time period. If the channel is clear, the station sends. If not, it has to delay a random amount of time before trying again. This is a form of Carrier Sense Multiple Access (CSMA) channel management.

Unfortunately, listening time is dead time when–at least potentially–there is no data transmitted on the network. DCF allows you to use various handshaking packets to do virtual carrier detection and ready/clear to send, but these are also less efficient use of bandwidth. There are other optional coordination functions available in the WiFi standard, but they all have their drawbacks.

[Aleksandar Kuzmanovic] at Northwestern University and two of his students have recently published a paper with a new way to coordinate multiple unrelated wireless networks using ubiquitous FM broadcast radio signals called WiFM. Instead of trying to synchronize to the WiFi data channel, this new scheme selects a strong FM radio station that broadcasts Radio Data Service (RDS) data (the data that populates the song titles and other information on modern radios).

Continue reading “Improving WiFi Throughput with FM Radio”

Better, Smaller WiFi Throwies

Because the world doesn’t have enough electronic junk floating around, [Victor] has improved the WiFi Throwie.

A decade ago, when strong, cheap magnets, bright LEDs, and small coin cell batteries were materials fresh to hacking, someone had a great idea: tape all these items up and throw them on bridges and overpasses. The LED throwie was born, and while we’re sure the biggest installation of LED throwies looked cool, it’s really just a small-scale environmental disaster.

Since then, the ESP8266 was created, and the world now has a tiny WiFi-enabled computer that’s the size of a postage stamp. Yes, WiFi throwies already exist, but coin cells don’t work with the ESP. This means the compact and tiny ESPs are laden down with heavy lithium cells. [Victor] had a better solution: tiny lithium batteries for quadcopters exist, so why not use those?

[Victor] ended up using a small 100mAh 3.7V Lipo battery from a tiny quadcopter for this build. 100mAh isn’t a lot, but in sleep mode, the ESP only uses about 15mAh, or about 6 hours of run time. Sending a picture takes 30 seconds at 120ma, or about 120mAh, so even with a tiny battery no bigger than the ESP itself, this diminutive web server can handle 100 connections before the battery dies.

While not recommended unless you intend to retrieve your throwable web server, it is an interesting example of the latest and cheapest technology that made a throwable webserver possible; 10 years ago, both the ESP and a battery this small would have been unthinkable.

WiFi Fob Acquaints OLED with ESP

When you think of WiFi in projects it’s easy to get into the rut of assuming the goal is to add WiFi to something. This particular build actually brings WiFi awareness to you, in terms of sniffing what’s going on with the signals around you and displaying them for instant feedback.

[0miker0] is working on the project as his entry in the Square Inch Project. It’s an adapter board that has a footprint for the 2×4 pin header of an ESP8266-01 module, and hosts the components and solder pads for a 128×64 OLED display. These are becoming rather ubiquitous and it’s not hard to figure out why. They’re relatively inexpensive, low-power, high-contrast, and require very few support components. From the schematic in the GitHub Repo it looks like 5 resistors and 7 caps.

The video below shows off two firmware modes so far. The first is an AP scan that reads out some information, the second is a weather-display program. Anyone who’s worked with the ESP modules knows that they have the potential to gather all kinds of data about WiFi signals — one of our favorite demos of this is when [cnlohr] used it to create a 3d light painted map of his WiFi signal strength. Chuck a rechargeable LiPo on this thing, tweak the example code for your needs, and you have a new gadget for wardriving-nouveau.

Continue reading “WiFi Fob Acquaints OLED with ESP”

Triple Frequency VFO on a Bamboo Breadboard

Historically when hams built low power (QRP) transmitters, they’d use a crystal to set the frequency. Years ago, it was common to find crystals in all sorts of radios, including scanners and handheld transceivers. Crystals are very stable and precise and it is relatively easy to make a high quality oscillator with a crystal and a few parts.

The big problem is you can’t change the frequency much without changing crystals. Making a high quality variable frequency oscillator (VFO) out of traditional components is quite a challenge. However, today you have many alternatives ranging from digital synthesis to all-in-one IC solutions that can generate stable signals in a wide range of frequencies.

[N2HTT] likes to build radio projects and he decided to take an Si5351 clock generator and turn it into a three frequency VFO for his projects. The Si5351 uses a crystal, so it is very stable. However, you can digitally convert that crystal frequency into multiple frequencies over a range of about 8kHz to 160MHz.

Continue reading “Triple Frequency VFO on a Bamboo Breadboard”

Google OnHub Can Has Root

It’s always nice to get down to the root directory of a device, especially if the device in question is one that you own. It’s no huge surprise that a Google product allows access to the root directory but the OnHub requires locating the hidden “developer mode” switch which [Maximus64] has done. The Google engineers have been sneaky with this button, locating it at the bottom of a threaded screw hole. Has anyone seen this implemented on other hardware before?

There isn’t a blog post regarding this, however [Maximus64] shared a video on YouTube walking us through the steps to root and un-root Google’s OnHub, which is embedded after the break. He also states “wiki coming soon” in the description of the video, so we’ll keep eye on it for an update.

We covered the product announcement back in August and have heard a few reviews/opinions about the device but not enough to make an opinionated assumption. Rooting the device doesn’t seem to increase the OnHub’s number of LAN ports but we think it’s still worth the effort.

Continue reading “Google OnHub Can Has Root”