SDRHardwareInformation.hxx

Go to the documentation of this file.

//
// Created by Zhiping Jiang on 2024/1/24.
//
 
#ifndef PICOSCENES_PLATFORM_SDRFRONTENDHARDWAREINFORMATION_HXX
#define PICOSCENES_PLATFORM_SDRFRONTENDHARDWAREINFORMATION_HXX
 
#include <vector>
#include <string>
#include <map>
#include <cstdint>
#include "PicoScenesCommons.hxx"
 
// Device combination types
enum class SDRDeviceCombinationType: uint8_t {
    None = 0, // Single device, no combination
    MIMOCable = 1, // Combined via MIMO cable
    Ethernet = 2 // Combined via Ethernet
};
 
// Ethernet connection interface with detailed information
struct SDREthernetConnectionInterface {
    bool isPrimary{false}; // Whether this is the primary interface
    std::string ipAddress{}; // Device IP address
    std::string hostInterfaceName{}; // Host interface name (e.g., eth0, eth1)
    std::string hostPortAddress{}; // IP address of the host-side port
    int linkSpeed{-1}; // Link speed in Mbps
    int MTU{-1}; // Interface MTU
    int txRingBufferDelta{0}; // Tx buffer adjustment
    int rxRingBufferDelta{0}; // Rx buffer adjustment
};
 
struct SDRConnectionProfile {
    enum class SDRConnectionType: uint8_t {
        Ethernet = 0,
        USB = 1,
        PCIe = 2,
        UnSpecified = 255
    };
 
    SDRConnectionType connectionType{SDRConnectionType::UnSpecified};
    std::vector<SDREthernetConnectionInterface> ethernetInterfaces{};
 
    // Device combination information
    SDRDeviceCombinationType combinationType{SDRDeviceCombinationType::None};
    uint8_t combinedDeviceCount{1}; // Total number of devices in the combination
    uint8_t deviceIndexInCombination{0}; // Index of this device in the combination (0 for primary)
    std::string combinationIdentifier{}; // Unique identifier for this combination (e.g., MIMO cable ID or combination group name)
 
    // Convenience methods
    [[nodiscard]] const SDREthernetConnectionInterface* getPrimaryInterface() const {
        if (connectionType != SDRConnectionType::Ethernet) return nullptr;
        auto it = std::find_if(ethernetInterfaces.begin(), ethernetInterfaces.end(),
                               [](const auto& iface) { return iface.isPrimary; });
        if (it != ethernetInterfaces.end()) {
            return &(*it);
        }
        return ethernetInterfaces.empty() ? nullptr : &ethernetInterfaces.front();
    }
 
    [[nodiscard]] bool isDualConnection() const {
        return ethernetInterfaces.size() > 1;
    }
};
 
struct SDRFrontEndProfile {
    std::string serialNumber{};
    std::string motherboardSerial{};
    std::string frontendHardwareModel{};
    std::vector<uint8_t> txChannelNumber{};
    std::vector<uint8_t> rxChannelNumber{};
 
    [[nodiscard]] int getNumTx() const { return txChannelNumber.size(); }
    [[nodiscard]] int getNumRx() const { return rxChannelNumber.size(); }
};
 
struct SDRDaughterboardProfile {
    std::string serialNumber{}; // Daughterboard serial number
    std::string model{}; // Daughterboard model
    std::vector<std::shared_ptr<SDRFrontEndProfile>> frontends{}; // FrontEnds on this daughterboard
};
 
struct SDRMainBoardInfo {
    std::string name;
    std::string serial{};
    std::string model{};
    std::string resource{};
    std::string fpgaImage{};
    PicoScenesDeviceType deviceType{PicoScenesDeviceType::Unknown};
    PicoScenesDeviceSubtype deviceSubtype{PicoScenesDeviceSubtype::Unknown};
    uint16_t deviceOrder{0};  // The order in the original device list
    SDRConnectionProfile connectionProfile; // Connection profile of the board
    std::map<std::string, std::string> inverseMap{};  // Maps identifiers to their types
    std::vector<SDRMainBoardInfo> otherBoards{};  // Connected boards that form a bigger virtual board
 
    void merge(const SDRMainBoardInfo& other) {
        // Add the other board to otherBoards
        otherBoards.push_back(other);
    }
 
    [[nodiscard]] size_t getTotalBoardCount() const {
        return 1 + otherBoards.size();  // Current board + other connected boards
    }
 
