utils/txm.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 <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 <cstdio>
#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[]){





    static const time_t time_available_for_trigger=1;

    //variables to be set by po
    std::string dev_name;
    time_t seconds_in_future;
    uint32_t total_num_samps, no_chan, skip_ant, no_times, gps_time_combined;
    double tx_rate, freq;
    bool use_external_10MHz, use_J1;
    
    std::string filename;
    std::string gains_str;
    itpp::vec gains; // IT++ class



    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
      ("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") 
        ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), 
         "external 10MHz on 'REF CLOCK' connector (true=1=yes)")
      ("gains",po::value<std::string>(&gains_str)-> default_value("0 0 0 0 0 0 0 0"),  "sets the transmitter gains") 
          ("nchan", po::value<uint32_t>(&no_chan)->default_value(1), "number of usrp2:s")
        ("help", "help message")
        ("nsamps", po::value<uint32_t>(&total_num_samps)->default_value(1000), "total number of samples to transmit")
      ("txrate", po::value<double>(&tx_rate)->default_value(25e6), "rate of outgoing samples")
        ("freq", po::value<double>(&freq)->default_value(0), "rf center frequency in Hz")
        ("filename",po::value<std::string>(&filename)->default_value("data_to_usrp.dat"), "input filename")
        ("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")
        ("use_J1",po::value<bool>(&use_J1)->default_value(true), "Use J1 as input")
        ("no_times",po::value<uint32_t>(&no_times)->default_value(0), "")
    ;

    

    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 TX Timed Samples %s") % desc << std::endl;
        return ~0;
    }
    seconds_in_future=1.0;

    if (uhd::set_thread_priority_safe(1,true)) {
       std::cout << "set priority went well " << std::endl;
    };


    std::string IP_addresses,IP_addresses1;  // Adresses of the USRPs

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


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

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

   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+=" ";
     }
    };


    uhd::usrp::multi_usrp::sptr d_mdev=uhd::usrp::multi_usrp::make(dev_addr);
    uhd::device::sptr sdev = 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_tx_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);
        };
      };
    };


   // Create storage for the entire transmitted signal.
   std::complex<int16_t> *d_buffer;
   std::vector<const void *> d_tx_buffers; 
   for (uint32_t i1=0;i1<no_chan;i1++) {
     d_buffer = new std::complex<int16_t>[total_num_samps];   
     d_tx_buffers.push_back(d_buffer);
   };
    

    /* Read input from disc */
    FILE *fp = 0;
    fp = fopen(filename.c_str(), "rb");    
    if (fp == 0){
        perror(filename.c_str());
        return 1;
    }
    for (uint32_t i1=0;i1<no_chan;i1++) {
      d_buffer = (std::complex<short int>*) d_tx_buffers[i1];
      fread(d_buffer, sizeof(uint32_t),total_num_samps, fp);
    };
    fclose(fp);

    d_buffer = (std::complex<short int>*) d_tx_buffers[0];
    std::cout << "buffer[1]=" << d_buffer[1] << std::endl;
    std::cout << "buffer[2]=" << d_buffer[2] << std::endl;


    
 
    // Internal variables // PZ
    uhd::clock_config_t my_clock_config; //PZ


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

    uhd::tune_result_t tr;

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

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

   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) {
      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;

 
    };   


   
    uhd::tx_metadata_t md;
    size_t num_tx_samps;

   

    md.start_of_burst = true;
    md.end_of_burst = false;
    if (no_times==1)
      md.end_of_burst = true;
    if (gps_time_combined>0) {
       md.has_time_spec = true;
       md.time_spec = uhd::time_spec_t(seconds_in_future);
    }
    else
       md.has_time_spec = false;


     
    //send the entire buffer, let the driver handle fragmentation
    num_tx_samps =sdev->send(
              d_tx_buffers, total_num_samps, md,
              uhd::io_type_t::COMPLEX_INT16,
             uhd::device::SEND_MODE_FULL_BUFF);

      
     md.start_of_burst = false;
     md.has_time_spec = false;
     bool done=false;          



     if (no_times==0) {
        while (1) {
          num_tx_samps = sdev->send(
              d_tx_buffers, total_num_samps, md,
              uhd::io_type_t::COMPLEX_INT16,
             uhd::device::SEND_MODE_FULL_BUFF);
        }} 
     else {

          std::cout << "hej \n";
          done=false;
          int no_tries=0;




       
         for (uint32_t i1=1; i1<no_times-1;i1++) {
           std::cout << "i1=" << i1 << "\n";
           num_tx_samps = sdev->send(
           d_tx_buffers, total_num_samps, md,
              uhd::io_type_t::COMPLEX_INT16,
             uhd::device::SEND_MODE_FULL_BUFF);     

          };
          md.end_of_burst = true;
          if (no_times>1) {
            num_tx_samps = sdev->send(
              d_tx_buffers, total_num_samps, md,
              uhd::io_type_t::COMPLEX_INT16,
             uhd::device::SEND_MODE_FULL_BUFF); 
          };
          done=false;
          while (!done) {
            sdev->recv_async_msg(async_metadata,0.1);
            done=(async_metadata.event_code==uhd::async_metadata_t::EVENT_CODE_BURST_ACK);
          };    

   };
     

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

    return 0;
}