diff --git a/CMakeLists.txt b/CMakeLists.txt index 031e774..73f30d2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -168,7 +168,6 @@ set(GR_REQUIRED_COMPONENTS RUNTIME PMT BLOCKS) find_package(Gnuradio "3.7.0") find_package(GnuradioIQBalance) find_package(UHD) -find_package(GnuradioUHD) find_package(GnuradioFCD) find_package(GnuradioFCDPP) find_package(LibOsmoSDR) diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 5963b7e..4bbc36a 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -247,7 +247,7 @@ endif(ENABLE_RTL_TCP) ######################################################################## # Setup UHD component ######################################################################## -GR_REGISTER_COMPONENT("Ettus USRP Devices" ENABLE_UHD UHD_FOUND GNURADIO_UHD_FOUND) +GR_REGISTER_COMPONENT("Ettus USRP Devices" ENABLE_UHD UHD_FOUND) if(ENABLE_UHD) GR_INCLUDE_SUBDIRECTORY(uhd) endif(ENABLE_UHD) diff --git a/lib/uhd/CMakeLists.txt b/lib/uhd/CMakeLists.txt index aba5c77..6c4fa6a 100644 --- a/lib/uhd/CMakeLists.txt +++ b/lib/uhd/CMakeLists.txt @@ -23,11 +23,12 @@ include_directories( ${CMAKE_CURRENT_SOURCE_DIR} - ${GNURADIO_UHD_INCLUDE_DIRS} ${UHD_INCLUDE_DIRS} ) set(uhd_srcs + ${CMAKE_CURRENT_SOURCE_DIR}/usrp_sink_impl.cc + ${CMAKE_CURRENT_SOURCE_DIR}/usrp_source_impl.cc ${CMAKE_CURRENT_SOURCE_DIR}/uhd_sink_c.cc ${CMAKE_CURRENT_SOURCE_DIR}/uhd_source_c.cc ) @@ -36,4 +37,4 @@ set(uhd_srcs # Append gnuradio-osmosdr library sources ######################################################################## list(APPEND gr_osmosdr_srcs ${uhd_srcs}) -list(APPEND gr_osmosdr_libs ${GNURADIO_UHD_LIBRARIES} ${UHD_LIBRARIES}) +list(APPEND gr_osmosdr_libs ${UHD_LIBRARIES}) diff --git a/lib/uhd/gr_uhd_common.h b/lib/uhd/gr_uhd_common.h new file mode 100644 index 0000000..f6a0f91 --- /dev/null +++ b/lib/uhd/gr_uhd_common.h @@ -0,0 +1,67 @@ +/* -*- c++ -*- */ +/* + * Copyright 2012-2013 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_GR_UHD_COMMON_H +#define INCLUDED_GR_UHD_COMMON_H + +#include +#include +#include + +namespace gr { + namespace uhd { + + static inline void check_abi(void) + { +#ifdef UHD_VERSION_ABI_STRING + if(std::string(UHD_VERSION_ABI_STRING) == ::uhd::get_abi_string()) + return; + + throw std::runtime_error(str(boost::format( + "\nGR-UHD detected ABI compatibility mismatch with UHD library.\n" + "GR-UHD was build against ABI: %s,\n" + "but UHD library reports ABI: %s\n" + "Suggestion: install an ABI compatible version of UHD,\n" + "or rebuild GR-UHD component against this ABI version.\n" + ) % UHD_VERSION_ABI_STRING % ::uhd::get_abi_string())); +#endif + } + + } /* namespace uhd */ +} /* namespace gr */ + +/*! + * The stream args ensure function sanitizes random user input. + * We may extend this to handle more things in the future, + * but ATM it ensures that the channels are initialized. + */ +static inline uhd::stream_args_t stream_args_ensure(const uhd::stream_args_t &args) +{ + uhd::stream_args_t sanitized = args; + if (sanitized.channels.empty()) + { + sanitized.channels.push_back(0); + } + return sanitized; +} + +#endif /* INCLUDED_GR_UHD_COMMON_H */ diff --git a/lib/uhd/uhd_sink_c.h b/lib/uhd/uhd_sink_c.h index 0462186..bc506a1 100644 --- a/lib/uhd/uhd_sink_c.h +++ b/lib/uhd/uhd_sink_c.h @@ -21,7 +21,8 @@ #define UHD_SINK_C_H #include -#include + +#include "usrp_sink.h" #include "sink_iface.h" diff --git a/lib/uhd/uhd_source_c.h b/lib/uhd/uhd_source_c.h index eac0ed7..b74214a 100644 --- a/lib/uhd/uhd_source_c.h +++ b/lib/uhd/uhd_source_c.h @@ -21,7 +21,8 @@ #define UHD_SOURCE_C_H #include -#include + +#include "usrp_source.h" #include "source_iface.h" diff --git a/lib/uhd/usrp_sink.h b/lib/uhd/usrp_sink.h new file mode 100644 index 0000000..6a81de4 --- /dev/null +++ b/lib/uhd/usrp_sink.h @@ -0,0 +1,529 @@ +/* -*- c++ -*- */ +/* + * Copyright 2010-2013 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_GR_UHD_USRP_SINK_H +#define INCLUDED_GR_UHD_USRP_SINK_H + +#include +#include + +#ifndef INCLUDED_UHD_STREAM_HPP +namespace uhd { + struct stream_args_t + { + stream_args_t(const std::string &cpu = "", + const std::string &otw = "") + { + cpu_format = cpu; + otw_format = otw; + } + std::string cpu_format; + std::string otw_format; + device_addr_t args; + std::vector channels; + }; +} +# define INCLUDED_UHD_STREAM_HPP +#else +# define GR_UHD_USE_STREAM_API +#endif + +namespace gr { + namespace uhd { + + class uhd_usrp_sink; + + class usrp_sink : virtual public sync_block + { + public: + // gr::uhd::usrp_sink::sptr + typedef boost::shared_ptr sptr; + + /*! + * \brief Make a new USRP sink block. + * \ingroup uhd_blk + * + * The USRP sink block reads a stream and transmits the samples. + * The sink block also provides API calls for transmitter settings. + * + * TX Stream tagging: + * + * The following tag keys will be consumed by the work function: + * - pmt::string_to_symbol("tx_sob") + * - pmt::string_to_symbol("tx_eob") + * - pmt::string_to_symbol("tx_time") + * + * The sob and eob (start and end of burst) tag values are pmt booleans. + * When present, burst tags should be set to true (pmt::PMT_T). + * + * The timstamp tag value is a pmt tuple of the following: + * (uint64 seconds, and double fractional seconds). + * + * See the UHD manual for more detailed documentation: + * http://code.ettus.com/redmine/ettus/projects/uhd/wiki + * + * \param device_addr the address to identify the hardware + * \param io_type the desired input data type + * \param num_channels number of stream from the device + * \return a new USRP sink block object + */ + static sptr make(const ::uhd::device_addr_t &device_addr, + const ::uhd::io_type_t &io_type, + size_t num_channels); + + /*! + * \brief Make a new USRP sink block. + * + * The USRP sink block reads a stream and transmits the samples. + * The sink block also provides API calls for transmitter settings. + * + * TX Stream tagging: + * + * The following tag keys will be consumed by the work function: + * - pmt::string_to_symbol("tx_sob") + * - pmt::string_to_symbol("tx_eob") + * - pmt::string_to_symbol("tx_time") + * + * The sob and eob (start and end of burst) tag values are pmt booleans. + * When present, burst tags should be set to true (pmt::PMT_T). + * + * The timstamp tag value is a pmt tuple of the following: + * (uint64 seconds, and double fractional seconds). + * + * See the UHD manual for more detailed documentation: + * http://code.ettus.com/redmine/ettus/projects/uhd/wiki + * + * \param device_addr the address to identify the hardware + * \param stream_args the IO format and channel specification + * \return a new USRP sink block object + */ + static sptr make(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args); + + /*! + * Set the start time for outgoing samples. + * To control when samples are transmitted, + * set this value before starting the flow graph. + * The value is cleared after each run. + * When not specified, the start time will be: + * - Immediately for the one channel case + * - in the near future for multi-channel + * + * \param time the absolute time for transmission to begin + */ + virtual void set_start_time(const ::uhd::time_spec_t &time) = 0; + + /*! + * Returns identifying information about this USRP's configuration. + * Returns motherboard ID, name, and serial. + * Returns daughterboard TX ID, subdev name and spec, serial, and antenna. + * \param chan channel index 0 to N-1 + * \return TX info + */ + virtual ::uhd::dict get_usrp_info(size_t chan = 0) = 0; + + /*! + * Set the frontend specification. + * \param spec the subdev spec markup string + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_subdev_spec(const std::string &spec, size_t mboard = 0) = 0; + + /*! + * Get the TX frontend specification. + * \param mboard the motherboard index 0 to M-1 + * \return the frontend specification in use + */ + virtual std::string get_subdev_spec (size_t mboard = 0) = 0; + + /*! + * Set the sample rate for the usrp device. + * \param rate a new rate in Sps + */ + virtual void set_samp_rate(double rate) = 0; + + /*! + * Get the sample rate for the usrp device. + * This is the actual sample rate and may differ from the rate set. + * \return the actual rate in Sps + */ + virtual double get_samp_rate(void) = 0; + + /*! + * Get the possible sample rates for the usrp device. + * \return a range of rates in Sps + */ + virtual ::uhd::meta_range_t get_samp_rates(void) = 0; + + /*! + * Tune the usrp device to the desired center frequency. + * \param tune_request the tune request instructions + * \param chan the channel index 0 to N-1 + * \return a tune result with the actual frequencies + */ + virtual ::uhd::tune_result_t set_center_freq + (const ::uhd::tune_request_t tune_request, size_t chan = 0) = 0; + + /*! + * Tune the usrp device to the desired center frequency. + * This is a wrapper around set center freq so that in this case, + * the user can pass a single frequency in the call through swig. + * \param freq the desired frequency in Hz + * \param chan the channel index 0 to N-1 + * \return a tune result with the actual frequencies + */ + ::uhd::tune_result_t set_center_freq(double freq, size_t chan = 0) + { + return set_center_freq(::uhd::tune_request_t(freq), chan); + } + + /*! + * Get the center frequency. + * \param chan the channel index 0 to N-1 + * \return the frequency in Hz + */ + virtual double get_center_freq(size_t chan = 0) = 0; + + /*! + * Get the tunable frequency range. + * \param chan the channel index 0 to N-1 + * \return the frequency range in Hz + */ + virtual ::uhd::freq_range_t get_freq_range(size_t chan = 0) = 0; + + /*! + * Set the gain for the dboard. + * \param gain the gain in dB + * \param chan the channel index 0 to N-1 + */ + virtual void set_gain(double gain, size_t chan = 0) = 0; + + /*! + * Set the named gain on the dboard. + * \param gain the gain in dB + * \param name the name of the gain stage + * \param chan the channel index 0 to N-1 + */ + virtual void set_gain(double gain, + const std::string &name, + size_t chan = 0) = 0; + + /*! + * Get the actual dboard gain setting. + * \param chan the channel index 0 to N-1 + * \return the actual gain in dB + */ + virtual double get_gain(size_t chan = 0) = 0; + + /*! + * Get the actual dboard gain setting of named stage. + * \param name the name of the gain stage + * \param chan the channel index 0 to N-1 + * \return the actual gain in dB + */ + virtual double get_gain(const std::string &name, + size_t chan = 0) = 0; + + /*! + * Get the actual dboard gain setting of named stage. + * \param chan the channel index 0 to N-1 + * \return the actual gain in dB + */ + virtual std::vector get_gain_names(size_t chan = 0) = 0; + + /*! + * Get the settable gain range. + * \param chan the channel index 0 to N-1 + * \return the gain range in dB + */ + virtual ::uhd::gain_range_t get_gain_range(size_t chan = 0) = 0; + + /*! + * Get the settable gain range. + * \param name the name of the gain stage + * \param chan the channel index 0 to N-1 + * \return the gain range in dB + */ + virtual ::uhd::gain_range_t get_gain_range(const std::string &name, + size_t chan = 0) = 0; + + /*! + * Set the antenna to use. + * \param ant the antenna string + * \param chan the channel index 0 to N-1 + */ + virtual void set_antenna(const std::string &ant, + size_t chan = 0) = 0; + + /*! + * Get the antenna in use. + * \param chan the channel index 0 to N-1 + * \return the antenna string + */ + virtual std::string get_antenna(size_t chan = 0) = 0; + + /*! + * Get a list of possible antennas. + * \param chan the channel index 0 to N-1 + * \return a vector of antenna strings + */ + virtual std::vector get_antennas(size_t chan = 0) = 0; + + /*! + * Set the bandpass filter on the RF frontend. + * \param chan the channel index 0 to N-1 + * \param bandwidth the filter bandwidth in Hz + */ + virtual void set_bandwidth(double bandwidth, size_t chan = 0) = 0; + + /*! + * Get the bandpass filter setting on the RF frontend. + * \param chan the channel index 0 to N-1 + * \return bandwidth of the filter in Hz + */ + virtual double get_bandwidth(size_t chan = 0) = 0; + + /*! + * Get the bandpass filter range of the RF frontend. + * \param chan the channel index 0 to N-1 + * \return the range of the filter bandwidth in Hz + */ + virtual ::uhd::freq_range_t get_bandwidth_range(size_t chan = 0) = 0; + + /*! + * Set a constant DC offset value. + * The value is complex to control both I and Q. + * \param offset the dc offset (1.0 is full-scale) + * \param chan the channel index 0 to N-1 + */ + virtual void set_dc_offset(const std::complex &offset, + size_t chan = 0) = 0; + + /*! + * Set the RX frontend IQ imbalance correction. + * Use this to adjust the magnitude and phase of I and Q. + * + * \param correction the complex correction (1.0 is full-scale) + * \param chan the channel index 0 to N-1 + */ + virtual void set_iq_balance(const std::complex &correction, + size_t chan = 0) = 0; + + /*! + * Get an RF frontend sensor value. + * \param name the name of the sensor + * \param chan the channel index 0 to N-1 + * \return a sensor value object + */ + virtual ::uhd::sensor_value_t get_sensor(const std::string &name, + size_t chan = 0) = 0; + + /*! + * Get a list of possible RF frontend sensor names. + * \param chan the channel index 0 to N-1 + * \return a vector of sensor names + */ + virtual std::vector get_sensor_names(size_t chan = 0) = 0; + + //! DEPRECATED use get_sensor + ::uhd::sensor_value_t get_dboard_sensor(const std::string &name, + size_t chan = 0) + { + return this->get_sensor(name, chan); + } + + //! DEPRECATED use get_sensor_names + std::vector get_dboard_sensor_names(size_t chan = 0) + { + return this->get_sensor_names(chan); + } + + /*! + * Get a motherboard sensor value. + * \param name the name of the sensor + * \param mboard the motherboard index 0 to M-1 + * \return a sensor value object + */ + virtual ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, + size_t mboard = 0) = 0; + + /*! + * Get a list of possible motherboard sensor names. + * \param mboard the motherboard index 0 to M-1 + * \return a vector of sensor names + */ + virtual std::vector get_mboard_sensor_names(size_t mboard = 0) = 0; + + /*! + * Set the clock configuration. + * DEPRECATED for set_time/clock_source. + * \param clock_config the new configuration + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_clock_config(const ::uhd::clock_config_t &clock_config, + size_t mboard = 0) = 0; + + /*! + * Set the time source for the usrp device. + * This sets the method of time synchronization, + * typically a pulse per second or an encoded time. + * Typical options for source: external, MIMO. + * \param source a string representing the time source + * \param mboard which motherboard to set the config + */ + virtual void set_time_source(const std::string &source, + const size_t mboard = 0) = 0; + + /*! + * Get the currently set time source. + * \param mboard which motherboard to get the config + * \return the string representing the time source + */ + virtual std::string get_time_source(const size_t mboard) = 0; + + /*! + * Get a list of possible time sources. + * \param mboard which motherboard to get the list + * \return a vector of strings for possible settings + */ + virtual std::vector get_time_sources(const size_t mboard) = 0; + + /*! + * Set the clock source for the usrp device. + * This sets the source for a 10 Mhz reference clock. + * Typical options for source: internal, external, MIMO. + * \param source a string representing the clock source + * \param mboard which motherboard to set the config + */ + virtual void set_clock_source(const std::string &source, + const size_t mboard = 0) = 0; + + /*! + * Get the currently set clock source. + * \param mboard which motherboard to get the config + * \return the string representing the clock source + */ + virtual std::string get_clock_source(const size_t mboard) = 0; + + /*! + * Get a list of possible clock sources. + * \param mboard which motherboard to get the list + * \return a vector of strings for possible settings + */ + virtual std::vector get_clock_sources(const size_t mboard) = 0; + + /*! + * Get the master clock rate. + * \param mboard the motherboard index 0 to M-1 + * \return the clock rate in Hz + */ + virtual double get_clock_rate(size_t mboard = 0) = 0; + + /*! + * Set the master clock rate. + * \param rate the new rate in Hz + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_clock_rate(double rate, size_t mboard = 0) = 0; + + /*! + * Get the current time registers. + * \param mboard the motherboard index 0 to M-1 + * \return the current usrp time + */ + virtual ::uhd::time_spec_t get_time_now(size_t mboard = 0) = 0; + + /*! + * Get the time when the last pps pulse occured. + * \param mboard the motherboard index 0 to M-1 + * \return the current usrp time + */ + virtual ::uhd::time_spec_t get_time_last_pps(size_t mboard = 0) = 0; + + /*! + * Sets the time registers immediately. + * \param time_spec the new time + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_time_now(const ::uhd::time_spec_t &time_spec, size_t mboard = 0) = 0; + + /*! + * Set the time registers at the next pps. + * \param time_spec the new time + */ + virtual void set_time_next_pps(const ::uhd::time_spec_t &time_spec) = 0; + + /*! + * Sync the time registers with an unknown pps edge. + * \param time_spec the new time + */ + virtual void set_time_unknown_pps(const ::uhd::time_spec_t &time_spec) = 0; + + /*! + * Set the time at which the control commands will take effect. + * + * A timed command will back-pressure all subsequent timed commands, + * assuming that the subsequent commands occur within the time-window. + * If the time spec is late, the command will be activated upon arrival. + * + * \param time_spec the time at which the next command will activate + * \param mboard which motherboard to set the config + */ + virtual void set_command_time(const ::uhd::time_spec_t &time_spec, + size_t mboard = 0) = 0; + + /*! + * Clear the command time so future commands are sent ASAP. + * + * \param mboard which motherboard to set the config + */ + virtual void clear_command_time(size_t mboard = 0) = 0; + + /*! + * Get access to the underlying uhd dboard iface object. + * \return the dboard_iface object + */ + virtual ::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan = 0) = 0; + + /*! + * Get access to the underlying uhd device object. + * \return the multi usrp device object + */ + virtual ::uhd::usrp::multi_usrp::sptr get_device(void) = 0; + + /*! + * Perform write on the user configuration register bus. These + * only exist if the user has implemented custom setting + * registers in the device FPGA. + * \param addr 8-bit register address + * \param data 32-bit register value + * \param mboard which motherboard to set the user register + */ + virtual void set_user_register(const uint8_t addr, + const uint32_t data, + size_t mboard = 0) = 0; + }; + + } /* namespace uhd */ +} /* namespace gr */ + +#endif /* INCLUDED_GR_UHD_USRP_SINK_H */ diff --git a/lib/uhd/usrp_sink_impl.cc b/lib/uhd/usrp_sink_impl.cc new file mode 100644 index 0000000..851c34b --- /dev/null +++ b/lib/uhd/usrp_sink_impl.cc @@ -0,0 +1,636 @@ +/* -*- c++ -*- */ +/* + * Copyright 2010-2013 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include "usrp_sink_impl.h" +#include "gr_uhd_common.h" +#include +#include +#include + +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) + { + //fill in the streamer args + ::uhd::stream_args_t stream_args; + switch(io_type.tid) { + case ::uhd::io_type_t::COMPLEX_FLOAT32: stream_args.cpu_format = "fc32"; break; + case ::uhd::io_type_t::COMPLEX_INT16: stream_args.cpu_format = "sc16"; break; + default: throw std::runtime_error("only complex float and shorts known to work"); + } + + 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 + + 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) + { + check_abi(); + return usrp_sink::sptr + (new usrp_sink_impl(device_addr, stream_args_ensure(stream_args))); + } + + usrp_sink_impl::usrp_sink_impl(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args) + : 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) + { + 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); + } + + usrp_sink_impl::~usrp_sink_impl() + { + } + + ::uhd::dict + usrp_sink_impl::get_usrp_info(size_t chan) + { + chan = _stream_args.channels[chan]; +#ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API + return _dev->get_usrp_tx_info(chan); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_sink_impl::set_subdev_spec(const std::string &spec, + size_t mboard) + { + return _dev->set_tx_subdev_spec(spec, mboard); + } + + std::string + usrp_sink_impl::get_subdev_spec(size_t mboard) + { + return _dev->get_tx_subdev_spec(mboard).to_string(); + } + + void + usrp_sink_impl::set_samp_rate(double rate) + { + BOOST_FOREACH(const size_t chan, _stream_args.channels) + { + _dev->set_tx_rate(rate, chan); + } + _sample_rate = this->get_samp_rate(); + } + + double + usrp_sink_impl::get_samp_rate(void) + { + return _dev->get_tx_rate(_stream_args.channels[0]); + } + + ::uhd::meta_range_t + usrp_sink_impl::get_samp_rates(void) + { +#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API + return _dev->get_tx_rates(_stream_args.channels[0]); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + ::uhd::tune_result_t + usrp_sink_impl::set_center_freq(const ::uhd::tune_request_t tune_request, + size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_tx_freq(tune_request, chan); + } + + double + usrp_sink_impl::get_center_freq(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_freq(chan); + } + + ::uhd::freq_range_t + usrp_sink_impl::get_freq_range(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_freq_range(chan); + } + + void + usrp_sink_impl::set_gain(double gain, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_tx_gain(gain, chan); + } + + void + usrp_sink_impl::set_gain(double gain, + const std::string &name, + size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_tx_gain(gain, name, chan); + } + + double + usrp_sink_impl::get_gain(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_gain(chan); + } + + double + usrp_sink_impl::get_gain(const std::string &name, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_gain(name, chan); + } + + std::vector + usrp_sink_impl::get_gain_names(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_gain_names(chan); + } + + ::uhd::gain_range_t + usrp_sink_impl::get_gain_range(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_gain_range(chan); + } + + ::uhd::gain_range_t + usrp_sink_impl::get_gain_range(const std::string &name, + size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_gain_range(name, chan); + } + + void + usrp_sink_impl::set_antenna(const std::string &ant, + size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_tx_antenna(ant, chan); + } + + std::string + usrp_sink_impl::get_antenna(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_antenna(chan); + } + + std::vector + usrp_sink_impl::get_antennas(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_antennas(chan); + } + + void + usrp_sink_impl::set_bandwidth(double bandwidth, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_tx_bandwidth(bandwidth, chan); + } + + double + usrp_sink_impl::get_bandwidth(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_bandwidth(chan); + } + + ::uhd::freq_range_t + usrp_sink_impl::get_bandwidth_range(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_bandwidth_range(chan); + } + + void + usrp_sink_impl::set_dc_offset(const std::complex &offset, + size_t chan) + { + chan = _stream_args.channels[chan]; +#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API + return _dev->set_tx_dc_offset(offset, chan); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_sink_impl::set_iq_balance(const std::complex &correction, + size_t chan) + { + chan = _stream_args.channels[chan]; +#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API + return _dev->set_tx_iq_balance(correction, chan); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + ::uhd::sensor_value_t + usrp_sink_impl::get_sensor(const std::string &name, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_sensor(name, chan); + } + + std::vector + usrp_sink_impl::get_sensor_names(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_sensor_names(chan); + } + + ::uhd::sensor_value_t + usrp_sink_impl::get_mboard_sensor(const std::string &name, + size_t mboard) + { + return _dev->get_mboard_sensor(name, mboard); + } + + std::vector + usrp_sink_impl::get_mboard_sensor_names(size_t mboard) + { + return _dev->get_mboard_sensor_names(mboard); + } + + void + usrp_sink_impl::set_clock_config(const ::uhd::clock_config_t &clock_config, + size_t mboard) + { + return _dev->set_clock_config(clock_config, mboard); + } + + void + usrp_sink_impl::set_time_source(const std::string &source, + const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->set_time_source(source, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::string + usrp_sink_impl::get_time_source(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_time_source(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::vector + usrp_sink_impl::get_time_sources(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_time_sources(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_sink_impl::set_clock_source(const std::string &source, + const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->set_clock_source(source, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::string + usrp_sink_impl::get_clock_source(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_clock_source(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::vector + usrp_sink_impl::get_clock_sources(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_clock_sources(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + double + usrp_sink_impl::get_clock_rate(size_t mboard) + { + return _dev->get_master_clock_rate(mboard); + } + + void + usrp_sink_impl::set_clock_rate(double rate, size_t mboard) + { + return _dev->set_master_clock_rate(rate, mboard); + } + + ::uhd::time_spec_t + usrp_sink_impl::get_time_now(size_t mboard) + { + return _dev->get_time_now(mboard); + } + + ::uhd::time_spec_t + usrp_sink_impl::get_time_last_pps(size_t mboard) + { + return _dev->get_time_last_pps(mboard); + } + + void + usrp_sink_impl::set_time_now(const ::uhd::time_spec_t &time_spec, + size_t mboard) + { + return _dev->set_time_now(time_spec, mboard); + } + + void + usrp_sink_impl::set_time_next_pps(const ::uhd::time_spec_t &time_spec) + { + return _dev->set_time_next_pps(time_spec); + } + + void + usrp_sink_impl::set_time_unknown_pps(const ::uhd::time_spec_t &time_spec) + { + return _dev->set_time_unknown_pps(time_spec); + } + + void + usrp_sink_impl::set_command_time(const ::uhd::time_spec_t &time_spec, + size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API + return _dev->set_command_time(time_spec, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_sink_impl::clear_command_time(size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API + return _dev->clear_command_time(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + ::uhd::usrp::dboard_iface::sptr + usrp_sink_impl::get_dboard_iface(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_tx_dboard_iface(chan); + } + + ::uhd::usrp::multi_usrp::sptr + usrp_sink_impl::get_device(void) + { + return _dev; + } + + void + usrp_sink_impl::set_user_register(const uint8_t addr, + const uint32_t data, + size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_USER_REGS_API + _dev->set_user_register(addr, data, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + + /*********************************************************************** + * Work + **********************************************************************/ + int + usrp_sink_impl::work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) + { + int ninput_items = noutput_items; //cuz its a sync block + + //send a mid-burst packet with time spec + _metadata.start_of_burst = false; + _metadata.end_of_burst = false; +#if 0 + //collect tags in this work() + const uint64_t samp0_count = nitems_read(0); + get_tags_in_range(_tags, 0, samp0_count, samp0_count + ninput_items); + if(not _tags.empty()) + this->tag_work(ninput_items); +#endif +#ifdef GR_UHD_USE_STREAM_API + //send all ninput_items with metadata + const size_t num_sent = _tx_stream->send + (input_items, ninput_items, _metadata, 1.0); +#else + const size_t num_sent = _dev->get_device()->send + (input_items, ninput_items, _metadata, + *_type, ::uhd::device::SEND_MODE_FULL_BUFF, 1.0); +#endif + + //increment the timespec by the number of samples sent + _metadata.time_spec += ::uhd::time_spec_t(0, num_sent, _sample_rate); + return num_sent; + } + + /*********************************************************************** + * Tag Work + **********************************************************************/ + void + usrp_sink_impl::tag_work(int &ninput_items) + { +#if 0 + //the for loop below assumes tags sorted by count low -> high + 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; + } +#endif + //time will not be set unless a time tag is found + _metadata.has_time_spec = false; +#if 0 + //process all of the tags found with the same count as tag0 + 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; + 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); + } + + //set the time specification in the metadata + else if(pmt::equal(key, TIME_KEY)) { + _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))); + } + } +#endif + } + + void + usrp_sink_impl::set_start_time(const ::uhd::time_spec_t &time) + { + _start_time = time; + _start_time_set = true; + _stream_now = false; + } + + //Send an empty start-of-burst packet to begin streaming. + //Set at a time in the near future to avoid late packets. + bool + usrp_sink_impl::start(void) + { +#ifdef GR_UHD_USE_STREAM_API + _tx_stream = _dev->get_tx_stream(_stream_args); +#endif + + _metadata.start_of_burst = true; + _metadata.end_of_burst = false; + _metadata.has_time_spec = not _stream_now; + if(_start_time_set) { + _start_time_set = false; //cleared for next run + _metadata.time_spec = _start_time; + } + else { + _metadata.time_spec = get_time_now() + ::uhd::time_spec_t(0.01); + } + +#ifdef GR_UHD_USE_STREAM_API + _tx_stream->send + (gr_vector_const_void_star(_nchan), 0, _metadata, 1.0); +#else + _dev->get_device()->send + (gr_vector_const_void_star(_nchan), 0, _metadata, + *_type, ::uhd::device::SEND_MODE_ONE_PACKET, 1.0); +#endif + return true; + } + + //Send an empty end-of-burst packet to end streaming. + //Ending the burst avoids an underflow error on stop. + bool + usrp_sink_impl::stop(void) + { + _metadata.start_of_burst = false; + _metadata.end_of_burst = true; + _metadata.has_time_spec = false; + +#ifdef GR_UHD_USE_STREAM_API + _tx_stream->send(gr_vector_const_void_star(_nchan), 0, _metadata, 1.0); +#else + _dev->get_device()->send + (gr_vector_const_void_star(_nchan), 0, _metadata, + *_type, ::uhd::device::SEND_MODE_ONE_PACKET, 1.0); +#endif + return true; + } + + void + usrp_sink_impl::setup_rpc() + { +#ifdef GR_CTRLPORT + add_rpc_variable( + rpcbasic_sptr(new rpcbasic_register_get( + alias(), "samp_rate", + &usrp_sink::get_samp_rate, + pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f), + "sps", "TX Sample Rate", RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + add_rpc_variable( + rpcbasic_sptr(new rpcbasic_register_set( + alias(), "samp_rate", + &usrp_sink::set_samp_rate, + pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f), + "sps", "TX Sample Rate", + RPC_PRIVLVL_MIN, DISPNULL))); +#endif /* GR_CTRLPORT */ + } + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/lib/uhd/usrp_sink_impl.h b/lib/uhd/usrp_sink_impl.h new file mode 100644 index 0000000..9e83a4e --- /dev/null +++ b/lib/uhd/usrp_sink_impl.h @@ -0,0 +1,142 @@ +/* -*- c++ -*- */ +/* + * Copyright 2010-2013 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include "usrp_sink.h" +#include +#if 0 +static const pmt::pmt_t SOB_KEY = pmt::string_to_symbol("tx_sob"); +static const pmt::pmt_t EOB_KEY = pmt::string_to_symbol("tx_eob"); +static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("tx_time"); +#endif +namespace gr { + namespace uhd { + + inline io_signature::sptr + args_to_io_sig(const ::uhd::stream_args_t &args) + { + const size_t nchan = std::max(args.channels.size(), 1); +#ifdef GR_UHD_USE_STREAM_API + const size_t size = ::uhd::convert::get_bytes_per_item(args.cpu_format); +#else + size_t size = 0; + if(args.cpu_format == "fc32") + size = 8; + if(args.cpu_format == "sc16") + size = 4; +#endif + return io_signature::make(nchan, nchan, size); + } + + /*********************************************************************** + * UHD Multi USRP Sink Impl + **********************************************************************/ + class usrp_sink_impl : public usrp_sink + { + public: + usrp_sink_impl(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args); + ~usrp_sink_impl(); + + void setup_rpc(); + + ::uhd::dict get_usrp_info(size_t chan); + double get_samp_rate(void); + ::uhd::meta_range_t get_samp_rates(void); + double get_center_freq(size_t chan); + ::uhd::freq_range_t get_freq_range(size_t chan); + double get_gain(size_t chan); + double get_gain(const std::string &name, size_t chan); + std::vector get_gain_names(size_t chan); + ::uhd::gain_range_t get_gain_range(size_t chan); + ::uhd::gain_range_t get_gain_range(const std::string &name, size_t chan); + std::string get_antenna(size_t chan); + std::vector get_antennas(size_t chan); + ::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan); + std::vector get_sensor_names(size_t chan); + ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard); + std::vector get_mboard_sensor_names(size_t mboard); + std::string get_time_source(const size_t mboard); + std::vector get_time_sources(const size_t mboard); + std::string get_clock_source(const size_t mboard); + std::vector get_clock_sources(const size_t mboard); + double get_clock_rate(size_t mboard); + ::uhd::time_spec_t get_time_now(size_t mboard = 0); + ::uhd::time_spec_t get_time_last_pps(size_t mboard); + ::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan); + ::uhd::usrp::multi_usrp::sptr get_device(void); + + void set_subdev_spec(const std::string &spec, size_t mboard); + std::string get_subdev_spec(size_t mboard); + void set_samp_rate(double rate); + ::uhd::tune_result_t set_center_freq(const ::uhd::tune_request_t tune_request, + size_t chan); + void set_gain(double gain, size_t chan); + void set_gain(double gain, const std::string &name, size_t chan); + void set_antenna(const std::string &ant, size_t chan); + void set_bandwidth(double bandwidth, size_t chan); + double get_bandwidth(size_t chan); + ::uhd::freq_range_t get_bandwidth_range(size_t chan); + void set_dc_offset(const std::complex &offset, size_t chan); + void set_iq_balance(const std::complex &correction, size_t chan); + void set_clock_config(const ::uhd::clock_config_t &clock_config, size_t mboard); + void set_time_source(const std::string &source, const size_t mboard); + void set_clock_source(const std::string &source, const size_t mboard); + void set_clock_rate(double rate, size_t mboard); + void set_time_now(const ::uhd::time_spec_t &time_spec, size_t mboard); + void set_time_next_pps(const ::uhd::time_spec_t &time_spec); + void set_time_unknown_pps(const ::uhd::time_spec_t &time_spec); + void set_command_time(const ::uhd::time_spec_t &time_spec, size_t mboard); + void clear_command_time(size_t mboard); + void set_user_register(const uint8_t addr, const uint32_t data, size_t mboard); + void set_start_time(const ::uhd::time_spec_t &time); + + bool start(void); + bool stop(void); + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); + + inline void tag_work(int &ninput_items); + + private: + ::uhd::usrp::multi_usrp::sptr _dev; + const ::uhd::stream_args_t _stream_args; + boost::shared_ptr< ::uhd::io_type_t > _type; +#ifdef GR_UHD_USE_STREAM_API + ::uhd::tx_streamer::sptr _tx_stream; +#endif + size_t _nchan; + bool _stream_now; + ::uhd::tx_metadata_t _metadata; + double _sample_rate; + + ::uhd::time_spec_t _start_time; + bool _start_time_set; +#if 0 + //stream tags related stuff + std::vector _tags; +#endif + }; + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/lib/uhd/usrp_source.h b/lib/uhd/usrp_source.h new file mode 100644 index 0000000..1744ebc --- /dev/null +++ b/lib/uhd/usrp_source.h @@ -0,0 +1,580 @@ +/* -*- c++ -*- */ +/* + * Copyright 2010-2013 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_GR_UHD_USRP_SOURCE_H +#define INCLUDED_GR_UHD_USRP_SOURCE_H + +#include +#include + +#ifndef INCLUDED_UHD_STREAM_HPP +namespace uhd { + struct stream_args_t + { + stream_args_t(const std::string &cpu = "", + const std::string &otw = "") + { + cpu_format = cpu; + otw_format = otw; + } + std::string cpu_format; + std::string otw_format; + device_addr_t args; + std::vector channels; + }; +} +# define INCLUDED_UHD_STREAM_HPP +#else +# define GR_UHD_USE_STREAM_API +#endif + +namespace gr { + namespace uhd { + + class uhd_usrp_source; + + class usrp_source : virtual public sync_block + { + public: + // gr::uhd::usrp_source::sptr + typedef boost::shared_ptr sptr; + + /*! + * \brief Make a new USRP source block. + * \ingroup uhd_blk + * + * The USRP source block receives samples and writes to a stream. + * The source block also provides API calls for receiver settings. + * + * RX Stream tagging: + * + * The following tag keys will be produced by the work function: + * - pmt::string_to_symbol("rx_time") + * - pmt::string_to_symbol("rx_rate") + * - pmt::string_to_symbol("rx_freq") + * + * The timstamp tag value is a pmt tuple of the following: + * (uint64 seconds, and double fractional seconds). + * A timestamp tag is produced at start() and after overflows. + * + * The sample rate and center frequency tags are doubles, + * representing the sample rate in Sps and frequency in Hz. + * These tags are produced upon the user changing parameters. + * + * See the UHD manual for more detailed documentation: + * http://code.ettus.com/redmine/ettus/projects/uhd/wiki + * + * \param device_addr the address to identify the hardware + * \param io_type the desired output data type + * \param num_channels number of stream from the device + * \return a new USRP source block object + */ + static sptr make(const ::uhd::device_addr_t &device_addr, + const ::uhd::io_type_t &io_type, + size_t num_channels); + + /*! + * \brief Make a new USRP source block. + * + * The USRP source block receives samples and writes to a stream. + * The source block also provides API calls for receiver settings. + * + * RX Stream tagging: + * + * The following tag keys will be produced by the work function: + * - pmt::string_to_symbol("rx_time") + * + * The timstamp tag value is a pmt tuple of the following: + * (uint64 seconds, and double fractional seconds). + * A timestamp tag is produced at start() and after overflows. + * + * See the UHD manual for more detailed documentation: + * http://code.ettus.com/redmine/ettus/projects/uhd/wiki + * + * \param device_addr the address to identify the hardware + * \param stream_args the IO format and channel specification + * \return a new USRP source block object + */ + static sptr make(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args); + + /*! + * Set the start time for incoming samples. + * To control when samples are received, + * set this value before starting the flow graph. + * The value is cleared after each run. + * When not specified, the start time will be: + * - Immediately for the one channel case + * - in the near future for multi-channel + * + * \param time the absolute time for reception to begin + */ + virtual void set_start_time(const ::uhd::time_spec_t &time) = 0; + + /*! + * *Advanced use only:* + * Issue a stream command to all channels in this source block. + * + * This method is intended to override the default "always on" + * behavior. After starting the flow graph, the user should + * call stop() on this block, then issue any desired arbitrary + * stream_cmd_t structs to the device. The USRP will be able to + * enqueue several stream commands in the FPGA. + * + * \param cmd the stream command to issue to all source channels + */ + virtual void issue_stream_cmd(const ::uhd::stream_cmd_t &cmd) = 0; + + /*! + * Returns identifying information about this USRP's configuration. + * Returns motherboard ID, name, and serial. + * Returns daughterboard RX ID, subdev name and spec, serial, and antenna. + * \param chan channel index 0 to N-1 + * \return RX info + */ + virtual ::uhd::dict get_usrp_info(size_t chan = 0) = 0; + + /*! + * Set the frontend specification. + * \param spec the subdev spec markup string + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_subdev_spec(const std::string &spec, size_t mboard = 0) = 0; + + /*! + * Get the RX frontend specification. + * \param mboard the motherboard index 0 to M-1 + * \return the frontend specification in use + */ + virtual std::string get_subdev_spec(size_t mboard = 0) = 0; + + /*! + * Set the sample rate for the usrp device. + * \param rate a new rate in Sps + */ + virtual void set_samp_rate(double rate) = 0; + + /*! + * Get the sample rate for the usrp device. + * This is the actual sample rate and may differ from the rate set. + * \return the actual rate in Sps + */ + virtual double get_samp_rate(void) = 0; + + /*! + * Get the possible sample rates for the usrp device. + * \return a range of rates in Sps + */ + virtual ::uhd::meta_range_t get_samp_rates(void) = 0; + + /*! + * Tune the usrp device to the desired center frequency. + * \param tune_request the tune request instructions + * \param chan the channel index 0 to N-1 + * \return a tune result with the actual frequencies + */ + virtual ::uhd::tune_result_t set_center_freq + (const ::uhd::tune_request_t tune_request, size_t chan = 0) = 0; + + /*! + * Tune the usrp device to the desired center frequency. + * This is a wrapper around set center freq so that in this case, + * the user can pass a single frequency in the call through swig. + * \param freq the desired frequency in Hz + * \param chan the channel index 0 to N-1 + * \return a tune result with the actual frequencies + */ + ::uhd::tune_result_t set_center_freq(double freq, size_t chan = 0) + { + return set_center_freq(::uhd::tune_request_t(freq), chan); + } + + /*! + * Get the center frequency. + * \param chan the channel index 0 to N-1 + * \return the frequency in Hz + */ + virtual double get_center_freq(size_t chan = 0) = 0; + + /*! + * Get the tunable frequency range. + * \param chan the channel index 0 to N-1 + * \return the frequency range in Hz + */ + virtual ::uhd::freq_range_t get_freq_range(size_t chan = 0) = 0; + + /*! + * Set the gain for the dboard. + * \param gain the gain in dB + * \param chan the channel index 0 to N-1 + */ + virtual void set_gain(double gain, size_t chan = 0) = 0; + + /*! + * Set the named gain on the dboard. + * \param gain the gain in dB + * \param name the name of the gain stage + * \param chan the channel index 0 to N-1 + */ + virtual void set_gain(double gain, + const std::string &name, + size_t chan = 0) = 0; + + /*! + * Get the actual dboard gain setting. + * \param chan the channel index 0 to N-1 + * \return the actual gain in dB + */ + virtual double get_gain(size_t chan = 0) = 0; + + /*! + * Get the actual dboard gain setting of named stage. + * \param name the name of the gain stage + * \param chan the channel index 0 to N-1 + * \return the actual gain in dB + */ + virtual double get_gain(const std::string &name, + size_t chan = 0) = 0; + + /*! + * Get the actual dboard gain setting of named stage. + * \param chan the channel index 0 to N-1 + * \return the actual gain in dB + */ + virtual std::vector get_gain_names(size_t chan = 0) = 0; + + /*! + * Get the settable gain range. + * \param chan the channel index 0 to N-1 + * \return the gain range in dB + */ + virtual ::uhd::gain_range_t get_gain_range(size_t chan = 0) = 0; + + /*! + * Get the settable gain range. + * \param name the name of the gain stage + * \param chan the channel index 0 to N-1 + * \return the gain range in dB + */ + virtual ::uhd::gain_range_t get_gain_range(const std::string &name, + size_t chan = 0) = 0; + + /*! + * Set the antenna to use. + * \param ant the antenna string + * \param chan the channel index 0 to N-1 + */ + virtual void set_antenna(const std::string &ant, + size_t chan = 0) = 0; + + /*! + * Get the antenna in use. + * \param chan the channel index 0 to N-1 + * \return the antenna string + */ + virtual std::string get_antenna(size_t chan = 0) = 0; + + /*! + * Get a list of possible antennas. + * \param chan the channel index 0 to N-1 + * \return a vector of antenna strings + */ + virtual std::vector get_antennas(size_t chan = 0) = 0; + + /*! + * Set the bandpass filter on the RF frontend. + * \param bandwidth the filter bandwidth in Hz + * \param chan the channel index 0 to N-1 + */ + virtual void set_bandwidth(double bandwidth, size_t chan = 0) = 0; + + /*! + * Get the bandpass filter setting on the RF frontend. + * \param chan the channel index 0 to N-1 + * \return bandwidth of the filter in Hz + */ + virtual double get_bandwidth(size_t chan = 0) = 0; + + /*! + * Get the bandpass filter range of the RF frontend. + * \param chan the channel index 0 to N-1 + * \return the range of the filter bandwidth in Hz + */ + virtual ::uhd::freq_range_t get_bandwidth_range(size_t chan = 0) = 0; + + /*! + * Enable/disable the automatic DC offset correction. + * The automatic correction subtracts out the long-run average. + * + * When disabled, the averaging option operation is halted. + * Once halted, the average value will be held constant until + * the user re-enables the automatic correction or overrides the + * value by manually setting the offset. + * + * \param enb true to enable automatic DC offset correction + * \param chan the channel index 0 to N-1 + */ + virtual void set_auto_dc_offset(const bool enb, size_t chan = 0) = 0; + + /*! + * Set a constant DC offset value. + * The value is complex to control both I and Q. + * Only set this when automatic correction is disabled. + * \param offset the dc offset (1.0 is full-scale) + * \param chan the channel index 0 to N-1 + */ + virtual void set_dc_offset(const std::complex &offset, size_t chan = 0) = 0; + + /*! + * Set the RX frontend IQ imbalance correction. + * Use this to adjust the magnitude and phase of I and Q. + * + * \param correction the complex correction value + * \param chan the channel index 0 to N-1 + */ + virtual void set_iq_balance(const std::complex &correction, + size_t chan = 0) = 0; + + /*! + * Get a RF frontend sensor value. + * \param name the name of the sensor + * \param chan the channel index 0 to N-1 + * \return a sensor value object + */ + virtual ::uhd::sensor_value_t get_sensor(const std::string &name, + size_t chan = 0) = 0; + + /*! + * Get a list of possible RF frontend sensor names. + * \param chan the channel index 0 to N-1 + * \return a vector of sensor names + */ + virtual std::vector get_sensor_names(size_t chan = 0) = 0; + + //! DEPRECATED use get_sensor + ::uhd::sensor_value_t get_dboard_sensor(const std::string &name, + size_t chan = 0) + { + return this->get_sensor(name, chan); + } + + //! DEPRECATED use get_sensor_names + std::vector get_dboard_sensor_names(size_t chan = 0) + { + return this->get_sensor_names(chan); + } + + /*! + * Get a motherboard sensor value. + * \param name the name of the sensor + * \param mboard the motherboard index 0 to M-1 + * \return a sensor value object + */ + virtual ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, + size_t mboard = 0) = 0; + + /*! + * Get a list of possible motherboard sensor names. + * \param mboard the motherboard index 0 to M-1 + * \return a vector of sensor names + */ + virtual std::vector get_mboard_sensor_names(size_t mboard = 0) = 0; + + /*! + * Set the clock configuration. + * DEPRECATED for set_time/clock_source. + * \param clock_config the new configuration + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_clock_config(const ::uhd::clock_config_t &clock_config, + size_t mboard = 0) = 0; + + /*! + * Set the time source for the usrp device. + * This sets the method of time synchronization, + * typically a pulse per second or an encoded time. + * Typical options for source: external, MIMO. + * \param source a string representing the time source + * \param mboard which motherboard to set the config + */ + virtual void set_time_source(const std::string &source, + const size_t mboard = 0) = 0; + + /*! + * Get the currently set time source. + * \param mboard which motherboard to get the config + * \return the string representing the time source + */ + virtual std::string get_time_source(const size_t mboard) = 0; + + /*! + * Get a list of possible time sources. + * \param mboard which motherboard to get the list + * \return a vector of strings for possible settings + */ + virtual std::vector get_time_sources(const size_t mboard) = 0; + + /*! + * Set the clock source for the usrp device. + * This sets the source for a 10 Mhz reference clock. + * Typical options for source: internal, external, MIMO. + * \param source a string representing the clock source + * \param mboard which motherboard to set the config + */ + virtual void set_clock_source(const std::string &source, + const size_t mboard = 0) = 0; + + /*! + * Get the currently set clock source. + * \param mboard which motherboard to get the config + * \return the string representing the clock source + */ + virtual std::string get_clock_source(const size_t mboard) = 0; + + /*! + * Get a list of possible clock sources. + * \param mboard which motherboard to get the list + * \return a vector of strings for possible settings + */ + virtual std::vector get_clock_sources(const size_t mboard) = 0; + + /*! + * Get the master clock rate. + * \param mboard the motherboard index 0 to M-1 + * \return the clock rate in Hz + */ + virtual double get_clock_rate(size_t mboard = 0) = 0; + + /*! + * Set the master clock rate. + * \param rate the new rate in Hz + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_clock_rate(double rate, size_t mboard = 0) = 0; + + /*! + * Get the current time registers. + * \param mboard the motherboard index 0 to M-1 + * \return the current usrp time + */ + virtual ::uhd::time_spec_t get_time_now(size_t mboard = 0) = 0; + + /*! + * Get the time when the last pps pulse occured. + * \param mboard the motherboard index 0 to M-1 + * \return the current usrp time + */ + virtual ::uhd::time_spec_t get_time_last_pps(size_t mboard = 0) = 0; + + /*! + * Sets the time registers immediately. + * \param time_spec the new time + * \param mboard the motherboard index 0 to M-1 + */ + virtual void set_time_now(const ::uhd::time_spec_t &time_spec, + size_t mboard = 0) = 0; + + /*! + * Set the time registers at the next pps. + * \param time_spec the new time + */ + virtual void set_time_next_pps(const ::uhd::time_spec_t &time_spec) = 0; + + /*! + * Sync the time registers with an unknown pps edge. + * \param time_spec the new time + */ + virtual void set_time_unknown_pps(const ::uhd::time_spec_t &time_spec) = 0; + + /*! + * Set the time at which the control commands will take effect. + * + * A timed command will back-pressure all subsequent timed + * commands, assuming that the subsequent commands occur within + * the time-window. If the time spec is late, the command will + * be activated upon arrival. + * + * \param time_spec the time at which the next command will activate + * \param mboard which motherboard to set the config + */ + virtual void set_command_time(const ::uhd::time_spec_t &time_spec, + size_t mboard = 0) = 0; + + /*! + * Clear the command time so future commands are sent ASAP. + * + * \param mboard which motherboard to set the config + */ + virtual void clear_command_time(size_t mboard = 0) = 0; + + /*! + * Get access to the underlying uhd dboard iface object. + * \return the dboard_iface object + */ + virtual ::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan = 0) = 0; + + /*! + * Get access to the underlying uhd device object. + * \return the multi usrp device object + */ + virtual ::uhd::usrp::multi_usrp::sptr get_device(void) = 0; + + /*! + * Perform write on the user configuration register bus. These + * only exist if the user has implemented custom setting + * registers in the device FPGA. + * \param addr 8-bit register address + * \param data 32-bit register value + * \param mboard which motherboard to set the user register + */ + virtual void set_user_register(const uint8_t addr, + const uint32_t data, + size_t mboard = 0) = 0; + + /*! + * Convenience function for finite data acquisition. + * This is not to be used with the scheduler; rather, + * one can request samples from the USRP in python. + * //TODO assumes fc32 + * \param nsamps the number of samples + * \return a vector of complex float samples + */ + virtual std::vector > + finite_acquisition(const size_t nsamps) = 0; + + /*! + * Convenience function for finite data acquisition. This is the + * multi-channel version of finite_acquisition; This is not to + * be used with the scheduler; rather, one can request samples + * from the USRP in python. + * //TODO assumes fc32 + * \param nsamps the number of samples per channel + * \return a vector of buffers, where each buffer represents a channel + */ + virtual std::vector > > + finite_acquisition_v(const size_t nsamps) = 0; + }; + + } /* namespace uhd */ +} /* namespace gr */ + +#endif /* INCLUDED_GR_UHD_USRP_SOURCE_H */ diff --git a/lib/uhd/usrp_source_impl.cc b/lib/uhd/usrp_source_impl.cc new file mode 100644 index 0000000..34a241d --- /dev/null +++ b/lib/uhd/usrp_source_impl.cc @@ -0,0 +1,696 @@ +/* -*- c++ -*- */ +/* + * Copyright 2010-2013 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include "usrp_source_impl.h" +#include "gr_uhd_common.h" +#include +#include +#include +#include +#include +#include + +namespace gr { + namespace uhd { + + usrp_source::sptr + usrp_source::make(const ::uhd::device_addr_t &device_addr, + const ::uhd::io_type_t &io_type, + size_t num_channels) + { + //fill in the streamer args + ::uhd::stream_args_t stream_args; + switch(io_type.tid) { + case ::uhd::io_type_t::COMPLEX_FLOAT32: stream_args.cpu_format = "fc32"; break; + case ::uhd::io_type_t::COMPLEX_INT16: stream_args.cpu_format = "sc16"; break; + default: throw std::runtime_error("only complex float and shorts known to work"); + } + + 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 + + return usrp_source::make(device_addr, stream_args); + } + + usrp_source::sptr + usrp_source::make(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args) + { + check_abi(); + return usrp_source::sptr + (new usrp_source_impl(device_addr, stream_args_ensure(stream_args))); + } + + usrp_source_impl::usrp_source_impl(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args): + sync_block("gr uhd usrp source", + io_signature::make(0, 0, 0), + args_to_io_sig(stream_args)), + _stream_args(stream_args), + _nchan(stream_args.channels.size()), + _stream_now(_nchan == 1), + _tag_now(false), + _start_time_set(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); + std::stringstream str; + str << name() << unique_id(); +#if 0 + _id = pmt::string_to_symbol(str.str()); +#endif + _dev = ::uhd::usrp::multi_usrp::make(device_addr); + } + + usrp_source_impl::~usrp_source_impl() + { + } + + ::uhd::dict + usrp_source_impl::get_usrp_info(size_t chan) + { + chan = _stream_args.channels[chan]; +#ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API + return _dev->get_usrp_rx_info(chan); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_source_impl::set_subdev_spec(const std::string &spec, size_t mboard) + { + return _dev->set_rx_subdev_spec(spec, mboard); + } + + std::string + usrp_source_impl::get_subdev_spec(size_t mboard) + { + return _dev->get_rx_subdev_spec(mboard).to_string(); + } + + void + usrp_source_impl::set_samp_rate(double rate) + { + BOOST_FOREACH(const size_t chan, _stream_args.channels) + { + _dev->set_rx_rate(rate, chan); + } + _samp_rate = this->get_samp_rate(); + _tag_now = true; + } + + double + usrp_source_impl::get_samp_rate(void) + { + return _dev->get_rx_rate(_stream_args.channels[0]); + } + + ::uhd::meta_range_t + usrp_source_impl::get_samp_rates(void) + { +#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API + return _dev->get_rx_rates(_stream_args.channels[0]); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + ::uhd::tune_result_t + usrp_source_impl::set_center_freq(const ::uhd::tune_request_t tune_request, + size_t chan) + { + const size_t user_chan = chan; + chan = _stream_args.channels[chan]; + const ::uhd::tune_result_t res = _dev->set_rx_freq(tune_request, chan); + _center_freq = this->get_center_freq(user_chan); + _tag_now = true; + return res; + } + + double + usrp_source_impl::get_center_freq(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_freq(chan); + } + + ::uhd::freq_range_t + usrp_source_impl::get_freq_range(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_freq_range(chan); + } + + void + usrp_source_impl::set_gain(double gain, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_rx_gain(gain, chan); + } + + void + usrp_source_impl::set_gain(double gain, const std::string &name, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_rx_gain(gain, name, chan); + } + + double + usrp_source_impl::get_gain(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_gain(chan); + } + + double + usrp_source_impl::get_gain(const std::string &name, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_gain(name, chan); + } + + std::vector + usrp_source_impl::get_gain_names(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_gain_names(chan); + } + + ::uhd::gain_range_t + usrp_source_impl::get_gain_range(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_gain_range(chan); + } + + ::uhd::gain_range_t + usrp_source_impl::get_gain_range(const std::string &name, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_gain_range(name, chan); + } + + void + usrp_source_impl::set_antenna(const std::string &ant, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_rx_antenna(ant, chan); + } + + std::string + usrp_source_impl::get_antenna(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_antenna(chan); + } + + std::vector + usrp_source_impl::get_antennas(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_antennas(chan); + } + + void + usrp_source_impl::set_bandwidth(double bandwidth, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->set_rx_bandwidth(bandwidth, chan); + } + + double + usrp_source_impl::get_bandwidth(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_bandwidth(chan); + } + + ::uhd::freq_range_t + usrp_source_impl::get_bandwidth_range(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_bandwidth_range(chan); + } + + void + usrp_source_impl::set_auto_dc_offset(const bool enable, size_t chan) + { + chan = _stream_args.channels[chan]; +#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API + return _dev->set_rx_dc_offset(enable, chan); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_source_impl::set_dc_offset(const std::complex &offset, + size_t chan) + { + chan = _stream_args.channels[chan]; +#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API + return _dev->set_rx_dc_offset(offset, chan); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_source_impl::set_iq_balance(const std::complex &correction, + size_t chan) + { + chan = _stream_args.channels[chan]; +#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API + return _dev->set_rx_iq_balance(correction, chan); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + ::uhd::sensor_value_t + usrp_source_impl::get_sensor(const std::string &name, size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_sensor(name, chan); + } + + std::vector + usrp_source_impl::get_sensor_names(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_sensor_names(chan); + } + + ::uhd::sensor_value_t + usrp_source_impl::get_mboard_sensor(const std::string &name, size_t mboard) + { + return _dev->get_mboard_sensor(name, mboard); + } + + std::vector + usrp_source_impl::get_mboard_sensor_names(size_t mboard) + { + return _dev->get_mboard_sensor_names(mboard); + } + + void + usrp_source_impl::set_clock_config(const ::uhd::clock_config_t &clock_config, + size_t mboard) + { + return _dev->set_clock_config(clock_config, mboard); + } + + void + usrp_source_impl::set_time_source(const std::string &source, + const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->set_time_source(source, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::string + usrp_source_impl::get_time_source(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_time_source(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::vector + usrp_source_impl::get_time_sources(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_time_sources(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_source_impl::set_clock_source(const std::string &source, + const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->set_clock_source(source, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::string + usrp_source_impl::get_clock_source(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_clock_source(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + std::vector + usrp_source_impl::get_clock_sources(const size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_REF_SOURCES_API + return _dev->get_clock_sources(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + double + usrp_source_impl::get_clock_rate(size_t mboard) + { + return _dev->get_master_clock_rate(mboard); + } + + void + usrp_source_impl::set_clock_rate(double rate, size_t mboard) + { + return _dev->set_master_clock_rate(rate, mboard); + } + + ::uhd::time_spec_t + usrp_source_impl::get_time_now(size_t mboard) + { + return _dev->get_time_now(mboard); + } + + ::uhd::time_spec_t + usrp_source_impl::get_time_last_pps(size_t mboard) + { + return _dev->get_time_last_pps(mboard); + } + + void + usrp_source_impl::set_time_now(const ::uhd::time_spec_t &time_spec, + size_t mboard) + { + return _dev->set_time_now(time_spec, mboard); + } + + void + usrp_source_impl::set_time_next_pps(const ::uhd::time_spec_t &time_spec) + { + return _dev->set_time_next_pps(time_spec); + } + + void + usrp_source_impl::set_time_unknown_pps(const ::uhd::time_spec_t &time_spec) + { + return _dev->set_time_unknown_pps(time_spec); + } + + void + usrp_source_impl::set_command_time(const ::uhd::time_spec_t &time_spec, size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API + return _dev->set_command_time(time_spec, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_source_impl::clear_command_time(size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_COMMAND_TIME_API + return _dev->clear_command_time(mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + ::uhd::usrp::dboard_iface::sptr + usrp_source_impl::get_dboard_iface(size_t chan) + { + chan = _stream_args.channels[chan]; + return _dev->get_rx_dboard_iface(chan); + } + + ::uhd::usrp::multi_usrp::sptr + usrp_source_impl::get_device(void) + { + return _dev; + } + + void + usrp_source_impl::set_user_register(const uint8_t addr, + const uint32_t data, + size_t mboard) + { +#ifdef UHD_USRP_MULTI_USRP_USER_REGS_API + _dev->set_user_register(addr, data, mboard); +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + void + usrp_source_impl::set_start_time(const ::uhd::time_spec_t &time) + { + _start_time = time; + _start_time_set = true; + _stream_now = false; + } + + void + usrp_source_impl::issue_stream_cmd(const ::uhd::stream_cmd_t &cmd) + { + for (size_t i = 0; i < _stream_args.channels.size(); i++) + { + _dev->issue_stream_cmd(cmd, _stream_args.channels[i]); + } + } + + bool + usrp_source_impl::start(void) + { +#ifdef GR_UHD_USE_STREAM_API + _rx_stream = _dev->get_rx_stream(_stream_args); + _samps_per_packet = _rx_stream->get_max_num_samps(); +#endif + //setup a stream command that starts streaming slightly in the future + static const double reasonable_delay = 0.1; //order of magnitude over RTT + ::uhd::stream_cmd_t stream_cmd(::uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS); + stream_cmd.stream_now = _stream_now; + if(_start_time_set) { + _start_time_set = false; //cleared for next run + stream_cmd.time_spec = _start_time; + } + else { + stream_cmd.time_spec = get_time_now() + ::uhd::time_spec_t(reasonable_delay); + } + this->issue_stream_cmd(stream_cmd); + _tag_now = true; + return true; + } + + void + usrp_source_impl::flush(void) + { + const size_t nbytes = 4096; + gr_vector_void_star outputs; + std::vector > buffs(_nchan, std::vector(nbytes)); + for(size_t i = 0; i < _nchan; i++) { + outputs.push_back(&buffs[i].front()); + } + while(true) { +#ifdef GR_UHD_USE_STREAM_API + const size_t bpi = ::uhd::convert::get_bytes_per_item(_stream_args.cpu_format); + _rx_stream->recv(outputs, nbytes/bpi, _metadata, 0.0); +#else + _dev->get_device()->recv + (outputs, nbytes/_type->size, _metadata, *_type, + ::uhd::device::RECV_MODE_FULL_BUFF, 0.0); +#endif + if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) + break; + } + } + + bool + usrp_source_impl::stop(void) + { + this->issue_stream_cmd(::uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS); + + this->flush(); + + return true; + } + + std::vector > + usrp_source_impl::finite_acquisition(const size_t nsamps) + { + if(_nchan != 1) + throw std::runtime_error("finite_acquisition: usrp source has multiple channels, call finite_acquisition_v"); + return finite_acquisition_v(nsamps).front(); + } + + std::vector > > + usrp_source_impl::finite_acquisition_v(const size_t nsamps) + { +#ifdef GR_UHD_USE_STREAM_API + //kludgy way to ensure rx streamer exsists + if(!_rx_stream) { + this->start(); + this->stop(); + } + + //flush so there is no queued-up data + this->flush(); + + //create a multi-dimensional container to hold an array of sample buffers + std::vector > > + samps(_nchan, std::vector >(nsamps)); + + //load the void* vector of buffer pointers + std::vector buffs(_nchan); + for(size_t i = 0; i < _nchan; i++) { + buffs[i] = &samps[i].front(); + } + + //tell the device to stream a finite amount + ::uhd::stream_cmd_t cmd(::uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); + cmd.num_samps = nsamps; + cmd.stream_now = _stream_now; + static const double reasonable_delay = 0.1; //order of magnitude over RTT + cmd.time_spec = get_time_now() + ::uhd::time_spec_t(reasonable_delay); + this->issue_stream_cmd(cmd); + + //receive samples until timeout + const size_t actual_num_samps = _rx_stream->recv + (buffs, nsamps, _metadata, 1.0); + + //resize the resulting sample buffers + for(size_t i = 0; i < _nchan; i++) { + samps[i].resize(actual_num_samps); + } + + return samps; +#else + throw std::runtime_error("not implemented in this version"); +#endif + } + + int + usrp_source_impl::work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) + { +#ifdef GR_UHD_USE_STREAM_API + //In order to allow for low-latency: + //We receive all available packets without timeout. + //This call can timeout under regular operation... + size_t num_samps = _rx_stream->recv + (output_items, noutput_items, _metadata, 0.0); + + //If receive resulted in a timeout condition: + //We now receive a single packet with a large timeout. + if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { + num_samps = _rx_stream->recv + (output_items, noutput_items, _metadata, 0.1, true/*one pkt*/); + } +#else + size_t num_samps = _dev->get_device()->recv + (output_items, noutput_items, _metadata, + *_type, ::uhd::device::RECV_MODE_FULL_BUFF, 0.0); + + if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { + num_samps = _dev->get_device()->recv + (output_items, noutput_items, _metadata, *_type, + ::uhd::device::RECV_MODE_ONE_PACKET, 1.0); + } +#endif + + //handle possible errors conditions + switch(_metadata.error_code) { + case ::uhd::rx_metadata_t::ERROR_CODE_NONE: + if(_tag_now) { + _tag_now = false; +#if 0 + //create a timestamp pmt for the first sample + const pmt::pmt_t val = pmt::make_tuple + (pmt::from_uint64(_metadata.time_spec.get_full_secs()), + pmt::from_double(_metadata.time_spec.get_frac_secs())); + //create a tag set for each channel + for(size_t i = 0; i < _nchan; i++) { + this->add_item_tag(i, nitems_written(0), TIME_KEY, val, _id); + this->add_item_tag(i, nitems_written(0), RATE_KEY, + pmt::from_double(_samp_rate), _id); + this->add_item_tag(i, nitems_written(0), FREQ_KEY, + pmt::from_double(_center_freq), _id); + } +#endif + } + break; + + case ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT: + //its ok to timeout, perhaps the user is doing finite streaming + return 0; + + case ::uhd::rx_metadata_t::ERROR_CODE_OVERFLOW: + _tag_now = true; + //ignore overflows and try work again + return work(noutput_items, input_items, output_items); + + default: + std::cout << boost::format("UHD source block got error code 0x%x") + % _metadata.error_code << std::endl; + return num_samps; + } + + return num_samps; + } + + void + usrp_source_impl::setup_rpc() + { +#ifdef GR_CTRLPORT + add_rpc_variable( + rpcbasic_sptr(new rpcbasic_register_get( + alias(), "samp_rate", + &usrp_source::get_samp_rate, + pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f), + "sps", "RX Sample Rate", RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + add_rpc_variable( + rpcbasic_sptr(new rpcbasic_register_set( + alias(), "samp_rate", + &usrp_source::set_samp_rate, + pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f), + "sps", "RX Sample Rate", + RPC_PRIVLVL_MIN, DISPNULL))); +#endif /* GR_CTRLPORT */ + } + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/lib/uhd/usrp_source_impl.h b/lib/uhd/usrp_source_impl.h new file mode 100644 index 0000000..dd597b0 --- /dev/null +++ b/lib/uhd/usrp_source_impl.h @@ -0,0 +1,149 @@ +/* -*- c++ -*- */ +/* + * Copyright 2010-2013 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include "usrp_source.h" +#include +#if 0 +static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("rx_time"); +static const pmt::pmt_t RATE_KEY = pmt::string_to_symbol("rx_rate"); +static const pmt::pmt_t FREQ_KEY = pmt::string_to_symbol("rx_freq"); +#endif +namespace gr { + namespace uhd { + + inline io_signature::sptr + args_to_io_sig(const ::uhd::stream_args_t &args) + { + const size_t nchan = std::max(args.channels.size(), 1); +#ifdef GR_UHD_USE_STREAM_API + const size_t size = ::uhd::convert::get_bytes_per_item(args.cpu_format); +#else + size_t size = 0; + if(args.cpu_format == "fc32") + size = 8; + if(args.cpu_format == "sc16") + size = 4; +#endif + return io_signature::make(nchan, nchan, size); + } + + /*********************************************************************** + * UHD Multi USRP Source Impl + **********************************************************************/ + class usrp_source_impl : public usrp_source + { + public: + usrp_source_impl(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args); + ~usrp_source_impl(); + + void setup_rpc(); + + // Get Commands + ::uhd::dict get_usrp_info(size_t chan); + std::string get_subdev_spec(size_t mboard); + double get_samp_rate(void); + ::uhd::meta_range_t get_samp_rates(void); + double get_center_freq(size_t chan); + ::uhd::freq_range_t get_freq_range(size_t chan); + double get_gain(size_t chan); + double get_gain(const std::string &name, size_t chan); + std::vector get_gain_names(size_t chan); + ::uhd::gain_range_t get_gain_range(size_t chan); + ::uhd::gain_range_t get_gain_range(const std::string &name, size_t chan); + std::string get_antenna(size_t chan); + std::vector get_antennas(size_t chan); + ::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan); + std::vector get_sensor_names(size_t chan); + ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard); + std::vector get_mboard_sensor_names(size_t mboard); + std::string get_time_source(const size_t mboard); + std::vector get_time_sources(const size_t mboard); + std::string get_clock_source(const size_t mboard); + std::vector get_clock_sources(const size_t mboard); + double get_clock_rate(size_t mboard); + ::uhd::time_spec_t get_time_now(size_t mboard = 0); + ::uhd::time_spec_t get_time_last_pps(size_t mboard); + ::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan); + ::uhd::usrp::multi_usrp::sptr get_device(void); + + // Set Commands + void set_subdev_spec(const std::string &spec, size_t mboard); + void set_samp_rate(double rate); + ::uhd::tune_result_t set_center_freq(const ::uhd::tune_request_t tune_request, + size_t chan); + void set_gain(double gain, size_t chan); + void set_gain(double gain, const std::string &name, size_t chan); + void set_antenna(const std::string &ant, size_t chan); + void set_bandwidth(double bandwidth, size_t chan); + double get_bandwidth(size_t chan); + ::uhd::freq_range_t get_bandwidth_range(size_t chan); + void set_auto_dc_offset(const bool enable, size_t chan); + void set_dc_offset(const std::complex &offset, size_t chan); + void set_iq_balance(const std::complex &correction, size_t chan); + void set_clock_config(const ::uhd::clock_config_t &clock_config, size_t mboard); + void set_time_source(const std::string &source, const size_t mboard); + void set_clock_source(const std::string &source, const size_t mboard); + void set_clock_rate(double rate, size_t mboard); + void set_time_now(const ::uhd::time_spec_t &time_spec, size_t mboard); + void set_time_next_pps(const ::uhd::time_spec_t &time_spec); + void set_time_unknown_pps(const ::uhd::time_spec_t &time_spec); + void set_command_time(const ::uhd::time_spec_t &time_spec, size_t mboard); + void set_user_register(const uint8_t addr, const uint32_t data, size_t mboard); + void set_start_time(const ::uhd::time_spec_t &time); + + void issue_stream_cmd(const ::uhd::stream_cmd_t &cmd); + void clear_command_time(size_t mboard); + void flush(void); + bool start(void); + bool stop(void); + std::vector > finite_acquisition(const size_t nsamps); + std::vector > > finite_acquisition_v(const size_t nsamps); + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); + + private: + ::uhd::usrp::multi_usrp::sptr _dev; + const ::uhd::stream_args_t _stream_args; + boost::shared_ptr< ::uhd::io_type_t > _type; + +#ifdef GR_UHD_USE_STREAM_API + ::uhd::rx_streamer::sptr _rx_stream; + size_t _samps_per_packet; +#endif + size_t _nchan; + bool _stream_now, _tag_now; + ::uhd::rx_metadata_t _metadata; +#if 0 + pmt::pmt_t _id; +#endif + ::uhd::time_spec_t _start_time; + bool _start_time_set; + + //tag shadows + double _samp_rate; + double _center_freq; + }; + + } /* namespace uhd */ +} /* namespace gr */