CommandHome.h

00001 #ifndef _ROS_SERVICE_CommandHome_h
00002 #define _ROS_SERVICE_CommandHome_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 COMMANDHOME[] = "mavros_msgs/CommandHome";
00012 
00013   class CommandHomeRequest : public ros::Msg
00014   {
00015     public:
00016       typedef bool _current_gps_type;
00017       _current_gps_type current_gps;
00018       typedef float _yaw_type;
00019       _yaw_type yaw;
00020       typedef float _latitude_type;
00021       _latitude_type latitude;
00022       typedef float _longitude_type;
00023       _longitude_type longitude;
00024       typedef float _altitude_type;
00025       _altitude_type altitude;
00026 
00027     CommandHomeRequest():
00028       current_gps(0),
00029       yaw(0),
00030       latitude(0),
00031       longitude(0),
00032       altitude(0)
00033     {
00034     }
00035 
00036     virtual int serialize(unsigned char *outbuffer) const
00037     {
00038       int offset = 0;
00039       union {
00040         bool real;
00041         uint8_t base;
00042       } u_current_gps;
00043       u_current_gps.real = this->current_gps;
00044       *(outbuffer + offset + 0) = (u_current_gps.base >> (8 * 0)) & 0xFF;
00045       offset += sizeof(this->current_gps);
00046       union {
00047         float real;
00048         uint32_t base;
00049       } u_yaw;
00050       u_yaw.real = this->yaw;
00051       *(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
00052       *(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
00053       *(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
00054       *(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
00055       offset += sizeof(this->yaw);
00056       union {
00057         float real;
00058         uint32_t base;
00059       } u_latitude;
00060       u_latitude.real = this->latitude;
00061       *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
00062       *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
00063       *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
00064       *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
00065       offset += sizeof(this->latitude);
00066       union {
00067         float real;
00068         uint32_t base;
00069       } u_longitude;
00070       u_longitude.real = this->longitude;
00071       *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
00072       *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
00073       *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
00074       *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
00075       offset += sizeof(this->longitude);
00076       union {
00077         float real;
00078         uint32_t base;
00079       } u_altitude;
00080       u_altitude.real = this->altitude;
00081       *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
00082       *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
00083       *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
00084       *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
00085       offset += sizeof(this->altitude);
00086       return offset;
00087     }
00088 
00089     virtual int deserialize(unsigned char *inbuffer)
00090     {
00091       int offset = 0;
00092       union {
00093         bool real;
00094         uint8_t base;
00095       } u_current_gps;
00096       u_current_gps.base = 0;
00097       u_current_gps.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00098       this->current_gps = u_current_gps.real;
00099       offset += sizeof(this->current_gps);
00100       union {
00101         float real;
00102         uint32_t base;
00103       } u_yaw;
00104       u_yaw.base = 0;
00105       u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00106       u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00107       u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00108       u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00109       this->yaw = u_yaw.real;
00110       offset += sizeof(this->yaw);
00111       union {
00112         float real;
00113         uint32_t base;
00114       } u_latitude;
00115       u_latitude.base = 0;
00116       u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00117       u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00118       u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00119       u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00120       this->latitude = u_latitude.real;
00121       offset += sizeof(this->latitude);
00122       union {
00123         float real;
00124         uint32_t base;
00125       } u_longitude;
00126       u_longitude.base = 0;
00127       u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00128       u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00129       u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00130       u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00131       this->longitude = u_longitude.real;
00132       offset += sizeof(this->longitude);
00133       union {
00134         float real;
00135         uint32_t base;
00136       } u_altitude;
00137       u_altitude.base = 0;
00138       u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00139       u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00140       u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00141       u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00142       this->altitude = u_altitude.real;
00143       offset += sizeof(this->altitude);
00144      return offset;
00145     }
00146 
00147     const char * getType(){ return COMMANDHOME; };
00148     const char * getMD5(){ return "af3ed5fc0724380793eba353ee384c9a"; };
00149 
00150   };
00151 
00152   class CommandHomeResponse : public ros::Msg
00153   {
00154     public:
00155       typedef bool _success_type;
00156       _success_type success;
00157       typedef uint8_t _result_type;
00158       _result_type result;
00159 
00160     CommandHomeResponse():
00161       success(0),
00162       result(0)
00163     {
00164     }
00165 
00166     virtual int serialize(unsigned char *outbuffer) const
00167     {
00168       int offset = 0;
00169       union {
00170         bool real;
00171         uint8_t base;
00172       } u_success;
00173       u_success.real = this->success;
00174       *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
00175       offset += sizeof(this->success);
00176       *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
00177       offset += sizeof(this->result);
00178       return offset;
00179     }
00180 
00181     virtual int deserialize(unsigned char *inbuffer)
00182     {
00183       int offset = 0;
00184       union {
00185         bool real;
00186         uint8_t base;
00187       } u_success;
00188       u_success.base = 0;
00189       u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00190       this->success = u_success.real;
00191       offset += sizeof(this->success);
00192       this->result =  ((uint8_t) (*(inbuffer + offset)));
00193       offset += sizeof(this->result);
00194      return offset;
00195     }
00196 
00197     const char * getType(){ return COMMANDHOME; };
00198     const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
00199 
00200   };
00201 
00202   class CommandHome {
00203     public:
00204     typedef CommandHomeRequest Request;
00205     typedef CommandHomeResponse Response;
00206   };
00207 
00208 }
00209 #endif