    void buildInverseMap() {
        // Clear existing map
        inverseMap.clear();
        
        // Add basic identifiers
        if (!serial.empty()) inverseMap[serial] = "serial";
        if (!name.empty()) inverseMap[name] = "name";
        if (!resource.empty()) inverseMap[resource] = "resource";
 
        // Add ethernet addresses if present
        if (connectionProfile.connectionType == SDRConnectionProfile::SDRConnectionType::Ethernet) {
            for (const auto& interface : connectionProfile.ethernetInterfaces) {
                if (!interface.ipAddress.empty() && !inverseMap.contains(interface.ipAddress)) {
                    inverseMap[interface.ipAddress] = "addr";
                }
            }
        }
    }
};
 
class SDRDeviceHardwareInformation {
public:
    virtual std::vector<SDRMainBoardInfo> getAllHardwareBoards(bool refresh = false) {
        if (refresh || boardInfoChanged) {
            refreshHardwareInfoForBoards();
            boardInfoChanged = false;
        }
        std::vector<SDRMainBoardInfo> allBoards{boardInfo};
        allBoards.insert(allBoards.end(), boardInfo.otherBoards.begin(), boardInfo.otherBoards.end());
        return allBoards;
    }
 
    virtual const SDRMainBoardInfo& getHardwareBoardByIndex(size_t boardIndex, bool refresh = false) {
        if (refresh || boardInfoChanged) {
            refreshHardwareInfoForBoards();
            boardInfoChanged = false;
        }
        if (boardIndex == 0) return boardInfo;
        if (boardIndex - 1 >= boardInfo.otherBoards.size()) {
            throw std::out_of_range("Board index out of range");
        }
        return boardInfo.otherBoards[boardIndex - 1];
    }
 
    virtual size_t getHardwareBoardCount(bool refresh = false) {
        if (refresh || boardInfoChanged) {
            refreshHardwareInfoForBoards();
            boardInfoChanged = false;
        }
        return boardInfo.getTotalBoardCount();
    }
 
    virtual const SDRMainBoardInfo& getHardwareBoardInfo(bool refresh = false) {
        if (refresh || boardInfoChanged) {
            refreshHardwareInfoForBoards();
            boardInfoChanged = false;
        }
        return boardInfo;
    }
 
    virtual const std::vector<uint8_t>& getHardwareSupportedTxChannels(bool refresh = false) {
        if (refresh || supportedChannelsChanged) {
            refreshHardwareInfoForSupportedChannels();
            supportedChannelsChanged = false;
        }
        return supportedTxChannels;
    }
 
    virtual const std::vector<uint8_t>& getHardwareSupportedRxChannels(bool refresh = false) {
        if (refresh || supportedChannelsChanged) {
            refreshHardwareInfoForSupportedChannels();
            supportedChannelsChanged = false;
        }
        return supportedRxChannels;
    }
 
    virtual const std::vector<std::string>& getHardwareSupportedTxAntennas(uint8_t channel, bool refresh = false) {
        if (refresh || supportedAntennasChanged) {
            refreshHardwareInfoForSupportedAntennas();
            supportedAntennasChanged = false;
        }
        return supportedTxAntennas.at(channel);
    }
 
    virtual const std::vector<std::string>& getHardwareSupportedRxAntennas(uint8_t channel, bool refresh = false) {
        if (refresh || supportedAntennasChanged) {
            refreshHardwareInfoForSupportedAntennas();
            supportedAntennasChanged = false;
        }
        return supportedRxAntennas.at(channel);
    }
 
    virtual const std::vector<std::vector<std::string>>& getHardwareSupportedTxAntennas(bool refresh = false) {
        if (refresh || supportedAntennasMapChanged) {
            refreshHardwareInfoForSupportedAntennas();
            supportedAntennasMapChanged = false;
        }
        return supportedTxAntennas;
    }
 
    virtual const std::vector<std::vector<std::string>>& getHardwareSupportedRxAntennas(bool refresh = false) {
        if (refresh || supportedAntennasMapChanged) {
            refreshHardwareInfoForSupportedAntennas();
            supportedAntennasMapChanged = false;
        }
        return supportedRxAntennas;
    }
 
    virtual const std::pair<double, double>& getHardwareTxGainRange(uint8_t channel, bool refresh = false) {
        if (refresh || gainRangesChanged) {
            refreshHardwareInfoForGainRanges();
            gainRangesChanged = false;
        }
        return txGainRanges.at(channel);
    }
 
