SDRFrontEndConfigurations.hxx

Go to the documentation of this file.

//
// Created by Zhiping Jiang on 5/2/21.
//
 
#ifndef PICOSCENES_PLATFORM_SDRFRONTENDCONFIGURATIONS_HXX
#define PICOSCENES_PLATFORM_SDRFRONTENDCONFIGURATIONS_HXX
 
#include "FrontEndConfigurations.hxx"
 
enum class SDRFrontEndTransferType : uint8_t {
    CS8 = 8,      
    CS16 = 16,    
};
 
struct SDRFrontEndTxStatus {
    bool valid{false};                  
    bool error{false};                  
    double txTime{0.0};                 
    double scheduledTime{0.0};          
    double systemDelay{0.0};            
    int eventCode{0};                   
    int numACKs{0};                     
    size_t scheduledTxLength{0};        
    size_t actualTxLength{0};           
    PicoScenesDeviceType deviceType{PicoScenesDeviceType::Unknown};           
    PicoScenesDeviceSubtype subType{PicoScenesDeviceSubtype::Unknown};       
};
 
struct SDRFrontEndRxStatus {
    bool valid{false};                  
    bool error{false};                  
    bool hasTime{false};                
    double rxStartTime{0.0};            
    int errorCode{0};                   
    int64_t numReceived{0};             
    PicoScenesDeviceType deviceType{PicoScenesDeviceType::Unknown};           
    PicoScenesDeviceSubtype subType{PicoScenesDeviceSubtype::Unknown};       
};
 
struct PipelineConfig {
    std::vector<size_t> rx_channel;
    double rx_resample_ratio{1};
    int rx_cbw{20};
    double rx_iq_mismatch_mag{0},rx_iq_mismatch_phase{0};
    int mt{1};
    double cfo{0},sfo{0};
};
class SDRFrontEndBasebandConfigurations {
public:
    virtual ~SDRFrontEndBasebandConfigurations() = default;
 
    virtual double getRxSensitivity() = 0;
 
    virtual void setRxSensitivity(double rxSensitivity) = 0;
 
    virtual bool isRxResampleBypassFIR() = 0;
 
    virtual void setRxResampleBypassFIR(bool bypass) = 0;
 
    virtual bool isTxSplitHighLow() = 0;
 
    virtual void setTxSplitHighLow(bool split) = 0;
 
    virtual bool isRxMergeHighLow() = 0;
 
    virtual void setRxMergeHighLow(bool merge) = 0;
 
    virtual std::optional<double> getCarrierFrequencyOffset4TxEncoding() = 0;
 
    virtual void setCarrierFrequencyOffset4TxEncoding(double carrierFrequencyOffset) = 0;
 
    virtual std::optional<double> getSamplingFrequencyOffset4TxEncoding() = 0;
 
    virtual void setSamplingFrequencyOffset4TxEncoding(double samplingFrequencyOffset) = 0;
 
    virtual std::optional<double> getCarrierFrequencyOffset4RxDecoding() = 0;
 
    virtual void setCarrierFrequencyOffset4RxDecoding(double carrierFrequencyOffset) = 0;
 
    virtual std::optional<double> getSamplingFrequencyOffset4RxDecoding() = 0;
 
    virtual void setSamplingFrequencyOffset4RxDecoding(double samplingFrequencyOffset) = 0;
 
    virtual double getTxResampleRatio() = 0;
 
    virtual void setTxResampleRatio(double txResampleRatio) = 0;
 
    virtual double getRxResampleRatio() = 0;
 
    virtual void setRxResampleRatio(double rxResampleRatio) = 0;
 
    virtual double getSDRFrontEndTime() = 0;
 
    virtual ChannelBandwidthEnum getRxChannelBandwidthMode() = 0;
 
    virtual void setRxChannelBandwidthMode(ChannelBandwidthEnum rxCbw) = 0;
 
    virtual void setTxIQMismatch(double iq_ratio_db, double iq_crosstalk_degree) = 0;
 
    virtual void setRxIQMismatch(double iq_ratio_db, double iq_crosstalk_degree) = 0;
 
    virtual double getTxIqRatioDB() = 0;
 
    virtual double getTxIqCrossTalkDegree() = 0;
 
