core/four_multi.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/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 <uhd/types/ranges.hpp>
#include "get_usrp2_ip_addr.hpp"
#include <boost/thread/thread.hpp>
#include <iostream>
#include <boost/asio.hpp>
#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;

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

class four_multi_node::udp_function_thread_class{
   public:
   
   uint32_t this_node_ix;
   uint32_t other_node_ix;
   void *pointer_to_data; 
   uint32_t num_bytes;
   

  void operator()(void){

      try
      {

        boost::asio::io_service io_service;
        udp::socket socket(io_service, udp::endpoint(udp::v4(), 
                                                     2000+other_node_ix*100+this_node_ix));
      

        udp::endpoint remote_endpoint;
        boost::system::error_code error;
        size_t len=socket.receive_from(boost::asio::buffer(pointer_to_data,num_bytes), 
                                     remote_endpoint, 0, error);


        while (len<num_bytes) {
          void *p;
          p=pointer_to_data;
          p=(void* ) (((char*) p)+len/sizeof(char));
          size_t len1=socket.receive_from(boost::asio::buffer(pointer_to_data,num_bytes), 
                                     remote_endpoint, 0, error);
          len=len+len1; 
        };
      }
      catch (std::exception& e)
      {
        std::cerr << e.what() << std::endl;  
      }


  };
};

class four_multi_node::usrp_thread_function_class {
  public:
  
    uhd::usrp::multi_usrp::sptr d_mdev;
    uhd::device::sptr d_dev;
    
    std::vector<const void *> d_tx_buffers;
    std::vector<void *> d_rx_buffers;

    uint32_t d_buffer_length;
    uint32_t d_no_ant;
    bool do_tx;
    uint32_t tx_repeats;   

 
    uhd::time_spec_t stream_time;

    uhd::tx_metadata_t md_tx;
    uhd::rx_metadata_t md_rx;


    void operator()(void){
      
      if (do_tx) {
                
        if (tx_repeats<2) {
          d_dev->send(
          d_tx_buffers, d_buffer_length, md_tx,
          uhd::io_type_t::COMPLEX_INT16,
          uhd::device::SEND_MODE_FULL_BUFF);
        } else {

          for (int i1=0;i1<(int) tx_repeats;i1++) {
            d_dev->send(
                        d_tx_buffers, d_buffer_length, md_tx,
                        uhd::io_type_t::COMPLEX_INT16,
                        uhd::device::SEND_MODE_FULL_BUFF);
            md_tx.time_spec += 5.2e-4;

          };
          
          #if 0
          uhd::tx_metadata_t md_tx_temp=md_tx;
          md_tx_temp.end_of_burst = false;
          md_tx.has_time_spec = true;

          d_dev->send(
          d_tx_buffers, d_buffer_length, md_tx_temp,
          uhd::io_type_t::COMPLEX_INT16,
          uhd::device::SEND_MODE_FULL_BUFF);

          md_tx_temp.start_of_burst = false;
          md_tx_temp.has_time_spec = false;

          for (int i1=0;i1<((int) tx_repeats)-2;i1++) {
            d_dev->send(
                        d_tx_buffers, d_buffer_length, md_tx_temp,
                        uhd::io_type_t::COMPLEX_INT16,
                        uhd::device::SEND_MODE_FULL_BUFF);
          };

          md_tx.end_of_burst = true;
          d_dev->send(d_tx_buffers, d_buffer_length, md_tx_temp,
          uhd::io_type_t::COMPLEX_INT16,
                        uhd::device::SEND_MODE_FULL_BUFF);

          #endif

        };

                
      } else {
        
        
          uint32_t num_rx_samps=0;
          uhd::stream_cmd_t    
            stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);        

          stream_cmd.stream_now=false;          
          stream_cmd.num_samps = d_buffer_length;
          stream_cmd.time_spec = stream_time; 
          d_mdev->issue_stream_cmd(stream_cmd);
          
          while (num_rx_samps==0) {

            num_rx_samps=d_dev->recv(
                                     d_rx_buffers,
                                     d_buffer_length,
                                     md_rx,
            uhd::io_type_t::COMPLEX_INT16, 
            uhd::device::RECV_MODE_FULL_BUFF 
           );

          
            if (!((md_rx.error_code==0) || (md_rx.error_code==1))) {
              std::cout << "!!!!!!!!!!!!!!!!!!!!!! md_rx.error_code=" << md_rx.error_code << std::endl;
              
              std::complex<int16_t> *p1;
              for (uint32_t i3=0;i3<d_no_ant;i3++) {
                p1=(std::complex<int16_t> *) d_rx_buffers[i3];
                p1[0]=10000;
              };
              break;
            };


          }; // while
  

      }; // if-else
      

   }; // operator()

}; // class



