Could you perhaps post a complete log of your program run?
On 2017-08-09 13:12, Snehasish Kar wrote:
> Sorry for that, basically I tried the below code, but I get an error saying
> "TIMEOUT". So not able to understand where I am going wrong. Please help!
>
> BR
>
> Snehasish
> -------------------------
>
> FROM: USRP-users <usrp-users-boun...@lists.ettus.com> on behalf of Marcus D.
> Leech via USRP-users <usrp-users@lists.ettus.com>
> SENT: Wednesday, August 9, 2017 9:10:51 PM
> TO: usrp-users@lists.ettus.com
> SUBJECT: Re: [USRP-users] help with receivng multiple frequencies
>
> 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
