examples/SISO_AMC_OFDM_node.cpp

//
// Copyright 2011-2013, Per Zetterberg, KITH 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 "SISO_AMC_OFDM_node.hpp"
#include <four_multi/four_multi.hpp>
#include <itpp/itcomm.h>
#include <itpp/stat/misc_stat.h>


SISO_AMC_OFDM_node::SISO_AMC_OFDM_node(float gain_rx, 
float gain_tx,uint32_t node_ix , double frequency,
                       bool same_antenna,
                                       uint32_t modulation_order, bool simulate, uint32_t codec_ix, bool chase,
double delta_time)
  : four_multi_node(buffer_size,1,0,true,same_antenna,node_ix,
               std::vector<std::string>(0),simulate,0)
{
 
  
   ivec reorder="0:20";
   ivec known_symbol_pos="10";
   ai.init(false,false,12,21,known_symbol_pos,reorder);

   d_modulation_order=modulation_order;
   d_codec_ix=codec_ix;
   d_chase=chase;
   d_delta_time=delta_time;

   word_length=38*5*2*4;
   amc.init(word_length,true);
   max_message_length=amc.codec_message_size(amc.no_of_codecs()-1);

   transmitted.set_length(word_length);
   soft_bit.set_length(word_length);
   input.set_length(max_message_length+1000);
   decoded_bits.set_length(max_message_length);
   
   symbols.set_length(word_length/2); // QPSK lowest modulation
   symbols_chase.set_length(word_length/2); // QPSK lowest modulation
   
   message_hat.set_length(max_message_length);
   transmitted.set_length(word_length);
   transmitted_hat.set_length(word_length);


   //amc.run_through_all_mcs(); // To see the performance of modulation&coding
   //exit(1);

   d_gain_rx=gain_rx;
   d_no_frames=4;
   d_node_ix=node_ix % 2;
   d_frame_ix=0;
   d_frequency=frequency;
   d_gain_tx=gain_tx;
   d_frame_ix=0;
   scaling_tx_signal=70000;

   waveform_rx.set_length(buffer_size);
   waveform_tx.set_length(buffer_size);
   waveform_rx.zeros();
   waveform_tx.zeros();
   
}


SISO_AMC_OFDM_node::~SISO_AMC_OFDM_node() {

};


frame_settings SISO_AMC_OFDM_node::node_init(void) {


  d_frame_ix=0;

  ber_i=0;  
  BER.set_length(d_no_frames*log2(d_modulation_order)/2);
  BERraw.set_length(d_no_frames*log2(d_modulation_order)/2);
  

  if (node_ix()==1) {
    return node_process(); // TX
  } else { //RX
    frame_settings frame;
    std::vector<double> gain_rx_vec(1);
    std::vector<double> gain_tx_vec(1);
    std::vector<double> freq_vec(1);
  
    gain_rx_vec[0]=d_gain_rx;
    gain_tx_vec[0]=d_gain_rx;
    freq_vec[0]=d_frequency;
    frame.what=RX;
    frame.gain_rx=gain_rx_vec;
    frame.gain_tx=gain_tx_vec;
    frame.time=0.0;
    frame.frequency=freq_vec;

    return frame;
  };

};




void SISO_AMC_OFDM_node::end_of_run(){
};

