Loading...
Searching...
No Matches
uhd::rfnoc::radio_control Class Referenceabstract
RFNoC » RFNoC Blocks

`#include <uhd/rfnoc/radio_control.hpp>`

Inheritance diagram for uhd::rfnoc::radio_control:
[legend]
Collaboration diagram for uhd::rfnoc::radio_control:
[legend]

## Public Member Functions

virtual double | set_rate (const double rate)=0
| Set the sample rate.
virtual double | get_rate () const =0
| Get the sample rate.
virtual uhd::meta_range_t | get_rate_range () const =0
| Return a list of valid rates.
virtual size_t | get_spc () const =0
| Return the samples per clock (SPC) value of this radio.
virtual uint64_t | get_ticks_now ()=0
virtual uhd::time_spec_t | get_time_now ()=0
virtual std::vector< std::string > | get_tx_gain_profile_names (const size_t chan) const =0
virtual std::vector< std::string > | get_rx_gain_profile_names (const size_t chan) const =0
virtual void | set_tx_gain_profile (const std::string &profile, const size_t chan)=0
virtual void | set_rx_gain_profile (const std::string &profile, const size_t chan)=0
virtual std::string | get_tx_gain_profile (const size_t chan) const =0
virtual std::string | get_rx_gain_profile (const size_t chan) const =0
virtual void | set_tx_dc_offset (const std::complex< double > &offset, size_t chan)=0
virtual meta_range_t | get_tx_dc_offset_range (size_t chan) const =0
virtual void | set_tx_iq_balance (const std::complex< double > &correction, size_t chan)=0
virtual void | set_rx_dc_offset (const bool enb, size_t chan=ALL_CHANS)=0
virtual void | set_rx_dc_offset (const std::complex< double > &offset, size_t chan)=0
virtual meta_range_t | get_rx_dc_offset_range (size_t chan) const =0
virtual void | set_rx_iq_balance (const bool enb, size_t chan)=0
virtual void | set_rx_iq_balance (const std::complex< double > &correction, size_t chan)=0
virtual std::vector< std::string > | get_gpio_banks () const =0
virtual void | set_gpio_attr (const std::string &bank, const std::string &attr, const uint32_t value)=0
virtual uint32_t | get_gpio_attr (const std::string &bank, const std::string &attr)=0
virtual std::vector< std::string > | get_rx_sensor_names (size_t chan) const =0
virtual uhd::sensor_value_t | get_rx_sensor (const std::string &name, size_t chan)=0
virtual std::vector< std::string > | get_tx_sensor_names (size_t chan) const =0
virtual uhd::sensor_value_t | get_tx_sensor (const std::string &name, size_t chan)=0
virtual void | issue_stream_cmd (const uhd::stream_cmd_t &stream_cmd, const size_t port)=0
virtual void | enable_rx_timestamps (const bool enable, const size_t chan)=0
virtual std::string | get_slot_name () const =0
| Returns this radio's slot name (typically "A" or "B").
virtual size_t | get_chan_from_dboard_fe (const std::string &fe, const uhd::direction_t direction) const =0
| Return the channel that corresponds to a frontend's name.
virtual std::string | get_dboard_fe_from_chan (const size_t chan, const uhd::direction_t direction) const =0
| Return the frontend name for a channel index.
virtual std::string | get_fe_name (const size_t chan, const uhd::direction_t direction) const =0
| Return the name of the frontend, as given by the dboard driver.
virtual void | set_db_eeprom (const uhd::eeprom_map_t &db_eeprom)=0
| Update the daughterboard EEPROM.
virtual uhd::eeprom_map_t | get_db_eeprom ()=0
| Return the content of the daughterboard EEPROM.
Public Member Functions inherited from uhd::rfnoc::noc_block_base
| ~noc_block_base () override
std::string | get_unique_id () const override
| Unique ID for an RFNoC block is its block ID.
size_t | get_num_input_ports () const override
size_t | get_num_output_ports () const override
noc_id_t | get_noc_id () const
const block_id_t & | get_block_id () const
double | get_tick_rate () const
size_t | get_mtu (const res_source_info &edge)
size_t | get_chdr_hdr_len (const bool account_for_ts=true) const
size_t | get_max_payload_size (const res_source_info &edge, const bool account_for_ts=true)
uhd::device_addr_t | get_block_args () const
uhd::property_tree::sptr & | get_tree () const
| Return a reference to this block's subtree.
uhd::property_tree::sptr & | get_tree ()
| Return a reference to this block's subtree (non-const version).
std::shared_ptr< mb_controller > | get_mb_controller ()
Public Member Functions inherited from uhd::rfnoc::node_t
| node_t ()
virtual | ~node_t ()
std::vector< std::string > | get_property_ids () const
template<typename prop_data_t>
void | set_property (const std::string &id, const prop_data_t &val, const size_t instance=0)
void | set_properties (const uhd::device_addr_t &props, const size_t instance=0)
template<typename prop_data_t>
const prop_data_t & | get_property (const std::string &id, const size_t instance=0)
virtual void | set_command_time (uhd::time_spec_t time, const size_t instance)
virtual uhd::time_spec_t | get_command_time (const size_t instance) const
virtual void | clear_command_time (const size_t instance)
Public Member Functions inherited from uhd::rfnoc::register_iface_holder
| register_iface_holder (register_iface::sptr reg)
virtual | ~register_iface_holder ()=default
register_iface & | regs ()
Public Member Functions inherited from uhd::rfnoc::rf_control::core_iface
virtual | ~core_iface ()=default
virtual std::string | get_tx_antenna (const size_t chan) const =0
virtual std::vector< std::string > | get_tx_antennas (const size_t chan) const =0
virtual void | set_tx_antenna (const std::string &ant, const size_t chan)=0
virtual std::string | get_rx_antenna (const size_t chan) const =0
virtual std::vector< std::string > | get_rx_antennas (const size_t chan) const =0
virtual void | set_rx_antenna (const std::string &ant, const size_t chan)=0
virtual double | get_tx_frequency (const size_t chan)=0
virtual double | set_tx_frequency (const double freq, size_t chan)=0
virtual void | set_tx_tune_args (const uhd::device_addr_t &args, const size_t chan)=0
virtual uhd::freq_range_t | get_tx_frequency_range (const size_t chan) const =0
virtual double | get_rx_frequency (const size_t chan)=0
virtual double | set_rx_frequency (const double freq, const size_t chan)=0
virtual void | set_rx_tune_args (const uhd::device_addr_t &args, const size_t chan)=0
virtual uhd::freq_range_t | get_rx_frequency_range (const size_t chan) const =0
virtual std::vector< std::string > | get_tx_gain_names (const size_t chan) const =0
virtual uhd::gain_range_t | get_tx_gain_range (const size_t chan) const =0
virtual uhd::gain_range_t | get_tx_gain_range (const std::string &name, const size_t chan) const =0
virtual double | get_tx_gain (const size_t chan)=0
virtual double | get_tx_gain (const std::string &name, const size_t chan)=0
virtual double | set_tx_gain (const double gain, const size_t chan)=0
virtual double | set_tx_gain (const double gain, const std::string &name, const size_t chan)=0
virtual std::vector< std::string > | get_rx_gain_names (const size_t chan) const =0
virtual uhd::gain_range_t | get_rx_gain_range (const size_t chan) const =0
virtual uhd::gain_range_t | get_rx_gain_range (const std::string &name, const size_t chan) const =0
virtual double | get_rx_gain (const size_t chan)=0
virtual double | get_rx_gain (const std::string &name, const size_t chan)=0
virtual double | set_rx_gain (const double gain, const size_t chan)=0
virtual double | set_rx_gain (const double gain, const std::string &name, const size_t chan)=0
virtual void | set_rx_agc (const bool enable, const size_t chan)=0
virtual meta_range_t | get_tx_bandwidth_range (size_t chan) const =0
virtual double | get_tx_bandwidth (const size_t chan)=0
virtual double | set_tx_bandwidth (const double bandwidth, const size_t chan)=0
virtual meta_range_t | get_rx_bandwidth_range (size_t chan) const =0
virtual double | get_rx_bandwidth (const size_t chan)=0
virtual double | set_rx_bandwidth (const double bandwidth, const size_t chan)=0
virtual std::vector< std::string > | get_rx_lo_names (const size_t chan) const =0
virtual std::vector< std::string > | get_rx_lo_sources (const std::string &name, const size_t chan) const =0
virtual freq_range_t | get_rx_lo_freq_range (const std::string &name, const size_t chan) const =0
virtual void | set_rx_lo_source (const std::string &src, const std::string &name, const size_t chan)=0
virtual std::string | get_rx_lo_source (const std::string &name, const size_t chan)=0
virtual void | set_rx_lo_export_enabled (bool enabled, const std::string &name, const size_t chan)=0
virtual bool | get_rx_lo_export_enabled (const std::string &name, const size_t chan)=0
virtual double | set_rx_lo_freq (double freq, const std::string &name, const size_t chan)=0
virtual double | get_rx_lo_freq (const std::string &name, const size_t chan)=0
virtual std::vector< std::string > | get_tx_lo_names (const size_t chan) const =0
virtual std::vector< std::string > | get_tx_lo_sources (const std::string &name, const size_t chan) const =0
virtual freq_range_t | get_tx_lo_freq_range (const std::string &name, const size_t chan)=0
virtual void | set_tx_lo_source (const std::string &src, const std::string &name, const size_t chan)=0
virtual std::string | get_tx_lo_source (const std::string &name, const size_t chan)=0
virtual void | set_tx_lo_export_enabled (const bool enabled, const std::string &name, const size_t chan)=0
virtual bool | get_tx_lo_export_enabled (const std::string &name, const size_t chan)=0
virtual double | set_tx_lo_freq (const double freq, const std::string &name, const size_t chan)=0
virtual double | get_tx_lo_freq (const std::string &name, const size_t chan)=0
Public Member Functions inherited from uhd::rfnoc::rf_control::power_reference_iface
virtual | ~power_reference_iface ()=default
virtual bool | has_rx_power_reference (const size_t chan=0)=0
virtual void | set_rx_power_reference (const double power_dbm, const size_t chan=0)=0
virtual double | get_rx_power_reference (const size_t chan=0)=0
virtual std::vector< std::string > | get_rx_power_ref_keys (const size_t chan=0)=0
virtual meta_range_t | get_rx_power_range (const size_t chan)=0
virtual bool | has_tx_power_reference (const size_t chan=0)=0
virtual void | set_tx_power_reference (const double power_dbm, const size_t chan=0)=0
virtual double | get_tx_power_reference (const size_t chan=0)=0
virtual std::vector< std::string > | get_tx_power_ref_keys (const size_t chan=0)=0
virtual meta_range_t | get_tx_power_range (const size_t chan)=0
Public Member Functions inherited from uhd::features::discoverable_feature_getter_iface
virtual | ~discoverable_feature_getter_iface ()=default
template<typename T>
T & | get_feature ()
| Retrieves a feature of the specified type.
template<typename T>
bool | has_feature ()
| Determines whether a given feature exists.
virtual std::vector< std::string > | enumerate_features ()=0
| Enumerate all discoverable features present on the device.

