examples/file_based_example.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 <four_multi/gps.hpp>
#include <four_multi/four_multi.hpp>

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

class file_based : public four_multi_node {

public:

  file_based(std::string filename_rx, std::string filename_tx, uint32_t buffer_length , std::vector<frame_settings> tdma_def, 
             uint32_t no_ant1, uint32_t no_ant2, 
             bool use_external_10MHz, bool use_same_antenna, uint32_t skip_ant,
             std::vector<std::string> IP);



  ~file_based();
   
   protected:
     double d_gain_rx;
     double d_gain_tx;
     double d_frequency;
     std::vector<frame_settings> d_tdma_def;
     virtual frame_settings node_init(void) ;
     virtual frame_settings node_process(void) ;
     virtual void end_of_run(void) ;
     uint32_t d_no_rx_buffer, d_no_tx_buffer, d_no_rx_buffer_so_far,  d_no_tx_buffer_so_far; 
     uint32_t d_frame_ix, d_no_frames;
     std::string d_filename_rx, d_filename_tx;
     std::vector<const void *> d_tx_storage;

};



frame_settings file_based::node_init(void) {
  uint32_t i1;
  

    d_frame_ix=0;
    d_no_rx_buffer_so_far=0;
    d_no_tx_buffer_so_far=0;

    std::complex<int16_t> *p;


    if (d_tdma_def[d_frame_ix].what==TX) {

      
      for (i1=0;i1<d_no_ant;i1++) {
        p=(std::complex<int16_t> *) d_tx_storage[i1];
        memcpy ( (void *) d_tx_buffers[i1], 
                  p,
                 //
                 d_buffer_length*4 );
      
      };

      d_no_tx_buffer_so_far++;
      
    };

       
    return d_tdma_def[0];

};                  


file_based::file_based(std::string filename_rx, std::string filename_tx, uint32_t buffer_length , std::vector<frame_settings> tdma_def, 
             uint32_t no_ant1, uint32_t no_ant2, 
                       bool use_external_10MHz, bool use_same_antenna, uint32_t skip_ant, std::vector<std::string> IP):
  four_multi_node(buffer_length, no_ant1, no_ant2,use_external_10MHz ,
             use_same_antenna,0,IP,false,skip_ant)
{

  d_buffer_length=buffer_length;    
  d_tdma_def=tdma_def;
  
  d_filename_rx=filename_rx;
  d_filename_tx=filename_tx;

  d_no_rx_buffer=0;
  d_no_tx_buffer=0;


  for (uint32_t i1=0;i1<d_tdma_def.size();i1++) {
      if ((d_tdma_def[i1].what)==TX)
        d_no_tx_buffer++;
      if ((d_tdma_def[i1].what)==RX)
        d_no_rx_buffer++;
  };


  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_no_tx_buffer];
      d_tx_storage.push_back(temp_buffer);
  };


  if (d_no_rx_buffer>0)
    save_raw_input_on_file(d_no_rx_buffer,filename_rx);



  if (d_no_tx_buffer>0) {
       std::ifstream s1; //(d_filename_tx.c_str(), std::ios::binary);  


       s1.open(d_filename_tx.c_str(), std::ios::binary);       

       for (uint32_t i1=0;i1<d_no_ant;i1++) {
         s1.read((char *) d_tx_storage[i1],d_buffer_length*d_no_tx_buffer*4); 
       };


       s1.close(); 
      
  }



};


void file_based::end_of_run(){


   std::cout << "d_no_rx_buffer=" << d_no_rx_buffer << std::endl;
   std::cout << "d_buffer_length=" << d_buffer_length << std::endl;



};

file_based::~file_based(){

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

};

frame_settings file_based::node_process(void) {

  std::complex<int16_t> *p1;
  void *p2;


  if (d_old_frame_settings.what==RX) {




    d_no_rx_buffer_so_far++;
  };

  


  if (d_frame_ix==(d_tdma_def.size()-1)) {

    std::cout << "END! \n";
    frame_settings frame;
    frame.what=END;
    return frame;
  } else {


    d_frame_ix++;  
    if (d_tdma_def[d_frame_ix].what==TX) {
      for (uint32_t i1=0;i1<d_no_ant;i1++) {
        
        p1=(std::complex<int16_t> *) d_tx_storage[i1];
        p1=&p1[d_no_tx_buffer_so_far*d_buffer_length];
        p2=(void *) d_tx_buffers[i1];
        memcpy (p2, p1, d_buffer_length*4 );
      };
      d_no_tx_buffer_so_far++;
    };
    

    
    return d_tdma_def[d_frame_ix];
  };

  

}