four_multi_node::four_multi_node(uint32_t buffer_length, uint32_t no_ant1, uint32_t no_ant2, bool use_external_10MHz,bool same_antenna,
uint32_t node_ix, 
std::vector<std::string> IP_addresses,bool simulate,uint32_t skip_ant)
{
  d_rate=25e6;
  d_skip_ant=skip_ant;
  save_input_on_file=false;
  no_rx_buffer_stored_so_far=0;
  wait_time_for_transmissions_to_finish=1.0;
  set_time_on_pps=true;
  skip_hw_set_during_init=false;
  use_udp=false;



  d_node_ix=node_ix; 
  d_IP_addresses=IP_addresses;
  d_simulate=simulate;

  d_buffer_length=buffer_length; 
  d_no_ant=no_ant1;
  d_no_ant1=no_ant1;
  d_no_ant2=no_ant2;
  d_no_ant=d_no_ant1+d_no_ant2;
  d_use_external_10MHz=use_external_10MHz;
  d_use_same_antenna=same_antenna;


  init(buffer_length);


};

four_multi_node::four_multi_node(uint32_t no_ant1, uint32_t no_ant2, bool use_external_10MHz,bool same_antenna,
uint32_t node_ix, 
std::vector<std::string> IP_addresses,bool simulate,uint32_t skip_ant)
{
  d_rate=25e6;
  d_skip_ant=skip_ant;
  save_input_on_file=false;
  no_rx_buffer_stored_so_far=0;
  wait_time_for_transmissions_to_finish=1.0;
  set_time_on_pps=true;
  skip_hw_set_during_init=false;
  use_udp=false;


  d_node_ix=node_ix; 
  d_IP_addresses=IP_addresses;
  d_simulate=simulate;

  d_no_ant=no_ant1;
  d_no_ant1=no_ant1;
  d_no_ant2=no_ant2;
  d_no_ant=d_no_ant1+d_no_ant2;
  d_use_external_10MHz=use_external_10MHz;
  d_use_same_antenna=same_antenna;


};




void four_multi_node::save_raw_input_on_file(uint32_t max_no_frames_to_save,std::string directory_name) {

  save_input_on_file=true;
  raw_data_dir=directory_name;
  std::complex<int16_t> *temp_buffer;
  for (uint32_t i1=0;i1<d_no_ant;i1++) {
    if (d_rx_storage_buffers[i1]==NULL) {
      temp_buffer=new std::complex<int16_t>[d_buffer_length*max_no_frames_to_save];
      d_rx_storage_buffers[i1]=temp_buffer;
    };
  };
  d_max_no_frames_to_save=max_no_frames_to_save;
 
}


void four_multi_node::dont_save_raw_input_on_file(void) {
  save_input_on_file=false;
  std::complex<int16_t> *temp_buffer;
  for (uint32_t i1=0;i1<d_no_ant;i1++) {
    temp_buffer= (std::complex<int16_t> *) d_rx_storage_buffers[i1];
    delete[] temp_buffer;
  };
}