    virtual double getRxIqRatioDB() = 0;
 
    virtual double getRxIqCrossTalkDegree() = 0;
 
    virtual bool isFullDuplexEnabled() = 0;
 
    virtual void setFullDuplex(bool enableFullduplex) = 0;
 
    virtual double getRxOfdmSymbolOffset() = 0;
 
    virtual void setRxOfdmSymbolOffset(double rxOfdmSymbolOffset) = 0;
 
    virtual double getNumSamplesSavedBeforeStart() = 0;
 
    virtual void getNumSamplesSavedBeforeStart(double numSamplesSavedBeforeStart) = 0;
 
    [[nodiscard]] virtual bool isReturnBasebandSignals() const = 0;
 
    [[nodiscard]] virtual bool useConventionalPacketDetector() const = 0;
};
 
class SDRFrontEndConfigurations : public SDRFrontEndBasebandConfigurations {
public:
    virtual void initializeSDR() = 0;
 
    [[nodiscard]] virtual const std::vector<size_t>& userSpecifiedTxChannels() const = 0;
 
    [[nodiscard]] virtual const std::vector<size_t>& userSpecifiedRxChannels() const = 0;
 
    virtual void setTxCarrierFrequencies(std::vector<double> carrierFreqs) = 0;
 
    virtual void setRxCarrierFrequencies(std::vector<double> carrierFreqs) = 0;
 
    virtual std::vector<double> getTxCarrierFrequencies() = 0;
 
    virtual std::vector<double> getRxCarrierFrequencies() = 0;
 
    virtual void setTxSamplingRate(double txRate) = 0;
 
    virtual void setRxSamplingRate(double rxRate) = 0;
 
    virtual double getTxSamplingRate() = 0;
 
    virtual double getRxSamplingRate() = 0;
 
    virtual bool supportAGC() = 0;
 
    virtual void setAGC(bool enableAGC) = 0;
 
    virtual std::string getTxAntenna() = 0;
 
    virtual std::string getRxAntenna() = 0;
 
    virtual void setTxAntenna(const std::string& txAnt) = 0;
 
    virtual void setRxAntenna(const std::string& rxAnt) = 0;
 
    virtual std::vector<std::string> getTxAntennas() = 0;
 
    virtual std::vector<std::string> getRxAntennas() = 0;
 
    virtual void setTxAntennas(const std::vector<std::string>& txAnts) = 0;
 
    virtual void setRxAntennas(const std::vector<std::string>& rxAnts) = 0;
 
    virtual double getFilterBandwidth() = 0;
 
    virtual void setFilterBandwidth(double bw) = 0;
 
    virtual std::string getClockSource() = 0;
 
    virtual void setClockSource(const std::string& clockSource) = 0;
 
    virtual void setClockSources(const std::vector<std::string>& clockSources) = 0;
 
    virtual std::vector<std::string> getClockSources() = 0;
 
    virtual std::string getTimeSource() = 0;
 
    virtual void setTimeSource(const std::string& timeSource) = 0;
 
    virtual void setTimeSources(const std::vector<std::string>& timeSources) = 0;
 
    virtual std::vector<std::string> getTimeSources() = 0;
 
    virtual double getMasterClockRate() = 0;
 
    virtual void setMasterClockRate(double masterClockRate) = 0;
 
    [[nodiscard]] virtual SDRFrontEndTransferType getTransferType() const = 0;
 
    virtual void setTransferType(SDRFrontEndTransferType transferType) = 0;
 
    virtual void setNumThreads4RxDecoding(uint8_t numThreads) = 0;
 
    [[nodiscard]] virtual double getRxBufferDuration() const = 0;
 
    virtual void skipMPDUDecoding4HESUHighDopplerFrame(bool skipDataDecoding) = 0;
 
    virtual void setRxPipelineChannels(std::vector<std::vector<size_t>> PipelineChannels) = 0;
 
    virtual std::vector<std::vector<size_t>> getRxPipelineChannels() = 0;
 
    virtual void setPinelineConfig(std::vector<PipelineConfig> cfgs) = 0;
 
    virtual std::vector<PipelineConfig> getPinelineConfig() = 0;
};
 
#endif //PICOSCENES_PLATFORM_SDRFRONTENDCONFIGURATIONS_HXX