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

Reply via email to