Merge branch 'mmajoral-fpga_ad-fmcomms5_compatibility' into next

src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.cc

@@ -58,8 +58,9 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con
       filter_filename_(configuration->property(role + ".filter_filename", filter_file_)),
       filename0_(configuration->property(role + ".filename", empty_string)),
       rf_gain_rx1_(configuration->property(role + ".gain_rx1", default_manual_gain_rx1)),
-      rf_gain_rx2_(configuration->property(role + ".gain_rx1", default_manual_gain_rx2)),
+      rf_gain_rx2_(configuration->property(role + ".gain_rx2", default_manual_gain_rx2)),
-      freq_(configuration->property(role + ".freq", static_cast<uint64_t>(GPS_L1_FREQ_HZ))),
+      freq0_(configuration->property(role + ".freq", 0)),
+      freq1_(configuration->property(role + ".freq1", static_cast<uint64_t>(GPS_L5_FREQ_HZ))),
       sample_rate_(configuration->property(role + ".sampling_frequency", default_bandwidth)),
       bandwidth_(configuration->property(role + ".bandwidth", default_bandwidth)),
       samples_to_skip_(0),
@@ -98,6 +99,12 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con
     const double seconds_to_skip = configuration->property(role + ".seconds_to_skip", 0.0);
     const size_t header_size = configuration->property(role + ".header_size", 0);
 
