Here's the rx streamer init. It is in the main function after initializing
the usrp device. This happens with both sc8 and sc16 wire format with
float32 cpu format.
uhd::stream_args_t rx_stream_args("fc32",wire); //complex floats
rx_stream_args.args["spp"] = str( boost::format( "%u" ) % spb );
std::vector<size_t> rx_channel_nums (
rx_channels, rx_channels + sizeof(rx_channels) /
sizeof(rx_channels[0]));
rx_stream_args.channels = rx_channel_nums;
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(rx_stream_args);
thanks,
- mitch
On Sun, Oct 14, 2018 at 1:35 PM Marcus Müller <marcus.muel...@ettus.com>
wrote:
> Hi Mitch,
>
> where/how do you create the rx_streamer, and which otw / cpu format
> does that use?
>
> Best regards,
>
> Marcus
> On Thu, 2018-10-11 at 11:53 -0400, Mitch Grabner via USRP-users wrote:
> > I'm doing a loopback to check which sample a certain signal level is
> > found. I'm transmitting in the main thread and I create a receiver
> > thread to look for the rise in the input signal. Here is my receiver
> > worker
> >
> > void receive_worker(
> > uhd::usrp::multi_usrp::sptr usrp,
> > std::vector<std::complex<float> > rx_buff,
> > uhd::rx_streamer::sptr rx_stream,
> > size_t total_num_rx_samps,
> > double time_to_receive,
> > std::queue<size_t>* edge_queue,
> > bool* stop_receive
> > ){
> > io_mutex.lock();
> > std::cout << boost::format("Receive thread started!") << std::endl;
> > io_mutex.unlock();
> >
> > //set buffers same for all channels (if more than 1)
> > std::vector<std::complex<float> *> rx_buffs(rx_stream-
> > >get_num_channels(), &rx_buff.front());
> >
> > //setup streaming
> > uhd::stream_cmd_t stream_cmd((total_num_rx_samps == 0)?
> > uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS:
> > uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE
> > );
> >
> > io_mutex.lock();
> > // if we are looking for a finite set of samples
> > if (total_num_rx_samps > 0){
> > std::cout << boost::format(
> > "Begin streaming in for %u samples starting at %0.9f device
> > time"
> > ) % total_num_rx_samps % time_to_receive << std::endl;
> > }
> > else{
> > std::cout << boost::format(
> > "Begin streaming in continuous samples starting at %0.9f
> > device time"
> > ) % time_to_receive << std::endl;
> > }
> > io_mutex.unlock();
> >
> > //set up the RX command
> > stream_cmd.num_samps = total_num_rx_samps;
> > stream_cmd.stream_now = false;
> > stream_cmd.time_spec = uhd::time_spec_t(time_to_receive);
> > rx_stream->issue_stream_cmd(stream_cmd);
> >
> > //meta-data will be filled in by recv()
> > uhd::rx_metadata_t rx_md;
> >
> > double rx_timeout = time_to_receive + 0.1;
> > size_t num_acc_samps = 0;
> > /* ------------- Main While Loop --------------- */
> > while(not *stop_receive and (num_acc_samps < total_num_rx_samps or
> > total_num_rx_samps == 0)){
> > //rece ive a single full otw packet
> > size_t num_rx_samps = rx_stream->recv(
> > rx_buffs, rx_buff.size(), rx_md, rx_timeout, true
> > );
> > rx_timeout = 0.1f; //small timeout for subsequent recv
> >
> > //error handling
> > if (rx_md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){
> > io_mutex.lock();
> > std::cout << boost::format(
> > "Receiver Error %s ... Shutting down!"
> > ) % rx_md.strerror() << std::endl;
> > io_mutex.unlock();
> > //set stop receive signal
> > *stop_receive = true;
> > }
> >
> > //look for a single rising edge
> > edge_offset_calc(rx_buff, num_acc_samps, edge_queue);
> >
> >
> > //keep track of absolute sample number
> > num_acc_samps += num_rx_samps;
> >
> > //if we were streaming continuously, send a stop command
> > if (*stop_receive and total_num_rx_samps == 0){
> > // Shut down receiver
> > std::cout << boost::format("Sending stop command...") <<
> > std::endl;
> > stream_cmd.stream_mode =
> > uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS;
> > rx_stream->issue_stream_cmd(stream_cmd);
> > }
> > }//RX while
> >
> > boost::this_thread::sleep(boost::posix_time::seconds(0.2)); //wait
> >
> > io_mutex.lock();
> > std::cout << boost::format("Receive thread ended!") << std::endl;
> > io_mutex.unlock();
> > }
> >
> > I create the rx thread with:
> >
> > //edge queue
> > std::queue<size_t> edge_queue;
> > bool stop_receive = false;
> >
> > //start the thread
> > boost::thread_group transmit_thread;
> > transmit_thread.create_thread(
> > boost::bind(
> > &receive_worker, usrp, rx_buff, rx_stream, total_num_rx_samps,
> > time_to_receive, &edge_queue, &stop_receive
> > )
> > );
> >
> > the edge calc function simply iterates through the vector and pushes
> > the sample location of the rise in signal level (2-norm of the
> > complex float) to the queue. When debugging I sometimes get this kind
> > of output after starting up the device
> >
> > Setting device timestamp to 0...
> > Transmitting 50 samples at 0.200000000 device time
> > Receive thread started!
> > Begin streaming in for 400000 samples starting at 0.190000000 device
> > time
> > Transmit burst success!
> > max is 0.358725
> > Edge found on sample 200164 packet offset of 164
> > max is 2.0942e+34
> > Edge found on sample 242000 packet offset of 2000
> > max is 2.0942e+34
> > Edge found on sample 244000 packet offset of 2000
> > max is 2.0943e+34
> > Edge found on sample 254000 packet offset of 2000
> > max is inf
> > Edge found on sample 262000 packet offset of 2000
> > max is inf
> > Edge found on sample 264000 packet offset of 2000
> > max is 2.09449e+34
> > Edge found on sample 272000 packet offset of 2000
> > max is 2.09449e+34
> > Edge found on sample 274000 packet offset of 2000
> > Receive thread ended!
> >
> > My spp is forced to 2000 using the stream args. and This is on UHD
> > 3.010.03.
> >
> > thanks for the help.
> >
> > On Wed, Oct 10, 2018 at 5:07 PM Michael Dickens <
> > michael.dick...@ettus.com> wrote:
> > > Hi Mitch - Can you provide your code for us to review, to get an
> > > idea of what you're doing that's causing this issue for you?
> > > Without specific code, debugging is a little difficult ... And, no,
> > > I haven't seen this issue to the best of my knowledge /
> > > understanding of what it might be. Cheers! - MLD
> > >
> > > On Wed, Oct 10, 2018, at 4:03 PM, Mitch Grabner via USRP-users
> > > wrote:
> > > > Hello,
> > > >
> > > > I find that sometimes when I initialize a b200 and start
> > > > streaming in samples I will get buffers with values of infinity
> > > > (especially at the last sample in the buffer). Is this caused by
> > > > a bad packet or overflow condition? It also seems to happen
> > > > randomly.
> > > >
> > > > Thanks for your help,
> > > > - mitch
> >
> >
> > _______________________________________________
> > 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