## Static Public Attributes

static const std::string | ALL_LOS
static const std::string | ALL_GAINS
static constexpr size_t | ALL_CHANS = size_t(~0)
Static Public Attributes inherited from uhd::rfnoc::node_t
static const size_t | ANY_PORT = size_t(~0)

## Additional Inherited Members

Public Types inherited from uhd::rfnoc::noc_block_base
using | sptr = std::shared_ptr<noc_block_base>
using | make_args_ptr = std::unique_ptr<make_args_t>
| Opaque pointer to the constructor arguments.
Public Types inherited from uhd::rfnoc::node_t
enum class | forwarding_policy_t { ONE_TO_ONE , ONE_TO_FAN , ONE_TO_ALL_IN , ONE_TO_ALL_OUT , ONE_TO_ALL , DROP , USE_MAP }
| Types of property/action forwarding for those not defined by the block itself. More...
using | resolver_fn_t = std::function<void(void)>
using | resolve_callback_t = std::function<void(void)>
using | graph_mutex_callback_t = std::function<std::recursive_mutex&(void)>
using | action_handler_t
using | forwarding_map_t
Public Types inherited from uhd::rfnoc::rf_control::core_iface
using | sptr = std::shared_ptr<core_iface>
Public Types inherited from uhd::rfnoc::rf_control::power_reference_iface
using | sptr = std::shared_ptr<power_reference_iface>
Protected Types inherited from uhd::rfnoc::node_t
using | prop_ptrs_t = std::vector<property_base_t*>
Protected Member Functions inherited from uhd::rfnoc::noc_block_base
| noc_block_base (make_args_ptr make_args)
void | set_num_input_ports (const size_t num_ports)
void | set_num_output_ports (const size_t num_ports)
void | set_tick_rate (const double tick_rate)
void | set_mtu_forwarding_policy (const forwarding_policy_t policy)
void | set_mtu (const res_source_info &edge, const size_t new_mtu)
property_base_t * | get_mtu_prop_ref (const res_source_info &edge)
virtual void | deinit ()
Protected Member Functions inherited from uhd::rfnoc::node_t
void | register_property (property_base_t *prop, resolve_callback_t &&clean_callback=nullptr)
void | add_property_resolver (prop_ptrs_t &&inputs, prop_ptrs_t &&outputs, resolver_fn_t &&resolver_fn)
void | set_prop_forwarding_policy (forwarding_policy_t policy, const std::string &prop_id="")
void | set_prop_forwarding_map (const forwarding_map_t &map)
template<typename prop_data_t>
void | set_property (const std::string &id, const prop_data_t &val, const res_source_info &src_info)
template<typename prop_data_t>
const prop_data_t & | get_property (const std::string &id, const res_source_info &src_info)
void | register_action_handler (const std::string &id, action_handler_t &&handler)
void | set_action_forwarding_policy (forwarding_policy_t policy, const std::string &action_key="")
void | set_action_forwarding_map (const forwarding_map_t &map)
void | post_action (const res_source_info &edge_info, action_info::sptr action)
virtual bool | check_topology (const std::vector< size_t > &connected_inputs, const std::vector< size_t > &connected_outputs)
Protected Member Functions inherited from uhd::rfnoc::register_iface_holder
void | update_reg_iface (register_iface::sptr new_iface=nullptr)
Static Protected Attributes inherited from uhd::rfnoc::node_t
static dirtifier_t | ALWAYS_DIRTY
| A dirtifyer object, useful for properties that always need updating.

