AbstractSDRFrontEnd.hxx

Go to the documentation of this file.

//
// Created by Zhiping Jiang on 5/2/21.
//
 
#ifndef PICOSCENES_PLATFORM_ABSTRACTSDRFRONTEND_HXX
#define PICOSCENES_PLATFORM_ABSTRACTSDRFRONTEND_HXX
 
#include <deque>
#include "BoostHeaders.hxx"
#include "Intrinsics.hxx"
#include "SystemTools.hxx"
#include "AbstractFrontEnd.hxx"
#include "SDRFrontEndConfigurations.hxx"
#include "BBSignalsFileWriter.hxx"
#include "LicenseService.hxx"
#include "SDRHardwareInformation.hxx"
 
class AbstractSDRFrontEnd : public AbstractFrontEnd, public SDRFrontEndConfigurations, public SDRDeviceHardwareInformation {
public:
    explicit AbstractSDRFrontEnd(const std::string& referredInterfaceName) :
        AbstractFrontEnd(referredInterfaceName) {
    }
 
    virtual CS16Vector generateSignal(const ModularPicoScenesTxFrame& frame, uint8_t numTxAntenna) = 0;
 
    virtual std::vector<CS16Vector> generateMultiChannelSignals(const ModularPicoScenesTxFrame& frame, const uint8_t numTxAntenna) {
        auto signals = generateSignal(frame, numTxAntenna);
        auto numSamples = static_cast<int64_t>(signals.size()) / numTxAntenna;
 
        std::vector multiChannelSignals(numTxAntenna, CS16Vector(numSamples));
        for (auto channelIndex = 0; channelIndex < numTxAntenna; channelIndex++) {
            Intrinsics::fastCopyN(signals.cbegin() + numSamples * channelIndex, numSamples, multiChannelSignals[channelIndex].begin());
        }
 
        return multiChannelSignals;
    }
 
    virtual void prebuildSignals(ModularPicoScenesTxFrame& frame, const uint8_t numTxAntenna) {
        frame.prebuiltSignals = std::move(generateMultiChannelSignals(frame, numTxAntenna));
    }
 
    virtual int transmitSignalsFromFile(const std::string& signalSourceFile, uint64_t repeat) = 0;
 
    virtual int32_t transmitSignals(const std::vector<const void*>& signals, int64_t bufferLength, double postfixDuration) = 0;
 
    virtual int transmitSignalsContinuously(const std::vector<const void*>& multiChannelHeaders, int64_t numSignalsPerAntenna, bool burstStart, bool burstEnd) = 0;
 
    int transmit(const ModularPicoScenesTxFrame& frame) override {
        static std::shared_ptr<BBSignalsFileWriter<std::complex<int16_t>>> signalWriter;
        if (!txServiceStarted)
            startTx();
 
        if (txSignalDumpFilePath && !signalWriter) {
            License::LicenseService::getInstance()->checkFeature(License::FeatureNaming::SDR_Tx2File, true);
            signalWriter = std::make_shared<BBSignalsFileWriter<std::complex<int16_t>>>(*txSignalDumpFilePath);
        }
 
        auto numTxChannels = userSpecifiedTxChannels().size();
        size_t txResult{};
        std::vector<CS16Vector> inplaceGeneratedSignals{};
        if (frame.prebuiltSignals.empty()) {
            inplaceGeneratedSignals = std::move(generateMultiChannelSignals(frame, numTxChannels));
            txResult = transmitSignal(inplaceGeneratedSignals, frame.txParameters.postfixPaddingTime);
        } else {
            txResult = transmitSignal(frame.prebuiltSignals, frame.txParameters.postfixPaddingTime);
        }
        const auto& ref2Signals = !frame.prebuiltSignals.empty() ? frame.prebuiltSignals : inplaceGeneratedSignals;
 
        // TODO to fix
        // if (signalWriter)
        //     signalWriter->write2DStream(ref2Signals);
 
        if (!txResult) {
            LoggingService_SDR_debug_printf("<%s>(%s)-->%s | PPDU: %u x %u (%.3f us)", getReferredInterfaceName(), DeviceSubtype2String(getFrontEndSubtype()), frame.toString(), ref2Signals[0].size(), ref2Signals.size(), 1e6f * ref2Signals[0].size() / getTxSamplingRate());
        } else {
            LoggingService_SDR_debug_printf("<%s>(%s) tx failure. | PPDU: %u x %u (%.3f us)", getReferredInterfaceName(), DeviceSubtype2String(getFrontEndSubtype()), ref2Signals[0].size(), ref2Signals.size(), 1e6f * ref2Signals[0].size() / getTxSamplingRate());
        }
 
        return 0;
    }
 
