communicator.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef COMMUNICATOR_H
#define COMMUNICATOR_H
 
#include "callbackmanagerxda.h"
#include "openportstage.h"
#include "protocolmanager.h"
#include "replyobject.h"
 
#include <xscommon/xsens_mutex.h>
#include "iointerfacefile.h"
#include "iprotocolhandler.h"
#include "serialinterface.h"
#include <xstypes/xsresultvalue.h>
#include <xstypes/xstimestamp.h>
 
#include <memory>
#include <vector>
 
struct XsByteArray;
struct XsString;
struct XsMessage;
struct XsDeviceConfiguration;
namespace xsens
{
class ReplyMonitor;
}
 
struct Communicator : public CallbackManagerXda
{
public:
        void destroy();
 
        struct Deleter
        {
                void operator()(Communicator* c)
                {
                        if (c != nullptr)
                                c->destroy();
                }
        };
 
        template <typename T>
        using UniquePtr = std::unique_ptr<T, Deleter>;
 
        template <typename T>
        static UniquePtr<T> createUniquePtr()
        {
                return UniquePtr<T>(new T(), Deleter());
        }
 
        template <typename T>
        static UniquePtr<T> createUniquePtr(T* communicator)
        {
                return UniquePtr<T>(communicator, Deleter());
        }
 
        Communicator(void);
 
        bool doTransaction(const XsMessage& message);
        bool doTransaction(const XsMessage& message, uint32_t timeout);
        bool doTransaction(const XsMessage& message, XsMessage& rcv);
 
        virtual bool doTransaction(const XsMessage& message, XsMessage& rcv, uint32_t timeout) = 0;
 
        void setDefaultTimeout(uint32_t timeout)
        {
                m_defaultTimeout = timeout;
        }
 
        uint32_t defaultTimeout() const
        {
                return m_defaultTimeout;
        }
 
        XsResultValue lastResult() const;
        XsString lastResultText() const;
        virtual void handleMessage(const XsMessage& message);
        XsSize childDeviceCount() const;
        XsDeviceId masterDeviceId() const;
 
        std::shared_ptr<ReplyObject> addReplyObject(uint8_t mid);
        std::shared_ptr<ReplyObject> addReplyObject(uint8_t mid, XsSize offset, XsSize size, uint8_t const* data);
        std::shared_ptr<ReplyObject> addReplyObject(ReplyObject* obj);
 
        // live stuff
 
        virtual XsResultValue gotoConfig(bool detectRs485 = false) = 0;
 
        virtual XsResultValue gotoMeasurement() = 0;
 
        virtual XsResultValue getDeviceId() = 0;
 
        virtual void setGotoConfigTimeout(uint32_t timeout) = 0;
 
        virtual bool writeMessage(const XsMessage& message) = 0;
 
        virtual void flushPort() = 0;
 
        virtual void closePort() = 0;
 
        virtual void scheduleClosePort()
        {
                closePort();
        }
 
        virtual bool isPortOpen() const = 0;
 
        virtual XsPortInfo portInfo() const = 0;
 
        virtual bool openPort(const XsPortInfo& portInfo, OpenPortStage stage = OPS_Full, bool detectRs485 = false) = 0;
 
        virtual bool reopenPort(OpenPortStage stage = OPS_Full, bool skipDeviceIdCheck = false) = 0;
 
        virtual bool isDockedAt(Communicator* other) const = 0;
 
        virtual void setKeepAlive(bool enable) = 0;
 
        // file stuff
 
        virtual void closeLogFile() = 0;
 
        virtual XsMessage readMessage(uint8_t msgId = 0) = 0;
 
        virtual XsMessage readMessageFromStartOfFile(uint8_t msgId, int maxMsgs = 0) = 0;
 
        virtual std::deque<XsMessage> readMessagesFromStartOfFile(uint8_t msgId, int maxMsgs = 0) = 0;
 
        virtual void loadLogFile(XsDevice* device) = 0;
 
        virtual void abortLoadLogFile() = 0;
 
        virtual bool openLogFile(const XsString& filename) = 0;
 
        virtual XsString logFileName() const = 0;
 
        virtual XsFilePos logFileSize() const = 0;
 
        virtual XsTimeStamp logFileDate() const = 0;
 
        virtual XsFilePos logFileReadPosition() const = 0;
 
        virtual void resetLogFileReadPosition(void) = 0;
 
        virtual bool isReadingFromFile() const = 0;
 
        virtual void waitForLastTaskCompletion() = 0;
 
        virtual bool isLoadLogFileInProgress() const;
 
        virtual bool allowReprocessing() const;
 
        static int configurationMessageSearchLimit()
        {
                return 20;
        }
 
        virtual void setCredentials(XsString const& id, XsString const& key);
 
        bool sanityCheck(XsMessage const& msg) const;
 
        virtual void addProtocolHandler(IProtocolHandler* handler);
        void removeProtocolHandler(XsProtocolType type);
        bool hasProtocol(XsProtocolType type) const;
 
        void setMasterDevice(XsDevice* masterDevice);
 
protected:
        virtual ~Communicator();
        virtual void prepareForDestruction();
 
        XsDevice* masterDevice() const;
        std::shared_ptr<ProtocolManager> protocolManager() const;
 
        // these may be a bit surprising:
        void setLastResult(XsResultValue lastResult, XsString const& text = XsString()) const;
        XsResultValue setAndReturnLastResult(XsResultValue lastResult, XsString const& text = XsString()) const;
 
        void setMasterDeviceId(const XsDeviceId& deviceId);
 
        bool m_preparedForDestruction;
 
        XsDevice* m_masterInfo;
 
        std::shared_ptr<ProtocolManager> m_protocolManager;
 
        XsDeviceId m_masterDeviceId;
 
        std::unique_ptr<xsens::ReplyMonitor> m_replyMonitor;
 
        mutable XsResultValue m_lastResult;
 
        mutable XsString m_lastResultText;
 
        mutable xsens::Mutex m_handleMux;
 
        uint32_t m_defaultTimeout;
};
 
#endif