frame_settings SISO_AMC_OFDM_node::node_process(void) {


  frame_settings frame;
  std::vector<double> gain_rx_vec(1);
  std::vector<double> gain_tx_vec(1);
  std::vector<double> freq_vec(1);
  //bvec transmitted, input;
  //int codec_ix=0;

  //transmitted.set_length((ai.Ns-1)*ai.length_ix*qam.bits_per_symbol());
  //transmitted.set_length(10000);
  //input.set_length(block_length);
  gain_rx_vec[0]=d_gain_rx;
  gain_tx_vec[0]=d_gain_rx;
  freq_vec[0]=d_frequency;

  frame.frequency=freq_vec;
  frame.gain_rx=gain_rx_vec;
  frame.gain_tx=gain_tx_vec;

  d_frame_ix++;


  if (node_ix()==0) { /****** RX ***********/

      frame.time=d_frame_ix*d_delta_time;
      
      /* Data is available in d_rx_buffers[0] */

      std::cout << "Processing in the receiver \n";

      std::complex<int16_t> *p1;
      p1=(std::complex<int16_t> *) d_rx_buffers[0];
      for (uint32_t i1=0;i1<buffer_size;i1++) 
        waveform_rx[i1]=p1[i1];


      //amc.skip_symbols=0;
      int start_sample;
      if (d_simulate) {
         start_sample=shift_transmit_signal_samples+6;
      } else {
         start_sample=shift_transmit_signal_samples+6+55;
      };
      double rms_signalr;
      cvec h(ai.length_ix_all);

      ivec t2=ai.start_of_known_symbol();
      ai.estimate_channel(waveform_rx.mid(start_sample+t2(0),ai.Nfft)
                          ,noise_variance_norm,h,noise_variance); 

                        
      ai.demodulate(waveform_rx,symbols,start_sample,h,rms_signalr);     
      ai.de_interleave_symbols(symbols, d_frame_ix);

      #if 0
      if (d_frame_ix==1) {
        itpp::it_file d1;
        d1.open("d1.it");
        d1<< itpp::Name("waveform_rx") << waveform_rx;
        d1<< itpp::Name("symbols") << symbols;
        d1.close();
      };
      #endif


     if (d_frame_ix==1) {
        noise_variance_chase=noise_variance_norm;
        symbols_chase=symbols;
      } else {
        double c1,c2,c;

        c1=1/sqrt(noise_variance_chase);
        c2=1/sqrt(noise_variance_norm);
        c=c1+c2;
        c1=c1/c;
        c2=c2/c;

        symbols_chase=c1*symbols_chase+c2*symbols;
        noise_variance_chase=1/((1/noise_variance_chase)+
                                   (1/noise_variance_norm));
      };
    
      
      decode_rx_symbols(d_codec_ix,d_modulation_order,d_chase);
      frame.what=RX;

      if (d_frame_ix==(d_no_frames)) 
        frame.what=END;

      


  };



  if (node_ix()==1) { // TX


    frame.time=(d_frame_ix-1)*d_delta_time;
    std::cout << "Processing in the transmitter \n";
    
    waveform_tx.zeros();

    //RNG_reset(100+d_frame_ix);
    //cout << "i2=" << input << ";"  << endl;

    format_tx_symbols(d_codec_ix,d_modulation_order);
    ai.interleave_symbols(symbols, d_frame_ix);


    double rms_power=-10;
    ai.modulate(waveform_tx,symbols,shift_transmit_signal_samples,rms_power,
                ones_c(ai.length_ix_all));
    waveform_tx*=scaling_tx_signal;

    std::complex<int16_t> *p1;
    p1=(std::complex<int16_t> *) d_tx_buffers[0];
    for (uint32_t i1=0;i1<buffer_size;i1++) 
      p1[i1]=waveform_tx[i1];




    #if 0
    it_file d1;
    d1.open("d1.it");
    d1 << Name("symbols") << symbols ;
    d1<< Name("waveform_tx") << waveform_tx;
    d1.close();
    exit(1);
    #endif

    frame.what=TX;

    if (d_frame_ix==(d_no_frames+1)) 
      frame.what=END;
  };
  

  return frame;
  

}

void SISO_AMC_OFDM_node::format_tx_symbols(uint32_t codec_ix, uint32_t modulation_order) 
{

  cout << "codec_ix=" << codec_ix << endl;


  int l=amc.codec_message_size(codec_ix);


  seed=100;
  RNG_reset(100);
  //input.set_subvector(0,randb(l));
  amc.randb_thread_safe(0,l,input,&seed);
  amc.modulate(modulation_order,codec_ix,input.mid(0,l),
               transmitted,symbols,0) ;    


 


  if (modulation_order>15) {
      seed=110;
      RNG_reset(110);
      //input.set_subvector(0,randb(l));
      amc.randb_thread_safe(0,l,input,&seed);
      amc.modulate(modulation_order,codec_ix,input.mid(0,l),
                   transmitted,symbols,word_length/(log2(modulation_order))); 
  };

  if (modulation_order>63) {
      seed=120;
      RNG_reset(120);
      //input.set_subvector(0,randb(l));
      amc.randb_thread_safe(0,l,input,&seed);
      amc.modulate(modulation_order,codec_ix,input.mid(0,l),
                   transmitted,symbols,2*word_length/(log2(modulation_order)));
    
  };
  if (modulation_order>255) {
      //RNG_reset(130);
      seed=130;
      input.set_subvector(0,randb(l));
      amc.randb_thread_safe(0,l,input,&seed);
      amc.modulate(modulation_order,codec_ix,input.mid(0,l),
                   transmitted,symbols,3*word_length/(log2(modulation_order)));
  };

};


void SISO_AMC_OFDM_node::decode_rx_symbols(uint32_t codec_ix, uint32_t modulation_order,
bool use_chase_combining) 
{ 
  
  int l=amc.codec_message_size(codec_ix);


  RNG_reset(100);
  seed=100;
  //input.set_subvector(0,randb(l));
  amc.randb_thread_safe(0,l,input,&seed);
  amc.encode(codec_ix,input.mid(0,l),transmitted) ;


  if (use_chase_combining) {
    amc.demodulate(symbols_chase.mid(0,word_length/log2( modulation_order)),
                   noise_variance_chase,
                  modulation_order,codec_ix,message_hat,transmitted_hat);
  } else {
    amc.demodulate(symbols.mid(0,word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);

  };


  berc.clear();
  berc.count(transmitted,transmitted_hat);  
  BERraw[ber_i]=berc.get_errorrate();
  //cout << "BER(raw)=" << BER[0] << endl;
  berc.clear();
  berc.count(input.mid(0,l),message_hat.mid(0,l));  
  BER[ber_i]=berc.get_errorrate();
  //cout << "BER=" << BER[0] << endl;
  ber_i++;


  if (modulation_order>15) {
    RNG_reset(110);
    seed=110;
    //input.set_subvector(0,randb(l));
    amc.randb_thread_safe(0,l,input,&seed);
    amc.encode(codec_ix,input.mid(0,l),transmitted) ;

    if (use_chase_combining) {
      amc.demodulate(symbols_chase.mid(word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_chase,
                  modulation_order,codec_ix,message_hat,transmitted_hat);   
    } else {  
      amc.demodulate(symbols.mid(word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);
    };
      
    berc.clear();
    berc.count(transmitted,transmitted_hat);  
    BERraw[ber_i]=berc.get_errorrate();
    //cout << "BER(raw)=" << BER[0] << endl;
    berc.clear();
    berc.count(input.mid(0,l),message_hat.mid(0,l));  
    BER[ber_i]=berc.get_errorrate();
    //cout << "BER=" << BER[0] << endl;
    ber_i++;

  };

  if (modulation_order>63) {

      RNG_reset(120);
      seed=120;
      //input.set_subvector(0,randb(l));
      amc.randb_thread_safe(0,l,input,&seed);
      amc.encode(codec_ix,input.mid(0,l),transmitted) ;
      if (use_chase_combining) 
        amc.demodulate(symbols_chase.mid(2*word_length
                                         /log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_chase,
                  modulation_order,codec_ix,message_hat,transmitted_hat);
      else
        amc.demodulate(symbols.mid(2*word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);
      
      berc.clear();
      berc.count(transmitted,transmitted_hat);  
      BERraw[ber_i]=berc.get_errorrate();
      //cout << "BER(raw)=" << BER[0] << endl;
      berc.clear();
      berc.count(input.mid(0,l),message_hat.mid(0,l));  
      BER[ber_i]=berc.get_errorrate();
      //cout << "BER=" << BER[0] << endl;
      ber_i++;



  };
  if (modulation_order>255) {
    
    RNG_reset(130);
    seed=130;

    //input.set_subvector(0,randb(l));
    amc.randb_thread_safe(0,l,input,&seed);
    amc.encode(codec_ix,input.mid(0,l),transmitted) ;
    if (use_chase_combining) 
      amc.demodulate(symbols_chase.mid(3*word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_chase,
                  modulation_order,codec_ix,message_hat,transmitted_hat);
    else
      amc.demodulate(symbols.mid(3*word_length/log2( modulation_order),
                                 word_length/log2( modulation_order)),
                          noise_variance_norm,
                  modulation_order,codec_ix,message_hat,transmitted_hat);
      
    berc.clear();
    berc.count(transmitted,transmitted_hat);  
    BERraw[ber_i]=berc.get_errorrate();
    //cout << "BER(raw)=" << BER[0] << endl;
    berc.clear();
    berc.count(input.mid(0,l),message_hat.mid(0,l));  
    BER[ber_i]=berc.get_errorrate();
    //cout << "BER=" << BER[0] << endl;
    ber_i++;



  };


};