InertialSense.h

Go to the documentation of this file.

/*
MIT LICENSE

Copyright (c) 2014-2021 Inertial Sense, Inc. - http://inertialsense.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files(the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions :

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef __INTERTIALSENSE_H
#define __INTERTIALSENSE_H

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>

#include "ISConstants.h"
#include "ISTcpClient.h"
#include "ISTcpServer.h"
#include "ISLogger.h"
#include "ISDisplay.h"
#include "ISUtilities.h"
#include "ISSerialPort.h"
#include "ISDataMappings.h"
#include "ISStream.h"

// use of InertialSense class requires winsock
#if PLATFORM_IS_WINDOWS

#pragma comment (lib, "Ws2_32.lib")

#endif

extern "C"
{
        // [C COMM INSTRUCTION]  Include data_sets.h and com_manager.h  
        #include "data_sets.h"
        #include "com_manager.h"

        #include "serialPortPlatform.h"
        #include "inertialSenseBootLoader.h"
}

#include <functional>

class InertialSense;

typedef std::function<void(InertialSense* i, p_data_t* data, int pHandle)> pfnHandleBinaryData;
typedef void(*pfnStepLogFunction)(InertialSense* i, const p_data_t* data, int pHandle);

using namespace std;

class InertialSense : public iISTcpServerDelegate
{
public:
        struct is_device_t
        {
                serial_port_t serialPort;
                dev_info_t devInfo;
                system_command_t sysCmd;
                nvm_flash_cfg_t flashConfig;
                evb_flash_cfg_t evbFlashCfg;
        };

        struct com_manager_cpp_state_t
        {
                // per device vars
                vector<is_device_t> devices;

                // common vars
                pfnHandleBinaryData binaryCallbackGlobal;
                pfnHandleBinaryData binaryCallback[256];
                pfnStepLogFunction stepLogFunction;
                InertialSense* inertialSenseInterface;
                char* clientBuffer;
                int clientBufferSize;
                int* clientBytesToSend;
        };

        typedef struct
        {
                string port;
                string error;
        } bootloader_result_t;

        InertialSense(pfnHandleBinaryData callback = NULL);

        virtual ~InertialSense();

        /*
        * Broadcast binary data
        * @param dataId the data id (DID_* - see data_sets.h) to broadcast
        * @param periodMultiple a scalar that the source period is multiplied by to give the output period in milliseconds, 0 for one time message, less than 0 to disable broadcast of the specified dataId
        * @param callback optional callback for this dataId
        * @return true if success, false if error - if callback is NULL and no global callback was passed to the constructor, this will return false
        */ 
        bool BroadcastBinaryData(uint32_t dataId, int periodMultiple, pfnHandleBinaryData callback = NULL);

        void Close();

        vector<string> GetPorts();

        bool IsOpen();

        bool Open(const char* port, int baudRate = IS_COM_BAUDRATE_DEFAULT, bool disableBroadcastsOnClose = false);

        size_t GetDeviceCount();

        bool Update();

        bool SetLoggerEnabled(
        bool enable, 
        const string& path = cISLogger::g_emptyString, 
        cISLogger::eLogType logType = cISLogger::eLogType::LOGTYPE_DAT, 
        uint64_t rmcPreset = RMC_PRESET_PPD_BITS, 
        float maxDiskSpacePercent = 0.5f, 
        uint32_t maxFileSize = 1024 * 1024 * 5, 
        const string& subFolder = cISLogger::g_emptyString);

        void BroadcastBinaryDataRmcPreset(uint64_t rmcPreset=RMC_PRESET_INS_BITS, uint32_t rmcOptions=0);

        bool LoggerEnabled() { return m_logger.Enabled(); }

        bool OpenServerConnection(const string& connectionString);

        bool CreateHost(const string& ipAndPort);

        void CloseServerConnection();

        void StopBroadcasts(bool allPorts=true);

        void SendData(eDataIDs dataId, uint8_t* data, uint32_t length, uint32_t offset);

        void SendRawData(eDataIDs dataId, uint8_t* data, uint32_t length = 0, uint32_t offset = 0);

        const dev_info_t GetDeviceInfo(int pHandle = 0)
        {
                if ((size_t)pHandle >= m_comManagerState.devices.size())
                {
                        pHandle = 0;
                }
                return m_comManagerState.devices[pHandle].devInfo;
        }

        system_command_t GetSysCmd(int pHandle = 0) 
        { 
                if ((size_t)pHandle >= m_comManagerState.devices.size())
                {
                        pHandle = 0;
                }
                return m_comManagerState.devices[pHandle].sysCmd;
        }

        void SetSysCmd(const system_command_t& sysCmd, int pHandle = 0);

        nvm_flash_cfg_t GetFlashConfig(int pHandle = 0) 
        {
                if ((size_t)pHandle >= m_comManagerState.devices.size())
                {
                        pHandle = 0;
                }
                return m_comManagerState.devices[pHandle].flashConfig;
        }

        evb_flash_cfg_t GetEvbFlashConfig(int pHandle = 0) 
        {
                if ((size_t)pHandle >= m_comManagerState.devices.size())
                {
                        pHandle = 0;
                }
                return m_comManagerState.devices[pHandle].evbFlashCfg;
        }

        void SetFlashConfig(const nvm_flash_cfg_t& flashConfig, int pHandle = 0);

        void SetEvbFlashConfig(const evb_flash_cfg_t& evbFlashCfg, int pHandle = 0);

        uint64_t GetClientServerByteCount() { return m_clientServerByteCount; }

        serial_port_t* GetSerialPort(int pHandle = 0) 
        {
                if ((size_t)pHandle >= m_comManagerState.devices.size())
                {
                        return NULL;
                }
                return &(m_comManagerState.devices[pHandle].serialPort);
        }

        time_t GetTimeoutFlushLoggerSeconds() { return m_logger.GetTimeoutFlushSeconds(); }

        void SetTimeoutFlushLoggerSeconds(time_t timeoutFlushLoggerSeconds) { m_logger.SetTimeoutFlushSeconds(timeoutFlushLoggerSeconds); }

        static vector<bootloader_result_t> BootloadFile(const string& comPort, const string& fileName, const string& bootloaderFileName, int baudRate = IS_BAUD_RATE_BOOTLOADER, pfnBootloadProgress uploadProgress = NULLPTR, pfnBootloadProgress verifyProgress = NULLPTR, pfnBootloadStatus infoProgress = NULLPTR, bool updateBootloader = false);
        static vector<bootloader_result_t> BootloadFile(const string& comPort, const string& fileName, int baudRate = IS_BAUD_RATE_BOOTLOADER, pfnBootloadProgress uploadProgress = NULLPTR, pfnBootloadProgress verifyProgress = NULLPTR, bool updateBootloader = false);

