core/super_node.cpp

// Copyright 2011-2013, Per Zetterberg, 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/device.hpp>
#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 <complex>
#include <uhd/types/clock_config.hpp>
#include "gps.hpp"
#include <uhd/usrp/subdev_spec.hpp>
#include "four_multi.hpp"
#include "super_node.hpp"
#include <uhd/types/ranges.hpp>
#include "get_usrp2_ip_addr.hpp"
#include <boost/thread/thread.hpp>
#include <iostream>
#include <boost/asio/io_service.hpp>
#include <boost/asio/serial_port.hpp>
#include <boost/thread/thread.hpp>
#include <boost/asio/socket_base.hpp>
#include <boost/asio/ip/address.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/write.hpp>
#include <boost/asio/buffer.hpp>


using namespace boost::asio::ip;
using boost::asio::ip::tcp;
using namespace std;

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

class node_process_class {
   public:
     
     void operator()(void){
       *fp=p_four_multi->node_process();
     };

      
     four_multi_node *p_four_multi;
     frame_settings *fp;



};


super_node::super_node(uint32_t no_ant1, 
                         uint32_t no_ant2 , bool use_external_10MHz,
                       bool use_same_antenna, //uint32_t node_ix, 
                       //std::vector<std::string> IP_addresses,
                       uint32_t skip_ant ,std::vector<four_multi_node*> *nodes) 
  : four_multi_node(no_ant1,no_ant2,true,use_same_antenna,0,
std::vector<std::string> (),false,skip_ant)
{
  d_nodes=nodes;
  do_override=false;



  int new_buffer_length=(*nodes)[0]->d_buffer_length;
  int i2;
  for (int i1=1;(unsigned int ) i1<(*d_nodes).size();i1++) {
    i2=(*d_nodes)[i1]->d_buffer_length;
    if (!(i2==new_buffer_length)) {
      std::cerr << "All constituent nodes of super_node must have the same buffer_length \n";
      exit(1);
    };
  };
  init(new_buffer_length);
};


super_node::super_node(uint32_t no_ant1, 
                         uint32_t no_ant2 , bool use_external_10MHz,
             bool use_same_antenna, 
                       // std::vector<std::string> IP_addresses,
              uint32_t skip_ant ,std::vector<four_multi_node*> *nodes,
              std::vector<double> override_gain_rx, 
              std::vector<double> override_gain_tx, 
                       std::vector<double> override_frequency) :
four_multi_node(no_ant1,no_ant2,true,use_same_antenna,0,
std::vector<std::string> (),
false,skip_ant)
{
  d_nodes=nodes;
  do_override=true;
  d_override_gain_rx= override_gain_rx;
  d_override_gain_tx=override_gain_tx;
  d_override_frequency=override_frequency;

  int new_buffer_length=(*nodes)[0]->d_buffer_length;
  int i2;
  for (int i1=1;(unsigned int ) i1<(*d_nodes).size();i1++) {
    i2=(*d_nodes)[i1]->d_buffer_length;
    if (!(i2==new_buffer_length)) {
      std::cerr << "All constituent nodes of super_node must have the same buffer_length \n";
      exit(1);
    };
  };
  init(new_buffer_length);
};





