The Receiver Chain class. More...

#include <receiver_chain.h>

Public Member Functions
	receiver_chain ()
	Constructor for receiver_chain. More...

std::vector< std::vector < unsigned char > >	process_samples (std::vector< std::complex< double > > samples)
	Processes the raw time domain samples. More...

Private Member Functions
void	add_block (fun::block_base *block)
	Adds block to the receiver call chain. More...

void	run_block (int index, fun::block_base *block)
	Runs the block by calling its work function. More...

Private Attributes
frame_detector *	m_frame_detector
	Detects start of frame using STS. More...

timing_sync *	m_timing_sync
	Aligns frame in time using LTS & some freq correction. More...

fft_symbols *	m_fft_symbols
	Forward FFT of symbols. More...

channel_est *	m_channel_est
	Channel estimation and equalization in freq domain. More...

phase_tracker *	m_phase_tracker
	Phase rotation tracking. More...

frame_decoder *	m_frame_decoder
	Frame decoding. More...

std::vector< std::thread >	m_threads
	Vector of threads - one for each block. More...

std::vector< sem_t >	m_wake_sems
	Vector of semaphores used to "wake up" each block. More...

std::vector< sem_t >	m_done_sems
	Vector of semaphores used to determine when the blocks are done. More...

Detailed Description

The Receiver Chain class.

Inputs raw complex doubles representing the base-band digitized time domain signal.

Outputs vector of correctly received payloads (MPDUs) which are themselves vectors of unsigned chars.

The Receiver Chain class is the main controller for the blocks that are used to receive and decode PHY layer frames. It holds the instances of each block and shifts the data through the receive chain as it is processed eventually returning the correctly received payloads (MPDUs) which can then be passed to the upper layers.

Definition at line 40 of file receiver_chain.h.

Constructor & Destructor Documentation

fun::receiver_chain::receiver_chain ( )

Constructor for receiver_chain.

-Initializes each receiver chain block:

Adds each block to the receiver chain.

Definition at line 29 of file receiver_chain.cpp.

References add_block(), m_channel_est, m_done_sems, m_fft_symbols, m_frame_decoder, m_frame_detector, m_phase_tracker, m_timing_sync, and m_wake_sems.

     {
         m_frame_detector = new frame_detector();
         m_timing_sync = new timing_sync();
         m_fft_symbols = new fft_symbols();
         m_channel_est = new channel_est();
         m_phase_tracker = new phase_tracker();
         m_frame_decoder = new frame_decoder();
 
         // We use semaphore references, so we don't
         // want them to move to a different memory location
         // if the vectors get resized
         m_wake_sems.reserve(100);
         m_done_sems.reserve(100);
 
         // Add the blocks to the receiver chain
         add_block(m_frame_detector);
         add_block(m_timing_sync);
         add_block(m_fft_symbols);
         add_block(m_channel_est);
         add_block(m_phase_tracker);
         add_block(m_frame_decoder);
     }

Member Function Documentation

void fun::receiver_chain::add_block ( fun::block_base * block)

private

Adds block to the receiver call chain.

Parameters

block A pointer to the block so that its work function can be called

The add_block function creates a wake & done semaphore for each block. It then creates a new thread for the block to run in and adds that thread to the thread vector for reference.

Definition at line 58 of file receiver_chain.cpp.

References m_done_sems, m_threads, m_wake_sems, and run_block().

Referenced by receiver_chain().

     {
         m_wake_sems.push_back(sem_t());
         m_done_sems.push_back(sem_t());
         int index = m_wake_sems.size() - 1;
         sem_init(&m_wake_sems[index], 0, 0);
         sem_init(&m_done_sems[index], 0, 0);
         m_threads.push_back(std::thread(&receiver_chain::run_block, this, index, block));
     }

std::vector< std::vector< unsigned char > > fun::receiver_chain::process_samples ( std::vector< std::complex< double > > samples)

Processes the raw time domain samples.

Parameters

samples A vector of received time-domain samples from the usrp block to pass to the receive chain for signal processing.

Returns: A vector of correctly received payloads where each payload is its own vector of unsigned chars.

This function is the main scheduler for the receive chain. It takes in raw complex samples from the usrp block and passes them first into the Frame Detector block's input buffer. It then unlocks each of the threads by posting to each block's "wake" semaphore. It then waits for each thread to post that it is done with that call to its work() function. Once all the threads are done it shifts the contents of each blocks output buffer to the input buffer of the next block in the chain and returns the contents of the Frame Decoder's output buffer.

Definition at line 106 of file receiver_chain.cpp.

