Gary Servin
/
rosserial_mbed_lib
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
rosserial_mbed_lib
by 
nucho
Embed:
(wiki syntax)
Show/hide line numbers
LaserScan.h
00001 #ifndef _ROS_sensor_msgs_LaserScan_h 00002 #define _ROS_sensor_msgs_LaserScan_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 00010 namespace sensor_msgs 00011 { 00012 00013 class LaserScan : public ros::Msg 00014 { 00015 public: 00016 std_msgs::Header header; 00017 float angle_min; 00018 float angle_max; 00019 float angle_increment; 00020 float time_increment; 00021 float scan_time; 00022 float range_min; 00023 float range_max; 00024 uint8_t ranges_length; 00025 float st_ranges; 00026 float * ranges; 00027 uint8_t intensities_length; 00028 float st_intensities; 00029 float * intensities; 00030 00031 virtual int serialize(unsigned char *outbuffer) const 00032 { 00033 int offset = 0; 00034 offset += this->header.serialize(outbuffer + offset); 00035 union { 00036 float real; 00037 uint32_t base; 00038 } u_angle_min; 00039 u_angle_min.real = this->angle_min; 00040 *(outbuffer + offset + 0) = (u_angle_min.base >> (8 * 0)) & 0xFF; 00041 *(outbuffer + offset + 1) = (u_angle_min.base >> (8 * 1)) & 0xFF; 00042 *(outbuffer + offset + 2) = (u_angle_min.base >> (8 * 2)) & 0xFF; 00043 *(outbuffer + offset + 3) = (u_angle_min.base >> (8 * 3)) & 0xFF; 00044 offset += sizeof(this->angle_min); 00045 union { 00046 float real; 00047 uint32_t base; 00048 } u_angle_max; 00049 u_angle_max.real = this->angle_max; 00050 *(outbuffer + offset + 0) = (u_angle_max.base >> (8 * 0)) & 0xFF; 00051 *(outbuffer + offset + 1) = (u_angle_max.base >> (8 * 1)) & 0xFF; 00052 *(outbuffer + offset + 2) = (u_angle_max.base >> (8 * 2)) & 0xFF; 00053 *(outbuffer + offset + 3) = (u_angle_max.base >> (8 * 3)) & 0xFF; 00054 offset += sizeof(this->angle_max); 00055 union { 00056 float real; 00057 uint32_t base; 00058 } u_angle_increment; 00059 u_angle_increment.real = this->angle_increment; 00060 *(outbuffer + offset + 0) = (u_angle_increment.base >> (8 * 0)) & 0xFF; 00061 *(outbuffer + offset + 1) = (u_angle_increment.base >> (8 * 1)) & 0xFF; 00062 *(outbuffer + offset + 2) = (u_angle_increment.base >> (8 * 2)) & 0xFF; 00063 *(outbuffer + offset + 3) = (u_angle_increment.base >> (8 * 3)) & 0xFF; 00064 offset += sizeof(this->angle_increment); 00065 union { 00066 float real; 00067 uint32_t base; 00068 } u_time_increment; 00069 u_time_increment.real = this->time_increment; 00070 *(outbuffer + offset + 0) = (u_time_increment.base >> (8 * 0)) & 0xFF; 00071 *(outbuffer + offset + 1) = (u_time_increment.base >> (8 * 1)) & 0xFF; 00072 *(outbuffer + offset + 2) = (u_time_increment.base >> (8 * 2)) & 0xFF; 00073 *(outbuffer + offset + 3) = (u_time_increment.base >> (8 * 3)) & 0xFF; 00074 offset += sizeof(this->time_increment); 00075 union { 00076 float real; 00077 uint32_t base; 00078 } u_scan_time; 00079 u_scan_time.real = this->scan_time; 00080 *(outbuffer + offset + 0) = (u_scan_time.base >> (8 * 0)) & 0xFF; 00081 *(outbuffer + offset + 1) = (u_scan_time.base >> (8 * 1)) & 0xFF; 00082 *(outbuffer + offset + 2) = (u_scan_time.base >> (8 * 2)) & 0xFF; 00083 *(outbuffer + offset + 3) = (u_scan_time.base >> (8 * 3)) & 0xFF; 00084 offset += sizeof(this->scan_time); 00085 union { 00086 float real; 00087 uint32_t base; 00088 } u_range_min; 00089 u_range_min.real = this->range_min; 00090 *(outbuffer + offset + 0) = (u_range_min.base >> (8 * 0)) & 0xFF; 00091 *(outbuffer + offset + 1) = (u_range_min.base >> (8 * 1)) & 0xFF; 00092 *(outbuffer + offset + 2) = (u_range_min.base >> (8 * 2)) & 0xFF; 00093 *(outbuffer + offset + 3) = (u_range_min.base >> (8 * 3)) & 0xFF; 00094 offset += sizeof(this->range_min); 00095 union { 00096 float real; 00097 uint32_t base; 00098 } u_range_max; 00099 u_range_max.real = this->range_max; 00100 *(outbuffer + offset + 0) = (u_range_max.base >> (8 * 0)) & 0xFF; 00101 *(outbuffer + offset + 1) = (u_range_max.base >> (8 * 1)) & 0xFF; 00102 *(outbuffer + offset + 2) = (u_range_max.base >> (8 * 2)) & 0xFF; 00103 *(outbuffer + offset + 3) = (u_range_max.base >> (8 * 3)) & 0xFF; 00104 offset += sizeof(this->range_max); 00105 *(outbuffer + offset++) = ranges_length; 00106 *(outbuffer + offset++) = 0; 00107 *(outbuffer + offset++) = 0; 00108 *(outbuffer + offset++) = 0; 00109 for( uint8_t i = 0; i < ranges_length; i++){ 00110 union { 00111 float real; 00112 uint32_t base; 00113 } u_rangesi; 00114 u_rangesi.real = this->ranges[i]; 00115 *(outbuffer + offset + 0) = (u_rangesi.base >> (8 * 0)) & 0xFF; 00116 *(outbuffer + offset + 1) = (u_rangesi.base >> (8 * 1)) & 0xFF; 00117 *(outbuffer + offset + 2) = (u_rangesi.base >> (8 * 2)) & 0xFF; 00118 *(outbuffer + offset + 3) = (u_rangesi.base >> (8 * 3)) & 0xFF; 00119 offset += sizeof(this->ranges[i]); 00120 } 00121 *(outbuffer + offset++) = intensities_length; 00122 *(outbuffer + offset++) = 0; 00123 *(outbuffer + offset++) = 0; 00124 *(outbuffer + offset++) = 0; 00125 for( uint8_t i = 0; i < intensities_length; i++){ 00126 union { 00127 float real; 00128 uint32_t base; 00129 } u_intensitiesi; 00130 u_intensitiesi.real = this->intensities[i]; 00131 *(outbuffer + offset + 0) = (u_intensitiesi.base >> (8 * 0)) & 0xFF; 00132 *(outbuffer + offset + 1) = (u_intensitiesi.base >> (8 * 1)) & 0xFF; 00133 *(outbuffer + offset + 2) = (u_intensitiesi.base >> (8 * 2)) & 0xFF; 00134 *(outbuffer + offset + 3) = (u_intensitiesi.base >> (8 * 3)) & 0xFF; 00135 offset += sizeof(this->intensities[i]); 00136 } 00137 return offset; 00138 } 00139 00140 virtual int deserialize(unsigned char *inbuffer) 00141 { 00142 int offset = 0; 00143 offset += this->header.deserialize(inbuffer + offset); 00144 union { 00145 float real; 00146 uint32_t base; 00147 } u_angle_min; 00148 u_angle_min.base = 0; 00149 u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00150 u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00151 u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00152 u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00153 this->angle_min = u_angle_min.real; 00154 offset += sizeof(this->angle_min); 00155 union { 00156 float real; 00157 uint32_t base; 00158 } u_angle_max; 00159 u_angle_max.base = 0; 00160 u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00161 u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00162 u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00163 u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00164 this->angle_max = u_angle_max.real; 00165 offset += sizeof(this->angle_max); 00166 union { 00167 float real; 00168 uint32_t base; 00169 } u_angle_increment; 00170 u_angle_increment.base = 0; 00171 u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00172 u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00173 u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00174 u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00175 this->angle_increment = u_angle_increment.real; 00176 offset += sizeof(this->angle_increment); 00177 union { 00178 float real; 00179 uint32_t base; 00180 } u_time_increment; 00181 u_time_increment.base = 0; 00182 u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00183 u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00184 u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00185 u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00186 this->time_increment = u_time_increment.real; 00187 offset += sizeof(this->time_increment); 00188 union { 00189 float real; 00190 uint32_t base; 00191 } u_scan_time; 00192 u_scan_time.base = 0; 00193 u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00194 u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00195 u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00196 u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00197 this->scan_time = u_scan_time.real; 00198 offset += sizeof(this->scan_time); 00199 union { 00200 float real; 00201 uint32_t base; 00202 } u_range_min; 00203 u_range_min.base = 0; 00204 u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00205 u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00206 u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00207 u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00208 this->range_min = u_range_min.real; 00209 offset += sizeof(this->range_min); 00210 union { 00211 float real; 00212 uint32_t base; 00213 } u_range_max; 00214 u_range_max.base = 0; 00215 u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00216 u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00217 u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00218 u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00219 this->range_max = u_range_max.real; 00220 offset += sizeof(this->range_max); 00221 uint8_t ranges_lengthT = *(inbuffer + offset++); 00222 if(ranges_lengthT > ranges_length) 00223 this->ranges = (float*)realloc(this->ranges, ranges_lengthT * sizeof(float)); 00224 offset += 3; 00225 ranges_length = ranges_lengthT; 00226 for( uint8_t i = 0; i < ranges_length; i++){ 00227 union { 00228 float real; 00229 uint32_t base; 00230 } u_st_ranges; 00231 u_st_ranges.base = 0; 00232 u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00233 u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00234 u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00235 u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00236 this->st_ranges = u_st_ranges.real; 00237 offset += sizeof(this->st_ranges); 00238 memcpy( &(this->ranges[i]), &(this->st_ranges), sizeof(float)); 00239 } 00240 uint8_t intensities_lengthT = *(inbuffer + offset++); 00241 if(intensities_lengthT > intensities_length) 00242 this->intensities = (float*)realloc(this->intensities, intensities_lengthT * sizeof(float)); 00243 offset += 3; 00244 intensities_length = intensities_lengthT; 00245 for( uint8_t i = 0; i < intensities_length; i++){ 00246 union { 00247 float real; 00248 uint32_t base; 00249 } u_st_intensities; 00250 u_st_intensities.base = 0; 00251 u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00252 u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00253 u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00254 u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00255 this->st_intensities = u_st_intensities.real; 00256 offset += sizeof(this->st_intensities); 00257 memcpy( &(this->intensities[i]), &(this->st_intensities), sizeof(float)); 00258 } 00259 return offset; 00260 } 00261 00262 virtual const char * getType(){ return "sensor_msgs/LaserScan"; }; 00263 virtual const char * getMD5(){ return "90c7ef2dc6895d81024acba2ac42f369"; }; 00264 00265 }; 00266 00267 } 00268 #endif
Generated on Tue Jul 12 2022 19:53:57 by
1.7.2