uhd/host/lib/cal/dsa_cal.cpp

//
// Copyright 2020 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
#include <uhd/cal/dsa_cal.hpp>
#include <uhd/cal/dsa_cal_generated.h>
#include <uhd/utils/log.hpp>
#include <uhd/exception.hpp>
#include <uhd/utils/math.hpp>
#include <map>
#include <string>
#include <array>
#include <boost/range/adaptor/indexed.hpp>

using namespace uhd::usrp::cal;

namespace {
constexpr size_t VERSION_MAJOR = 2;
constexpr size_t VERSION_MINOR = 0;

/***********************************************************************
 * Helper routines
 **********************************************************************/
template<typename base, size_t num_gain_stages, int num_dsa>
class dsa_cal_impl : public base
{
public:
    dsa_cal_impl(const std::string& name = "",
        const std::string& serial         = "",
        const uint64_t timestamp          = 0)
        : _name(name)
        , _serial(serial)
        , _timestamp(timestamp)
    {
    }

    /**************************************************************************
     * Container API (Basics)
     *************************************************************************/
    std::string get_name() const
    {
        return _name;
    }

    std::string get_serial() const
    {
        return _serial;
    }

    uint64_t get_timestamp() const
    {
        return _timestamp;
    }

    /**************************************************************************
     * Specific APIs
     *************************************************************************/
    void add_frequency_band(
        const double max_freq,
        const std::string& name,
        const std::array<std::array<uint32_t, num_dsa>, num_gain_stages> dsa_values)
    {
        _data[max_freq] = name_dsas_pair(name, dsa_values);
    }

    const std::array<uint32_t, num_dsa> get_dsa_setting(double freq, size_t gain_index) const
    {
        if (_data.empty()) {
            throw uhd::runtime_error("Cannot get DSA settings from an empty container.");
        }
        // find the lowest band with band_freq_max <= freq
        const uint64_t freqi = static_cast<uint64_t>(freq);
        const auto freq_it = _data.lower_bound(freqi);
        if (freq_it == _data.end()) {
            throw uhd::value_error("No DSA band found for freq " + std::to_string(freq));
        }
        // select DSA setting using gain_index
        if (gain_index >= num_gain_stages) {
            throw uhd::value_error(
                "gain index " + std::to_string(gain_index) + " out of bounds.");
        }
        return freq_it->second.second[gain_index];
    }

    bool is_same_band(double freq1, double freq2) const
    {
        const uint64_t freqi1 = static_cast<uint64_t>(freq1);
        const auto freq_it1 = _data.lower_bound(freqi1);
        const uint64_t freqi2 = static_cast<uint64_t>(freq2);
        const auto freq_it2 = _data.lower_bound(freqi2);
        return freq_it1 == freq_it2;
    }

    std::vector<uint32_t> get_band_settings(double freq, uint8_t dsa) const
    {
        std::vector<uint32_t> result;
        // find the lowest band with band_freq_max <= freq
        const uint64_t freqi = static_cast<uint64_t>(freq);
        const auto freq_it = _data.lower_bound(freqi);
        if (freq_it == _data.end()) {
            throw uhd::value_error("No DSA band found for freq " + std::to_string(freq));
        }
        // select DSA setting using gain_index
        for (auto item : freq_it->second.second) {
            result.push_back(item[dsa]);
        }
        return result;
    }

    void clear()
    {
        _data.clear();
    }


    /**************************************************************************
     * Container API (Serialization/Deserialization)
     *************************************************************************/
    std::vector<uint8_t> serialize()
    {
        const size_t initial_size_bytes = 2 * num_gain_stages * num_dsa * sizeof(uint32_t); // 2 band of DSA values
        flatbuffers::FlatBufferBuilder builder(initial_size_bytes);

        std::vector<flatbuffers::Offset<BandDsaMap>> band_dsas;
        band_dsas.reserve(_data.size());
        for (auto& band_dsas_pair : _data) {
            const uint64_t freq = band_dsas_pair.first;
            std::vector<flatbuffers::Offset<DsaStep>> dsa_steps;
            auto name_dsas = band_dsas_pair.second;
            for (auto const& values: name_dsas.second) // iterate over gain indizes
            {
                std::vector<uint32_t> steps(values.begin(), values.end());
                dsa_steps.push_back(CreateDsaStepDirect(builder, &steps));
            }

            band_dsas.push_back(
                CreateBandDsaMapDirect(builder, freq, &dsa_steps, name_dsas.first.c_str()));

        }

        // Now load it all into the FlatBuffer
        auto metadata = CreateMetadataDirect(builder,
            _name.c_str(),
            _serial.c_str(),
            _timestamp,
            VERSION_MAJOR,
            VERSION_MINOR);
        auto gain_dsa_cal =
            CreateDsaCalDirect(builder, metadata, &band_dsas);
        FinishDsaCalBuffer(builder, gain_dsa_cal);
        const size_t table_size = builder.GetSize();
        const uint8_t* table    = builder.GetBufferPointer();
        return std::vector<uint8_t>(table, table + table_size);
    }