protected:
        bool OnPacketReceived(const uint8_t* data, uint32_t dataLength);
        void OnClientConnecting(cISTcpServer* server) OVERRIDE;
        void OnClientConnected(cISTcpServer* server, socket_t socket) OVERRIDE;
        void OnClientConnectFailed(cISTcpServer* server) OVERRIDE;
        void OnClientDisconnected(cISTcpServer* server, socket_t socket) OVERRIDE;

private:
        InertialSense::com_manager_cpp_state_t m_comManagerState;
        cISLogger m_logger;
        void* m_logThread;
        cMutex m_logMutex;
        map<int, vector<p_data_t>> m_logPackets;
        time_t m_lastLogReInit;
        cISTcpClient m_tcpClient;
        char m_clientBuffer[512];
        int m_clientBufferBytesToSend;
        cISTcpServer m_tcpServer;
        cISSerialPort m_serialServer;
        cISStream* m_clientStream;
        uint64_t m_clientServerByteCount;
        bool m_disableBroadcastsOnClose;
        com_manager_init_t m_cmInit;
        com_manager_port_t *m_cmPorts;
        is_comm_instance_t m_gpComm;
        uint8_t m_gpCommBuffer[PKT_BUF_SIZE];

        // returns false if logger failed to open
        bool EnableLogging(const string& path, cISLogger::eLogType logType, float maxDiskSpacePercent, uint32_t maxFileSize, const string& subFolder);
        void DisableLogging();
        bool HasReceivedResponseFromDevice(size_t index);
        bool HasReceivedResponseFromAllDevices();
        void RemoveDevice(size_t index);
        bool OpenSerialPorts(const char* port, int baudRate);
        static void LoggerThread(void* info);
        static void StepLogger(InertialSense* i, const p_data_t* data, int pHandle);
};

#endif