Fix handling of discontinuities in power calibration data

The power that corresponds to a certain gain values depends on the
frequency band we are in. At the edges of these bands discontinuities
can occur (the gain necessary to achieve the same power value changes
non-continuously). The power calibration does a linear interpolation
between two neighbor points in the calibration data set to find at
best fitting value. We therefore have to make sure that this interpolation
does not cross discontinuities.

This is a minimal invasive approach. It adds values at discontinuities
for the lower and the upper band. The power calibration format uses
the frequency for a power to gain mapping as a map key. Therefore two
gain to power mappings cannot be stored for the same frequency as it
would be needed for the discontinuity. Instead the mapping for the
lower band is stored at the discontinuity frequency itself. The mapping
for the upper band is stored at the frequency + 1Hz. The calibration
will therefore still fail to yield proper results within this
sub-Hertz range. The frequency lookup in the power calibration manager
now uses round instead of truncation to find the best mapping frequency
in the calibration table.

With this, searching for neighbor data points now ensures that the data
points used belong to the same band (except for the range of
(f_discontinuity, f_discontinuity + 1Hz) ).

This commit does not solve the issue for calibration data generated
with usrp_power_cal.py because the Python interface has no means to
detect band edges for the USRP it is calibrating.

1 files changed, 3 insertions, 3 deletions

diff --git a/host/lib/usrp/common/pwr_cal_mgr.cpp b/host/lib/usrp/common/pwr_cal_mgr.cpp
index d2838cbe9..7fb569e83 100644
--- a/host/lib/usrp/common/pwr_cal_mgr.cpp
+++ b/host/lib/usrp/common/pwr_cal_mgr.cpp
@@ -99,7 +99,7 @@ public:
         _load_cal_data(key);
         UHD_ASSERT_THROW(_cal_data.count(key));
         _desired_power      = power_dbm;
-        const uint64_t freq = static_cast<uint64_t>(_get_freq());
+        const uint64_t freq = static_cast<uint64_t>(std::round(_get_freq()));
         auto& cal_data = _cal_data.at(key);
         if (!cal_data) {
             const std::string err_msg = std::string("Attempting to set power for key ")
@@ -141,7 +141,7 @@ public:
             throw uhd::runtime_error(err_msg);
         }
 
-        const uint64_t freq    = static_cast<uint64_t>(_get_freq());
+        const uint64_t freq    = static_cast<uint64_t>(std::round(_get_freq()));
         const double hw_gain = _gain_group->get_value(_hw_gain_name);
         const double hw_power = cal_data->get_power(hw_gain, freq);
         // We directly scale the power with the residual gain
@@ -167,7 +167,7 @@ public:
             UHD_LOG_ERROR(_log_id, err_msg);
             throw uhd::runtime_error(err_msg);
         }
-        const uint64_t freq = static_cast<uint64_t>(_get_freq());
+        const uint64_t freq = static_cast<uint64_t>(std::round(_get_freq()));
         return cal_data->get_power_limits(freq);
     }