    virtual size_t transmitSignal(const CS16Vector& signals, const uint8_t numTxChannels, const double postfixDuration) {
        int64_t numSignalsPerAntenna = signals.size() / numTxChannels;
 
        auto signalHeaders = std::vector<const void*>(numTxChannels);
        for (auto channelIndex = 0; channelIndex < numTxChannels; channelIndex++) {
            signalHeaders[channelIndex] = signals.data() + channelIndex * numSignalsPerAntenna;
        }
 
        return transmitSignals(signalHeaders, numSignalsPerAntenna, postfixDuration);
    }
 
    virtual size_t transmitSignal(const std::vector<CS16Vector>& multiChannelSignals, const double postfixDuration) {
        int64_t numSignalsPerAntenna = multiChannelSignals[0].size();
        uint8_t numTxChannels = multiChannelSignals.size();
 
        auto signalHeaders = std::vector<const void*>(numTxChannels);
        for (auto channelIndex = 0; channelIndex < numTxChannels; channelIndex++) {
            signalHeaders[channelIndex] = multiChannelSignals[channelIndex].data();
        }
 
        return transmitSignals(signalHeaders, numSignalsPerAntenna, postfixDuration);
    }
 
    virtual int32_t transmitSignalInBatchedSingleBurst(const std::vector<std::vector<const void*>>& multipleSignals, const std::vector<int64_t>& signalLength, const std::vector<double>& postfixDurations, uint32_t repeat) = 0;
 
    int transmitFramesInBatch(const std::vector<const ModularPicoScenesTxFrame*>& frames, const uint32_t repeat) override {
        static std::shared_ptr<BBSignalsFileWriter<std::complex<int16_t>>> signalWriter;
        if (!txServiceStarted)
            startTx();
 
        if (txSignalDumpFilePath && !signalWriter) {
            License::LicenseService::getInstance()->checkFeature(License::FeatureNaming::SDR_Tx2File, true);
            signalWriter = std::make_shared<BBSignalsFileWriter<std::complex<int16_t>>>(*txSignalDumpFilePath);
        }
 
        std::vector<std::vector<CS16Vector>> frameSignals;
        std::vector<std::vector<const void*>> frameSignalHeads;
        std::vector<int64_t> framePPDULengths;
        std::vector<double> framePostfixDurations;
        for (const auto* frame: frames) {
            if (!frame->prebuiltSignals.empty()) {
                std::vector<const void*> signalHeaders;
                signalHeaders.reserve(frame->prebuiltSignals.size());
                for (const auto& column: frame->prebuiltSignals)
                    signalHeaders.emplace_back(column.data());
                frameSignalHeads.emplace_back(signalHeaders);
                framePPDULengths.emplace_back(frame->prebuiltSignals.at(0).size());
                framePostfixDurations.emplace_back(frame->txParameters.postfixPaddingTime);
            } else {
                frameSignals.emplace_back(generateMultiChannelSignals(*frame, userSpecifiedTxChannels().size()));
                std::vector<const void*> signalHeaders;
                for (const auto& column: frameSignals.back())
                    signalHeaders.emplace_back(column.data());
                frameSignalHeads.emplace_back(signalHeaders);
                framePPDULengths.emplace_back(frameSignals.back().at(0).size());
                framePostfixDurations.emplace_back(frame->txParameters.postfixPaddingTime);
            }
        }
 
        const auto txResult = transmitSignalInBatchedSingleBurst(frameSignalHeads, framePPDULengths, framePostfixDurations, repeat);
 
        auto totalTransmitSamples = [&] {
            size_t total{0};
            for (auto i = 0; i < framePPDULengths.size(); i++) {
                total += framePPDULengths[i] + static_cast<int64_t>(std::round(framePostfixDurations[i] * getTxSamplingRate()));
            }
            total *= repeat;
            return total;
        }();
        [[maybe_unused]] auto latestResult = getLastTxStatus();
 
        // TODO temporarily disable this field
        //  if (signalWriter) {
        //      for (auto r = 0; r < repeat; r++) {
        //          for (auto i = 0; i < framePPDULengths.size(); i++) {
        //              signalWriter->write2DStream(frameSignalHeads[i], framePPDULengths[i]);
        //              size_t zeroLength = static_cast<int64_t>(std::round(framePostfixDurations[i] * getTxSamplingRate()));
        //              signalWriter->writeZerosTo2DStream(zeroLength);
        //          }
        //      }
        //  }
 
        if (!txResult) {
            LoggingService_SDR_debug_printf("%s(%s) batch-Tx %u frames w/ %u repeat. Total Tx: %u samples (%.3f us) | 1st frame -->%s | PPDU: %u (%.3f us)", getReferredInterfaceName(), DeviceType2String(getFrontEndType()), frames.size(), repeat, totalTransmitSamples, 1e6f * totalTransmitSamples / getTxSamplingRate(), frames[0]->toString(), framePPDULengths[0], 1e6f * framePPDULengths[0] / getTxSamplingRate());
        } else {
            LoggingService_SDR_warning_printf("%s(%s) FAILED to batch-Tx %u frames w/ %u repeats. Total Tx: %u samples (%.3f us) | 1st frame -->%s | PPDU: %u (%.3f us)", getReferredInterfaceName(), DeviceType2String(getFrontEndType()), frames.size(), repeat, totalTransmitSamples, 1e6f * totalTransmitSamples / getTxSamplingRate(), frames[0]->toString(), framePPDULengths[0], 1e6f * framePPDULengths[0] / getTxSamplingRate());
        }
 
        return txResult;
    }
 