    // This will amend the existing table. If that's not desired, then it is
    // necessary to call clear() ahead of time.
    void deserialize(const std::vector<uint8_t>& data)
    {
        clear();
        auto verifier = flatbuffers::Verifier(data.data(), data.size());
        if (!VerifyDsaCalBuffer(verifier)) {
            throw uhd::runtime_error("dsa_cal: Invalid data provided! ");
        }
        auto cal_table = GetDsaCal(static_cast<const void*>(data.data()));
        if (cal_table->metadata()->version_major() != VERSION_MAJOR) {
            throw uhd::runtime_error("dsa_cal: Compat number mismatch!");
        }
        if (cal_table->metadata()->version_minor() != VERSION_MINOR) {
            UHD_LOG_WARNING("CAL",
                "gain_cal: Expected compat number "
                    << VERSION_MAJOR << "." << VERSION_MINOR << ", got "
                    << cal_table->metadata()->version_major() << "."
                    << cal_table->metadata()->version_minor());
        }
        _name      = std::string(cal_table->metadata()->name()->c_str());
        _serial    = std::string(cal_table->metadata()->serial()->c_str());
        _timestamp = cal_table->metadata()->timestamp();

        auto band_dsa_map = cal_table->band_dsa_map();
        for (auto it = band_dsa_map->begin(); it != band_dsa_map->end(); ++it) {
            const uint64_t max_freq = it->max_freq();
            const std::string name(it->name()->c_str());
            auto gains = it->gains();
            if (gains->size() != num_gain_stages) {
                UHD_LOG_ERROR("CAL", "Invalid number of gain indizes. Got: "
                    << gains->size() << " expected: " << num_gain_stages);
                throw uhd::runtime_error("Invalid number of gain indizes");
            }
            std::array<std::array<uint32_t, num_dsa>, num_gain_stages> indizes;
            int i = 0;
            for (auto gain_it = gains->begin(); gain_it != gains->end(); ++gain_it) {
                if (gain_it->steps()->size() != num_dsa) {
                    UHD_LOG_ERROR("CAL", "Invalid number of attenuator indizes. Got: "
                        << gain_it->steps()->size() << " expected: " << num_dsa);
                    throw uhd::runtime_error("Invalid number of attenuator indizes");
                }
                std::copy(gain_it->steps()->begin(),
                          gain_it->steps()->end(),
                          indizes[i++].begin());
            }
            add_frequency_band(max_freq, name, indizes);
        }
    }


private:
    std::string _name;
    std::string _serial;
    uint64_t _timestamp;

    using dsa_steps = std::array<std::array<uint32_t, num_dsa>, num_gain_stages>;
    using name_dsas_pair = std::pair<std::string, dsa_steps>;

    std::map<uint64_t /* freq */, name_dsas_pair> _data;

};

} //namespace
std::shared_ptr<zbx_tx_dsa_cal> zbx_tx_dsa_cal::make()
{
    return std::make_shared<dsa_cal_impl<
            zbx_tx_dsa_cal,
            zbx_tx_dsa_cal::NUM_GAIN_STAGES,
            zbx_tx_dsa_cal::NUM_DSA>>();
}

std::shared_ptr<zbx_tx_dsa_cal> zbx_tx_dsa_cal::make(
    const std::string& name, const std::string& serial, const uint64_t timestamp)
{
    return std::make_shared<dsa_cal_impl<
            zbx_tx_dsa_cal,
            zbx_tx_dsa_cal::NUM_GAIN_STAGES,
            zbx_tx_dsa_cal::NUM_DSA>>(name, serial, timestamp);
}

std::shared_ptr<zbx_rx_dsa_cal> zbx_rx_dsa_cal::make()
{
    return std::make_shared<dsa_cal_impl<
            zbx_rx_dsa_cal,
            zbx_rx_dsa_cal::NUM_GAIN_STAGES,
            zbx_rx_dsa_cal::NUM_DSA>>();
}

std::shared_ptr<zbx_rx_dsa_cal> zbx_rx_dsa_cal::make(
    const std::string& name, const std::string& serial, const uint64_t timestamp)
{
    return std::make_shared<dsa_cal_impl<
            zbx_rx_dsa_cal,
            zbx_rx_dsa_cal::NUM_GAIN_STAGES,
            zbx_rx_dsa_cal::NUM_DSA>>(name, serial, timestamp);
}