10 Milliwatt Si5351A WSPR Beacon

It’s fun to experiment with propagation by seeing how far you can get a signal to travel with a transmitter in the milliwatt range (this is known colloquially as QRPp). For quite a while, this esoteric pursuit was done with flea-powered CW signals, until the invention of the WSPR modulation scheme by Nobel laureate Joe Taylor, K1JT. WSPR is now a very popular method with hams around the world for HF propagation experiments; aided greatly by the WSPRnet online database, which allows hams to get detailed information about where and when their signals are being heard.

Although a fair amount of computation (for a microcontroller at least) is used to encode a WSPR message, the actual modulation scheme is relatively simple 4-FSK, which means that four different symbols can be encoded by transmitting on one of four discrete equidistant frequencies (spaced approximately 1.46 Hz apart). For any method of signal generation with a decent amount of frequency resolution such as a PLL or DDS, this is easily implemented. The Etherkit Si5351A Breakout Board combined with the Si5351Arduino library provides a low-cost, wide range PLL with excellent frequency resolution for a task such as this.

The tricky part is timing the transmissions correctly. WSPR requires transmissions that start on the first second of an even minute. Any transmission that deviates more than about one second either too soon or too late will not be decoded, so it is most important to be sure that you have an accurate clock when attempting to transmit with WSPR. Traditionally, this has been accomplished by using a PC synchronized to an internet time server to act as the controller for the WSPR transmitter (and often it is transmitted as AFSK via USB mode on a radio). As mentioned above, the WSPR modulation scheme is very easily realized in microcontroller code, but timing becomes a bit more of a challenge. The on-board oscillator for a microcontroller simply does not have the ability to keep accurate time for very long, even if it is initially set accurately. An external RTC module is slightly better, but will still drift too far out of spec for WSPR after a short time. This has typically left a GPS module as the only viable solution for a microcontroller-based WSPR transmitter. While this is the ideal approach, plenty of experimenters don’t have GPS modules sitting around ready to be plugged into their Arduinos.

However, by using the Arduino Time library and a internet connected PC, a simple WSPR transmitter can be built that does not require a GPS module for timing nor a separate “big rig” radio with upper sideband capability. The Time library can use various synchronization sources, including grabbing a Unix time string over the Arduino’s USB-UART bridge. First, the PC must be accurately synchronized to a NTP time source. If you are using a Linux or Unix based OS, there are a variety of different methods for doing this, so search for documentation for your particular OS distribution. For a Windows PC, you’ll need to use a third-party program such as Dimension 4. In all cases, do not rely on the settings in your operating system’s time control panel for internet time. Typically, these services do not maintain good clock discipline and it’s not uncommon for your PC clock to drift far enough out of sync for your WSPR frames to be invalid after a few weeks.

The sending of the Unix time string to the Arduino can be handled by a variety of different programming and scripting languages. Python is the preferred scripting language for such tasks here at Etherkit, so we’ll provide a simple example Python script below, but the same thing could be accomplished in many different ways. The firmware in the Arduino will send an ASCII bell character to the host PC when it needs to get a Unix timestamp for synchronization, so the program simply needs to open the serial port of the Arduino’s USB-UART bridge, wait for an incoming ASCII bell, and then send back a properly formatted Unix timestamp. When the Arduino is properly synchronized, it will light up the LED on pin 13 to let you know. Typically you just need to plug the Arduino into your PC, execute the time synchronization script on your PC (python ntpserial.py), and then the pin 13 LED should light up within a few seconds to let you know that the beacon transmitter is ready to go.

Before loading the firmware onto the Arduino, be sure to change the callsign (6 characters or fewer) and locator (exactly 4 characters) variables to the proper values for your station (and perhaps the dBm if you use an amplifier). Set the frequency to any one that you like within the tuning range of the Si5351 by setting the freq variable. You’ll also want to be sure to have properly frequency calibrated your Si5351 and use the correction factor in the CORRECTION define near the top of the firmware file. The Etherkit JTEncode library takes care of generating the correct WSPR symbols for you, so there’s no need to have the PC use the wsprcode application for this. The if block at the end of the loop() function determines when the beacon will transmit. It is set to transmit every 10th minute of the hour, but this can be tweaked by changing the modulo math in that if statement.

