uhd: import gr-uhd code to be independent from gnuradio-runtime
stripped stream tags support due to lack of pmt
This commit is contained in:
parent
be1314af10
commit
3df0e00276
|
|
@ -168,7 +168,6 @@ set(GR_REQUIRED_COMPONENTS RUNTIME PMT BLOCKS)
|
|||
find_package(Gnuradio "3.7.0")
|
||||
find_package(GnuradioIQBalance)
|
||||
find_package(UHD)
|
||||
find_package(GnuradioUHD)
|
||||
find_package(GnuradioFCD)
|
||||
find_package(GnuradioFCDPP)
|
||||
find_package(LibOsmoSDR)
|
||||
|
|
|
|||
|
|
@ -247,7 +247,7 @@ endif(ENABLE_RTL_TCP)
|
|||
########################################################################
|
||||
# Setup UHD component
|
||||
########################################################################
|
||||
GR_REGISTER_COMPONENT("Ettus USRP Devices" ENABLE_UHD UHD_FOUND GNURADIO_UHD_FOUND)
|
||||
GR_REGISTER_COMPONENT("Ettus USRP Devices" ENABLE_UHD UHD_FOUND)
|
||||
if(ENABLE_UHD)
|
||||
GR_INCLUDE_SUBDIRECTORY(uhd)
|
||||
endif(ENABLE_UHD)
|
||||
|
|
|
|||
|
|
@ -23,11 +23,12 @@
|
|||
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${GNURADIO_UHD_INCLUDE_DIRS}
|
||||
${UHD_INCLUDE_DIRS}
|
||||
)
|
||||
|
||||
set(uhd_srcs
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/usrp_sink_impl.cc
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/usrp_source_impl.cc
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/uhd_sink_c.cc
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/uhd_source_c.cc
|
||||
)
|
||||
|
|
@ -36,4 +37,4 @@ set(uhd_srcs
|
|||
# Append gnuradio-osmosdr library sources
|
||||
########################################################################
|
||||
list(APPEND gr_osmosdr_srcs ${uhd_srcs})
|
||||
list(APPEND gr_osmosdr_libs ${GNURADIO_UHD_LIBRARIES} ${UHD_LIBRARIES})
|
||||
list(APPEND gr_osmosdr_libs ${UHD_LIBRARIES})
|
||||
|
|
|
|||
|
|
@ -0,0 +1,67 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* Copyright 2012-2013 Free Software Foundation, Inc.
|
||||
*
|
||||
* This file is part of GNU Radio
|
||||
*
|
||||
* GNU Radio is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU Radio is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNU Radio; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_GR_UHD_COMMON_H
|
||||
#define INCLUDED_GR_UHD_COMMON_H
|
||||
|
||||
#include <uhd/version.hpp>
|
||||
#include <boost/format.hpp>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace gr {
|
||||
namespace uhd {
|
||||
|
||||
static inline void check_abi(void)
|
||||
{
|
||||
#ifdef UHD_VERSION_ABI_STRING
|
||||
if(std::string(UHD_VERSION_ABI_STRING) == ::uhd::get_abi_string())
|
||||
return;
|
||||
|
||||
throw std::runtime_error(str(boost::format(
|
||||
"\nGR-UHD detected ABI compatibility mismatch with UHD library.\n"
|
||||
"GR-UHD was build against ABI: %s,\n"
|
||||
"but UHD library reports ABI: %s\n"
|
||||
"Suggestion: install an ABI compatible version of UHD,\n"
|
||||
"or rebuild GR-UHD component against this ABI version.\n"
|
||||
) % UHD_VERSION_ABI_STRING % ::uhd::get_abi_string()));
|
||||
#endif
|
||||
}
|
||||
|
||||
} /* namespace uhd */
|
||||
} /* namespace gr */
|
||||
|
||||
/*!
|
||||
* The stream args ensure function sanitizes random user input.
|
||||
* We may extend this to handle more things in the future,
|
||||
* but ATM it ensures that the channels are initialized.
|
||||
*/
|
||||
static inline uhd::stream_args_t stream_args_ensure(const uhd::stream_args_t &args)
|
||||
{
|
||||
uhd::stream_args_t sanitized = args;
|
||||
if (sanitized.channels.empty())
|
||||
{
|
||||
sanitized.channels.push_back(0);
|
||||
}
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
#endif /* INCLUDED_GR_UHD_COMMON_H */
|
||||
|
|
@ -21,7 +21,8 @@
|
|||
#define UHD_SINK_C_H
|
||||
|
||||
#include <gnuradio/hier_block2.h>
|
||||
#include <gnuradio/uhd/usrp_sink.h>
|
||||
|
||||
#include "usrp_sink.h"
|
||||
|
||||
#include "sink_iface.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,8 @@
|
|||
#define UHD_SOURCE_C_H
|
||||
|
||||
#include <gnuradio/hier_block2.h>
|
||||
#include <gnuradio/uhd/usrp_source.h>
|
||||
|
||||
#include "usrp_source.h"
|
||||
|
||||
#include "source_iface.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,529 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* Copyright 2010-2013 Free Software Foundation, Inc.
|
||||
*
|
||||
* This file is part of GNU Radio
|
||||
*
|
||||
* GNU Radio is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU Radio is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNU Radio; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_GR_UHD_USRP_SINK_H
|
||||
#define INCLUDED_GR_UHD_USRP_SINK_H
|
||||
|
||||
#include <gnuradio/sync_block.h>
|
||||
#include <uhd/usrp/multi_usrp.hpp>
|
||||
|
||||
#ifndef INCLUDED_UHD_STREAM_HPP
|
||||
namespace uhd {
|
||||
struct stream_args_t
|
||||
{
|
||||
stream_args_t(const std::string &cpu = "",
|
||||
const std::string &otw = "")
|
||||
{
|
||||
cpu_format = cpu;
|
||||
otw_format = otw;
|
||||
}
|
||||
std::string cpu_format;
|
||||
std::string otw_format;
|
||||
device_addr_t args;
|
||||
std::vector<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 usrp_sink : virtual public 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;
|
||||
|
||||
/*!
|
||||
* Get the bandpass filter setting on the RF frontend.
|
||||
* \param chan the channel index 0 to N-1
|
||||
* \return bandwidth of the filter in Hz
|
||||
*/
|
||||
virtual double get_bandwidth(size_t chan = 0) = 0;
|
||||
|
||||
/*!
|
||||
* Get the bandpass filter range of the RF frontend.
|
||||
* \param chan the channel index 0 to N-1
|
||||
* \return the range of the filter bandwidth in Hz
|
||||
*/
|
||||
virtual ::uhd::freq_range_t get_bandwidth_range(size_t chan = 0) = 0;
|
||||
|
||||
/*!
|
||||
* Set a constant DC offset value.
|
||||
* The value is complex to control both I and Q.
|
||||
* \param offset the dc offset (1.0 is full-scale)
|
||||
* \param chan the channel index 0 to N-1
|
||||
*/
|
||||
virtual void set_dc_offset(const std::complex<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 */
|
||||
|
|
@ -0,0 +1,636 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* Copyright 2010-2013 Free Software Foundation, Inc.
|
||||
*
|
||||
* This file is part of GNU Radio
|
||||
*
|
||||
* GNU Radio is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU Radio is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNU Radio; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include "usrp_sink_impl.h"
|
||||
#include "gr_uhd_common.h"
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include <boost/make_shared.hpp>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace gr {
|
||||
namespace uhd {
|
||||
|
||||
usrp_sink::sptr
|
||||
usrp_sink::make(const ::uhd::device_addr_t &device_addr,
|
||||
const ::uhd::io_type_t &io_type,
|
||||
size_t num_channels)
|
||||
{
|
||||
//fill in the streamer args
|
||||
::uhd::stream_args_t stream_args;
|
||||
switch(io_type.tid) {
|
||||
case ::uhd::io_type_t::COMPLEX_FLOAT32: stream_args.cpu_format = "fc32"; break;
|
||||
case ::uhd::io_type_t::COMPLEX_INT16: stream_args.cpu_format = "sc16"; break;
|
||||
default: throw std::runtime_error("only complex float and shorts known to work");
|
||||
}
|
||||
|
||||
stream_args.otw_format = "sc16"; //only sc16 known to work
|
||||
for(size_t chan = 0; chan < num_channels; chan++)
|
||||
stream_args.channels.push_back(chan); //linear mapping
|
||||
|
||||
return usrp_sink::make(device_addr, stream_args);
|
||||
}
|
||||
|
||||
usrp_sink::sptr
|
||||
usrp_sink::make(const ::uhd::device_addr_t &device_addr,
|
||||
const ::uhd::stream_args_t &stream_args)
|
||||
{
|
||||
check_abi();
|
||||
return usrp_sink::sptr
|
||||
(new usrp_sink_impl(device_addr, stream_args_ensure(stream_args)));
|
||||
}
|
||||
|
||||
usrp_sink_impl::usrp_sink_impl(const ::uhd::device_addr_t &device_addr,
|
||||
const ::uhd::stream_args_t &stream_args)
|
||||
: sync_block("gr uhd usrp sink",
|
||||
args_to_io_sig(stream_args),
|
||||
io_signature::make(0, 0, 0)),
|
||||
_stream_args(stream_args),
|
||||
_nchan(stream_args.channels.size()),
|
||||
_stream_now(_nchan == 1),
|
||||
_start_time_set(false)
|
||||
{
|
||||
if(stream_args.cpu_format == "fc32")
|
||||
_type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_FLOAT32);
|
||||
if(stream_args.cpu_format == "sc16")
|
||||
_type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_INT16);
|
||||
_dev = ::uhd::usrp::multi_usrp::make(device_addr);
|
||||
}
|
||||
|
||||
usrp_sink_impl::~usrp_sink_impl()
|
||||
{
|
||||
}
|
||||
|
||||
::uhd::dict<std::string, std::string>
|
||||
usrp_sink_impl::get_usrp_info(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
#ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API
|
||||
return _dev->get_usrp_tx_info(chan);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_subdev_spec(const std::string &spec,
|
||||
size_t mboard)
|
||||
{
|
||||
return _dev->set_tx_subdev_spec(spec, mboard);
|
||||
}
|
||||
|
||||
std::string
|
||||
usrp_sink_impl::get_subdev_spec(size_t mboard)
|
||||
{
|
||||
return _dev->get_tx_subdev_spec(mboard).to_string();
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_samp_rate(double rate)
|
||||
{
|
||||
BOOST_FOREACH(const size_t chan, _stream_args.channels)
|
||||
{
|
||||
_dev->set_tx_rate(rate, chan);
|
||||
}
|
||||
_sample_rate = this->get_samp_rate();
|
||||
}
|
||||
|
||||
double
|
||||
usrp_sink_impl::get_samp_rate(void)
|
||||
{
|
||||
return _dev->get_tx_rate(_stream_args.channels[0]);
|
||||
}
|
||||
|
||||
::uhd::meta_range_t
|
||||
usrp_sink_impl::get_samp_rates(void)
|
||||
{
|
||||
#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API
|
||||
return _dev->get_tx_rates(_stream_args.channels[0]);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
::uhd::tune_result_t
|
||||
usrp_sink_impl::set_center_freq(const ::uhd::tune_request_t tune_request,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_tx_freq(tune_request, chan);
|
||||
}
|
||||
|
||||
double
|
||||
usrp_sink_impl::get_center_freq(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_freq(chan);
|
||||
}
|
||||
|
||||
::uhd::freq_range_t
|
||||
usrp_sink_impl::get_freq_range(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_freq_range(chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_gain(double gain, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_tx_gain(gain, chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_gain(double gain,
|
||||
const std::string &name,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_tx_gain(gain, name, chan);
|
||||
}
|
||||
|
||||
double
|
||||
usrp_sink_impl::get_gain(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_gain(chan);
|
||||
}
|
||||
|
||||
double
|
||||
usrp_sink_impl::get_gain(const std::string &name, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_gain(name, chan);
|
||||
}
|
||||
|
||||
std::vector<std::string>
|
||||
usrp_sink_impl::get_gain_names(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_gain_names(chan);
|
||||
}
|
||||
|
||||
::uhd::gain_range_t
|
||||
usrp_sink_impl::get_gain_range(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_gain_range(chan);
|
||||
}
|
||||
|
||||
::uhd::gain_range_t
|
||||
usrp_sink_impl::get_gain_range(const std::string &name,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_gain_range(name, chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_antenna(const std::string &ant,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_tx_antenna(ant, chan);
|
||||
}
|
||||
|
||||
std::string
|
||||
usrp_sink_impl::get_antenna(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_antenna(chan);
|
||||
}
|
||||
|
||||
std::vector<std::string>
|
||||
usrp_sink_impl::get_antennas(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_antennas(chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_bandwidth(double bandwidth, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_tx_bandwidth(bandwidth, chan);
|
||||
}
|
||||
|
||||
double
|
||||
usrp_sink_impl::get_bandwidth(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_bandwidth(chan);
|
||||
}
|
||||
|
||||
::uhd::freq_range_t
|
||||
usrp_sink_impl::get_bandwidth_range(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_bandwidth_range(chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_dc_offset(const std::complex<double> &offset,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
|
||||
return _dev->set_tx_dc_offset(offset, chan);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_iq_balance(const std::complex<double> &correction,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
|
||||
return _dev->set_tx_iq_balance(correction, chan);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
::uhd::sensor_value_t
|
||||
usrp_sink_impl::get_sensor(const std::string &name, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_sensor(name, chan);
|
||||
}
|
||||
|
||||
std::vector<std::string>
|
||||
usrp_sink_impl::get_sensor_names(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_sensor_names(chan);
|
||||
}
|
||||
|
||||
::uhd::sensor_value_t
|
||||
usrp_sink_impl::get_mboard_sensor(const std::string &name,
|
||||
size_t mboard)
|
||||
{
|
||||
return _dev->get_mboard_sensor(name, mboard);
|
||||
}
|
||||
|
||||
std::vector<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)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_tx_dboard_iface(chan);
|
||||
}
|
||||
|
||||
::uhd::usrp::multi_usrp::sptr
|
||||
usrp_sink_impl::get_device(void)
|
||||
{
|
||||
return _dev;
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_user_register(const uint8_t addr,
|
||||
const uint32_t data,
|
||||
size_t mboard)
|
||||
{
|
||||
#ifdef UHD_USRP_MULTI_USRP_USER_REGS_API
|
||||
_dev->set_user_register(addr, data, mboard);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Work
|
||||
**********************************************************************/
|
||||
int
|
||||
usrp_sink_impl::work(int noutput_items,
|
||||
gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items)
|
||||
{
|
||||
int ninput_items = noutput_items; //cuz its a sync block
|
||||
|
||||
//send a mid-burst packet with time spec
|
||||
_metadata.start_of_burst = false;
|
||||
_metadata.end_of_burst = false;
|
||||
#if 0
|
||||
//collect tags in this work()
|
||||
const uint64_t samp0_count = nitems_read(0);
|
||||
get_tags_in_range(_tags, 0, samp0_count, samp0_count + ninput_items);
|
||||
if(not _tags.empty())
|
||||
this->tag_work(ninput_items);
|
||||
#endif
|
||||
#ifdef GR_UHD_USE_STREAM_API
|
||||
//send all ninput_items with metadata
|
||||
const size_t num_sent = _tx_stream->send
|
||||
(input_items, ninput_items, _metadata, 1.0);
|
||||
#else
|
||||
const size_t num_sent = _dev->get_device()->send
|
||||
(input_items, ninput_items, _metadata,
|
||||
*_type, ::uhd::device::SEND_MODE_FULL_BUFF, 1.0);
|
||||
#endif
|
||||
|
||||
//increment the timespec by the number of samples sent
|
||||
_metadata.time_spec += ::uhd::time_spec_t(0, num_sent, _sample_rate);
|
||||
return num_sent;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Tag Work
|
||||
**********************************************************************/
|
||||
void
|
||||
usrp_sink_impl::tag_work(int &ninput_items)
|
||||
{
|
||||
#if 0
|
||||
//the for loop below assumes tags sorted by count low -> high
|
||||
std::sort(_tags.begin(), _tags.end(), tag_t::offset_compare);
|
||||
|
||||
//extract absolute sample counts
|
||||
const tag_t &tag0 = _tags.front();
|
||||
const uint64_t tag0_count = tag0.offset;
|
||||
const uint64_t samp0_count = this->nitems_read(0);
|
||||
|
||||
//only transmit nsamples from 0 to the first tag
|
||||
//this ensures that the next work starts on a tag
|
||||
if(samp0_count != tag0_count) {
|
||||
ninput_items = tag0_count - samp0_count;
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
//time will not be set unless a time tag is found
|
||||
_metadata.has_time_spec = false;
|
||||
#if 0
|
||||
//process all of the tags found with the same count as tag0
|
||||
BOOST_FOREACH(const tag_t &my_tag, _tags) {
|
||||
const uint64_t my_tag_count = my_tag.offset;
|
||||
const pmt::pmt_t &key = my_tag.key;
|
||||
const pmt::pmt_t &value = my_tag.value;
|
||||
|
||||
//determine how many samples to send...
|
||||
//from zero until the next tag or end of work
|
||||
if(my_tag_count != tag0_count) {
|
||||
ninput_items = my_tag_count - samp0_count;
|
||||
break;
|
||||
}
|
||||
|
||||
//handle end of burst with a mini end of burst packet
|
||||
else if(pmt::equal(key, EOB_KEY)) {
|
||||
_metadata.end_of_burst = pmt::to_bool(value);
|
||||
ninput_items = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
//set the start of burst flag in the metadata
|
||||
else if(pmt::equal(key, SOB_KEY)) {
|
||||
_metadata.start_of_burst = pmt::to_bool(value);
|
||||
}
|
||||
|
||||
//set the time specification in the metadata
|
||||
else if(pmt::equal(key, TIME_KEY)) {
|
||||
_metadata.has_time_spec = true;
|
||||
_metadata.time_spec = ::uhd::time_spec_t
|
||||
(pmt::to_uint64(pmt::tuple_ref(value, 0)),
|
||||
pmt::to_double(pmt::tuple_ref(value, 1)));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::set_start_time(const ::uhd::time_spec_t &time)
|
||||
{
|
||||
_start_time = time;
|
||||
_start_time_set = true;
|
||||
_stream_now = false;
|
||||
}
|
||||
|
||||
//Send an empty start-of-burst packet to begin streaming.
|
||||
//Set at a time in the near future to avoid late packets.
|
||||
bool
|
||||
usrp_sink_impl::start(void)
|
||||
{
|
||||
#ifdef GR_UHD_USE_STREAM_API
|
||||
_tx_stream = _dev->get_tx_stream(_stream_args);
|
||||
#endif
|
||||
|
||||
_metadata.start_of_burst = true;
|
||||
_metadata.end_of_burst = false;
|
||||
_metadata.has_time_spec = not _stream_now;
|
||||
if(_start_time_set) {
|
||||
_start_time_set = false; //cleared for next run
|
||||
_metadata.time_spec = _start_time;
|
||||
}
|
||||
else {
|
||||
_metadata.time_spec = get_time_now() + ::uhd::time_spec_t(0.01);
|
||||
}
|
||||
|
||||
#ifdef GR_UHD_USE_STREAM_API
|
||||
_tx_stream->send
|
||||
(gr_vector_const_void_star(_nchan), 0, _metadata, 1.0);
|
||||
#else
|
||||
_dev->get_device()->send
|
||||
(gr_vector_const_void_star(_nchan), 0, _metadata,
|
||||
*_type, ::uhd::device::SEND_MODE_ONE_PACKET, 1.0);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
//Send an empty end-of-burst packet to end streaming.
|
||||
//Ending the burst avoids an underflow error on stop.
|
||||
bool
|
||||
usrp_sink_impl::stop(void)
|
||||
{
|
||||
_metadata.start_of_burst = false;
|
||||
_metadata.end_of_burst = true;
|
||||
_metadata.has_time_spec = false;
|
||||
|
||||
#ifdef GR_UHD_USE_STREAM_API
|
||||
_tx_stream->send(gr_vector_const_void_star(_nchan), 0, _metadata, 1.0);
|
||||
#else
|
||||
_dev->get_device()->send
|
||||
(gr_vector_const_void_star(_nchan), 0, _metadata,
|
||||
*_type, ::uhd::device::SEND_MODE_ONE_PACKET, 1.0);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
usrp_sink_impl::setup_rpc()
|
||||
{
|
||||
#ifdef GR_CTRLPORT
|
||||
add_rpc_variable(
|
||||
rpcbasic_sptr(new rpcbasic_register_get<usrp_sink, double>(
|
||||
alias(), "samp_rate",
|
||||
&usrp_sink::get_samp_rate,
|
||||
pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f),
|
||||
"sps", "TX Sample Rate", RPC_PRIVLVL_MIN,
|
||||
DISPTIME | DISPOPTSTRIP)));
|
||||
|
||||
add_rpc_variable(
|
||||
rpcbasic_sptr(new rpcbasic_register_set<usrp_sink, double>(
|
||||
alias(), "samp_rate",
|
||||
&usrp_sink::set_samp_rate,
|
||||
pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f),
|
||||
"sps", "TX Sample Rate",
|
||||
RPC_PRIVLVL_MIN, DISPNULL)));
|
||||
#endif /* GR_CTRLPORT */
|
||||
}
|
||||
|
||||
} /* namespace uhd */
|
||||
} /* namespace gr */
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* Copyright 2010-2013 Free Software Foundation, Inc.
|
||||
*
|
||||
* This file is part of GNU Radio
|
||||
*
|
||||
* GNU Radio is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU Radio is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNU Radio; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include "usrp_sink.h"
|
||||
#include <uhd/convert.hpp>
|
||||
#if 0
|
||||
static const pmt::pmt_t SOB_KEY = pmt::string_to_symbol("tx_sob");
|
||||
static const pmt::pmt_t EOB_KEY = pmt::string_to_symbol("tx_eob");
|
||||
static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("tx_time");
|
||||
#endif
|
||||
namespace gr {
|
||||
namespace uhd {
|
||||
|
||||
inline io_signature::sptr
|
||||
args_to_io_sig(const ::uhd::stream_args_t &args)
|
||||
{
|
||||
const size_t nchan = std::max<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 io_signature::make(nchan, nchan, size);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* UHD Multi USRP Sink Impl
|
||||
**********************************************************************/
|
||||
class usrp_sink_impl : public usrp_sink
|
||||
{
|
||||
public:
|
||||
usrp_sink_impl(const ::uhd::device_addr_t &device_addr,
|
||||
const ::uhd::stream_args_t &stream_args);
|
||||
~usrp_sink_impl();
|
||||
|
||||
void setup_rpc();
|
||||
|
||||
::uhd::dict<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);
|
||||
double get_bandwidth(size_t chan);
|
||||
::uhd::freq_range_t get_bandwidth_range(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;
|
||||
#if 0
|
||||
//stream tags related stuff
|
||||
std::vector<tag_t> _tags;
|
||||
#endif
|
||||
};
|
||||
|
||||
} /* namespace uhd */
|
||||
} /* namespace gr */
|
||||
|
|
@ -0,0 +1,580 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* Copyright 2010-2013 Free Software Foundation, Inc.
|
||||
*
|
||||
* This file is part of GNU Radio
|
||||
*
|
||||
* GNU Radio is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU Radio is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNU Radio; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_GR_UHD_USRP_SOURCE_H
|
||||
#define INCLUDED_GR_UHD_USRP_SOURCE_H
|
||||
|
||||
#include <gnuradio/sync_block.h>
|
||||
#include <uhd/usrp/multi_usrp.hpp>
|
||||
|
||||
#ifndef INCLUDED_UHD_STREAM_HPP
|
||||
namespace uhd {
|
||||
struct stream_args_t
|
||||
{
|
||||
stream_args_t(const std::string &cpu = "",
|
||||
const std::string &otw = "")
|
||||
{
|
||||
cpu_format = cpu;
|
||||
otw_format = otw;
|
||||
}
|
||||
std::string cpu_format;
|
||||
std::string otw_format;
|
||||
device_addr_t args;
|
||||
std::vector<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 usrp_source : virtual public 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;
|
||||
|
||||
/*!
|
||||
* Get the bandpass filter setting on the RF frontend.
|
||||
* \param chan the channel index 0 to N-1
|
||||
* \return bandwidth of the filter in Hz
|
||||
*/
|
||||
virtual double get_bandwidth(size_t chan = 0) = 0;
|
||||
|
||||
/*!
|
||||
* Get the bandpass filter range of the RF frontend.
|
||||
* \param chan the channel index 0 to N-1
|
||||
* \return the range of the filter bandwidth in Hz
|
||||
*/
|
||||
virtual ::uhd::freq_range_t get_bandwidth_range(size_t chan = 0) = 0;
|
||||
|
||||
/*!
|
||||
* Enable/disable the automatic DC offset correction.
|
||||
* The automatic correction subtracts out the long-run average.
|
||||
*
|
||||
* When disabled, the averaging option operation is halted.
|
||||
* Once halted, the average value will be held constant until
|
||||
* the user re-enables the automatic correction or overrides the
|
||||
* value by manually setting the offset.
|
||||
*
|
||||
* \param enb true to enable automatic DC offset correction
|
||||
* \param chan the channel index 0 to N-1
|
||||
*/
|
||||
virtual void set_auto_dc_offset(const bool enb, size_t chan = 0) = 0;
|
||||
|
||||
/*!
|
||||
* Set a constant DC offset value.
|
||||
* The value is complex to control both I and Q.
|
||||
* Only set this when automatic correction is disabled.
|
||||
* \param offset the dc offset (1.0 is full-scale)
|
||||
* \param chan the channel index 0 to N-1
|
||||
*/
|
||||
virtual void set_dc_offset(const std::complex<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 */
|
||||
|
|
@ -0,0 +1,696 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* Copyright 2010-2013 Free Software Foundation, Inc.
|
||||
*
|
||||
* This file is part of GNU Radio
|
||||
*
|
||||
* GNU Radio is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU Radio is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNU Radio; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include "usrp_source_impl.h"
|
||||
#include "gr_uhd_common.h"
|
||||
#include <gnuradio/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_ensure(stream_args)));
|
||||
}
|
||||
|
||||
usrp_source_impl::usrp_source_impl(const ::uhd::device_addr_t &device_addr,
|
||||
const ::uhd::stream_args_t &stream_args):
|
||||
sync_block("gr uhd usrp source",
|
||||
io_signature::make(0, 0, 0),
|
||||
args_to_io_sig(stream_args)),
|
||||
_stream_args(stream_args),
|
||||
_nchan(stream_args.channels.size()),
|
||||
_stream_now(_nchan == 1),
|
||||
_tag_now(false),
|
||||
_start_time_set(false)
|
||||
{
|
||||
if(stream_args.cpu_format == "fc32")
|
||||
_type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_FLOAT32);
|
||||
if(stream_args.cpu_format == "sc16")
|
||||
_type = boost::make_shared< ::uhd::io_type_t >(::uhd::io_type_t::COMPLEX_INT16);
|
||||
std::stringstream str;
|
||||
str << name() << unique_id();
|
||||
#if 0
|
||||
_id = pmt::string_to_symbol(str.str());
|
||||
#endif
|
||||
_dev = ::uhd::usrp::multi_usrp::make(device_addr);
|
||||
}
|
||||
|
||||
usrp_source_impl::~usrp_source_impl()
|
||||
{
|
||||
}
|
||||
|
||||
::uhd::dict<std::string, std::string>
|
||||
usrp_source_impl::get_usrp_info(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
#ifdef UHD_USRP_MULTI_USRP_GET_USRP_INFO_API
|
||||
return _dev->get_usrp_rx_info(chan);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_subdev_spec(const std::string &spec, size_t mboard)
|
||||
{
|
||||
return _dev->set_rx_subdev_spec(spec, mboard);
|
||||
}
|
||||
|
||||
std::string
|
||||
usrp_source_impl::get_subdev_spec(size_t mboard)
|
||||
{
|
||||
return _dev->get_rx_subdev_spec(mboard).to_string();
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_samp_rate(double rate)
|
||||
{
|
||||
BOOST_FOREACH(const size_t chan, _stream_args.channels)
|
||||
{
|
||||
_dev->set_rx_rate(rate, chan);
|
||||
}
|
||||
_samp_rate = this->get_samp_rate();
|
||||
_tag_now = true;
|
||||
}
|
||||
|
||||
double
|
||||
usrp_source_impl::get_samp_rate(void)
|
||||
{
|
||||
return _dev->get_rx_rate(_stream_args.channels[0]);
|
||||
}
|
||||
|
||||
::uhd::meta_range_t
|
||||
usrp_source_impl::get_samp_rates(void)
|
||||
{
|
||||
#ifdef UHD_USRP_MULTI_USRP_GET_RATES_API
|
||||
return _dev->get_rx_rates(_stream_args.channels[0]);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
::uhd::tune_result_t
|
||||
usrp_source_impl::set_center_freq(const ::uhd::tune_request_t tune_request,
|
||||
size_t chan)
|
||||
{
|
||||
const size_t user_chan = chan;
|
||||
chan = _stream_args.channels[chan];
|
||||
const ::uhd::tune_result_t res = _dev->set_rx_freq(tune_request, chan);
|
||||
_center_freq = this->get_center_freq(user_chan);
|
||||
_tag_now = true;
|
||||
return res;
|
||||
}
|
||||
|
||||
double
|
||||
usrp_source_impl::get_center_freq(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_freq(chan);
|
||||
}
|
||||
|
||||
::uhd::freq_range_t
|
||||
usrp_source_impl::get_freq_range(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_freq_range(chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_gain(double gain, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_rx_gain(gain, chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_gain(double gain, const std::string &name, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_rx_gain(gain, name, chan);
|
||||
}
|
||||
|
||||
double
|
||||
usrp_source_impl::get_gain(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_gain(chan);
|
||||
}
|
||||
|
||||
double
|
||||
usrp_source_impl::get_gain(const std::string &name, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_gain(name, chan);
|
||||
}
|
||||
|
||||
std::vector<std::string>
|
||||
usrp_source_impl::get_gain_names(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_gain_names(chan);
|
||||
}
|
||||
|
||||
::uhd::gain_range_t
|
||||
usrp_source_impl::get_gain_range(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_gain_range(chan);
|
||||
}
|
||||
|
||||
::uhd::gain_range_t
|
||||
usrp_source_impl::get_gain_range(const std::string &name, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_gain_range(name, chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_antenna(const std::string &ant, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_rx_antenna(ant, chan);
|
||||
}
|
||||
|
||||
std::string
|
||||
usrp_source_impl::get_antenna(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_antenna(chan);
|
||||
}
|
||||
|
||||
std::vector<std::string>
|
||||
usrp_source_impl::get_antennas(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_antennas(chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_bandwidth(double bandwidth, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->set_rx_bandwidth(bandwidth, chan);
|
||||
}
|
||||
|
||||
double
|
||||
usrp_source_impl::get_bandwidth(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_bandwidth(chan);
|
||||
}
|
||||
|
||||
::uhd::freq_range_t
|
||||
usrp_source_impl::get_bandwidth_range(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_bandwidth_range(chan);
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_auto_dc_offset(const bool enable, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
|
||||
return _dev->set_rx_dc_offset(enable, chan);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_dc_offset(const std::complex<double> &offset,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
|
||||
return _dev->set_rx_dc_offset(offset, chan);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_iq_balance(const std::complex<double> &correction,
|
||||
size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
#ifdef UHD_USRP_MULTI_USRP_FRONTEND_CAL_API
|
||||
return _dev->set_rx_iq_balance(correction, chan);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
::uhd::sensor_value_t
|
||||
usrp_source_impl::get_sensor(const std::string &name, size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_sensor(name, chan);
|
||||
}
|
||||
|
||||
std::vector<std::string>
|
||||
usrp_source_impl::get_sensor_names(size_t chan)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_sensor_names(chan);
|
||||
}
|
||||
|
||||
::uhd::sensor_value_t
|
||||
usrp_source_impl::get_mboard_sensor(const std::string &name, size_t mboard)
|
||||
{
|
||||
return _dev->get_mboard_sensor(name, mboard);
|
||||
}
|
||||
|
||||
std::vector<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)
|
||||
{
|
||||
chan = _stream_args.channels[chan];
|
||||
return _dev->get_rx_dboard_iface(chan);
|
||||
}
|
||||
|
||||
::uhd::usrp::multi_usrp::sptr
|
||||
usrp_source_impl::get_device(void)
|
||||
{
|
||||
return _dev;
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_user_register(const uint8_t addr,
|
||||
const uint32_t data,
|
||||
size_t mboard)
|
||||
{
|
||||
#ifdef UHD_USRP_MULTI_USRP_USER_REGS_API
|
||||
_dev->set_user_register(addr, data, mboard);
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::set_start_time(const ::uhd::time_spec_t &time)
|
||||
{
|
||||
_start_time = time;
|
||||
_start_time_set = true;
|
||||
_stream_now = false;
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::issue_stream_cmd(const ::uhd::stream_cmd_t &cmd)
|
||||
{
|
||||
for (size_t i = 0; i < _stream_args.channels.size(); i++)
|
||||
{
|
||||
_dev->issue_stream_cmd(cmd, _stream_args.channels[i]);
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
usrp_source_impl::start(void)
|
||||
{
|
||||
#ifdef GR_UHD_USE_STREAM_API
|
||||
_rx_stream = _dev->get_rx_stream(_stream_args);
|
||||
_samps_per_packet = _rx_stream->get_max_num_samps();
|
||||
#endif
|
||||
//setup a stream command that starts streaming slightly in the future
|
||||
static const double reasonable_delay = 0.1; //order of magnitude over RTT
|
||||
::uhd::stream_cmd_t stream_cmd(::uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
|
||||
stream_cmd.stream_now = _stream_now;
|
||||
if(_start_time_set) {
|
||||
_start_time_set = false; //cleared for next run
|
||||
stream_cmd.time_spec = _start_time;
|
||||
}
|
||||
else {
|
||||
stream_cmd.time_spec = get_time_now() + ::uhd::time_spec_t(reasonable_delay);
|
||||
}
|
||||
this->issue_stream_cmd(stream_cmd);
|
||||
_tag_now = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::flush(void)
|
||||
{
|
||||
const size_t nbytes = 4096;
|
||||
gr_vector_void_star outputs;
|
||||
std::vector<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)
|
||||
{
|
||||
this->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);
|
||||
this->issue_stream_cmd(cmd);
|
||||
|
||||
//receive samples until timeout
|
||||
const size_t actual_num_samps = _rx_stream->recv
|
||||
(buffs, nsamps, _metadata, 1.0);
|
||||
|
||||
//resize the resulting sample buffers
|
||||
for(size_t i = 0; i < _nchan; i++) {
|
||||
samps[i].resize(actual_num_samps);
|
||||
}
|
||||
|
||||
return samps;
|
||||
#else
|
||||
throw std::runtime_error("not implemented in this version");
|
||||
#endif
|
||||
}
|
||||
|
||||
int
|
||||
usrp_source_impl::work(int noutput_items,
|
||||
gr_vector_const_void_star &input_items,
|
||||
gr_vector_void_star &output_items)
|
||||
{
|
||||
#ifdef GR_UHD_USE_STREAM_API
|
||||
//In order to allow for low-latency:
|
||||
//We receive all available packets without timeout.
|
||||
//This call can timeout under regular operation...
|
||||
size_t num_samps = _rx_stream->recv
|
||||
(output_items, noutput_items, _metadata, 0.0);
|
||||
|
||||
//If receive resulted in a timeout condition:
|
||||
//We now receive a single packet with a large timeout.
|
||||
if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) {
|
||||
num_samps = _rx_stream->recv
|
||||
(output_items, noutput_items, _metadata, 0.1, true/*one pkt*/);
|
||||
}
|
||||
#else
|
||||
size_t num_samps = _dev->get_device()->recv
|
||||
(output_items, noutput_items, _metadata,
|
||||
*_type, ::uhd::device::RECV_MODE_FULL_BUFF, 0.0);
|
||||
|
||||
if(_metadata.error_code == ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) {
|
||||
num_samps = _dev->get_device()->recv
|
||||
(output_items, noutput_items, _metadata, *_type,
|
||||
::uhd::device::RECV_MODE_ONE_PACKET, 1.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
//handle possible errors conditions
|
||||
switch(_metadata.error_code) {
|
||||
case ::uhd::rx_metadata_t::ERROR_CODE_NONE:
|
||||
if(_tag_now) {
|
||||
_tag_now = false;
|
||||
#if 0
|
||||
//create a timestamp pmt for the first sample
|
||||
const pmt::pmt_t val = pmt::make_tuple
|
||||
(pmt::from_uint64(_metadata.time_spec.get_full_secs()),
|
||||
pmt::from_double(_metadata.time_spec.get_frac_secs()));
|
||||
//create a tag set for each channel
|
||||
for(size_t i = 0; i < _nchan; i++) {
|
||||
this->add_item_tag(i, nitems_written(0), TIME_KEY, val, _id);
|
||||
this->add_item_tag(i, nitems_written(0), RATE_KEY,
|
||||
pmt::from_double(_samp_rate), _id);
|
||||
this->add_item_tag(i, nitems_written(0), FREQ_KEY,
|
||||
pmt::from_double(_center_freq), _id);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
|
||||
case ::uhd::rx_metadata_t::ERROR_CODE_TIMEOUT:
|
||||
//its ok to timeout, perhaps the user is doing finite streaming
|
||||
return 0;
|
||||
|
||||
case ::uhd::rx_metadata_t::ERROR_CODE_OVERFLOW:
|
||||
_tag_now = true;
|
||||
//ignore overflows and try work again
|
||||
return work(noutput_items, input_items, output_items);
|
||||
|
||||
default:
|
||||
std::cout << boost::format("UHD source block got error code 0x%x")
|
||||
% _metadata.error_code << std::endl;
|
||||
return num_samps;
|
||||
}
|
||||
|
||||
return num_samps;
|
||||
}
|
||||
|
||||
void
|
||||
usrp_source_impl::setup_rpc()
|
||||
{
|
||||
#ifdef GR_CTRLPORT
|
||||
add_rpc_variable(
|
||||
rpcbasic_sptr(new rpcbasic_register_get<usrp_source, double>(
|
||||
alias(), "samp_rate",
|
||||
&usrp_source::get_samp_rate,
|
||||
pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f),
|
||||
"sps", "RX Sample Rate", RPC_PRIVLVL_MIN,
|
||||
DISPTIME | DISPOPTSTRIP)));
|
||||
|
||||
add_rpc_variable(
|
||||
rpcbasic_sptr(new rpcbasic_register_set<usrp_source, double>(
|
||||
alias(), "samp_rate",
|
||||
&usrp_source::set_samp_rate,
|
||||
pmt::mp(100000.0f), pmt::mp(25000000.0f), pmt::mp(1000000.0f),
|
||||
"sps", "RX Sample Rate",
|
||||
RPC_PRIVLVL_MIN, DISPNULL)));
|
||||
#endif /* GR_CTRLPORT */
|
||||
}
|
||||
|
||||
} /* namespace uhd */
|
||||
} /* namespace gr */
|
||||
|
|
@ -0,0 +1,149 @@
|
|||
/* -*- c++ -*- */
|
||||
/*
|
||||
* Copyright 2010-2013 Free Software Foundation, Inc.
|
||||
*
|
||||
* This file is part of GNU Radio
|
||||
*
|
||||
* GNU Radio is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 3, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU Radio is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNU Radio; see the file COPYING. If not, write to
|
||||
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include "usrp_source.h"
|
||||
#include <uhd/convert.hpp>
|
||||
#if 0
|
||||
static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("rx_time");
|
||||
static const pmt::pmt_t RATE_KEY = pmt::string_to_symbol("rx_rate");
|
||||
static const pmt::pmt_t FREQ_KEY = pmt::string_to_symbol("rx_freq");
|
||||
#endif
|
||||
namespace gr {
|
||||
namespace uhd {
|
||||
|
||||
inline io_signature::sptr
|
||||
args_to_io_sig(const ::uhd::stream_args_t &args)
|
||||
{
|
||||
const size_t nchan = std::max<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 io_signature::make(nchan, nchan, size);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* UHD Multi USRP Source Impl
|
||||
**********************************************************************/
|
||||
class usrp_source_impl : public usrp_source
|
||||
{
|
||||
public:
|
||||
usrp_source_impl(const ::uhd::device_addr_t &device_addr,
|
||||
const ::uhd::stream_args_t &stream_args);
|
||||
~usrp_source_impl();
|
||||
|
||||
void setup_rpc();
|
||||
|
||||
// Get Commands
|
||||
::uhd::dict<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);
|
||||
double get_bandwidth(size_t chan);
|
||||
::uhd::freq_range_t get_bandwidth_range(size_t chan);
|
||||
void set_auto_dc_offset(const bool enable, size_t chan);
|
||||
void set_dc_offset(const std::complex<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;
|
||||
#if 0
|
||||
pmt::pmt_t _id;
|
||||
#endif
|
||||
::uhd::time_spec_t _start_time;
|
||||
bool _start_time_set;
|
||||
|
||||
//tag shadows
|
||||
double _samp_rate;
|
||||
double _center_freq;
|
||||
};
|
||||
|
||||
} /* namespace uhd */
|
||||
} /* namespace gr */
|
||||
Loading…
Reference in New Issue