void four_multi_node::init(uint32_t buffer_length){

  m1= new usrp_thread_function_class[1];
  m2= new usrp_thread_function_class[1];


  m1->d_no_ant=d_no_ant1;
  m2->d_no_ant=d_no_ant2;
  d_old_frame_settings.what=START;
  d_buffer_length=buffer_length;
  m1->tx_repeats=0;
  m2->tx_repeats=0;

  // Internal variables 
  uhd::clock_config_t my_clock_config; 
  


  m1->d_buffer_length=buffer_length;
  m2->d_buffer_length=buffer_length;

  

  std::string IP_addresses1, IP_addresses2, IP_addresses;
  std::stringstream temp_ss;
  uhd::device_addr_t dev_addr1;
  uhd::device_addr_t dev_addr2;


  IP_addresses=get_usrp2_ip_addr(d_no_ant+d_skip_ant); // Get all IP addresses needed

  // Split them into two subsets
  std::istringstream iss(IP_addresses);
  
  // Skip skip_ant addresses:
  for (uint32_t i1=0;i1<d_skip_ant;i1++) {
    std::string subs;
    iss >> subs;
  };

  //std::cout << "IP_addresses=" << IP_addresses << std::endl;

  for (uint32_t i1=0;i1<d_no_ant1;i1++) {
    std::string subs;
    std::string numb;
    std::stringstream ss;

    ss << i1;
    ss >> numb;
    numb="addr"+numb;
    iss >> subs;
    dev_addr1[numb]=subs;
    IP_addresses1+=subs;
    if (i1<(d_no_ant1-1)){
      IP_addresses1+=" ";
    }
  };

  for (uint32_t i2=0;i2<d_no_ant2;i2++) {
    std::string subs; 
    std::string numb;
    std::stringstream ss;
    
    ss << i2;
    ss >> numb;
    numb="addr"+numb;
    iss >> subs;
    dev_addr2[numb]=subs;
    IP_addresses2+=subs;       
    if (i2<(d_no_ant2-1))
      IP_addresses2+=" ";
  };


  
  temp_ss << buffer_length*4*4;
  dev_addr1["recv_buff_size"]=temp_ss.str();
  dev_addr1["send_buff_size"]=temp_ss.str();
  dev_addr2["recv_buff_size"]=temp_ss.str();
  dev_addr2["send_buff_size"]=temp_ss.str();

 
  if (!d_simulate) {


    if (d_no_ant1>0)
      m1->d_mdev=uhd::usrp::multi_usrp::make(dev_addr1);
    if (d_no_ant2>0)
      m2->d_mdev=uhd::usrp::multi_usrp::make(dev_addr2);

    #if 0
    uhd::usrp::subdev_spec_t e("");

    if (d_no_ant1>0) {
      for (uint32_t i1=0;i1<d_no_ant1;i1++) {
        m1->d_mdev->set_rx_subdev_spec(e, i1);
        m1->d_mdev->set_tx_subdev_spec(e, i1);
      };
      m1->d_dev=m1->d_mdev->get_device();
    };
    if (d_no_ant2>0) {
      for (uint32_t i1=0;i1<d_no_ant2;i1++) {
        m2->d_mdev->set_rx_subdev_spec(e, i1);
        m2->d_mdev->set_tx_subdev_spec(e, i1);
      };
      m2->d_dev=m2->d_mdev->get_device();
    };
    #endif
  
    //XCVR2450-LNA
    //XCVR2450-VGA
    //0,15,30.5
    //0,2,62
    //XCVR2450-VGA
    //XCVR2450-BB
    //0,0.5,30
    //0,1.5,5
  
  };


  std::complex<int16_t> *temp_buffer;
  for (uint32_t i1=0;i1<d_no_ant;i1++) {
    temp_buffer=new std::complex<int16_t>[d_buffer_length];
    d_tx_buffers.push_back(temp_buffer);
  };



  for (uint32_t i1=0;i1<d_no_ant;i1++) {
    temp_buffer=new std::complex<int16_t>[d_buffer_length];
    d_rx_buffers.push_back(temp_buffer);
  };

  for (uint32_t i1=0;i1<d_no_ant;i1++) {
    temp_buffer=NULL;
    d_rx_storage_buffers.push_back(temp_buffer);
  };



  for (uint32_t i1=0;i1<d_no_ant1;i1++) {
     temp_buffer=(std::complex<short int>*) d_tx_buffers[i1];
     m1->d_tx_buffers.push_back(temp_buffer);
     temp_buffer=(std::complex<short int>*) d_rx_buffers[i1];
     m1->d_rx_buffers.push_back(temp_buffer);
  };
 
  for (uint32_t i1=0;i1<d_no_ant2;i1++) {
     temp_buffer=(std::complex<short int>*) d_tx_buffers[i1+d_no_ant1];
     m2->d_tx_buffers.push_back(temp_buffer);
     temp_buffer=(std::complex<short int>*) d_rx_buffers[i1+d_no_ant1];
     m2->d_rx_buffers.push_back(temp_buffer);
  };


  if (!d_simulate) {

    std::string config;
    uint32_t temp;
    bool is_basic_1=false, is_xcvr2450_1=false, 
      is_basic_2=false, is_xcvr2450_2=false;
    


    if (d_no_ant1>0) {
      m1->d_mdev->set_rx_rate(d_rate);
      m1->d_mdev->set_tx_rate(d_rate);

      
      config = m1->d_mdev->get_pp_string();


      temp=config.find("Basic");
      if (temp<config.length())
        is_basic_1=true;
      else
        is_basic_1=false;

      temp=config.find("XCVR2450");
      if (temp<config.length())
        is_xcvr2450_1=true; 
      else
        is_xcvr2450_1=false;
    
    };

    if (d_no_ant2>0) {
      m2->d_mdev->set_rx_rate(d_rate);
      m2->d_mdev->set_tx_rate(d_rate);

      config = m2->d_mdev->get_pp_string();
      temp=config.find("Basic");
      if (temp<config.length())
        is_basic_2=true;
      else
        is_basic_2=false;

      temp=config.find("XCVR2450");
      if (temp<config.length())
        is_xcvr2450_2=true; 
      else
        is_xcvr2450_2=false;

    };

    bool is_basic , is_xcvr2450;
 
    is_basic=is_basic_1 | is_basic_2;
    is_xcvr2450=is_xcvr2450_1 | is_xcvr2450_2;

    if (is_basic & is_xcvr2450) {
      std::cout << "Either basic db or xcvr2450 must be used, not both. \n";
      exit(1);
    };
    if (!(is_basic | is_xcvr2450)) {
      std::cout << "Either basic db or xcvr2450 must be used \n";
      exit(1);
    };

    if (is_xcvr2450) {
      if (d_use_same_antenna) {
        for (uint32_t i1=0;i1<d_no_ant1;i1++) {
          m1->d_mdev->set_tx_antenna("J1",i1);
          m1->d_mdev->set_rx_antenna("J1",i1);
        }
        for (uint32_t i1=0;i1<d_no_ant2;i1++) {
          m2->d_mdev->set_tx_antenna("J1",i1);
          m2->d_mdev->set_rx_antenna("J1",i1);
        }
      } else {
        for (uint32_t i1=0;i1<d_no_ant1;i1++) {
          m1->d_mdev->set_tx_antenna("J2",i1);
          m1->d_mdev->set_rx_antenna("J1",i1);
        };
        for (uint32_t i1=0;i1<d_no_ant2;i1++) {
          m2->d_mdev->set_tx_antenna("J2",i1);
          m2->d_mdev->set_rx_antenna("J1",i1);
        };
      };
  };

  if (is_basic) {
     uhd::usrp::subdev_spec_t spec("A:A");
     for (uint32_t i1=0;i1<d_no_ant1;i1++) {
        m1->d_mdev->set_rx_subdev_spec(spec, i1);
        m1->d_mdev->set_tx_subdev_spec(spec, i1);
     };
     for (uint32_t i1=0;i1<d_no_ant2;i1++) {
        m2->d_mdev->set_rx_subdev_spec(spec, i1);
        m2->d_mdev->set_tx_subdev_spec(spec, i1);
     };

  };

  if (d_no_ant1>0)  
    m1->d_dev=m1->d_mdev->get_device();
  if (d_no_ant2>0)  
    m2->d_dev=m2->d_mdev->get_device();

  my_clock_config.pps_source=uhd::clock_config_t::PPS_SMA; 
  my_clock_config.pps_polarity=uhd::clock_config_t::PPS_POS; 

  // Lock to 10MHz
  if (d_use_external_10MHz) 
      my_clock_config.ref_source=uhd::clock_config_t::REF_SMA; 
  else
      my_clock_config.ref_source=uhd::clock_config_t::REF_INT; 
  };

  if (!d_simulate) {
    for (uint32_t i1=0;i1<d_no_ant1;i1++) 
      m1->d_mdev->set_clock_config(my_clock_config, i1);

    for (uint32_t i1=0;i1<d_no_ant2;i1++) 
      m2->d_mdev->set_clock_config(my_clock_config, i1);
  };  


  usleep(1e5); 


}




