Go to the documentation of this file.00001 #ifndef _ROS_SERVICE_QueryTrajectoryState_h
00002 #define _ROS_SERVICE_QueryTrajectoryState_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 #include "ros/time.h"
00008
00009 namespace pr2_controllers_msgs
00010 {
00011
00012 static const char QUERYTRAJECTORYSTATE[] = "pr2_controllers_msgs/QueryTrajectoryState";
00013
00014 class QueryTrajectoryStateRequest : public ros::Msg
00015 {
00016 public:
00017 ros::Time time;
00018
00019 virtual int serialize(unsigned char *outbuffer) const
00020 {
00021 int offset = 0;
00022 *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF;
00023 *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF;
00024 *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF;
00025 *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF;
00026 offset += sizeof(this->time.sec);
00027 *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF;
00028 *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF;
00029 *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF;
00030 *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF;
00031 offset += sizeof(this->time.nsec);
00032 return offset;
00033 }
00034
00035 virtual int deserialize(unsigned char *inbuffer)
00036 {
00037 int offset = 0;
00038 this->time.sec = ((uint32_t) (*(inbuffer + offset)));
00039 this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00040 this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00041 this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00042 offset += sizeof(this->time.sec);
00043 this->time.nsec = ((uint32_t) (*(inbuffer + offset)));
00044 this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00045 this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00046 this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00047 offset += sizeof(this->time.nsec);
00048 return offset;
00049 }
00050
00051 const char * getType(){ return QUERYTRAJECTORYSTATE; };
00052 const char * getMD5(){ return "556a4fb76023a469987922359d08a844"; };
00053
00054 };
00055
00056 class QueryTrajectoryStateResponse : public ros::Msg
00057 {
00058 public:
00059 uint8_t name_length;
00060 char* st_name;
00061 char* * name;
00062 uint8_t position_length;
00063 float st_position;
00064 float * position;
00065 uint8_t velocity_length;
00066 float st_velocity;
00067 float * velocity;
00068 uint8_t acceleration_length;
00069 float st_acceleration;
00070 float * acceleration;
00071
00072 virtual int serialize(unsigned char *outbuffer) const
00073 {
00074 int offset = 0;
00075 *(outbuffer + offset++) = name_length;
00076 *(outbuffer + offset++) = 0;
00077 *(outbuffer + offset++) = 0;
00078 *(outbuffer + offset++) = 0;
00079 for( uint8_t i = 0; i < name_length; i++){
00080 uint32_t length_namei = strlen(this->name[i]);
00081 memcpy(outbuffer + offset, &length_namei, sizeof(uint32_t));
00082 offset += 4;
00083 memcpy(outbuffer + offset, this->name[i], length_namei);
00084 offset += length_namei;
00085 }
00086 *(outbuffer + offset++) = position_length;
00087 *(outbuffer + offset++) = 0;
00088 *(outbuffer + offset++) = 0;
00089 *(outbuffer + offset++) = 0;
00090 for( uint8_t i = 0; i < position_length; i++){
00091 int32_t * val_positioni = (int32_t *) &(this->position[i]);
00092 int32_t exp_positioni = (((*val_positioni)>>23)&255);
00093 if(exp_positioni != 0)
00094 exp_positioni += 1023-127;
00095 int32_t sig_positioni = *val_positioni;
00096 *(outbuffer + offset++) = 0;
00097 *(outbuffer + offset++) = 0;
00098 *(outbuffer + offset++) = 0;
00099 *(outbuffer + offset++) = (sig_positioni<<5) & 0xff;
00100 *(outbuffer + offset++) = (sig_positioni>>3) & 0xff;
00101 *(outbuffer + offset++) = (sig_positioni>>11) & 0xff;
00102 *(outbuffer + offset++) = ((exp_positioni<<4) & 0xF0) | ((sig_positioni>>19)&0x0F);
00103 *(outbuffer + offset++) = (exp_positioni>>4) & 0x7F;
00104 if(this->position[i] < 0) *(outbuffer + offset -1) |= 0x80;
00105 }
00106 *(outbuffer + offset++) = velocity_length;
00107 *(outbuffer + offset++) = 0;
00108 *(outbuffer + offset++) = 0;
00109 *(outbuffer + offset++) = 0;
00110 for( uint8_t i = 0; i < velocity_length; i++){
00111 int32_t * val_velocityi = (int32_t *) &(this->velocity[i]);
00112 int32_t exp_velocityi = (((*val_velocityi)>>23)&255);
00113 if(exp_velocityi != 0)
00114 exp_velocityi += 1023-127;
00115 int32_t sig_velocityi = *val_velocityi;
00116 *(outbuffer + offset++) = 0;
00117 *(outbuffer + offset++) = 0;
00118 *(outbuffer + offset++) = 0;
00119 *(outbuffer + offset++) = (sig_velocityi<<5) & 0xff;
00120 *(outbuffer + offset++) = (sig_velocityi>>3) & 0xff;
00121 *(outbuffer + offset++) = (sig_velocityi>>11) & 0xff;
00122 *(outbuffer + offset++) = ((exp_velocityi<<4) & 0xF0) | ((sig_velocityi>>19)&0x0F);
00123 *(outbuffer + offset++) = (exp_velocityi>>4) & 0x7F;
00124 if(this->velocity[i] < 0) *(outbuffer + offset -1) |= 0x80;
00125 }
00126 *(outbuffer + offset++) = acceleration_length;
00127 *(outbuffer + offset++) = 0;
00128 *(outbuffer + offset++) = 0;
00129 *(outbuffer + offset++) = 0;
00130 for( uint8_t i = 0; i < acceleration_length; i++){
00131 int32_t * val_accelerationi = (int32_t *) &(this->acceleration[i]);
00132 int32_t exp_accelerationi = (((*val_accelerationi)>>23)&255);
00133 if(exp_accelerationi != 0)
00134 exp_accelerationi += 1023-127;
00135 int32_t sig_accelerationi = *val_accelerationi;
00136 *(outbuffer + offset++) = 0;
00137 *(outbuffer + offset++) = 0;
00138 *(outbuffer + offset++) = 0;
00139 *(outbuffer + offset++) = (sig_accelerationi<<5) & 0xff;
00140 *(outbuffer + offset++) = (sig_accelerationi>>3) & 0xff;
00141 *(outbuffer + offset++) = (sig_accelerationi>>11) & 0xff;
00142 *(outbuffer + offset++) = ((exp_accelerationi<<4) & 0xF0) | ((sig_accelerationi>>19)&0x0F);
00143 *(outbuffer + offset++) = (exp_accelerationi>>4) & 0x7F;
00144 if(this->acceleration[i] < 0) *(outbuffer + offset -1) |= 0x80;
00145 }
00146 return offset;
00147 }
00148
00149 virtual int deserialize(unsigned char *inbuffer)
00150 {
00151 int offset = 0;
00152 uint8_t name_lengthT = *(inbuffer + offset++);
00153 if(name_lengthT > name_length)
00154 this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
00155 offset += 3;
00156 name_length = name_lengthT;
00157 for( uint8_t i = 0; i < name_length; i++){
00158 uint32_t length_st_name;
00159 memcpy(&length_st_name, (inbuffer + offset), sizeof(uint32_t));
00160 offset += 4;
00161 for(unsigned int k= offset; k< offset+length_st_name; ++k){
00162 inbuffer[k-1]=inbuffer[k];
00163 }
00164 inbuffer[offset+length_st_name-1]=0;
00165 this->st_name = (char *)(inbuffer + offset-1);
00166 offset += length_st_name;
00167 memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
00168 }
00169 uint8_t position_lengthT = *(inbuffer + offset++);
00170 if(position_lengthT > position_length)
00171 this->position = (float*)realloc(this->position, position_lengthT * sizeof(float));
00172 offset += 3;
00173 position_length = position_lengthT;
00174 for( uint8_t i = 0; i < position_length; i++){
00175 uint32_t * val_st_position = (uint32_t*) &(this->st_position);
00176 offset += 3;
00177 *val_st_position = ((uint32_t)(*(inbuffer + offset++))>>5 & 0x07);
00178 *val_st_position |= ((uint32_t)(*(inbuffer + offset++)) & 0xff)<<3;
00179 *val_st_position |= ((uint32_t)(*(inbuffer + offset++)) & 0xff)<<11;
00180 *val_st_position |= ((uint32_t)(*(inbuffer + offset)) & 0x0f)<<19;
00181 uint32_t exp_st_position = ((uint32_t)(*(inbuffer + offset++))&0xf0)>>4;
00182 exp_st_position |= ((uint32_t)(*(inbuffer + offset)) & 0x7f)<<4;
00183 if(exp_st_position !=0)
00184 *val_st_position |= ((exp_st_position)-1023+127)<<23;
00185 if( ((*(inbuffer+offset++)) & 0x80) > 0) this->st_position = -this->st_position;
00186 memcpy( &(this->position[i]), &(this->st_position), sizeof(float));
00187 }
00188 uint8_t velocity_lengthT = *(inbuffer + offset++);
00189 if(velocity_lengthT > velocity_length)
00190 this->velocity = (float*)realloc(this->velocity, velocity_lengthT * sizeof(float));
00191 offset += 3;
00192 velocity_length = velocity_lengthT;
00193 for( uint8_t i = 0; i < velocity_length; i++){
00194 uint32_t * val_st_velocity = (uint32_t*) &(this->st_velocity);
00195 offset += 3;
00196 *val_st_velocity = ((uint32_t)(*(inbuffer + offset++))>>5 & 0x07);
00197 *val_st_velocity |= ((uint32_t)(*(inbuffer + offset++)) & 0xff)<<3;
00198 *val_st_velocity |= ((uint32_t)(*(inbuffer + offset++)) & 0xff)<<11;
00199 *val_st_velocity |= ((uint32_t)(*(inbuffer + offset)) & 0x0f)<<19;
00200 uint32_t exp_st_velocity = ((uint32_t)(*(inbuffer + offset++))&0xf0)>>4;
00201 exp_st_velocity |= ((uint32_t)(*(inbuffer + offset)) & 0x7f)<<4;
00202 if(exp_st_velocity !=0)
00203 *val_st_velocity |= ((exp_st_velocity)-1023+127)<<23;
00204 if( ((*(inbuffer+offset++)) & 0x80) > 0) this->st_velocity = -this->st_velocity;
00205 memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(float));
00206 }
00207 uint8_t acceleration_lengthT = *(inbuffer + offset++);
00208 if(acceleration_lengthT > acceleration_length)
00209 this->acceleration = (float*)realloc(this->acceleration, acceleration_lengthT * sizeof(float));
00210 offset += 3;
00211 acceleration_length = acceleration_lengthT;
00212 for( uint8_t i = 0; i < acceleration_length; i++){
00213 uint32_t * val_st_acceleration = (uint32_t*) &(this->st_acceleration);
00214 offset += 3;
00215 *val_st_acceleration = ((uint32_t)(*(inbuffer + offset++))>>5 & 0x07);
00216 *val_st_acceleration |= ((uint32_t)(*(inbuffer + offset++)) & 0xff)<<3;
00217 *val_st_acceleration |= ((uint32_t)(*(inbuffer + offset++)) & 0xff)<<11;
00218 *val_st_acceleration |= ((uint32_t)(*(inbuffer + offset)) & 0x0f)<<19;
00219 uint32_t exp_st_acceleration = ((uint32_t)(*(inbuffer + offset++))&0xf0)>>4;
00220 exp_st_acceleration |= ((uint32_t)(*(inbuffer + offset)) & 0x7f)<<4;
00221 if(exp_st_acceleration !=0)
00222 *val_st_acceleration |= ((exp_st_acceleration)-1023+127)<<23;
00223 if( ((*(inbuffer+offset++)) & 0x80) > 0) this->st_acceleration = -this->st_acceleration;
00224 memcpy( &(this->acceleration[i]), &(this->st_acceleration), sizeof(float));
00225 }
00226 return offset;
00227 }
00228
00229 const char * getType(){ return QUERYTRAJECTORYSTATE; };
00230 const char * getMD5(){ return "1f1a6554ad060f44d013e71868403c1a"; };
00231
00232 };
00233
00234 class QueryTrajectoryState {
00235 public:
00236 typedef QueryTrajectoryStateRequest Request;
00237 typedef QueryTrajectoryStateResponse Response;
00238 };
00239
00240 }
00241 #endif