TetherCom.h

Go to the documentation of this file.

//
// Copyright (C) ValoFly GmbH - All Rights Reserved
//
#ifndef _VALOFLY_TETHERCOM_LIB_HEADER_
#define _VALOFLY_TETHERCOM_LIB_HEADER_
 
#include <TetherCom/TetherComDefinitions.h>
 
#include <exception>
#include <vector>
#include <string>
#include <sstream>
#include <iostream>
 
namespace VALOFLY {
 
 
    class IOException : public std::exception {
        // Disable copy constructors
        IOException& operator=(const IOException&);
        std::string _exWhat;
 
    public:
        explicit IOException(const char* description)
        {
            std::stringstream ss;
            ss << "IO Exception: " << description;
            _exWhat = ss.str();
        }
        IOException(const IOException& other) : _exWhat(other._exWhat) {}
 
        virtual ~IOException() noexcept {}
 
        virtual const char* what() const throw () {
            return _exWhat.c_str();
        }
    };
 
 
    class DataException : public std::exception {
        // Disable copy constructors
        DataException& operator=(const DataException&);
        std::string _exWhat;
 
    public:
        explicit DataException(const char* description)
        {
            std::stringstream ss;
            ss << "Data Exception: " << description;
            _exWhat = ss.str();
        }
        DataException(const DataException& other) : _exWhat(other._exWhat) {}
 
        virtual ~DataException() noexcept {}
 
        virtual const char* what() const throw () {
            return _exWhat.c_str();
        }
    };
 
 
    class ValueException : public std::exception {
        // Disable copy constructors
        ValueException& operator=(const ValueException&);
        std::string _exWhat;
 
    public:
        explicit ValueException(const char* description)
        {
            std::stringstream ss;
            ss << "Value Exception: " << description;
            _exWhat = ss.str();
        }
        ValueException(const ValueException& other) : _exWhat(other._exWhat) {}
 
        virtual ~ValueException() noexcept {}
 
        virtual const char* what() const throw () {
            return _exWhat.c_str();
        }
    };
 
 
    class TetherCom
    {
    public:
        /******************************************************************/
        /*                Public communication definitions                */
        /******************************************************************/
 
 
        struct systemConfig //
        {
            bool systemActivation;              
            unsigned int cableRetractionTorque; 
            float cableRetractionStartLength;   
            int cableRetractionStatus;          
        };
 
        struct cableStatus
        {
            float lengthUnwound = 0;            
            float speed = 0;                    
            int retractionStatus = static_cast<int>(TetherComDefinitions::cableRetractionStatus::not_available);    
            unsigned int retractionTorque = 0;  
            float retractionStartLength = 0;    
            int tetherStatus = static_cast<int>(TetherComDefinitions::cableTetherStatus::failure);      
            int guideStatus = static_cast<int>(TetherComDefinitions::cableGuideStatus::not_available);  
            int reelStatus = static_cast<int>(TetherComDefinitions::cableReelStatus::not_available);    
        };
 
        struct envStatus
        {
            float temp1 = -128;     
            float temp2 = -128;     
            float temp3 = -128;     
            float temp4 = -128;     
            float humidity1 = -128;  
            float pressure1 = 0;     
            int envSensor1Status = static_cast<int>(TetherComDefinitions::envSensorStatus::not_available);   
            int envSensor2Status = static_cast<int>(TetherComDefinitions::envSensorStatus::not_available);   
            int envSensor3Status = static_cast<int>(TetherComDefinitions::envSensorStatus::not_available);   
            int envSensor4Status = static_cast<int>(TetherComDefinitions::envSensorStatus::not_available);   
            int fan1RPM = 0;        
            int fan1Status = static_cast<int>(TetherComDefinitions::fanStatus::not_available);  
            int fan2RPM = 0;        
            int fan2Status = static_cast<int>(TetherComDefinitions::fanStatus::not_available);  
        };
 
        struct energyGSStatus
        {
            float mainsU = 0;               
            float mainsI = 0;               
            float mainsF = 0;               
            int mainsStatus = static_cast<int>(TetherComDefinitions::supplyStatus::not_available);      
            int ctrlSupplyStatus = static_cast<int>(TetherComDefinitions::supplyStatus::not_available); 
            float backupBatteryVoltage = static_cast<float>(TetherComDefinitions::backupBatteryStatus::not_available);  
            int backupBatteryStatus = static_cast<int>(TetherComDefinitions::backupBatteryStatus::not_available);       
        };
 
        struct energyUAVStatus
        {
            float uavVoltage = 0;           
            float uavCurrent = 0;           
            float uavPower = 0;             
            int extSupplyStatus = static_cast<int>(TetherComDefinitions::extUAVSupplyStatus::supply_error); 
            int uavBatCellCount = 0;        
        };
 
        struct systemStates
        {
            int activation = static_cast<int>(TetherComDefinitions::systemActivationStatus::off);   
            int retractionStatus = static_cast<int>(TetherComDefinitions::cableRetractionStatus::not_available);    
            int backupBatteryStatus = static_cast<int>(TetherComDefinitions::backupBatteryStatus::not_available);   
            uint32_t systemTime = 0;                
            uint32_t operationTime = 0;             
            uint32_t flightTime = 0;                
            uint32_t operationFlightTimeSum = 0;    
            uint32_t operationFlightCountSum = 0;   
            int error = static_cast<int>(TetherComDefinitions::systemError::generic_error); 
        };
 