void four_multi_node::run(void) {
   run("",0); 
};


void four_multi_node::run(const char* device_name, uint32_t gps_time_combined){


   frame_settings new_frame_settings;
   //uhd::tune_result_t tr; 


   uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); // For reception
   uhd::rx_metadata_t md_rx;
   uhd::tx_metadata_t md_tx;


   md_tx.start_of_burst = true;
   md_tx.end_of_burst = true;
   md_tx.has_time_spec = true;

   m1->md_tx=md_tx;
   m2->md_tx=md_tx;


   no_rx_buffer_stored_so_far=0;
   new_frame_settings=node_init();


   if (!skip_hw_set_during_init) {
     set_trx_params(new_frame_settings);
   };


   if (gps_time_combined>0) 
     gps_wait_until(device_name,gps_time_combined);



   const uhd::time_spec_t t0=time_available_for_trigger+headroom_after_trigger; // Seconds
   
   if (set_time_on_pps) {
     // Sync the node to pps
     if (d_no_ant1>0)
       m1->d_mdev->set_time_next_pps(uhd::time_spec_t(0.0));
     if (d_no_ant2>0)
       m2->d_mdev->set_time_next_pps(uhd::time_spec_t(0.0)); 
   std::cout << "Wait for pps trigger!" << std::endl;
   usleep(1e6*time_available_for_trigger); 
   std::cout << "Sync hopefully done" << std::endl;   
   };

  
   while (!(new_frame_settings.what==END)) {

     std::cout << "time=" << new_frame_settings.time.get_real_secs() << std::endl;

     switch (new_frame_settings.what) {
   
        case TX:
        case CALIB_TXTX:
          m1->do_tx=true;
          m2->do_tx=true;
          break;
        case CALIB_TXRX:
          m1->do_tx=true;
          m2->do_tx=false;
          break;
        case CALIB_RXTX:
          m1->do_tx=false;
          m2->do_tx=true;
          break;
        case RX:
        case CALIB_RXRX:
          m1->do_tx=false;
          m2->do_tx=false;
          break;
        case START:
          /* Just to keep the compiler happy */
          break;
        case END:
          std::cout << "END !! \n";
          /* Just to keep the compiler happy */
          break;
     };


     m1->md_tx.time_spec = uhd::time_spec_t(t0+new_frame_settings.time);
     m1->stream_time=uhd::time_spec_t(t0+new_frame_settings.time);       
     m2->md_tx.time_spec = uhd::time_spec_t(t0+new_frame_settings.time);
     m2->stream_time=uhd::time_spec_t(t0+new_frame_settings.time);

     std::cout << "new_frame_settings.tx_repeats=" <<
       new_frame_settings.tx_repeats << std::endl;

     if (new_frame_settings.small_buffer_length!=0) {
         m1->d_buffer_length=new_frame_settings.small_buffer_length;
         m2->d_buffer_length=new_frame_settings.small_buffer_length;
     } ;
     if (new_frame_settings.tx_repeats!=0) {
         m1->tx_repeats=new_frame_settings.tx_repeats;
         m2->tx_repeats=new_frame_settings.tx_repeats;
     } ;

     
     if ((d_no_ant1>0) && (d_no_ant2>0)) {
       boost::thread m2t(*m2);
       (*m1)();
       m2t.join();
     };
     if  ((d_no_ant1>0) && (d_no_ant2==0)) {
       (*m1)();
     };
     if ((d_no_ant2>0) && (d_no_ant1==0)) {
        (*m2)();
     };


     if (new_frame_settings.small_buffer_length!=0) {
       m1->d_buffer_length=d_buffer_length;
       m2->d_buffer_length=d_buffer_length;
     };
     if (new_frame_settings.tx_repeats!=0) {
         m1->tx_repeats=0;
         m2->tx_repeats=0;
     } ;


    
     if (save_input_on_file) {
       if (new_frame_settings.what==RX) {
         if (new_frame_settings.small_buffer_length!=0) {
           log_raw_buffer(new_frame_settings.small_buffer_length);
         } else {
           log_raw_buffer(d_buffer_length);
         };
       };
     };     
      
 
     d_old_frame_settings=new_frame_settings;
     new_frame_settings=node_process();
     

     //double new_freq, old_freq, new_gain_rx, old_gain_rx;
     //double new_gain_tx, old_gain_tx;


     if (!(new_frame_settings.what==END)) {
       set_trx_params(new_frame_settings,d_old_frame_settings);
     } ; 



   };
   if (save_input_on_file) {    
     save_logged_raw_data();
   };
   usleep(1e6*wait_time_for_transmissions_to_finish); 
                            // Just so that all outgoing frames have left.
   end_of_run();
   std::cout << "Done !\n";

};