Since the Si5351 output is a square wave, make sure you properly low-pass filter the output before connecting it to an antenna for transmission (you can find tables for low-pass filter generation in a variety of places, including the ARRL Handbook). You may also wish to connect a current-limited LED to pin 12, as this pin will go high to indicate when the beacon is transmitting.

While 10 milliwatts is an awfully sparse amount of power, due to the robust WSPR scheme, you can get spots with that power level and an average HF antenna. As a demonstration at the NT7S shack, we set the beacon to transmit on 20 meters and let it run for 24 hours. Conditions weren’t great, but we did manage to get spotted, especially during the local twilight hours. The antenna here is a basic double (ZS6BKW) up about 12 meters or so.

Selection_103

As you can see, 10 milliwatts on 20 meters WSPR was about to reach out to an area about 3000 km distance, which isn’t bad, all things considered.

Selection_104

With some amplification to half a watt or so, it would be very easy to get spots, but there’s fun in seeing how far you can send a flea-powered signal and still have it be perfectly decoded (watch for our upcoming 500 mW linear amplifier, which would be a perfect accompaniment to this project). There’s plenty of areas where this project could be expanded, so have fun hacking this simple example into something even more useful.

Block Diagram

Bill of Materials

Item Quantity
Arduino Uno (can substitute other variants) 1
Etherkit Si5351A Breakout Board 1
Low Pass Filter 1
Amplifer (optional) 1
LED (optional) 1
470 ohm 0.25 W resistor (optional) 1
RF connectors of choice

Wiring

A transmit LED indicator can be wired with a 470 ohm current limiting resistor in series by connecting to pin 12.

Terminal Arduino Uno Pin
Si5351 SCL A5
Si5351 SDA A4
Optional LED/resistor 12/GND
Si5351 5V 5V
Si5351 GND GND

Usage

Simply load the sketch onto your Arduino Uno, connect the power and I2C lines from the Uno to the Si5351A Breakout Board and then connect an appropriate low-pass filter to the output of the Si5351A Breakout Board CLK0 (or the output of the amplifier, if you are using one). Connect the output of the low-pass filter to a dummy load, then provide power to the Uno, Si5351A Breakout Board, and amplifier (if applicable).

Connect the Arduino USB to your PC and then run the provided Python time synchronization script:
python ntpserial.py
Once the Arduino is able to get a valid timestamp from the PC, the pin 13 LED will light and your beacon will be in transmission mode.

Use your favorite WSPR program and a PC-connected receiver to monitor your transmission in order to ensure that your setup is working correctly. Once you are satisfied that is the case, connect the output of the low-pass filter to an antenna in order to transmit your WSPR transmitter on the air. Don’t forget to change your callsign and the grid locator in the Arduino sketch before you put it on the air.

Extending the Transmitter

With only about 10 to 20 mW of output power, it will be tough to hear this transmitter barefoot, so some sort of amplifier would be very useful to bring the output level to a point where you can reasonably expect to be heard. In the near future, we intend to publish an example design for a linear amplifier that will bring the output power up to 500 mW, and will update this post with the link to it when it is ready.

If you have a GPS module with a serial UART available, you can bypass the PC connection entirely and have the Time library consume time data from the GPS. See the TimeGPS example sketch provided with the Arduino Time library for an example of how to do this.

Since this project uses a connection to an internet-connected PC, there’s no reason why it could not be used in an Internet of Things fashion and be controlled via LAN or over the Internet. This would give you the ability to be a remote control operator, so that you can be away from the transmitter and still maintain control over it.

Arduino Sketch and Python Script

Required Libraries

All of the required libraries are available through the Library Manager in recent versions of the Arduino IDE. This is the preferred method for obtaining the libraries, although the Si5351Arduino and JTEncode libraries can be manually installed by downloading ZIP files from the links below.

Si5351Arduino
JTEncode
Time
Wire

Links

Si5351Arduino Library on GitHub
JTEncode Library on GitHub
Si5351_WSPR.ino sketch on Gist




Arduino FSQ Beacon on the Si5351A Breakout Board

A new digital mode by the name of FSQ has arrived on the scene lately, and it looks quite interesting. The mode has received some recent attention as it was featured in an article written by one of its developers, Murray Greenman ZL1BPU, in the Sep. 2015 issue of QST. According to ZL1BPU’s FSQ website:

FSQ is a Fast Simple QSO mode designed specifically for HF. It works well under NVIS and sunrise/sunset conditions on the lower bands, and also works well for short skip and grey-line on higher bands. It can also be used on VHF FM, and clearly has a much wider useful range of operating conditions that other more conventional digital modes. FSQ transmission is also well within the capability of micro-controller based devices for low-power propagation transmissions (MEPT and telemetry).

The QST article describes the modulation scheme as 33-FSK, with the inclusion of Incremental Frequency Keying (meaning that an offset of +1 tone is added to each new symbol). The symbol table is varicode and designed to take advantage of the number of tones available so that each lowercase letter is encoded as a single tone, while the rest of the characters are encoded as two consecutive tones. As mentioned in a previous app note, the Si5351 is quite easily used to implement modulation based on FSK at modest rates. Since the author specifically mentioned that FSQ transmission is within the capability of microcontrollers for MEPT and telemetry purposes, it looked like fun to implement a simple Si5351A FSQ transmitter with an Arduino.

The basic hardware configuration is identical to that used in the Si5351 Feld Hell beacon. The Arduino firmware from that project was also used as a starting point for this firmware, as it already has a lot of the basic program structure (such as a timer for the modulation rate and a multi-symbol lookup table). Not knowing how well the mode would work under QRP or QRPp conditions, for my on-air trials of this transmitter, I decided to use both my 500 mW linear amplifier and my 20 W linear amplifier in order to give myself a good chance of being heard by others. You can see the setup in the photo featured at the top of the post. The Arduino and Si5351A Breakout Board are at the left, followed by the 500 mW linear amp with a low-pass filter on the output, feeding into the 20 W linear amp with another low-pass filter on the output.

After doing quite a bit of testing on a dummy load and receiving the transmitter signal on my main station rig and fldigi, I put the FSQ transmitter on the air on 23 August 2015 and asked for QSLs from Twitter hams who wouldn’t mind monitoring 7.104 MHz for my signal. The beacon was set to send a sounding transmission every 5 minutes on the main designated 40 meter FSQ frequency. It didn’t take too long before I received a couple of reception reports for the transmitter from hams at a decent distance from me.

https://twitter.com/wd3c/status/635637565337542656

https://twitter.com/wm6h/status/635638291086340096

In fact, it worked a bit too well, as I had someone calling me for a QSO and then asking why I wasn’t responding! The only reason that I knew this was because I left fldigi running to monitor my own signal and enough of the other ham’s signal leaked through my antenna switch that I was able to get a print in fldigi!

fldigi - Hamlib IC-718 - NT7S_001

Which leads to an important consideration for you if you decide to try this new mode in a transmit-only fashion: as of yet, I have not seen a protocol for MEPT/telemetry uses of FSQ so I cannot advise you of the proper way of conducting such transmissions. My current recommendation is that you make it clear that your transmission is a test or beacon transmission so that others will not try to call you. Better yet, if you have others who are working with you, it would probably be prudent to QSY a bit so as not to be clogging up the main channel with your messages. And of course, never leave your transmitter running unattended if you are in doubt of the legality of such operation in your country.

Since ZL1BPU did mention the use of FSQ in MEPT/telemetry applications, I do hope to get some clarification from him and other developers on the proper protocol soon. I believe that FSQ could have some good potential to be used in such applications due to the message format used and the lack of time synchronization needed (like WSPR and JT65/JT9 have). Based on the small amount of QSO operation of FSQ that I have done so far, I would recommend a 2nd FSQ channel near the main channel that is devoted to MEPT and telemetry. A couple of extensions to the message format specifically for MEPT messages and for telemetry (such as perhaps APRS over FSQ) would also very extremely handy.

Block Diagram

Si5351FeldHellBockDiagram

Bill of Materials

Item Quantity
Arduino Uno (can substitute other variants) 1
Etherkit Si5351A Breakout Board 1
Low Pass Filter 1
Amplifer (optional) 1
RF connectors of choice

Wiring

Terminal Arduino Uno Pin
Si5351 SCL A5
Si5351 SDA A4
Si5351 5V 5V
Si5351 GND GND

Usage

Simply load the sketch onto your Arduino Uno, connect the power and I2C lines from the Uno to the Si5351A Breakout Board and then connect an appropriate low-pass filter to the output of the Si5351A Breakout Board CLK0 (or the output of the amplifier, if you are using one). Connect the output of the low-pass filter to a dummy load, then provide power to the Uno, Si5351A Breakout Board, and amplifier (if applicable). Then use your favorite digimode program and a PC-connected receiver to monitor your transmission in order to ensure that your setup is working correctly. Once you are satisfied that is the case, connect the output of the low-pass filter to an antenna in order to transmit your FSQ transmitter on the air. Don’t forget to change your callsign and the message in the Arduino sketch before you put it on the air.

