FlowControlClient.h

/***************************************************************************
 * \file FlowControlClient.h
 *
 * \brief NDR651 flow control client.
 *
 * \author NH
 * \copyright Copyright (c) 2015-2021 CyberRadio Solutions, Inc.
 *
 */
 
#ifndef INCLUDED_LIBCYBERRADIO_NDR651_FLOWCONTROLCLIENT_H
#define INCLUDED_LIBCYBERRADIO_NDR651_FLOWCONTROLCLIENT_H
 
#include "LibCyberRadio/Common/BasicList.h"
#include "LibCyberRadio/Common/Debuggable.h"
#include "LibCyberRadio/Common/Thread.h"
#include "LibCyberRadio/NDR651/ClientSocket.h"
#include "LibCyberRadio/NDR651/PacketTypes.h"
#include <boost/thread/mutex.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <vector>
 
//#define TX_BUFFER_MAX_SIZE 67108862 // (2^26)-2
#define TX_BUFFER_MAX_SIZE 67108862 // (2^26)-2
#define TX_BUFFER_MIN_SIZE 0

namespace LibCyberRadio
{
    namespace NDR651
    {
        class FlowControlClient : public Thread, public Debuggable
        {
            public:
                FlowControlClient(unsigned int ducChannel,
                        bool config_tx,
                        unsigned int updatesPerSecond,
                        bool debug = false);
                virtual ~FlowControlClient();
                virtual void run();
                void update(void);
                bool connectToRadio(const std::string& hostname, unsigned int port);
                unsigned int setUpdateRate(unsigned int updatesPerSecond);
                unsigned int getUpdateDelay() { return _fcUpdateDelay; };
                void setDucChannel(unsigned int ducChannel);
                bool isConnected(void) { return _mySocket->isConnected(); };
                // bool tryBoostSocket(void);
                bool disconnect(void);
                void testQueries(void);
                long unsigned int getUtc(void) {return _utc;};
                std::string getRadioMac(unsigned int tenGbeIndex);
                std::string getRadioIp(unsigned int tenGbeIndex);
                bool disableDuc();// { return _sendDuc(false); };
                //bool enableDuc() { return _setDucConfig(true); };
                bool enableDuc(unsigned int rateIndex, unsigned int txChannel,
                        unsigned int streamId, unsigned int tenGbeIndex, float attenuation,
                        double txFreq, long ducFreq, unsigned int txAtten, bool ducEnable = true);
                //bool enableDucChannel(unsigned int ducChannel, bool enable, unsigned int ducRate, unsigned int streamId, unsigned int tenGbeIndex, unsigned int ducTxChannel, float ducFreq, float ducAtten);
                //bool enableDucChannel(unsigned int ducChannel, bool enable, unsigned int ducRate, unsigned int streamId, unsigned int tenGbeIndex, unsigned int ducTxChannel, float ducFreq, float ducAtten, bool enableTxChannels, float txFreq, unsigned int txAtten);
                bool setTxFrequency(double txFreq, bool applySetting = true);
                bool setTxAttenuation(unsigned int txAttenuation, bool applySetting = true);
                bool setDucTxChannel(unsigned int txChannel, bool applySetting = true);
                bool setDucRateIndex(unsigned int rateIndex, bool applySetting = true);
                bool setDucStreamId(unsigned int streamId, bool applySetting = true);
                bool setDucAttenuation(float attenuation, bool applySetting = true);
                bool setDucFrequency(long ducFreq, bool applySetting = true);
                bool setDucTxinvMode(unsigned int txinvMode, bool applySetting = true);
                bool setDucEnable(bool ducEnable, bool applySetting = true);
                bool setDucTenGbePort(unsigned int ducTenGbePort, bool applySetting = true);
                bool okToSend(long int pendingSamples, bool lockIfOk);
                // bool okToSend(long int pendingSamples, bool lockIfOk, unsigned int ducChannel);
                long int getFreeSpace(void);
                // long int getFreeSpace(unsigned int ducChannel);
                bool sentNSamples(long int samplesSent);
                // bool sentNSamples(long int samplesSent, unsigned int ducChannel);
 
                bool setDucDipStatusEntry(int dipIndex, std::string dip, std::string dmac, unsigned int ducStatusPort);
                bool setDuchsParameters(unsigned int duchsFullThresh, unsigned int duchsEmptyThresh, unsigned int duchsPeriod);
 
                bool unpause(void);
 
            private:
 
                std::string _radioHostname;
                unsigned int _radioTcpPort;
 
                struct TxStatusFrame _statusFrame;
                int _statusSockfd;
                socklen_t _statusDestLen; /* byte size of client's address */
                struct sockaddr_in _statusDestAddr, _statusCopyAddr; /* client addr */
 
                unsigned int _tbsChannel;
                unsigned int _tbsSpace;
                unsigned int _tbsUnderrunFlag;
                unsigned int _tbsUnderrunCount;
                unsigned int _tbsOverrunFlag;
                unsigned int _tbsOverrunCount;
                unsigned int _tbsEmptyFlag;
                unsigned int _tbsFullFlag;
 
                bool _validDucChannel, _multiChannel;
                bool _ducEnable;
                unsigned int _ducChannel;
                unsigned int _ducRateIndex;
                unsigned int _ducStreamId;
                unsigned int _ducTxChannel;
                unsigned int _ducTenGbePort;
                unsigned int _ducDipIndex;
                unsigned int _ducAttenuation;
                unsigned int _txinvMode;
                unsigned int _txAttenuation;
                double _txFreq;
                int _shfMode;
                long _ducFreq;
                bool _config_tx;
 
                unsigned int _duchsFullThresh;
                unsigned int _duchsEmptyThresh;
                unsigned int _duchsPeriod;
                unsigned int _duchsUdpPort;
 
                BasicStringList _rspVec;
 
                boost::ptr_vector<boost::mutex> _fcMutexVector;
                std::vector<long int> _freeSpaceVector;
 
                boost::mutex _fcMutex, _fcSendMutex, _fcUpdateMutex;
                bool _sendLock;
                unsigned int _fcUpdateRate, _fcUpdateDelay;
                bool _firstUpdate;
                // long int _651bufferSize;
                unsigned long int _utc;
                long int _651freeSpace;
                long int _651freeSpaceArray[8];
                long int _651freeSpaceLast;
                long int _samplesPerUpdate;
                // long int _651minFreeSpace;
                //std::string _tqbaQuery, _tqouQuery;
                std::string _tbsQuery;
                ClientSocket * _mySocket;
 
 
                bool _sendCmdAndQry(const std::string& cmd, const std::string& qry);
                bool _setShfMode();
                bool _sendShf();
                bool _sendTxf();
                bool _sendTxa();
                bool _sendTxp();
                bool _sendTxinv();
                bool _sendWbduc();
                bool _sendDuc();
                bool _sendDucp();
                bool _sendWba();
                bool _sendWbf();
                bool _sendDuchs();
                bool _sendDip();
 
                bool _clearDucSettingsInRadio(void);
 
                void _initStatusFrame(void);
                void _initStatusSocket(void);
                void _initStatusAddress(void);
                void _sendStatusFrame(void);
 
                //bool _setDucConfig(bool enable);
                void _queryBufferState(void);
                void _queryUtc(void);
                void _queryStatus(void);
                long _getDucSampleRate(void) const;
 
        };
 
    }
}
 
#endif /* INCLUDED_LIBCYBERRADIO_NDR651_FLOWCONTROLCLIENT_H */