RadioHandler.h

/***************************************************************************
 * \file RadioHandler.h
 * \brief Defines the basic radio handler interface for an NDR-class radio.
 * \author DA
 * \author NH
 * \author MN
 * \copyright (c) 2017 CyberRadio Solutions, Inc.  All rights reserved.
 *
 ***************************************************************************/
 
#ifndef INCLUDED_LIBCYBERRADIO_DRIVER_RADIOHANDLER_H
#define INCLUDED_LIBCYBERRADIO_DRIVER_RADIOHANDLER_H
 
#include "LibCyberRadio/Common/BasicDict.h"
#include "LibCyberRadio/Common/BasicList.h"
#include "LibCyberRadio/Driver/Configurable.h"
#include "LibCyberRadio/Driver/DataPort.h"
#include "LibCyberRadio/Driver/DucComponent.h"
#include "LibCyberRadio/Driver/NbddcComponent.h"
#include "LibCyberRadio/Driver/NbddcGroupComponent.h"
#include "LibCyberRadio/Driver/RadioTransport.h"
#include "LibCyberRadio/Driver/SimpleIpSetup.h"
#include "LibCyberRadio/Driver/TransmitterComponent.h"
#include "LibCyberRadio/Driver/TunerComponent.h"
#include "LibCyberRadio/Driver/VitaIfSpec.h"
#include "LibCyberRadio/Driver/WbddcComponent.h"
#include "LibCyberRadio/Driver/WbddcGroupComponent.h"
#include <cstdint>
#include <string>
 

