On 08/09/2017 10:29 AM, Snehasish Kar via USRP-users wrote:

Hi

I am trying to receive multiple frequencies with one usro x310 separately from two daughter boards. But not able to receive it properly. Below is my code. Please help me with it.

Could you describe what you mean by "not properly receive it"?


#include <fstream>
#include <iostream>
#include <csignal>
#include <stdlib.h>
#include <complex>
#include <string.h>
#include "../include/conf.hpp"
#include <boost/format.hpp>
#include <boost/thread.hpp>
#include <uhd/types/tune_request.hpp>
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <uhd/exception.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/program_options.hpp>
#include <boost/algorithm/string.hpp>

static bool stop_signal_called = false;
void sig_int_handler(int){
    stop_signal_called = true;
}

void startStreaming(uhd::rx_streamer::sptr rx_stream, uhd::usrp::multi_usrp::sptr usrp){
    //setup streaming
    size_t total_num_samps = 10000;
    double seconds_in_future = 1.5;
    std::cout << std::endl;
    std::cout << boost::format(
          "Begin streaming %u samples, %f seconds in the future..."
    ) % total_num_samps % seconds_in_future << std::endl;
uhd::stream_cmd_t stream_cmd((total_num_samps ==0)? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS:uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);
    stream_cmd.num_samps = size_t(total_num_samps);
    stream_cmd.stream_now = true; //true
    stream_cmd.time_spec = uhd::time_spec_t();
rx_stream->issue_stream_cmd(stream_cmd); //tells all channels to stream

    //meta-data will be filled in by recv()
    uhd::rx_metadata_t md;

    //allocate buffers to receive with samples (one buffer per channel)
    const size_t samps_per_buff = rx_stream->get_max_num_samps();
std::vector<std::vector<std::complex<float> > > buffs(usrp->get_rx_num_channels(), std::vector<std::complex<float> >(samps_per_buff));

    //create a vector of pointers to point to each of the channel buffers
    std::vector<std::complex<float> *> buff_ptrs;
for (size_t i = 0; i < buffs.size(); i++) buff_ptrs.push_back(&buffs[i].front()); double timeout = 3.0;//seconds_in_future + 0.1; //timeout (delay before receive + padding)
    size_t num_acc_samps = 0; //number of accumulated samples
    while(num_acc_samps < total_num_samps){
     //receive a single packet
size_t num_rx_samps = rx_stream->recv(buff_ptrs, samps_per_buff, md, timeout);
     //use a small timeout for subsequent packets
     timeout = 0.1;
     //handle the error code
     if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) break;
     if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){
throw std::runtime_error(str(boost::format("Receiver error %s") % md.strerror()));
     }
std::cout << boost::format("Received packet: %u samples, %u full secs, %f frac secs") % num_rx_samps % md.time_spec.get_full_secs() % md.time_spec.get_frac_secs() << std::endl;
          num_acc_samps += num_rx_samps;
     }
if (num_acc_samps < total_num_samps) std::cerr << "Receive timeout before all samples received..." << std::endl;
     //finished
     std::cout << std::endl << "Done!" << std::endl << std::endl;
}

typedef boost::function<uhd::sensor_value_t (const std::string&)> get_sensor_fn_t;

bool check_locked_sensor(std::vector<std::string> sensor_names, const char* sensor_name, get_sensor_fn_t get_sensor_fn, double setup_time){ if (std::find(sensor_names.begin(), sensor_names.end(), sensor_name) == sensor_names.end())
        return false;

    boost::system_time start = boost::get_system_time();
    boost::system_time first_lock_time;

    std::cout << boost::format("Waiting for \"%s\": ") % sensor_name;
    std::cout.flush();

    while (true) {
        if ((not first_lock_time.is_not_a_date_time()) and
(boost::get_system_time() > (first_lock_time + boost::posix_time::seconds(setup_time))))
        {
            std::cout << " locked." << std::endl;
            break;
        }
        if (get_sensor_fn(sensor_name).to_bool()){
            if (first_lock_time.is_not_a_date_time())
                first_lock_time = boost::get_system_time();
            std::cout << "+";
            std::cout.flush();
        }
        else {
first_lock_time = boost::system_time(); //reset to 'not a date time'

if (boost::get_system_time() > (start + boost::posix_time::seconds(setup_time))){
                std::cout << std::endl;
throw std::runtime_error(str(boost::format("timed out waiting for consecutive locks on sensor \"%s\"") % sensor_name));
            }
            std::cout << "_";
            std::cout.flush();
        }
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
    }
    std::cout << std::endl;
    return true;
}


