Also, please don't open a new thread if you have already opened one for the same issue ([USRP-users] Help with rx_multi_sample) that is waiting for details from your side.
On 08/09/2017 05:40 PM, Marcus D. Leech via USRP-users wrote: > 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 -- Julian Arnold, M.Sc. Institute for Networked Systems RWTH Aachen University Kackertstrasse 9 52072 Aachen Germany _______________________________________________ USRP-users mailing list USRP-users@lists.ettus.com http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com