cmt2.h

Go to the documentation of this file.

#ifndef XSENS_MONOLITHIC

#endif
#ifndef CMT2_H
#define CMT2_H

#ifndef XSENS_MONOLITHIC
#       include "cmt1.h"
#       include "cmtmessage.h"
#       include "xsens_fifoqueue.h"
#endif

namespace xsens {


int32_t findValidMessage(const uint8_t* buffer, const uint16_t bufferLength);



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

        CmtCallbackFunction m_onMessageReceived;
        int32_t m_onMessageReceivedInstance;
        void* m_onMessageReceivedParam;

        CmtCallbackFunction m_onMessageSent;
        int32_t m_onMessageSentInstance;
        void* m_onMessageSentParam;

protected:
        uint32_t m_baudrate;
        Cmt1s m_cmt1s;
        mutable XsensResultValue m_lastResult;
        uint8_t m_readBuffer[CMT_DEFAULT_READ_BUFFER_SIZE];
        uint16_t m_readBufferCount;
        uint32_t m_timeout;
        uint32_t m_toEnd;
public:
        Cmt2s();

        ~Cmt2s();

        XsensResultValue close(void);

        uint32_t getBaudrate(void) { return (m_baudrate = m_cmt1s.getBaudrate()); }
        Cmt1s* getCmt1s(void) { return &m_cmt1s; }
        XsensResultValue getLastResult(void) const { return m_lastResult; }
        XsensResultValue getPortNr(uint16_t& port) const;
        XsensResultValue getPortNr(int32_t& port) const;
        XsensResultValue getPortName(char *portname) const;
        uint32_t getTimeout(void) const { return m_timeout; }
        bool isOpen (void) const { return (m_cmt1s.isOpen()); }
        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 readMessage(Message* rcv);

        XsensResultValue setCallbackFunction(CmtCallbackType tp, int32_t instance, CmtCallbackFunction func, void* param);

        XsensResultValue setTimeout(const uint32_t ms = CMT2_DEFAULT_TIMEOUT);

        XsensResultValue waitForMessage(Message* rcv, const uint8_t msgId, uint32_t timeoutOverride, bool acceptErrorMessage);
        XsensResultValue writeMessage(Message* msg);
};


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

protected:
        Cmt1f m_cmt1f;
        mutable XsensResultValue m_lastResult;

        bool m_readOnly;                                

public:
        Cmt2f();
        ~Cmt2f();
        XsensResultValue close(void);
        XsensResultValue closeAndDelete(void);
        XsensResultValue create(const char* filename);
        XsensResultValue create(const wchar_t* filename);
        Cmt1f* getCmt1f(void);

        XsensResultValue getLastResult(void) const;
        XsensResultValue getName(char* filename) const;
        XsensResultValue getName(wchar_t* filename) const;
        bool isOpen(void) const;
        XsensResultValue open(const char* filename, const bool readOnly = false);
        XsensResultValue open(const wchar_t* filename, const bool readOnly = false);
        XsensResultValue readMessage(Message* msg, const uint8_t msgId = 0);
        XsensFilePos getFileSize(void);
        XsensFilePos getReadPosition(void);
        XsensResultValue setReadPosition(XsensFilePos pos);
        XsensResultValue writeMessage(const Message* msg);
};

} // end of xsens namespace

#endif  // CMT2_H