void four_multi_node::log_raw_buffer(uint32_t number_of_samples) {
       std::complex<int16_t> *p1;
       void *p2;

       
       //std::cout << "no_samples=" << number_of_samples << std::endl;
       if (no_rx_buffer_stored_so_far<d_max_no_frames_to_save) {
           for (uint32_t i1=0;i1<d_no_ant;i1++) {
             p1=(std::complex<int16_t> *) d_rx_storage_buffers[i1];          
             p1=&p1[no_rx_buffer_stored_so_far*d_buffer_length];
             p2=d_rx_buffers[i1];
             memcpy (p1, p2 , number_of_samples*4 );
           };
           no_rx_buffer_stored_so_far++;
       };
};
    

void four_multi_node::save_logged_raw_data(void){
     
  std::string filename;
  std::stringstream temp_ss;


  if (no_rx_buffer_stored_so_far>0) {
    for (uint32_t i1=0;i1<no_rx_buffer_stored_so_far;i1++) {
       temp_ss << d_node_ix;
       filename=raw_data_dir+"node="+temp_ss.str()+"_";
       temp_ss.str("");
       temp_ss << i1;
       filename+="frame="+temp_ss.str()+".dat";
       temp_ss.str("");
       //std::cout << "d_buffer_length=" << d_buffer_length << std::endl;
       //std::cout << " filename=" << filename << std::endl;

       std::ofstream s1(filename.c_str(), std::ios::binary);
       for (uint32_t i2=0;i2<d_no_ant;i2++) {
         //std::cout << "save_logged_raw_data i2=" << i2 << std::endl;
       s1.write(((char *) d_rx_storage_buffers[i2]) + 
           4*i1*d_buffer_length, 
           d_buffer_length*4); 
       };
       
       s1.flush(); 
       s1.close(); 

    }
  };

  
}


