utils/rxm.cpp

//
// Copyright 2011-2013 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 <complex>
#include <uhd/types/clock_config.hpp>
#include <itpp/itbase.h>
#include <four_multi/get_usrp2_ip_addr.hpp>
#include <four_multi/gps.hpp>



namespace po = boost::program_options;

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


    double d_rate;
    static const time_t time_available_for_trigger=1;

    //variables to be set by po
    std::string args;
    time_t seconds_in_future=1;
    uint32_t total_num_samps, gps_time_combined;
    uint32_t no_chan, skip_ant;
    double freq;
    std::string filename, dev_name;
    bool use_external_10MHz, use_J1;

    std::string gains_str;
    itpp::vec gains; // IT++ class
    //std::vector<double> gains_vec;
    std::string IP_addresses, IP_addresses1;  // Adresses of the USRPs
    

    // Internal variables 
    uhd::clock_config_t my_clock_config; 

    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
        ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), 
         "external 10MHz on 'REF CLOCK' connector (true=1=yes)")
      ("gps_time_combined", po::value<uint32_t>(&gps_time_combined)->default_value(0), "start time triggering using GPS and PPS (h*3600+m*60+s, or =0 no triggering)")
("dev_name",po::value<std::string>(&dev_name)->default_value("/dev/ttyUSB0"), "Name of GPS device") 
       ("help", "help message")
        ("rate", po::value<double>(&d_rate)->default_value(25e6), "sample rate")
        ("nsamps", po::value<uint32_t>(&total_num_samps)->default_value(1000), "total number of samples to receive")
        ("nchan", po::value<uint32_t>(&no_chan)->default_value(1), "number of usrp2:s")
        ("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")
         ("freq", po::value<double>(&freq)->default_value(2420e6), "rf center frequency in Hz")
      ("filename",po::value<std::string>(&filename)->default_value("data_from_usrp.dat"), "output filename") 
     ("gains",po::value<std::string>(&gains_str)->default_value("0 0 0 0"), 
   "set the receiver gains")
        ("use_J1",po::value<bool>(&use_J1)->default_value(true), "Use J1 as input")
 
    ;
    po::variables_map vm;
    po::store(po::parse_command_line(argc, argv, desc), vm);
    po::notify(vm);
    


    //print the help message
    if (vm.count("help")){
        std::cout << boost::format("UHD RX Timed Samples %s") % desc << std::endl;
        return ~0;
    }

    if (!(uhd::set_thread_priority_safe(1,true))) {
      std::cout << "Problem setting thread priority" << std::endl;
      return 1;
    };


       
   gains=gains_str.c_str();  
   IP_addresses=get_usrp2_ip_addr(no_chan+skip_ant);

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


   //create a usrp device
   uhd::device_addr_t dev_addr;


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

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

  };





   uhd::usrp::multi_usrp::sptr d_mdev=uhd::usrp::multi_usrp::make(dev_addr);
   uhd::device::sptr dev = d_mdev->get_device();
   

   std::string config = d_mdev->get_pp_string();
   uint32_t temp;
   bool is_basic, is_xcvr2450;
   
   std::cout << "config=" << config << std::endl;

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

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

   std::cout << "is_basic=" << is_basic << std::endl;
   std::cout << "is_xcvr2450=" << is_xcvr2450 << std::endl;

   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_basic) {
     uhd::usrp::subdev_spec_t spec("A:A");
     for (uint32_t i1=0;i1<no_chan;i1++) {
        d_mdev->set_rx_subdev_spec(spec, i1);
     };
   };
   if (is_xcvr2450) {
     if (use_J1) {
       for (uint32_t i1=0;i1<no_chan;i1++) {
         d_mdev->set_tx_antenna("J2",i1);
         d_mdev->set_rx_antenna("J1",i1);
       };
     } else {
       for (uint32_t i1=0;i1<no_chan;i1++) {
         d_mdev->set_tx_antenna("J1",i1);
         d_mdev->set_rx_antenna("J2",i1);
       };
     };
   };


   d_mdev->set_rx_rate(d_rate);
   d_mdev->set_tx_rate(d_rate);

   

   uhd::tune_result_t tr;

   for (uint32_t i1=0;i1<no_chan;i1++) {
     tr=d_mdev->set_rx_freq(freq,i1);
     if ((int) i1<gains.size())        
       d_mdev->set_rx_gain(gains(i1),i1);
     else {
       d_mdev->set_rx_gain(gains(gains.size()-1),i1);
     };
   };
   


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

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

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


    usleep(1e5); // Wait for freq and gain to settle

    if (gps_time_combined==0) {
      for (uint32_t i1=0;i1<no_chan;i1++) {
        d_mdev->set_time_now(uhd::time_spec_t(0.0));
      };
    } else {
      
      // Sync the node to pps   
      //uhd::time_spec_t offset_time(0.0);
      if (gps_time_combined>1) {
        gps_wait_until(dev_name.c_str(),gps_time_combined);
      };
      d_mdev->set_time_next_pps(uhd::time_spec_t(0.0));
      std::cout << "Wait for pps!" << std::endl;
      usleep(1e6*time_available_for_trigger); 
      std::cout << "Sync done" << std::endl;
    };
      
    //} else {
    //    offset_time=d_mdev->get_time_now(0);
    //};

   // Create storage for the entire received signal.
   std::complex<int16_t> *d_buffer_rx;
   std::vector<void *> d_rx_buffers;

   for (uint32_t i1=0;i1<no_chan;i1++) {
     d_buffer_rx = new std::complex<int16_t>[total_num_samps];   
     d_rx_buffers.push_back(d_buffer_rx);
   };

    

    //setup streaming
    //std::cout << std::endl;
    //std::cout << boost::format("Begin streaming %u samples, %d seconds in the future...")
    //    % total_num_samps % seconds_in_future << std::endl;
    uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);
    stream_cmd.num_samps = total_num_samps;
    stream_cmd.stream_now = false;
    stream_cmd.time_spec = uhd::time_spec_t(seconds_in_future);
    d_mdev->issue_stream_cmd(stream_cmd);


    uhd::rx_metadata_t md_rx;
    unsigned int num_rx_samps=0;


    while (num_rx_samps==0) {

   
      num_rx_samps=dev->recv(
                                     d_rx_buffers,
                                     total_num_samps,
                                     md_rx,
            uhd::io_type_t::COMPLEX_INT16, // PZ
            uhd::device::RECV_MODE_FULL_BUFF // PZ
       );



    };

    


    //finished
    std::cout << std::endl << "Done!" << std::endl << std::endl; // PZ

    // Save output to disc
    std::ofstream s1(filename.c_str(), std::ios::binary);   // PZ
    for (uint32_t i1=0;i1<no_chan;i1++) {
      d_buffer_rx = (std::complex<short int>*) d_rx_buffers[i1];
      s1.write((char *) d_buffer_rx ,4*total_num_samps); //ZP
    };
    s1.flush(); //PZ
    s1.close(); //PZ




    return 0;
}