+    if (freq0_ == 0)
+        {
+            // use ".freq0"
+            freq0_ = configuration->property(role + ".freq0", static_cast<uint64_t>(GPS_L1_FREQ_HZ));
+        }
+
     if (filter_auto_)
         {
             filter_source_ = configuration->property(role + ".filter_source", std::string("Auto"));
@@ -340,12 +347,13 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(const ConfigurationInterface *con
                     LOG(WARNING) << "Invalid configuration value for bandwidth parameter. Set to bandwidth=" << default_bandwidth;
                 }
 
-            std::cout << "LO frequency : " << freq_ << " Hz\n";
+            std::cout << "LO frequency : " << freq0_ << " Hz\n";
             try
                 {
                     config_ad9361_rx_local(bandwidth_,
                         sample_rate_,
-                        freq_,
+                        freq0_,
+                        freq1_,
                         rf_port_select_,
                         rx1_enable_,
                         rx2_enable_,

src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.h

@@ -126,7 +126,8 @@ private:
 
     double rf_gain_rx1_;
     double rf_gain_rx2_;
-    uint64_t freq_;  // frequency of local oscillator
+    uint64_t freq0_;  // frequency of local oscillator for ADRV9361-A 0
+    uint64_t freq1_;  // frequency of local oscillator for ADRV9361-B (if present)
     uint64_t sample_rate_;
     uint64_t bandwidth_;
     uint64_t samples_to_skip_;

src/algorithms/signal_source/libs/ad9361_manager.cc

@@ -22,6 +22,7 @@
 #include <fstream>  // for ifstream
 #include <iostream>
 #include <sstream>
+#include <utility>
 #include <vector>
 
 /* check return value of attr_write function */
@@ -93,7 +94,7 @@ bool get_ad9361_stream_ch(struct iio_context *ctx __attribute__((unused)), enum
 
 
 /* finds AD9361 phy IIO configuration channel with id chid */
-bool get_phy_chan(struct iio_context *ctx, enum iodev d, int chid, struct iio_channel **chn)
+bool get_phy_chan(struct iio_device *dev, enum iodev d, int chid, struct iio_channel **chn)
 {
     std::stringstream name;
     switch (d)
@@ -102,14 +103,14 @@ bool get_phy_chan(struct iio_context *ctx, enum iodev d, int chid, struct iio_ch
             name.str("");
             name << "voltage";
             name << chid;
-            *chn = iio_device_find_channel(get_ad9361_phy(ctx), name.str().c_str(), false);
+            *chn = iio_device_find_channel(dev, name.str().c_str(), false);
             return *chn != nullptr;
             break;
         case TX:
             name.str("");
             name << "voltage";
             name << chid;
-            *chn = iio_device_find_channel(get_ad9361_phy(ctx), name.str().c_str(), true);
+            *chn = iio_device_find_channel(dev, name.str().c_str(), true);
             return *chn != nullptr;
             break;
         default:
@@ -119,17 +120,26 @@ bool get_phy_chan(struct iio_context *ctx, enum iodev d, int chid, struct iio_ch
 
 
 /* finds AD9361 local oscillator IIO configuration channels */
-bool get_lo_chan(struct iio_context *ctx, enum iodev d, struct iio_channel **chn)
+bool get_lo_chan(struct iio_device *dev, enum iodev d, int chid, struct iio_channel **chn)
 {
+    std::stringstream name;
     switch (d)
         {
-        // LO chan is always output, i.e. true
+            // LO chan is always output, i.e. true
         case RX:
-            *chn = iio_device_find_channel(get_ad9361_phy(ctx), "altvoltage0", true);
+            name.str("");
+            name << "altvoltage";
+            name << chid;
+            *chn = iio_device_find_channel(dev, name.str().c_str(), true);
             return *chn != nullptr;
+            break;
         case TX:
-            *chn = iio_device_find_channel(get_ad9361_phy(ctx), "altvoltage1", true);
+            name.str("");
+            name << "altvoltage";
+            name << chid;
+            *chn = iio_device_find_channel(dev, name.str().c_str(), true);
             return *chn != nullptr;
+            break;
         default:
             return false;
         }
@@ -137,36 +147,173 @@ bool get_lo_chan(struct iio_context *ctx, enum iodev d, struct iio_channel **chn
 
 
 /* applies streaming configuration through IIO */
-bool cfg_ad9361_streaming_ch(struct iio_context *ctx, struct stream_cfg *cfg, enum iodev type, int chid)
+void cfg_ad9361_streaming_ch(struct stream_cfg *cfg, iio_channel *chn)
 {
-    struct iio_channel *chn = nullptr;
-
     // Configure phy and lo channels
-    // LOG(INFO)<<"* Acquiring AD9361 phy channel"<<chid;
-    std::cout << "* Acquiring AD9361 phy channel" << chid << '\n';
-    if (!get_phy_chan(ctx, type, chid, &chn))
-        {
-            return false;
-        }
     wr_ch_str(chn, "rf_port_select", cfg->rfport);
     wr_ch_lli(chn, "rf_bandwidth", cfg->bw_hz);
     wr_ch_lli(chn, "sampling_frequency", cfg->fs_hz);
+}
 
-    // Configure LO channel
+
-    // LOG(INFO)<<"* Acquiring AD9361 "<<type == TX ? "TX" : "RX";
+int setup_filter(const std::string &filter_source_, uint64_t bandwidth_, uint64_t sample_rate_, uint64_t freq_, const std::string &rf_port_select_,
-    std::cout << "* Acquiring AD9361 " << (type == TX ? "TX" : "RX") << '\n';
+    struct iio_device *ad9361_phy_dev, struct iio_channel *rx_chan, struct iio_channel *chn, int chid, std::string filter_filename_, float Fpass_, float Fstop_)
-    if (!get_lo_chan(ctx, type, &chn))
+{
+    int ret;
+    if (filter_source_ == "Off")
         {
-            return false;
+            struct stream_cfg rxcfg;
+            rxcfg.bw_hz = bandwidth_;
+            rxcfg.fs_hz = sample_rate_;
+            rxcfg.lo_hz = freq_;
+            rxcfg.rfport = rf_port_select_.c_str();
+            cfg_ad9361_streaming_ch(&rxcfg, chn);
         }
-    wr_ch_lli(chn, "frequency", cfg->lo_hz);
+    else if (filter_source_ == "Auto")
-    return true;
+        {
+            ret = ad9361_set_bb_rate(ad9361_phy_dev, sample_rate_);
+            if (ret)
+                {
+                    throw std::runtime_error("Unable to set BB rate");
+                    // set bw
+                    // params.push_back("in_voltage_rf_bandwidth=" + boost::to_string(bandwidth));
+                }
+            // wr_ch_str(rx_chan, "rf_port_select", rf_port_select_.c_str());
+            ret = iio_device_attr_write(ad9361_phy_dev, "in_voltage0_rf_port_select", rf_port_select_.c_str());
+            if (ret)
+                {
+                    throw std::runtime_error("Unable to set rf_port_select");
+                }
+            wr_ch_lli(rx_chan, "rf_bandwidth", bandwidth_);
+            if (!get_lo_chan(ad9361_phy_dev, RX, chid, &rx_chan))
+                {
+                    return -1;
+                }
+            wr_ch_lli(rx_chan, "frequency", freq_);
+        }
+    else if (filter_source_ == "File")
+        {
+            try
+                {
+                    if (!load_fir_filter(filter_filename_, ad9361_phy_dev))
+                        {
+                            throw std::runtime_error("Unable to load filter file");
+                        }
+                }
+            catch (const std::runtime_error &e)
+                {
+                    std::cout << "Exception cached when configuring the RX FIR filter: " << e.what() << '\n';
+                }
+            ret = iio_device_attr_write(ad9361_phy_dev, "in_voltage0_rf_port_select", rf_port_select_.c_str());
+            if (ret)
+                {
+                    throw std::runtime_error("Unable to set rf_port_select");
+                }
+            wr_ch_lli(rx_chan, "rf_bandwidth", bandwidth_);
+            if (!get_lo_chan(ad9361_phy_dev, RX, chid, &rx_chan))
+                {
+                    return -1;
+                }
+            wr_ch_lli(rx_chan, "frequency", freq_);
+        }
+#if LIBAD9361_VERSION_GREATER_THAN_01
+    else if (filter_source_ == "Design")
+        {
+            ret = ad9361_set_bb_rate_custom_filter_manual(
+                ad9361_phy_dev, sample_rate_, static_cast<uint64_t>(Fpass_), static_cast<uint64_t>(Fstop_), bandwidth_, bandwidth_);
+            if (ret)
+                {
+                    throw std::runtime_error("Unable to set BB rate");
+                }
+            ret = iio_device_attr_write(ad9361_phy_dev, "in_voltage0_rf_port_select", rf_port_select_.c_str());
+            if (ret)
+                {
+                    throw std::runtime_error("Unable to set rf_port_select");
+                }
+            wr_ch_lli(rx_chan, "rf_bandwidth", bandwidth_);
+            if (!get_lo_chan(ad9361_phy_dev, RX, chid, &rx_chan))
+                {
+                    return -1;
+                }
+            wr_ch_lli(rx_chan, "frequency", freq_);
+        }
+#endif
+    else
+        {
+            throw std::runtime_error("Unknown filter configuration");
+        }
+
+    // Filters can only be disabled after the sample rate has been set
+    if (filter_source_ == "Off")
+        {
+            ret = ad9361_set_trx_fir_enable(ad9361_phy_dev, false);
+            if (ret)
+                {
+                    throw std::runtime_error("Unable to disable filters");
+                }
+        }
+    return 0;
+}
+
+
+int setup_device_parameters(iio_device *ad9361_phy_dev, bool quadrature_, bool rfdc_, bool bbdc_, const std::string &gain_mode_rx1_, const std::string &gain_mode_rx2_)
+{
+    int ret;
+    ret = iio_device_attr_write(ad9361_phy_dev, "trx_rate_governor", "nominal");
+    if (ret < 0)
+        {
+            std::cout << "Failed to set trx_rate_governor: " << ret << '\n';
+            return ret;
+        }
+    ret = iio_device_attr_write(ad9361_phy_dev, "ensm_mode", "fdd");
+    if (ret < 0)
+        {
+            std::cout << "Failed to set ensm_mode: " << ret << '\n';
+            return ret;
+        }
+    ret = iio_device_attr_write(ad9361_phy_dev, "calib_mode", "auto");
+    if (ret < 0)
+        {
+            std::cout << "Failed to set calib_mode: " << ret << '\n';
+            return ret;
+        }
+    ret = iio_device_attr_write_bool(ad9361_phy_dev, "in_voltage_quadrature_tracking_en", quadrature_);
+    if (ret < 0)
+        {
+            std::cout << "Failed to set in_voltage_quadrature_tracking_en: " << ret << '\n';
+            return ret;
+        }
+    ret = iio_device_attr_write_bool(ad9361_phy_dev, "in_voltage_rf_dc_offset_tracking_en", rfdc_);
+    if (ret < 0)
+        {
+            std::cout << "Failed to set in_voltage_rf_dc_offset_tracking_en: " << ret << '\n';
+            return ret;
+        }
+    ret = iio_device_attr_write_bool(ad9361_phy_dev, "in_voltage_bb_dc_offset_tracking_en", bbdc_);
+    if (ret < 0)
+        {
+            std::cout << "Failed to set in_voltage_bb_dc_offset_tracking_en: " << ret << '\n';
+            return ret;
+        }
+    ret = iio_device_attr_write(ad9361_phy_dev, "in_voltage0_gain_control_mode", gain_mode_rx1_.c_str());
+    if (ret < 0)
+        {
+            std::cout << "Failed to set in_voltage0_gain_control_mode: " << ret << '\n';
+            return ret;
+        }
+    ret = iio_device_attr_write(ad9361_phy_dev, "in_voltage1_gain_control_mode", gain_mode_rx2_.c_str());
+    if (ret < 0)
+        {
+            std::cout << "Failed to set in_voltage1_gain_control_mode: " << ret << '\n';
+        }
+    return ret;
 }
 
 
 bool config_ad9361_rx_local(uint64_t bandwidth_,
     uint64_t sample_rate_,
-    uint64_t freq_,
+    uint64_t freq0_,
+    uint64_t freq1_,
     const std::string &rf_port_select_,
     bool rx1_enable_,
     bool rx2_enable_,
@@ -184,12 +331,13 @@ bool config_ad9361_rx_local(uint64_t bandwidth_,
 
 {
     // RX stream config
-    std::cout << "AD9361 Acquiring IIO LOCAL context\n";
     struct iio_context *ctx;
     // Streaming devices
     struct iio_device *rx;
-    struct iio_channel *rx_chan1;
+    struct iio_channel *rx_chan0;  // stream channel 0
-    struct iio_channel *rx_chan2;
+    struct iio_channel *rx_chan1;  // stream channel 1
+    struct iio_channel *chn;       // phy channel
+
     int ret;
 
 #ifndef LIBAD9361_VERSION_GREATER_THAN_01
@@ -205,6 +353,8 @@ bool config_ad9361_rx_local(uint64_t bandwidth_,
         }
 #endif
 
+    // iio context
+    std::cout << "Acquiring IIO LOCAL context\n";
     ctx = iio_create_default_context();
     if (!ctx)
         {
@@ -218,181 +368,144 @@ bool config_ad9361_rx_local(uint64_t bandwidth_,
             throw std::runtime_error("AD9361 IIO No devices");
         }
 
+    // AD9361-A
     struct iio_device *ad9361_phy;
-    ad9361_phy = iio_context_find_device(ctx, "ad9361-phy");
+    std::cout << "Acquiring AD9361 phy devices\n";
-
+    ad9361_phy = iio_context_find_device(ctx, RX_DEV_A.c_str());
-    std::cout << "* Acquiring AD9361 streaming devices\n";
+    if (!ad9361_phy)
-    if (!get_ad9361_stream_dev(ctx, RX, &rx))
         {
-            std::cout << "No rx dev found\n";
+            std::cout << "No " << RX_DEV_A << " dev found\n";
-            throw std::runtime_error("AD9361 IIO No rx dev found");
+            throw std::runtime_error("AD9361 IIO no rx dev found");
         }
 
-    std::cout << "* Initializing AD9361 IIO streaming channels\n";
+    // AD9361-B
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan1))
+    struct iio_device *ad9361_phy_B;
+    bool enable_ad9361_b;
+    ad9361_phy_B = iio_context_find_device(ctx, RX_DEV_B.c_str());
+    if (ad9361_phy_B)
         {
-            std::cout << "RX channel 1 not found\n";
+            enable_ad9361_b = true;  // the RF board has two AD9361 devices
-            throw std::runtime_error("RX channel 1 not found");
         }
-
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan2))
-        {
-            std::cout << "RX channel 2 not found\n";
-            throw std::runtime_error("RX channel 2 not found");
-        }
-
-    if (filter_source_ == "Off")
-        {
-            struct stream_cfg rxcfg;
-            rxcfg.bw_hz = bandwidth_;
-            rxcfg.fs_hz = sample_rate_;
-            rxcfg.lo_hz = freq_;
-            rxcfg.rfport = rf_port_select_.c_str();
-
-            if (!cfg_ad9361_streaming_ch(ctx, &rxcfg, RX, 0))
-                {
-                    std::cout << "RX port 0 not found\n";
-                    throw std::runtime_error("AD9361 IIO RX port 0 not found");
-                }
-        }
-    else if (filter_source_ == "Auto")
-        {
-            ret = ad9361_set_bb_rate(ad9361_phy, sample_rate_);
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set BB rate");
-                    // set bw
-                    // params.push_back("in_voltage_rf_bandwidth=" + boost::to_string(bandwidth));
-                }
-            // wr_ch_str(rx_chan1, "rf_port_select", rf_port_select_.c_str());
-            ret = iio_device_attr_write(ad9361_phy, "in_voltage0_rf_port_select", rf_port_select_.c_str());
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set rf_port_select");
-                }
-            wr_ch_lli(rx_chan1, "rf_bandwidth", bandwidth_);
-            if (!get_lo_chan(ctx, RX, &rx_chan1))
-                {
-                    return false;
-                }
-            wr_ch_lli(rx_chan1, "frequency", freq_);
-        }
-    else if (filter_source_ == "File")
-        {
-            try
-                {
-                    if (!load_fir_filter(filter_filename_, ad9361_phy))
-                        {
-                            throw std::runtime_error("Unable to load filter file");
-                        }
-                }
-            catch (const std::runtime_error &e)
-                {
-                    std::cout << "Exception cached when configuring the RX FIR filter: " << e.what() << '\n';
-                }
-            ret = iio_device_attr_write(ad9361_phy, "in_voltage0_rf_port_select", rf_port_select_.c_str());
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set rf_port_select");
-                }
-            wr_ch_lli(rx_chan1, "rf_bandwidth", bandwidth_);
-            if (!get_lo_chan(ctx, RX, &rx_chan1))
-                {
-                    return false;
-                }
-            wr_ch_lli(rx_chan1, "frequency", freq_);
-        }
-#if LIBAD9361_VERSION_GREATER_THAN_01
-    else if (filter_source_ == "Design")
-        {
-            ret = ad9361_set_bb_rate_custom_filter_manual(
-                ad9361_phy, sample_rate_, static_cast<uint64_t>(Fpass_), static_cast<uint64_t>(Fstop_), bandwidth_, bandwidth_);
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set BB rate");
-                }
-            ret = iio_device_attr_write(ad9361_phy, "in_voltage0_rf_port_select", rf_port_select_.c_str());
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set rf_port_select");
-                }
-            wr_ch_lli(rx_chan1, "rf_bandwidth", bandwidth_);
-            if (!get_lo_chan(ctx, RX, &rx_chan1))
-                {
-                    return false;
-                }
-            wr_ch_lli(rx_chan1, "frequency", freq_);
-        }
-#endif
     else
         {
-            throw std::runtime_error("Unknown filter configuration");
+            enable_ad9361_b = false;  // the RF board has one AD9361 device
         }
 
-    // Filters can only be disabled after the sample rate has been set
+    // set-up AD9361-A stream device
-    if (filter_source_ == "Off")
+    std::string rx_stream_dev_a = (enable_ad9361_b ? RX_STREAM_DEV_A : RX_STREAM_DEV);
+    std::cout << "* Acquiring " << rx_stream_dev_a << " streaming device\n";
+    rx = iio_context_find_device(ctx, rx_stream_dev_a.c_str());
+    if (!rx)
         {
-            ret = ad9361_set_trx_fir_enable(ad9361_phy, false);
+            std::cout << "No " << rx_stream_dev_a << " stream dev found\n";
-            if (ret)
+            throw std::runtime_error("AD9361 IIO No " + rx_stream_dev_a + " stream dev found");
+        }
+
+    // get AD9361-A stream device channel 0 as rx channel 0
+    std::cout << "* Acquiring " << rx_stream_dev_a << " phy channel 0\n";
+    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan0))
+        {
+            std::cout << rx_stream_dev_a << " channel 0 not found\n";
+            throw std::runtime_error(rx_stream_dev_a + "RX channel 0 not found");
+        }
+
+    if (!get_phy_chan(ad9361_phy, RX, 0, &chn))
+        {
+            return false;
+        }
+    if (setup_filter(filter_source_, bandwidth_, sample_rate_, freq0_, rf_port_select_, ad9361_phy, rx_chan0, chn, 0, filter_filename_, Fpass_, Fstop_) == -1)
+        {
+            return false;
+        }
+    // Configure LO channel
+    std::cout << "* Acquiring " << RX_DEV_A << " LO RX channel 0\n";
+    if (!get_lo_chan(ad9361_phy, RX, 0, &chn))
+        {
+            std::cout << "RX LO channel 0not found\n";
+            throw std::runtime_error("RX LO channel 0not found");
+        }
+    wr_ch_lli(chn, "frequency", freq0_);
+
+    if (enable_ad9361_b)
+        {
+            // set-up AD9361-B stream device
+            std::cout << "* Acquiring " << RX_STREAM_DEV_B << " streaming device\n";
+            rx = iio_context_find_device(ctx, RX_STREAM_DEV_B.c_str());
+            if (!rx)
                 {
-                    throw std::runtime_error("Unable to disable filters");
+                    std::cout << "No " << RX_STREAM_DEV_B << " stream dev found\n";
+                    throw std::runtime_error("AD9361 IIO No " + RX_STREAM_DEV_B + " stream dev found");
+                }
+
+            // get AD9361-B stream device channel 0 as rx channel 1
+            std::cout << "* Acquiring " << RX_STREAM_DEV_B << " phy channel 0\n";
+            if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan1))
+                {
+                    std::cout << RX_STREAM_DEV_B << " channel 0 not found\n";
+                    throw std::runtime_error(RX_STREAM_DEV_B + "RX channel 0 not found");
+                }
+
+            if (!get_phy_chan(ad9361_phy_B, RX, 0, &chn))
+                {
+                    return false;
+                }
+            if (setup_filter(filter_source_, bandwidth_, sample_rate_, freq1_, rf_port_select_, ad9361_phy_B, rx_chan1, chn, 0, filter_filename_, Fpass_, Fstop_) == -1)
+                {
+                    return false;
+                }
+            // Configure LO channel
+            std::cout << "* Acquiring " << RX_DEV_B << " LO RX channel 0\n";
+            if (!get_lo_chan(ad9361_phy_B, RX, 0, &chn))
+                {
+                    std::cout << "RX LO channel 1 not found\n";
+                    throw std::runtime_error("RX LO channel 1 not found");
+                }
+            wr_ch_lli(chn, "frequency", freq1_);
+        }
+    else
+        {
+            // GET ad9361-A stream device channel 1 as rx channel 1
+            std::cout << "* Acquiring " << rx_stream_dev_a << " phy channel 1\n";
+            if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan1))
+                {
+                    std::cout << rx_stream_dev_a << " channel 1 not found\n";
+                    throw std::runtime_error(rx_stream_dev_a + "RX channel 1 not found");
+                }
+            if (setup_filter(filter_source_, bandwidth_, sample_rate_, freq0_, rf_port_select_, ad9361_phy, rx_chan1, chn, 1, filter_filename_, Fpass_, Fstop_) == -1)
+                {
+                    return false;
                 }
         }
 
     std::cout << "* Enabling IIO streaming channels\n";
     if (rx1_enable_)
         {
-            iio_channel_enable(rx_chan1);
+            iio_channel_enable(rx_chan0);
         }
     if (rx2_enable_)
         {
-            iio_channel_enable(rx_chan2);
+            iio_channel_enable(rx_chan1);
+            ad9361_fmcomms5_multichip_sync(ctx, FIXUP_INTERFACE_TIMING | CHECK_SAMPLE_RATES);
         }
     if (!rx1_enable_ and !rx2_enable_)
         {
             std::cout << "WARNING: No Rx channels enabled.\n";
         }
 
