NavSatFix.h

00001 #ifndef _ROS_sensor_msgs_NavSatFix_h
00002 #define _ROS_sensor_msgs_NavSatFix_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "std_msgs/Header.h"
00009 #include "sensor_msgs/NavSatStatus.h"
00010 
00011 namespace sensor_msgs
00012 {
00013 
00014   class NavSatFix : public ros::Msg
00015   {
00016     public:
00017       std_msgs::Header header;
00018       sensor_msgs::NavSatStatus status;
00019       double latitude;
00020       double longitude;
00021       double altitude;
00022       double position_covariance[9];
00023       uint8_t position_covariance_type;
00024       enum { COVARIANCE_TYPE_UNKNOWN =  0 };
00025       enum { COVARIANCE_TYPE_APPROXIMATED =  1 };
00026       enum { COVARIANCE_TYPE_DIAGONAL_KNOWN =  2 };
00027       enum { COVARIANCE_TYPE_KNOWN =  3 };
00028 
00029     NavSatFix():
00030       header(),
00031       status(),
00032       latitude(0),
00033       longitude(0),
00034       altitude(0),
00035       position_covariance(),
00036       position_covariance_type(0)
00037     {
00038     }
00039 
00040     virtual int serialize(unsigned char *outbuffer) const
00041     {
00042       int offset = 0;
00043       offset += this->header.serialize(outbuffer + offset);
00044       offset += this->status.serialize(outbuffer + offset);
00045       union {
00046         double real;
00047         uint64_t base;
00048       } u_latitude;
00049       u_latitude.real = this->latitude;
00050       *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
00051       *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
00052       *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
00053       *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
00054       *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
00055       *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
00056       *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
00057       *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
00058       offset += sizeof(this->latitude);
00059       union {
00060         double real;
00061         uint64_t base;
00062       } u_longitude;
00063       u_longitude.real = this->longitude;
00064       *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
00065       *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
00066       *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
00067       *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
00068       *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
00069       *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
00070       *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
00071       *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
00072       offset += sizeof(this->longitude);
00073       union {
00074         double real;
00075         uint64_t base;
00076       } u_altitude;
00077       u_altitude.real = this->altitude;
00078       *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
00079       *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
00080       *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
00081       *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
00082       *(outbuffer + offset + 4) = (u_altitude.base >> (8 * 4)) & 0xFF;
00083       *(outbuffer + offset + 5) = (u_altitude.base >> (8 * 5)) & 0xFF;
00084       *(outbuffer + offset + 6) = (u_altitude.base >> (8 * 6)) & 0xFF;
00085       *(outbuffer + offset + 7) = (u_altitude.base >> (8 * 7)) & 0xFF;
00086       offset += sizeof(this->altitude);
00087       for( uint8_t i = 0; i < 9; i++){
00088       union {
00089         double real;
00090         uint64_t base;
00091       } u_position_covariancei;
00092       u_position_covariancei.real = this->position_covariance[i];
00093       *(outbuffer + offset + 0) = (u_position_covariancei.base >> (8 * 0)) & 0xFF;
00094       *(outbuffer + offset + 1) = (u_position_covariancei.base >> (8 * 1)) & 0xFF;
00095       *(outbuffer + offset + 2) = (u_position_covariancei.base >> (8 * 2)) & 0xFF;
00096       *(outbuffer + offset + 3) = (u_position_covariancei.base >> (8 * 3)) & 0xFF;
00097       *(outbuffer + offset + 4) = (u_position_covariancei.base >> (8 * 4)) & 0xFF;
00098       *(outbuffer + offset + 5) = (u_position_covariancei.base >> (8 * 5)) & 0xFF;
00099       *(outbuffer + offset + 6) = (u_position_covariancei.base >> (8 * 6)) & 0xFF;
00100       *(outbuffer + offset + 7) = (u_position_covariancei.base >> (8 * 7)) & 0xFF;
00101       offset += sizeof(this->position_covariance[i]);
00102       }
00103       *(outbuffer + offset + 0) = (this->position_covariance_type >> (8 * 0)) & 0xFF;
00104       offset += sizeof(this->position_covariance_type);
00105       return offset;
00106     }
00107 
00108     virtual int deserialize(unsigned char *inbuffer)
00109     {
00110       int offset = 0;
00111       offset += this->header.deserialize(inbuffer + offset);
00112       offset += this->status.deserialize(inbuffer + offset);
00113       union {
00114         double real;
00115         uint64_t base;
00116       } u_latitude;
00117       u_latitude.base = 0;
00118       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00119       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00120       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00121       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00122       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00123       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00124       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00125       u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00126       this->latitude = u_latitude.real;
00127       offset += sizeof(this->latitude);
00128       union {
00129         double real;
00130         uint64_t base;
00131       } u_longitude;
00132       u_longitude.base = 0;
00133       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00134       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00135       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00136       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00137       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00138       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00139       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00140       u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00141       this->longitude = u_longitude.real;
00142       offset += sizeof(this->longitude);
00143       union {
00144         double real;
00145         uint64_t base;
00146       } u_altitude;
00147       u_altitude.base = 0;
00148       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00149       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00150       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00151       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00152       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00153       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00154       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00155       u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00156       this->altitude = u_altitude.real;
00157       offset += sizeof(this->altitude);
00158       for( uint8_t i = 0; i < 9; i++){
00159       union {
00160         double real;
00161         uint64_t base;
00162       } u_position_covariancei;
00163       u_position_covariancei.base = 0;
00164       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00165       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00166       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00167       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00168       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00169       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00170       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00171       u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00172       this->position_covariance[i] = u_position_covariancei.real;
00173       offset += sizeof(this->position_covariance[i]);
00174       }
00175       this->position_covariance_type =  ((uint8_t) (*(inbuffer + offset)));
00176       offset += sizeof(this->position_covariance_type);
00177      return offset;
00178     }
00179 
00180     const char * getType(){ return "sensor_msgs/NavSatFix"; };
00181     const char * getMD5(){ return "2d3a8cd499b9b4a0249fb98fd05cfa48"; };
00182 
00183   };
00184 
00185 }
00186 #endif