The Encoding of the WAAS data signal is more complicated than the Navstar data as it incorporates FEC coding and CRC parity coding as well as a frame and preamble.

Each WAAS message is 250 data bits in length and 1 second in time. They consist of

- 8 bits of a Preamble
- 6 bits for message type (0-63)
- 212 bits for the message
- 24 Parity bits

The preamble is actually 24 bits long but is split in to three 8 bit words that repeat every 3 messages. The end of the message consists of 24 Parity bits calculated using a CRC algorithm applied to the first 226 bits of the message.

The resulting bit stream is then rate ½ convolutionally encoded with a Forward Error Correction (FEC) code. The convolutional coding is constraint length 7 as standard for Veterbi decoding, the G1 symbol is selected on the output of the first half of a 4 millisecond data bit resulting from the bitwise sum of the last 7 bits of the data stream OR'ed with Octal 171, for the G2 symbol Octal 133 is used.

The CRC algorithm is defined as follows in the WAAS definition documents.

The CRC word is calculated in the forward direction on the entire bit-oriented message, including the block header containing the preamble and message type identifier, and using a seed of 0. The sequence of 24 bits (p

_{1},p_{2},...,p_{24}) is generated from the sequence of information bits (m_{1},m_{2},.......,m_{226}). This is done by means of a code that is generated by the polynomial

g(X) = E^{24}_{i=0}

where g_{i}= 1 for i = 0, 1, 3, 4, 5, 6, 7, 10, 11, 14, 17, 18, 23, 24

g = 0 otherwise.This code is called CRC-24Q (Q for Qualcomm). The generator polynomial of this code is in the following form (using binary polynomial algebra):

g(X) = (1 + X)p(X)

where p(X) is the primitive and irreducible polynomial

p(X) = X^{23}+ X^{17}+ X^{13}+ X^{12}+ X^{11}+ X^{9}+ X^{8}+ X^{7}+ X^{5}+ X^{3}+ 1

When, by the application of the binay polynomial algebra, the above g(X) is divided into m(X)X^{24}, where the information sequence m(X) is expressed as

m(X) = m_{k}+ m_{k-1}X^{1}+ m_{k-2}X^{2}+.....+ m_{1}X^{k-1}the result is a quotient and a remainder R(X) of degree < 24. The bit sequence formed by this remainder represents the parity check sequence. parity bit p

_{i}, for any i from 1 to 24, is the coeffecient of X^{24-i}in R(X).

The section above is a direct extract from the WAAS DTFA-001 and for most of us is not very meaningful. So what does this mean in practice, if the first bit of the message is 1, we bitwise OR the first 25 bits of the message with g(X), the binary value of which is 1100001100100110011111011, (0x01864cfb in hexadecimal). Then we repeat this process starting with the next bit of the message, until the last bit of the message is reached. The resulting 24 bit value is the required parity code.

If you are unfamiliar with the notation used the following example should help clarify what happens in practice, you will see it is pretty simple.

for(bit=0;bit<226;bit++) { if(bit%8 == 0)shift += (unsigned int)data[byte++]; if((shift&0x80000000) == 0x80000000) { shift = shift ^ (CRC_POLY<<7); } shift = shift<<1; }

There is an example in the manual of a 250 bit data string including the correct parity, to enable one to validate your algorithm is correct.

Preamble, Message Id, IODF, IODP: Binary 11, followed by Hex: 182413 corrections: Hex: 003|c00|3c2|200|03f|4bc|000|3c0|03c|003|c00|03f|fd8

13 UDREI's: Hex: 0003cb240003f

Parity: Hex: a0f7dd

For an example using the full message to calculate the parity see here.

The resulting bit stream is rate ½ encoded, this means we produce two values from a single bit stream and we do that by bitwise ORing the bit stream with two different binary values. The constraint length is 7, this means that use a 7 digit binary value to bitwise OR with the next 7 bits of the bit stream.

for(bit=0;bit<256;bit++) { if(bit%8 == 0)byte++; next_bit = bit%8; shift += data[byte]>>(8 - next_bit); shift &= 0x80; sym1 = shift ^ 0x79; sym2 = shift ^ 0x5a shift = shift<<1; }

So we start by getting the next byte every 8 bits, we then move a bit at a time to the shift register, starting with the MSB or 7th bit and after we get to the 0th bit we move on to the next byte. Then for every new bit we clear out the current 8th bit and OR the remaining 7 bits with Convolution Polynomial A for output symbol G1 and Polynomial B for output symbol G2. For decoding the polynomials are in reverse bit order, (0x4f and 0x6d). In practise this is a continuous process and there is no break between messages.

The Waas message has several different types and data formats, also there is no guaranteed order of the messages.

- Message 0 - Don't use
- Message 1 - PRN Mask Assignments
- Message 2-5 - Fast Corrections
- Message 6 - Integrity Information
- Message 7 - Fast Correction Degradation factor
- Message 8 - Estimated RMS Error message
- Message 9 - GEO Navigation message
- Message 10 - Degradation Parameters
- Message 11 - Reserved for future messages
- Message 12 - WAAS Network time/UTC Offset Parameters
- Message 13-16- Reserved for future messages
- Message 17 - GEO Almanacs message
- Message 18 - Ionospheric grid point masks
- Message 19-23 - Reserved for future messages
- Message 24 - Mixed fast/long term satellite error corrections
- Message 25 - Long term satellite error corrections
- Message 26 - Ionospheric delay corrections
- Message 27 - Reserved (Service Message)
- Message 61 - Reserved for future messages
- Message 62 - Reserved (Internal Test Message)
- Message 63 - NULL Message

Back to Top of Page