namespace LibCyberRadio
{
    namespace Driver
    {
        class RadioHandler : public Configurable
        {
            public:
                RadioHandler(
                        const std::string& name = "NDR",
                        int numTuner = 0,
                        int tunerIndexBase = 1,
                        int numWbddc = 0,
                        int wbddcIndexBase = 1,
                        int numNbddc = 0,
                        int nbddcIndexBase = 1,
                        int numTunerBoards = 1,
                        int maxTunerBw = 0,
                        int numTransmitter = 0,
                        int transmitterIndexBase = 1,
                        int numDuc = 0,
                        int ducIndexBase = 1,
                        int numWbddcGroups = 0,
                        int wbddcGroupIndexBase = 1,
                        int numNbddcGroups = 0,
                        int nbddcGroupIndexBase = 1,
                        int numDdcGroups = 0,
                        int ddcGroupIndexBase = 1,
                        int numDataPorts = 0,
                        int dataPortIndexBase = 1,
                        int numSimpleIpSetups = 0,
                        double adcRate = 102.4e6,
                        VitaIfSpec ifSpec = VitaIfSpec(),
                        bool debug = false
                );
                virtual ~RadioHandler();
                RadioHandler(const RadioHandler& other);
                virtual RadioHandler& operator=(const RadioHandler& other);
                virtual bool isConnected() const;
                virtual BasicStringStringDict getVersionInfo();
                virtual BasicStringStringDict getConnectionInfo();
                virtual bool connect(
                        const std::string& mode,
                        const std::string& host_or_dev,
                        const int port_or_baudrate
                );
                virtual void disconnect();
                virtual BasicStringList sendCommand(
                        const std::string& cmdString,
                        double timeout = -1
                );
                virtual bool setConfiguration(ConfigurationDict& cfg);
                virtual void queryConfiguration();
                virtual std::string getLastCommandErrorInfo() const;
                virtual bool sendReset(int resetType=0);
                virtual bool getPps();
                virtual bool setTimeNextPps(bool checkTime=false, bool useGpsTime=false);
                virtual time_t getTimeNow();
                virtual time_t getTimeNextPps();
                virtual unsigned int getStatus();
                virtual unsigned int getTstatus();
                virtual bool setReferenceMode(int mode);
                virtual bool setBypassMode(int mode);
                virtual bool setTimeAdjustment(int tunerIndex, int timeAdjustValue);
                virtual BasicDoubleList getGpsPosition();
                virtual int getTemperature();
                virtual int getGpioOutput();
                virtual BasicIntList getGpioOutputByIndex(int index);
                virtual bool setGpioOutput(int value);
                virtual bool setGpioOutputByIndex(int index, int value,
                        int duration, int loop, int go);
                virtual double getCalibrationFrequency() const;
                virtual bool setCalibrationFrequency(double freq);
                virtual int getNumDataPorts() const;
                virtual BasicIntList getDataPortIndexRange() const;
                virtual int getNumDataPortDipEntries() const;
                virtual BasicIntList getDataPortDipEntryIndexRange() const;
                virtual BasicStringList getConnectionModeList() const;
                virtual bool isConnectionModeSupported(const std::string& mode) const;
                virtual double getAdcRate() const;
                virtual int getVitaHeaderSize() const;
                virtual int getVitaPayloadSize() const;
                virtual int getVitaTailSize() const;
                virtual bool isByteswapped() const;
                virtual bool isIqSwapped() const;
                virtual const char* getByteOrder() const;
                // getVitaEnableOptionSet()
                virtual int getNumTuner() const;
                virtual int getNumTunerBoards() const;
                virtual BasicIntList getTunerIndexRange() const;
                virtual BasicDoubleList getTunerFrequencyRange() const;
                virtual double getTunerFrequencyRes() const;
                virtual double getTunerFrequencyUnit() const;
                virtual BasicDoubleList getTunerAttenuationRange() const;
                virtual double getTunerAttenuationRes() const;
                virtual bool isTunerEnabled(int index) const;
                virtual bool enableTuner(int index, bool enabled = true);
                virtual bool disableTuner(int index);
                virtual double getTunerFrequency(int index) const;
                virtual bool setTunerFrequency(int index, double freq);
                virtual double getTunerAttenuation(int index) const;
                virtual bool setTunerAttenuation(int index, double atten);
                virtual int getTunerFilter(int index) const;
                virtual bool setTunerFilter(int index, int filter);
                virtual ConfigurationDict getTunerConfiguration(int index) const;
                virtual bool setTunerConfiguration(int index, ConfigurationDict& cfg);
                virtual int getNumWbddc() const;
                virtual BasicIntList getWbddcIndexRange() const;
                virtual bool isWbddcTunable() const;
                virtual bool isWbddcSelectableSource() const;
                virtual BasicDoubleList getWbddcFrequencyRange() const;
                virtual double getWbddcFrequencyRes() const;
                virtual double getWbddcFrequencyUnit() const;
                virtual WbddcRateSet getWbddcRateSet() const;
                virtual BasicDoubleList getWbddcRateList() const;
                virtual bool isWbddcEnabled(int index) const;
                virtual bool enableWbddc(int index, bool enabled = true);
                virtual bool disableWbddc(int index);
                virtual double getWbddcFrequency(int index) const;
                virtual bool setWbddcFrequency(int index, double freq);
                virtual int getWbddcSource(int index) const;
                virtual bool setWbddcSource(int index, int source);
                virtual int getWbddcRateIndex(int index) const;
                virtual bool setWbddcRateIndex(int index, int rateIndex);
                virtual int getWbddcUdpDestination(int index) const;
                virtual bool setWbddcUdpDestination(int index, int dest);
                virtual int getWbddcVitaEnable(int index) const;
                virtual bool setWbddcVitaEnable(int index, int enable);
                virtual unsigned int getWbddcStreamId(int index) const;
                virtual bool setWbddcStreamId(int index, unsigned int sid);
                virtual int getWbddcDataPort(int index) const;
                virtual bool setWbddcDataPort(int index, int port);
                virtual bool setWbddcRateSet(int index, const WbddcRateSet& set);
                virtual ConfigurationDict getWbddcConfiguration(int index) const;
                virtual bool setWbddcConfiguration(int index, ConfigurationDict& cfg);
                virtual int getNumNbddc() const;
                virtual BasicIntList getNbddcIndexRange() const;
                virtual BasicDoubleList getNbddcFrequencyRange() const;
                virtual double getNbddcFrequencyRes() const;
                virtual double getNbddcFrequencyUnit() const;
                virtual NbddcRateSet getNbddcRateSet() const;
                virtual BasicDoubleList getNbddcRateList() const;
                virtual bool isNbddcEnabled(int index) const;
                virtual bool enableNbddc(int index, bool enabled = true);
                virtual bool disableNbddc(int index);
                virtual double getNbddcFrequency(int index) const;
                virtual bool setNbddcFrequency(int index, double freq);
                virtual int getNbddcSource(int index) const;
                virtual bool setNbddcSource(int index, int source);
                virtual int getNbddcRateIndex(int index) const;
                virtual bool setNbddcRateIndex(int index, int rateIndex);
                virtual int getNbddcUdpDestination(int index) const;
                virtual bool setNbddcUdpDestination(int index, int dest);
                virtual int getNbddcVitaEnable(int index) const;
                virtual bool setNbddcVitaEnable(int index, int enable);
                virtual unsigned int getNbddcStreamId(int index) const;
                virtual bool setNbddcStreamId(int index, unsigned int sid);
                virtual int getNbddcDataPort(int index) const;
                virtual bool setNbddcDataPort(int index, int port);
                virtual bool setNbddcRateSet(int index, const NbddcRateSet& set);
                virtual ConfigurationDict getNbddcConfiguration(int index) const;
                virtual bool setNbddcConfiguration(int index, ConfigurationDict& cfg);
                virtual int getNumTransmitters() const;
                virtual BasicIntList getTransmitterIndexRange() const;
                virtual BasicDoubleList getTransmitterFrequencyRange() const;
                virtual double getTransmitterFrequencyRes() const;
                virtual double getTransmitterFrequencyUnit() const;
                virtual BasicDoubleList getTransmitterAttenuationRange() const;
                virtual double getTransmitterAttenuationRes() const;
                virtual bool isTransmitterEnabled(int index) const;
                virtual bool enableTransmitter(int index, bool enabled = true);
                virtual bool disableTransmitter(int index);
                virtual double getTransmitterFrequency(int index) const;
                virtual bool setTransmitterFrequency(int index, double freq);
                virtual double getTransmitterAttenuation(int index) const;
                virtual bool setTransmitterAttenuation(int index, double atten);
                virtual ConfigurationDict getTransmitterConfiguration(int index) const;
                virtual bool setTransmitterConfiguration(int index, ConfigurationDict& cfg);
                virtual bool transmitterSupportsCW() const;
                virtual int getTransmitterCWNum() const;
                virtual BasicIntList getTransmitterCWIndexRange() const;
                virtual BasicDoubleList getTransmitterCWFrequencyRange() const;
                virtual double getTransmitterCWFrequencyRes() const;
                virtual BasicDoubleList getTransmitterCWAmplitudeRange() const;
                virtual double getTransmitterCWAmplitudeRes() const;
                virtual BasicDoubleList getTransmitterCWPhaseRange() const;
                virtual int getTransmitterCWPhaseRes() const;
                virtual bool transmitterSupportsCWSweep() const;
                virtual BasicDoubleList getTransmitterCWSweepStartRange() const;
                virtual double getTransmitterCWSweepStartRes() const;
                virtual BasicDoubleList getTransmitterCWSweepStopRange() const;
                virtual double getTransmitterCWSweepStopRes() const;
                virtual BasicDoubleList getTransmitterCWSweepStepRange() const;
                virtual double getTransmitterCWSweepStepRes() const;
                virtual BasicDoubleList getTransmitterCWSweepDwellRange() const;
                virtual double getTransmitterCWSweepDwellRes() const;
                virtual bool enableTransmitterCW(int index, int cwIndex,
                        bool enabled = true);
                virtual bool disableTransmitterCW(int index, int cwIndex);
                virtual ConfigurationDict getTransmitterCWConfiguration(int index,
                        int cwIndex) const;
                virtual bool setTransmitterCWConfiguration(int index, int cwIndex,
                        ConfigurationDict& cfg);
                virtual double getTransmitterCWFrequency(int index, int cwIndex) const;
                virtual bool setTransmitterCWFrequency(int index, int cwIndex, double freq);
                virtual double getTransmitterCWAmplitude(int index, int cwIndex) const;
                virtual bool setTransmitterCWAmplitude(int index, int cwIndex, double amp);
                virtual double getTransmitterCWPhase(int index, int cwIndex) const;
                virtual bool setTransmitterCWPhase(int index, int cwIndex, double phase);
                virtual bool transmitterSupportsCWSweep(int index, int cwIndex) const;
                virtual double getTransmitterCWSweepStartFrequency(int index, int cwIndex) const;
                virtual double getTransmitterCWSweepStopFrequency(int index, int cwIndex) const;
                virtual double getTransmitterCWSweepFrequencyStep(int index, int cwIndex) const;
                virtual double getTransmitterCWSweepDwellTime(int index, int cwIndex) const;
                virtual bool setTransmitterCWFrequencySweep(int index, int cwIndex, double start,
                        double stop, double step, double dwell);
                virtual int getNumDuc() const;
                virtual BasicIntList getDucIndexRange() const;
                virtual bool ducSupportsSnapshotLoad() const;
                virtual bool ducSupportsSnapshotTransmit() const;
                virtual bool enableDuc(int index, bool enabled);
                virtual bool disableDuc(int index);
                virtual ConfigurationDict getDucConfiguration(int index) const;
                virtual bool setDucConfiguration(int index, ConfigurationDict& cfg);
                virtual int getDucDataPort(int index) const;
                virtual bool setDucDataPort(int index, int port);
                virtual double getDucFrequency(int index) const;
                virtual bool setDucFrequency(int index, double freq);
                virtual BasicDoubleList getDucFrequencyRange() const;
                virtual double getDucFrequencyRes() const;
                virtual double getDucFrequencyUnit() const;
                virtual double getDucAttenuation(int index) const;
                virtual bool setDucAttenuation(int index, double atten);
                virtual BasicDoubleList getDucAttenuationRange() const;
                virtual double getDucAttenuationRes() const;
                virtual int getDucRateIndex(int index) const;
                virtual bool setDucRateIndex(int index, int rateIndex);
                virtual int getDucTxChannelBitmap(int index) const;
                virtual bool setDucTxChannelBitmap(int index, int txChannels);
                virtual int getDucMode(int index) const;
                virtual bool setDucMode(int index, int mode);
                virtual unsigned int getDucStreamId(int index) const;
                virtual bool setDucStreamId(int index, unsigned int sid);
                virtual bool loadDucSnapshot(int index,
                        const std::string& filename,
                        unsigned int startSample = 0,
                        unsigned int samples = 0
                );
                virtual DucRateSet getDucRateSet() const;
                virtual BasicDoubleList getDucRateList() const;
                virtual int getNumWbddcGroups() const;
                virtual BasicIntList getWbddcGroupIndexRange() const;
                virtual bool isWbddcGroupEnabled(int index) const;
                virtual bool enableWbddcGroup(int index, bool enabled);
                virtual bool disableWbddcGroup(int index);
                virtual ConfigurationDict getWbddcGroupConfiguration(int index) const;
                virtual bool setWbddcGroupConfiguration(int index, ConfigurationDict& cfg);
                virtual BasicIntList getWbddcGroupMembers(int index) const;
                virtual bool setWbddcGroupMembers(int index, const BasicIntList& groupMembers);
                virtual bool addWbddcGroupMember(int index, int member);
                virtual bool removeWbddcGroupMember(int index, int member);
                virtual int getNumNbddcGroups() const;
                virtual BasicIntList getNbddcGroupIndexRange() const;
                virtual bool isNbddcGroupEnabled(int index) const;
                virtual bool enableNbddcGroup(int index, bool enabled);
                virtual bool disableNbddcGroup(int index);
                virtual ConfigurationDict getNbddcGroupConfiguration(int index) const;
                virtual bool setNbddcGroupConfiguration(int index, ConfigurationDict& cfg);
                virtual BasicIntList getNbddcGroupMembers(int index) const;
                virtual bool setNbddcGroupMembers(int index, const BasicIntList& groupMembers);
                virtual bool addNbddcGroupMember(int index, int member);
                virtual bool removeNbddcGroupMember(int index, int member);
                virtual bool disableTenGigFlowControl();
                virtual bool enableTenGigFlowControl();
                virtual bool setTenGigFlowControlStatus(bool enable);
                virtual BasicIntBoolDict getTenGigFlowControlStatus();
                virtual ConfigurationDict getDataPortConfiguration(int index) const;
                virtual bool setDataPortConfiguration(int index, ConfigurationDict& cfg);
                virtual std::string getDataPortSourceIP(int index) const;
                virtual bool setDataPortSourceIP(int index, const std::string& ipAddr);
                virtual bool enableDataPortErrors(int index, bool enabled = true);
                virtual bool disableDataPortErrors(int index);
                virtual bool enableDataPortFlowControl(int index, bool enabled = true);
                virtual bool disableDataPortFlowControl(int index);
                virtual std::string getDataPortDestMACAddress(int index, int dipIndex) const;
                virtual bool setDataPortDestMACAddress(int index, int dipIndex,
                        const std::string& macAddr);
                virtual std::string getDataPortDestIPAddress(int index, int dipIndex) const;
                virtual bool setDataPortDestIPAddress(int index, int dipIndex,
                        const std::string& ipAddr);
                virtual unsigned int getDataPortDestSourcePort(int index, int dipIndex) const;
                virtual bool setDataPortDestSourcePort(int index, int dipIndex,
                        unsigned int sourcePort);
                virtual unsigned int getDataPortDestDestPort(int index, int dipIndex) const;
                virtual bool setDataPortDestDestPort(int index, int dipIndex,
                        unsigned int destPort);
                virtual bool setDataPortDestInfo(int index,
                        int dipIndex,
                        const std::string& ipAddr,
                        const std::string& macAddr,
                        unsigned int sourcePort,
                        unsigned int destPort);
                virtual ConfigurationDict getSimpleIPConfiguration() const;
                virtual bool setSimpleIPConfiguration(ConfigurationDict& cfg);
                virtual std::string getSimpleSourceMACAddress() const;
                virtual std::string getSimpleSourceIPAddress() const;
                virtual bool setSimpleSourceIPAddress(const std::string& ipAddr);
                virtual std::string getSimpleDestMACAddress() const;
                virtual bool setSimpleDestMACAddress(const std::string& macAddr);
                virtual std::string getSimpleDestIPAddress() const;
                virtual bool setSimpleDestIPAddress(const std::string& ipAddr);
                virtual int getDefaultDeviceInfo() const;
                virtual uint32_t getMessageId( void );
 