void four_multi_node::x2_tx_udp(uint32_t other_node_ix ,const void * pointer_to_data, 
                                uint32_t size) {



       
   try {
       std::stringstream temp_ss;
       boost::asio::io_service io_service;
       udp::socket socket(io_service, udp::endpoint(udp::v4(),0));
       udp::resolver resolver(io_service);
       temp_ss << 2000+d_node_ix*100+other_node_ix;
       udp::resolver::query query(udp::v4(), d_IP_addresses[other_node_ix], temp_ss.str());
       udp::endpoint receiver_endpoint = *resolver.resolve(query);
       
     
       socket.send_to(boost::asio::buffer(pointer_to_data,size), receiver_endpoint);
       socket.close();


       }
       catch (std::exception& e)
       {
         std::cout << "exception in x2_tx_udp \n";
         std::cerr << e.what() << std::endl;  
       }
  
}

void four_multi_node::x2_tx(uint32_t other_node_ix ,const void * pointer_to_data, 
                                uint32_t size) {

  if (use_udp && (!d_simulate))
    x2_tx_udp(other_node_ix,pointer_to_data,size);
  else
    x2_tx_tcp(other_node_ix,pointer_to_data,size);

}


void four_multi_node::x2_tx_tcp(uint32_t other_node_ix ,const void * pointer_to_data, 
                uint32_t size)
{


   if (d_simulate) {
     bool empty;


     empty=(feedback_buffers_empty)[other_node_ix+num_nodes*d_node_ix];
     if (!empty) {
       std::cerr << "Feedback buffer not empty! \n";
       exit(1);
     };

     // Create room and copy the data
     void *p;
     p=malloc(size);
     memcpy (p,pointer_to_data,size);
     feedback_buffers[other_node_ix+num_nodes*d_node_ix]=p;
     (feedback_buffers_empty)[other_node_ix+num_nodes*d_node_ix]=false;


   } else {



       try {


       boost::asio::io_service io_service;
       tcp::resolver resolver(io_service);
       std::stringstream temp_ss;

       temp_ss << 2000+d_node_ix*100+other_node_ix;
       tcp::resolver::query query(d_IP_addresses[other_node_ix], temp_ss.str());
       tcp::resolver::iterator endpoint_iterator; 
       endpoint_iterator = resolver.resolve(query);
       resolver.resolve(query);
       
       tcp::resolver::iterator end;
       tcp::socket socket(io_service);
       boost::system::error_code error = boost::asio::error::host_not_found;

       while (error && endpoint_iterator != end)
       {
         socket.close();
         socket.connect(*endpoint_iterator, error);
         while (error==boost::system::errc::connection_refused) {
           socket.connect(*endpoint_iterator, error);
           usleep(100);
         };
         endpoint_iterator++;
       }

       if (error) {
         std::cout << "error=" << error << "\n";
         throw boost::system::system_error(error);
       };

       boost::system::error_code ignored_error;
       boost::asio::write(socket, 
                          boost::asio::buffer(pointer_to_data,size),
       boost::asio::transfer_all(), ignored_error);

     }
     catch (std::exception& e)
     {
       std::cerr << e.what() << std::endl;  
     }

   };

   return;



};


void four_multi_node::x2_rx(uint32_t other_node_ix ,void  *pointer_to_data, 
                       uint32_t size) {

  if (use_udp && (!d_simulate))
    x2_rx_udp(other_node_ix,pointer_to_data,size);
  else
    x2_rx_tcp(other_node_ix,pointer_to_data,size);

}
void four_multi_node::x2_rx_tcp(uint32_t other_node_ix ,void  *pointer_to_data, 
                       uint32_t size) {


  if (d_simulate) {
     bool empty;
     empty=(feedback_buffers_empty)[d_node_ix+other_node_ix*num_nodes];
     if (empty) {
       std::cerr << "Feedback buffer is empty! \n";
       exit(1);
     };

     // Copy the data
     void *p;
     p=feedback_buffers[d_node_ix+num_nodes*other_node_ix];
     memcpy(pointer_to_data,p,size);
     (feedback_buffers_empty)[d_node_ix+num_nodes*other_node_ix]=true;
     
     // Free the memory
     free(p);

  }
  else
    {




      try
      {
      boost::system::error_code error;
      boost::asio::io_service io_service;
      tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 2000+other_node_ix*100+d_node_ix));


      {
        tcp::socket socket(io_service);
        acceptor.accept(socket);

        boost::asio::ip::tcp::endpoint remote_ep = socket.remote_endpoint();
        address remote_ad = remote_ep.address();
        std::string new_ip_address = remote_ad.to_string();
        std::cout << "received call from: " << new_ip_address << std::endl;
                
        size_t len=socket.read_some(boost::asio::buffer(pointer_to_data,size), error);

        while (len<size) {
          std::cout << "Extra read_some \n";
          void *p;
          p=pointer_to_data;
          p=(void* ) (((char*) p)+len/sizeof(char));
          size_t len1=socket.read_some(boost::asio::buffer(p,size-len), error);
          len=len+len1;
        };


        //boost::system::error_code ignored_error;
        //boost::asio::write(socket, boost::asio::buffer(response_ip_address),
        //boost::asio::transfer_all(), ignored_error);

        socket.close();
      }
    }
    catch (std::exception& e)
    {
      std::cerr << e.what() << std::endl;
    }

  };


};

