diff options
Diffstat (limited to 'gr-uhd/lib/usrp_sink_impl.cc')
| -rw-r--r-- | gr-uhd/lib/usrp_sink_impl.cc | 321 |
1 files changed, 278 insertions, 43 deletions
diff --git a/gr-uhd/lib/usrp_sink_impl.cc b/gr-uhd/lib/usrp_sink_impl.cc index 828537fab3..b6a98391be 100644 --- a/gr-uhd/lib/usrp_sink_impl.cc +++ b/gr-uhd/lib/usrp_sink_impl.cc @@ -20,19 +20,20 @@ * Boston, MA 02110-1301, USA. */ +#include <climits> +#include <stdexcept> #include "usrp_sink_impl.h" #include "gr_uhd_common.h" #include <gnuradio/io_signature.h> #include <boost/make_shared.hpp> -#include <stdexcept> namespace gr { namespace uhd { usrp_sink::sptr usrp_sink::make(const ::uhd::device_addr_t &device_addr, - const ::uhd::io_type_t &io_type, - size_t num_channels) + const ::uhd::io_type_t &io_type, + size_t num_channels) { //fill in the streamer args ::uhd::stream_args_t stream_args; @@ -44,35 +45,55 @@ namespace gr { stream_args.otw_format = "sc16"; //only sc16 known to work for(size_t chan = 0; chan < num_channels; chan++) - stream_args.channels.push_back(chan); //linear mapping + stream_args.channels.push_back(chan); //linear mapping - return usrp_sink::make(device_addr, stream_args); + return usrp_sink::make(device_addr, stream_args, ""); } usrp_sink::sptr usrp_sink::make(const ::uhd::device_addr_t &device_addr, - const ::uhd::stream_args_t &stream_args) + const ::uhd::stream_args_t &stream_args, + const std::string &length_tag_name) { check_abi(); return usrp_sink::sptr - (new usrp_sink_impl(device_addr, stream_args_ensure(stream_args))); + (new usrp_sink_impl(device_addr, stream_args_ensure(stream_args), length_tag_name)); } usrp_sink_impl::usrp_sink_impl(const ::uhd::device_addr_t &device_addr, - const ::uhd::stream_args_t &stream_args) + const ::uhd::stream_args_t &stream_args, + const std::string &length_tag_name) : sync_block("gr uhd usrp sink", args_to_io_sig(stream_args), io_signature::make(0, 0, 0)), _stream_args(stream_args), _nchan(stream_args.channels.size()), - _stream_now(_nchan == 1), - _start_time_set(false) + _stream_now(_nchan == 1 and length_tag_name.empty()), + _start_time_set(false), + _length_tag_key(length_tag_name.empty() ? pmt::PMT_NIL : pmt::string_to_symbol(length_tag_name)), + _nitems_to_send(0), + _curr_freq(stream_args.channels.size(), 0.0), + _curr_lo_offset(stream_args.channels.size(), 0.0), + _curr_gain(stream_args.channels.size(), 0.0), + _chans_to_tune(stream_args.channels.size(), false), + _call_tune(false) { if(stream_args.cpu_format == "fc32") _type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_FLOAT32); if(stream_args.cpu_format == "sc16") _type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_INT16); _dev = ::uhd::usrp::multi_usrp::make(device_addr); + + message_port_register_in(pmt::mp("command")); + set_msg_handler( + pmt::mp("command"), + boost::bind(&usrp_sink_impl::msg_handler_command, this, _1) + ); + //message_port_register_in(pmt::mp("query")); + //set_msg_handler( + //pmt::mp("query"), + //boost::bind(&usrp_sink_impl::msg_handler_query, this, _1) + //); } usrp_sink_impl::~usrp_sink_impl() @@ -133,10 +154,40 @@ namespace gr { usrp_sink_impl::set_center_freq(const ::uhd::tune_request_t tune_request, size_t chan) { + _curr_freq[chan] = tune_request.target_freq; + if (tune_request.rf_freq_policy == ::uhd::tune_request_t::POLICY_MANUAL) { + _curr_lo_offset[chan] = tune_request.rf_freq - tune_request.target_freq; + } else { + _curr_lo_offset[chan] = 0.0; + } chan = _stream_args.channels[chan]; return _dev->set_tx_freq(tune_request, chan); } + ::uhd::tune_result_t + usrp_sink_impl::_set_center_freq_from_internals(size_t chan) + { + _chans_to_tune[chan] = false; + if (_curr_lo_offset[chan] == 0.0) { + return _dev->set_tx_freq(_curr_freq[chan], _stream_args.channels[chan]); + } else { + return _dev->set_tx_freq( + ::uhd::tune_request_t(_curr_freq[chan], _curr_lo_offset[chan]), + _stream_args.channels[chan] + ); + } + } + + void + usrp_sink_impl::_set_center_freq_from_internals_allchans() + { + for (size_t chan = 0; chan < _nchan; chan++) { + if (_chans_to_tune[chan]) { + _set_center_freq_from_internals(chan); + } + } + } + double usrp_sink_impl::get_center_freq(size_t chan) { @@ -154,6 +205,7 @@ namespace gr { void usrp_sink_impl::set_gain(double gain, size_t chan) { + _curr_gain[chan] = gain; chan = _stream_args.channels[chan]; return _dev->set_tx_gain(gain, chan); } @@ -163,6 +215,7 @@ namespace gr { const std::string &name, size_t chan) { + _curr_gain[chan] = gain; chan = _stream_args.channels[chan]; return _dev->set_tx_gain(gain, name, chan); } @@ -464,9 +517,9 @@ namespace gr { gr_vector_const_void_star &input_items, gr_vector_void_star &output_items) { - int ninput_items = noutput_items; //cuz its a sync block + int ninput_items = noutput_items; //cuz it's a sync block - //send a mid-burst packet with time spec + // default to send a mid-burst packet _metadata.start_of_burst = false; _metadata.end_of_burst = false; @@ -476,6 +529,27 @@ namespace gr { if(not _tags.empty()) this->tag_work(ninput_items); + if(not pmt::is_null(_length_tag_key)) { + //check if there is data left to send from a burst tagged with length_tag + //If a burst is started during this call to work(), tag_work() should have + //been called and we should have _nitems_to_send > 0. + if (_nitems_to_send > 0) { + ninput_items = std::min<long>(_nitems_to_send, ninput_items); + //if we run out of items to send, it's the end of the burst + if(_nitems_to_send - long(ninput_items) == 0) + _metadata.end_of_burst = true; + } + else { + //There is a tag gap since no length_tag was found immediately following + //the last sample of the previous burst. Drop samples until the next + //length_tag is found. Notify the user of the tag gap. + std::cerr << "tG" << std::flush; + //increment the timespec by the number of samples dropped + _metadata.time_spec += ::uhd::time_spec_t(0, ninput_items, _sample_rate); + return ninput_items; + } + } + #ifdef GR_UHD_USE_STREAM_API //send all ninput_items with metadata const size_t num_sent = _tx_stream->send @@ -486,8 +560,20 @@ namespace gr { *_type, ::uhd::device::SEND_MODE_FULL_BUFF, 1.0); #endif + //if using length_tags, decrement items left to send by the number of samples sent + if(not pmt::is_null(_length_tag_key) and _nitems_to_send > 0) { + _nitems_to_send -= long(num_sent); + } + //increment the timespec by the number of samples sent _metadata.time_spec += ::uhd::time_spec_t(0, num_sent, _sample_rate); + + // Some post-processing tasks if we actually transmitted the entire burst + if (_call_tune and num_sent == size_t(ninput_items)) { + _set_center_freq_from_internals_allchans(); + _call_tune = false; + } + return num_sent; } @@ -501,54 +587,156 @@ namespace gr { std::sort(_tags.begin(), _tags.end(), tag_t::offset_compare); //extract absolute sample counts - const tag_t &tag0 = _tags.front(); - const uint64_t tag0_count = tag0.offset; const uint64_t samp0_count = this->nitems_read(0); - - //only transmit nsamples from 0 to the first tag - //this ensures that the next work starts on a tag - if(samp0_count != tag0_count) { - ninput_items = tag0_count - samp0_count; - return; - } - - //time will not be set unless a time tag is found - _metadata.has_time_spec = false; - - //process all of the tags found with the same count as tag0 + uint64_t max_count = samp0_count + ninput_items; + + // Go through tag list until something indicates the end of a burst. + bool found_time_tag = false; + bool found_eob = false; + bool found_freq_tag_in_burst = false; + uint64_t freq_cmd_offset = 0; + double freq_cmd_freq; + int freq_cmd_chan; BOOST_FOREACH(const tag_t &my_tag, _tags) { const uint64_t my_tag_count = my_tag.offset; const pmt::pmt_t &key = my_tag.key; const pmt::pmt_t &value = my_tag.value; - //determine how many samples to send... - //from zero until the next tag or end of work - if(my_tag_count != tag0_count) { - ninput_items = my_tag_count - samp0_count; + if (my_tag_count >= max_count) { break; } - - //handle end of burst with a mini end of burst packet - else if(pmt::equal(key, EOB_KEY)) { - _metadata.end_of_burst = pmt::to_bool(value); - ninput_items = 1; - return; - } - - //set the start of burst flag in the metadata - else if(pmt::equal(key, SOB_KEY)) { - _metadata.start_of_burst = pmt::to_bool(value); + else if (not pmt::is_null(_length_tag_key) and my_tag_count > samp0_count + _nitems_to_send) { + break; + } + + /* I. Bursts that can only be on the first sample of burst + * + * This includes: + * - tx_time + * - tx_command + * - tx_sob + * - length tags + * + * With these tags, we check if they're on the first item, otherwise, + * we stop before that tag so they are on the first item the next time round. + */ + else if (pmt::equal(key, COMMAND_KEY)) { + if (my_tag_count != samp0_count) { + max_count = my_tag_count; + break; + } + msg_handler_command(value); } //set the time specification in the metadata else if(pmt::equal(key, TIME_KEY)) { + if (my_tag_count != samp0_count) { + max_count = my_tag_count; + break; + } + found_time_tag = true; _metadata.has_time_spec = true; _metadata.time_spec = ::uhd::time_spec_t (pmt::to_uint64(pmt::tuple_ref(value, 0)), pmt::to_double(pmt::tuple_ref(value, 1))); } + + //set the start of burst flag in the metadata; ignore if length_tag_key is not null + else if(pmt::is_null(_length_tag_key) and pmt::equal(key, SOB_KEY)) { + if (my_tag.offset != samp0_count) { + max_count = my_tag_count; + break; + } + // Bursty tx will not use time specs, unless a tx_time tag is also given. + _metadata.has_time_spec = false; + _metadata.start_of_burst = pmt::to_bool(value); + } + + //length_tag found; set the start of burst flag in the metadata + else if(not pmt::is_null(_length_tag_key) and pmt::equal(key, _length_tag_key)) { + if (my_tag_count != samp0_count) { + max_count = my_tag_count; + break; + } + //If there are still items left to send, the current burst has been preempted. + //Set the items remaining counter to the new burst length. Notify the user of + //the tag preemption. + else if(_nitems_to_send > 0) { + std::cerr << "tP" << std::flush; + } + _nitems_to_send = pmt::to_long(value); + _metadata.start_of_burst = true; + } + + /* II. Bursts that can be on the first OR last sample of a burst + * + * This includes: + * - tx_freq (tags that don't actually change the frequency are ignored) + * + * With these tags, we check if they're at the start of a burst, and do + * the appropriate action. Otherwise, make sure the corresponding sample + * is the last one. + */ + else if (pmt::equal(key, FREQ_KEY) and my_tag_count == samp0_count) { + int chan = pmt::to_long(pmt::tuple_ref(value, 0)); + double new_freq = pmt::to_double(pmt::tuple_ref(value, 1)); + if (new_freq != _curr_freq[chan]) { + _curr_freq[chan] = new_freq; + _set_center_freq_from_internals(chan); + } + } + + else if(pmt::equal(key, FREQ_KEY) and not found_freq_tag_in_burst) { + int chan = pmt::to_long(pmt::tuple_ref(value, 0)); + double new_freq = pmt::to_double(pmt::tuple_ref(value, 1)); + if (new_freq != _curr_freq[chan]) { + freq_cmd_freq = new_freq; + freq_cmd_chan = chan; + freq_cmd_offset = my_tag_count; + max_count = my_tag_count + 1; + found_freq_tag_in_burst = true; + } + } + + /* III. Bursts that can only be on the last sample of a burst + * + * This includes: + * - tx_eob + * + * Make sure that no more samples are allowed through. + */ + else if(pmt::is_null(_length_tag_key) and pmt::equal(key, EOB_KEY)) { + found_eob = true; + max_count = my_tag_count + 1; + _metadata.end_of_burst = pmt::to_bool(value); + } + } // end foreach + + if(not pmt::is_null(_length_tag_key) and long(max_count - samp0_count) == _nitems_to_send) { + found_eob = true; } - } + + if (found_freq_tag_in_burst) { + if (not found_eob) { + // If it's in the middle of a burst, only send() until before the tag + max_count = freq_cmd_offset; + } else if (freq_cmd_offset < max_count) { + // Otherwise, tune after work() + _curr_freq[freq_cmd_chan] = freq_cmd_freq; + _chans_to_tune[freq_cmd_chan] = true; + _call_tune = true; + } + } + + if (found_time_tag) { + _metadata.has_time_spec = true; + } + + // Only transmit up to and including end of burst, + // or everything if no burst boundaries are found. + ninput_items = int(max_count - samp0_count); + + } // end tag_work() void usrp_sink_impl::set_start_time(const ::uhd::time_spec_t &time) @@ -569,7 +757,9 @@ namespace gr { _metadata.start_of_burst = true; _metadata.end_of_burst = false; - _metadata.has_time_spec = not _stream_now; + // Bursty tx will need to send a tx_time to activate time spec + _metadata.has_time_spec = not _stream_now and pmt::is_null(_length_tag_key); + _nitems_to_send = 0; if(_start_time_set) { _start_time_set = false; //cleared for next run _metadata.time_spec = _start_time; @@ -597,6 +787,7 @@ namespace gr { _metadata.start_of_burst = false; _metadata.end_of_burst = true; _metadata.has_time_spec = false; + _nitems_to_send = 0; #ifdef GR_UHD_USE_STREAM_API _tx_stream->send(gr_vector_const_void_star(_nchan), 0, _metadata, 1.0); @@ -608,6 +799,50 @@ namespace gr { return true; } + + /************** External interfaces (RPC + Message passing) ********************/ + // Helper function for msg_handler_command: Extracts chan and command value from + // the 2-tuple in cmd_val, updates the value in vector_to_update[chan] and returns + // true if it was different from the old value. + bool _unpack_chan_command(pmt::pmt_t &cmd_val, int &chan, std::vector<double> &vector_to_update) + { + chan = pmt::to_long(pmt::tuple_ref(cmd_val, 0)); + double new_value = pmt::to_double(pmt::tuple_ref(cmd_val, 1)); + if (new_value == vector_to_update[chan]) { + return false; + } else { + vector_to_update[chan] = new_value; + return true; + } + } + + void usrp_sink_impl::msg_handler_command(pmt::pmt_t msg) + { + const std::string command(pmt::symbol_to_string(pmt::car(msg))); + pmt::pmt_t value(pmt::cdr(msg)); + int chan = 0; + if (command == "freq") { + if (_unpack_chan_command(value, chan, _curr_freq)) { + _set_center_freq_from_internals(chan); + } + } else if (command == "lo_offset") { + if (_unpack_chan_command(value, chan, _curr_lo_offset)) { + _set_center_freq_from_internals(chan); + } + } else if (command == "gain") { + if (_unpack_chan_command(value, chan, _curr_gain)) { + set_gain(_curr_gain[chan], chan); + } + } else { + GR_LOG_ALERT(d_logger, boost::format("Received unknown command: %s") % command); + } + } + + void usrp_sink_impl::msg_handler_query(pmt::pmt_t msg) + { + //tbi + } + void usrp_sink_impl::setup_rpc() { |