    template<int repeat = 1, typename... Frames, typename = std::enable_if_t<(std::is_same_v<std::remove_cvref_t<Frames>, ModularPicoScenesTxFrame*> && ...) || (std::is_same_v<std::remove_cvref_t<Frames>, ModularPicoScenesTxFrame> && ...) || ((std::is_same_v<std::remove_cvref_t<Frames>, std::shared_ptr<ModularPicoScenesTxFrame>> || std::is_same_v<std::remove_cvref_t<Frames>, std::unique_ptr<ModularPicoScenesTxFrame>>) && ...)>>
    [[maybe_unused]] int transmitFramesInBatch(Frames&&... frames) {
        return AbstractFrontEnd::transmitFramesInBatch<repeat>(std::forward<Frames>(frames)...);
    }
 
    //    int transmitTest(const ModularPicoScenesTxFrame &frame1, const ModularPicoScenesTxFrame &frame2) {
    //        ModularPicoScenesTxFrame t1, t2, t3;
    //        auto t4 = std::make_shared<ModularPicoScenesTxFrame>();
    //        auto t5 = std::make_shared<ModularPicoScenesTxFrame>();
    //        auto t6 = std::make_unique<ModularPicoScenesTxFrame>();
    //        auto t7 = std::make_unique<ModularPicoScenesTxFrame>();
    //        transmitFramesInBatch(t4, t6);
    //        transmitFramesInBatch(t6, t7);
    //        transmitFramesInBatch(t1, t2, t3);
    //        return transmitFramesInBatch(frame1, frame2);
    //    }
 
    virtual std::optional<double> getCurrentNoiseFloor() = 0;
 
    [[nodiscard]] virtual SDRFrontEndTxStatus getLastTxStatus() const = 0;
 
    virtual void clearTxStatus() = 0;
 
    void setTxSignalDumpFilePath(const std::string& txSignalDumpFilePathV) {
        AbstractSDRFrontEnd::txSignalDumpFilePath = txSignalDumpFilePathV;
    }
 
    void setRxSignalDumpFilePath(const std::string& rxSignalDumpFilePathV) {
        rxSignalDumpFilePath = rxSignalDumpFilePathV;
    }
 
    void setRxSignalDumpDelayedStartDuration(const double delayedStartDuration) {
        rxSignalDumpDelayedStartDuration = delayedStartDuration;
    }
 
    void setSignalReplayFilePath(const std::string& signalReplayFilePath) {
        rxSignalReplayFilePath = signalReplayFilePath;
    }
 