void four_multi_node::x2_rx_udp(uint32_t other_node_ix ,void  * const
pointer_to_data, uint32_t size) {

  udp_function_thread_class n0p;
  n0p.this_node_ix=d_node_ix;
  n0p.other_node_ix=other_node_ix;
  n0p.pointer_to_data=pointer_to_data;
  n0p.num_bytes=size;
  boost::thread n0t(n0p);
  n0t.join();


}

void four_multi_node::x2_rx(std::vector<uint32_t> other_node_ixs ,std::vector<void  *> const pointers_to_data,  std::vector<uint32_t> num_bytess) {

  if (use_udp && (!d_simulate))
    x2_rx_udp(other_node_ixs,pointers_to_data,num_bytess);
  else
    x2_rx_tcp(other_node_ixs,pointers_to_data,num_bytess);
}


void four_multi_node::x2_rx_tcp(std::vector<uint32_t> other_node_ixs ,std::vector<void  *> const pointers_to_data,  std::vector<uint32_t> num_bytess) {

  for (uint32_t i1=0;i1< other_node_ixs.size();i1++) {
     x2_rx_tcp(other_node_ixs[i1],pointers_to_data[i1],num_bytess[i1]);
  };

}


void four_multi_node::x2_rx_udp(std::vector<uint32_t> other_node_ixs ,std::vector<void  *> pointers_to_data,  std::vector<uint32_t> num_bytess) {


  udp_function_thread_class n0p;
  n0p.this_node_ix=d_node_ix;
  n0p.other_node_ix=other_node_ixs[0];
  n0p.pointer_to_data=pointers_to_data[0];
  n0p.num_bytes=num_bytess[0];
  boost::thread n0t(n0p);
  if (other_node_ixs.size()>1) {
    udp_function_thread_class n1p;
    n1p.this_node_ix=d_node_ix;
    n1p.other_node_ix=other_node_ixs[1];
    n1p.pointer_to_data=pointers_to_data[1];
    n1p.num_bytes=num_bytess[1];
    boost::thread n1t(n1p);
    if (other_node_ixs.size()>2) {
      udp_function_thread_class n2p;
      n2p.this_node_ix=d_node_ix;
      n2p.other_node_ix=other_node_ixs[2];
      n2p.pointer_to_data=pointers_to_data[2];
      n2p.num_bytes=num_bytess[2];
      boost::thread n2t(n2p);
      if (other_node_ixs.size()>3) {
          std::cerr << "x2_rx_udp can currently only take max 3 subnodes \n";
      };
      n2t.join();
    };
    n1t.join();
  };
  n0t.join();
 
}


void four_multi_node::set_trx_params(frame_settings fs_new, frame_settings fs_old) {

  uhd::tune_result_t tr;  
  double old_freq, new_freq, new_gain_tx, old_gain_tx, new_gain_rx, old_gain_rx;

  for (uint32_t i1=0;i1<d_no_ant1;i1++) {
    if (i1<fs_old.frequency.size())
      old_freq=fs_old.frequency[i1];
    else {
      old_freq=fs_old.frequency.back();
    };  

    if (i1<fs_new.frequency.size())
      new_freq=fs_new.frequency[i1];
    else
      new_freq=fs_new.frequency.back();

    if (!(old_freq==new_freq)) {
      std::cout << "NEW FREQUENCY !!! \n";
      tr=m1->d_mdev->set_rx_freq(new_freq,i1);
    };


    if (i1<fs_old.gain_rx.size())
       old_gain_rx=fs_old.gain_rx[i1];
    else
       old_gain_rx=fs_old.gain_rx.back();

    if (i1<fs_new.gain_rx.size())
      new_gain_rx=fs_new.gain_rx[i1];
    else
      new_gain_rx=fs_new.gain_rx.back();

     if (!(old_gain_rx==new_gain_rx)) {
        std::cout << "NEW RX GAIN !!! \n";
        m1->d_mdev->set_rx_gain(new_gain_rx,i1);
     }

     if (i1<fs_old.gain_tx.size())
       old_gain_tx=fs_old.gain_tx[i1];
     else
       old_gain_tx=fs_old.gain_tx.back();

     if (i1<fs_new.gain_tx.size())
           new_gain_tx=fs_new.gain_tx[i1];
     else
       new_gain_tx=fs_new.gain_tx.back();

      if (!(old_gain_tx==new_gain_tx)) {
           std::cout << "NEW TX GAIN !!! \n";
           m1->d_mdev->set_tx_gain(new_gain_tx,i1);
           std::cout << "new_gain_tx=" << new_gain_tx << std::endl;
      }


  };
  for (uint32_t i2=0;i2<d_no_ant2;i2++) {
                 

      uint32_t i1;
      i1=i2+d_no_ant1;

      if (i1<fs_old.frequency.size())
        old_freq=fs_old.frequency[i1];
      else {
        old_freq=fs_old.frequency.back();
      };
      if (i1<fs_new.frequency.size())
        new_freq=fs_new.frequency[i1];
      else
        new_freq=fs_new.frequency.back();


      if (!(old_freq==new_freq)) {
        tr=m2->d_mdev->set_rx_freq(i2,new_freq);
      };

      if (i1<fs_old.gain_rx.size())
        old_gain_rx=fs_old.gain_rx[i1];
      else
         old_gain_rx=fs_old.gain_rx.back();

       if (i1<fs_new.gain_rx.size())
         new_gain_rx=fs_new.gain_rx[i1];
       else
         new_gain_rx=fs_new.gain_rx.back();

       if (!(old_gain_rx==new_gain_rx)) {
         m2->d_mdev->set_rx_gain(new_gain_rx,i2);
       }
       if (i1<fs_old.gain_tx.size())
         old_gain_tx=fs_old.gain_tx[i1];
       else
         old_gain_tx=fs_old.gain_tx.back();

       if (i1<fs_new.gain_tx.size())
         new_gain_tx=fs_new.gain_tx[i1];
       else
         new_gain_tx=fs_new.gain_tx.back();

        if (!(old_gain_tx==new_gain_tx)) {
          m2->d_mdev->set_tx_gain(new_gain_tx,i2);
        };


    };

};


