EmergencyStopState.h

Go to the documentation of this file.

/* Auto-generated by genmsg_cpp for file /tmp/buildd/ros-diamondback-cob-driver-0.3.1/debian/ros-diamondback-cob-driver/opt/ros/diamondback/stacks/cob_driver/cob_relayboard/msg/EmergencyStopState.msg */
#ifndef COB_RELAYBOARD_MESSAGE_EMERGENCYSTOPSTATE_H
#define COB_RELAYBOARD_MESSAGE_EMERGENCYSTOPSTATE_H
#include <string>
#include <vector>
#include <ostream>
#include "ros/serialization.h"
#include "ros/builtin_message_traits.h"
#include "ros/message_operations.h"
#include "ros/message.h"
#include "ros/time.h"


namespace cob_relayboard
{
template <class ContainerAllocator>
struct EmergencyStopState_ : public ros::Message
{
  typedef EmergencyStopState_<ContainerAllocator> Type;

  EmergencyStopState_()
  : emergency_button_stop(false)
  , scanner_stop(false)
  , emergency_state(0)
  {
  }

  EmergencyStopState_(const ContainerAllocator& _alloc)
  : emergency_button_stop(false)
  , scanner_stop(false)
  , emergency_state(0)
  {
  }

  typedef uint8_t _emergency_button_stop_type;
  uint8_t emergency_button_stop;

  typedef uint8_t _scanner_stop_type;
  uint8_t scanner_stop;

  typedef int16_t _emergency_state_type;
  int16_t emergency_state;

  enum { EMFREE = 0 };
  enum { EMSTOP = 1 };
  enum { EMCONFIRMED = 2 };

private:
  static const char* __s_getDataType_() { return "cob_relayboard/EmergencyStopState"; }
public:
  ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }

  ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }

private:
  static const char* __s_getMD5Sum_() { return "d857d7312ffc16f75239036504e493e9"; }
public:
  ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }

  ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }

private:
  static const char* __s_getMessageDefinition_() { return "# This message holds the emergency stop (EMStop) status of the robot. It detects wether an EMStop is caused by the safety laserscanner or the emergency stop buttons. Moreover, it gives signalizes wether the EMStop was confirmed (after Button press stop) and the system is free again.\n\
\n\
# Possible EMStop States\n\
int16 EMFREE = 0                # system operatign normal\n\
int16 EMSTOP = 1                # emergency stop is active (Button pressed; obstacle in safety field of scanner)\n\
int16 EMCONFIRMED = 2   # emergency stop was confirmed system is reinitializing and going back to normal\n\
\n\
bool emergency_button_stop      # true = emergency stop signal is issued by button pressed\n\
bool scanner_stop                       # true = emergency stop signal is issued by scanner\n\
int16 emergency_state           # state (including confimation by key-switch), values see above\n\
\n\
\n\
"; }
public:
  ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }

  ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }

  ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
  {
    ros::serialization::OStream stream(write_ptr, 1000000000);
    ros::serialization::serialize(stream, emergency_button_stop);
    ros::serialization::serialize(stream, scanner_stop);
    ros::serialization::serialize(stream, emergency_state);
    return stream.getData();
  }

  ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
  {
    ros::serialization::IStream stream(read_ptr, 1000000000);
    ros::serialization::deserialize(stream, emergency_button_stop);
    ros::serialization::deserialize(stream, scanner_stop);
    ros::serialization::deserialize(stream, emergency_state);
    return stream.getData();
  }

  ROS_DEPRECATED virtual uint32_t serializationLength() const
  {
    uint32_t size = 0;
    size += ros::serialization::serializationLength(emergency_button_stop);
    size += ros::serialization::serializationLength(scanner_stop);
    size += ros::serialization::serializationLength(emergency_state);
    return size;
  }

  typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState_<ContainerAllocator>  const> ConstPtr;
}; // struct EmergencyStopState
typedef  ::cob_relayboard::EmergencyStopState_<std::allocator<void> > EmergencyStopState;

typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState> EmergencyStopStatePtr;
typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState const> EmergencyStopStateConstPtr;


template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> & v)
{
  ros::message_operations::Printer< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> >::stream(s, "", v);
  return s;}

} // namespace cob_relayboard

namespace ros
{
namespace message_traits
{
template<class ContainerAllocator>
struct MD5Sum< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > {
  static const char* value() 
  {
    return "d857d7312ffc16f75239036504e493e9";
  }

  static const char* value(const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> &) { return value(); } 
  static const uint64_t static_value1 = 0xd857d7312ffc16f7ULL;
  static const uint64_t static_value2 = 0x5239036504e493e9ULL;
};

template<class ContainerAllocator>
struct DataType< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > {
  static const char* value() 
  {
    return "cob_relayboard/EmergencyStopState";
  }

  static const char* value(const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> &) { return value(); } 
};

template<class ContainerAllocator>
struct Definition< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > {
  static const char* value() 
  {
    return "# This message holds the emergency stop (EMStop) status of the robot. It detects wether an EMStop is caused by the safety laserscanner or the emergency stop buttons. Moreover, it gives signalizes wether the EMStop was confirmed (after Button press stop) and the system is free again.\n\
\n\
# Possible EMStop States\n\
int16 EMFREE = 0                # system operatign normal\n\
int16 EMSTOP = 1                # emergency stop is active (Button pressed; obstacle in safety field of scanner)\n\
int16 EMCONFIRMED = 2   # emergency stop was confirmed system is reinitializing and going back to normal\n\
\n\
bool emergency_button_stop      # true = emergency stop signal is issued by button pressed\n\
bool scanner_stop                       # true = emergency stop signal is issued by scanner\n\
int16 emergency_state           # state (including confimation by key-switch), values see above\n\
\n\
\n\
";
  }

  static const char* value(const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> &) { return value(); } 
};

template<class ContainerAllocator> struct IsFixedSize< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > : public TrueType {};
} // namespace message_traits
} // namespace ros

namespace ros
{
namespace serialization
{

template<class ContainerAllocator> struct Serializer< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> >
{
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
  {
    stream.next(m.emergency_button_stop);
    stream.next(m.scanner_stop);
    stream.next(m.emergency_state);
  }

  ROS_DECLARE_ALLINONE_SERIALIZER;
}; // struct EmergencyStopState_
} // namespace serialization
} // namespace ros

namespace ros
{
namespace message_operations
{

template<class ContainerAllocator>
struct Printer< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> >
{
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> & v) 
  {
    s << indent << "emergency_button_stop: ";
    Printer<uint8_t>::stream(s, indent + "  ", v.emergency_button_stop);
    s << indent << "scanner_stop: ";
    Printer<uint8_t>::stream(s, indent + "  ", v.scanner_stop);
    s << indent << "emergency_state: ";
    Printer<int16_t>::stream(s, indent + "  ", v.emergency_state);
  }
};


} // namespace message_operations
} // namespace ros

#endif // COB_RELAYBOARD_MESSAGE_EMERGENCYSTOPSTATE_H

---

cob_relayboard
Author(s): Christian Connette
autogenerated on Fri Jan 11 09:12:49 2013