## Detailed Description

Parent class for radio block controllers

# Overrun Handling

When the radio block on the FPGA detects an overrun (i.e., a buffer filled up and was not emptied fast enough), the radio block sends an asynchronous message to the radio block controller to notify the software of an overrun.

When streaming samples into a user application, the radio block is however not the recipient of the streaming data. Rather, the recipient is a streamer object.

Because the topology of the RFNoC graph is not known at compile time, overruns are handled with a special protocol. As an example, assume that multiple radios are streaming to the host via a custom DSP block, and that Radio0 has detected an overrun:

┌─────────┐ O
│ Radio0 ├──┐
└─────────┘ │ ┌──────────────────┐ ┌─────────────┐
├───> Custom DSP Block ├────> RX Streamer │
┌─────────┐ │ └──────────────────┘ └─────────────┘
│ Radio1 ├──┘
└─────────┘

In all cases, when the radio block controller is notified of an overrun by the FPGA, it will log a 'O' character (using UHD_LOG_FASTPATH()) and post an uhd::rfnoc::rx_event_action_info object downstream. The custom DSP block may choose to act upon the overrun notification by registering an event handler for such an action message, or it can ignore the message, in which case RFNoC will forward the message downstream to the RX Streamer. If the user is calling uhd::rx_streamer::recv(), then the overrun will be declared as part of the uhd::rx_metadata_t object.

