SickSafetyscanners.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------

// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------

#ifndef SICK_SAFETYSCANNERS_SICKSAFETYSCANNERS_H
#define SICK_SAFETYSCANNERS_SICKSAFETYSCANNERS_H

#include <ros/ros.h>

#include <boost/function.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/thread.hpp>

#include <iostream>
#include <string>
#include <vector>

#include <sick_safetyscanners/communication/AsyncTCPClient.h>
#include <sick_safetyscanners/communication/AsyncUDPClient.h>
#include <sick_safetyscanners/data_processing/ParseData.h>
#include <sick_safetyscanners/data_processing/UDPPacketMerger.h>
#include <sick_safetyscanners/datastructure/CommSettings.h>
#include <sick_safetyscanners/datastructure/ConfigData.h>
#include <sick_safetyscanners/datastructure/PacketBuffer.h>

#include <sick_safetyscanners/cola2/ApplicationNameVariableCommand.h>
#include <sick_safetyscanners/cola2/ChangeCommSettingsCommand.h>
#include <sick_safetyscanners/cola2/Cola2Session.h>
#include <sick_safetyscanners/cola2/ConfigMetadataVariableCommand.h>
#include <sick_safetyscanners/cola2/DeviceNameVariableCommand.h>
#include <sick_safetyscanners/cola2/DeviceStatusVariableCommand.h>
#include <sick_safetyscanners/cola2/FieldGeometryVariableCommand.h>
#include <sick_safetyscanners/cola2/FieldHeaderVariableCommand.h>
#include <sick_safetyscanners/cola2/FindMeCommand.h>
#include <sick_safetyscanners/cola2/FirmwareVersionVariableCommand.h>
#include <sick_safetyscanners/cola2/MeasurementCurrentConfigVariableCommand.h>
#include <sick_safetyscanners/cola2/MeasurementPersistentConfigVariableCommand.h>
#include <sick_safetyscanners/cola2/MonitoringCaseTableHeaderVariableCommand.h>
#include <sick_safetyscanners/cola2/MonitoringCaseVariableCommand.h>
#include <sick_safetyscanners/cola2/OrderNumberVariableCommand.h>
#include <sick_safetyscanners/cola2/ProjectNameVariableCommand.h>
#include <sick_safetyscanners/cola2/RequiredUserActionVariableCommand.h>
#include <sick_safetyscanners/cola2/SerialNumberVariableCommand.h>
#include <sick_safetyscanners/cola2/StatusOverviewVariableCommand.h>
#include <sick_safetyscanners/cola2/TypeCodeVariableCommand.h>
#include <sick_safetyscanners/cola2/UserNameVariableCommand.h>

namespace sick {

class SickSafetyscanners
{
public:
  typedef boost::function<void(const sick::datastructure::Data&)> packetReceivedCallbackFunction;

  SickSafetyscanners(const packetReceivedCallbackFunction& newPacketReceivedCallbackFunction,
                     sick::datastructure::CommSettings* settings,
                     boost::asio::ip::address_v4 interface_ip);

  virtual ~SickSafetyscanners();

  bool run();

  void changeSensorSettings(const sick::datastructure::CommSettings& settings);

  void requestTypeCode(const sick::datastructure::CommSettings& settings,
                       sick::datastructure::TypeCode& type_code);