-    ret = iio_device_attr_write(ad9361_phy, "trx_rate_governor", "nominal");
+    std::cout << "configuring " << RX_DEV_A << " device parameters\n";
-    if (ret < 0)
+    if (setup_device_parameters(ad9361_phy, quadrature_, rfdc_, bbdc_, gain_mode_rx1_, gain_mode_rx2_) < 0)
         {
-            std::cout << "Failed to set trx_rate_governor: " << ret << '\n';
+            throw std::runtime_error("configuring " + RX_DEV_A + " device parameters failed\n");
         }
-    ret = iio_device_attr_write(ad9361_phy, "ensm_mode", "fdd");
+    if (enable_ad9361_b)
-    if (ret < 0)
         {
-            std::cout << "Failed to set ensm_mode: " << ret << '\n';
+            std::cout << "configuring " << RX_DEV_B << " device parameters\n";
-        }
+            if (setup_device_parameters(ad9361_phy_B, quadrature_, rfdc_, bbdc_, gain_mode_rx2_, gain_mode_rx2_) < 0)
-    ret = iio_device_attr_write(ad9361_phy, "calib_mode", "auto");
+                {
-    if (ret < 0)
+                    throw std::runtime_error("configuring " + RX_DEV_B + " device parameters failed\n");
-        {
+                }
-            std::cout << "Failed to set calib_mode: " << ret << '\n';
-        }
-    ret = iio_device_attr_write_bool(ad9361_phy, "in_voltage_quadrature_tracking_en", quadrature_);
-    if (ret < 0)
-        {
-            std::cout << "Failed to set in_voltage_quadrature_tracking_en: " << ret << '\n';
-        }
-    ret = iio_device_attr_write_bool(ad9361_phy, "in_voltage_rf_dc_offset_tracking_en", rfdc_);
-    if (ret < 0)
-        {
-            std::cout << "Failed to set in_voltage_rf_dc_offset_tracking_en: " << ret << '\n';
-        }
-    ret = iio_device_attr_write_bool(ad9361_phy, "in_voltage_bb_dc_offset_tracking_en", bbdc_);
-    if (ret < 0)
-        {
-            std::cout << "Failed to set in_voltage_bb_dc_offset_tracking_en: " << ret << '\n';
-        }
-    ret = iio_device_attr_write(ad9361_phy, "in_voltage0_gain_control_mode", gain_mode_rx1_.c_str());
-    if (ret < 0)
-        {
-            std::cout << "Failed to set in_voltage0_gain_control_mode: " << ret << '\n';
-        }
-    ret = iio_device_attr_write(ad9361_phy, "in_voltage1_gain_control_mode", gain_mode_rx2_.c_str());
-    if (ret < 0)
-        {
-            std::cout << "Failed to set in_voltage1_gain_control_mode: " << ret << '\n';
         }