Note that the FPGA will immediately stop streaming when overrun occurs, as it has nowhere to put the received sample data. However, there is a special case where UHD performs a more elaborate overrun handling: When the user requested continuous streaming data (the stream command mode was stream_cmd_t::STREAM_MODE_START_CONTINUOUS), the streamer will attempt to restart the stream. This restarting of the stream is implemented as handshake between the streamer and the radio blocks.

In the example above, the following steps will be taken:

- At some point, the application starts requests a continuous stream from the radios. The radio block controllers will take a note of this continuous streaming state.
- Now the overrun occurs in Radio0. It will send an overrun notification downstream. We assume that the custom DSP block is not handling the message. The rx_event_action_info object with the overrun information is then delivered to the RX Streamer. This object also contains a flag whether or not the radio block controller was in continuous streaming mode.
- The RX Streamer will switch to overrun handling mode. This is to prevent it from overreacting from other overrun messages (e.g., Radio1 could be stalled by Radio0 and then also send an overrun message).
- The RX Streamer then sends a stop stream command to all upstream blocks. This is to ensure that other radios (in this example, Radio1) are no longer streaming.
- At some point, the RX streamer will run out of data to receive (because the upstream radios have either stopped due to an overrun, or because they were told to stop by the streamer). When this happens, the rx_streamer::recv() call will flag an overrun.
- If the overrun happened during continuous streaming, the RX streamer will now issue a restart request to the radio that first flagged an overrun (in this example, Radio0) by posting another uhd::rfnoc::action_info object.
- When Radio0 receives the restart request, it will send a new continuous stream command downstream to the RX streamer, with a timestamp that is sufficiently far enough in the future.
- The RX streamer sends the start-stream command back upstream to all radios. This ensures that all upstream radios start streaming at the same time. It also leaves overrun handling mode.
- Note that if either the radio block controller or the RX streamer receive a stop-stream command from outside, this overrun handling mode is interrupted and there will be no further attempts to restart the radio.