    virtual const std::pair<double, double>& getHardwareRxGainRange(uint8_t channel, bool refresh = false) {
        if (refresh || gainRangesChanged) {
            refreshHardwareInfoForGainRanges();
            gainRangesChanged = false;
        }
        return rxGainRanges.at(channel);
    }
 
    virtual const std::vector<std::pair<double, double>>& getHardwareTxGainRanges(bool refresh = false) {
        if (refresh || gainRangesMapChanged) {
            refreshHardwareInfoForGainRanges();
            gainRangesMapChanged = false;
        }
        return txGainRanges;
    }
 
    virtual const std::vector<std::pair<double, double>>& getHardwareRxGainRanges(bool refresh = false) {
        if (refresh || gainRangesMapChanged) {
            refreshHardwareInfoForGainRanges();
            gainRangesMapChanged = false;
        }
        return rxGainRanges;
    }
 
    virtual const std::pair<double, double>& getHardwareTxFrequencyRange(uint8_t channel, bool refresh = false) {
        if (refresh || frequencyRangesChanged) {
            refreshHardwareInfoForFrequencyRanges();
            frequencyRangesChanged = false;
        }
        return txFrequencyRanges.at(channel);
    }
 
    virtual const std::pair<double, double>& getHardwareRxFrequencyRange(uint8_t channel, bool refresh = false) {
        if (refresh || frequencyRangesChanged) {
            refreshHardwareInfoForFrequencyRanges();
            frequencyRangesChanged = false;
        }
        return rxFrequencyRanges.at(channel);
    }
 
    virtual const std::vector<std::pair<double, double>>& getHardwareTxFrequencyRanges(bool refresh = false) {
        if (refresh || frequencyRangesMapChanged) {
            refreshHardwareInfoForFrequencyRanges();
            frequencyRangesMapChanged = false;
        }
        return txFrequencyRanges;
    }
 
    virtual const std::vector<std::pair<double, double>>& getHardwareRxFrequencyRanges(bool refresh = false) {
        if (refresh || frequencyRangesMapChanged) {
            refreshHardwareInfoForFrequencyRanges();
            frequencyRangesMapChanged = false;
        }
        return rxFrequencyRanges;
    }
 
    virtual const std::pair<double, double>& getHardwareTxSamplingRateRange(uint8_t channel, bool refresh = false) {
        if (refresh || samplingRateRangesChanged) {
            refreshHardwareInfoForSamplingRateRanges();
            samplingRateRangesChanged = false;
        }
        return txSamplingRateRanges.at(channel);
    }
 
    virtual const std::pair<double, double>& getHardwareRxSamplingRateRange(uint8_t channel, bool refresh = false) {
        if (refresh || samplingRateRangesChanged) {
            refreshHardwareInfoForSamplingRateRanges();
            samplingRateRangesChanged = false;
        }
        return rxSamplingRateRanges.at(channel);
    }
 
    virtual const std::vector<std::pair<double, double>>& getHardwareTxSamplingRateRanges(bool refresh = false) {
        if (refresh || samplingRateRangesMapChanged) {
            refreshHardwareInfoForSamplingRateRanges();
            samplingRateRangesMapChanged = false;
        }
        return txSamplingRateRanges;
    }
 
    virtual const std::vector<std::pair<double, double>>& getHardwareRxSamplingRateRanges(bool refresh = false) {
        if (refresh || samplingRateRangesMapChanged) {
            refreshHardwareInfoForSamplingRateRanges();
            samplingRateRangesMapChanged = false;
        }
        return rxSamplingRateRanges;
    }
 
    virtual const std::vector<double>& getHardwareSupportedMasterClockRates(bool refresh = false) {
        if (refresh || masterClockRatesChanged) {
            refreshHardwareInfoForMasterClockRates();
            masterClockRatesChanged = false;
        }
        return supportedMasterClockRates;
    }
 
    virtual const std::vector<std::string>& getHardwareSupportedClockAndTimeSources(bool refresh = false) {
        if (refresh || clockAndTimeSourcesChanged) {
            refreshHardwareInfoForClockAndTimeSources();
            clockAndTimeSourcesChanged = false;
        }
        return supportedClockAndTimeSources;
    }
 
