DucComponent.h

/***************************************************************************
 * \file DucComponent.h
 * \brief Defines the basic DUC 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_DUCCOMPONENT_H
#define INCLUDED_LIBCYBERRADIO_DRIVER_DUCCOMPONENT_H

#include "LibCyberRadio/Driver/RadioComponent.h"
#include "LibCyberRadio/Common/BasicDict.h"
#include "LibCyberRadio/Common/BasicList.h"
#include <string>


namespace LibCyberRadio
{
    namespace Driver
    {
        typedef BASIC_DICT_CONTAINER<int, double> DucRateSet;

        class DucComponent : public RadioComponent
        {
            public:
                DucComponent(const std::string& name = "DUC",
                        int index = 1,
                        RadioHandler* parent = NULL,
                        bool debug = false,
                        double freqRangeMin = 0.0,
                        double freqRangeMax = 0.0,
                        double freqRes = 1.0,
                        double freqUnits = 1.0,
                        double attRangeMin = 0.0,
                        double attRangeMax = 10.0,
                        double attRes = 1.0,
                        int dataPort = 0,
                        double frequency = 0.0,
                        double attenuation = 0.0,
                        int rateIndex = 0,
                        int txChannels = 0,
                        int mode = 0,
                        unsigned int streamId = 0);
                virtual ~DucComponent();
                DucComponent(const DucComponent& other);
                virtual DucComponent& operator=(const DucComponent& other);
                // RadioComponent interface
                virtual bool enable(bool enabled = true);
                virtual bool setConfiguration(ConfigurationDict& cfg);
                virtual void queryConfiguration();
                // DucComponent extensions
                virtual int getDataPort() const;
                virtual bool setDataPort(int port);
                virtual double getFrequency() const;
                virtual bool setFrequency(double freq);
                virtual BasicDoubleList getFrequencyRange() const;
                virtual double getFrequencyRes() const;
                virtual double getFrequencyUnit() const;
                virtual double getAttenuation() const;
                virtual bool setAttenuation(double atten);
                virtual BasicDoubleList getAttenuationRange() const;
                virtual double getAttenuationRes() const;
                virtual int getRateIndex() const;
                virtual bool setRateIndex(int index);
                virtual int getTxChannelBitmap() const;
                virtual bool setTxChannelBitmap(int txChannels);
                virtual int getMode() const;
                virtual bool setMode(int mode);
                virtual unsigned int getStreamId() const;
                virtual bool setStreamId(unsigned int sid);
                virtual DucRateSet getRateSet() const;
                virtual bool setRateSet(const DucRateSet& set);
                virtual BasicDoubleList getRateList() const;
                virtual bool supportsSnapshotLoad() const;
                virtual bool loadSnapshot(const std::string& filename,
                        unsigned int startSample = 0,
                        unsigned int samples = 0);
                virtual bool supportsSnapshotTransmit() const;

            protected:
                // RadioComponent interface
                virtual void initConfigurationDict();
                virtual void updateConfigurationDict();
                // DucComponent extensions
                virtual bool executeDucQuery(int index,
                        int& dataPort,
                        double& frequency,
                        double& attenuation,
                        int& rateIndex,
                        int& txChannels,
                        int& mode,
                        unsigned int& streamId);
                virtual bool executeDucCommand(int index,
                        int& dataPort,
                        double& frequency,
                        double& attenuation,
                        int& rateIndex,
                        int& txChannels,
                        int& mode,
                        unsigned int& streamId);
                virtual bool executeSnapshotLoadCommand(int index,
                        const std::string& filename,
                        unsigned int startSample,
                        unsigned int samples);

            protected:
                // Minimum tunable frequency (Hz)
                double _freqRangeMin;
                // Maximum tunable frequency (Hz)
                double _freqRangeMax;
                // Frequency resolution (Hz)
                double _freqRes;
                // Frequency units (Hz)
                double _freqUnits;
                // Minimum attenuation (dB)
                double _attRangeMin;
                // Maximum attenuation (dB)
                double _attRangeMax;
                // Attenuation resolution
                double _attRes;
                // Data port
                int _dataPort;
                // Tuned frequency
                double _frequency;
                // Attenuation
                double _attenuation;
                // Rate index
                int _rateIndex;
                // TX channel bitmap
                int _txChannels;
                // DUC mode (streaming or playback)
                int _mode;
                // VITA 49 stream ID
                unsigned int _streamId;
                // Supports snapshot load
                bool _supportsSnapLoad;
                // Snapshot file name
                std::string _snapFilename;
                // Snapshot starting sample
                unsigned int _snapStartSample;
                // Snapshot number of samples
                unsigned int _snapSamples;
                // Supports snapshot transmit
                bool _supportsSnapTransmit;
                // Whether snapshot transmit is single playback
                bool _snapSinglePlayback;
                // Whether snapshot transmit should pause until enabled
                bool _snapPauseUntilEnabled;
                // Rate set
                DucRateSet _rateSet;

        }; // class DucComponent

        typedef BASIC_DICT_CONTAINER<int, DucComponent*> DucComponentDict;

    } // namespace Driver

} // namespace LibCyberRadio


#endif // INCLUDED_LIBCYBERRADIO_DRIVER_DUCCOMPONENT_H