## Member Function Documentation

## enable_rx_timestamps()

virtual void uhd::rfnoc::radio_control::enable_rx_timestamps | ( | const bool | enable,
|  | const size_t | chan )

pure virtual

Enable or disable the setting of timestamps on Rx.

## get_chan_from_dboard_fe()

virtual size_t uhd::rfnoc::radio_control::get_chan_from_dboard_fe | ( | const std::string & | fe,
|  | const uhd::direction_t | direction ) const

pure virtual

Return the channel that corresponds to a frontend's name.

## get_db_eeprom()

virtual uhd::eeprom_map_t uhd::rfnoc::radio_control::get_db_eeprom | ( |  | ) |

pure virtual

Return the content of the daughterboard EEPROM.

## get_dboard_fe_from_chan()

virtual std::string uhd::rfnoc::radio_control::get_dboard_fe_from_chan | ( | const size_t | chan,
|  | const uhd::direction_t | direction ) const

pure virtual

Return the frontend name for a channel index.

## get_fe_name()

virtual std::string uhd::rfnoc::radio_control::get_fe_name | ( | const size_t | chan,
|  | const uhd::direction_t | direction ) const

pure virtual

Return the name of the frontend, as given by the dboard driver.

## get_gpio_attr()

virtual uint32_t uhd::rfnoc::radio_control::get_gpio_attr | ( | const std::string & | bank,
|  | const std::string & | attr )

pure virtual

Get a GPIO attribute on a particular GPIO bank. Possible attribute names:

- CTRL - 1 for ATR mode 0 for GPIO mode
- DDR - 1 for output 0 for input
- OUT - GPIO output level (not ATR mode)
- ATR_0X - ATR idle state
- ATR_RX - ATR receive only state
- ATR_TX - ATR transmit only state
- ATR_XX - ATR full duplex state
- READBACK - readback input GPIOs
  Parameters

    bank | the name of a GPIO bank
    attr | the name of a GPIO attribute

  Returns
    the value set for this attribute

## get_gpio_banks()

virtual std::vector< std::string > uhd::rfnoc::radio_control::get_gpio_banks | ( |  | ) | const

pure virtual

Returns the list of GPIO banks that are associated with this radio.

Returns
  list of GPIO bank names

## get_rate()

virtual double uhd::rfnoc::radio_control::get_rate | ( |  | ) | const

pure virtual

Get the sample rate.

## get_rate_range()

virtual uhd::meta_range_t uhd::rfnoc::radio_control::get_rate_range | ( |  | ) | const

pure virtual

Return a list of valid rates.

## get_rx_dc_offset_range()

virtual meta_range_t uhd::rfnoc::radio_control::get_rx_dc_offset_range | ( | size_t | chan | ) | const

