fun::frame_decoder Class Reference

The frame_decoder block. More...

#include <frame_decoder.h>

Inheritance diagram for fun::frame_decoder:

Public Member Functions
	frame_decoder ()
	Constructor for frame_decoder block. More...
virtual void	work ()
	Signal processing happens here. More...
Public Member Functions inherited from fun::block< tagged_vector< 48 >, std::vector< unsigned char > >
	block (std::string block_name)
	constructor More...
Public Member Functions inherited from fun::block_base
	block_base (std::string block_name)
	block_base constructor More...

Private Attributes
FrameData	m_current_frame
	Current frame that is being decoded. More...

Additional Inherited Members
Public Attributes inherited from fun::block< tagged_vector< 48 >, std::vector< unsigned char > >
std::vector< tagged_vector< 48 > >	input_buffer
	input_buffer contains new input items to be consumed More...
std::vector< std::vector < unsigned char > >	output_buffer
	output_buffer is where the output items of the block should be placed More...

Detailed Description

The frame_decoder block.

Inputs tagged_vector<48> from phase_tracker block. Outputs std::vector<unsigned char> back to the receiver chain

The Frame Decoder block is in charge of decoding the frame header and then the frame body. This includes demodulating, deinterleaving, de-convolutional-coding, and descrambling. First these must all be done to the header so as to get the correct rate and length of the payload, then the payload must be decoded as well. If the block is succesful in decoding the frame as determined by an IEEE CRC-32 check the payload is passed into the output_buffer as unsigned char's or bytes.

Definition at line 80 of file frame_decoder.h.

Constructor & Destructor Documentation

fun::frame_decoder::frame_decoder

(

)

Constructor for frame_decoder block.

• Initializations:
  • m_current_frame -> Reset to a frame of 0 length with RATE_1_2_BPSK

Definition at line 30 of file frame_decoder.cpp.

References m_current_frame, fun::RATE_1_2_BPSK, and fun::FrameData::Reset().

                                 :
        block("frame_decoder"),
        m_current_frame(FrameData(RateParams(RATE_1_2_BPSK)))
    {
        m_current_frame.Reset(RateParams(RATE_1_2_BPSK), 0, 0);
    }

Member Function Documentation

void fun::frame_decoder::work ( )

virtual

Signal processing happens here.

When a start of frame is detected this block first attempts to decode the ppdu header. If that is successful as determined by a simple parity check on the header bits it then tries to decode the payload of the frame using the parameters it gathered from header. If that is successful as deteremined by an IEEE CRC-32 check, the decoded payload is passed to the output_buffer to be returned to the receive chain so that it can be passed up to the MAC layer.

Implements fun::block< tagged_vector< 48 >, std::vector< unsigned char > >.

Definition at line 45 of file frame_decoder.cpp.

References fun::ppdu::decode_data(), fun::ppdu::decode_header(), fun::ppdu::get_length(), fun::ppdu::get_num_symbols(), fun::ppdu::get_payload(), fun::ppdu::get_rate(), fun::block< tagged_vector< 48 >, std::vector< unsigned char > >::input_buffer, fun::FrameData::length, m_current_frame, fun::block< tagged_vector< 48 >, std::vector< unsigned char > >::output_buffer, fun::RateParams::rate, fun::FrameData::rate_params, fun::FrameData::Reset(), fun::FrameData::sample_count, fun::FrameData::samples, fun::FrameData::samples_copied, and fun::START_OF_FRAME.

    {
        if(input_buffer.size() == 0) return;
        output_buffer.resize(0);

        // Step through each 48 sample symbol
        for(int x = 0; x < input_buffer.size(); x++)
        {
            // Copy over available symbols
            if(m_current_frame.samples_copied < m_current_frame.sample_count)
            {
                memcpy(&m_current_frame.samples[m_current_frame.samples_copied], &input_buffer[x].samples[0], 48 * sizeof(std::complex<double>));
                m_current_frame.samples_copied += 48;
            }

            // Decode the frame if possible
            if(m_current_frame.samples_copied >= m_current_frame.sample_count && m_current_frame.sample_count != 0)
            {
                ppdu frame = ppdu(m_current_frame.rate_params.rate, m_current_frame.length);
                if(frame.decode_data(m_current_frame.samples))
                {
                    output_buffer.push_back(frame.get_payload());
                }
                m_current_frame.sample_count = 0;
            }

            // Look for a start of frame
            if(input_buffer[x].tag == START_OF_FRAME)
            {
                // Attempt to decode the header
                ppdu h = ppdu();
                std::vector<std::complex<double> > header_samples(48);
                memcpy(header_samples.data(), input_buffer[x].samples, 48 * sizeof(std::complex<double>));
                if(!h.decode_header(header_samples)) continue;

                // Calculate the frame sample count
                int length = h.get_length();
                RateParams rate_params = RateParams(h.get_rate());
                int frame_sample_count = h.get_num_symbols() * 48;

                // Start a new frame
                m_current_frame.Reset(rate_params, frame_sample_count, length);
                m_current_frame.samples.resize(h.get_num_symbols() * 48);
                continue;
            }
        }
    }

Member Data Documentation

FrameData fun::frame_decoder::m_current_frame

private

Current frame that is being decoded.

Definition at line 90 of file frame_decoder.h.

Referenced by frame_decoder(), and work().

---

The documentation for this class was generated from the following files:

• /home/benjamin/Documents/fun_ofdm/src/frame_decoder.h
• /home/benjamin/Documents/fun_ofdm/src/frame_decoder.cpp