cyberatom.hpp

    

#pragma once
#include <memory>
#include <stdint.h>

#include <vector>
#include <string>


namespace cyberatom
{

    class UnsupportedMessageIdException : public std::exception { };

    class DataTransferException : public std::exception { };

    class CannotOpenPortException : public std::exception { };

    class DeviceNotFoundException : public std::exception { };

    class CannotOpenDeviceException : public std::exception { };

    // forward declarations
    class IDevice;
    class IConnection;
    class IResponse;

    class IDevice
    {
    public:
        virtual ~IDevice() {}
        
        virtual void onMessage(uint8_t code, const uint8_t* payload, size_t payload_size)=0;
        
        virtual void checkForMessages()=0;

    };

    class IConnection
    {
    public:
        virtual ~IConnection() {}
        
        virtual void sendMessage(uint8_t code, const uint8_t* payload, size_t len)=0;
        
        virtual void checkForMessages(IDevice& receiver)=0;

    };

    class IResponse
    {
    public:
        virtual ~IResponse() {}
        
        virtual void sysInfo(const char* model, const char* firmwareVersion)=0;
        
        virtual void quatData(float q0, float q1, float q2, float q3)=0;
        
        virtual void eulerData(float p, float r, float y)=0;
        
        virtual void rotRateData(float x, float y, float z)=0;
        
        virtual void accCalibMatrix(float* cal, float* bias)=0;
        
        virtual void magCalibMatrix(float* cal, float* bias)=0;
        
        virtual void gyrCalibMatrix(float* cal, float* bias)=0;
        
        virtual void filterMagMatrix(float* mat)=0;
        
        virtual void filterAccMatrix(float* mat)=0;
        
        virtual void filterGyrMatrix(float* mat)=0;
        
        virtual void filterProcMatrix(float* mat)=0;
        
        virtual void temperature(float temp)=0;
        
        virtual void baudRate(uint8_t rate)=0;
        
        virtual void i2cAddress(uint8_t addr)=0;
        
        virtual void confirm()=0;
        
        virtual void rawAccData(int16_t x, int16_t y, int16_t z)=0;
        
        virtual void rawMagData(int16_t x, int16_t y, int16_t z)=0;
        
        virtual void rawGyrData(int16_t x, int16_t y, int16_t z)=0;
        
        virtual void normAccData(float x, float y, float z)=0;
        
        virtual void normMagData(float x, float y, float z)=0;
        
        virtual void normGyrData(float x, float y, float z)=0;
        
        virtual void calibAccData(float x, float y, float z)=0;
        
        virtual void calibMagData(float x, float y, float z)=0;
        
        virtual void calibGyrData(float x, float y, float z)=0;
        
        virtual void stats(uint32_t perf0, uint32_t perf1, uint32_t perf2, uint32_t perf3, uint32_t perf4, uint32_t perf5, uint32_t perf6, uint32_t perf7)=0;

    };


    class DevicePriv;
    
    
    class Device : public IDevice
    {
        std::shared_ptr<DevicePriv> _private = nullptr;
    public:
         
 Device(IConnection& connection, IResponse& response);
            
        virtual ~Device();
        
        virtual void onMessage(uint8_t code, const uint8_t* payload, size_t payload_size) override;
        
        virtual void checkForMessages() override;
        
        virtual void getSysInfo();
        
        virtual void getQuatData();
        
        virtual void getEulerData();
        
        virtual void getRotRateData();
        
        virtual void reboot();
        
        virtual void factoryReset();
        
        virtual void setAccCalibMatrix(float* cal, float* bias);
        
        virtual void setMagCalibMatrix(float* cal, float* bias);
        
        virtual void setGyrCalibMatrix(float* cal, float* bias);
        
        virtual void setFilterMagMatrix(float* mat);
        
        virtual void setFilterAccMatrix(float* mat);
        
        virtual void setFilterGyrMatrix(float* mat);
        
        virtual void setFilterProcMatrix(float* mat);
        
        virtual void getFilterMagMatrix();
        
        virtual void getFilterAccMatrix();
        
        virtual void getFilterGyrMatrix();
        
        virtual void getFilterProcMatrix();
        
        virtual void getTemperature();
        
        virtual void setBaudRate(uint8_t rate);
        
        virtual void setI2cAddress(uint8_t address);
        
        virtual void getI2cAddress();
        
        virtual void getBaudRate();
        
        virtual void resetGyr();
        
        virtual void writeFlash();
        
        virtual void getRawAccData();
        
        virtual void getRawMagData();
        
        virtual void getRawGyrData();
        
        virtual void getNormAccData();
        
        virtual void getNormMagData();
        
        virtual void getNormGyrData();
        
        virtual void getCalibAccData();
        
        virtual void getCalibMagData();
        
        virtual void getCalibGyrData();
        
        virtual void getAccCalibMatrix();
        
        virtual void getMagCalibMatrix();
        
        virtual void getGyrCalibMatrix();
        
        virtual void getStats();

    };


    class SerialConnectionPriv;
    
    
    class SerialConnection : public IConnection
    {
        std::shared_ptr<SerialConnectionPriv> _private = nullptr;
    public:
         
SerialConnection(const char* portName, int baudRate);
            
        virtual ~SerialConnection();
        
        virtual void sendMessage(uint8_t code, const uint8_t* payload, size_t len) override;
        
        virtual void checkForMessages(IDevice& receiver) override;

    };


    class UsbConnectionPriv;
    
    
    class UsbConnection : public IConnection
    {
        std::shared_ptr<UsbConnectionPriv> _private = nullptr;
    public:
         
UsbConnection();
            
UsbConnection(const char* serialNumber);
            
        virtual ~UsbConnection();
        
        virtual void sendMessage(uint8_t code, const uint8_t* payload, size_t len) override;
        
        virtual void checkForMessages(IDevice& receiver) override;

        static std::vector<std::string>  enumerateDevices(); 

    };


    class Response : public IResponse
    {
    public: 
        virtual void sysInfo(const char* model, const char* firmwareVersion) override {}
        virtual void quatData(float q0, float q1, float q2, float q3) override {}
        virtual void eulerData(float p, float r, float y) override {}
        virtual void rotRateData(float x, float y, float z) override {}
        virtual void accCalibMatrix(float* cal, float* bias) override {}
        virtual void magCalibMatrix(float* cal, float* bias) override {}
        virtual void gyrCalibMatrix(float* cal, float* bias) override {}
        virtual void filterMagMatrix(float* mat) override {}
        virtual void filterAccMatrix(float* mat) override {}
        virtual void filterGyrMatrix(float* mat) override {}
        virtual void filterProcMatrix(float* mat) override {}
        virtual void temperature(float temp) override {}
        virtual void baudRate(uint8_t rate) override {}
        virtual void i2cAddress(uint8_t addr) override {}
        virtual void confirm() override {}
        virtual void rawAccData(int16_t x, int16_t y, int16_t z) override {}
        virtual void rawMagData(int16_t x, int16_t y, int16_t z) override {}
        virtual void rawGyrData(int16_t x, int16_t y, int16_t z) override {}
        virtual void normAccData(float x, float y, float z) override {}
        virtual void normMagData(float x, float y, float z) override {}
        virtual void normGyrData(float x, float y, float z) override {}
        virtual void calibAccData(float x, float y, float z) override {}
        virtual void calibMagData(float x, float y, float z) override {}
        virtual void calibGyrData(float x, float y, float z) override {}
        virtual void stats(uint32_t perf0, uint32_t perf1, uint32_t perf2, uint32_t perf3, uint32_t perf4, uint32_t perf5, uint32_t perf6, uint32_t perf7) override {}
    };

}