ROS Serial library for Mbed platforms for ROS Indigo Igloo. Check http://wiki.ros.org/rosserial_mbed/ for more information

Dependencies:   BufferedSerial

Dependents:   rosserial_mbed_hello_world_publisher rtos_base_control rosserial_mbed_F64MA ROS-RTOS ... more

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers JointControllerState.h Source File

JointControllerState.h

00001 #ifndef _ROS_control_msgs_JointControllerState_h
00002 #define _ROS_control_msgs_JointControllerState_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 control_msgs
00011 {
00012 
00013   class JointControllerState : public ros::Msg
00014   {
00015     public:
00016       std_msgs::Header header;
00017       double set_point;
00018       double process_value;
00019       double process_value_dot;
00020       double error;
00021       double time_step;
00022       double command;
00023       double p;
00024       double i;
00025       double d;
00026       double i_clamp;
00027 
00028     JointControllerState():
00029       header(),
00030       set_point(0),
00031       process_value(0),
00032       process_value_dot(0),
00033       error(0),
00034       time_step(0),
00035       command(0),
00036       p(0),
00037       i(0),
00038       d(0),
00039       i_clamp(0)
00040     {
00041     }
00042 
00043     virtual int serialize(unsigned char *outbuffer) const
00044     {
00045       int offset = 0;
00046       offset += this->header.serialize(outbuffer + offset);
00047       union {
00048         double real;
00049         uint64_t base;
00050       } u_set_point;
00051       u_set_point.real = this->set_point;
00052       *(outbuffer + offset + 0) = (u_set_point.base >> (8 * 0)) & 0xFF;
00053       *(outbuffer + offset + 1) = (u_set_point.base >> (8 * 1)) & 0xFF;
00054       *(outbuffer + offset + 2) = (u_set_point.base >> (8 * 2)) & 0xFF;
00055       *(outbuffer + offset + 3) = (u_set_point.base >> (8 * 3)) & 0xFF;
00056       *(outbuffer + offset + 4) = (u_set_point.base >> (8 * 4)) & 0xFF;
00057       *(outbuffer + offset + 5) = (u_set_point.base >> (8 * 5)) & 0xFF;
00058       *(outbuffer + offset + 6) = (u_set_point.base >> (8 * 6)) & 0xFF;
00059       *(outbuffer + offset + 7) = (u_set_point.base >> (8 * 7)) & 0xFF;
00060       offset += sizeof(this->set_point);
00061       union {
00062         double real;
00063         uint64_t base;
00064       } u_process_value;
00065       u_process_value.real = this->process_value;
00066       *(outbuffer + offset + 0) = (u_process_value.base >> (8 * 0)) & 0xFF;
00067       *(outbuffer + offset + 1) = (u_process_value.base >> (8 * 1)) & 0xFF;
00068       *(outbuffer + offset + 2) = (u_process_value.base >> (8 * 2)) & 0xFF;
00069       *(outbuffer + offset + 3) = (u_process_value.base >> (8 * 3)) & 0xFF;
00070       *(outbuffer + offset + 4) = (u_process_value.base >> (8 * 4)) & 0xFF;
00071       *(outbuffer + offset + 5) = (u_process_value.base >> (8 * 5)) & 0xFF;
00072       *(outbuffer + offset + 6) = (u_process_value.base >> (8 * 6)) & 0xFF;
00073       *(outbuffer + offset + 7) = (u_process_value.base >> (8 * 7)) & 0xFF;
00074       offset += sizeof(this->process_value);
00075       union {
00076         double real;
00077         uint64_t base;
00078       } u_process_value_dot;
00079       u_process_value_dot.real = this->process_value_dot;
00080       *(outbuffer + offset + 0) = (u_process_value_dot.base >> (8 * 0)) & 0xFF;
00081       *(outbuffer + offset + 1) = (u_process_value_dot.base >> (8 * 1)) & 0xFF;
00082       *(outbuffer + offset + 2) = (u_process_value_dot.base >> (8 * 2)) & 0xFF;
00083       *(outbuffer + offset + 3) = (u_process_value_dot.base >> (8 * 3)) & 0xFF;
00084       *(outbuffer + offset + 4) = (u_process_value_dot.base >> (8 * 4)) & 0xFF;
00085       *(outbuffer + offset + 5) = (u_process_value_dot.base >> (8 * 5)) & 0xFF;
00086       *(outbuffer + offset + 6) = (u_process_value_dot.base >> (8 * 6)) & 0xFF;
00087       *(outbuffer + offset + 7) = (u_process_value_dot.base >> (8 * 7)) & 0xFF;
00088       offset += sizeof(this->process_value_dot);
00089       union {
00090         double real;
00091         uint64_t base;
00092       } u_error;
00093       u_error.real = this->error;
00094       *(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
00095       *(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
00096       *(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
00097       *(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
00098       *(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
00099       *(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
00100       *(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
00101       *(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
00102       offset += sizeof(this->error);
00103       union {
00104         double real;
00105         uint64_t base;
00106       } u_time_step;
00107       u_time_step.real = this->time_step;
00108       *(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
00109       *(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
00110       *(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
00111       *(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
00112       *(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
00113       *(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
00114       *(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
00115       *(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
00116       offset += sizeof(this->time_step);
00117       union {
00118         double real;
00119         uint64_t base;
00120       } u_command;
00121       u_command.real = this->command;
00122       *(outbuffer + offset + 0) = (u_command.base >> (8 * 0)) & 0xFF;
00123       *(outbuffer + offset + 1) = (u_command.base >> (8 * 1)) & 0xFF;
00124       *(outbuffer + offset + 2) = (u_command.base >> (8 * 2)) & 0xFF;
00125       *(outbuffer + offset + 3) = (u_command.base >> (8 * 3)) & 0xFF;
00126       *(outbuffer + offset + 4) = (u_command.base >> (8 * 4)) & 0xFF;
00127       *(outbuffer + offset + 5) = (u_command.base >> (8 * 5)) & 0xFF;
00128       *(outbuffer + offset + 6) = (u_command.base >> (8 * 6)) & 0xFF;
00129       *(outbuffer + offset + 7) = (u_command.base >> (8 * 7)) & 0xFF;
00130       offset += sizeof(this->command);
00131       union {
00132         double real;
00133         uint64_t base;
00134       } u_p;
00135       u_p.real = this->p;
00136       *(outbuffer + offset + 0) = (u_p.base >> (8 * 0)) & 0xFF;
00137       *(outbuffer + offset + 1) = (u_p.base >> (8 * 1)) & 0xFF;
00138       *(outbuffer + offset + 2) = (u_p.base >> (8 * 2)) & 0xFF;
00139       *(outbuffer + offset + 3) = (u_p.base >> (8 * 3)) & 0xFF;
00140       *(outbuffer + offset + 4) = (u_p.base >> (8 * 4)) & 0xFF;
00141       *(outbuffer + offset + 5) = (u_p.base >> (8 * 5)) & 0xFF;
00142       *(outbuffer + offset + 6) = (u_p.base >> (8 * 6)) & 0xFF;
00143       *(outbuffer + offset + 7) = (u_p.base >> (8 * 7)) & 0xFF;
00144       offset += sizeof(this->p);
00145       union {
00146         double real;
00147         uint64_t base;
00148       } u_i;
00149       u_i.real = this->i;
00150       *(outbuffer + offset + 0) = (u_i.base >> (8 * 0)) & 0xFF;
00151       *(outbuffer + offset + 1) = (u_i.base >> (8 * 1)) & 0xFF;
00152       *(outbuffer + offset + 2) = (u_i.base >> (8 * 2)) & 0xFF;
00153       *(outbuffer + offset + 3) = (u_i.base >> (8 * 3)) & 0xFF;
00154       *(outbuffer + offset + 4) = (u_i.base >> (8 * 4)) & 0xFF;
00155       *(outbuffer + offset + 5) = (u_i.base >> (8 * 5)) & 0xFF;
00156       *(outbuffer + offset + 6) = (u_i.base >> (8 * 6)) & 0xFF;
00157       *(outbuffer + offset + 7) = (u_i.base >> (8 * 7)) & 0xFF;
00158       offset += sizeof(this->i);
00159       union {
00160         double real;
00161         uint64_t base;
00162       } u_d;
00163       u_d.real = this->d;
00164       *(outbuffer + offset + 0) = (u_d.base >> (8 * 0)) & 0xFF;
00165       *(outbuffer + offset + 1) = (u_d.base >> (8 * 1)) & 0xFF;
00166       *(outbuffer + offset + 2) = (u_d.base >> (8 * 2)) & 0xFF;
00167       *(outbuffer + offset + 3) = (u_d.base >> (8 * 3)) & 0xFF;
00168       *(outbuffer + offset + 4) = (u_d.base >> (8 * 4)) & 0xFF;
00169       *(outbuffer + offset + 5) = (u_d.base >> (8 * 5)) & 0xFF;
00170       *(outbuffer + offset + 6) = (u_d.base >> (8 * 6)) & 0xFF;
00171       *(outbuffer + offset + 7) = (u_d.base >> (8 * 7)) & 0xFF;
00172       offset += sizeof(this->d);
00173       union {
00174         double real;
00175         uint64_t base;
00176       } u_i_clamp;
00177       u_i_clamp.real = this->i_clamp;
00178       *(outbuffer + offset + 0) = (u_i_clamp.base >> (8 * 0)) & 0xFF;
00179       *(outbuffer + offset + 1) = (u_i_clamp.base >> (8 * 1)) & 0xFF;
00180       *(outbuffer + offset + 2) = (u_i_clamp.base >> (8 * 2)) & 0xFF;
00181       *(outbuffer + offset + 3) = (u_i_clamp.base >> (8 * 3)) & 0xFF;
00182       *(outbuffer + offset + 4) = (u_i_clamp.base >> (8 * 4)) & 0xFF;
00183       *(outbuffer + offset + 5) = (u_i_clamp.base >> (8 * 5)) & 0xFF;
00184       *(outbuffer + offset + 6) = (u_i_clamp.base >> (8 * 6)) & 0xFF;
00185       *(outbuffer + offset + 7) = (u_i_clamp.base >> (8 * 7)) & 0xFF;
00186       offset += sizeof(this->i_clamp);
00187       return offset;
00188     }
00189 
00190     virtual int deserialize(unsigned char *inbuffer)
00191     {
00192       int offset = 0;
00193       offset += this->header.deserialize(inbuffer + offset);
00194       union {
00195         double real;
00196         uint64_t base;
00197       } u_set_point;
00198       u_set_point.base = 0;
00199       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00200       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00201       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00202       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00203       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00204       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00205       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00206       u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00207       this->set_point = u_set_point.real;
00208       offset += sizeof(this->set_point);
00209       union {
00210         double real;
00211         uint64_t base;
00212       } u_process_value;
00213       u_process_value.base = 0;
00214       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00215       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00216       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00217       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00218       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00219       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00220       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00221       u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00222       this->process_value = u_process_value.real;
00223       offset += sizeof(this->process_value);
00224       union {
00225         double real;
00226         uint64_t base;
00227       } u_process_value_dot;
00228       u_process_value_dot.base = 0;
00229       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00230       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00231       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00232       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00233       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00234       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00235       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00236       u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00237       this->process_value_dot = u_process_value_dot.real;
00238       offset += sizeof(this->process_value_dot);
00239       union {
00240         double real;
00241         uint64_t base;
00242       } u_error;
00243       u_error.base = 0;
00244       u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00245       u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00246       u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00247       u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00248       u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00249       u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00250       u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00251       u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00252       this->error = u_error.real;
00253       offset += sizeof(this->error);
00254       union {
00255         double real;
00256         uint64_t base;
00257       } u_time_step;
00258       u_time_step.base = 0;
00259       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00260       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00261       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00262       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00263       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00264       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00265       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00266       u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00267       this->time_step = u_time_step.real;
00268       offset += sizeof(this->time_step);
00269       union {
00270         double real;
00271         uint64_t base;
00272       } u_command;
00273       u_command.base = 0;
00274       u_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00275       u_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00276       u_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00277       u_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00278       u_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00279       u_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00280       u_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00281       u_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00282       this->command = u_command.real;
00283       offset += sizeof(this->command);
00284       union {
00285         double real;
00286         uint64_t base;
00287       } u_p;
00288       u_p.base = 0;
00289       u_p.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00290       u_p.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00291       u_p.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00292       u_p.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00293       u_p.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00294       u_p.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00295       u_p.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00296       u_p.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00297       this->p = u_p.real;
00298       offset += sizeof(this->p);
00299       union {
00300         double real;
00301         uint64_t base;
00302       } u_i;
00303       u_i.base = 0;
00304       u_i.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00305       u_i.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00306       u_i.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00307       u_i.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00308       u_i.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00309       u_i.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00310       u_i.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00311       u_i.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00312       this->i = u_i.real;
00313       offset += sizeof(this->i);
00314       union {
00315         double real;
00316         uint64_t base;
00317       } u_d;
00318       u_d.base = 0;
00319       u_d.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00320       u_d.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00321       u_d.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00322       u_d.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00323       u_d.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00324       u_d.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00325       u_d.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00326       u_d.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00327       this->d = u_d.real;
00328       offset += sizeof(this->d);
00329       union {
00330         double real;
00331         uint64_t base;
00332       } u_i_clamp;
00333       u_i_clamp.base = 0;
00334       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00335       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00336       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00337       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00338       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00339       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00340       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00341       u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00342       this->i_clamp = u_i_clamp.real;
00343       offset += sizeof(this->i_clamp);
00344      return offset;
00345     }
00346 
00347     const char * getType(){ return "control_msgs/JointControllerState"; };
00348     const char * getMD5(){ return "c0d034a7bf20aeb1c37f3eccb7992b69"; };
00349 
00350   };
00351 
00352 }
00353 #endif