    virtual const std::vector<std::string>& getHardwareSupportedSensors(uint8_t channel, bool refresh = false) {
        if (refresh || sensorsChanged) {
            refreshHardwareInfoForSensors();
            sensorsChanged = false;
        }
        return supportedSensors.at(channel);
    }
 
    virtual const std::vector<std::vector<std::string>>& getAllHardwareSupportedSensors(bool refresh = false) {
        if (refresh || sensorsMapChanged) {
            refreshHardwareInfoForSensors();
            sensorsMapChanged = false;
        }
        return supportedSensors;
    }
 
    virtual const std::vector<double>& getHardwareTemperatures(bool refresh = false) {
        if (refresh || temperaturesChanged) {
            refreshHardwareInfoForTemperatures();
        }
        return temperatureReadings;
    }
 
    virtual bool getHardwareAGCSupport(uint8_t channel, bool refresh = false) {
        if (refresh || agcSupportChanged) {
            refreshHardwareInfoForAGCSupport();
            agcSupportChanged = false;
        }
        return agcSupport.at(channel);
    }
 
    virtual const std::vector<bool>& getHardwareAGCSupport(bool refresh = false) {
        if (refresh || agcSupportMapChanged) {
            refreshHardwareInfoForAGCSupport();
            agcSupportMapChanged = false;
        }
        return agcSupport;
    }
 
    virtual const std::shared_ptr<SDRFrontEndProfile>& getHardwareFrontEndProfile(uint8_t channel, bool refresh = false) {
        if (refresh || frontendProfilesChanged) {
            refreshHardwareInfoForFrontEndProfiles();
            frontendProfilesChanged = false;
        }
        return frontendProfiles.at(channel);
    }
 
    virtual const std::vector<std::shared_ptr<SDRFrontEndProfile>>& getHardwareFrontEndProfiles(bool refresh = false) {
        if (refresh || frontendProfilesChanged) {
            refreshHardwareInfoForFrontEndProfiles();
            frontendProfilesChanged = false;
        }
        return frontendProfiles;
    }
 
    virtual const SDRDaughterboardProfile& getHardwareDaughterboardProfile(size_t index, bool refresh = false) {
        if (refresh || frontendProfilesChanged) {
            refreshHardwareInfoForFrontEndProfiles();
            frontendProfilesChanged = false;
        }
        return daughterboardProfiles.at(index);
    }
 
    virtual const std::vector<SDRDaughterboardProfile>& getHardwareDaughterboardProfiles(bool refresh = false) {
        if (refresh || frontendProfilesChanged) {
            refreshHardwareInfoForFrontEndProfiles();
            frontendProfilesChanged = false;
        }
        return daughterboardProfiles;
    }
 
    virtual void refreshAllHardwareInfo() {
        refreshHardwareInfoForBoards();
        refreshHardwareInfoForConnectionProfile();
        refreshHardwareInfoForFrontEndProfiles();
        refreshHardwareInfoForSupportedChannels();
        refreshHardwareInfoForSupportedAntennas();
        refreshHardwareInfoForGainRanges();
        refreshHardwareInfoForFrequencyRanges();
        refreshHardwareInfoForSamplingRateRanges();
        refreshHardwareInfoForMasterClockRates();
        refreshHardwareInfoForClockAndTimeSources();
        refreshHardwareInfoForSensors();
        refreshHardwareInfoForTemperatures();
        refreshHardwareInfoForAGCSupport();
    }
 