    void setTxSignalReplayDelayMs(const std::optional<uint32_t>& txSignalReplayDelayMs) {
        txSignalReplayDelay_ms = txSignalReplayDelayMs;
    }
 
    ChannelBandwidthEnum getRxChannelBandwidthMode() override {
        return rxCBW;
    }
 
    void setRxChannelBandwidthMode(ChannelBandwidthEnum rxCbw) override {
        rxCBW = rxCbw;
        LoggingService_SDR_info_print("<{}> sets RX channel bandwidth (CBW) to [{}].", getReferredInterfaceName(), ChannelBandwidth2String(getRxChannelBandwidthMode()));
    }
 
    void setTxIQMismatch(double iq_ratio_db, double iq_crosstalk_degree) override {
        getUserSpecifiedTxParameters().txIQAmplitudeImbalance_dB = iq_ratio_db;
        getUserSpecifiedTxParameters().txIQPhaseImbalance_rad = iq_crosstalk_degree / 360 * M_PI;
        LoggingService_SDR_info_print("<{}> sets Tx IQ mismatch ratio (DB) to [{}] and IQ crosstalk degree to [{}].", getReferredInterfaceName(), getTxIqRatioDB(), getTxIqCrossTalkDegree());
    }
 
    void setRxIQMismatch(double iq_ratio_db, double iq_crosstalk_degree) override {
        rxIQMismatchRatioDb = iq_ratio_db;
        rxIQMismatchRatioDegree = iq_crosstalk_degree;
        LoggingService_SDR_info_print("<{}> sets Rx IQ mismatch ratio (DB) to [{}] and IQ crosstalk degree to [{}].", getReferredInterfaceName(), getRxIqRatioDB(), getRxIqCrossTalkDegree());
    }
 
    double getTxIqRatioDB() override {
        return getUserSpecifiedTxParameters().txIQAmplitudeImbalance_dB;
    }
 
    double getTxIqCrossTalkDegree() override {
        return getUserSpecifiedTxParameters().txIQPhaseImbalance_rad / M_PI * 360;
    }
 
    double getRxIqRatioDB() override {
        return rxIQMismatchRatioDb;
    }
 
    double getRxIqCrossTalkDegree() override {
        return rxIQMismatchRatioDegree;
    }
 
    double getRxSensitivity() override {
        return rxSensitivity;
    }
 
    void setRxSensitivity(const double rxSensitivityV) override {
        rxSensitivity = rxSensitivityV;
        LoggingService_SDR_info_print("{}'s RX sensitivity is changed to [{}] dB.", getReferredInterfaceName(), getRxSensitivity());
    }
 
    void setCarrierFrequencyOffset4TxEncoding(double carrierFrequencyOffset) override {
        userSpecifiedTxParameters.carrierFrequencyOffset = carrierFrequencyOffset;
        LoggingService_SDR_info_print("<{}> sets TX carrier frequency offset to [{}].", getReferredInterfaceName(), *getCarrierFrequencyOffset4TxEncoding());
    }
 
    std::optional<double> getCarrierFrequencyOffset4TxEncoding() override {
        return userSpecifiedTxParameters.carrierFrequencyOffset;
    }
 
    void setSamplingFrequencyOffset4TxEncoding(double samplingFrequencyOffset) override {
        userSpecifiedTxParameters.samplingRateOffset = samplingFrequencyOffset;
        LoggingService_SDR_info_print("<{}> sets TX sampling frequency offset to [{}].", getReferredInterfaceName(), *getSamplingFrequencyOffset4TxEncoding());
    }
 
    std::optional<double> getSamplingFrequencyOffset4TxEncoding() override {
        return userSpecifiedTxParameters.samplingRateOffset;
    }
 
    void setCarrierFrequencyOffset4RxDecoding(double rxCarrierFrequencyOffsetV) override {
        rxCarrierFrequencyOffset = rxCarrierFrequencyOffsetV;
        LoggingService_SDR_info_print("<{}> sets RX carrier frequency offset to [{}].", getReferredInterfaceName(), *getCarrierFrequencyOffset4RxDecoding());
    }
 
    std::optional<double> getCarrierFrequencyOffset4RxDecoding() override {
        return rxCarrierFrequencyOffset;
    }
 
