SopasBase.hpp

Go to the documentation of this file.

//
// SopasBase.h
//
//  Created on: 18.07.2011
//     Author: sick
//

#ifndef SOPASBASE_H
#define SOPASBASE_H

#include "sick_scan/tcp/BasicDatatypes.hpp"
// #include "sick_scan/tcp/datatypes/Scan.hpp"
#include "sick_scan/tcp/interfaces/tcp.hpp"

#include "colaa.hpp"
#include "colab.hpp"
#include <map>  // for std::map
#include "sick_scan/tcp/tools/Mutex.hpp"

namespace devices
{
        
class SopasEventMessage;
class SopasAnswer;

class SopasBase
{
public:
        static const std::string EVENTNAME_SUBSCRIBE_EVALCASES;
        static const std::string EVENTNAME_SUBSCRIBE_SCANS;
        static const std::string METHODNAME_LOGIN;
        static const std::string METHODNAME_LOGOUT;
        static const std::string METHODNAME_SET_SCANCONFIG;
        static const std::string METHODNAME_START_MEASURE;
        static const std::string METHODNAME_STOP_MEASURE;
        static const std::string VARIABLENAME_DEVICEIDENT;
        static const std::string VARIABLENAME_SCANCONFIG;
        static const std::string VARIABLENAME_DATAOUTPUTRANGE;
        static const std::string VARIABLENAME_SCANDATACONFIG;

        // sopas commands
        static const std::string COMMAND_Read_Variable_ByIndex;
        static const std::string COMMAND_Write_Variable_ByIndex;
        static const std::string COMMAND_Invoke_Method_ByIndex;
        static const std::string COMMAND_Method_Result_ByIndex;
        static const std::string COMMAND_Register_Event_ByIndex;
        static const std::string COMMAND_Send_Event_ByIndex; // receive data event

        static const std::string COMMAND_Read_Variable_Answer;
        static const std::string COMMAND_Write_Variable_Answer;
        static const std::string COMMAND_Invoke_Method_Answer;
        static const std::string COMMAND_Method_Result_Answer;
        static const std::string COMMAND_Register_Event_Answer;
        static const std::string COMMAND_Event_Acknowledge;

        static const std::string COMMAND_Read_Variable_ByName;
        static const std::string COMMAND_Write_Variable_ByName;
        static const std::string COMMAND_Invoke_Method_ByName;
        static const std::string COMMAND_Method_Result_ByName;
        static const std::string COMMAND_Register_Event_ByName;
        static const std::string COMMAND_Send_Event_ByName; // receive data event

        static const UINT16 INDEX_DEVICE_IDENT;

        enum SopasProtocol
        {
                CoLa_A, 
                CoLa_B  
        };

        enum SopasEncoding
        {
                ByName, 
                ByIndex 
        };

        enum SopasMessageType
        {
                MSG_UNKNOWN, 
                //              MSG_READ_VARIABLE, ///< Read Variable
                //              MSG_WRITE_VARIABLE, ///< Write Variable
                //              MSG_INVOKE_METHOD, ///< Invoke Method
                //              MSG_METHOD_RESULT, ///< Method Result
                //              MSG_REGISTER_EVENT, ///< Register Event
                MSG_SEND_EVENT, 
                MSG_READ_VARIABLE_ANSWER, 
                MSG_WRITE_VARIABLE_ANSWER, 
                MSG_INVOKE_METHOD_ANSWER, 
                MSG_METHOD_RESULT_ANSWER, 
                MSG_REGISTER_EVENT_ANSWER, 
                MSG_EVENT_ACKNOWLEDGE, 
                MSG_ERROR
        };

        typedef void (*DecoderFunction)(SopasEventMessage& frame);      //  Decoder for events

        SopasBase();

        virtual ~SopasBase();


        virtual bool init(SopasProtocol protocol,
                                                std::string ipAddress,
                                                UINT16 portNumber,
                                                bool weWantScanData,
                                                bool weWantFieldData,
                                                bool readOnlyMode,
                                                Tcp::DisconnectFunction disconnectFunction,
                                                void* obj);

        bool connect();

        bool isConnected();

        bool disconnect();

        bool action_getScannerTypeAndVersion();


        void setReadOnlyMode(bool mode);

        bool isReadOnly();

        bool invokeMethod(const std::string& methodeName, BYTE* parameters, UINT16 parametersLength, SopasAnswer*& answer);

        bool invokeMethod(UINT16 index, BYTE* parameters, UINT16 parametersLength, SopasAnswer*& answer);

        bool readVariable(const std::string& variableName, SopasAnswer*& answer);

        bool readVariable(UINT16 index, SopasAnswer*& answer);

        bool writeVariable(const std::string& variableName, BYTE* parameters, UINT16 parametersLength);

        bool writeVariable(UINT16 index, BYTE* parameters, UINT16 parametersLength);

        bool registerEvent(const std::string& eventName);

        bool registerEvent(UINT16 index);

        bool unregisterEvent(const std::string& eventName);

        bool unregisterEvent(UINT16 index);

        void setEventCallbackFunction(DecoderFunction decoderFunction, const std::string& eventName)
        {
                m_decoderFunctionMapByName[eventName] = decoderFunction;
        }

        void setEventCallbackFunction(DecoderFunction decoderFunction, UINT16 eventIndex)
        {
                m_decoderFunctionMapByIndex[eventIndex] = decoderFunction;
        }


        double makeAngleValid(double angle);

        const std::string& getScannerName() const { return m_scannerName; }
        const std::string& getScannerVersion() const { return m_scannerVersion; }

        // Convert a SOPAS error code to readable text
        static std::string convertSopasErrorCodeToText(UINT16 errorCode);

protected:

        enum SopasCommand
        {
                CMD_UNKNOWN = 0, 
                RI = 1, 
                WI = 2, 
                MI = 3, 
                AI = 4, 
                EI = 5, 
                SI = 6, 
                RA = 7, 
                WA = 8, 
                MA = 9, 
                AA = 10, 
                EA = 11, 
                SA = 12, 
                RN = 20, 
                AN = 21, 
                SN = 22, 
                FA = 50
        };

        enum State
        {
                CONSTRUCTED
                ,
                CONNECTED
                //              , RUNNING
        };

        bool receiveAnswer(SopasCommand cmd, std::string name, UINT32 timeout, SopasAnswer*& answer);
        bool receiveAnswer_CoLa_A(SopasCommand cmd, std::string name, UINT32 timeout, SopasAnswer*& answer );
        bool receiveAnswer_CoLa_B(SopasCommand cmd, std::string name, UINT32 timeout, SopasAnswer*& answer );
        bool receiveAnswer(SopasCommand cmd, UINT16 index, UINT32 timeout, SopasAnswer*& answer );
        bool receiveAnswer_CoLa_A(SopasCommand cmd, UINT16 index, UINT32 timeout, SopasAnswer*& answer);
        bool receiveAnswer_CoLa_B(SopasCommand cmd, UINT16 index, UINT32 timeout, SopasAnswer*& answer);

        void sendCommandBuffer(UINT8* buffer, UINT16 len);

        SopasCommand colaA_decodeCommand(std::string* rxData);

        SopasCommand stringToSopasCommand(const std::string& cmdString);
        std::string sopasCommandToString(SopasCommand cmd);

protected:
        // Decoder functions that need to be overwritten by derived classes
        virtual void evalCaseResultDecoder(SopasEventMessage& msg) = 0;
        virtual void scanDataDecoder(SopasEventMessage& msg) = 0;
        
        bool m_scanEventIsRegistered;
        bool m_fieldEventIsRegistered;
        bool m_weWantScanData; 
        bool m_weWantFieldData; 

        State m_state;
        std::string m_scannerName; 
        std::string m_scannerVersion; 

        bool m_beVerbose; //   true = Show extended status traces

        bool m_isLoggedIn;

private:
        // TCP
        bool openTcpConnection();
        void closeTcpConnection();

        static void readCallbackFunctionS(void* obj, UINT8* buffer, UINT32& numOfBytes);
        void readCallbackFunction(UINT8* buffer, UINT32& numOfBytes);

        SopasEventMessage findFrameInReceiveBuffer();

        void processFrame(SopasEventMessage& frame);
        void processFrame_CoLa_A(SopasEventMessage& frame);
        void processFrame_CoLa_B(SopasEventMessage& frame);
        void copyFrameToResposeBuffer(UINT32 frameLength);
        void removeFrameFromReceiveBuffer(UINT32 frameLength);

        // SOPAS / Cola
        SopasProtocol m_protocol; 
        SopasEncoding m_encoding; 
        void colaA_decodeScannerTypeAndVersion(std::string* rxData);
        void colaB_decodeScannerTypeAndVersion(UINT8* buffer, UINT16 pos);

private:
        typedef std::map<std::string, DecoderFunction> DecoderFunctionMapByName;
        typedef std::map<UINT16, DecoderFunction> DecoderFunctionMapByIndex;
        DecoderFunctionMapByName m_decoderFunctionMapByName;
        DecoderFunctionMapByIndex m_decoderFunctionMapByIndex;

//      DecoderFunction m_scanDecoderFunction;
//      DecoderFunction m_evalCaseDecoderFunction;

        typedef std::map<UINT16, std::string> IndexToNameMap;
        IndexToNameMap m_indexToNameMap;

        // Response buffer
        UINT32 m_numberOfBytesInResponseBuffer; 
        UINT8 m_responseBuffer[1024]; 
        Mutex m_receiveDataMutex; 

        // Receive buffer
        UINT32 m_numberOfBytesInReceiveBuffer; 
        UINT8 m_receiveBuffer[25000]; 

        // TCP
        Tcp m_tcp;
        std::string m_ipAddress;
        UINT16 m_portNumber;

        bool m_readOnlyMode;
};


class SopasEventMessage
{
public:
        SopasEventMessage();

        ~SopasEventMessage() {}

        SopasEventMessage(BYTE* buffer, SopasBase::SopasProtocol protocol, UINT32 frameLength);

        SopasBase::SopasProtocol getProtocolType() const
        {
                return m_protocol;
        }

        SopasBase::SopasEncoding getEncodingType() const
        {
                return m_encoding;
        }

        SopasBase::SopasMessageType getMessageType() const
        {
                return m_messageType;
        }

        UINT32 size() const
        {
                return m_frameLength;
        }

        UINT32 getPayLoadLength() const;

        std::string getCommandString() const;

        BYTE* getPayLoad();

        INT32 getVariableIndex();

        std::string getVariableName();

        bool isValid() const { return (m_buffer != NULL); }

private:
        void detectEncoding();

        void detectMessageType();

private:
        BYTE* m_buffer;
        SopasBase::SopasProtocol m_protocol;
        UINT32 m_frameLength;
        SopasBase::SopasEncoding m_encoding;
        SopasBase::SopasMessageType m_messageType;
};

class SopasAnswer
{
public:
        SopasAnswer(const BYTE* answer, UINT32 answerLength);

        ~SopasAnswer();

        BYTE* getBuffer() { return m_answerBuffer; }

        UINT32 size() { return m_answerLength; }

        bool isValid() { return (m_answerBuffer != NULL); }

private:
        UINT32 m_answerLength;
        BYTE*  m_answerBuffer;
};

}       // namespace devices

#endif // SOPASBASE_H