frame_settings super_node::node_init(void) {

  frame_settings frame,f;
  std::vector<double> gain_rx_vec(d_no_ant);
  std::vector<double> gain_tx_vec(d_no_ant);
  std::vector<double> freq_vec(d_no_ant);  
  
  
  uint32_t i2=0;
  uint32_t i30=0;
  uint32_t i4;
  for (uint32_t i1=0;i1<(*d_nodes).size();i1++) {
    for (uint32_t i3=0;i3<(*d_nodes)[i1]->d_no_ant;i3++) {
      (*d_nodes)[i1]->d_tx_buffers[i3]=d_tx_buffers[i2];
      (*d_nodes)[i1]->d_rx_buffers[i3]=d_rx_buffers[i2];
      i2++;
    };
    (*d_nodes)[i1]->d_simulate=true;
    (*d_nodes)[i1]->no_rx_buffer_stored_so_far=0;
    f=(*d_nodes)[i1]->node_init();

    if (!do_override) {
      for (uint32_t i3=0;i3<(*d_nodes)[i1]->d_no_ant;i3++) {
        i4=min(i3,(uint32_t) f.gain_rx.size()-1);
        gain_rx_vec[i3+i30]=f.gain_rx[i4];
        i4=min(i3,(uint32_t) f.gain_tx.size()-1);
        gain_tx_vec[i3+i30]=f.gain_tx[i4];
        i4=min(i3,(uint32_t) f.frequency.size()-1);
        freq_vec[i3+i30]=f.frequency[i4];
      };
      frame.gain_rx=gain_rx_vec;
      frame.gain_tx=gain_tx_vec;
      frame.frequency=freq_vec;
    } else {
      frame.gain_rx=d_override_gain_rx;
      frame.gain_tx=d_override_gain_tx;
      frame.frequency=d_override_frequency;
    };

    frame.time=f.time;
    frame.what=f.what;
    frame.small_buffer_length=f.small_buffer_length;
    frame.tx_repeats=f.tx_repeats;


    i30=i2;
    (*d_nodes)[i1]->d_simulate=false;
  };
 
  return frame;

};
frame_settings super_node::node_process(void) { 

  frame_settings frame,f1,f2,f3;
  std::vector<double> gain_rx_vec(d_no_ant);
  std::vector<double> gain_tx_vec(d_no_ant);
  std::vector<double> freq_vec(d_no_ant);  

  for (uint32_t i1=0;i1<(*d_nodes).size();i1++) {
     (*d_nodes)[i1]->d_old_frame_settings=d_old_frame_settings;
  };

  node_process_class n0p;
  n0p.p_four_multi=(*d_nodes)[0];
  n0p.fp=&f1;
  boost::thread n0t(n0p);
  if ((*d_nodes).size()>1) {
    node_process_class n1p;
    n1p.p_four_multi=(*d_nodes)[1];
    n1p.fp=&f2;
    boost::thread n1t(n1p);
    if ((*d_nodes).size()>2) {
       node_process_class n2p;
       n2p.p_four_multi=(*d_nodes)[2];
       n2p.fp=&f3;
       boost::thread n2t(n2p);
       if ((*d_nodes).size()>3) {
          cerr << "super_node can only take max 3 subnodes \n";
       };
       n2t.join();
    };
    n1t.join();
  };
  n0t.join();

  frame.what=f1.what;

  frame.tx_repeats=f1.tx_repeats;
  frame.time=f1.time;
  frame.small_buffer_length=f1.small_buffer_length;
  std::cout << "inside super_node frame.small_buffer_length=" << frame.small_buffer_length << std::endl;

  int i4, i30;
  i30=0;

  for (uint32_t i3=0;i3<(*d_nodes)[0]->d_no_ant;i3++) {
    i4=min(i3,(uint32_t) f1.gain_rx.size()-1);
    gain_rx_vec[i3+i30]=f1.gain_rx[i4];
    i4=min(i3,(uint32_t) f1.gain_tx.size()-1);
    gain_tx_vec[i3+i30]=f1.gain_tx[i4];
    i4=min(i3,(uint32_t) f1.frequency.size()-1);
    freq_vec[i3+i30]=f1.frequency[i4];
  };
  i30=i30+(*d_nodes)[0]->d_no_ant;
  if ((*d_nodes).size()>1) {
    for (uint32_t i3=0;i3<(*d_nodes)[1]->d_no_ant;i3++) {
      i4=min(i3,(uint32_t) f2.gain_rx.size()-1);
      gain_rx_vec[i3+i30]=f2.gain_rx[i4];
      i4=min(i3,(uint32_t) f2.gain_tx.size()-1);
      gain_tx_vec[i3+i30]=f2.gain_tx[i4];
      i4=min(i3,(uint32_t) f2.frequency.size()-1);
      freq_vec[i3+i30]=f2.frequency[i4];
    };
   i30=i30+(*d_nodes)[1]->d_no_ant;
  };
  if ((*d_nodes).size()>2) {
    for (uint32_t i3=0;i3<(*d_nodes)[2]->d_no_ant;i3++) {
      i4=min(i3,(uint32_t) f3.gain_rx.size()-1);
      gain_rx_vec[i3+i30]=f3.gain_rx[i4];
      i4=min(i3,(uint32_t) f3.gain_tx.size()-1);
      gain_tx_vec[i3+i30]=f3.gain_tx[i4];
      i4=min(i3,(uint32_t) f3.frequency.size()-1);
      freq_vec[i3+i30]=f3.frequency[i4];
    };
   i30=i30+(*d_nodes)[2]->d_no_ant;
  };

  if (!do_override) {
    frame.gain_rx=gain_rx_vec;
    frame.gain_tx=gain_tx_vec;
    frame.frequency=freq_vec;
  }
  else  {
    frame.gain_rx=d_override_gain_rx;
    frame.gain_tx=d_override_gain_tx;
    frame.frequency=d_override_frequency;    
  };


  //  std::cout << "heeej d_old_frame_settings.small_buffer_length=" << d_old_frame_settings.small_buffer_length << std::endl;

  if (d_old_frame_settings.what==RX) {
    for (uint32_t i1=0;i1<(*d_nodes).size();i1++) {
      if ((*d_nodes)[i1]->save_input_on_file) {
        if (d_old_frame_settings.small_buffer_length!=0) {
          (*d_nodes)[i1]->
            log_raw_buffer(d_old_frame_settings.small_buffer_length);
        } else {
          (*d_nodes)[i1]->log_raw_buffer(d_buffer_length);
         };
      };
    };
  };     

  return frame;

};
void super_node::end_of_run(void) {  
  for (uint32_t i1=0;i1<(*d_nodes).size();i1++) {
    if ((*d_nodes)[i1]->save_input_on_file) {
      (*d_nodes)[i1]->save_logged_raw_data();
    };    
    (*d_nodes)[i1]->end_of_run();
  };
};