    void setSamplingFrequencyOffset4RxDecoding(double samplingFrequencyOffset) override {
        rxSamplingFrequencyOffset = samplingFrequencyOffset;
        LoggingService_SDR_info_print("<{}> sets RX sampling frequency offset to [{}].", getReferredInterfaceName(), *getSamplingFrequencyOffset4RxDecoding());
    }
 
    std::optional<double> getSamplingFrequencyOffset4RxDecoding() override {
        return rxSamplingFrequencyOffset;
    }
 
    double getSamplingRate() override {
        const auto txRate = getTxSamplingRate();
        const auto rxRate = getRxSamplingRate();
 
        if (txRate == rxRate)
            return txRate;
 
        LoggingService_SDR_warning_print(fmt::format("<{}> has different Tx and Rx sampling rates (Tx={} MHz, Rx={} MHz), return Rx rate.", getReferredInterfaceName(), txRate / 1e6, rxRate / 1e6));
        return rxRate;
    }
 
    void setSamplingRate(double samplingRate) override {
        setTxSamplingRate(samplingRate);
        setRxSamplingRate(samplingRate);
    }
 
    double getTxResampleRatio() override {
        return getUserSpecifiedTxParameters().resampleRatio;
    }
 
    void setTxResampleRatio(double txResampleRatioV) override {
        if (!txChannels.empty()) {
            getUserSpecifiedTxParameters().resampleRatio = txResampleRatioV;
            LoggingService_SDR_info_print("<{}> sets TX resample ratio to [{}].", getReferredInterfaceName(), getTxResampleRatio());
        }
    }
 
    double getRxResampleRatio() override {
        return rxResampleRatio;
    }
 
    bool isRxResampleBypassFIR() override {
        return rxResampleBypassFIR;
    }
 
    void setRxResampleBypassFIR(const bool bypass) override {
        if (!rxChannels.empty()) {
            rxResampleBypassFIR = bypass;
            LoggingService_SDR_info_print("<{}> sets RX resample bypass FIR to [{}].", getReferredInterfaceName(), isRxResampleBypassFIR());
        }
    }
 
    bool isTxSplitHighLow() override {
        return getUserSpecifiedTxParameters().splitHighLow;
    }
 
    void setTxSplitHighLow(const bool split) override {
        getUserSpecifiedTxParameters().splitHighLow = split;
    }
 
    bool isRxMergeHighLow() override {
        return mergeHighLow;
    }
 
    void setRxMergeHighLow(const bool merge) override {
        mergeHighLow = merge;
    }
 
    void setRxResampleRatio(double rxResampleRatioV) override {
        rxResampleRatio = rxResampleRatioV;
        LoggingService_SDR_info_print("<{}> sets RX resample ratio to [{}].", getReferredInterfaceName(), getRxResampleRatio());
    }
 
    double getRxOfdmSymbolOffset() override {
        return rxOFDMSymbolOffset;
    }
 
    void setRxOfdmSymbolOffset(const double rxOfdmSymbolOffset) override {
        rxOFDMSymbolOffset = rxOfdmSymbolOffset;
        LoggingService_SDR_info_print("{}'s RX OFDM Symbol Offset is changed to [{}].", getReferredInterfaceName(), getRxOfdmSymbolOffset());
    }
 
    double getNumSamplesSavedBeforeStart() override {
        return numSamplesSavedBeforeStart;
    }
 
    void getNumSamplesSavedBeforeStart(const double numSamplesSavedBeforeStartV) override {
        numSamplesSavedBeforeStart = numSamplesSavedBeforeStartV;
    }
 
    uint8_t getTxChainMask() override {
        std::bitset<8> txcmBits;
        for (const auto& txch: userSpecifiedTxChannels())
            txcmBits.set(txch, true);
 
        return txcmBits.to_ulong();
    }
 
    void setTxChainMask(const uint8_t txChainMask) override {
        std::bitset<8> txcmBits{txChainMask};
        std::vector<size_t> newTxChannels;
        for (size_t i = 0; i < txcmBits.size(); i++) {
            if (txcmBits[i])
                newTxChannels.emplace_back(i);
        }
        setTxChannels(newTxChannels);
    }
 
    uint8_t getRxChainMask() override {
        std::bitset<8> rxcmBits;
        for (const auto& rxch: userSpecifiedRxChannels())
            rxcmBits.set(rxch, true);
 
        return rxcmBits.to_ulong();
    }
 