int UHD_SAFE_MAIN(int argc, char *argv[]){
    uhd::set_thread_priority_safe();
    int i=0;
    std::string args, type ;
    struct rfSettings rfParam[3];
    double rate, freq, gain, bw, setupTime, totalTime;
    memset(rfParam,0x00,sizeof(rfParam));

/*****************************Koyel to check***************************/

    rfParam[0].freq = 935800000;
    strcpy(rfParam[0].band,"P-GSM");
    rfParam[0].bandwidth = 25000000;
    rfParam[0].samplerate = 50000000;
    rfParam[0].total_time = 0x00;
    rfParam[0].setup_time = 1.0;

    rfParam[1].freq = 925000000;
    strcpy(rfParam[1].band,"E-GSM");
    rfParam[1].bandwidth = 35000000;
    rfParam[1].samplerate = 70000000;
    rfParam[1].setup_time = 1.0;

    rfParam[2].freq = 1805200000;
    strcpy(rfParam[1].band,"DCS");
    rfParam[2].bandwidth = 74600000;
    rfParam[2].samplerate = 149200000;
    rfParam[2].setup_time = 1.0;

/*************************************************************************/

    std::string subdev("A:0 B:0");
    std::string sync("internal");
    for(i=0;i<3;i++){
        if(strcmp(rfParam[i].band,"P-GSM")==0x00){
            rate = rfParam[i].samplerate;
            freq = rfParam[i].freq;
            gain = rfParam[i].gain;
            bw = rfParam[i].bandwidth;
            setupTime = rfParam[i].setup_time;
            totalTime = rfParam[i].total_time;
            break;
        }
    }

    //create a usrp device
        std::cout << std::endl;
std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);

//always select the subdevice first, the channel mapping affects the other settings
        usrp->set_rx_subdev_spec(subdev); //sets across all mboards
std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;

        //set the rx sample rate (sets across all channels)
std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl;
        usrp->set_rx_rate(rate);
std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl << std::endl; std::cout << boost::format("Setting device timestamp to 0...") << std::endl;
        if (sync == "now"){
//This is not a true time lock, the devices will be off by a few RTT. //Rather, this is just to allow for demonstration of the code below.
            usrp->set_time_now(uhd::time_spec_t(0.0));
        }
        else if (sync == "pps"){
            usrp->set_time_source("external");
usrp->set_time_unknown_pps(uhd::time_spec_t(0.0));
boost::this_thread::sleep(boost::posix_time::seconds(1)); //wait for pps sync pulse
        }
        else if (sync == "mimo"){
            UHD_ASSERT_THROW(usrp->get_num_mboards() == 2);

            //make mboard 1 a slave over the MIMO Cable
            usrp->set_clock_source("mimo", 1);
            usrp->set_time_source("mimo", 1);

            //set time on the master (mboard 0)
            usrp->set_time_now(uhd::time_spec_t(0.0), 0);

            //sleep a bit while the slave locks its time to the master
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
        }
        else if(sync=="internal"){
            usrp->set_time_source(sync);
        }
        /*
         * create a receive streamer
* linearly map channels (index0 = channel0, index1 = channel1, ...)
         */
        uhd::stream_args_t stream_args("fc32","sc16"); //complex floats
        stream_args.channels = boost::assign::list_of(0)(1);
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
        std::signal(SIGINT, &sig_int_handler);
        std::cout << "Press Ctrl + C to stop streaming..." << std::endl;
check_locked_sensor(usrp->get_rx_sensor_names(0), "lo_locked", boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp, _1, 0), rfParam[0].setup_time);
        startStreaming(rx_stream,usrp);
}


BR

Snehasish



_______________________________________________
USRP-users mailing list
USRP-users@lists.ettus.com
http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com

_______________________________________________
USRP-users mailing list
USRP-users@lists.ettus.com
http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com

Reply via email to