diff options
21 files changed, 2775 insertions, 2249 deletions
diff --git a/gr-uhd/CMakeLists.txt b/gr-uhd/CMakeLists.txt index 252229d2a7..b0407cb8c8 100644 --- a/gr-uhd/CMakeLists.txt +++ b/gr-uhd/CMakeLists.txt @@ -92,7 +92,7 @@ CPACK_COMPONENT("uhd_swig" ######################################################################## # Add subdirectories ######################################################################## -add_subdirectory(include) +add_subdirectory(include/uhd) add_subdirectory(lib) add_subdirectory(doc) add_subdirectory(examples/c++) diff --git a/gr-uhd/examples/c++/tags_demo.cc b/gr-uhd/examples/c++/tags_demo.cc index cc4c932726..890cc12dea 100644 --- a/gr-uhd/examples/c++/tags_demo.cc +++ b/gr-uhd/examples/c++/tags_demo.cc @@ -20,8 +20,8 @@ */ #include <gr_top_block.h> -#include <gr_uhd_usrp_source.h> -#include <gr_uhd_usrp_sink.h> +#include <uhd/usrp_source.h> +#include <uhd/usrp_sink.h> #include <tag_source_demo.h> #include <tag_sink_demo.h> #include <boost/make_shared.hpp> @@ -79,9 +79,8 @@ int main(int argc, char *argv[]){ //------------------------------------------------------------------ //-- make the usrp source test blocks //------------------------------------------------------------------ - boost::shared_ptr<uhd_usrp_source> usrp_source = uhd_make_usrp_source( - device_addr, uhd::stream_args_t("fc32") - ); + gr::uhd::usrp_source::sptr usrp_source = gr::uhd::usrp_source::make + (device_addr, uhd::stream_args_t("fc32")); usrp_source->set_samp_rate(samp_rate); usrp_source->set_center_freq(center_freq); @@ -95,9 +94,8 @@ int main(int argc, char *argv[]){ //------------------------------------------------------------------ //-- make the usrp sink test blocks //------------------------------------------------------------------ - boost::shared_ptr<uhd_usrp_sink> usrp_sink = uhd_make_usrp_sink( - device_addr, uhd::stream_args_t("fc32") - ); + gr::uhd::usrp_sink::sptr usrp_sink = gr::uhd::usrp_sink::make + (device_addr, uhd::stream_args_t("fc32")); usrp_sink->set_samp_rate(samp_rate); usrp_sink->set_center_freq(center_freq); const uhd::time_spec_t time_now = usrp_sink->get_time_now(); diff --git a/gr-uhd/include/gr_uhd_usrp_sink.h b/gr-uhd/include/gr_uhd_usrp_sink.h deleted file mode 100644 index b684ca146f..0000000000 --- a/gr-uhd/include/gr_uhd_usrp_sink.h +++ /dev/null @@ -1,492 +0,0 @@ -/* - * Copyright 2010-2012 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 <gr_uhd_api.h> -#include <gr_sync_block.h> -#include <uhd/usrp/multi_usrp.hpp> - -#ifndef INCLUDED_UHD_STREAM_HPP -namespace uhd{ - struct GR_UHD_API 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<size_t> channels; - }; -} -# define INCLUDED_UHD_STREAM_HPP -#else -# define GR_UHD_USE_STREAM_API -#endif - -class uhd_usrp_sink; - -/*! - * \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 - */ -GR_UHD_API boost::shared_ptr<uhd_usrp_sink> uhd_make_usrp_sink( - 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 - */ -GR_UHD_API boost::shared_ptr<uhd_usrp_sink> uhd_make_usrp_sink( - const uhd::device_addr_t &device_addr, - const uhd::stream_args_t &stream_args -); - -class GR_UHD_API uhd_usrp_sink : virtual public gr_sync_block{ -public: - - /*! - * 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<std::string, std::string> 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<std::string> 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<std::string> 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; - - /*! - * 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<double> &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<double> &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<std::string> 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<std::string> 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<std::string> 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<std::string> 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<std::string> 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; -}; - -#endif /* INCLUDED_GR_UHD_USRP_SINK_H */ diff --git a/gr-uhd/include/gr_uhd_usrp_source.h b/gr-uhd/include/gr_uhd_usrp_source.h deleted file mode 100644 index a56da6ab09..0000000000 --- a/gr-uhd/include/gr_uhd_usrp_source.h +++ /dev/null @@ -1,538 +0,0 @@ -/* - * Copyright 2010-2012 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 <gr_uhd_api.h> -#include <gr_sync_block.h> -#include <uhd/usrp/multi_usrp.hpp> - -#ifndef INCLUDED_UHD_STREAM_HPP -namespace uhd{ - struct GR_UHD_API 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<size_t> channels; - }; -} -# define INCLUDED_UHD_STREAM_HPP -#else -# define GR_UHD_USE_STREAM_API -#endif - -class uhd_usrp_source; - -/*! - * \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 - */ -GR_UHD_API boost::shared_ptr<uhd_usrp_source> uhd_make_usrp_source( - 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 - */ -GR_UHD_API boost::shared_ptr<uhd_usrp_source> uhd_make_usrp_source( - const uhd::device_addr_t &device_addr, - const uhd::stream_args_t &stream_args -); - -class GR_UHD_API uhd_usrp_source : virtual public gr_sync_block{ -public: - - /*! - * 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<std::string, std::string> 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<std::string> 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<std::string> 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; - - /*! - * 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<double> &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<double> &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<std::string> 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<std::string> 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<std::string> 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<std::string> 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<std::string> 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<std::complex<float> > 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<std::vector<std::complex<float> > > finite_acquisition_v(const size_t nsamps) = 0; -}; - -#endif /* INCLUDED_GR_UHD_USRP_SOURCE_H */ diff --git a/gr-uhd/include/CMakeLists.txt b/gr-uhd/include/uhd/CMakeLists.txt index 27d3d1d369..066487c6ca 100644 --- a/gr-uhd/include/CMakeLists.txt +++ b/gr-uhd/include/uhd/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright 2011 Free Software Foundation, Inc. +# Copyright 2011,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,10 +21,10 @@ # Install header files ######################################################################## install(FILES - gr_uhd_api.h - gr_uhd_usrp_source.h - gr_uhd_usrp_sink.h - gr_uhd_amsg_source.h - DESTINATION ${GR_INCLUDE_DIR}/gnuradio + api.h + usrp_source.h + usrp_sink.h + amsg_source.h + DESTINATION ${GR_INCLUDE_DIR}/gnuradio/gr_uhd COMPONENT "uhd_devel" ) diff --git a/gr-uhd/include/gr_uhd_amsg_source.h b/gr-uhd/include/uhd/amsg_source.h index f2f21c99f5..819f6edad2 100644 --- a/gr-uhd/include/gr_uhd_amsg_source.h +++ b/gr-uhd/include/uhd/amsg_source.h @@ -1,5 +1,6 @@ +/* -*- c++ -*- */ /* - * Copyright 2011 Free Software Foundation, Inc. + * Copyright 2011,2013 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -22,29 +23,37 @@ #ifndef INCLUDED_GR_UHD_AMSG_SOURCE_H #define INCLUDED_GR_UHD_AMSG_SOURCE_H -#include <gr_uhd_api.h> +#include <uhd/api.h> #include <uhd/usrp/multi_usrp.hpp> #include <gr_msg_queue.h> -class uhd_amsg_source; +namespace gr { + namespace uhd { -/*! - * \brief Make a new USRP asynchronous message-based source block. - * \ingroup uhd_blk - */ -GR_UHD_API boost::shared_ptr<uhd_amsg_source> uhd_make_amsg_source( - const uhd::device_addr_t &device_addr, - gr_msg_queue_sptr msgq -); - -class GR_UHD_API uhd_amsg_source{ -public: - /*! - * Convert a raw asynchronous message to an asynchronous metatdata object. - * \return The asynchronous metadata object. - */ - static uhd::async_metadata_t msg_to_async_metadata_t(const gr_message_sptr msg); - -}; + class uhd_amsg_source; + + class GR_UHD_API amsg_source + { + public: + // gr::uhd::amsg_source::sptr + typedef boost::shared_ptr<amsg_source> sptr; + + /*! + * \brief Make a new USRP asynchronous message-based source block. + * \ingroup uhd_blk + */ + static sptr make(const ::uhd::device_addr_t &device_addr, + gr_msg_queue_sptr msgq); + + /*! + * Convert a raw asynchronous message to an asynchronous metatdata object. + * \return The asynchronous metadata object. + */ + static ::uhd::async_metadata_t + msg_to_async_metadata_t(const gr_message_sptr msg); + }; + + } /* namespace uhd */ +} /* namespace gr */ #endif /* INCLUDED_GR_UHD_AMSG_SOURCE_H */ diff --git a/gr-uhd/include/gr_uhd_api.h b/gr-uhd/include/uhd/api.h index 106acd8c76..106acd8c76 100644 --- a/gr-uhd/include/gr_uhd_api.h +++ b/gr-uhd/include/uhd/api.h diff --git a/gr-uhd/include/uhd/usrp_sink.h b/gr-uhd/include/uhd/usrp_sink.h new file mode 100644 index 0000000000..c54689241b --- /dev/null +++ b/gr-uhd/include/uhd/usrp_sink.h @@ -0,0 +1,516 @@ +/* -*- 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 <uhd/api.h> +#include <gr_sync_block.h> +#include <uhd/usrp/multi_usrp.hpp> + +#ifndef INCLUDED_UHD_STREAM_HPP +namespace uhd { + struct GR_UHD_API 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<size_t> channels; + }; +} +# define INCLUDED_UHD_STREAM_HPP +#else +# define GR_UHD_USE_STREAM_API +#endif + +namespace gr { + namespace uhd { + + class uhd_usrp_sink; + + class GR_UHD_API usrp_sink : virtual public gr_sync_block + { + public: + // gr::uhd::usrp_sink::sptr + typedef boost::shared_ptr<usrp_sink> 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<std::string, std::string> 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<std::string> 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<std::string> 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; + + /*! + * 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<double> &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<double> &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<std::string> 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<std::string> 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<std::string> 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<std::string> 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<std::string> 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/gr-uhd/include/uhd/usrp_source.h b/gr-uhd/include/uhd/usrp_source.h new file mode 100644 index 0000000000..2348e73ed4 --- /dev/null +++ b/gr-uhd/include/uhd/usrp_source.h @@ -0,0 +1,567 @@ +/* -*- 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 <uhd/api.h> +#include <gr_sync_block.h> +#include <uhd/usrp/multi_usrp.hpp> + +#ifndef INCLUDED_UHD_STREAM_HPP +namespace uhd { + struct GR_UHD_API 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<size_t> channels; + }; +} +# define INCLUDED_UHD_STREAM_HPP +#else +# define GR_UHD_USE_STREAM_API +#endif + +namespace gr { + namespace uhd { + + class uhd_usrp_source; + + class GR_UHD_API usrp_source : virtual public gr_sync_block + { + public: + // gr::uhd::usrp_source::sptr + typedef boost::shared_ptr<usrp_source> 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<std::string, std::string> 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<std::string> 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<std::string> 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; + + /*! + * 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<double> &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<double> &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<std::string> 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<std::string> 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<std::string> 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<std::string> 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<std::string> 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<std::complex<float> > + 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<std::vector<std::complex<float> > > + finite_acquisition_v(const size_t nsamps) = 0; + }; + + } /* namespace uhd */ +} /* namespace gr */ + +#endif /* INCLUDED_GR_UHD_USRP_SOURCE_H */ diff --git a/gr-uhd/lib/CMakeLists.txt b/gr-uhd/lib/CMakeLists.txt index c494fddad5..ab1448a673 100644 --- a/gr-uhd/lib/CMakeLists.txt +++ b/gr-uhd/lib/CMakeLists.txt @@ -38,9 +38,9 @@ link_directories( # Setup library ######################################################################## list(APPEND gr_uhd_sources - gr_uhd_usrp_source.cc - gr_uhd_usrp_sink.cc - gr_uhd_amsg_source.cc + usrp_source_impl.cc + usrp_sink_impl.cc + amsg_source_impl.cc ) list(APPEND uhd_libs diff --git a/gr-uhd/lib/amsg_source_impl.cc b/gr-uhd/lib/amsg_source_impl.cc new file mode 100644 index 0000000000..76603e4989 --- /dev/null +++ b/gr-uhd/lib/amsg_source_impl.cc @@ -0,0 +1,86 @@ +/* -*- c++ -*- */ +/* + * Copyright 2011-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 "amsg_source_impl.h" +#include "gr_uhd_common.h" +#include <boost/bind.hpp> + +namespace gr { + namespace uhd { + + amsg_source::sptr + amsg_source::make(const ::uhd::device_addr_t &device_addr, + gr_msg_queue_sptr msgq) + { + check_abi(); + return amsg_source::sptr + (new amsg_source_impl(device_addr, msgq)); + } + + ::uhd::async_metadata_t + amsg_source::msg_to_async_metadata_t(const gr_message_sptr msg) + { + return *(::uhd::async_metadata_t *)msg->msg(); + } + + amsg_source_impl::amsg_source_impl(const ::uhd::device_addr_t &device_addr, + gr_msg_queue_sptr msgq) + : _msgq(msgq), _running(true) + { + _dev = ::uhd::usrp::multi_usrp::make(device_addr); + _amsg_thread = + gruel::thread(boost::bind(&amsg_source_impl::recv_loop, this)); + } + + amsg_source_impl::~amsg_source_impl() + { + _running = false; + _amsg_thread.join(); + } + + void + amsg_source_impl::recv_loop() + { + gr_message_sptr msg; + ::uhd::async_metadata_t *md; + + while(_running) { + msg = gr_make_message(0, 0.0, 0.0, sizeof(::uhd::async_metadata_t)); + md = (::uhd::async_metadata_t*) msg->msg(); + + while(!_dev->get_device()->recv_async_msg(*md, 0.1)) { + if(!_running) + return; + } + + post(msg); + } + } + + void + amsg_source_impl::post(gr_message_sptr msg) + { + _msgq->insert_tail(msg); + } + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/gr-uhd/lib/amsg_source_impl.h b/gr-uhd/lib/amsg_source_impl.h new file mode 100644 index 0000000000..2928e85adb --- /dev/null +++ b/gr-uhd/lib/amsg_source_impl.h @@ -0,0 +1,48 @@ +/* -*- c++ -*- */ +/* + * Copyright 2011-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 <uhd/amsg_source.h> +#include <gruel/thread.h> + +namespace gr { + namespace uhd { + + class amsg_source_impl : public amsg_source + { + public: + amsg_source_impl(const ::uhd::device_addr_t &device_addr, + gr_msg_queue_sptr msgq); + ~amsg_source_impl(); + + void recv_loop(); + void post(gr_message_sptr msg); + + protected: + ::uhd::usrp::multi_usrp::sptr _dev; + gruel::thread _amsg_thread; + gr_msg_queue_sptr _msgq; + bool _running; + }; + + } /* namespace uhd */ +} /* namespace gr */ + diff --git a/gr-uhd/lib/gr_uhd_amsg_source.cc b/gr-uhd/lib/gr_uhd_amsg_source.cc deleted file mode 100644 index d2e2dd0bf8..0000000000 --- a/gr-uhd/lib/gr_uhd_amsg_source.cc +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright 2011-2012 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 <gr_uhd_amsg_source.h> -#include <boost/bind.hpp> -#include <gruel/thread.h> -#include "gr_uhd_common.h" - -/*********************************************************************** - * UHD Asynchronous Message Source Impl - **********************************************************************/ -class uhd_amsg_source_impl : public uhd_amsg_source{ -public: - uhd_amsg_source_impl( - const uhd::device_addr_t &device_addr, - gr_msg_queue_sptr msgq - ): - _msgq(msgq), _running(true) - { - _dev = uhd::usrp::multi_usrp::make(device_addr); - _amsg_thread = - gruel::thread(boost::bind(&uhd_amsg_source_impl::recv_loop, this)); - } - - ~uhd_amsg_source_impl() - { - _running = false; - _amsg_thread.join(); - } - - void recv_loop() - { - gr_message_sptr msg; - uhd::async_metadata_t *md; - - while (_running) { - msg = gr_make_message(0, 0.0, 0.0, sizeof(uhd::async_metadata_t)); - md = (uhd::async_metadata_t *) msg->msg(); - - while (!_dev->get_device()->recv_async_msg(*md, 0.1)) { - if (!_running) - return; - } - - post(msg); - } - } - - void post(gr_message_sptr msg) - { - _msgq->insert_tail(msg); - } - -protected: - uhd::usrp::multi_usrp::sptr _dev; - gruel::thread _amsg_thread; - gr_msg_queue_sptr _msgq; - bool _running; -}; - -uhd::async_metadata_t uhd_amsg_source::msg_to_async_metadata_t(const gr_message_sptr msg) -{ - return *(uhd::async_metadata_t *)msg->msg(); -} - -/*********************************************************************** - * Make UHD Asynchronous Message Source - **********************************************************************/ -boost::shared_ptr<uhd_amsg_source> uhd_make_amsg_source( - const uhd::device_addr_t &device_addr, - gr_msg_queue_sptr msgq -){ - gr_uhd_check_abi(); - return boost::shared_ptr<uhd_amsg_source>( - new uhd_amsg_source_impl(device_addr, msgq) - ); -} diff --git a/gr-uhd/lib/gr_uhd_common.h b/gr-uhd/lib/gr_uhd_common.h index f2433b288c..0c18fa4634 100644 --- a/gr-uhd/lib/gr_uhd_common.h +++ b/gr-uhd/lib/gr_uhd_common.h @@ -1,5 +1,6 @@ +/* -*- c++ -*- */ /* - * Copyright 2012 Free Software Foundation, Inc. + * Copyright 2012-2013 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -26,17 +27,26 @@ #include <boost/format.hpp> #include <stdexcept> -static inline void gr_uhd_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( +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 -} + ) % UHD_VERSION_ABI_STRING % ::uhd::get_abi_string())); +#endif + } + + } /* namespace uhd */ +} /* namespace gr */ #endif /* INCLUDED_GR_UHD_COMMON_H */ diff --git a/gr-uhd/lib/gr_uhd_usrp_sink.cc b/gr-uhd/lib/gr_uhd_usrp_sink.cc deleted file mode 100644 index 3b8fcea405..0000000000 --- a/gr-uhd/lib/gr_uhd_usrp_sink.cc +++ /dev/null @@ -1,503 +0,0 @@ -/* - * Copyright 2010-2012 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 <gr_uhd_usrp_sink.h> -#include <gr_io_signature.h> -#include <stdexcept> -#include <boost/make_shared.hpp> -#include "gr_uhd_common.h" - -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"); - -#include <uhd/convert.hpp> -inline gr_io_signature_sptr args_to_io_sig(const uhd::stream_args_t &args){ - const size_t nchan = std::max<size_t>(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 gr_make_io_signature(nchan, nchan, size); -} - -/*********************************************************************** - * UHD Multi USRP Sink Impl - **********************************************************************/ -class uhd_usrp_sink_impl : public uhd_usrp_sink{ -public: - uhd_usrp_sink_impl( - const uhd::device_addr_t &device_addr, - const uhd::stream_args_t &stream_args - ): - gr_sync_block( - "gr uhd usrp sink", - args_to_io_sig(stream_args), - gr_make_io_signature(0, 0, 0) - ), - _stream_args(stream_args), - _nchan(std::max<size_t>(1, 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); - } - - uhd::dict<std::string, std::string> get_usrp_info(size_t 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 set_subdev_spec(const std::string &spec, size_t mboard){ - return _dev->set_tx_subdev_spec(spec, mboard); - } - - std::string get_subdev_spec(size_t mboard){ - return _dev->get_tx_subdev_spec(mboard).to_string(); - } - - void set_samp_rate(double rate){ - _dev->set_tx_rate(rate); - _sample_rate = this->get_samp_rate(); - } - - double get_samp_rate(void){ - return _dev->get_tx_rate(); - } - - uhd::meta_range_t get_samp_rates(void){ - #ifdef UHD_USRP_MULTI_USRP_GET_RATES_API - return _dev->get_tx_rates(); - #else - throw std::runtime_error("not implemented in this version"); - #endif - } - - uhd::tune_result_t set_center_freq( - const uhd::tune_request_t tune_request, size_t chan - ){ - return _dev->set_tx_freq(tune_request, chan); - } - - double get_center_freq(size_t chan){ - return _dev->get_tx_freq(chan); - } - - uhd::freq_range_t get_freq_range(size_t chan){ - return _dev->get_tx_freq_range(chan); - } - - void set_gain(double gain, size_t chan){ - return _dev->set_tx_gain(gain, chan); - } - - void set_gain(double gain, const std::string &name, size_t chan){ - return _dev->set_tx_gain(gain, name, chan); - } - - double get_gain(size_t chan){ - return _dev->get_tx_gain(chan); - } - - double get_gain(const std::string &name, size_t chan){ - return _dev->get_tx_gain(name, chan); - } - - std::vector<std::string> get_gain_names(size_t chan){ - return _dev->get_tx_gain_names(chan); - } - - uhd::gain_range_t get_gain_range(size_t chan){ - return _dev->get_tx_gain_range(chan); - } - - uhd::gain_range_t get_gain_range(const std::string &name, size_t chan){ - return _dev->get_tx_gain_range(name, chan); - } - - void set_antenna(const std::string &ant, size_t chan){ - return _dev->set_tx_antenna(ant, chan); - } - - std::string get_antenna(size_t chan){ - return _dev->get_tx_antenna(chan); - } - - std::vector<std::string> get_antennas(size_t chan){ - return _dev->get_tx_antennas(chan); - } - - void set_bandwidth(double bandwidth, size_t chan){ - return _dev->set_tx_bandwidth(bandwidth, chan); - } - - void set_dc_offset(const std::complex<double> &offset, size_t 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 set_iq_balance(const std::complex<double> &correction, size_t 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 get_sensor(const std::string &name, size_t chan){ - return _dev->get_tx_sensor(name, chan); - } - - std::vector<std::string> get_sensor_names(size_t chan){ - return _dev->get_tx_sensor_names(chan); - } - - uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard){ - return _dev->get_mboard_sensor(name, mboard); - } - - std::vector<std::string> get_mboard_sensor_names(size_t mboard){ - return _dev->get_mboard_sensor_names(mboard); - } - - void set_clock_config(const uhd::clock_config_t &clock_config, size_t mboard){ - return _dev->set_clock_config(clock_config, mboard); - } - - void 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 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<std::string> 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 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 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<std::string> 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 get_clock_rate(size_t mboard){ - return _dev->get_master_clock_rate(mboard); - } - - void set_clock_rate(double rate, size_t mboard){ - return _dev->set_master_clock_rate(rate, mboard); - } - - uhd::time_spec_t get_time_now(size_t mboard = 0){ - return _dev->get_time_now(mboard); - } - - uhd::time_spec_t get_time_last_pps(size_t mboard){ - return _dev->get_time_last_pps(mboard); - } - - void set_time_now(const uhd::time_spec_t &time_spec, size_t mboard){ - return _dev->set_time_now(time_spec, mboard); - } - - void set_time_next_pps(const uhd::time_spec_t &time_spec){ - return _dev->set_time_next_pps(time_spec); - } - - void set_time_unknown_pps(const uhd::time_spec_t &time_spec){ - return _dev->set_time_unknown_pps(time_spec); - } - - void 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 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 get_dboard_iface(size_t chan){ - return _dev->get_tx_dboard_iface(chan); - } - - uhd::usrp::multi_usrp::sptr get_device(void){ - return _dev; - } - - void 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 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; - - //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); - - #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 - **********************************************************************/ - inline void tag_work(int &ninput_items){ - //the for loop below assumes tags sorted by count low -> high - std::sort(_tags.begin(), _tags.end(), gr_tag_t::offset_compare); - - //extract absolute sample counts - const gr_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 - BOOST_FOREACH(const gr_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)) - ); - } - } - } - - void 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 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 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; - } - -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; - - //stream tags related stuff - std::vector<gr_tag_t> _tags; -}; - -/*********************************************************************** - * Make UHD Multi USRP Sink - **********************************************************************/ -boost::shared_ptr<uhd_usrp_sink> uhd_make_usrp_sink( - 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 uhd_make_usrp_sink(device_addr, stream_args); -} - -boost::shared_ptr<uhd_usrp_sink> uhd_make_usrp_sink( - const uhd::device_addr_t &device_addr, - const uhd::stream_args_t &stream_args -){ - gr_uhd_check_abi(); - return boost::shared_ptr<uhd_usrp_sink>( - new uhd_usrp_sink_impl(device_addr, stream_args) - ); -} diff --git a/gr-uhd/lib/gr_uhd_usrp_source.cc b/gr-uhd/lib/gr_uhd_usrp_source.cc deleted file mode 100644 index 6403d3d913..0000000000 --- a/gr-uhd/lib/gr_uhd_usrp_source.cc +++ /dev/null @@ -1,563 +0,0 @@ -/* - * Copyright 2010-2012 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 <gr_uhd_usrp_source.h> -#include <gr_io_signature.h> -#include <stdexcept> -#include <iostream> -#include <boost/format.hpp> -#include <boost/thread/thread.hpp> -#include <boost/make_shared.hpp> -#include "gr_uhd_common.h" - -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"); - -#include <uhd/convert.hpp> -inline gr_io_signature_sptr args_to_io_sig(const uhd::stream_args_t &args){ - const size_t nchan = std::max<size_t>(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 gr_make_io_signature(nchan, nchan, size); -} - -/*********************************************************************** - * UHD Multi USRP Source Impl - **********************************************************************/ -class uhd_usrp_source_impl : public uhd_usrp_source{ -public: - uhd_usrp_source_impl( - const uhd::device_addr_t &device_addr, - const uhd::stream_args_t &stream_args - ): - gr_sync_block( - "gr uhd usrp source", - gr_make_io_signature(0, 0, 0), - args_to_io_sig(stream_args) - ), - _stream_args(stream_args), - _nchan(std::max<size_t>(1, 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(); - _id = pmt::string_to_symbol(str.str()); - _dev = uhd::usrp::multi_usrp::make(device_addr); - } - - uhd::dict<std::string, std::string> get_usrp_info(size_t 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 set_subdev_spec(const std::string &spec, size_t mboard){ - return _dev->set_rx_subdev_spec(spec, mboard); - } - - std::string get_subdev_spec(size_t mboard){ - return _dev->get_rx_subdev_spec(mboard).to_string(); - } - - void set_samp_rate(double rate){ - _dev->set_rx_rate(rate); - _samp_rate = this->get_samp_rate(); - _tag_now = true; - } - - double get_samp_rate(void){ - return _dev->get_rx_rate(); - } - - uhd::meta_range_t get_samp_rates(void){ - #ifdef UHD_USRP_MULTI_USRP_GET_RATES_API - return _dev->get_rx_rates(); - #else - throw std::runtime_error("not implemented in this version"); - #endif - } - - uhd::tune_result_t set_center_freq( - const uhd::tune_request_t tune_request, size_t chan - ){ - const uhd::tune_result_t res = _dev->set_rx_freq(tune_request, chan); - _center_freq = this->get_center_freq(chan); - _tag_now = true; - return res; - } - - double get_center_freq(size_t chan){ - return _dev->get_rx_freq(chan); - } - - uhd::freq_range_t get_freq_range(size_t chan){ - return _dev->get_rx_freq_range(chan); - } - - void set_gain(double gain, size_t chan){ - return _dev->set_rx_gain(gain, chan); - } - - void set_gain(double gain, const std::string &name, size_t chan){ - return _dev->set_rx_gain(gain, name, chan); - } - - double get_gain(size_t chan){ - return _dev->get_rx_gain(chan); - } - - double get_gain(const std::string &name, size_t chan){ - return _dev->get_rx_gain(name, chan); - } - - std::vector<std::string> get_gain_names(size_t chan){ - return _dev->get_rx_gain_names(chan); - } - - uhd::gain_range_t get_gain_range(size_t chan){ - return _dev->get_rx_gain_range(chan); - } - - uhd::gain_range_t get_gain_range(const std::string &name, size_t chan){ - return _dev->get_rx_gain_range(name, chan); - } - - void set_antenna(const std::string &ant, size_t chan){ - return _dev->set_rx_antenna(ant, chan); - } - - std::string get_antenna(size_t chan){ - return _dev->get_rx_antenna(chan); - } - - std::vector<std::string> get_antennas(size_t chan){ - return _dev->get_rx_antennas(chan); - } - - void set_bandwidth(double bandwidth, size_t chan){ - return _dev->set_rx_bandwidth(bandwidth, chan); - } - - void set_auto_dc_offset(const bool enable, size_t 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 set_dc_offset(const std::complex<double> &offset, size_t 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 set_iq_balance(const std::complex<double> &correction, size_t 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 get_sensor(const std::string &name, size_t chan){ - return _dev->get_rx_sensor(name, chan); - } - - std::vector<std::string> get_sensor_names(size_t chan){ - return _dev->get_rx_sensor_names(chan); - } - - uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard){ - return _dev->get_mboard_sensor(name, mboard); - } - - std::vector<std::string> get_mboard_sensor_names(size_t mboard){ - return _dev->get_mboard_sensor_names(mboard); - } - - void set_clock_config(const uhd::clock_config_t &clock_config, size_t mboard){ - return _dev->set_clock_config(clock_config, mboard); - } - - void 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 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<std::string> 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 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 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<std::string> 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 get_clock_rate(size_t mboard){ - return _dev->get_master_clock_rate(mboard); - } - - void set_clock_rate(double rate, size_t mboard){ - return _dev->set_master_clock_rate(rate, mboard); - } - - uhd::time_spec_t get_time_now(size_t mboard = 0){ - return _dev->get_time_now(mboard); - } - - uhd::time_spec_t get_time_last_pps(size_t mboard){ - return _dev->get_time_last_pps(mboard); - } - - void set_time_now(const uhd::time_spec_t &time_spec, size_t mboard){ - return _dev->set_time_now(time_spec, mboard); - } - - void set_time_next_pps(const uhd::time_spec_t &time_spec){ - return _dev->set_time_next_pps(time_spec); - } - - void set_time_unknown_pps(const uhd::time_spec_t &time_spec){ - return _dev->set_time_unknown_pps(time_spec); - } - - void 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 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 get_dboard_iface(size_t chan){ - return _dev->get_rx_dboard_iface(chan); - } - - uhd::usrp::multi_usrp::sptr get_device(void){ - return _dev; - } - - void 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 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; - //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); - } - } - 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 set_start_time(const uhd::time_spec_t &time){ - _start_time = time; - _start_time_set = true; - _stream_now = false; - } - - void issue_stream_cmd(const uhd::stream_cmd_t &cmd) - { - _dev->issue_stream_cmd(cmd); - } - - bool 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); - } - _dev->issue_stream_cmd(stream_cmd); - _tag_now = true; - return true; - } - - void flush(void){ - const size_t nbytes = 4096; - gr_vector_void_star outputs; - std::vector<std::vector<char> > buffs(_nchan, std::vector<char>(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 stop(void){ - _dev->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS); - - this->flush(); - - return true; - } - - std::vector<std::complex<float> > 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<std::vector<std::complex<float> > > 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<std::vector<std::complex<float> > > samps(_nchan, std::vector<std::complex<float> >(nsamps)); - - //load the void* vector of buffer pointers - std::vector<void *> 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); - _dev->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 - } - -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; - pmt::pmt_t _id; - - uhd::time_spec_t _start_time; - bool _start_time_set; - - //tag shadows - double _samp_rate; - double _center_freq; -}; - - -/*********************************************************************** - * Make UHD Multi USRP Source - **********************************************************************/ -boost::shared_ptr<uhd_usrp_source> uhd_make_usrp_source( - 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 uhd_make_usrp_source(device_addr, stream_args); -} - -boost::shared_ptr<uhd_usrp_source> uhd_make_usrp_source( - const uhd::device_addr_t &device_addr, - const uhd::stream_args_t &stream_args -){ - gr_uhd_check_abi(); - return boost::shared_ptr<uhd_usrp_source>( - new uhd_usrp_source_impl(device_addr, stream_args) - ); -} diff --git a/gr-uhd/lib/usrp_sink_impl.cc b/gr-uhd/lib/usrp_sink_impl.cc new file mode 100644 index 0000000000..563917abaf --- /dev/null +++ b/gr-uhd/lib/usrp_sink_impl.cc @@ -0,0 +1,575 @@ +/* -*- 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 <gr_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) + { + //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)); + } + + usrp_sink_impl::usrp_sink_impl(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args) + : gr_sync_block("gr uhd usrp sink", + args_to_io_sig(stream_args), + gr_make_io_signature(0, 0, 0)), + _stream_args(stream_args), + _nchan(std::max<size_t>(1, 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<std::string, std::string> + usrp_sink_impl::get_usrp_info(size_t 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) + { + _dev->set_tx_rate(rate); + _sample_rate = this->get_samp_rate(); + } + + double + usrp_sink_impl::get_samp_rate(void) + { + return _dev->get_tx_rate(); + } + + ::uhd::meta_range_t + usrp_sink_impl::get_samp_rates(void) + { +#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API + return _dev->get_tx_rates(); +#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) + { + return _dev->set_tx_freq(tune_request, chan); + } + + double + usrp_sink_impl::get_center_freq(size_t chan) + { + return _dev->get_tx_freq(chan); + } + + ::uhd::freq_range_t + usrp_sink_impl::get_freq_range(size_t chan) + { + return _dev->get_tx_freq_range(chan); + } + + void + usrp_sink_impl::set_gain(double gain, size_t chan) + { + return _dev->set_tx_gain(gain, chan); + } + + void + usrp_sink_impl::set_gain(double gain, + const std::string &name, + size_t chan) + { + return _dev->set_tx_gain(gain, name, chan); + } + + double + usrp_sink_impl::get_gain(size_t chan) + { + return _dev->get_tx_gain(chan); + } + + double + usrp_sink_impl::get_gain(const std::string &name, size_t chan) + { + return _dev->get_tx_gain(name, chan); + } + + std::vector<std::string> + usrp_sink_impl::get_gain_names(size_t chan) + { + return _dev->get_tx_gain_names(chan); + } + + ::uhd::gain_range_t + usrp_sink_impl::get_gain_range(size_t 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) + { + return _dev->get_tx_gain_range(name, chan); + } + + void + usrp_sink_impl::set_antenna(const std::string &ant, + size_t chan) + { + return _dev->set_tx_antenna(ant, chan); + } + + std::string + usrp_sink_impl::get_antenna(size_t chan) + { + return _dev->get_tx_antenna(chan); + } + + std::vector<std::string> + usrp_sink_impl::get_antennas(size_t chan) + { + return _dev->get_tx_antennas(chan); + } + + void + usrp_sink_impl::set_bandwidth(double bandwidth, size_t chan) + { + return _dev->set_tx_bandwidth(bandwidth, chan); + } + + void + usrp_sink_impl::set_dc_offset(const std::complex<double> &offset, + size_t 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<double> &correction, + size_t 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) + { + return _dev->get_tx_sensor(name, chan); + } + + std::vector<std::string> + usrp_sink_impl::get_sensor_names(size_t 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<std::string> + 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<std::string> + 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<std::string> + 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) + { + 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; + + //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); + +#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) + { + //the for loop below assumes tags sorted by count low -> high + std::sort(_tags.begin(), _tags.end(), gr_tag_t::offset_compare); + + //extract absolute sample counts + const gr_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 + BOOST_FOREACH(const gr_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))); + } + } + } + + 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; + } + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/gr-uhd/lib/usrp_sink_impl.h b/gr-uhd/lib/usrp_sink_impl.h new file mode 100644 index 0000000000..d630e0f2fc --- /dev/null +++ b/gr-uhd/lib/usrp_sink_impl.h @@ -0,0 +1,137 @@ +/* -*- 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 <uhd/usrp_sink.h> +#include <uhd/convert.hpp> + +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"); + +namespace gr { + namespace uhd { + + inline gr_io_signature_sptr + args_to_io_sig(const ::uhd::stream_args_t &args) + { + const size_t nchan = std::max<size_t>(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 gr_make_io_signature(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(); + + ::uhd::dict<std::string, std::string> 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<std::string> 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<std::string> get_antennas(size_t chan); + ::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan); + std::vector<std::string> get_sensor_names(size_t chan); + ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard); + std::vector<std::string> get_mboard_sensor_names(size_t mboard); + std::string get_time_source(const size_t mboard); + std::vector<std::string> get_time_sources(const size_t mboard); + std::string get_clock_source(const size_t mboard); + std::vector<std::string> 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); + void set_dc_offset(const std::complex<double> &offset, size_t chan); + void set_iq_balance(const std::complex<double> &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; + + //stream tags related stuff + std::vector<gr_tag_t> _tags; + }; + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/gr-uhd/lib/usrp_source_impl.cc b/gr-uhd/lib/usrp_source_impl.cc new file mode 100644 index 0000000000..9d6a55ae5a --- /dev/null +++ b/gr-uhd/lib/usrp_source_impl.cc @@ -0,0 +1,628 @@ +/* -*- 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 <gr_io_signature.h> +#include <boost/format.hpp> +#include <boost/thread/thread.hpp> +#include <boost/make_shared.hpp> +#include <stdexcept> +#include <iostream> + +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)); + } + + usrp_source_impl::usrp_source_impl(const ::uhd::device_addr_t &device_addr, + const ::uhd::stream_args_t &stream_args): + gr_sync_block("gr uhd usrp source", + gr_make_io_signature(0, 0, 0), + args_to_io_sig(stream_args)), + _stream_args(stream_args), + _nchan(std::max<size_t>(1, 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(); + _id = pmt::string_to_symbol(str.str()); + _dev = ::uhd::usrp::multi_usrp::make(device_addr); + } + + usrp_source_impl::~usrp_source_impl() + { + } + + ::uhd::dict<std::string, std::string> + usrp_source_impl::get_usrp_info(size_t 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) + { + _dev->set_rx_rate(rate); + _samp_rate = this->get_samp_rate(); + _tag_now = true; + } + + double + usrp_source_impl::get_samp_rate(void) + { + return _dev->get_rx_rate(); + } + + ::uhd::meta_range_t + usrp_source_impl::get_samp_rates(void) + { +#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API + return _dev->get_rx_rates(); +#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 ::uhd::tune_result_t res = _dev->set_rx_freq(tune_request, chan); + _center_freq = this->get_center_freq(chan); + _tag_now = true; + return res; + } + + double + usrp_source_impl::get_center_freq(size_t chan) + { + return _dev->get_rx_freq(chan); + } + + ::uhd::freq_range_t + usrp_source_impl::get_freq_range(size_t chan) + { + return _dev->get_rx_freq_range(chan); + } + + void + usrp_source_impl::set_gain(double gain, size_t chan) + { + return _dev->set_rx_gain(gain, chan); + } + + void + usrp_source_impl::set_gain(double gain, const std::string &name, size_t chan) + { + return _dev->set_rx_gain(gain, name, chan); + } + + double + usrp_source_impl::get_gain(size_t chan) + { + return _dev->get_rx_gain(chan); + } + + double + usrp_source_impl::get_gain(const std::string &name, size_t chan) + { + return _dev->get_rx_gain(name, chan); + } + + std::vector<std::string> + usrp_source_impl::get_gain_names(size_t chan) + { + return _dev->get_rx_gain_names(chan); + } + + ::uhd::gain_range_t + usrp_source_impl::get_gain_range(size_t 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) + { + return _dev->get_rx_gain_range(name, chan); + } + + void + usrp_source_impl::set_antenna(const std::string &ant, size_t chan) + { + return _dev->set_rx_antenna(ant, chan); + } + + std::string + usrp_source_impl::get_antenna(size_t chan) + { + return _dev->get_rx_antenna(chan); + } + + std::vector<std::string> + usrp_source_impl::get_antennas(size_t chan) + { + return _dev->get_rx_antennas(chan); + } + + void + usrp_source_impl::set_bandwidth(double bandwidth, size_t chan) + { + return _dev->set_rx_bandwidth(bandwidth, chan); + } + + void + usrp_source_impl::set_auto_dc_offset(const bool enable, size_t 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<double> &offset, + size_t 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<double> &correction, + size_t 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) + { + return _dev->get_rx_sensor(name, chan); + } + + std::vector<std::string> + usrp_source_impl::get_sensor_names(size_t 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<std::string> + 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<std::string> + 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<std::string> + 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) + { + 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) + { + _dev->issue_stream_cmd(cmd); + } + + 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); + } + _dev->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<std::vector<char> > buffs(_nchan, std::vector<char>(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) + { + _dev->issue_stream_cmd(::uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS); + + this->flush(); + + return true; + } + + std::vector<std::complex<float> > + 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<std::vector<std::complex<float> > > + 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<std::vector<std::complex<float> > > + samps(_nchan, std::vector<std::complex<float> >(nsamps)); + + //load the void* vector of buffer pointers + std::vector<void *> 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); + _dev->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; + //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); + } + } + 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; + } + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/gr-uhd/lib/usrp_source_impl.h b/gr-uhd/lib/usrp_source_impl.h new file mode 100644 index 0000000000..b0b04a795b --- /dev/null +++ b/gr-uhd/lib/usrp_source_impl.h @@ -0,0 +1,144 @@ +/* -*- 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 <uhd/usrp_source.h> +#include <uhd/convert.hpp> + +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"); + +namespace gr { + namespace uhd { + + inline gr_io_signature_sptr + args_to_io_sig(const ::uhd::stream_args_t &args) + { + const size_t nchan = std::max<size_t>(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 gr_make_io_signature(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(); + + // Get Commands + ::uhd::dict<std::string, std::string> 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<std::string> 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<std::string> get_antennas(size_t chan); + ::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan); + std::vector<std::string> get_sensor_names(size_t chan); + ::uhd::sensor_value_t get_mboard_sensor(const std::string &name, size_t mboard); + std::vector<std::string> get_mboard_sensor_names(size_t mboard); + std::string get_time_source(const size_t mboard); + std::vector<std::string> get_time_sources(const size_t mboard); + std::string get_clock_source(const size_t mboard); + std::vector<std::string> 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); + void set_auto_dc_offset(const bool enable, size_t chan); + void set_dc_offset(const std::complex<double> &offset, size_t chan); + void set_iq_balance(const std::complex<double> &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<std::complex<float> > finite_acquisition(const size_t nsamps); + std::vector<std::vector<std::complex<float> > > 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; + pmt::pmt_t _id; + + ::uhd::time_spec_t _start_time; + bool _start_time_set; + + //tag shadows + double _samp_rate; + double _center_freq; + }; + + } /* namespace uhd */ +} /* namespace gr */ diff --git a/gr-uhd/swig/uhd_swig.i b/gr-uhd/swig/uhd_swig.i index 99258c0f5e..8ab4d59f3e 100644 --- a/gr-uhd/swig/uhd_swig.i +++ b/gr-uhd/swig/uhd_swig.i @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2010-2012 Free Software Foundation, Inc. + * Copyright 2010-2013 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -41,9 +41,9 @@ // block headers //////////////////////////////////////////////////////////////////////// %{ -#include <gr_uhd_usrp_source.h> -#include <gr_uhd_usrp_sink.h> -#include <gr_uhd_amsg_source.h> +#include <uhd/usrp_source.h> +#include <uhd/usrp_sink.h> +#include <uhd/amsg_source.h> %} //////////////////////////////////////////////////////////////////////// @@ -99,14 +99,13 @@ //////////////////////////////////////////////////////////////////////// // block magic //////////////////////////////////////////////////////////////////////// -GR_SWIG_BLOCK_MAGIC(uhd,usrp_source) -%include <gr_uhd_usrp_source.h> +%include <uhd/usrp_source.h> +%include <uhd/usrp_sink.h> +%include <uhd/amsg_source.h> -GR_SWIG_BLOCK_MAGIC(uhd,usrp_sink) -%include <gr_uhd_usrp_sink.h> - -GR_SWIG_BLOCK_MAGIC(uhd,amsg_source) -%include <gr_uhd_amsg_source.h> +GR_SWIG_BLOCK_MAGIC2(uhd, usrp_source) +GR_SWIG_BLOCK_MAGIC2(uhd, usrp_sink) +GR_SWIG_BLOCK_MAGIC2(uhd, amsg_source) //////////////////////////////////////////////////////////////////////// // device discovery (no need to %include device.hpp) |