References fun::block< I, O >::input_buffer, m_channel_est, m_done_sems, m_fft_symbols, m_frame_decoder, m_frame_detector, m_phase_tracker, m_timing_sync, m_wake_sems, and fun::block< I, O >::output_buffer.

Referenced by fun::receiver::receiver_chain_loop(), and test_sim().

     {
         // samples -> sync short in
         m_frame_detector->input_buffer.swap(samples);
 
         // Unlock the threads
         for(int x = 0; x < m_wake_sems.size(); x++) sem_post(&m_wake_sems[x]);
 
         // Wait for the threads to finish
         for(int x = 0; x < m_done_sems.size(); x++) sem_wait(&m_done_sems[x]);
 
         // Update the buffers
         m_timing_sync->input_buffer.swap(m_frame_detector->output_buffer);
         m_fft_symbols->input_buffer.swap(m_timing_sync->output_buffer);
         m_channel_est->input_buffer.swap(m_fft_symbols->output_buffer);
         m_phase_tracker->input_buffer.swap(m_channel_est->output_buffer);
         m_frame_decoder->input_buffer.swap(m_phase_tracker->output_buffer);
 
         // Return any completed packets
         return m_frame_decoder->output_buffer;
     }

void fun::receiver_chain::run_block	(	int	index,
		fun::block_base *	block
	)

private

Runs the block by calling its work function.

Parameters

index	the block's index for referencing the correct semaphores for that block.
block	A pointer to the block used as a handle to access its work() function.

The run_block function is the main thread for controlling the calls to each block's work function. This function is a forever loops that first waits for the wake_sempahore to post indicating its time for the block to "wake up" and process the data that has just been placed in its input_buffer by running its work() function. Then once, the work() function returns run_block posts to the done sempahore that the block has finished processing everything in the input_buffer. At this point it loops back around and waits for the block to be "woken up" again when the next set of input data is ready.

Definition at line 78 of file receiver_chain.cpp.

References m_done_sems, m_wake_sems, and fun::block_base::work().

Referenced by add_block().

     {
         while(1)
         {
             sem_wait(&m_wake_sems[index]);
 
             boost::posix_time::ptime start = boost::posix_time::microsec_clock::local_time();
             block->work();
             boost::posix_time::time_duration elapsed = boost::posix_time::microsec_clock::local_time() - start;
 
             if(elapsed.total_microseconds() > (2000 / 5e6 * 1e6))
             {
                 //std::cout << "! - " <<  block->name << std::endl;
             }
 
             sem_post(&m_done_sems[index]);
         }
     }

Member Data Documentation

channel_est* fun::receiver_chain::m_channel_est

private

Channel estimation and equalization in freq domain.

Definition at line 67 of file receiver_chain.h.

Referenced by process_samples(), and receiver_chain().

std::vector<sem_t> fun::receiver_chain::m_done_sems

private

Vector of semaphores used to determine when the blocks are done.

Definition at line 95 of file receiver_chain.h.

Referenced by add_block(), process_samples(), receiver_chain(), and run_block().

fft_symbols* fun::receiver_chain::m_fft_symbols

private

Forward FFT of symbols.

Definition at line 66 of file receiver_chain.h.

Referenced by process_samples(), and receiver_chain().

frame_decoder* fun::receiver_chain::m_frame_decoder

private

Frame decoding.

Definition at line 69 of file receiver_chain.h.

Referenced by process_samples(), and receiver_chain().

frame_detector* fun::receiver_chain::m_frame_detector

private

Detects start of frame using STS.

Definition at line 64 of file receiver_chain.h.

Referenced by process_samples(), and receiver_chain().

phase_tracker* fun::receiver_chain::m_phase_tracker

private

Phase rotation tracking.

Definition at line 68 of file receiver_chain.h.

Referenced by process_samples(), and receiver_chain().

std::vector<std::thread> fun::receiver_chain::m_threads

private

Vector of threads - one for each block.

Definition at line 89 of file receiver_chain.h.

Referenced by add_block().

timing_sync* fun::receiver_chain::m_timing_sync

private

Aligns frame in time using LTS & some freq correction.

Definition at line 65 of file receiver_chain.h.

Referenced by process_samples(), and receiver_chain().

std::vector<sem_t> fun::receiver_chain::m_wake_sems

private

Vector of semaphores used to "wake up" each block.

Definition at line 92 of file receiver_chain.h.

Referenced by add_block(), process_samples(), receiver_chain(), and run_block().

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

/home/benjamin/Documents/fun_ofdm/src/receiver_chain.h
/home/benjamin/Documents/fun_ofdm/src/receiver_chain.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation