IA1/IA1_super_realtime.cpp

//
// Copyright 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 <four_multi/get_usrp2_ip_addr.hpp>
#include <itpp/stat/misc_stat.h>
#include "IA1_node.hpp"
#include <iostream>
#include <four_multi/super_node.hpp>


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




int UHD_SAFE_MAIN(int argc, char *argv[]){


    std::vector<four_multi_node*> all_my_nodes1, all_my_nodes2;
    std::vector<four_multi_node*> all_my_nodes3, all_my_nodes4;
 
   
    #if 1
    if (!(uhd::set_thread_priority_safe(1,true))) {
      std::cout << "Problem setting thread priority" << std::endl;
      return 1;
    };
    #endif
    


    //variables to be set by po
    uint32_t super_node_ix, skip_ant;
    std::vector<string> IP_addresses;
    string IP_addresses_input_string;
    uint32_t start_time, no_runs;
    std::string dev_name, freq_str;
    itpp::vec freqs;
    std::string gains_str;
    itpp::vec gains; // IT++ class

    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
      ("help", "help message")
      ("super_node_ix", po::value<uint32_t>(&super_node_ix)->default_value(0), "node index")
      ("IP_addresses",po::value<string>(&IP_addresses_input_string)->default_value(""),"Backbone IP addresses of all nodes in order (space separated)")
        ("start_time",po::value<uint32_t>(&start_time)->default_value(0), "Start time (GPS ref) h*3600+m*60+s") 
        ("dev_name",po::value<std::string>(&dev_name)->default_value("/dev/ttyUSB0"), "Name of GPS device") 
        ("s",po::value<uint32_t>(&skip_ant)->default_value(0), "skip_ant") 
        ("freq",po::value<std::string>(&freq_str)->default_value("70e6 70e6 70e6 70e6 70e6 70e6"), "frequencies of super_node_ix=1")
        ("no_runs",po::value<uint32_t>(&no_runs)->default_value(1), "number of runs") 
         ("tx_gains",po::value<std::string>(&gains_str)->default_value("0 0 0 0 0 0"), 
             "set the transmitter gains")
    ;



    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;
    }

    IP_addresses_input_string="130.237.43.227 130.237.43.227 130.237.43.227";

    std::istringstream iss(IP_addresses_input_string);
    for (uint32_t i1=0;i1<20;i1++) {
      std::string subs;
      iss >> subs;
      if (subs.length()==0) break;
      IP_addresses.push_back(subs);
    };

    gains=gains_str.c_str();  

    double freq;
    std::vector<double> override_frequency;
    std::vector<double> override_gain_rx;
    std::vector<double> override_gain_tx;

    if (super_node_ix==0) {
      freq=2490e6;
      for (int i1=0;i1<6;i1++) {
        override_frequency.push_back(freq);
      };

    } else {
      freq=70e6;
      freqs=freq_str.c_str();
      override_frequency.push_back(freqs(0));
      override_frequency.push_back(freqs(0));
      override_frequency.push_back(freqs(1));
      override_frequency.push_back(freqs(1));
      override_frequency.push_back(freqs(2));
      override_frequency.push_back(freqs(2));

    };
    
    for (int i1=0;i1<6;i1++) {
      override_gain_rx.push_back(0);
      override_gain_tx.push_back(gains(i1));
    };
    //std::cout << "override_gain_tx=";
    for (int i1=0;i1<6;i1++) {
      std::cout << override_gain_tx[i1] << ",";
    };
    std::cout << std::endl;
    

    

    double offset_time=1.0;

    if (super_node_ix==0) {

      // scenario 1: IA
      IA1_node node0_IA(2,0,0,0,0,freq,true,IP_addresses,true,60,start_time,
                        false,1); 
      IA1_node node1_IA(2,0,0,0,1,freq,true,IP_addresses,true,60,start_time,
                        false,1); 
      IA1_node node2_IA(2,0,0,0,2,freq,true,IP_addresses,true,60,start_time,
                        false,1); 

      
      all_my_nodes1.push_back(&node0_IA);
      all_my_nodes1.push_back(&node1_IA);
      all_my_nodes1.push_back(&node2_IA);

      // Scenario 2: CoMP

      IA1_node node0_CoMP(6,0,0,0,0,freq,true,IP_addresses,true,
                          60,start_time,false,2); 
      node0_CoMP.offset_time=offset_time;
      all_my_nodes2.push_back(&node0_CoMP);


      // scenario 3: MIMO
      IA1_node node0_MIMO(2,0,0,0,0,freq,true,IP_addresses,true,60,start_time,
                        false,3); 
      IA1_node node1_MIMO(2,0,0,0,1,freq,true,IP_addresses,true,60,start_time,
                        false,3); 
      IA1_node node2_MIMO(2,0,0,0,2,freq,true,IP_addresses,true,60,start_time,
                        false,3); 

      all_my_nodes3.push_back(&node0_MIMO);
      all_my_nodes3.push_back(&node1_MIMO);
      all_my_nodes3.push_back(&node2_MIMO);


      // First run is with IA


      super_node my_super_node(6,0,true,false,skip_ant,
                               &all_my_nodes1,
                               override_gain_rx,
                               override_gain_tx,
                               override_frequency);

      usleep(0.1);
      my_super_node.wait_time_for_transmissions_to_finish=0.1; 


      for (uint32_t run_ix=0;run_ix<no_runs;run_ix++) {
      
         my_super_node.set_time_on_pps=true;
         my_super_node.set_nodes(&all_my_nodes1);
         my_super_node.run(dev_name.c_str(),start_time);
      
         // Second run with CoMP
         my_super_node.set_nodes(&all_my_nodes2);
         my_super_node.set_time_on_pps=false;
         my_super_node.skip_hw_set_during_init=true;
         my_super_node.run();

         // Third run with MIMO1
         node0_MIMO.MIMO_all_active=false;
         node1_MIMO.MIMO_all_active=false;
         node2_MIMO.MIMO_all_active=false;
         node0_MIMO.MIMO_active_tx_node_tx=0;
         node1_MIMO.MIMO_active_tx_node_tx=0;
         node2_MIMO.MIMO_active_tx_node_tx=0;
         node0_MIMO.offset_time=2*offset_time;
         node1_MIMO.offset_time=2*offset_time;
         node2_MIMO.offset_time=2*offset_time;
         my_super_node.set_nodes(&all_my_nodes3);
         my_super_node.run();

         // Fourth run with MIMO2
         node0_MIMO.offset_time=3*offset_time;
         node1_MIMO.offset_time=3*offset_time;
         node2_MIMO.offset_time=3*offset_time;
         node0_MIMO.MIMO_active_tx_node_tx=1;
         node1_MIMO.MIMO_active_tx_node_tx=1;
         node2_MIMO.MIMO_active_tx_node_tx=1;
         my_super_node.run();

         // Fifth run with MIMO3
         node0_MIMO.offset_time=4*offset_time;
         node1_MIMO.offset_time=4*offset_time;
         node2_MIMO.offset_time=4*offset_time;
         node0_MIMO.MIMO_active_tx_node_tx=2;
         node1_MIMO.MIMO_active_tx_node_tx=2;
         node2_MIMO.MIMO_active_tx_node_tx=2;
         my_super_node.run();

         // Sixth run with MIMO4
         node0_MIMO.offset_time=5*offset_time;
         node1_MIMO.offset_time=5*offset_time;
         node2_MIMO.offset_time=5*offset_time;
         node0_MIMO.MIMO_all_active=true;
         node1_MIMO.MIMO_all_active=true;
         node2_MIMO.MIMO_all_active=true;
         my_super_node.run();
         
         start_time+=60;

      };

    
    };
    if (super_node_ix==1) {

      vec MIMO1_BER, MIMO2_BER, MIMO3_BER;

      // Scenario 1: IA
      IA1_node node0_IA(2,0,0,0,3,freqs(0),true,IP_addresses,true,60,start_time,
                        false,1); 
      IA1_node node1_IA(2,0,0,0,4,freqs(1),true,IP_addresses,true,60,start_time,
                        false,1); 
      IA1_node node2_IA(2,0,0,0,5,freqs(2),true,IP_addresses,true,60,start_time,
                        false,1); 

    
      node0_IA.save_raw_input_on_file(5,"/usr/local/meas_data/IA_");
      node1_IA.save_raw_input_on_file(5,"/usr/local/meas_data/IA_");
      node2_IA.save_raw_input_on_file(5,"/usr/local/meas_data/IA_");

      all_my_nodes1.push_back(&node0_IA);
      all_my_nodes1.push_back(&node1_IA);
      all_my_nodes1.push_back(&node2_IA);

      // Scenario 2: CoMP
      IA1_node node0_CoMP(2,0,0,0,1,freq,true,IP_addresses,true,
                          60,start_time,false,2); 
      IA1_node node1_CoMP(2,0,0,0,2,freq,true,IP_addresses,true,
                          60,start_time,false,2); 
      IA1_node node2_CoMP(2,0,0,0,3,freq,true,IP_addresses,true,
                          60,start_time,false,2); 
      node0_CoMP.offset_time=offset_time;
      node1_CoMP.offset_time=offset_time;
      node2_CoMP.offset_time=offset_time;

    
      node0_CoMP.save_raw_input_on_file(5,"/usr/local/meas_data/CoMP_");
      node1_CoMP.save_raw_input_on_file(5,"/usr/local/meas_data/CoMP_");
      node2_CoMP.save_raw_input_on_file(5,"/usr/local/meas_data/CoMP_");

      all_my_nodes2.push_back(&node0_CoMP);
      all_my_nodes2.push_back(&node1_CoMP);
      all_my_nodes2.push_back(&node2_CoMP);


      // Scenario 3: MIMO
      IA1_node node0_MIMO(2,0,0,0,3,freq,true,IP_addresses,true,
                          60,start_time,false,3); 
      IA1_node node1_MIMO(2,0,0,0,4,freq,true,IP_addresses,true,
                          60,start_time,false,3); 
      IA1_node node2_MIMO(2,0,0,0,5,freq,true,IP_addresses,true,
                          60,start_time,false,3); 

      
      all_my_nodes3.push_back(&node0_MIMO);
      all_my_nodes3.push_back(&node1_MIMO);
      all_my_nodes3.push_back(&node2_MIMO);


      // First run is with IA
      //super_node my_super_node(6,0,true,false,0,IP_addresses,0,&all_my_nodes1);

      super_node my_super_node(6,0,true,false,0,&all_my_nodes1);


      my_super_node.wait_time_for_transmissions_to_finish=0.1;


      for (uint32_t run_ix=0;run_ix<no_runs;run_ix++) {

        gps_wait_until(dev_name.c_str(),start_time);
      
        my_super_node.set_nodes(&all_my_nodes1);
        my_super_node.set_time_on_pps=true;
        my_super_node.run();

        cout << "node0_IA.BER=" << node0_IA.BERraw << endl;
        cout << "node1_IA.BER=" << node1_IA.BERraw << endl;
        cout << "node2_IA.BER=" << node2_IA.BERraw << endl;

        // Second run with CoMP
        my_super_node.set_nodes(&all_my_nodes2);
        my_super_node.set_time_on_pps=false;
        my_super_node.skip_hw_set_during_init=true;
        my_super_node.run();

        cout << "node0_CoMP.BER=" << node0_CoMP.BERraw << endl;
        cout << "node1_CoMP.BER=" << node1_CoMP.BERraw << endl;
        cout << "node2_CoMP.BER=" << node2_CoMP.BERraw << endl;


        // Third run with MIMO-1

        node0_MIMO.offset_time=2*offset_time;
        node1_MIMO.offset_time=2*offset_time;
        node2_MIMO.offset_time=2*offset_time;
        node0_MIMO.MIMO_active_tx_node_tx=0;
        node1_MIMO.MIMO_active_tx_node_tx=0;
        node2_MIMO.MIMO_active_tx_node_tx=0;

        node0_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO1_");
        node1_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO1_");
        node2_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO1_");
      

        my_super_node.set_nodes(&all_my_nodes3);
        my_super_node.run();

        cout << "node0_MIMO.BER=" << node0_MIMO.BERraw << endl;
        cout << "node1_MIMO.BER=" << node1_MIMO.BERraw << endl;
        cout << "node2_MIMO.BER=" << node2_MIMO.BERraw << endl;

        MIMO1_BER=node0_MIMO.BERraw;

        // Fourth run with MIMO-2

        node0_MIMO.offset_time=3*offset_time;
        node1_MIMO.offset_time=3*offset_time;
        node2_MIMO.offset_time=3*offset_time;
        node0_MIMO.MIMO_active_tx_node_tx=1;
        node1_MIMO.MIMO_active_tx_node_tx=1;
        node2_MIMO.MIMO_active_tx_node_tx=1;

        node0_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO2_");
        node1_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO2_");
        node2_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO2_");

        my_super_node.run();

        cout << "node0_MIMO.BER=" << node0_MIMO.BERraw << endl;
        cout << "node1_MIMO.BER=" << node1_MIMO.BERraw << endl;
        cout << "node2_MIMO.BER=" << node2_MIMO.BERraw << endl;
        MIMO2_BER=node1_MIMO.BERraw;

        // Fifth run with MIMO-3

        node0_MIMO.offset_time=4*offset_time;
        node1_MIMO.offset_time=4*offset_time;
        node2_MIMO.offset_time=4*offset_time;
        node0_MIMO.MIMO_active_tx_node_tx=2;
        node1_MIMO.MIMO_active_tx_node_tx=2;
        node2_MIMO.MIMO_active_tx_node_tx=2;

        node0_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO3_");
        node1_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO3_");
        node2_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO3_");

        my_super_node.run();
        MIMO3_BER=node2_MIMO.BERraw;

        // Sixth run with MIMO-4

        node0_MIMO.offset_time=5*offset_time;
        node1_MIMO.offset_time=5*offset_time;
        node2_MIMO.offset_time=5*offset_time;
        node0_MIMO.MIMO_all_active=true;
        node1_MIMO.MIMO_all_active=true;
        node2_MIMO.MIMO_all_active=true;
        node0_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO4_");
        node1_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO4_");
        node2_MIMO.save_raw_input_on_file(5,"/usr/local/meas_data/MIMO4_");

        my_super_node.run();

        cout << "node0_MIMO.BER=" << MIMO1_BER.get(4,-1) << endl;
        cout << "node1_MIMO.BER=" << MIMO2_BER.get(4,-1) << endl;
        cout << "node2_MIMO.BER=" << MIMO3_BER.get(4,-1) << endl;
        cout <<  "node0_MIMO5.BER=" << node0_MIMO.BERraw.get(0,-1) << endl;

        cout << "node0_IA.BER=" << node0_IA.BERraw.get(2,-1) << endl;
        cout << "node1_IA.BER=" << node1_IA.BERraw.get(2,-1) << endl;
        cout << "node2_IA.BER=" << node2_IA.BERraw.get(2,-1) << endl;

        cout << "node0_CoMP.BER=" << node0_CoMP.BERraw.get(2,-1) << endl;
        cout << "node1_CoMP.BER=" << node1_CoMP.BERraw.get(2,-1) << endl;
        cout << "node2_CoMP.BER=" << node2_CoMP.BERraw.get(2,-1) << endl;

        start_time+=60;

      };


      #if 0
      itpp::it_file d1;
      d1.open("const.it");
      cvec c;
      c=(node0_CoMP.ai[0]).ConstellationStorage;
      d1<< itpp::Name("const0") << c;
      d1<< itpp::Name("w0") << node0_CoMP.waveform_rx;
      //d1<< itpp::Name("soft_bit0") << node0.soft_bit;

      c=node1_CoMP.ai[0].ConstellationStorage;
      d1<< itpp::Name("const1") << c;
      d1<< itpp::Name("w1") << node1_CoMP.waveform_rx;
      //d1<<itpp::Name("transmitted1") << node1.transmitted;
      //d1<< itpp::Name("soft_bit1") << node1.soft_bit;


      c=node2_CoMP.ai[0].ConstellationStorage;
      d1<< itpp::Name("const2") << c;
      d1<< itpp::Name("w2") << node2_CoMP.waveform_rx;
      //d1<<itpp::Name("transmitted2") << node2.transmitted;
      //d1<< itpp::Name("soft_bit2") << node2.soft_bit;

      //
      //d1<<itpp::Name("waveform_rx") << node0.waveform_rx;
      d1.close();
      #endif

  };


 cout << "The end \n";
 return 0;



}