        struct systemStatusConfig
        {
            int cableEnabled = static_cast<int>(TetherComDefinitions::statusConfig::disable);       
            int envEnabled = static_cast<int>(TetherComDefinitions::statusConfig::disable);         
            int energyGSEnabled = static_cast<int>(TetherComDefinitions::statusConfig::disable);    
            int energyUAVEnabled = static_cast<int>(TetherComDefinitions::statusConfig::disable);   
            int systemStatesEnabled = static_cast<int>(TetherComDefinitions::statusConfig::disable);
            int hardwareModuleStatusEnabled = static_cast<int>(TetherComDefinitions::statusConfig::disable);    
        };
 
        struct hardwareModuleStatus
        {
            int mainCtrlStatus = static_cast<int>(TetherComDefinitions::hardwareModuleStatus::not_available);   
            int reelCtrlStatus = static_cast<int>(TetherComDefinitions::hardwareModuleStatus::not_available);   
            int lpwrCtrlStatus = static_cast<int>(TetherComDefinitions::hardwareModuleStatus::not_available);   
            int hpwrCtrlStatus = static_cast<int>(TetherComDefinitions::hardwareModuleStatus::not_available);   
            int envCtrlStatus = static_cast<int>(TetherComDefinitions::hardwareModuleStatus::not_available);    
        };
 
        struct systemStatus
        {
            systemStatusConfig conf;        
            cableStatus cable;              
            envStatus env;                  
            energyGSStatus energyGS;        
            energyUAVStatus energyUAV;      
            systemStates sysStates;         
            hardwareModuleStatus hwModules; 
        };
 
        struct systemDetails
        {
            std::string productType = "";       
            std::string model = "";             
            std::string serialNumber = "";      
            std::string dayOfProduction = "";   
            std::string hardwareVersion = "";   
            struct softwareVersions
            {
                std::string mainCtrl = "";          
                std::string reelCtrl = "";          
                std::string lpwrCtrl = "";          
                std::string hpwrCtrl = "";          
                std::string envCtrl = "";           
                std::string netCtrl = "";           
                std::string backupBatteryCtrl = ""; 
            } softwareVersion;                   
            std::string protocolVersion = "";   
            std::string uavCellVoltages = "";   
            int maxPower = 0;                   
            std::string cableType = "";         
            int maxCableLength = 0;             
            int networkType = static_cast<int>(TetherComDefinitions::systemNetworkType::not_available); 
            uint32_t flightTimeSum = 0;         
            uint32_t flightCount = 0;           
            uint32_t operationTimeSum = 0;      
            uint32_t operationCount = 0;        
            uint32_t systemTimeSum = 0;         
            uint32_t systemUseCount = 0;        
            uint32_t maintenanceLastTimestamp = 0;  
            uint32_t timeToMaintenance = 0;     
            int maintenanceRequired = 0;        
        };
 
    private:
        class TetherComImpl;
        TetherComImpl* _pImpl;
 
    public:
        TetherCom();
        TetherCom(TetherCom&&);
        TetherCom(const TetherCom&) = delete;   // non construction-copyable
        TetherCom& operator=(TetherCom&&) = default;    // move assignment operator
        TetherCom& operator=(const TetherCom&) = delete;    // non copyable
        ~TetherCom();
 
        void getSerialPortsInfo(std::vector<std::string>& devListPort, std::vector<std::string>& devListDesc, std::vector<std::string>& devListHwID);
 
        void printSerialPortList();
 
        void printSerialPortList(std::ostream& stream);
 
        void openConnection(const std::string& portName);
 
        void closeConnection();
 
        int getConnectionStatus();
 
        bool isConnected();
 
        void setConnectionTimeout(const unsigned int timeout);
 
        int getConnectionTimeout();
 
        void getSystemDetails(systemDetails& sysDetails);
 
        void getSystemStatus(systemStatus& sysStatus);
 
        bool checkSystemStatus(TetherComDefinitions::systemError & errorStatus);
 
        bool checkSystemStatus(systemStatus& sysStatus, TetherComDefinitions::systemError& errorStatus, bool checkMaintenance = false);
 
        bool checkSystemStatus(systemStatus& sysStatus, systemDetails& sysDetails, TetherComDefinitions::systemError& errorStatus, bool checkMaintenance = true);
 
        void getSystemConfig(systemConfig& config);
 
        unsigned int getMinimalCableRetractionTorque();
 
        unsigned int getMaximalCableRetractionTorque();
 
        float getMinimalCableRetractionStartLength();
 
        void setSystemConfig(const bool activation, const unsigned int retractionTorque, const float startLength);
 
        void setSystemConfig(const systemConfig& conf);
 
        void setSystemActivation(bool activation);
 
        void setCableRetractionTorque(unsigned int retractionTorque);
 
        void setCableRetractionStartLength(float startLength);
 
        void getSystemStatusConfig(systemStatusConfig& conf);
 
        void setSystemStatusConfig(systemStatusConfig& conf);
 
        void print();
 
        void print(systemStatus& sysStatus, std::ostream& stream = std::cout);
 
        void print(systemDetails& sysDetails, std::ostream& stream = std::cout);
 
        std::string getLibBuild();
 
        void getLibBuild(std::string& build);
 
        std::string getLibProtocolVersion();
 
        void getLibProtocolVersion(std::string& version);
        
        void printVersionDetails();
        
        void printVersionDetails(std::ostream& stream);
        
    };
};
 
#endif // _VALOFLY_TETHERCOM_LIB_HEADER_