pure virtual

Get the valid range for RX DC offset values.

Parameters

  chan | the channel index

## get_rx_gain_profile()

virtual std::string uhd::rfnoc::radio_control::get_rx_gain_profile | ( | const size_t | chan | ) | const

pure virtual

Set the RX gain profile

## get_rx_gain_profile_names()

virtual std::vector< std::string > uhd::rfnoc::radio_control::get_rx_gain_profile_names | ( | const size_t | chan | ) | const

pure virtual

Return a list of TX gain profiles for this radio

## get_rx_sensor()

virtual uhd::sensor_value_t uhd::rfnoc::radio_control::get_rx_sensor | ( | const std::string & | name,
|  | size_t | chan )

pure virtual

Return the sensor value for sensor `name`

Parameters

  name | Sensor name (e.g. "lo_locked")
  chan | Channel index

Exceptions

  uhd::key_error | if the sensor does not exist

## get_rx_sensor_names()

virtual std::vector< std::string > uhd::rfnoc::radio_control::get_rx_sensor_names | ( | size_t | chan | ) | const

pure virtual

Return a list of RX sensors

The names returned in this list can be used as an input to get_rx_sensor()

## get_slot_name()

virtual std::string uhd::rfnoc::radio_control::get_slot_name | ( |  | ) | const

pure virtual

Returns this radio's slot name (typically "A" or "B").

## get_spc()

virtual size_t uhd::rfnoc::radio_control::get_spc | ( |  | ) | const

pure virtual

Return the samples per clock (SPC) value of this radio.

## get_ticks_now()

virtual uint64_t uhd::rfnoc::radio_control::get_ticks_now | ( |  | ) |

pure virtual

Get tick count

Returns
  tick count

Exceptions

  uhd::not_implemented_error | if not implemented

## get_time_now()

virtual uhd::time_spec_t uhd::rfnoc::radio_control::get_time_now | ( |  | ) |

pure virtual

Get the time

Returns
  time now

Exceptions

  uhd::not_implemented_error | if not implemented

## get_tx_dc_offset_range()

virtual meta_range_t uhd::rfnoc::radio_control::get_tx_dc_offset_range | ( | size_t | chan | ) | const

pure virtual

Get the valid range for TX DC offset values.

Parameters

  chan | the channel index

## get_tx_gain_profile()

virtual std::string uhd::rfnoc::radio_control::get_tx_gain_profile | ( | const size_t | chan | ) | const

pure virtual

Return the TX gain profile

## get_tx_gain_profile_names()

virtual std::vector< std::string > uhd::rfnoc::radio_control::get_tx_gain_profile_names | ( | const size_t | chan | ) | const

pure virtual

Return a list of TX gain profiles for this radio

## get_tx_sensor()

virtual uhd::sensor_value_t uhd::rfnoc::radio_control::get_tx_sensor | ( | const std::string & | name,
|  | size_t | chan )

pure virtual

Return the sensor value for sensor `name`

Parameters

  name | Sensor name (e.g. "lo_locked")
  chan | Channel index

Exceptions

  uhd::key_error | if the sensor does not exist

## get_tx_sensor_names()

virtual std::vector< std::string > uhd::rfnoc::radio_control::get_tx_sensor_names | ( | size_t | chan | ) | const

pure virtual

Return a list of TX sensors

The names returned in this list can be used as an input to get_tx_sensor()

## issue_stream_cmd()

virtual void uhd::rfnoc::radio_control::issue_stream_cmd | ( | const uhd::stream_cmd_t & | stream_cmd,
|  | const size_t | port )

pure virtual

Issue stream command: Instruct the RX part of the radio to send samples

When the radio is running at multiple samples per clock cycle, there are some restrictions in place:

- When requesting a burst of length N, N must be an integer multiple of SPC. If it's not, the radio will round up to the next integer multiple.
- When requesting a start time, the start time may be rounded down such that the first sample has a tick count value that is an integer multiple of SPC. That means the sample at the requested time will always be produced, but it might not be the first sample to be returned.

Parameters

  stream_cmd | The actual stream command to execute
  port | The port for which the stream command is meant