    void setRxChainMask(const uint8_t rxChainMask) override {
        std::bitset<8> rxcmBits{rxChainMask};
        std::vector<size_t> newRxChannels;
        for (size_t i = 0; i < rxcmBits.size(); i++) {
            if (rxcmBits[i])
                newRxChannels.emplace_back(i);
        }
        setRxChannels(newRxChannels);
    }
 
    [[nodiscard]] const std::vector<size_t>& userSpecifiedTxChannels() const override {
        return txChannels;
    }
 
    [[deprecated("Use 'const std::vector<size_t>& userSpecifiedTxChannels() const' instead")]]
    std::vector<size_t> getTxChannels() override {
        return txChannels;
    }
 
    void setTxChannels(const std::vector<size_t>& txChannelsN) override {
        txChannels = txChannelsN;
        std::stringstream ss;
        // If we deliberately set empty txChannels, it means we want to disable Tx
        if (!txChannelsN.empty()) {
            std::copy(txChannels.cbegin(), txChannels.cend() - 1, std::ostream_iterator<int>(ss, ","));
            ss << txChannels.back();
            LoggingService_SDR_info_print("<{}> sets Tx-Channel to [{}].", getReferredInterfaceName(), ss.str());
        }
    }
 
    [[nodiscard]] const std::vector<size_t>& userSpecifiedRxChannels() const override {
        return rxChannels;
    }
 
    [[deprecated("Use 'const std::vector<size_t>& userSpecifiedRxChannels() const' instead")]]
    std::vector<size_t> getRxChannels() override {
        return rxChannels;
    }
 
    void setRxChannels(const std::vector<size_t>& rxChannelsN) override {
        rxChannels = rxChannelsN;
        std::stringstream ss;
        // If we deliberately set empty rxChannels, it means we want to disable Rx
        if (!rxChannelsN.empty()) {
            std::copy(rxChannels.cbegin(), rxChannels.cend() - 1, std::ostream_iterator<int>(ss, ","));
            ss << rxChannels.back();
        }
        LoggingService_SDR_info_print("<{}> sets Rx-Channel to [{}].", getReferredInterfaceName(), ss.str());
    }
 
    bool isFullDuplexEnabled() override {
        return fullDuplex;
    }
 
    void setFullDuplex(const bool enableFullDuplex) override {
        fullDuplex = enableFullDuplex;
    }
 
    [[nodiscard]] SDRFrontEndTransferType getTransferType() const override {
        return transferType;
    }
 
    void setTransferType(const SDRFrontEndTransferType transferTypeV) override {
        transferType = transferTypeV;
    }
 
    void setNumThreads4RxDecoding(const uint8_t numThreads) override {
        numDecodingThreads = numThreads;
        LoggingService_SDR_info_print("<{}> sets {}-thread parallel baseband decoding.", getReferredInterfaceName(), numDecodingThreads);
    }
 
    void printStatus() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    ExtraInfo buildExtraInfo() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    std::tuple<double, double, double> getChannelAndBandwidth() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    int setChannelAndBandwidth(double control, double bw, double center) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    int setChannelAndBandwidth(std::optional<double> control, std::optional<double> bw, std::optional<double> center) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    [[deprecated("Use 'getTxCarrierFrequencies' or 'getRxCarrierFrequencies' instead")]]
    double getCarrierFrequency() override {
        if (!userSpecifiedTxChannels().empty()) {
            return getTxCarrierFrequencies()[0];
        }
        if (!userSpecifiedRxChannels().empty()) {
            return getRxCarrierFrequencies()[0];
        }
        return 0.0;
    }
 
    void setCarrierFrequency(double carrierFrequency) override {
        if (!userSpecifiedTxChannels().empty()) {
            setTxCarrierFrequencies(std::vector<double>(userSpecifiedTxChannels().size(), carrierFrequency));
        }
        if (!userSpecifiedRxChannels().empty()) {
            setRxCarrierFrequencies(std::vector<double>(userSpecifiedRxChannels().size(), carrierFrequency));
        }
    }
 
