VirtualSDRFrontEnd.hxx

Go to the documentation of this file.

//
// Created by Zhiping Jiang on 5/4/21.
//
 
#ifndef PICOSCENES_PLATFORM_VIRTUALSDRFRONTEND_HXX
#define PICOSCENES_PLATFORM_VIRTUALSDRFRONTEND_HXX
 
#include <thread>
#include "AbstractSDRFrontEnd.hxx"
 
class VirtualSDRFrontEnd : virtual public AbstractSDRFrontEnd {
public:
    static std::shared_ptr<VirtualSDRFrontEnd> getInstance(const std::string& referredInterfaceName);
 
    int32_t transmitSignals(const std::vector<const void*>& signals, int64_t bufferLength, double postfixDuration) override {
        // VirtualSDR does not perform actual transmission
        return 0;
    }
 
    ExtraInfo buildExtraInfo() override {
        ExtraInfo extraInfo;
        return extraInfo;
    }
 
    void printStatus() override {
        LoggingService_Frontend_info_printf("[VirtualSDR(%s)]: cf=%.4fMHz, sf=%.4fMHz, mode=%s, txcm = %u, rxcm = %u, txpower = %0.f\n", getReferredInterfaceName(),
                                   getRxCarrierFrequencies()[0] / 1e6, getSamplingRate() / 1e6, channelModel2String(channelFlags2ChannelMode(getChannelFlags())), getTxChainMask(), getRxChainMask(), getTxpower());
    }
 
    std::tuple<double, double, double> getChannelAndBandwidth() override {
        // Virtual SDR does not manage real channel information
        return std::tuple<double, double, double>();
    }
 
    int setChannelAndBandwidth(double center, double bw, double control) override { return 0; }
 
    int setChannelAndBandwidth(std::optional<double> control, std::optional<double> bw, std::optional<double> center) override {
        return 0;
    }
 
    bool isHardwareSupportedPreset(const std::string& presetName) override {
        // Support all presets
        return true;
    }
 
    void applyPreset(const std::string& presetName, bool skipChangeRate) override {
        // Convert preset name to uppercase for case-insensitive comparison
        std::string upperPresetName = boost::to_upper_copy(presetName);
 
        // First check if preset exists and is supported by hardware
        if (!isHardwareSupportedPreset(upperPresetName)) {
            throw std::invalid_argument(fmt::format("Preset '{}' is not supported by the current USRP device type.", presetName));
        }
 
        // Get the preset from the preset map
        const auto& preset = FrontEndModePreset::getPresetMap().at(upperPresetName);
        userSpecifiedTxParameters.applyPreset(upperPresetName);
 
        if (preset->txCBW.has_value()) {
            if (!skipChangeRate)
                setTxSamplingRate(preset->txCBW.value() * 1e6);
            setTxResampleRatio(1.0); // Virtual SDR doesn't actually resample
        }
 
        if (preset->rxCBW.has_value()) {
            if (!skipChangeRate)
                setRxSamplingRate(preset->rxCBW.value() * 1e6);
            setRxResampleRatio(1.0); // Virtual SDR doesn't actually resample
            setRxChannelBandwidthMode(static_cast<ChannelBandwidthEnum>(preset->rxCBW.value()));
        }
    }
 
    void setTxCarrierFrequencies(std::vector<double> carrierFreqsV) override {
        if (!carrierFreqsV.empty()) {
            carrierFrequency = carrierFreqsV[0];
        }
    }
 
    void setRxCarrierFrequencies(std::vector<double> carrierFreqsV) override {
        if (!carrierFreqsV.empty()) {
            carrierFrequency = carrierFreqsV[0];
        }
    }
 
    std::vector<double> getTxCarrierFrequencies() override {
        return {carrierFrequency};
    }
 
    std::vector<double> getRxCarrierFrequencies() override {
        return {carrierFrequency};
    }
 
    double getTxSamplingRate() override {
        return txSamplingRate;
    }
 
    double getRxSamplingRate() override {
        return rxSamplingRate;
    }
 
    void setTxSamplingRate(double txRate) override {
        txSamplingRate = txRate;
    }
 
    void setRxSamplingRate(double rxRate) override {
        rxSamplingRate = rxRate;
    }
 
    double getControlChannelFrequency() override {
        return controlFrequency;
    }
 
    void setControlChannelFrequency(const double controlFrequencyV) override {
        controlFrequency = controlFrequencyV;
    }
 
    double getTxpower() override {
        return txpower;
    }
 
    void setTxpower(const double txpowerV) override {
        txpower = txpowerV;
    }
 
    double getRxGain() override {
        return rxGain;
    }
 
    void setRxGain(const double rxGainV) override {
        rxGain = rxGainV;
    }
 
    void setRxGain(const double rxGainV, uint8_t channel) override {
        rxGain = rxGainV; // VirtualSDR has only one global gain setting
    };
 
    bool supportAGC() override {
        return false;
    }
 
    void setAGC(bool enableAGC) override {
        // VirtualSDR does not support AGC
    }
 
    uint16_t getChannelFlags() override {
        return channelFlags;
    }
 
    std::string getClockSource() override {
        return clockSource;
    }
 
    void setClockSource(const std::string& clockSourceV) override {
        clockSource = clockSourceV;
    }
 
    std::string getTimeSource() override {
        return timeSource;
    }
 
    void setTimeSource(const std::string& timeSourceV) override {
        timeSource = timeSourceV;
    }
 
    double getMasterClockRate() override {
        return masterClockRate;
    }
 
    void setMasterClockRate(const double masterClockRateV) override {
        masterClockRate = masterClockRateV;
    }
 
    double getSDRFrontEndTime() override {
        // Return a simulated timestamp, e.g., system time
        return std::chrono::system_clock::now().time_since_epoch().count();
    }
 
    std::vector<std::string> getTxAntennas() override {
        return txAntennas;
    }
 
    void setTxAntennas(const std::vector<std::string>& txAnts) override {
        txAntennas = txAnts;
    }
 
    std::vector<std::string> getRxAntennas() override {
        return rxAntennas;
    }
 
    void setRxAntennas(const std::vector<std::string>& rxAnts) override {
        rxAntennas = rxAnts;
    }
 
    double getFilterBandwidth() override {
        return filterBandwidth;
    }
 
    void setFilterBandwidth(const double bw) override {
        filterBandwidth = bw;
    }
 
protected:
    double carrierFrequency = 2412e6; 
    double txSamplingRate = 20e6;     
    double rxSamplingRate = 20e6;     
    double controlFrequency = 2412e6; 
    double txpower = 10;              
    double rxGain = 30;               
    uint16_t channelFlags{};          
    std::string clockSource;          
    std::string timeSource;           
    std::optional<double> rxCarrierFrequencyOffset = std::nullopt; 
    ChannelBandwidthEnum rxCBW = ChannelBandwidthEnum::CBW_20; 
    double masterClockRate = 100e6;   
    std::vector<std::string> txAntennas{"TX/RX"}; 
    std::vector<std::string> rxAntennas{"RX2"};   
    double filterBandwidth = 40e6;    
 
    explicit VirtualSDRFrontEnd(const std::string& referredInterfaceName) : AbstractSDRFrontEnd(referredInterfaceName) {}
};
 
 
#endif //PICOSCENES_PLATFORM_VIRTUALSDRFRONTEND_HXX