SafeVisionaryDataStream.h

Go to the documentation of this file.

// -- BEGIN LICENSE BLOCK ----------------------------------------------
// -- END LICENSE BLOCK ------------------------------------------------
 
#pragma once
 
#include "TcpSocket.h"
#include "UdpSocket.h"
#include "VisionaryData.h"
#include <memory>
#include <vector>
 
namespace visionary {
struct UdpProtocolData
{
  uint16_t blobNumber;     
  uint16_t fragmentNumber; 
  uint16_t dataLength;     
  bool isLastFragment;     
};
 
enum class DataStreamError
{
  OK,
  DATA_RECEIVE_TIMEOUT,
  CONNECTION_CLOSED,
  PARSE_XML_ERROR,
  INVALID_VERSION_UDP_HEADER,
  INVALID_PACKET_TYPE_UDP_HEADER,
  INVALID_LENGTH_UDP_HEADER,
  INVALID_CRC_UDP_HEADER,
  INVALID_BLOB_HEADER,
  INVALID_VERSION_BLOB_HEADER,
  INVALID_PACKET_TYPE_BLOB_HEADER,
  INVALID_BLOB_ID,
  INVALID_BLOB_NUMBER,
  INVALID_UDP_FRAGMENT_NUMBER,
  DATA_SEGMENT_DEPTHMAP_ERROR,
  DATA_SEGMENT_DEVICESTATUS_ERROR,
  DATA_SEGMENT_ROI_ERROR,
  DATA_SEGMENT_LOCALIOS_ERROR,
  DATA_SEGMENT_FIELDINFORMATION_ERROR,
  DATA_SEGMENT_LOGICSIGNALS_ERROR,
  DATA_SEGMENT_IMU_ERROR
};
 
class SafeVisionaryDataStream
{
public:
  SafeVisionaryDataStream(std::shared_ptr<VisionaryData> dataHandler);
  ~SafeVisionaryDataStream();
 
  bool openUdpConnection(std::uint16_t port);
 
  bool openTcpConnection(std::uint16_t port, std::string deviceIpAddress);
 
  void closeUdpConnection();
 
  // Close the Tcp connection
  void closeTcpConnection();
 
  bool getNextBlobUdp();
 
  bool getNextBlobTcp(std::vector<std::uint8_t>& receiveBufferPacketSize);
 
  DataStreamError getLastError();
 
  // start bytes of Blob data have been found
  bool getBlobStartTcp(std::vector<std::uint8_t>& receiveBufferPacketSize);
 
private:
  std::shared_ptr<VisionaryData> m_dataHandler;
 
  std::unique_ptr<UdpSocket> m_pTransportUdp;
 
  TcpSocket m_pTransportTcp;
 
  std::vector<uint8_t> m_blobDataBuffer;
 
  uint16_t m_blobNumber;
 
  uint16_t m_numSegments;
 
  std::vector<uint32_t> m_offsetSegment;
 
  std::vector<uint32_t> m_changeCounter;
 
  DataStreamError m_lastDataStreamError;
 
  bool getNextFragment(std::vector<std::uint8_t>& receiveBuffer);
 
  int32_t getNextTcpReception(std::vector<std::uint8_t>& receiveBuffer);
 
  bool parseUdpHeader(std::vector<std::uint8_t>& buffer, UdpProtocolData& udpProtocolData);
 
  bool getBlobStartUdp(bool& lastFragment);
 
  bool parseBlobHeaderUdp();
 
  bool parseBlobHeaderTcp();
 
  bool parseBlobData();
};
 
} // namespace visionary