cob_relayboard: cob_relayboard: EmergencyStopState.h Source File

00001 /* Auto-generated by genmsg_cpp for file /home/rosbuild/hudson/workspace/doc-electric-cob_driver/doc_stacks/2013-03-01_14-39-27.991733/cob_driver/cob_relayboard/msg/EmergencyStopState.msg */
00002 #ifndef COB_RELAYBOARD_MESSAGE_EMERGENCYSTOPSTATE_H
00003 #define COB_RELAYBOARD_MESSAGE_EMERGENCYSTOPSTATE_H
00004 #include <string>
00005 #include <vector>
00006 #include <map>
00007 #include <ostream>
00008 #include "ros/serialization.h"
00009 #include "ros/builtin_message_traits.h"
00010 #include "ros/message_operations.h"
00011 #include "ros/time.h"
00012 
00013 #include "ros/macros.h"
00014 
00015 #include "ros/assert.h"
00016 
00017 
00018 namespace cob_relayboard
00019 {
00020 template <class ContainerAllocator>
00021 struct EmergencyStopState_ {
00022   typedef EmergencyStopState_<ContainerAllocator> Type;
00023 
00024   EmergencyStopState_()
00025   : emergency_button_stop(false)
00026   , scanner_stop(false)
00027   , emergency_state(0)
00028   {
00029   }
00030 
00031   EmergencyStopState_(const ContainerAllocator& _alloc)
00032   : emergency_button_stop(false)
00033   , scanner_stop(false)
00034   , emergency_state(0)
00035   {
00036   }
00037 
00038   typedef uint8_t _emergency_button_stop_type;
00039   uint8_t emergency_button_stop;
00040 
00041   typedef uint8_t _scanner_stop_type;
00042   uint8_t scanner_stop;
00043 
00044   typedef int16_t _emergency_state_type;
00045   int16_t emergency_state;
00046 
00047   enum { EMFREE = 0 };
00048   enum { EMSTOP = 1 };
00049   enum { EMCONFIRMED = 2 };
00050 
00051 private:
00052   static const char* __s_getDataType_() { return "cob_relayboard/EmergencyStopState"; }
00053 public:
00054   ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00055 
00056   ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00057 
00058 private:
00059   static const char* __s_getMD5Sum_() { return "d857d7312ffc16f75239036504e493e9"; }
00060 public:
00061   ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00062 
00063   ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00064 
00065 private:
00066   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\
00067 \n\
00068 # Possible EMStop States\n\
00069 int16 EMFREE = 0                # system operatign normal\n\
00070 int16 EMSTOP = 1                # emergency stop is active (Button pressed; obstacle in safety field of scanner)\n\
00071 int16 EMCONFIRMED = 2   # emergency stop was confirmed system is reinitializing and going back to normal\n\
00072 \n\
00073 bool emergency_button_stop      # true = emergency stop signal is issued by button pressed\n\
00074 bool scanner_stop                       # true = emergency stop signal is issued by scanner\n\
00075 int16 emergency_state           # state (including confimation by key-switch), values see above\n\
00076 \n\
00077 \n\
00078 "; }
00079 public:
00080   ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00081 
00082   ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00083 
00084   ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00085   {
00086     ros::serialization::OStream stream(write_ptr, 1000000000);
00087     ros::serialization::serialize(stream, emergency_button_stop);
00088     ros::serialization::serialize(stream, scanner_stop);
00089     ros::serialization::serialize(stream, emergency_state);
00090     return stream.getData();
00091   }
00092 
00093   ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00094   {
00095     ros::serialization::IStream stream(read_ptr, 1000000000);
00096     ros::serialization::deserialize(stream, emergency_button_stop);
00097     ros::serialization::deserialize(stream, scanner_stop);
00098     ros::serialization::deserialize(stream, emergency_state);
00099     return stream.getData();
00100   }
00101 
00102   ROS_DEPRECATED virtual uint32_t serializationLength() const
00103   {
00104     uint32_t size = 0;
00105     size += ros::serialization::serializationLength(emergency_button_stop);
00106     size += ros::serialization::serializationLength(scanner_stop);
00107     size += ros::serialization::serializationLength(emergency_state);
00108     return size;
00109   }
00110 
00111   typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > Ptr;
00112   typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState_<ContainerAllocator>  const> ConstPtr;
00113   boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00114 }; // struct EmergencyStopState
00115 typedef  ::cob_relayboard::EmergencyStopState_<std::allocator<void> > EmergencyStopState;
00116 
00117 typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState> EmergencyStopStatePtr;
00118 typedef boost::shared_ptr< ::cob_relayboard::EmergencyStopState const> EmergencyStopStateConstPtr;
00119 
00120 
00121 template<typename ContainerAllocator>
00122 std::ostream& operator<<(std::ostream& s, const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> & v)
00123 {
00124   ros::message_operations::Printer< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> >::stream(s, "", v);
00125   return s;}
00126 
00127 } // namespace cob_relayboard
00128 
00129 namespace ros
00130 {
00131 namespace message_traits
00132 {
00133 template<class ContainerAllocator> struct IsMessage< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > : public TrueType {};
00134 template<class ContainerAllocator> struct IsMessage< ::cob_relayboard::EmergencyStopState_<ContainerAllocator>  const> : public TrueType {};
00135 template<class ContainerAllocator>
00136 struct MD5Sum< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > {
00137   static const char* value() 
00138   {
00139     return "d857d7312ffc16f75239036504e493e9";
00140   }
00141 
00142   static const char* value(const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> &) { return value(); } 
00143   static const uint64_t static_value1 = 0xd857d7312ffc16f7ULL;
00144   static const uint64_t static_value2 = 0x5239036504e493e9ULL;
00145 };
00146 
00147 template<class ContainerAllocator>
00148 struct DataType< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > {
00149   static const char* value() 
00150   {
00151     return "cob_relayboard/EmergencyStopState";
00152   }
00153 
00154   static const char* value(const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> &) { return value(); } 
00155 };
00156 
00157 template<class ContainerAllocator>
00158 struct Definition< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > {
00159   static const char* value() 
00160   {
00161     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\
00162 \n\
00163 # Possible EMStop States\n\
00164 int16 EMFREE = 0                # system operatign normal\n\
00165 int16 EMSTOP = 1                # emergency stop is active (Button pressed; obstacle in safety field of scanner)\n\
00166 int16 EMCONFIRMED = 2   # emergency stop was confirmed system is reinitializing and going back to normal\n\
00167 \n\
00168 bool emergency_button_stop      # true = emergency stop signal is issued by button pressed\n\
00169 bool scanner_stop                       # true = emergency stop signal is issued by scanner\n\
00170 int16 emergency_state           # state (including confimation by key-switch), values see above\n\
00171 \n\
00172 \n\
00173 ";
00174   }
00175 
00176   static const char* value(const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> &) { return value(); } 
00177 };
00178 
00179 template<class ContainerAllocator> struct IsFixedSize< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> > : public TrueType {};
00180 } // namespace message_traits
00181 } // namespace ros
00182 
00183 namespace ros
00184 {
00185 namespace serialization
00186 {
00187 
00188 template<class ContainerAllocator> struct Serializer< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> >
00189 {
00190   template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00191   {
00192     stream.next(m.emergency_button_stop);
00193     stream.next(m.scanner_stop);
00194     stream.next(m.emergency_state);
00195   }
00196 
00197   ROS_DECLARE_ALLINONE_SERIALIZER;
00198 }; // struct EmergencyStopState_
00199 } // namespace serialization
00200 } // namespace ros
00201 
00202 namespace ros
00203 {
00204 namespace message_operations
00205 {
00206 
00207 template<class ContainerAllocator>
00208 struct Printer< ::cob_relayboard::EmergencyStopState_<ContainerAllocator> >
00209 {
00210   template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::cob_relayboard::EmergencyStopState_<ContainerAllocator> & v) 
00211   {
00212     s << indent << "emergency_button_stop: ";
00213     Printer<uint8_t>::stream(s, indent + "  ", v.emergency_button_stop);
00214     s << indent << "scanner_stop: ";
00215     Printer<uint8_t>::stream(s, indent + "  ", v.scanner_stop);
00216     s << indent << "emergency_state: ";
00217     Printer<int16_t>::stream(s, indent + "  ", v.emergency_state);
00218   }
00219 };
00220 
00221 
00222 } // namespace message_operations
00223 } // namespace ros
00224 
00225 #endif // COB_RELAYBOARD_MESSAGE_EMERGENCYSTOPSTATE_H
00226