int UHD_SAFE_MAIN(int argc, char *argv[]){
    
    
    
    if (!(uhd::set_thread_priority_safe(1,true))) {
      std::cout << "Failed setting priority, using sudo?  " << std::endl;
    };
   

    //variables to be set by po

    double freq,freq2;
    double d_time;
    bool use_external_10MHz,trigger_with_pps, use_same;
    std::string filename_rx, filename_tx, dev_name;
    uint32_t start_time;
    float gain_rx, gain_tx, gain_rx2;
    uint32_t node_ix, no_ant, Nsamples, Nframes, skip_ant;
    double rate;


    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
        ("help", "help message")
        ("freq", po::value<double>(&freq)->default_value(2490e6), "rf center frequency in Hz")
        ("freq2", po::value<double>(&freq2)->default_value(0), "second center frequency in Hz")
        ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(true), 
         "external 10MHz on 'REF CLOCK' connector (true=1=yes)")
        ("use_same",po::value<bool>(&use_same)->default_value(false), 
         "Use J1 for RX as well as TX")
        ("PPS",po::value<bool>(&trigger_with_pps)->default_value(false),
         "trigger reception with 'PPS IN' connector (true=1=yes)")
        ("filename_tx",po::value<std::string>(&filename_tx)->default_value("data_to_usrp.dat"), 
         "filename of data to USRP") 
        ("filename_rx",po::value<std::string>(&filename_rx)->default_value("data_from_usrp.dat"), 
         "filename of data from USRP") 
        ("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") 
        ("gain_rx",po::value<float>(&gain_rx)->default_value(0), "receiver gain") 
        ("gain_rx2",po::value<float>(&gain_rx2)->default_value(1000), "second receiver gain") 
        ("gain_tx",po::value<float>(&gain_tx)->default_value(0), "transmitter gain")
        ("node_ix",po::value<uint32_t>(&node_ix)->default_value(0), "node index")
        ("no_ant",po::value<uint32_t>(&no_ant)->default_value(1), 
          "number of antennas (or more precisely - the number of USRP2s")
        ("skip_ant",po::value<uint32_t>(&skip_ant)->default_value(0), 
          "Example: if skip_ant=1 then the first USPR2 should have address 192.168.20.2")
        ("Nsamples",po::value<uint32_t>(&Nsamples)->default_value(10000), 
          "Number of samples per buffer")
        ("Nframes",po::value<uint32_t>(&Nframes)->default_value(4), 
          "Number of frames (Nframes/2 in each direction)")
        ("d_time", po::value<double>(&d_time)->default_value(0.012), "time between frames")
        ("rate", po::value<double>(&rate)->default_value(25e6), "sample-rate")

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

    /* Here choose tdma_def */
    std::vector<frame_settings> tdma_def;
    frame_settings frame;
    std::vector<double> temp_double_vector;
    std::vector<double> temp_double_vector2;

    temp_double_vector.resize(1);
    temp_double_vector2.resize(2);


    for (uint32_t i1=0;i1<Nframes;i1 ++ ) {


      if (freq2>0) {
         temp_double_vector2[0]=freq;
         temp_double_vector2[1]=freq2;
         frame.frequency=temp_double_vector2;
      } else {
        temp_double_vector[0]=freq;
        frame.frequency=temp_double_vector;
      };

      if (gain_rx2<1000) {
        temp_double_vector[0]=gain_rx;
        temp_double_vector[1]=gain_rx2;
        frame.gain_rx=temp_double_vector2;
      } else {
        temp_double_vector[0]=gain_rx;
        frame.gain_rx=temp_double_vector;
      };
        

      temp_double_vector[0]=gain_tx;
      frame.gain_tx=temp_double_vector;
      frame.time=i1*d_time;

      if ((i1 % 2)==(node_ix %2)) {
        frame.what=RX;  
      }
      else {
        frame.what=TX;
        //std::cout << "i1=" << i1 << std::endl;
      }

      tdma_def.push_back(frame);

    };

    
    std::cout << "number of frames=" << tdma_def.size() << std::endl;

    std::vector<std::string> IP_addresses;

    file_based my_file_based(filename_rx,filename_tx,Nsamples,tdma_def,
                             no_ant,0,use_external_10MHz,use_same,
                             skip_ant,std::vector<std::string>(0)) ;

    gps_wait_until(dev_name.c_str(),start_time);

    std::cout << "OK, we got here!" << std::endl;

    my_file_based.run();        

    return 0;
}