receiver_chain.cpp

Go to the documentation of this file.

#include <iostream>
#include <functional>
#include <boost/date_time/posix_time/posix_time.hpp>

#include "receiver_chain.h"

namespace fun
{
    receiver_chain::receiver_chain()
    {
        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);
    }

    void receiver_chain::add_block(fun::block_base * block)
    {
        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));
    }

    void receiver_chain::run_block(int index, fun::block_base * 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]);
        }
    }

    std::vector<std::vector<unsigned char> > receiver_chain::process_samples(std::vector<std::complex<double> > samples)
    {
        // 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;
    }

}