During my recent dabble with a WSPR Beacon on the Arduino I created a C++ class to create the WSPR symbols given the callsign, location and power. The class is suitable for use on all platforms including an Arduino which is just as well, as that is what I wanted it for.
Thanks go to Mark VandeWettering (K6HX) for his work and to Andy Talbot (G4INT) for his help in unraveling the WSPR specification. Most of Andy’s work is reproduced in the code comments.
The code is presented as a C++ class that can be added to any C++ project or simply dropped into an Arduino sketch as a new ‘tab’. It is somewhat over commented but the aim is to try and clarify the WSPR encoding process in the context of a working example.
Error checking is sparse, therefore, please make sure that the callsign location and power are of the appropriate form.
WsprMessage.h
#ifndef WSPR_MESSAGE_H_
#define WSPR_MESSAGE_H_
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <arduino.h>
#define MSG_SIZE 162
class WsprMessage {
private:
int getCharValue(unsigned char ch);
int calculateParity(uint32_t ch);
unsigned char reverseAddress(unsigned char &reverseAddressIndex);
unsigned char reverseBits(unsigned char b);
void generateSymbols(char * callsign, char * location, int power);
public:
WsprMessage(char * callsign, char * location, int power);
unsigned char * symbols;
int size = MSG_SIZE;
};
#endif
WsprMessage.cpp
#include "WsprMessage.h"
/*
162 bit synchronisation vector stored in FLASH with PROGMEM. For
non-arduino simply remove the PROGMEM keyword
*/
const unsigned char sync[] PROGMEM = {
1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1,
0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1,
1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1,
0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1,
1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0,
0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0
};
WsprMessage::WsprMessage(char * callsign, char * location, int power) {
generateSymbols(callsign, location, power);
}
void WsprMessage::generateSymbols(char * callsign, char * location, int power) {
symbols = new unsigned char[MSG_SIZE];
//=================================================================
//call sign encoding (28 bits)
//=================================================================
/*
Tidy the call sign and check for 1 or 2 letter prefix.
Return a 6 char call sign with leading space if neccesary.
The third character is forced to be always a number, therefore a space is
prepended as necessary. For example, G6AML will become [sp]G6AML.
*/
char call[6];
for (int i = 0; i < 6; i++) call[i] = ' ';
if (isdigit(callsign[1])) {
for (int i = 0; i < (int)strlen(callsign); i++)
call[1 + i] = callsign[i];
}
else if (isdigit(callsign[2])) {
for (int i = 0; i < (int)strlen(callsign); i++)
call[i] = callsign[i];
}
/*
The 37 allowed characters are allocated values from 0 to 36 such that "0" - "9" give 0 - 9,
"A" to "Z" give 10 to 35 and [space] is given the value 36. Further coding rules on
callsigns mean that the final three characters (of the now padded out callsign) can only
be letters or [sp] so will only take the values 10 to 36. This allows the callsign
to be becompressed into a single integer 'N'. e.g.
N1 = [Ch 1] The first character can take on any of the 37 values including[sp],
N2 = N1 * 36 + [Ch 2] but the second character cannot then be a space so can have 36 values
N3 = N2 * 10 + [Ch 3] The third character must always be a number, so only 10 values are possible.
N4 = 27 * N3 + [Ch 4] - 10]
N5 = 27 * N4 + [Ch 5] - 10] Characters at the end cannot be numbers,
N6 = 27 * N5 + [Ch 6] - 10] so only 27 values are possible.
*/
uint32_t N = getCharValue(call[0]);
N *= 36; N += getCharValue(call[1]);
N *= 10; N += getCharValue(call[2]);
//the following can not be numbers so only 27 values are possible
N *= 27; N += getCharValue(call[3]) - 10;
N *= 27; N += getCharValue(call[4]) - 10;
N *= 27; N += getCharValue(call[5]) - 10;
//=================================================================
//location encoding (15 bits)
//=================================================================
/*
Designating the four locator characters as[Loc 1] to[Loc 4], the first two can each take
on the 18 values 'A' to 'R' only so are allocated numbers from 0 - 17. The second pair
can take only the values 0 - 9.
Another integer M is formed from :
M1 = (179 - 10 * [Loc 1] - [Loc 3]) * 180 + 10 * [Loc 2] + [Loc 4]
Which gives a range of values from 'AA00' = 32220 to 'RR99' = 179, which comfortably
fit into a 15 bit representation(215 = 32768), leaving spare codes for further
enhancements.
*/
uint32_t M1 = (179 - 10 * (location[0] - 'A') - (location[2] - '0')) * 180
+ (10 * (location[1] - 'A')) + (location[3] - '0');
//=================================================================
//power encoding (7 bits)
//=================================================================
/*
Power level, [Pwr] is taken as a value from 0 - 60. Although only certain values will work
with the WSJT / WSPR software(just those ending in 0, 3 or 7) any of the possible 61
values will be encoded; Illegal values are labeled when decoded. Power is encoded
into M by : M = M1 * 128 + [Pwr] + 64
*/
uint32_t M = M1 * 128 + power + 64;
//Summary: N has call sign (28 bits), M has location and power (22 bits)
//=================================================================
//convolution encoding and interleaving
//=================================================================
/*
The data is now expanded to add FEC with a convolutional
encoder.
The 81 bits (including the 31 trailing zeros) are are clocked simultaneously into the
right hand side, or least significant position, of a 32 bit shift register.
The shift register feeds an ExclusiveOR parity generator from feedback taps described
respectively by the 32 bit values 0xF2D05351 and 0xE4613C47.
Parity generation starts immediately the first bit appears in the registers and continues
until the registers are flushed by the final 31st zero being clocked into them.
Each of the 81 bits shifted in generates a parity bit
from each of the generators, a total of 162 bits in all.For each bit shifted in,
the resulting two parity bits are taken in turn, in the order the two feedback tap
positions values are given, to give a stream of 162 output bits.
The interleaving process is performed by taking a bit reversal of the address (array index)
to reorder them.
*/
int i;
uint32_t reg = 0;
unsigned char reverseAddressIndex = 0;
/*
We need to merge the source with the synchronisation bits
so transfer these accross first as this allows us to merge,
encode and interleave at the same time
*/
for (i = 0; i < MSG_SIZE; i++) {
//For non-arduino simply replace the following statement
//the one below
symbols[i] = pgm_read_byte(sync + i);
//symbols[i] = sync[i];
}
//move N (callsign) into the symbols byte array
for (i = 27; i >= 0; i--) {
//make room for the next register bit
reg <<= 1; // same as reg = reg << 1
//if bit 'i' of Nc (call sign) is a '1', set LSB of the register
//with the bitwise OR operator
if (N & ((uint32_t)1 << i)) reg |= 1;
/*
These next two lines add the parity data to the symbols array
but in the interleved order using a reverse of the address
the constant values (feedback taps) come directly from the
specification.
*/
symbols[reverseAddress(reverseAddressIndex)] += 2 * calculateParity(reg & 0xf2d05351L);
symbols[reverseAddress(reverseAddressIndex)] += 2 * calculateParity(reg & 0xe4613c47L);
}
//the register (reg) should be maintained ready for the next loop
//move M (location and power) into the symbols array in the same way
//as N above
for (i = 21; i >= 0; i--) {
reg <<= 1;
if (M & ((uint32_t)1 << i)) reg |= 1;
symbols[reverseAddress(reverseAddressIndex)] += 2 * calculateParity(reg & 0xf2d05351L);
symbols[reverseAddress(reverseAddressIndex)] += 2 * calculateParity(reg & 0xe4613c47L);
}
//pad with 31 zero bits
for (i = 30; i >= 0; i--) {
reg <<= 1;
symbols[reverseAddress(reverseAddressIndex)] += 2 * calculateParity(reg & 0xf2d05351L);
symbols[reverseAddress(reverseAddressIndex)] += 2 * calculateParity(reg & 0xe4613c47L);
}
}
int WsprMessage::getCharValue(unsigned char ch)
{
if (isdigit(ch)) return ch - '0';
if (isalpha(ch)) return 10 + toupper(ch) - 'A';
if (ch == ' ') return 36;
//if we get to here then call sign is no good
//throw exception;
return 0;
}
unsigned char WsprMessage::reverseAddress(unsigned char &reverseAddressIndex) {
/*
The index of each bit within the 162 bit message is passed
to this function and the bits are reversed.
E.g. 1 becomes 128 2 become 64 etc. Where the reversed
value is greater than 161 it is ignored and we move the index
on. For example bit 3 would becom 192 when reversed, therefore
we move on and use the value 4 for bit 3 and 5 for bit 4
and so on. e have 255 addresses we can use to get the 162 address
values we need.
*/
unsigned char result = reverseBits(reverseAddressIndex++);
while (result > 161) {
result = reverseBits(reverseAddressIndex++);
}
return result;
}
unsigned char WsprMessage::reverseBits(unsigned char b) {
/*
This function reverses the bits in a byte. I.e. 1 becomes
128, 2 becomes 64, 3 becomes 192 and so on.
The left four bits are swapped with the right four bits,
all adjacent pairs are swapped, all adjacent single bits
are swapped.
Thanks to http://stackoverflow.com/users/56338/sth for
this snippet of code
*/
b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
return b;
}
int WsprMessage::calculateParity(uint32_t x)
{
//generate XOR parity bit (returned as 0 or 1)
int even = 0;
while (x) {
even = 1 - even;
x = x & (x - 1);
}
return even;
}