Extending the Transmitter

With only about 10 to 20 mW of output power, it will be tough to hear this transmitter barefoot, so some sort of amplifier would be very useful to bring the output level to a point where you can reasonably expect to be heard. In the near future, we intend to publish an example design for a linear amplifier that will bring the output power up to 500 mW, and will update this post with the link to it when it is ready.

Arduino Sketch

Required Libraries

Si5351Arduino

Links

Si5351Arduino Library on GitHub
Si5351FSQ.ino sketch on Gist




Arduino Feld Hell Beacon on the Si5351A Breakout Board

The Si5351A is well-suited to generating digital modes which are based on frequency shift or on-off keying. One of the more venerable digital modes in our arsenal is Hellschreiber (or Feldhellschreiber, shortened to Feld Hell for the purposes of this post), which has enjoyed a modest bit of resurgence in recent years on the ham bands. Since Feld Hell is based off of on-off keying at a particular rate, it is fairly easily implemented with an Arduino Uno and the Si5351A Breakout Board. The code for this example is graciously provided by Robert Liesenfeld, AK6L, and is based on original code for a Feld Hell beacon using the AD9850 DDS from Mark VandeWettering, K6HX.

The Arduino sketch simply generates a repeating bit of Feld Hell text on any desired frequency within the output range of the Si5351. You may change the transmission frequency, beacon text, and transmission interval to customize the sketch for your own needs. Below, you can see an example of the sketch running here with a bit of wire connected to the Si5351A Breakout Board output as an antenna, and received on the main station rig, the Icom IC-718.

fldigi - NT7S_005

We have also recorded a short video of the setup in action, so that you can see how simple the basic setup is and how it looks and sounds when it is transmitting. The Si5351A can provide a maximum output power of approximately +10 to +13 dBm into a 50 Ω load, so this beacon transmitter will be quite low powered unless you add an amplifier to it (we’ll post a companion amplifier schematic soon).

https://www.youtube.com/watch?v=EFTvl3yxN88

Block Diagram

Si5351FeldHellBockDiagram

Bill of Materials

Item Quantity
Arduino Uno (can substitute other variants) 1
Etherkit Si5351A Breakout Board 1
Low Pass Filter 1
Amplifer (optional) 1
RF connectors of choice

Wiring

Terminal Arduino Uno Pin
Si5351 SCL A5
Si5351 SDA A4
Si5351 5V 5V
Si5351 GND GND

Usage

Simply load the sketch onto your Arduino Uno, connect the power and I2C lines from the Uno to the Si5351A Breakout Board and then connect an appropriate low-pass filter to the output of the Si5351A Breakout Board CLK0 (or the output of the amplifier, if you are using one). Connect the output of the low-pass filter to a dummy load, then provide power to the Uno, Si5351A Breakout Board, and amplifier (if applicable). Then use your favorite digimode program and a PC-connected receiver to monitor your transmission in order to ensure that your setup is working correctly. Once you are satisfied that is the case, connect the output of the low-pass filter to an antenna in order to transmit your Feld Hell beacon on the air.

Since the timing of the Feld Hell depends on the oscillator on the Arduino Uno, there’s a good chance that when you first run the sketch, the Feld Hell text will be skewed a bit more than you would like, simply based on the variation in the 16 MHz oscillators used in the Arduino Uno. In order to counter this, it is simplest to tweak the timer compare value used to trigger the modulation. This is the hexadecimal value 0xFF1A in line 189 of the sketch. Try tweaking this up or down a bit in order to get the timing right.

Extending the Transmitter

With only about 10 to 20 mW of output power, it will be tough to hear this beacon barefoot, so some sort of amplifier would be very useful to bring the output level to a point where you can reasonably expect to be heard. In the near future, we intend to publish an example design for a linear amplifier that will bring the output power up to 500 mW, and will update this post with the link to it when it is ready.

Arduino Sketch

Required Libraries

Si5351Arduino

Links

Si5351Arduino Library on GitHub
Feld_Hell_Si5351.ino sketch on Gist