IA1/IA1_receiver.cpp

//
// Copyright 2011-2012 KTH Royal Institute of Technology
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#include <fstream> 
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <iostream>
#include <uhd/types/clock_config.hpp>
#include <itpp/itbase.h>
#include <itpp/base/itfile.h>
#include <itpp/stat/misc_stat.h>
#include <itpp/itcomm.h>
#include <four_multi/AMC.hpp>
#include <four_multi/modem_OFDM1.hpp>
#include <itpp/stat/misc_stat.h>
#include <iostream>

namespace po = boost::program_options;
using namespace itpp;
using namespace std;




int UHD_SAFE_MAIN(int argc, char *argv[]){
    
 
    int s, stream_ix, codec_ix, modulation_order, frame_ix, scenario;
    bvec input,transmitted, transmitted1, transmitted2;
    cvec symbols, symbols_in;
    ivec known_pos_all;
    ivec reorder_all[10];
    //bool use_old_rand;


    //use_old_rand=true;
    string dir;
    
    if (!(uhd::set_thread_priority_safe(1,true))) {
      std::cout << "Problem setting thread priority" << std::endl;
      return 1;
    };

    //variables to be set by po
    std::vector<string> IP_addresses;
    
    // Internal variables // PZ
    uhd::clock_config_t my_clock_config; //PZ

    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
      ("help", "help message")
      ("fi", po::value<int>(&s)->default_value(0), "file index")
      ("s_ix", po::value<int>(&stream_ix)->default_value(0), "stream index")
      ("dir", po::value<string>(&dir)
       ->default_value("/usr/local/meas_data/"), "directory")
      ("c_ix", po::value<int>(&codec_ix)->default_value(3), "codec index")
      ("m_o", po::value<int>(&modulation_order)->default_value(16),
       "modulation order")
      ("f_ix", po::value<int>(&frame_ix)->default_value(1),
       "frame_index")
      ("sc", po::value<int>(&scenario)->default_value(1),"scenario")
    ;

    po::variables_map vm;
    po::store(po::parse_command_line(argc, argv, desc), vm);
    po::notify(vm);
    
    if (vm.count("help")){
        std::cout << boost::format("Ping pong  %s") % desc << std::endl;
        return ~0;
    }

    

    AMC amc;
    OFDM1 ai;
    int num_streams=3;
    int num_symbols=21;
    int num_payload_symbols_before_pilots=10;
    int num_payload_symbols_after_pilots=10;
    int num_antennas_in_system=6;
    

    known_pos_all.set_length(num_streams);
    for (int i1=0;i1<num_streams;i1++) {
      reorder_all[i1].set_length(num_symbols);
      known_pos_all(i1)=num_payload_symbols_before_pilots+i1;
      for (int i2=0;i2<num_payload_symbols_before_pilots;i2++) {
        (reorder_all[i1])(i2)=i2;
      };
      reorder_all[i1](num_payload_symbols_before_pilots)=num_payload_symbols_before_pilots+i1;
      for (int i2=0;i2<num_payload_symbols_after_pilots;i2++) {
       (reorder_all[i1])(i2+num_payload_symbols_before_pilots+1)=
         num_payload_symbols_before_pilots+num_streams+num_antennas_in_system+i2;
      };
    };
       
   
    #if 1
    itpp::it_file d1;
    d1.open("symbols_in.it");        
    d1 >> Name("symbolsc") >> symbols_in;
    d1.close();
    #endif
    

    // Estimate noise variance in symbols_in
    QAM modulation;
    modulation.set_M(modulation_order);
    double noise_variance_norm=0;
    cvec symbol(1), closest_constellation_point(1);
    for (int i1=0;i1<symbols_in.length();i1++) {
      symbol=symbols_in(i1);
      closest_constellation_point=modulation.modulate_bits(
                      modulation.demodulate_bits(symbol));
       
      noise_variance_norm+=sum(sqr(symbol-closest_constellation_point));
    };
    noise_variance_norm/=symbols_in.length();

    
    
    ivec known_pos(1);
    known_pos(0)=10;
    ai.init(false,false,12,21,known_pos,reorder_all[0]);
    

    int word_length=38*5*2*4;
    amc.init(word_length,true);
    input.set_length(amc.codec_message_size(amc.no_of_codecs()-1));
    transmitted.set_length(word_length);
    bvec transmitted_hat, message_hat;
    transmitted_hat.set_length(word_length);
    message_hat.set_length(amc.codec_message_size(amc.no_of_codecs()-1));
    symbols.set_length(38*20);
    int l=amc.codec_message_size(codec_ix);
    //amc.skip_symbols=0;

       
    #if 1
    
    RNG_reset(100+10000*stream_ix+s);
    input.set_subvector(0,randb(l));
    amc.modulate(modulation_order,codec_ix,input.mid(0,l),
                 transmitted,symbols,0) ;

    transmitted1=transmitted;    
    #endif


    #if 0
    stringstream filename;
    
    filename << "Vbig" << frame_ix-1 << "_" << scenario << ".it";
    itpp::it_file d2;
    d2.open(filename.str());
    
    
    stringstream variable_name;   
    variable_name.str(""); variable_name.clear();
    variable_name << "transmitted" << stream_ix << "_a";    
    d2 >> itpp::Name(variable_name.str()) >> transmitted;
    d2>> itpp::Name("symbol_interleave_matrix") >> ai.symbol_interleave_matrix;
    d2>> itpp::Name("symbol_de_interleave_matrix") >> 
      ai.symbol_de_interleave_matrix;

        
    variable_name.str(""); variable_name.clear();
    variable_name << "input" << stream_ix << "_a";
    d2 >> itpp::Name(variable_name.str()) >> input;
    
    #endif

    
    
    int n;
    n=word_length/log2( modulation_order);
    ai.de_interleave_symbols(symbols_in,stream_ix+frame_ix);     


    amc.demodulate(symbols_in.mid(0,n),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);


    
    BERC berc;
    vec BERraw(2), BER(2);
    berc.clear();
    berc.count(transmitted,transmitted_hat);
    BERraw(0)=berc.get_errorrate();
    berc.clear();
    berc.count(input,message_hat);
    BER(0)=berc.get_errorrate();


    
    if (modulation_order>15) {
      
      #if 1      
      RNG_reset(110+10000*stream_ix+s);
      input.set_subvector(0,randb(l));
      amc.modulate(modulation_order,codec_ix,input.mid(0,l),
                   transmitted,symbols,word_length/(log2(modulation_order)));
      transmitted2=transmitted;



      #endif

      #if 0
      variable_name.str(""); variable_name.clear();
      variable_name << "transmitted" << stream_ix << "_b";
      d2 >> itpp::Name(variable_name.str()) >> transmitted;
      variable_name.str(""); variable_name.clear();
      variable_name << "input" << stream_ix << "_b";
      d2 >> itpp::Name(variable_name.str()) >> input;
      #endif

      amc.demodulate(symbols_in.mid(n,n),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);

      berc.clear();
      berc.count(transmitted,transmitted_hat);
      BERraw(1)=berc.get_errorrate();
      berc.clear();
      berc.count(input,message_hat);
      BER(1)=berc.get_errorrate();
   

    };

    #if 0

    variable_name.str(""); variable_name.clear();
    variable_name << "symbols" << stream_ix;
    d2 >> itpp::Name(variable_name.str()) >> symbols;
    #endif
    ai.interleave_symbols(symbols,stream_ix+frame_ix);
    
    int shift_transmit_signal_samples=2000;
    cvec waveform_tx_temp(10000);
    double rms_power;
    

    ai.modulate(waveform_tx_temp,symbols,shift_transmit_signal_samples,
                rms_power,ones_c(ai.length_ix_all));

    float scaling_tx_signal=70000;
    waveform_tx_temp=scaling_tx_signal*waveform_tx_temp;
   
    d1.open("symbols_true.it");
    d1<< itpp::Name("symbols_true") << symbols;
    d1<< itpp::Name("BERraw") << BERraw;
    d1<< itpp::Name("BER") << BER;
    d1<< itpp::Name("transmitted1") << transmitted1;
    d1<< itpp::Name("transmitted2") << transmitted2;
    d1<< itpp::Name("waveform_tx_temp") << waveform_tx_temp;
    d1.close();
  
    return 0;

}
//08-59090500