    double getControlChannelFrequency() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setControlChannelFrequency(double controlFrequency) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    double getRxChannelBandwidth() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setRxChannelBandwidth(double rxcbw) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    double getTxpower() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setTxpower(double txpower) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    double getRxGain() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setRxGain(double rxGain) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setRxGain(double rxGain, uint8_t channel) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    uint16_t getChannelFlags() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    std::string getClockSource() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setClockSource(const std::string& clockSource) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setClockSources(const std::vector<std::string>& clockSources) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    std::vector<std::string> getClockSources() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    std::string getTimeSource() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setTimeSource(const std::string& timeSource) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setTimeSources(const std::vector<std::string>& timeSources) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    std::vector<std::string> getTimeSources() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    double getMasterClockRate() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setMasterClockRate(double masterClockRate) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    double getSDRFrontEndTime() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    std::string getTxAntenna() override {
        return getTxAntennas().at(0);
    }
 
    void setTxAntenna(const std::string& txAnt) override {
        setTxAntennas({txAnt});
    }
 
    std::string getRxAntenna() override {
        return getRxAntennas().at(0);
    }
 
    void setRxAntenna(const std::string& rxAnt) override {
        setRxAntennas({rxAnt});
    }
 
    std::vector<std::string> getTxAntennas() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setTxAntennas(const std::vector<std::string>& txAnts) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    std::vector<std::string> getRxAntennas() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setRxAntennas(const std::vector<std::string>& rxAnts) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    double getFilterBandwidth() override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
    void setFilterBandwidth(double bw) override {
        throw std::runtime_error(fmt::format("<{}> does not support operation: {}.", getReferredInterfaceName(), std::string(BOOST_CURRENT_FUNCTION)));
    }
 
protected:
    std::optional<uint32_t> txSignalReplayDelay_ms;
    std::optional<std::string> txSignalDumpFilePath;
    std::optional<std::string> rxSignalDumpFilePath;
    std::optional<double> rxSignalDumpDelayedStartDuration;
    std::optional<std::string> rxSignalReplayFilePath;
 
    bool fullDuplex{false};
    uint8_t numDecodingThreads{1};
    SDRFrontEndTransferType transferType{SDRFrontEndTransferType::CS16};
    std::vector<size_t> txChannels{}; // TwinRx has no Tx channel
    std::vector<size_t> rxChannels{}; // LFTX and BasicTx have no Rx channel
 
    ChannelBandwidthEnum rxCBW{ChannelBandwidthEnum::CBW_20};
    double rxResampleRatio{1.0};
    bool rxResampleBypassFIR{false};
    bool mergeHighLow{false};
    double rxOFDMSymbolOffset{0.75};
    double numSamplesSavedBeforeStart{5};
    double rxSensitivity{10};
    double rxIQMismatchRatioDb{0};
    double rxIQMismatchRatioDegree{0};
    std::optional<double> rxCarrierFrequencyOffset{};
    std::optional<double> rxSamplingFrequencyOffset{};
 
    // Override hardware information refresh methods
    void refreshHardwareInfoForSupportedChannels() override {
        // Default implementation - derived classes should override
    }
 
    void refreshHardwareInfoForBoards() override {
        // Default implementation - derived classes should override
        // boardInfo.motherboardSerial = SDRSerialNumber;
        // boardInfo.motherboardModel = SDRHWName;
        // boardInfo.fpgaImageFlavor = SDRHWType;
    }
 
    void refreshHardwareInfoForSupportedAntennas() override {
        // Default implementation - derived classes should override
    }
 
    void refreshHardwareInfoForGainRanges() override {
        // Derived classes should override this
    }
 
    void refreshHardwareInfoForFrequencyRanges() override {
        // Derived classes should override this
    }
 
    void refreshHardwareInfoForSamplingRateRanges() override {
        // Derived classes should override this
    }
 
    void refreshHardwareInfoForMasterClockRates() override {
        // Default implementation - derived classes should override
    }
 
    void refreshHardwareInfoForClockAndTimeSources() override {
        // Default implementation - derived classes should override
    }
 
    void refreshHardwareInfoForSensors() override {
        // Derived classes should override this
    }
 
    void refreshHardwareInfoForTemperatures() override {
        // Derived classes should override this
    }
 
    void refreshHardwareInfoForAGCSupport() override {
        // Derived classes should override this
    }
 
    void refreshHardwareInfoForFrontEndProfiles() override {
        // Derived classes should override this
    }
};
 
#endif // PICOSCENES_PLATFORM_ABSTRACTSDRFRONTEND_HXX