sick_scan_common_nw.h

Go to the documentation of this file.

//
// Created by michael on 1/22/18.
//
 
#ifndef SICK_SCAN_SICK_SCAN_COMMON_NW_H
#define SICK_SCAN_SICK_SCAN_COMMON_NW_H
 
#include "sick_scan/tcp/BasicDatatypes.hpp"
#include "sick_scan/tcp/tcp.hpp"
#include <map>  // for std::map
 
//
// SickScanCommonNw.cpp
//
//  Created on: 18.07.2011
//      Author: sick
//
#include "sick_scan/tcp/tcp.hpp"
#include "sick_scan/tcp/errorhandler.hpp"
#include "sick_scan/tcp/toolbox.hpp"
#include "sick_scan/tcp/Mutex.hpp"
 
 
#include <string>
 
class SopasEventMessage;
 
class SopasAnswer;
 
enum SopasProtocol
{
  CoLa_A, 
  CoLa_B,  
  CoLa_Unknown  
};
 
 
class SickScanCommonNw
{
public:
 
 
  SickScanCommonNw();
 
  ~SickScanCommonNw();
 
  bool init(std::string ipAddress,
            unsigned short portNumber,
            Tcp::DisconnectFunction disconnectFunction,
            void *obj);
 
  bool setReadCallbackFunction(Tcp::ReadFunction readFunction,
                               void *obj);
 
  bool connect();
 
  bool isConnected();
 
  bool disconnect();
 
  void sendCommandBuffer(UINT8 *buffer, UINT16 len);
 
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);
 
  bool m_beVerbose;
 
 
  // 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;
  SopasProtocol m_protocol;
 
 
  void copyFrameToResposeBuffer(UINT32 frameLength);
 
  void removeFrameFromReceiveBuffer(UINT32 frameLength);
 
protected:
  enum State
  {
    CONSTRUCTED
    ,
    CONNECTED
    //          , RUNNING
  };
 
  State m_state;
};
 
class SopasEventMessage
{
public:
  SopasEventMessage();
 
  ~SopasEventMessage()
  {}
 
  SopasEventMessage(BYTE *buffer, SopasProtocol protocol, UINT32 frameLength);
 
  SopasProtocol getProtocolType() const
  {
    return m_protocol;
  }
 
 
  UINT32 size() const
  {
    return m_frameLength;
  }
 
  UINT32 getPayLoadLength() const;
 
  std::string getCommandString() const;
 
  BYTE *getPayLoad();
 
  BYTE *getRawData();
 
  INT32 getVariableIndex();
 
  std::string getVariableName();
 
  bool isValid() const
  { return (m_buffer != NULL); }
 
private:
  void detectEncoding();
 
  void detectMessageType();
 
private:
  BYTE *m_buffer;
  SopasProtocol m_protocol;
  UINT32 m_frameLength;
};
 
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;
};
 
#endif //SICK_SCAN_SICK_SCAN_COMMON_NW_H