Re: [USRP-users] weird sample values when receiving on b200
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 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
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 > rx_buff,
> > uhd::rx_streamer::sptr rx_stream,
> > size_t total_num_rx_samps,
> > double time_to_receive,
> > std::queue* 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 *> 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 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.2
Re: [USRP-users] weird sample values when receiving on b200
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 > rx_buff,
> uhd::rx_streamer::sptr rx_stream,
> size_t total_num_rx_samps,
> double time_to_receive,
> std::queue* 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 *> 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 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.2 device time
> Receive thread started!
> Begin streaming in for 40 samples starting at 0.19000 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.
>
Re: [USRP-users] weird sample values when receiving on b200
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 > rx_buff,
uhd::rx_streamer::sptr rx_stream,
size_t total_num_rx_samps,
double time_to_receive,
std::queue* 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 *>
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 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.2 device time
Receive thread started!
Begin streaming in for 40 samples starting at 0.19000 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
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 ini
Re: [USRP-users] weird sample values when receiving on b200
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] weird sample values when receiving on b200
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