    std::string hardwareInformationSheet() {
        std::ostringstream info;
        const auto& board = getHardwareBoardInfo();
 
        // Get maximum line width for border
        size_t maxWidth = 100;  // wider width for better readability
 
        // Top border
        info << "\n" << std::string(maxWidth, '*') << "\n";
        // Print information for each board
        const auto& boards = getAllHardwareBoards();
        for (size_t i = 0; i < boards.size(); i++) {
            const auto& board = boards[i];
            info << "* Board " << i << ": " << board.name
                    << " [Serial: " << board.serial
                    << ", Model: " << board.model 
                    << ", FPGA: " << board.fpgaImage
                    << ", Subtype: " << DeviceSubtype2String(board.deviceSubtype) << "]\n";
 
            // Print connectivity information
            const auto& conn = board.connectionProfile;
            info << "* Connection: " << (conn.connectionType == SDRConnectionProfile::SDRConnectionType::Ethernet ? 
                                       "Ethernet" :
                                       conn.connectionType == SDRConnectionProfile::SDRConnectionType::PCIe ? "PCIe" :
                                       conn.connectionType == SDRConnectionProfile::SDRConnectionType::USB ? "USB" : "Unknown") << "\n";
 
            if (conn.connectionType == SDRConnectionProfile::SDRConnectionType::Ethernet) {
                for (const auto& eth : conn.ethernetInterfaces) {
                    info << "*   Interface: " << eth.hostInterfaceName
                         << "=" << eth.ipAddress << "  Speed=" << eth.linkSpeed / 1000 << "GbE  MTU=" << eth.MTU << "\n";
                }
            }
        }
 
        // Section separator
        info << "*" << std::string(maxWidth-2, '-') << "\n";
        const auto& masterClockRates = getHardwareSupportedMasterClockRates();
        info << "* Supported Master Clock Rates: [";
        if (!masterClockRates.empty()) {
            auto minRate = *std::min_element(masterClockRates.begin(), masterClockRates.end()) / 1e6;
            auto maxRate = *std::max_element(masterClockRates.begin(), masterClockRates.end()) / 1e6;
            info << minRate << " MHz, " << maxRate << " MHz";
        }
        info << "]\n";
        info << "* Available Channel #: Tx (Transmit)=";
        const auto& txChannels = getHardwareSupportedTxChannels();
        if (txChannels.empty()) {
            info << "N/A";
        } else {
            info << "[";
            for (size_t chIndex = 0; chIndex < txChannels.size(); ++chIndex) {
                info << (chIndex == 0 ? "" : ", ") << static_cast<int>(txChannels[chIndex]);
            }
            info << "]";
        }
        info << ", and Rx (Receive)=";
        const auto& rxChannels = getHardwareSupportedRxChannels();
        if (rxChannels.empty()) {
            info << "N/A";
        } else {
            info << "[";
            for (size_t chIndex = 0; chIndex < rxChannels.size(); ++chIndex) {
                info << (chIndex == 0 ? "" : ", ") << static_cast<int>(rxChannels[chIndex]);
            }
            info << "]";
        }
        info << "\n";
 
        // Section separator
        info << "*" << std::string(maxWidth-2, '-') << "\n";
 
        // Combined Channel-Frontend-Antenna Mapping section
        info << "* <Motherboard -> Channel # (Tx/Rx) -> Tx/Rx FrontEnd -> Available Antennas> Mapping: \n";
 
        // Process Tx channels
        const auto& frontendProfiles = getHardwareFrontEndProfiles();
        const auto& daughterboards = getHardwareDaughterboardProfiles();
        
        // Helper function to get motherboard info for a frontend
        auto getMboardInfo = [&](const std::string& frontendSerial) -> std::string {
            for (const auto& db : daughterboards) {
                for (const auto& fe : db.frontends) {
                    if (fe->serialNumber == frontendSerial) {
                        return fe->motherboardSerial + " (" + 
                               DeviceSubtype2String(board.deviceSubtype) + ")";
                    }
                }
            }
            return "N/A";
        };
        
        for (size_t i = 0; i < txChannels.size(); i++) {
            uint8_t ch = txChannels[i];
            
            // Start with motherboard info
            info << "* ";
            
            // Frontend info to get motherboard info
            std::string frontendSerial;
            for (const auto& profile : frontendProfiles) {
                if (std::find(profile->txChannelNumber.begin(), profile->txChannelNumber.end(), ch) != profile->txChannelNumber.end()) {
                    frontendSerial = profile->serialNumber;
                    break;
                }
            }
            
            // Print motherboard info
            info << getMboardInfo(frontendSerial) << " -> ";
            
            // Channel info
            info << static_cast<int>(ch) << " (Tx) -> ";
            
            // Frontend info
            bool foundFrontend = false;
            for (const auto& profile : frontendProfiles) {
                if (std::find(profile->txChannelNumber.begin(), profile->txChannelNumber.end(), ch) != profile->txChannelNumber.end()) {
                    info << profile->serialNumber;
                    if (!profile->frontendHardwareModel.empty()) {
                        info << " (" << profile->frontendHardwareModel << ")";
                    }
                    foundFrontend = true;
                    break;
                }
            }
            if (!foundFrontend) {
                info << "N/A";
            }
            
            // Antenna info
            info << " -> ";
            const auto& supportedAnts = getHardwareSupportedTxAntennas(ch);
            if (supportedAnts.empty()) {
                info << "None";
            } else {
                for (size_t j = 0; j < supportedAnts.size(); j++) {
                    if (supportedAnts[j].empty()) {
                        info << "None";
                    } else {
                        info << supportedAnts[j];
                    }
                    if (j < supportedAnts.size() - 1) {
                        info << ", ";
                    }
                }
            }
            info << "\n";
        }
 
        // Process Rx channels
        for (size_t i = 0; i < rxChannels.size(); i++) {
            uint8_t ch = rxChannels[i];
            
            // Start with motherboard info
            info << "* ";
            
            // Frontend info to get motherboard info
            std::string frontendSerial;
            for (const auto& profile : frontendProfiles) {
                if (std::find(profile->rxChannelNumber.begin(), profile->rxChannelNumber.end(), ch) != profile->rxChannelNumber.end()) {
                    frontendSerial = profile->serialNumber;
                    break;
                }
            }
            
            // Print motherboard info
            info << getMboardInfo(frontendSerial) << " -> ";
            
            // Channel info
            info << static_cast<int>(ch) << " (Rx) -> ";
            
            // Frontend info
            bool foundFrontend = false;
            for (const auto& profile : frontendProfiles) {
                if (std::find(profile->rxChannelNumber.begin(), profile->rxChannelNumber.end(), ch) != profile->rxChannelNumber.end()) {
                    info << profile->serialNumber;
                    if (!profile->frontendHardwareModel.empty()) {
                        info << " (" << profile->frontendHardwareModel << ")";
                    }
                    foundFrontend = true;
                    break;
                }
            }
            if (!foundFrontend) {
                info << "N/A";
            }
            
            // Antenna info
            info << " -> ";
            const auto& supportedAnts = getHardwareSupportedRxAntennas(ch);
            if (supportedAnts.empty()) {
                info << "None";
            } else {
                for (size_t j = 0; j < supportedAnts.size(); j++) {
                    if (supportedAnts[j].empty()) {
                        info << "None";
                    } else {
                        info << supportedAnts[j];
                    }
                    if (j < supportedAnts.size() - 1) {
                        info << ", ";
                    }
                }
            }
            info << "\n";
        }
 
        // Section separator
        info << "*" << std::string(maxWidth-2, '-') << "\n";
 
        // Channel Capabilities section
        info << "* Channel Capabilities:\n";
 
        // Process Tx channels capabilities
        for (size_t i = 0; i < txChannels.size(); i++) {
            uint8_t ch = txChannels[i];
            info << "* # " << static_cast<int>(ch) << " (Tx):\n";
            
            // Gain range
            info << "*   Gain -> " << std::fixed << std::setprecision(1)
                 << getHardwareTxGainRange(ch).first << " to " 
                 << getHardwareTxGainRange(ch).second << " dB\n";
            
            // Frequency range
            info << "*   Carrier Frequency -> " << std::fixed << std::setprecision(1)
                 << getHardwareTxFrequencyRange(ch).first/1e6 << " to "
                 << getHardwareTxFrequencyRange(ch).second/1e6 << " MHz\n";
            
            // Sampling rate range
            info << "*   Sampling Rate -> " << std::fixed << std::setprecision(2)
                 << getHardwareTxSamplingRateRange(ch).first/1e6 << " to "
                 << getHardwareTxSamplingRateRange(ch).second/1e6 << " MHz\n";
        }
 
        // Process Rx channels capabilities including AGC support
        const auto& agcSupport = getHardwareAGCSupport();
        for (size_t i = 0; i < rxChannels.size(); i++) {
            uint8_t ch = rxChannels[i];
            info << "* # " << static_cast<int>(ch) << " (Rx):\n";
            
            // Gain range
            info << "*   Gain -> " << std::fixed << std::setprecision(1)
                 << getHardwareRxGainRange(ch).first << " to "
                 << getHardwareRxGainRange(ch).second << " dB\n";
            
            // Frequency range
            info << "*   Carrier Frequency -> " << std::fixed << std::setprecision(1)
                 << getHardwareRxFrequencyRange(ch).first/1e6 << " to "
                 << getHardwareRxFrequencyRange(ch).second/1e6 << " MHz\n";
            
            // Sampling rate range
            info << "*   Sampling Rate -> " << std::fixed << std::setprecision(2)
                 << getHardwareRxSamplingRateRange(ch).first/1e6 << " to "
                 << getHardwareRxSamplingRateRange(ch).second/1e6 << " MHz\n";
 
            // AGC support
            if (i < agcSupport.size() && agcSupport[i]) {
                info << "*   AGC -> Supported\n";
            } else {
                info << "*   AGC -> Not Supported\n";
            }
        }
 
        // Bottom border
        info << std::string(maxWidth, '*') << "\n";
 
        return info.str();
    }
 
