The ppdu class. More...

#include <ppdu.h>

Public Member Functions
	ppdu ()
	Default constructor for empty ppdu. More...

	ppdu (Rate rate, int length)
	Constructor for ppdu with rate and length known. More...

	ppdu (std::vector< unsigned char > payload, Rate rate)
	Constructor for ppdu with payload and Rate known. More...

std::vector< std::complex < double > >	encode ()
	Public interface for encoding a ppdu. More...

bool	decode_header (std::vector< std::complex< double > > samples)
	Public interface for decoding a plcp_header. More...

bool	decode_data (std::vector< std::complex< double > > samples)
	Public interface for decoding the PHY payload into a PPDU. More...

Rate	get_rate ()
	Get this PPDU's PHY tx rate. More...

int	get_length ()
	Get this PPDU's payload length. More...

int	get_num_symbols ()
	Get the number of OFDM symbols in this PPDU. More...

std::vector< unsigned char >	get_payload ()
	Get the payload of this PPDU. More...

Private Member Functions
std::vector< std::complex < double > >	encoder_header ()
	Encodes this PPDU's header. The header is always encoded with BPSK modulation and 1/2 rate convolutional code. More...

std::vector< std::complex < double > >	encode_data ()
	Encodes this PPDU's payload. The payload is encoded at the rate specified in the header.rate field. More...

Private Attributes
plcp_header	header
	This PPDU's header parameters. More...

std::vector< unsigned char >	payload
	This PPDU's payload. More...

Detailed Description

The ppdu class.

The ppdu class is a container for a ppdu which is made up of a PHY Header, otherwise known as a PLCP Header, and a payload of bytes. The class also has functions for encoding and decoding the header and payload based on the PHY transmission rates.

Definition at line 85 of file ppdu.h.

Constructor & Destructor Documentation

fun::ppdu::ppdu ( )

Default constructor for empty ppdu.

This constructor creates an empty PPDU with the default/empty plcp_header constructor

Definition at line 26 of file ppdu.cpp.

References header, MAX_FRAME_SIZE, and payload.

     {
         header = plcp_header();
         payload.reserve(MAX_FRAME_SIZE);
     }

fun::ppdu::ppdu	(	Rate	rate,
		int	length
	)

Constructor for ppdu with rate and length known.

Parameters

rate	PHY Rate for this frame.
length	Length of payload in bytes.

This constructor creates a PPDU with a header, but no payload field.

Definition at line 35 of file ppdu.cpp.

References fun::RateParams::dbps, header, MAX_FRAME_SIZE, and payload.

     {
         RateParams rate_params = RateParams(rate);
         int num_symbols = std::ceil(
                 double((16 /* service */ + 8 * (length + 4 /* CRC */) + 6 /* tail */)) /
                 double(rate_params.dbps));
         header = plcp_header(rate, length, num_symbols);
         payload.reserve(MAX_FRAME_SIZE);
     }

fun::ppdu::ppdu	(	std::vector< unsigned char >	payload,
		Rate	rate
	)

Constructor for ppdu with payload and Rate known.

Parameters

payload	The payload/data/MPDU to be transmitted.
rate	The PHY rate for this frame.

This constructor creates a complete PPDU with header and payload.

Definition at line 49 of file ppdu.cpp.

References fun::RateParams::dbps, and header.

                                                           :
         payload(payload)
     {
         RateParams rate_params = RateParams(rate);
         int length = payload.size();
         int num_symbols = std::ceil(
                 double((16 /* service */ + 8 * (length + 4 /* CRC */) + 6 /* tail */)) /
                 double(rate_params.dbps));
 
         header = plcp_header(rate, length, num_symbols);
     }

Member Function Documentation

bool fun::ppdu::decode_data ( std::vector< std::complex< double > > samples)

Public interface for decoding the PHY payload into a PPDU.

Parameters

samples Complex samples representing the encoded payload symbols.

Returns: boolean of whether decoding the payload was successful or not based on calculating and comparing the IEEE CRC-32 appended to the end of the payload. If successful the object's payload field is populated with the decoded payload/MPDU.

Definition at line 223 of file ppdu.cpp.

References fun::viterbi::conv_decode(), fun::RateParams::dbps, fun::interleaver::deinterleave(), fun::modulator::demodulate(), fun::puncturer::depuncture(), header, fun::plcp_header::length, payload, fun::plcp_header::rate, and fun::plcp_header::service.

