eiscat: Antenna selection, gain setting

2 files changed, 306 insertions, 32 deletions

diff --git a/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.cpp b/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.cpp
index f78876791..648492486 100644
--- a/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.cpp
+++ b/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.cpp
@@ -30,44 +30,74 @@ using namespace uhd;
 using namespace uhd::usrp;
 using namespace uhd::rfnoc;
 
-static const double EISCAT_TICK_RATE = 208e6; // Hz
-static const double EISCAT_RADIO_RATE = 104e6; // Hz
-static const double EISCAT_CENTER_FREQ = 104e6; // Hz
-static const double EISCAT_DEFAULT_GAIN = 0.0; // Hz
-static const double EISCAT_DEFAULT_BANDWIDTH = 52e6; // Hz
-static const char* EISCAT_ANTENNA_NAME = "Rx";
-static const size_t EISCAT_NUM_CHANS = 5;
-static const size_t EISCAT_NUM_FRONTENDS = 16;
+namespace {
+    const size_t SR_ANTENNA_GAIN_BASE     = 204;
+    const size_t SR_ANTENNA_SELECT_BASE   = 192; // Note: On other dboards, 192 is DB_GPIO address space
+
+    const double EISCAT_TICK_RATE         = 208e6; // Hz
+    const double EISCAT_RADIO_RATE        = 104e6; // Hz
+    const double EISCAT_CENTER_FREQ       = 104e6; // Hz
+    const double EISCAT_DEFAULT_NULL_GAIN = 0.0; // dB. This is not the digital antenna gain, this a fake stub value.
+    const double EISCAT_DEFAULT_BANDWIDTH = 52e6; // Hz
+    const char*  EISCAT_DEFAULT_ANTENNA   = "BF";
+    const size_t EISCAT_NUM_ANTENNAS      = 16;
+    const size_t EISCAT_NUM_BEAMS         = 10;
+    const size_t EISCAT_NUM_PORTS         = 5;
+    const size_t EISCAT_GAIN_RANGE        = 18; // Bits, *signed*.
+    const int32_t EISCAT_MAX_GAIN         = (1<<(EISCAT_GAIN_RANGE-1))-1;
+    const int32_t EISCAT_MIN_GAIN         = -(1<<(EISCAT_GAIN_RANGE-1));
+    const double EISCAT_DEFAULT_NORM_GAIN = 1.0; // Normalized. This is the actual digital gain value.
+    const size_t EISCAT_BITS_PER_TAP      = 18;
+    const eiscat_radio_ctrl_impl::fir_tap_t EISCAT_MAX_TAP_VALUE  = (1<<(EISCAT_BITS_PER_TAP-1))-1;
+    const eiscat_radio_ctrl_impl::fir_tap_t EISCAT_MIN_TAP_VALUE  = -(1<<(EISCAT_BITS_PER_TAP-1));
+    const size_t EISCAT_NUM_FIR_TAPS      = 10;
+    const size_t EISCAT_NUM_FIR_SETS      = 1024; // BRAM must be at least EISCAT_NUM_FIR_TAPS * EISCAT_NUM_FIR_SETS
+    const size_t EISCAT_FIR_INDEX_IMPULSE = 1002;
+    const size_t EISCAT_FIR_INDEX_ZEROS   = 1003; // FIXME
+};
+
 
 UHD_RFNOC_RADIO_BLOCK_CONSTRUCTOR(eiscat_radio_ctrl)
 {
     UHD_LOG_TRACE("EISCAT", "eiscat_radio_ctrl_impl::ctor() ");
-    const size_t num_chans = get_output_ports().size();
-    UHD_ASSERT_THROW(num_chans == EISCAT_NUM_CHANS);
-    UHD_LOG_TRACE("EISCAT", "Number of channels: " << num_chans);
-
+    _num_ports = get_output_ports().size();
+    UHD_LOG_TRACE("EISCAT", "Number of channels: " << _num_ports);
     UHD_LOG_TRACE("EISCAT", "Setting tick rate to " << EISCAT_TICK_RATE/1e6 << " MHz");
 
-    /**** Configure the radio itself ***************************************/
+    /**** Configure the radio_ctrl itself ***********************************/
     radio_ctrl_impl::set_rate(EISCAT_TICK_RATE);
-    for (size_t chan = 0; chan < num_chans; chan++) {
+    for (size_t chan = 0; chan < _num_ports; chan++) {
         radio_ctrl_impl::set_rx_frequency(EISCAT_CENTER_FREQ, chan);
-        radio_ctrl_impl::set_rx_gain(EISCAT_DEFAULT_GAIN, chan);
-        radio_ctrl_impl::set_rx_antenna(EISCAT_ANTENNA_NAME, chan);
+        radio_ctrl_impl::set_rx_gain(EISCAT_DEFAULT_NULL_GAIN, chan);
+        radio_ctrl_impl::set_rx_antenna(EISCAT_DEFAULT_ANTENNA, chan);
         radio_ctrl_impl::set_rx_bandwidth(EISCAT_DEFAULT_BANDWIDTH, chan);
     }
 
+    /**** Configure the digital gain controls *******************************/
+    for (size_t i = 0; i < EISCAT_NUM_ANTENNAS; i++) {
+        _tree->access<double>(get_arg_path("gain", i) / "value")
+            .set_coercer([](double gain){ return std::max(-1.0, std::min(1.0, gain)); })
+            .add_coerced_subscriber([this, i](double gain){ this->set_antenna_gain(i, gain); })
+            .set(EISCAT_DEFAULT_NORM_GAIN)
+        ;
+    }
+
     /**** Set up legacy compatible properties ******************************/
     // For use with multi_usrp APIs etc.
     // For legacy prop tree init:
     fs_path fe_path = fs_path("dboards") / "A" / "rx_frontends";
 
+    auto antenna_options = std::vector<std::string>{"BF"};
+    for (size_t i = 0; i < EISCAT_NUM_ANTENNAS; i++) {
+        antenna_options.push_back(str(boost::format("Rx%d") % i));
+    }
+
     // The EISCAT dboards have 16 frontends total, but they map to 5 channels
     // each through a matrix of FIR filters and summations. UHD will get much
     // less confused if we create 5 fake frontends, because that's also the
     // number of channels. Since we have no control over the frontends,
     // nothing is lost here.
-    for (size_t fe_idx = 0; fe_idx < EISCAT_NUM_CHANS; fe_idx++) {
+    for (size_t fe_idx = 0; fe_idx < _num_ports; fe_idx++) {
         _tree->create<std::string>(fe_path / fe_idx / "name")
             .set(str(boost::format("EISCAT Beam Contributions %d") % fe_idx))
         ;
@@ -75,13 +105,11 @@ UHD_RFNOC_RADIO_BLOCK_CONSTRUCTOR(eiscat_radio_ctrl)
             .set("I")
         ;
         _tree->create<std::string>(fe_path / fe_idx / "antenna" / "value")
-            .set(EISCAT_ANTENNA_NAME)
-            //.add_coerced_subscriber(boost::bind(&eiscat_radio_ctrl_impl::set_rx_antenna, this, _1, 0))
-            ////.set_publisher(boost::bind(&radio_ctrl_impl::get_rx_antenna, this, 0))
-            //.set_publisher([](){ return EISCAT_ANTENNA_NAME; })
+            .add_coerced_subscriber(boost::bind(&eiscat_radio_ctrl_impl::set_rx_antenna, this, _1, 0))
+            .set_publisher(boost::bind(&radio_ctrl_impl::get_rx_antenna, this, 0))
         ;
         _tree->create<std::vector<std::string>>(fe_path / fe_idx / "antenna" / "options")
-            .set(std::vector<std::string>(1, "Rx"))
+            .set(antenna_options)
         ;
         _tree->create<double>(fe_path / fe_idx / "freq" / "value")
             .set(EISCAT_CENTER_FREQ)
@@ -92,12 +120,12 @@ UHD_RFNOC_RADIO_BLOCK_CONSTRUCTOR(eiscat_radio_ctrl)
             .set(meta_range_t(EISCAT_CENTER_FREQ, EISCAT_CENTER_FREQ))
         ;
         _tree->create<double>(fe_path / fe_idx / "gains" / "null" / "value")
-            .set(EISCAT_DEFAULT_GAIN)
+            .set(EISCAT_DEFAULT_NULL_GAIN)
             //.set_coercer(boost::bind(&eiscat_radio_ctrl_impl::set_rx_gain, this, _1, 0))
             //.set_publisher(boost::bind(&radio_ctrl_impl::get_rx_gain, this, 0))
         ;
         _tree->create<meta_range_t>(fe_path / fe_idx / "gains" / "null" / "range")
-            .set(meta_range_t(EISCAT_DEFAULT_GAIN, EISCAT_DEFAULT_GAIN))
+            .set(meta_range_t(EISCAT_DEFAULT_NULL_GAIN, EISCAT_DEFAULT_NULL_GAIN))
         ;
         _tree->create<double>(fe_path / fe_idx / "bandwidth" / "value")
             .set(EISCAT_DEFAULT_BANDWIDTH)
@@ -115,7 +143,7 @@ UHD_RFNOC_RADIO_BLOCK_CONSTRUCTOR(eiscat_radio_ctrl)
     // We can actually stream data to an EISCAT board, so it needs some tx
     // frontends too:
     fe_path = fs_path("dboards") / "A" / "tx_frontends";
-    for (size_t fe_idx = 0; fe_idx < EISCAT_NUM_CHANS; fe_idx++) {
+    for (size_t fe_idx = 0; fe_idx < _num_ports; fe_idx++) {
         _tree->create<std::string>(fe_path / fe_idx / "name")
             .set(str(boost::format("EISCAT Uplink %d") % fe_idx))
         ;
@@ -141,14 +169,78 @@ eiscat_radio_ctrl_impl::~eiscat_radio_ctrl_impl()
     UHD_LOG_TRACE("EISCAT", "eiscat_radio_ctrl_impl::dtor() ");
 }
 
+
+/****************************************************************************
+ * Public API calls
+ ***************************************************************************/
 void eiscat_radio_ctrl_impl::set_tx_antenna(const std::string &, const size_t)
 {
     throw uhd::runtime_error("Cannot set Tx antenna on EISCAT daughterboard");
 }
 
-void eiscat_radio_ctrl_impl::set_rx_antenna(const std::string & /* ant */, const size_t /* chan */)
+void eiscat_radio_ctrl_impl::set_rx_antenna(const std::string &ant, const size_t port)
 {
-    UHD_LOG_WARNING("EISCAT", "Ignoring attempt to set Rx antenna");
+    UHD_ASSERT_THROW(port < EISCAT_NUM_PORTS);
+    if (ant == "BF") {
+        UHD_LOG_TRACE("EISCAT", "Setting antenna to 'BF' (which is a no-op)");
+        return;
+    }
+    if (ant.size() < 3 or ant.size() > 4 or (ant.substr(0, 2) != "Rx" and ant.substr(0, 2) != "BF")) {
+        throw uhd::value_error(str(
+            boost::format("EISCAT: Invalid antenna selection: %s")
+            % ant
+        ));
+    }
+
+    bool use_fir_matrix = (ant.substr(0, 2) == "BF");
+
+    const size_t antenna_idx = [&ant](){
+        try {
+            return boost::lexical_cast<size_t>(ant.substr(2));
+        } catch (const boost::bad_lexical_cast&) {
+            throw uhd::value_error(str(
+                boost::format("EISCAT: Invalid antenna selection: %s")
+                % ant
+            ));
+        }
+    }();
+
+    if (use_fir_matrix) {
+        UHD_LOG_TRACE("EISCAT", str(
+            boost::format("Setting port %d to only receive on antenna %d via FIR matrix")
+            % port % antenna_idx
+        ));
+        // TODO: When we have a way to select neighbour contributions, we will need
+        // to calculate the beam_index as a function of the port *and* if we're the
+        // left or right USRP
+        const size_t beam_index = port;
+        uhd::time_spec_t send_now(0.0);
+
+        for (size_t i = 0; i < EISCAT_NUM_ANTENNAS; i++) {
+            if (i == antenna_idx) {
+                select_filter(
+                    beam_index,
+                    i,
+                    EISCAT_FIR_INDEX_IMPULSE,
+                    send_now
+                );
+            } else {
+                select_filter(
+                    beam_index,
+                    i,
+                    EISCAT_FIR_INDEX_ZEROS,
+                    send_now
+                );
+            }
+        }
+    } else {
+        set_arg<int>("choose_beams", 6);
+        UHD_LOG_TRACE("EISCAT", str(
+            boost::format("Setting port %d to only receive on antenna %d directly")
+            % port % antenna_idx
+        ));
+        sr_write(SR_ANTENNA_SELECT_BASE + port, antenna_idx);
+    }
 }
 
 double eiscat_radio_ctrl_impl::get_tx_frequency(const size_t /* chan */)
@@ -201,13 +293,17 @@ double eiscat_radio_ctrl_impl::set_rate(double rate)
     return get_rate();
 }
 
-size_t eiscat_radio_ctrl_impl::get_chan_from_dboard_fe(const std::string &fe, const uhd::direction_t dir)
-{
+size_t eiscat_radio_ctrl_impl::get_chan_from_dboard_fe(
+        const std::string &fe,
+        const uhd::direction_t /* dir */
+) {
     return boost::lexical_cast<size_t>(fe);
 }
 
-std::string eiscat_radio_ctrl_impl::get_dboard_fe_from_chan(const size_t chan, const uhd::direction_t dir)
-{
+std::string eiscat_radio_ctrl_impl::get_dboard_fe_from_chan(
+        const size_t chan,
+        const uhd::direction_t /* dir */
+) {
     return std::to_string(chan);
 }
 
@@ -232,4 +328,116 @@ bool eiscat_radio_ctrl_impl::check_radio_config()
     return true;
 }
 
+/****************************************************************************
+ * Internal methods
+ ***************************************************************************/
+void eiscat_radio_ctrl_impl::write_fir_taps(
+    const size_t fir_idx,
+    const std::vector<eiscat_radio_ctrl_impl::fir_tap_t> &taps
+) {
+    if (taps.size() > EISCAT_NUM_FIR_TAPS) {
+        throw uhd::value_error(str(
+            boost::format("Too many FIR taps for EISCAT filters (%d)")
+            % taps.size()
+        ));
+    }
+    for (const auto &tap: taps) {
+        if (tap > EISCAT_MAX_TAP_VALUE or tap < EISCAT_MIN_TAP_VALUE) {
+            throw uhd::value_error(str(
+                boost::format("Filter tap for filter_idx %d exceeds dynamic range (%d bits are allowed)")
+                % fir_idx % EISCAT_BITS_PER_TAP
+            ));
+        }
+    }
+
+    UHD_LOG_TRACE("EISCAT", str(
+        boost::format("Writing %d filter taps for filter index %d")
+        % taps.size() % fir_idx
+    ));
+    for (size_t i = 0; i < EISCAT_NUM_FIR_TAPS; i++) {
+        // Payload:
+        // - bottom 14 bits address, fir_idx * 16 + tap_index
+        // - top 18 bits are value
+        uint32_t reg_value = (fir_idx * 16) + i;;
+        if (taps.size() > i) {
+            reg_value |= (taps[i] & 0x3FFFF) << 14;
+        }
+        sr_write("SR_FIR_BRAM_WRITE_TAPS", reg_value);
+    }
+}
+
+void eiscat_radio_ctrl_impl::select_filter(
+        const size_t beam_index,
+        const size_t antenna_index,
+        const size_t fir_index,
+        const uhd::time_spec_t &time_spec
+) {
+    if (antenna_index >= EISCAT_NUM_ANTENNAS) {
+        throw uhd::value_error(str(
+            boost::format("Antenna index %d out of range. There are %d antennas in EISCAT.")
+            % antenna_index % EISCAT_NUM_ANTENNAS
+        ));
+    }
+    if (beam_index >= EISCAT_NUM_BEAMS) {
+        throw uhd::value_error(str(
+            boost::format("Beam index %d out of range. There are %d beam channels in EISCAT.")
+            % beam_index % EISCAT_NUM_BEAMS
+        ));
+    }
+
+    UHD_LOGGER_TRACE("EISCAT")
+        << "Selecting filter " << fir_index
+        << " for beam " << beam_index
+        << " and antenna " << antenna_index
+    ;
+    bool send_now = (time_spec == uhd::time_spec_t(0.0));
+    uint32_t reg_value = 0
+        | (fir_index * 16)
+        | (antenna_index & 0xF) << 14
+        | (beam_index & 0xF) << 18
+        | send_now << 22
+    ;
+
+    if (not send_now) {
+        uint64_t cmd_time_ticks = time_spec.to_ticks(EISCAT_TICK_RATE);
+        UHD_LOG_TRACE("EISCAT", str(
+            boost::format("Filter selection will be applied at time %f (0x%016X == %u)")
+            % time_spec.get_full_secs()
+            % cmd_time_ticks
+        ));
+        sr_write("SR_FIR_COMMANDS_CTRL_TIME_LO", cmd_time_ticks & 0xFFFFFFFF);
+        sr_write("SR_FIR_COMMANDS_CTRL_TIME_HI", (cmd_time_ticks >> 32) & 0xFFFFFFFF);
+    }
+    sr_write("SR_FIR_COMMANDS_RELOAD", reg_value);
+}
+
+void eiscat_radio_ctrl_impl::set_antenna_gain(
+    const size_t antenna_idx,
+    const double normalized_gain
+) {
+    if (normalized_gain < -1.0 or normalized_gain > 1.0) {
+        throw uhd::value_error(str(
+            boost::format("Invalid gain value for antenna %d: %f")
+            % antenna_idx % normalized_gain
+        ));
+    }
+
+    const auto fixpoint_gain = std::max<int32_t>(
+        EISCAT_MIN_GAIN,
+        std::min(
+            EISCAT_MAX_GAIN,
+            int32_t(normalized_gain * EISCAT_MAX_GAIN)
+        )
+    );
+
+    UHD_LOG_TRACE("EISCAT", str(
+        boost::format("Setting digital gain value for antenna %d to %f (%d)")
+        % antenna_idx % normalized_gain % fixpoint_gain
+    ));
+    sr_write(SR_ANTENNA_GAIN_BASE + antenna_idx, fixpoint_gain);
+}
+
+/****************************************************************************
+ * Registry
+ ***************************************************************************/
 UHD_RFNOC_BLOCK_REGISTER(eiscat_radio_ctrl, "EISCATRadio");
diff --git a/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.hpp b/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.hpp
index 5bfbbc035..cb45208ce 100644
--- a/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.hpp
+++ b/host/lib/usrp/dboard/eiscat/eiscat_radio_ctrl_impl.hpp
@@ -31,7 +31,8 @@ namespace uhd {
 class eiscat_radio_ctrl_impl : public radio_ctrl_impl
 {
 public:
-    typedef boost::shared_ptr<eiscat_radio_ctrl_impl> sptr;
+    using sptr = boost::shared_ptr<eiscat_radio_ctrl_impl>;
+    using fir_tap_t = int32_t;
 
     /************************************************************************
      * Structors
@@ -46,6 +47,21 @@ public:
     double set_rate(double rate);
 
     void set_tx_antenna(const std::string &ant, const size_t chan);
+
+    /*! Configures FPGA switching for antenna selection
+     *
+     *
+     * Valid antenna values:
+     * - BF: This is the default. Will apply the beamforming matrix in whatever
+     *   state it currently is.
+     * - Rx0...Rx15: Will mux the antenna signal 0...15 straight to this
+     *   channel. Note that this will disable the FIR matrix entirely.
+     * - BF0...BF15: Will configure the FIR filter matrix such that only the
+     *   contributions from antenna 0...15 are passed to this channel.
+     *
+     *
+     * \throws uhd::value_error if the antenna value was not valid
+     */
     void set_rx_antenna(const std::string &ant, const size_t chan);
 
     double set_tx_frequency(const double freq, const size_t chan);
@@ -66,6 +82,56 @@ protected:
 
 private:
 
+    /*! Write filter taps for a specific FIR filter.
+     *
+     * Note: If the number of taps is smaller than the number of available
+     * filter taps, it is padded with zero.
+     *
+     * \param fir_idx The index of the FIR filter we are reprogramming
+     * \param taps A list of FIR filter taps for this filter.
+     *
+     * \throws uhd::value_error if the number of taps is longer than the number
+     *                          of taps that the filter can handle, or if any
+     *                          tap has more bits than allowed.
+     */
+    void write_fir_taps(
+        const size_t fir_idx,
+        const std::vector<fir_tap_t> &taps
+    );
+
+
+    /*! Choose a filter to be applied between an output beam and antenna input
+     *
+     * \param beam_index Beam index
+     * \param antenna_index Antenna index
+     * \param fir_index The index of the FIR filter taps that get applied
+     * \param time_spec If non-zero, the taps get applied at this time
+     */
+    void select_filter(
+        const size_t beam_index,
+        const size_t antenna_index,
+        const size_t fir_index,
+        const uhd::time_spec_t &time_spec
+    );
+
+    /*! Sets the digital gain on a specific antenna
+     *
+     * \param antenna_idx Antenna for which this gain setting applies
+     * \param normalized_gain A value in [0, 1] which gets converted to a
+     *                        digital gain value
+     */
+    void set_antenna_gain(
+        const size_t antenna_idx,
+        const double normalized_gain
+    );
+
+    /*! The number of channels this block outputs
+     *
+     * This is *not* the number of antennas, but the number of streams a single
+     * block outputs to the crossbar.
+     */
+    size_t _num_ports;
+
 }; /* class radio_ctrl_impl */
 
 }} /* namespace uhd::rfnoc */