    virtual ~SDRDeviceHardwareInformation() = default;
 
protected:
    virtual void refreshHardwareInfoForSupportedChannels() {
    }
 
    virtual void refreshHardwareInfoForSupportedAntennas() {
    }
 
    virtual void refreshHardwareInfoForGainRanges() {
    }
 
    virtual void refreshHardwareInfoForFrequencyRanges() {
    }
 
    virtual void refreshHardwareInfoForSamplingRateRanges() {
    }
 
    virtual void refreshHardwareInfoForMasterClockRates() {
    }
 
    virtual void refreshHardwareInfoForClockAndTimeSources() {
    }
 
    virtual void refreshHardwareInfoForSensors() {
    }
 
    virtual void refreshHardwareInfoForTemperatures() {
    }
 
    virtual void refreshHardwareInfoForAGCSupport() {
    }
 
    virtual void refreshHardwareInfoForBoards() {
    }
 
    virtual void refreshHardwareInfoForConnectionProfile() {
    }
 
    virtual void refreshHardwareInfoForFrontEndProfiles() {
    }
 
    // Board information (motherboard, FPGA, daughterboard)
    mutable SDRMainBoardInfo boardInfo;
    mutable bool boardInfoChanged{true};
 
    // Channel information
    mutable std::vector<uint8_t> supportedTxChannels{};
    mutable std::vector<uint8_t> supportedRxChannels{};
    mutable bool supportedChannelsChanged{true};
 