void four_multi_node::set_trx_params(frame_settings fs) {
  uhd::tune_result_t tr;  

  for (uint32_t i1=0;i1<d_no_ant1;i1++) {
    if (i1<fs.frequency.size()) {
      tr=m1->d_mdev->set_rx_freq(fs.frequency[i1],i1);
      tr=m1->d_mdev->set_tx_freq(fs.frequency[i1],i1);
    } else {
      tr=m1->d_mdev->set_rx_freq(fs.frequency.back(),i1);
      tr=m1->d_mdev->set_tx_freq(fs.frequency.back(),i1);
    };
    if (i1<fs.gain_rx.size()) {
      m1->d_mdev->set_rx_gain(fs.gain_rx[i1],i1);
    } else
      m1->d_mdev->set_rx_gain(fs.gain_rx.back(),i1);

    if (i1<fs.gain_tx.size())  {
      m1->d_mdev->set_tx_gain(fs.gain_tx[i1],i1);             
    } else {
      m1->d_mdev->set_tx_gain(fs.gain_tx.back(),i1);      
    };
  };
  for (uint32_t i2=0;i2<d_no_ant2;i2++) {
    uint32_t i1;
    i1=i2+d_no_ant1;
       
    if (i1<fs.frequency.size()) {
         tr=m2->d_mdev->set_rx_freq(fs.frequency[i1],i2);
         tr=m2->d_mdev->set_tx_freq(fs.frequency[i1],i2);
    }
    else {
       tr=m2->d_mdev->set_rx_freq(fs.frequency.back(),i2);
       tr=m2->d_mdev->set_tx_freq(fs.frequency.back(),i2);
    };

    if (i1<fs.gain_rx.size()) {
      m2->d_mdev->set_rx_gain(fs.gain_rx[i1],i2);
    }
     else
       m2->d_mdev->set_rx_gain(fs.gain_rx.back(),i2);

    if (i1<fs.gain_tx.size()) 
       m2->d_mdev->set_tx_gain(fs.gain_tx[i1],i2);
    else
        m2->d_mdev->set_tx_gain(fs.gain_tx.back(),i2);

   };
  
}

#if 0
void four_multi_node::change_buffer_length(uint32_t new_buffer_length){

  std::complex<int16_t> *temp_buffer;
  for (uint32_t i1=0;i1<d_no_ant;i1++) {
    temp_buffer=(std::complex<int16_t> *) d_tx_buffers[i1];
    delete[] temp_buffer;
    temp_buffer=new std::complex<int16_t>[new_buffer_length];
    d_tx_buffers[i1]=temp_buffer;
  };

  for (uint32_t i1=0;i1<d_no_ant;i1++) {
    temp_buffer=(std::complex<int16_t> *) d_rx_buffers[i1];
    delete[] temp_buffer;
    temp_buffer=new std::complex<int16_t>[new_buffer_length];
    d_rx_buffers[i1]=temp_buffer;
  };

  d_buffer_length=new_buffer_length;

};
#endif