+
     if (gain_mode_rx1_ == "manual")
         {
             ret = iio_device_attr_write_double(ad9361_phy, "in_voltage0_hardwaregain", rf_gain_rx1_);
@@ -401,12 +514,27 @@ bool config_ad9361_rx_local(uint64_t bandwidth_,
                     std::cout << "Failed to set in_voltage0_hardwaregain: " << ret << '\n';
                 }
         }
-    if (gain_mode_rx2_ == "manual")
+
+    if (!enable_ad9361_b)
         {
-            ret = iio_device_attr_write_double(ad9361_phy, "in_voltage1_hardwaregain", rf_gain_rx2_);
+            if (gain_mode_rx2_ == "manual")
-            if (ret < 0)
                 {
-                    std::cout << "Failed to set in_voltage1_hardwaregain: " << ret << '\n';
+                    ret = iio_device_attr_write_double(ad9361_phy, "in_voltage1_hardwaregain", rf_gain_rx2_);
+                    if (ret < 0)
+                        {
+                            std::cout << "Failed to set in_voltage1_hardwaregain: " << ret << '\n';
+                        }
+                }
+        }
+    else
+        {
+            if (gain_mode_rx2_ == "manual")
+                {
+                    ret = iio_device_attr_write_double(ad9361_phy_B, "in_voltage0_hardwaregain", rf_gain_rx2_);
+                    if (ret < 0)
+                        {
+                            std::cout << "Failed to set in_voltage1_hardwaregain: " << ret << '\n';
+                        }
                 }
         }
 
@@ -440,8 +568,9 @@ bool config_ad9361_rx_remote(const std::string &remote_host,
     struct iio_context *ctx;
     // Streaming devices
     struct iio_device *rx;
+    struct iio_channel *rx_chan0;
     struct iio_channel *rx_chan1;
-    struct iio_channel *rx_chan2;
+    struct iio_channel *chn;  // phy channel
 
 #ifndef LIBAD9361_VERSION_GREATER_THAN_01
     if (filter_source_ == "Design")
@@ -484,124 +613,42 @@ bool config_ad9361_rx_remote(const std::string &remote_host,
     int ret;
 
     std::cout << "* Initializing AD9361 IIO streaming channels\n";
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan1))
+    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan0))
         {
             std::cout << "RX channel 1 not found\n";
             throw std::runtime_error("RX channel 1 not found");
         }
-
+    if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan1))
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan2))
         {
             std::cout << "RX channel 2 not found\n";
             throw std::runtime_error("RX channel 2 not found");
         }
-
+    if (!get_phy_chan(ad9361_phy, RX, 0, &chn))
-    if (filter_source_ == "Off")
         {
-            struct stream_cfg rxcfg;
+            return false;
-            rxcfg.bw_hz = bandwidth_;
-            rxcfg.fs_hz = sample_rate_;
-            rxcfg.lo_hz = freq_;
-            rxcfg.rfport = rf_port_select_.c_str();
-
-            if (!cfg_ad9361_streaming_ch(ctx, &rxcfg, RX, 0))
-                {
-                    std::cout << "RX port 0 not found\n";
-                    throw std::runtime_error("AD9361 IIO RX port 0 not found");
-                }
         }