    // Daughterboard and Frontend profiles
    mutable std::vector<SDRDaughterboardProfile> daughterboardProfiles{}; // Vector of daughterboards
    mutable std::vector<std::shared_ptr<SDRFrontEndProfile>> frontendProfiles{}; // channel -> frontend
    mutable bool frontendProfilesChanged{true};
 
    // Antenna information
    mutable std::vector<std::vector<std::string>> supportedTxAntennas{};
    mutable std::vector<std::vector<std::string>> supportedRxAntennas{};
    mutable bool supportedAntennasChanged{true};
    mutable bool supportedAntennasMapChanged{true};
 
    // Gain ranges
    mutable std::vector<std::pair<double, double>> txGainRanges{};
    mutable std::vector<std::pair<double, double>> rxGainRanges{};
    mutable bool gainRangesChanged{true};
    mutable bool gainRangesMapChanged{true};
 
    // Frequency ranges
    mutable std::vector<std::pair<double, double>> txFrequencyRanges{};
    mutable std::vector<std::pair<double, double>> rxFrequencyRanges{};
    mutable bool frequencyRangesChanged{true};
    mutable bool frequencyRangesMapChanged{true};
 
    // Sampling rate ranges
    mutable std::vector<std::pair<double, double>> txSamplingRateRanges{};
    mutable std::vector<std::pair<double, double>> rxSamplingRateRanges{};
    mutable bool samplingRateRangesChanged{true};
    mutable bool samplingRateRangesMapChanged{true};
 
    // Master clock rates
    mutable std::vector<double> supportedMasterClockRates{};
    mutable bool masterClockRatesChanged{true};
 
    // Clock and time sources
    mutable std::vector<std::string> supportedClockAndTimeSources{};
    mutable bool clockAndTimeSourcesChanged{true};
 
    // Sensors
    mutable std::vector<std::vector<std::string>> supportedSensors{}; // channel -> sensors
    mutable bool sensorsChanged{true};
    mutable bool sensorsMapChanged{true};
 
    // Temperature sensors
    mutable std::vector<double> temperatureReadings{};
    mutable bool temperaturesChanged{true};
 
    // AGC support
    mutable std::vector<bool> agcSupport{}; // per channel AGC support
    mutable bool agcSupportChanged{true};
    mutable bool agcSupportMapChanged{true};
 
};
 
#endif //PICOSCENES_PLATFORM_SDRFRONTENDHARDWAREINFORMATION_HXX