MessageInterval.h

00001 #ifndef _ROS_SERVICE_MessageInterval_h
00002 #define _ROS_SERVICE_MessageInterval_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 
00008 namespace mavros_msgs
00009 {
00010 
00011 static const char MESSAGEINTERVAL[] = "mavros_msgs/MessageInterval";
00012 
00013   class MessageIntervalRequest : public ros::Msg
00014   {
00015     public:
00016       typedef uint32_t _message_id_type;
00017       _message_id_type message_id;
00018       typedef float _message_rate_type;
00019       _message_rate_type message_rate;
00020 
00021     MessageIntervalRequest():
00022       message_id(0),
00023       message_rate(0)
00024     {
00025     }
00026 
00027     virtual int serialize(unsigned char *outbuffer) const
00028     {
00029       int offset = 0;
00030       *(outbuffer + offset + 0) = (this->message_id >> (8 * 0)) & 0xFF;
00031       *(outbuffer + offset + 1) = (this->message_id >> (8 * 1)) & 0xFF;
00032       *(outbuffer + offset + 2) = (this->message_id >> (8 * 2)) & 0xFF;
00033       *(outbuffer + offset + 3) = (this->message_id >> (8 * 3)) & 0xFF;
00034       offset += sizeof(this->message_id);
00035       union {
00036         float real;
00037         uint32_t base;
00038       } u_message_rate;
00039       u_message_rate.real = this->message_rate;
00040       *(outbuffer + offset + 0) = (u_message_rate.base >> (8 * 0)) & 0xFF;
00041       *(outbuffer + offset + 1) = (u_message_rate.base >> (8 * 1)) & 0xFF;
00042       *(outbuffer + offset + 2) = (u_message_rate.base >> (8 * 2)) & 0xFF;
00043       *(outbuffer + offset + 3) = (u_message_rate.base >> (8 * 3)) & 0xFF;
00044       offset += sizeof(this->message_rate);
00045       return offset;
00046     }
00047 
00048     virtual int deserialize(unsigned char *inbuffer)
00049     {
00050       int offset = 0;
00051       this->message_id =  ((uint32_t) (*(inbuffer + offset)));
00052       this->message_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00053       this->message_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00054       this->message_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00055       offset += sizeof(this->message_id);
00056       union {
00057         float real;
00058         uint32_t base;
00059       } u_message_rate;
00060       u_message_rate.base = 0;
00061       u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00062       u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00063       u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00064       u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00065       this->message_rate = u_message_rate.real;
00066       offset += sizeof(this->message_rate);
00067      return offset;
00068     }
00069 
00070     const char * getType(){ return MESSAGEINTERVAL; };
00071     const char * getMD5(){ return "e0211a7928924521de24f3981706be52"; };
00072 
00073   };
00074 
00075   class MessageIntervalResponse : public ros::Msg
00076   {
00077     public:
00078       typedef bool _success_type;
00079       _success_type success;
00080 
00081     MessageIntervalResponse():
00082       success(0)
00083     {
00084     }
00085 
00086     virtual int serialize(unsigned char *outbuffer) const
00087     {
00088       int offset = 0;
00089       union {
00090         bool real;
00091         uint8_t base;
00092       } u_success;
00093       u_success.real = this->success;
00094       *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
00095       offset += sizeof(this->success);
00096       return offset;
00097     }
00098 
00099     virtual int deserialize(unsigned char *inbuffer)
00100     {
00101       int offset = 0;
00102       union {
00103         bool real;
00104         uint8_t base;
00105       } u_success;
00106       u_success.base = 0;
00107       u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00108       this->success = u_success.real;
00109       offset += sizeof(this->success);
00110      return offset;
00111     }
00112 
00113     const char * getType(){ return MESSAGEINTERVAL; };
00114     const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
00115 
00116   };
00117 
00118   class MessageInterval {
00119     public:
00120     typedef MessageIntervalRequest Request;
00121     typedef MessageIntervalResponse Response;
00122   };
00123 
00124 }
00125 #endif