            protected:
                virtual void initConfigurationDict();
                virtual void updateConfigurationDict();
                // Queries the radio for its version information.
                virtual bool queryVersionInfo();
                // Queries the radio for its specific configuration information.
                // Individual radios should override this as necessary.
                virtual bool queryRadioConfiguration();
                // Executes the *IDN? query on the radio.
                virtual bool executeQueryIDN(std::string& model,
                        std::string& serialNumber);
                // Executes the VER? query on the radio.
                virtual bool executeQueryVER(std::string& softwareVersion,
                        std::string& firmwareVersion,
                        std::string& referenceVersion,
                        std::string& firmwareDate);
                // Executes the HREV? query on the radio.
                virtual bool executeQueryHREV(std::string& hardwareInfo);
                // Executes the reset command on the radio.
                // Override this as needed for radios that support this command.
                virtual bool executeResetCommand(int resetType=0);
                // Executes the PPS command on the radio.
                // Override this as needed for radios that support this command.
                virtual bool executePpsQuery();
                // Executes the time query on the radio.
                // Override this as needed for radios that support this command.
                // Time is an in/out parameter
                virtual bool executeTimeQuery(std::string& timeStr);
                // Executes the time command on the radio.
                // Override this as needed for radios that support this command.
                // Time is an in/out parameter
                virtual bool executeTimeCommand(std::string& timeStr);
                // Executes the GPS time query on the radio.
                // Override this as needed for radios that support this command.
                // Time is an in/out parameter
                virtual bool executeGpsTimeQuery(std::string& timeStr);
                // Executes the config mode query on the radio.
                // Override this as needed for radios that support this command.
                // Config mode is an in/out parameter
                virtual bool executeConfigModeQuery(int& configMode);
                // Executes the config mode command on the radio.
                // Override this as needed for radios that support this command.
                // Config mode is an input parameter
                virtual bool executeConfigModeCommand(int& configMode);
                // Executes the coherent mode query on the radio.
                // Override this as needed for radios that support this command.
                // Coherent mode is an in/out parameter
                virtual bool executeCoherentModeQuery(int& coherentMode);
                // Executes the coherent mode command on the radio.
                // Override this as needed for radios that support this command.
                // Coherent mode is an in/out parameter
                virtual bool executeCoherentModeCommand(int& coherentMode);
                // Executes the frequency normalization query on the radio.
                // Override this as needed for radios that support this command.
                // FNR mode is an in/out parameter
                virtual bool executeFreqNormalizationQuery(int& fnrMode);
                // Executes the frequency normalization command on the radio.
                // Override this as needed for radios that support this command.
                // FNR mode is an in/out parameter
                virtual bool executeFreqNormalizationCommand(int& fnrMode);
                // Executes the GPS enabled query on the radio.
                // Override this as needed for radios that support this command.
                // GPS mode is an in/out parameter
                virtual bool executeGpsEnabledQuery(int& enabled);
                // Executes the GPS enabled command on the radio.
                // Override this as needed for radios that support this command.
                // GPS mode is an in/out parameter
                virtual bool executeGpsEnabledCommand(int& enabled);
                // Executes the GPS position query on the radio.
                // Override this as needed for radios that support this command.
                // GPS position are in/out parameters
                virtual bool executeGpsPositionQuery(double& lat, double& lon);
                // Executes the reference mode query on the radio.
                // Override this as needed for radios that support this command.
                // Ref mode is an in/out parameter
                virtual bool executeReferenceModeQuery(int& refMode);
                // Executes the reference mode command on the radio.
                // Override this as needed for radios that support this command.
                // Ref mode is an in/out parameter
                virtual bool executeReferenceModeCommand(int& refMode);
                // Executes the reference bypass query on the radio.
                // Override this as needed for radios that support this command.
                // Ref bypass is an in/out parameter
                virtual bool executeReferenceBypassQuery(int& bypassMode);
                // Executes the reference bypass command on the radio.
                // Override this as needed for radios that support this command.
                // Ref bypass is an in/out parameter
                virtual bool executeReferenceBypassCommand(int& bypassMode);
                // Executes the reference tuning voltage query on the radio.
                // Override this as needed for radios that support this command.
                // Ref tuning voltage is an in/out parameter
                virtual bool executeReferenceVoltageQuery(int& voltage);
                // Executes the reference tuning voltage command on the radio.
                // Override this as needed for radios that support this command.
                // Ref tuning voltage is an in/out parameter
                virtual bool executeReferenceVoltageCommand(int& voltage);
                // Executes the status query on the radio.
                // Override this as needed for radios that support this command.
                // Status is an in/out parameter
                virtual bool executeStatusQuery(unsigned int& stat);
                // Executes the tuner status query on the radio.
                // Override this as needed for radios that support this command.
                // Status is an in/out parameter
                virtual bool executeTstatusQuery(unsigned int& stat);
                // Executes the temperature query on the radio.
                // Override this as needed for radios that support this command.
                // Temperature is an in/out parameter
                virtual bool executeTemperatureQuery(int& temp);
                // Executes the GPIO static query
                // Override this as needed for radios that support this command.
                // Value is an in/out parameter
                virtual bool executeGpioStaticQuery(int& value);
                // Executes the GPIO sequence query
                // Override this as needed for radios that support this command.
                // Value, duration, loop are in/out parameters
                virtual bool executeGpioSequenceQuery(int index, int& value,
                        int &duration, int& loop);
                // Executes the GPIO static command
                // Override this as needed for radios that support this command.
                // Value is an in/out parameter
                virtual bool executeGpioStaticCommand(int& value);
                // Executes the GPIO sequence comamnd
                // Override this as needed for radios that support this command.
                // Value, duration, loop, go are in/out parameters
                virtual bool executeGpioSequenceCommand(int index, int& value,
                        int &duration, int& loop,
                        int &go);
                // Executes the calibration frequency query
                // Override this as needed for radios that support this command.
                // Freq is an in/out parameter
                virtual bool executeCalibFrequencyQuery(double& freq);
                // Executes the calibration frequency command
                // Override this as needed for radios that support this command.
                // Freq is an in/out parameter
                virtual bool executeCalibFrequencyCommand(double& freq);
                // Converts an NMEA 0183-formatted coordinate string to decimal degrees.
                virtual double getDecimalDegreesFromNmea(const std::string& coord);
                
 
 
