cmt1.h

Go to the documentation of this file.

#ifndef XSENS_MONOLITHIC

#endif
#ifndef CMT1_H
#define CMT1_H

#ifndef CMTDEF_H
#       include "cmtdef.h"
#endif

#include <stdlib.h>
#include <stdio.h>
#ifdef _WIN32
#       include <windows.h>
//#     include <sys/types.h>
#else
#       include <termios.h>
// these are not required by level 1, but to keep the higher levels platform-independent they are put here
#       include <string.h>
#       include <stddef.h>
#define _strnicmp       strncasecmp
#endif

#include <stdio.h>

namespace xsens {

#ifndef CMTLOG
#       if defined(XSENS_DEBUG) || defined(CMT_LOG_ALWAYS)
                void CMTLOG(const char *str, ...);
#               define CMTEXITLOG(str)  JanitorFunc2R<const char*,XsensResultValue> _cmtExitLog(CMTLOG,str " returns %u",m_lastResult);
#       else
#               define CMTLOG(...)
#               define CMTEXITLOG(...)
#       endif
#endif

#ifndef _WIN32
int _wcsnicmp(const wchar_t* s1, const wchar_t* s2,int count);
typedef int32_t HANDLE;
#endif


class Cmt1s {
private:
        Cmt1s(const Cmt1s& ref);

        #ifdef LOG_RX_TX
                FILE* rx_log;
                FILE* tx_log;
        #endif

        CmtCallbackFunction m_onBytesReceived;
        int32_t m_onBytesReceivedInstance;
        void* m_onBytesReceivedParam;
protected:
        uint32_t m_baudrate;
        uint32_t m_endTime;
        bool m_isOpen;
        mutable XsensResultValue m_lastResult;
        uint16_t m_port;
        char m_portname[32];
        uint32_t m_timeout;

        #ifdef _WIN32
                DCB             m_commState;            
                HANDLE  m_handle;                       
        #else
                termios m_commState;            
                int32_t         m_handle;                       
        #endif
public:
        Cmt1s();
        ~Cmt1s();
        XsensResultValue close (void);
        XsensResultValue escape (const CmtControlLine mask, const CmtControlLine state);
        XsensResultValue flushData (void);
        uint32_t getBaudrate(void) const;
        HANDLE getHandle(void) const;
        uint16_t getPortNr (void) const;
        void getPortName(char *portname) const;
        XsensResultValue getLastResult(void) const;
        uint32_t getTimeout (void) const;
        bool isOpen (void) const;
        
        XsensResultValue open ( const char *portName,
                                                        const uint32_t baudRate = CMT_DEFAULT_BAUD_RATE,
                                                        uint32_t readBufSize = CMT_DEFAULT_READ_BUFFER_SIZE,
                                                        uint32_t writeBufSize = CMT_DEFAULT_WRITE_BUFFER_SIZE);

#ifdef _WIN32

        XsensResultValue open ( const uint32_t portNumber,
                                                        const uint32_t baudRate = CMT_DEFAULT_BAUD_RATE,
                                                        uint32_t readBufSize = CMT_DEFAULT_READ_BUFFER_SIZE,
                                                        uint32_t writeBufSize = CMT_DEFAULT_WRITE_BUFFER_SIZE);
#endif

        XsensResultValue readData (const uint32_t maxLength, uint8_t* data,
                                                                uint32_t* length = NULL);
        XsensResultValue setCallbackFunction(CmtCallbackType tp, int32_t instance, CmtCallbackFunction func, void* param);
        XsensResultValue setTimeout (const uint32_t ms = CMT1_DEFAULT_TIMEOUT);
        XsensResultValue waitForData (const uint32_t maxLength, uint8_t* data,
                                                                uint32_t* length = NULL);
        XsensResultValue writeData (const uint32_t length, const uint8_t* data,
                                                                uint32_t* written);

};


class Cmt1f {
private:
        Cmt1f(const Cmt1f& ref);

protected:
        FILE* m_handle;
        XsensFilePos m_fileSize;
        XsensFilePos m_readPos;
        XsensFilePos m_writePos;
        mutable XsensResultValue m_lastResult;
        char m_filename[CMT_MAX_FILENAME_LENGTH];
        wchar_t m_filename_w[CMT_MAX_FILENAME_LENGTH];
        bool m_isOpen;
        bool m_unicode;
        bool m_reading;
        bool m_readOnly;
        void gotoRead(void);
        void gotoWrite(void);
public:
        Cmt1f();
        ~Cmt1f();
        XsensResultValue appendData(const uint32_t length,  const void* data);
        XsensResultValue close(void);
        XsensResultValue closeAndDelete(void);
        XsensResultValue create(const char* filename);
        XsensResultValue create(const wchar_t* filename);
        XsensResultValue deleteData(const XsensFilePos start, const uint32_t length);
        XsensResultValue find(const void* needle, const uint32_t needleLength, XsensFilePos& pos);
        XsensResultValue flushData(void);
        XsensFilePos getFileSize(void) const { return m_fileSize; }
        XsensResultValue getLastResult(void) const      { return m_lastResult; }
        XsensResultValue getName(char* filename) const;
        XsensResultValue getName(wchar_t* filename) const;
        XsensFilePos getReadPos(void) const { return m_readPos; }
        XsensFilePos getWritePos(void) const { return m_writePos; }
        XsensResultValue insertData(const XsensFilePos start, const uint32_t length,
                                                                const void* data);
        bool isOpen(void) const { return m_isOpen; }
        bool isReadOnly(void) const { return !m_isOpen || m_readOnly; }
        XsensResultValue open(const char* filename, const bool create, const bool readOnly);
        XsensResultValue open(const wchar_t* filename, const bool create, const bool readOnly);
        XsensResultValue readData(const uint32_t maxLength, void* data, uint32_t* length);
        XsensResultValue readData(const uint32_t maxLength, const char terminator, void* data, uint32_t* length);
        XsensResultValue setReadPos(const XsensFilePos pos);
        XsensResultValue setWritePos(const XsensFilePos pos = -1);

        XsensResultValue writeData(const uint32_t length,  const void* data);
};

}       // end of xsens namespace

#endif  // CMT1_H