-    else if (filter_source_ == "Auto")
+    if (setup_filter(std::move(filter_source_), bandwidth_, sample_rate_, freq_, rf_port_select_, ad9361_phy, rx_chan0, chn, 0, std::move(filter_filename_), Fpass_, Fstop_) == -1)
         {
-            ret = ad9361_set_bb_rate(ad9361_phy, sample_rate_);
+            return false;
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set BB rate");
-                    // set bw
-                    // params.push_back("in_voltage_rf_bandwidth=" + boost::to_string(bandwidth));
-                }
-            // wr_ch_str(rx_chan1, "rf_port_select", rf_port_select_.c_str());
-            ret = iio_device_attr_write(ad9361_phy, "in_voltage0_rf_port_select", rf_port_select_.c_str());
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set rf_port_select");
-                }
-            wr_ch_lli(rx_chan1, "rf_bandwidth", bandwidth_);
-            if (!get_lo_chan(ctx, RX, &rx_chan1))
-                {
-                    return false;
-                }
-            wr_ch_lli(rx_chan1, "frequency", freq_);
-        }
-    else if (filter_source_ == "File")
-        {
-            try
-                {
-                    if (!load_fir_filter(filter_filename_, ad9361_phy))
-                        {
-                            throw std::runtime_error("Unable to load filter file");
-                        }
-                }
-            catch (const std::runtime_error &e)
-                {
-                    std::cout << "Exception cached when configuring the RX FIR filter: " << e.what() << '\n';
-                }
-            ret = iio_device_attr_write(ad9361_phy, "in_voltage0_rf_port_select", rf_port_select_.c_str());
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set rf_port_select");
-                }
-            wr_ch_lli(rx_chan1, "rf_bandwidth", bandwidth_);
-            if (!get_lo_chan(ctx, RX, &rx_chan1))
-                {
-                    return false;
-                }
-            wr_ch_lli(rx_chan1, "frequency", freq_);
-        }
-#if LIBAD9361_VERSION_GREATER_THAN_01
-    else if (filter_source_ == "Design")
-        {
-            ret = ad9361_set_bb_rate_custom_filter_manual(
-                ad9361_phy, sample_rate_, static_cast<uint64_t>(Fpass_), static_cast<uint64_t>(Fstop_), bandwidth_, bandwidth_);
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set BB rate");
-                }
-            ret = iio_device_attr_write(ad9361_phy, "in_voltage0_rf_port_select", rf_port_select_.c_str());
-            if (ret)
-                {
-                    throw std::runtime_error("Unable to set rf_port_select");
-                }
-            wr_ch_lli(rx_chan1, "rf_bandwidth", bandwidth_);
-            if (!get_lo_chan(ctx, RX, &rx_chan1))
-                {
-                    return false;
-                }
-            wr_ch_lli(rx_chan1, "frequency", freq_);
-        }
-#endif
-    else
-        {
-            throw std::runtime_error("Unknown filter configuration");
         }
 
-    // Filters can only be disabled after the sample rate has been set
+    // Configure LO channel
-    if (filter_source_ == "Off")
+    std::cout << "* Acquiring LO channel RX\n";
+    if (!get_lo_chan(ad9361_phy, RX, 0, &chn))
         {
-            ret = ad9361_set_trx_fir_enable(ad9361_phy, false);
+            std::cout << "RX LO channel not found\n";
-            if (ret)
+            throw std::runtime_error("RX LO channel not found");
-                {
-                    throw std::runtime_error("Unable to disable filters");
-                }
         }