Referenced by fun::frame_decoder::work().

     {
         // Get the RateParams
         RateParams rate_params = RateParams(header.rate);
 
         // Calculate the number of symbols
         int num_symbols = std::ceil(
                 double((16 /* service */ + 8 * (header.length + 4 /* CRC */) + 6 /* tail */)) /
                 double(rate_params.dbps));
 
         // Calculate the number of data bits/bytes (including padding bits)
         int num_data_bits = num_symbols * rate_params.dbps;
         int num_data_bytes = num_data_bits / 8;
 
         // Demodulate the data
         std::vector<unsigned char> demodulated = modulator::demodulate(samples, header.rate);
 
         // Deinterleave the data
         std::vector<unsigned char> deinterleaved = interleaver::deinterleave(demodulated);
 
         // Depuncture the data
         std::vector<unsigned char> depunctured = puncturer::depuncture(deinterleaved, header.rate);
 
         // Convolutionally decode the data
         int data_bits = 16 /* service */ + (header.length + 4 /* CRC */) * 8 + 6 /* tail bits */;
         int data_bytes = data_bits / 8 + 1;
         data_bits = num_data_bits - 6;
         data_bytes = num_data_bytes;
         std::vector<unsigned char> decoded(data_bytes);
         viterbi v;
         v.conv_decode(&depunctured[0], &decoded[0], data_bits);
 
         // Descramble the data
         std::vector<unsigned char> descrambled(num_data_bytes+1, 0);
         int state = 93, feedback = 0;
         for(int x = 0; x < num_data_bytes; x++)
         {
            feedback = (!!(state & 64)) ^ (!!(state & 8));
            descrambled[x] = feedback ^ decoded[x];
            state = ((state << 1) & 0x7E) | feedback;
         }
         decoded.swap(descrambled);
 
         // Calculate the CRC
         boost::crc_32_type crc;
         crc.process_bytes(&decoded[0], 2 + header.length);
         unsigned int calculated_crc = crc.checksum();
         unsigned int given_crc = 0;
         memcpy(&given_crc, &decoded[2 + header.length], 4);
 
         // Verify the CRC
         if(given_crc != calculated_crc)
         {
             std::cerr << "Invalid CRC (length " << header.length << ")" << std::endl;
             // Indicate failure
             return false;
         }
         else
         {
             // Copy the payload
     //        std::vector<unsigned char> payload(length);
             payload.resize(header.length);
             memcpy(&payload[0], &decoded[2 /* skip the service field */], header.length);
 
             // Fill the output values
     //        data_out.rate = rate;
             memcpy(&header.service, &decoded[0], 2);
     //        data_out.length = length;
             // Indicate success
             return true;
         }
 
     }

bool fun::ppdu::decode_header ( std::vector< std::complex< double > > samples)

Public interface for decoding a plcp_header.

Parameters

samples Complex samples representing the encoded header symbol.

Returns: boolean of whether decoding the header was successful or not based on checking/comparing the 1 bit parity field in the header. If successful the object's header field is populated appropriately with the decoded fields.

Definition at line 168 of file ppdu.cpp.

References fun::viterbi::conv_decode(), fun::RateParams::dbps, fun::interleaver::deinterleave(), fun::modulator::demodulate(), fun::RateParams::FromRateField(), header, fun::plcp_header::length, fun::plcp_header::num_symbols, fun::parity(), fun::plcp_header::rate, fun::RateParams::rate, fun::RATE_1_2_BPSK, and fun::VALID_RATES.

Referenced by fun::frame_decoder::work().

     {
         assert(samples.size() == 48);
 
         // Demodulate the header
         std::vector<unsigned char> demodulated = modulator::demodulate(samples, RATE_1_2_BPSK);
 
         // Deinterleave the header
         std::vector<unsigned char> deinterleaved = interleaver::deinterleave(demodulated);
 
         // Convolutionally decode the header        
         std::vector<unsigned char> header_bytes(4);
         viterbi v;
         v.conv_decode(deinterleaved.data(), header_bytes.data(), 18 /* header is always 18 data bits */);
 
         // Verify header parity
         unsigned int header_field;
         memcpy(&header_field, &header_bytes[0], 3);
         header_field = htonl(header_field) >> 8;
         int par = parity(header_field);
         if(par == 1)
         {
             return false;
         }
 
         // Get the rate field and length
         unsigned char rate_field = ((header_field >> 19) & 0xF);
         unsigned int length = ((header_field >> 6) & 0xFFF);
 
         // Check for a valid rate
         bool valid_rate = false;
         for(int x = 0; x < VALID_RATES.size(); x++) if(VALID_RATES[x] == rate_field) valid_rate = true;
         if(!valid_rate)
         {
             return false;
         }
 
         // Calculate the number of symbols
         RateParams rate_params = RateParams::FromRateField(rate_field);
         int num_symbols = std::ceil(
                 double((16 /* service */ + 8 * (length + 4 /* CRC */) + 6 /* tail */)) /
                 double(rate_params.dbps));
 
         // Populate the header fields
         header.length = length;
         header.rate = RateParams::FromRateField(rate_field).rate;
         header.num_symbols = num_symbols;
 
         // Indicate success
         return true;
     }

std::vector< std::complex< double > > fun::ppdu::encode ( )

Public interface for encoding a ppdu.

Returns: Modulated data as a vector of complex doubles

Public wrapper for encoding the header & payload and concatenating them together into a PHY frame.

Definition at line 65 of file ppdu.cpp.

References encode_data(), and encoder_header().

