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.
#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