+    wr_ch_lli(rx_chan0, "frequency", freq_);
 
     std::cout << "* Enabling IIO streaming channels\n";
     if (rx1_enable_)
         {
-            iio_channel_enable(rx_chan1);
+            iio_channel_enable(rx_chan0);
         }
     if (rx2_enable_)
         {
-            iio_channel_enable(rx_chan2);
+            iio_channel_enable(rx_chan1);
         }
     if (!rx1_enable_ and !rx2_enable_)
         {
@@ -682,6 +729,7 @@ bool config_ad9361_lo_local(uint64_t bandwidth_,
 {
     // TX stream config
     std::cout << "Start of AD9361 TX Local Oscillator DDS configuration\n";
+    struct iio_channel *tx_chan;
     struct stream_cfg txcfg;
     txcfg.bw_hz = bandwidth_;
     txcfg.fs_hz = sample_rate_;
@@ -709,15 +757,28 @@ bool config_ad9361_lo_local(uint64_t bandwidth_,
         }
 
     std::cout << "* Configuring AD9361 for streaming TX\n";
-    if (!cfg_ad9361_streaming_ch(ctx, &txcfg, TX, 0))
-        {
-            std::cout << "TX port 0 not found\n";
-            throw std::runtime_error("AD9361 IIO TX port 0 not found");
-        }
 
     // ENABLE DDS on TX1
     struct iio_device *ad9361_phy;
     ad9361_phy = iio_context_find_device(ctx, "ad9361-phy");
+
+    if (!get_ad9361_stream_ch(ctx, TX, ad9361_phy, 0, &tx_chan))
+        {
+            std::cout << "TX channel 0 not found\n";
+            throw std::runtime_error("TX channel 0 not found");
+        }
+
+    cfg_ad9361_streaming_ch(&txcfg, tx_chan);
+
+    // Configure LO channel
+    std::cout << "* Acquiring LO channel TX\n";
+    if (!get_lo_chan(ad9361_phy, TX, 1, &tx_chan))
+        {
+            std::cout << "TX LO channel not found\n";
+            throw std::runtime_error("TX LO channel not found");
+        }
+    wr_ch_lli(tx_chan, "frequency", txcfg.lo_hz);
+
     int ret;
     // set output amplifier attenuation
     ret = iio_device_attr_write_double(ad9361_phy, "out_voltage0_hardwaregain", -std::abs(tx_attenuation_db_));
@@ -824,6 +885,7 @@ bool config_ad9361_lo_remote(const std::string &remote_host,
 {
     // TX stream config
     std::cout << "Start of AD9361 TX Local Oscillator DDS configuration\n";
+    struct iio_channel *tx_chan;
     struct stream_cfg txcfg;
     txcfg.bw_hz = bandwidth_;
     txcfg.fs_hz = sample_rate_;
@@ -851,15 +913,28 @@ bool config_ad9361_lo_remote(const std::string &remote_host,
         }
 
     std::cout << "* Configuring AD9361 for streaming TX\n";
-    if (!cfg_ad9361_streaming_ch(ctx, &txcfg, TX, 0))
-        {
-            std::cout << "TX port 0 not found\n";
-            throw std::runtime_error("AD9361 IIO TX port 0 not found");
-        }
 
     // ENABLE DDS on TX1
     struct iio_device *ad9361_phy;
     ad9361_phy = iio_context_find_device(ctx, "ad9361-phy");
+
+    if (!get_ad9361_stream_ch(ctx, TX, ad9361_phy, 0, &tx_chan))
+        {
+            std::cout << "TX channel 0 not found\n";
+            throw std::runtime_error("TX channel 0 not found");
+        }
+
+    cfg_ad9361_streaming_ch(&txcfg, tx_chan);
+
+    // Configure LO channel
+    std::cout << "* Acquiring LO channel TX\n";
+    if (!get_lo_chan(ad9361_phy, TX, 1, &tx_chan))
+        {
+            std::cout << "TX LO channel not found\n";
+            throw std::runtime_error("TX LO channel not found");
+        }
+    wr_ch_lli(tx_chan, "frequency", txcfg.lo_hz);
+
     int ret;
     // set output amplifier attenuation
     ret = iio_device_attr_write_double(ad9361_phy, "out_voltage0_hardwaregain", -std::abs(tx_attenuation_db_));
@@ -1089,8 +1164,8 @@ bool disable_ad9361_rx_local()
 {
     struct iio_context *ctx;
     struct iio_device *rx;
+    struct iio_channel *rx_chan0;
     struct iio_channel *rx_chan1;
-    struct iio_channel *rx_chan2;
 
     ctx = iio_create_default_context();
     if (!ctx)
@@ -1105,26 +1180,60 @@ bool disable_ad9361_rx_local()
             return false;
         }
 
-    if (!get_ad9361_stream_dev(ctx, RX, &rx))
+    // check if the second AD9361 is present
+    struct iio_device *ad9361_phy_B;
+    bool enable_ad9361_b;
+    ad9361_phy_B = iio_context_find_device(ctx, RX_DEV_B.c_str());
+    if (ad9361_phy_B)
         {
-            std::cout << "No rx streams found when disabling RX channels\n";
+            enable_ad9361_b = true;  // the RF board has two AD9361 devices
-            return false;
+        }
+    else
+        {
+            enable_ad9361_b = false;  // the RF board has one AD9361 device
         }
 
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan1))
+    std::string rx_stream_dev_a = (enable_ad9361_b ? RX_STREAM_DEV_A : RX_STREAM_DEV);
+    rx = iio_context_find_device(ctx, rx_stream_dev_a.c_str());
+    if (!rx)
         {
-            std::cout << "RX channel 1 not found when disabling RX channels\n";
+            std::cout << "No " << rx_stream_dev_a << " stream dev found when disabling RX channels\n";
-            return false;
+            throw std::runtime_error("AD9361 IIO No " + rx_stream_dev_a + " stream dev found");
         }
 
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan2))
+    // get AD9361-A stream device channel 0 as rx channel 0
+    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan0))
         {
-            std::cout << "RX channel 2 not found when disabling RX channels\n";
+            std::cout << rx_stream_dev_a << " channel 0 not found when disabling RX channels\n";
-            return false;
+            throw std::runtime_error(rx_stream_dev_a + "RX channel 0 not found");
         }
 
+    if (enable_ad9361_b)
+        {
+            rx = iio_context_find_device(ctx, RX_STREAM_DEV_B.c_str());
+            if (!rx)
+                {
+                    std::cout << "No " << RX_STREAM_DEV_B << " stream dev found when disabling RX channels\n";
+                    throw std::runtime_error("AD9361 IIO No " + RX_STREAM_DEV_B + " stream dev found");
+                }
+
+            if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan1))
+                {
+                    std::cout << RX_STREAM_DEV_B << " channel 0 not found when disabling RX channels\n";
+                    throw std::runtime_error(RX_STREAM_DEV_B + "RX channel 0 not found");
+                }
+        }
+    else
+        {
+            if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan1))
+                {
+                    std::cout << rx_stream_dev_a << " channel 1 not found\n";
+                    throw std::runtime_error(rx_stream_dev_a + "RX channel 1 not found");
+                }
+        }
+
+    iio_channel_disable(rx_chan0);
     iio_channel_disable(rx_chan1);
