radio_control.hpp

Go to the documentation of this file.

//
// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <uhd/features/discoverable_feature_getter_iface.hpp>
#include <uhd/rfnoc/noc_block_base.hpp>
#include <uhd/types/device_addr.hpp>
#include <uhd/types/direction.hpp>
#include <uhd/types/eeprom.hpp>
#include <uhd/types/ranges.hpp>
#include <uhd/types/sensors.hpp>
#include <uhd/types/stream_cmd.hpp>
 
namespace uhd { namespace rfnoc {
 
class radio_control : public noc_block_base,
                      public virtual ::uhd::features::discoverable_feature_getter_iface
{
public:
    static const std::string ALL_LOS;
    static const std::string ALL_GAINS;
    static constexpr size_t ALL_CHANS = size_t(~0);
 
    RFNOC_DECLARE_BLOCK(radio_control)
 
    /**************************************************************************
     * Rate-Related API Calls
     *************************************************************************/
    //
    // This function will coerce the rate and return the actual, current value.
    virtual double set_rate(const double rate) = 0;
 
    virtual double get_rate() const = 0;
 
    virtual uhd::meta_range_t get_rate_range() const = 0;
 
    /**************************************************************************
     * RF-Related API Calls
     *************************************************************************/
    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 bool has_tx_power_reference(const size_t chan) = 0;
 
    virtual void set_tx_power_reference(
        const double power_dbm, const size_t chan) = 0;
 
    virtual double get_tx_power_reference(const size_t chan) = 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;
 
    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 bool has_rx_power_reference(const size_t chan) = 0;
 
    virtual void set_rx_power_reference(
        const double power_dbm, const size_t chan) = 0;
 
    virtual double get_rx_power_reference(const size_t chan) = 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 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 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;
 
    /**************************************************************************
     * LO Controls
     *************************************************************************/
    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 const 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) const = 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) = 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 const 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;
 
    /**************************************************************************
     * Calibration-Related API Calls
     *************************************************************************/
    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;
 
    /**************************************************************************
     * GPIO Controls
     *************************************************************************/
    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;
 
    /**************************************************************************
     * Sensor API
     *************************************************************************/
    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;
 
    /**************************************************************************
     * Streaming-Related API Calls
     *************************************************************************/
    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;
 
    /**************************************************************************
     * Radio Identification API Calls
     *************************************************************************/
    virtual std::string get_slot_name() const = 0;
 
    //
    // Example: "0" -> 0 (for UBX), or "A" -> 0 (for E310)
    virtual size_t get_chan_from_dboard_fe(
        const std::string& fe, const uhd::direction_t direction) const = 0;
 
    //
    // Example: 0 -> "0" (for UBX), or 0 -> "A" (for E310)
    virtual std::string get_dboard_fe_from_chan(
        const size_t chan, const uhd::direction_t direction) const = 0;
 
    virtual std::string get_fe_name(
        const size_t chan, const uhd::direction_t direction) const = 0;
 
    /**************************************************************************
     * EEPROM API Calls
     *************************************************************************/
    //
    // Note: EEPROMs have finite numbers of write cycles, so don't overuse this
    // method!
    virtual void set_db_eeprom(const uhd::eeprom_map_t& db_eeprom) = 0;
 
    virtual uhd::eeprom_map_t get_db_eeprom() = 0;
};
 
}} // namespace uhd::rfnoc