  void requestApplicationName(const sick::datastructure::CommSettings& settings,
                              sick::datastructure::ApplicationName& application_name);
  void requestSerialNumber(const sick::datastructure::CommSettings& settings,
                           sick::datastructure::SerialNumber& serial_number);
  void requestFirmwareVersion(const sick::datastructure::CommSettings& settings,
                              sick::datastructure::FirmwareVersion& firmware_version);
  void requestOrderNumber(const datastructure::CommSettings& settings,
                          datastructure::OrderNumber& order_number);
  void requestProjectName(const datastructure::CommSettings& settings,
                          datastructure::ProjectName& project_name);
  void requestUserName(const datastructure::CommSettings& settings,
                       datastructure::UserName& user_name);
  void requestConfigMetadata(const datastructure::CommSettings& settings,
                             datastructure::ConfigMetadata& config_metadata);
  void requestStatusOverview(const datastructure::CommSettings& settings,
                             datastructure::StatusOverview& status_overview);
  void requestDeviceStatus(const datastructure::CommSettings& settings,
                           datastructure::DeviceStatus& device_status);
  void requestRequiredUserAction(const datastructure::CommSettings& settings,
                                 datastructure::RequiredUserAction& required_user_action);
  void FindSensor(const datastructure::CommSettings& settings, uint16_t blink_time);
  void requestFieldData(const sick::datastructure::CommSettings& settings,
                        std::vector<sick::datastructure::FieldData>& field_data);

  void requestDeviceName(const sick::datastructure::CommSettings& settings,
                         datastructure::DeviceName& device_name);

  void requestPersistentConfig(const datastructure::CommSettings& settings,
                               sick::datastructure::ConfigData& config_data);
  void
  requestMonitoringCases(const sick::datastructure::CommSettings& settings,
                         std::vector<sick::datastructure::MonitoringCaseData>& monitoring_cases);


private:
  packetReceivedCallbackFunction m_newPacketReceivedCallbackFunction;

  std::shared_ptr<boost::asio::io_service> m_io_service_ptr;
  std::shared_ptr<boost::asio::io_service::work> m_io_work_ptr;
  std::shared_ptr<sick::communication::AsyncUDPClient> m_async_udp_client_ptr;
  std::shared_ptr<sick::communication::AsyncTCPClient> m_async_tcp_client_ptr;
  boost::scoped_ptr<boost::thread> m_udp_client_thread_ptr;

  std::shared_ptr<sick::cola2::Cola2Session> m_session_ptr;

  std::shared_ptr<sick::data_processing::UDPPacketMerger> m_packet_merger_ptr;

  void processUDPPacket(const sick::datastructure::PacketBuffer& buffer);
  bool udpClientThread();
  void processTCPPacket(const sick::datastructure::PacketBuffer& buffer);
  void startTCPConnection(const sick::datastructure::CommSettings& settings);
  void changeCommSettingsInColaSession(const datastructure::CommSettings& settings);
  void stopTCPConnection();
  void requestTypeCodeInColaSession(sick::datastructure::TypeCode& type_code);
  void requestFieldDataInColaSession(std::vector<sick::datastructure::FieldData>& fields);
  void requestDeviceNameInColaSession(datastructure::DeviceName& device_name);
  void requestApplicationNameInColaSession(sick::datastructure::ApplicationName& application_name);
  void requestSerialNumberInColaSession(sick::datastructure::SerialNumber& serial_number);
  void requestOrderNumberInColaSession(sick::datastructure::OrderNumber& order_number);
  void requestProjectNameInColaSession(sick::datastructure::ProjectName& project_name);
  void requestUserNameInColaSession(sick::datastructure::UserName& user_name);
  void requestFirmwareVersionInColaSession(sick::datastructure::FirmwareVersion& firmware_version);
  void requestPersistentConfigInColaSession(sick::datastructure::ConfigData& config_data);
  void requestConfigMetadataInColaSession(sick::datastructure::ConfigMetadata& config_metadata);
  void requestStatusOverviewInColaSession(sick::datastructure::StatusOverview& status_overview);
  void requestDeviceStatusInColaSession(sick::datastructure::DeviceStatus& device_status);
  void requestRequiredUserActionInColaSession(
    sick::datastructure::RequiredUserAction& required_user_action);
  void requestMonitoringCaseDataInColaSession(
    std::vector<sick::datastructure::MonitoringCaseData>& monitoring_cases);
  void FindSensorInColaSession(uint16_t blink_time);
};

} // namespace sick


#endif // SICK_SAFETYSCANNERS_SICKSAFETYSCANNERS_H