-    iio_channel_disable(rx_chan2);
     iio_context_destroy(ctx);
     return true;
 }
@@ -1134,8 +1243,8 @@ bool disable_ad9361_rx_remote(const std::string &remote_host)
 {
     struct iio_context *ctx;
     struct iio_device *rx;
+    struct iio_channel *rx_chan0;
     struct iio_channel *rx_chan1;
-    struct iio_channel *rx_chan2;
 
     ctx = iio_create_network_context(remote_host.c_str());
     if (!ctx)
@@ -1150,19 +1259,19 @@ bool disable_ad9361_rx_remote(const std::string &remote_host)
             return false;
         }
 
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan1))
+    if (!get_ad9361_stream_ch(ctx, RX, rx, 0, &rx_chan0))
         {
             std::cout << "RX channel 1 not found at " << remote_host << " when disabling RX channels\n";
             return false;
         }
 
-    if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan2))
+    if (!get_ad9361_stream_ch(ctx, RX, rx, 1, &rx_chan1))
         {
             std::cout << "RX channel 2 not found at " << remote_host << " when disabling RX channels\n";
             return false;
         }
+    iio_channel_disable(rx_chan0);
     iio_channel_disable(rx_chan1);
-    iio_channel_disable(rx_chan2);
     iio_context_destroy(ctx);
     return true;
 }

src/algorithms/signal_source/libs/ad9361_manager.h

@@ -32,6 +32,13 @@
 
 #define FIR_BUF_SIZE 8192
 
+static const std::string RX_DEV_A = "ad9361-phy";          // one or two AD9361s are present
+static const std::string RX_DEV_B = "ad9361-phy-B";        // one or two AD9361s are present
+static const std::string RX_STREAM_DEV = "cf-ad9361-lpc";  // one AD9361 is present
+static const std::string RX_STREAM_DEV_A = "cf-ad9361-A";  // two AD9361s are present
+static const std::string RX_STREAM_DEV_B = "cf-ad9361-B";  // two AD9361s are present
+static const std::string TX_STREAM_DEV = "cf-ad9361-dds-core-lpc";
+
 /* RX is input, TX is output */
 enum iodev
 {
@@ -77,7 +84,8 @@ bool cfg_ad9361_streaming_ch(struct iio_context *ctx, struct stream_cfg *cfg, en
 
 bool config_ad9361_rx_local(uint64_t bandwidth_,
     uint64_t sample_rate_,
-    uint64_t freq_,
+    uint64_t freq0_,
+    uint64_t freq1_,
     const std::string &rf_port_select_,
     bool rx1_enable_,
     bool rx2_enable_,

src/algorithms/signal_source/libs/fpga_dma.cc

@@ -31,7 +31,7 @@ int Fpga_DMA::DMA_open()
             return tx_channel.fd;
         }
 
-    tx_channel.buf_ptr = (struct channel_buffer *)mmap(NULL, sizeof(struct channel_buffer) * TX_BUFFER_COUNT,
+    tx_channel.buf_ptr = (struct channel_buffer *)mmap(nullptr, sizeof(struct channel_buffer) * TX_BUFFER_COUNT,
         PROT_READ | PROT_WRITE, MAP_SHARED, tx_channel.fd, 0);
     if (tx_channel.buf_ptr == MAP_FAILED)
         {
@@ -68,7 +68,7 @@ int Fpga_DMA::DMA_open()
 }
 
 
-std::array<int8_t, BUFFER_SIZE> *Fpga_DMA::get_buffer_address(void)
+std::array<int8_t, BUFFER_SIZE> *Fpga_DMA::get_buffer_address() const
 {
 #if INTPTR_MAX == INT64_MAX  // 64-bit processor architecture
     return &tx_channel.buf_ptr[0].buffer;
@@ -78,7 +78,7 @@ std::array<int8_t, BUFFER_SIZE> *Fpga_DMA::get_buffer_address(void)
 }
 
 
-int Fpga_DMA::DMA_write(int nbytes)
+int Fpga_DMA::DMA_write(int nbytes) const
 {
 #if INTPTR_MAX == INT64_MAX  // 64-bit processor architecture
 
@@ -105,21 +105,18 @@ int Fpga_DMA::DMA_write(int nbytes)
             std::cerr << "Proxy DMA Tx transfer error " << '\n';
             return -1;
         }
-
 #else  // 32-bit processor architecture
-
     const int num_bytes_sent = write(tx_fd, buffer.data(), nbytes);
     if (num_bytes_sent != nbytes)
         {
             return -1;
         }
-
 #endif
-
     return 0;
 }
 
-int Fpga_DMA::DMA_close()
+
+int Fpga_DMA::DMA_close() const
 {
 #if INTPTR_MAX == INT64_MAX  // 64-bit processor architecture
     if (munmap(tx_channel.buf_ptr, sizeof(struct channel_buffer)))

src/algorithms/signal_source/libs/fpga_dma.h

@@ -78,17 +78,17 @@ public:
     /*!
      * \brief Obtain DMA buffer address.
      */
-    std::array<int8_t, BUFFER_SIZE> *get_buffer_address(void);
+    std::array<int8_t, BUFFER_SIZE> *get_buffer_address(void) const;
 
     /*!
      * \brief Transfer DMA data
      */
-    int DMA_write(int nbytes);
+    int DMA_write(int nbytes) const;
 
     /*!
      * \brief Close the DMA device driver
      */
-    int DMA_close(void);
+    int DMA_close(void) const;
 
 private:
 #if INTPTR_MAX == INT64_MAX  // 64-bit processor architecture