Referenced by fun::frame_builder::build_frame().

     {
         std::vector<std::complex<double> > header_samples = encoder_header();
         std::vector<std::complex<double> > payload_samples = encode_data();
         std::vector<std::complex<double> > ppdu_samples = std::vector<std::complex<double> >(header_samples.size() + payload_samples.size());
         memcpy(&ppdu_samples[0], &header_samples[0], header_samples.size() * sizeof(std::complex<double>));
         memcpy(&ppdu_samples[48], payload_samples.data(), payload_samples.size() * sizeof(std::complex<double>));
         return ppdu_samples;
     }

std::vector< std::complex< double > > fun::ppdu::encode_data ( )

private

Encodes this PPDU's payload. The payload is encoded at the rate specified in the header.rate field.

Returns: The modulated data.

Definition at line 112 of file ppdu.cpp.

References fun::viterbi::conv_encode(), fun::RateParams::dbps, header, fun::interleaver::interleave(), fun::modulator::modulate(), payload, fun::puncturer::puncture(), and fun::plcp_header::rate.

Referenced by encode().

     {
         // Get the RateParams
         RateParams rate_params = RateParams(header.rate);
 
         // Calculate the number of symbols
         int num_symbols = std::ceil(
                 double((16 /* service */ + 8 * (payload.size() + 4 /* CRC */) + 6 /* tail */)) /
                 double(rate_params.dbps));
 
         // Calculate the number of data bits/bytes (including padding bits)
         int num_data_bits = num_symbols * rate_params.dbps;
         int num_data_bytes = num_data_bits / 8;
 
         unsigned short service_field = 0;
 
         // Concatenate the service and payload
         std::vector<unsigned char> data(num_data_bytes+1, 0);
         memcpy(&data[0], &service_field, 2);
         memcpy(&data[2], payload.data(), payload.size());
 
         // Calcualate and append the CRC
         boost::crc_32_type crc;
         crc.process_bytes(&data[0], 2 + payload.size());
         unsigned int calculated_crc = crc.checksum();
         memcpy(&data[2 + payload.size()], &calculated_crc, 4);
 
         // Scramble the data
         std::vector<unsigned char> scrambled(num_data_bytes+1, 0);
         int state = 93, feedback = 0;
         for(int x = 0; x < num_data_bytes; x++)
         {
            feedback = (!!(state & 64)) ^ (!!(state & 8));
            scrambled[x] = feedback ^ data[x];
            state = ((state << 1) & 0x7E) | feedback;
         }
         data.swap(scrambled);
 
         // Convolutionally encode the data
         std::vector<unsigned char> data_encoded(num_data_bits * 2, 0);
         viterbi v;
         v.conv_encode(&data[0], data_encoded.data(), num_data_bits-6);
 
         // Puncture the data
         std::vector<unsigned char> data_punctured = puncturer::puncture(data_encoded, header.rate);
 
         // Interleave the data
         std::vector<unsigned char> data_interleaved = interleaver::interleave(data_punctured);
 
         // Modulated the data
         std::vector<std::complex<double> > data_modulated = modulator::modulate(data_interleaved, header.rate);
 
         return data_modulated;
     }

std::vector< std::complex< double > > fun::ppdu::encoder_header ( )

private

Encodes this PPDU's header. The header is always encoded with BPSK modulation and 1/2 rate convolutional code.

Returns: The modulated header symbol.

Uses the rate_params to build the header. Note the header is NOT scrambled. Codes the header using a 1/2 convolutional code. Interleaves the header. And finally modulates the header using BPSK modulation.

Definition at line 81 of file ppdu.cpp.

References fun::viterbi::conv_encode(), header, fun::interleaver::interleave(), fun::plcp_header::length, fun::modulator::modulate(), fun::parity(), fun::plcp_header::rate, fun::RATE_1_2_BPSK, and fun::RateParams::rate_field.

Referenced by encode().

     {
         // Build the header from the rate field and length
         RateParams rate_params = RateParams(header.rate);
         unsigned int header_field = 0;
         header_field = ((rate_params.rate_field & 0xF) << 13) | (header.length & 0xFFF);
 
         // Set the parity bit and align
         if(parity(header_field) == 1) header_field |= 131072;
         header_field <<= 6;
 
         // Convert the header to a unsigned char array
         unsigned char header_bytes[4];
         unsigned int h = htonl(header_field) >> 8;
         memcpy(header_bytes, &h, 3);
 
         // Convolutionally encode the header
         std::vector<unsigned char> header_symbols(48 /* header is always a single 1/2 BPSK symbol */);
         viterbi v;
         v.conv_encode(header_bytes, &header_symbols[0], 18 /* header is always 18 data bits */);
 
         // Interleave the header
         std::vector<unsigned char> interleaved = interleaver::interleave(header_symbols);
 
         // Modulate the header
         std::vector<std::complex<double> > modulated = modulator::modulate(interleaved, RATE_1_2_BPSK);
 
         return modulated;
 
     }