So called "pirate" radio stations have existed as long as radio broadcast has existed. These unlicensed operators setup shop in various locations and start broadcasting whatever content they wished. Shown above is the lightship used as a base for Radio Veronica  broadcasting offshore of the Netherlands in the 1960's. Being based offshore on a boat makes it extra pirate-y!

In this guide we'll show how to use the Adafruit Si4713 FM Transmitter to create your own little pirate radio station. A Raspberry Pi provides the source for music storage and playback. Attaching a small 1.3" PiTFT provides a display for playback song information and status.

FM Radio? Really?

Pretty much no one carries a personal FM radio receiver with them these days. So if you're all like pepperidge-farm-remembers / i-was-there-gandalf at the mention of FM radio and wondering what's the point, here are some ideas:

• Create a personal radio station for someone that does not have a smartphone. Perhaps for an older generation member more comfortable with FM radio technology, as was heartwarmingly done in this post.
• Broadcast audio to cars at an ad hoc "drive in" style gathering. Cars still have FM radio receivers.
• Other imaginative use :)

Parts

In this guide we demonstrate using a Raspberry Pi Model 3B. However, the processing being done is minimal, and actually any model Pi could probably handle this task. A USB port makes connecting the USB audio adapter easy.

The 1.3" PiTFT used is another trade-off. It's pretty small and only provides two buttons for user interaction. But it leaves some of the Pi's GPIO pins available, which are needed for connecting the Si4713's reset line. Also, it has a STEMMA QT connector which makes the I2C connections easy.

Here's a connection diagram of the overall hardware setup.

• Attach the PiTFT to the Pi GPIO header.
• Use the STEMMA QT connector on the PiTFT to connect to power and I2C to the Si4713.
• Connect Si4713 RST to GPIO 26 on the Pi.
• Plug the USB audio adapter into an available USB port on the Pi.
• Connect the USB audio adapter to the Si4713 input using an audio cable.

Here is a list of the various hardware items shown.

The Si4714 is the FM radio transmitter:

For getting good audio out from the Raspberry Pi, a USB audio adapter is used:

To connect the USB audio adapter to the FM radio, a 3.5mm stereo plug/plug cable is needed. This cable is nothing special and one is often included with various media devices. So check your electronic drawer first - you may already have one.

The 1.3" PiTFT provides status and buttons for user interaction:

The Si4713 is connected to the Pi through the PiTFT's STEMMA QT connector. This cable can be used:

And of course, need a Raspberry Pi. We based this guide on the Pi 3 Model B:

OK, let's get all the necessary software bits installed and checked out. The first few are covered in other guides, which are linked to from here. It works best to do these in the order shown here, checking that each step works before moving to the next.

Blinka Installation

Follow this guide page for initial Pi setup (including the OS) and Blinka installation:

Be sure the blinkatest.py script from that setup runs as expected before moving on.

PiTFT Setup

This guide uses the PiTFT directly via Python. So follow this setup page from the PiTFT main guide:

The guide covers a couple of TFTs, and the rgb_display_minipitfttest.py test script appears to be configured for the smaller TFT - not the one used in this guide. However, it's a simple fix to change to the 1.3" TFT.

Change these lines:

to this:

FM Radio Setup

To install the CircuitPython library for the Si4713 FM radio transmitter, follow this guide page:

Test using the frequency scan example from that guide. If that runs OK, then it should be installed and working correctly.

USB Audio Adapter Setup

The Pi has built in support for the USB audio adapter, so there's nothing extra needed in terms of software. Simply plug the USB audio adapter into one of the Pi's USB ports and run the following command:

This will list the audio devices that the Pi has. There will likely be more than one, but the USB audio adapter should show up in the list. Look for C-Media USB Headphone Set in the output.

Here's an example:

The USB audio adapter shows up as card 2.

Music Player Software

To serve up audio, we'll use the Music Player Daemon software. To install it, along with a couple of other tools, run the following:

This will install:

• mpd - the main music server (daemon)
• mpc - a simple command line tool for controlling mpd
• ncmpc - a simple text based interface music player

After installation, run the following as a simple test:

This just queries the current status of the server, which won't be anything exciting at this point. It should look like this:

But that verifies the server has been installed correctly and is running.

Python Library for MPD

The python-mpd2 library allows for controlling mpd playback from within Python. This is another pip install:

Music and Playlists Folders

We'll store music and playlist files in the default pi users home directory. Use mkdir to create these folders. An initial cd is done to make sure the current directory is the pi user's home directory (/home/pi).

Run these commands:

Nothing exciting should happen.

• The /home/pi/music directory will contain the actual music files, like MP3s, etc.
• The /home/pi/playlists directory will contain playlists.

MPD Configuration

The main file that controls the mpd configuration is located in /etc/mpd.conf. A default file is added during the installation of mpd. There is a lot of content in this file, however the vast majority is commented out and is just there for reference. For this guide, it is possible to use a very minimal configuration.

First, let's move (rename) the original file so it's still available as a backup:

Now use a text editor to add the contents below to a new empty /etc/mpd.conf.

This sets the following:

• Sets the music_directory and playlist_directory to the locations we created previously.
• The audio_output lines enable using the USB audio adapter. Actually selecting this output is done later.

Adding this content to /etc/mpd.conf can be done using the nano text editor as shown below.

Restart MPD Server

For the configuration changes to take effect, the mpd server needs to be restarted. Use the following command:

This should not generate any additional output. So running mpc status as a quick sanity check can help to make sure the mpd server actually did restart.

For comparison, here is what mpc status will output if the mpd server is not running:

There are two steps for adding music:

• Add the music files (mp3, etc. ) to the /home/pi/music directory.
• Create playlists files (m3u) in the /home/pi/playlists directory.

Playlists are really an optional feature from mpd's point of view. However, the Python radio program works by specifying a playlist to use for broadcast. So we'll go through both steps.

Add Music Files

This is pretty simple, just dump all the mp3 files in to the music directory:

However, if there are a lot of music files, from numerous artists and albums, then this can get messy. The mpd server will search the music folder recursively. So a good way to organize things is into a hierarchy of artist/album/song. Something like this:

To provide examples for this guide, we'll use these two short mp3 files. Click each button to download them.

Copy them to the Raspberry Pi. To keep things simple, we'll just place them directly in the music directory so it ends up looking like this:

Create Playlist

A playlist is a simple text file with a .m3u extension. Each line of the playlist file references a music file. The full path of the file relative to the music folder is used.

Let's create one called test.m3u using the two example files downloaded in the previous section.

Multiple playlist files can be created and stored in the playlists directory.

Update MPD

Anytime new music files are added, or playlists added or updated, the mpd server needs to be told to update its internal database. This can be done using mpc:

This will generally be very fast. But if there are a lot of new files to be searched through, it can take many seconds. The update progress can be checked using the status command with mpc. If this does not show "Updating DB", then the update is complete.

The Si4713 FM Radio Transmitter uses the same FM radio band as regular domestic radio. So a lot of frequencies will already be occupied by local radio stations - like all the ones you hear driving around in your car.

To find an available frequency, we can use the Si4713 itself, which has the built in ability to measure the noise for a given FM frequency. By scanning across the frequencies in the FM broadcast band, locations where frequencies are occupied can be determined.

Use the code below to run a frequency scan. This is really just the same basic demo from the Si4713 guide, with added output to a file.

The output is simple. For each frequency, a relative noise level is given. The higher the value, the stronger the radio station signal. So look for frequencies with the lowest values.

The data can also be plotted to help find the occupied areas. Pick a frequency somewhere between the peaks.

At this point, all the supporting software pieces should be in place, music has been added, playlist(s) created, and an available broadcast frequency has be determined. Now we can use a Python program to configure the Si4713 FM radio transmitter, start music playback, and use the TFT to provide status and basic control (via the buttons).

Here's the code. Save a copy of this as radio.py in the pi users home directory /home/pi.

Background Image

A static image file is used for the background on the PiTFT. Download this image:

And save it as radio_bg.py onto the Pi in /home/pi - the same directory where radio.py is saved.

Configure and Run

There are a few lines at the top of the radio.py code that can be changed. Look for these lines:

And change, if needed, as follows:

• FREQ - Set this to the frequency that was found to be available from the frequency scan performed in the previous section.
• PLAYLIST - Set this to the playlist that will be broadcast over the radio. The default test playlist was created earlier in this guide.
• STATION_NAME - Change this text to be your station name. It actually gets broadcast (via RDS) and will show up on radios that display this kind of information.
• UPDATE_RATE - This sets how often the TFT display is refreshed, in seconds. The default 0.5 value should be fine, but the adjustment is here if needed.

Once the changes have been saved, run the radio.py program to start broadcasting:

It will print the station name and frequency being used. As long as the program is running, the radio is broadcasting.

Info and Status

When the radio.py program runs, the PiTFT is updated with with playback information and status.

Playback Control

The two buttons on the PiTFT provide some minimal control of playback.