## set_db_eeprom()

virtual void uhd::rfnoc::radio_control::set_db_eeprom | ( | const uhd::eeprom_map_t & | db_eeprom | ) |

pure virtual

Update the daughterboard EEPROM.

## set_gpio_attr()

virtual void uhd::rfnoc::radio_control::set_gpio_attr | ( | const std::string & | bank,
|  | const std::string & | attr,
|  | const uint32_t | value )

pure virtual

Set a GPIO attribute on a particular GPIO bank. Possible attribute names:

- CTRL - 1 for ATR mode 0 for GPIO mode
- DDR - 1 for output 0 for input
- OUT - GPIO output level (not ATR mode)
- ATR_0X - ATR idle state
- ATR_RX - ATR receive only state
- ATR_TX - ATR transmit only state
- ATR_XX - ATR full duplex state
  Parameters

    bank | the name of a GPIO bank (e.g., FP0)
    attr | the name of a GPIO attribute (e.g., CTRL)
    value | the new value for this GPIO bank

## set_rate()

virtual double uhd::rfnoc::radio_control::set_rate | ( | const double | rate | ) |

pure virtual

Set the sample rate.

## set_rx_dc_offset() [1/2]

virtual void uhd::rfnoc::radio_control::set_rx_dc_offset | ( | const bool | enb,
|  | size_t | chan = ALL_CHANS )

pure virtual

Enable/disable the automatic RX 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.

Parameters

  enb | true to enable automatic DC offset correction
  chan | the channel index

## set_rx_dc_offset() [2/2]

virtual void uhd::rfnoc::radio_control::set_rx_dc_offset | ( | const std::complex< double > & | offset,
|  | size_t | chan )

pure virtual

Set a constant RX DC offset value.

The value is complex to control both I and Q. Only set this when automatic correction is disabled.

Parameters

  offset | the dc offset (1.0 is full-scale)
  chan | the channel index 0 to N-1

## set_rx_gain_profile()

virtual void uhd::rfnoc::radio_control::set_rx_gain_profile | ( | const std::string & | profile,
|  | const size_t | chan )

pure virtual

Set the RX gain profile

## set_rx_iq_balance() [1/2]

virtual void uhd::rfnoc::radio_control::set_rx_iq_balance | ( | const bool | enb,
|  | size_t | chan )

pure virtual

Enable/disable the automatic IQ imbalance correction.

Parameters

  enb | true to enable automatic IQ balance correction
  chan | the channel index 0 to N-1

## set_rx_iq_balance() [2/2]

virtual void uhd::rfnoc::radio_control::set_rx_iq_balance | ( | const std::complex< double > & | correction,
|  | size_t | chan )

pure virtual

Enable/disable the automatic IQ imbalance correction.

Parameters

  correction | the complex correction (1.0 is full-scale)
  chan | the channel index 0 to N-1

## set_tx_dc_offset()

virtual void uhd::rfnoc::radio_control::set_tx_dc_offset | ( | const std::complex< double > & | offset,
|  | size_t | chan )

pure virtual

Set a constant TX DC offset value

The value is complex to control both I and Q.

Parameters

  offset | the dc offset (1.0 is full-scale)
  chan | the channel index

## set_tx_gain_profile()

virtual void uhd::rfnoc::radio_control::set_tx_gain_profile | ( | const std::string & | profile,
|  | const size_t | chan )

pure virtual

Set the TX gain profile

## set_tx_iq_balance()

virtual void uhd::rfnoc::radio_control::set_tx_iq_balance | ( | const std::complex< double > & | correction,
|  | size_t | chan )

pure virtual

Set the TX frontend IQ imbalance correction.

Use this to adjust the magnitude and phase of I and Q.

Parameters

  correction | the complex correction
  chan | the channel index 0 to N-1

## Member Data Documentation

## ALL_CHANS

size_t uhd::rfnoc::radio_control::ALL_CHANS = size_t(~0)

static constexpr

## ALL_GAINS

const std::string uhd::rfnoc::radio_control::ALL_GAINS

static

## ALL_LOS

const std::string uhd::rfnoc::radio_control::ALL_LOS

static

The documentation for this class was generated from the following file:

- radio_control.hpp