            protected:
                std::string _name;
                RadioTransport _transport;
                BasicStringList _connModesSupported;
                // Radio capabilities
                int _numTuner;
                int _tunerIndexBase;
                int _numWbddc;
                int _wbddcIndexBase;
                int _numNbddc;
                int _nbddcIndexBase;
                int _numTunerBoards;
                int _maxTunerBw;
                int _numTransmitter;
                int _transmitterIndexBase;
                int _numDuc;
                int _ducIndexBase;
                int _numWbddcGroups;
                int _wbddcGroupIndexBase;
                int _numNbddcGroups;
                int _nbddcGroupIndexBase;
                int _numDdcGroups;
                int _ddcGroupIndexBase;
                int _numDataPorts;
                int _dataPortIndexBase;
                int _numSimpleIpSetups;
                double _adcRate;
                VitaIfSpec _ifSpec;
                // Radio configuration items
                int _configMode;
                int _coherentMode;
                int _freqNormalization;
                int _gpsEnabled;
                int _referenceMode;
                int _referenceTuningVoltage;
                int _referenceBypass;
                double _calibFrequency;
                // Components
                TunerComponentDict _tuners;
                WbddcComponentDict _wbddcs;
                NbddcComponentDict _nbddcs;
                TransmitterComponentDict _txs;
                DucComponentDict _ducs;
                WbddcGroupComponentDict _wbddcGroups;
                NbddcGroupComponentDict _nbddcGroups;
                // Other configurables
                DataPortDict _dataPorts;
                SimpleIpSetupDict _simpleIpSetups;
                // Status
                std::string _lastCmdErrorInfo;
                BasicStringStringDict _versionInfo;
                BasicStringStringDict _connectionInfo;
                double _defaultTimeout;
                int _defaultDeviceInfo;
 
        }; /* class RadioHandler */
 
    } /* namespace Driver */
 
} /* namespace LibCyberRadio */
 
#endif /* INCLUDED_LIBCYBERRADIO_DRIVER_RADIOHANDLER_H */