catchrobo2022 / Mbed 2 deprecated catchrobo2022_mbed

Dependencies:   mbed

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers ControlStruct.h Source File

ControlStruct.h

00001 #ifndef _ROS_catchrobo_msgs_ControlStruct_h
00002 #define _ROS_catchrobo_msgs_ControlStruct_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 
00009 namespace catchrobo_msgs
00010 {
00011 
00012   class ControlStruct : public ros::Msg
00013   {
00014     public:
00015       typedef int32_t _id_type;
00016       _id_type id;
00017       typedef double _p_des_type;
00018       _p_des_type p_des;
00019       typedef double _v_des_type;
00020       _v_des_type v_des;
00021       typedef double _torque_feed_forward_type;
00022       _torque_feed_forward_type torque_feed_forward;
00023       typedef double _kp_type;
00024       _kp_type kp;
00025       typedef double _kd_type;
00026       _kd_type kd;
00027 
00028     ControlStruct():
00029       id(0),
00030       p_des(0),
00031       v_des(0),
00032       torque_feed_forward(0),
00033       kp(0),
00034       kd(0)
00035     {
00036     }
00037 
00038     virtual int serialize(unsigned char *outbuffer) const
00039     {
00040       int offset = 0;
00041       union {
00042         int32_t real;
00043         uint32_t base;
00044       } u_id;
00045       u_id.real = this->id;
00046       *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
00047       *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
00048       *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
00049       *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
00050       offset += sizeof(this->id);
00051       union {
00052         double real;
00053         uint64_t base;
00054       } u_p_des;
00055       u_p_des.real = this->p_des;
00056       *(outbuffer + offset + 0) = (u_p_des.base >> (8 * 0)) & 0xFF;
00057       *(outbuffer + offset + 1) = (u_p_des.base >> (8 * 1)) & 0xFF;
00058       *(outbuffer + offset + 2) = (u_p_des.base >> (8 * 2)) & 0xFF;
00059       *(outbuffer + offset + 3) = (u_p_des.base >> (8 * 3)) & 0xFF;
00060       *(outbuffer + offset + 4) = (u_p_des.base >> (8 * 4)) & 0xFF;
00061       *(outbuffer + offset + 5) = (u_p_des.base >> (8 * 5)) & 0xFF;
00062       *(outbuffer + offset + 6) = (u_p_des.base >> (8 * 6)) & 0xFF;
00063       *(outbuffer + offset + 7) = (u_p_des.base >> (8 * 7)) & 0xFF;
00064       offset += sizeof(this->p_des);
00065       union {
00066         double real;
00067         uint64_t base;
00068       } u_v_des;
00069       u_v_des.real = this->v_des;
00070       *(outbuffer + offset + 0) = (u_v_des.base >> (8 * 0)) & 0xFF;
00071       *(outbuffer + offset + 1) = (u_v_des.base >> (8 * 1)) & 0xFF;
00072       *(outbuffer + offset + 2) = (u_v_des.base >> (8 * 2)) & 0xFF;
00073       *(outbuffer + offset + 3) = (u_v_des.base >> (8 * 3)) & 0xFF;
00074       *(outbuffer + offset + 4) = (u_v_des.base >> (8 * 4)) & 0xFF;
00075       *(outbuffer + offset + 5) = (u_v_des.base >> (8 * 5)) & 0xFF;
00076       *(outbuffer + offset + 6) = (u_v_des.base >> (8 * 6)) & 0xFF;
00077       *(outbuffer + offset + 7) = (u_v_des.base >> (8 * 7)) & 0xFF;
00078       offset += sizeof(this->v_des);
00079       union {
00080         double real;
00081         uint64_t base;
00082       } u_torque_feed_forward;
00083       u_torque_feed_forward.real = this->torque_feed_forward;
00084       *(outbuffer + offset + 0) = (u_torque_feed_forward.base >> (8 * 0)) & 0xFF;
00085       *(outbuffer + offset + 1) = (u_torque_feed_forward.base >> (8 * 1)) & 0xFF;
00086       *(outbuffer + offset + 2) = (u_torque_feed_forward.base >> (8 * 2)) & 0xFF;
00087       *(outbuffer + offset + 3) = (u_torque_feed_forward.base >> (8 * 3)) & 0xFF;
00088       *(outbuffer + offset + 4) = (u_torque_feed_forward.base >> (8 * 4)) & 0xFF;
00089       *(outbuffer + offset + 5) = (u_torque_feed_forward.base >> (8 * 5)) & 0xFF;
00090       *(outbuffer + offset + 6) = (u_torque_feed_forward.base >> (8 * 6)) & 0xFF;
00091       *(outbuffer + offset + 7) = (u_torque_feed_forward.base >> (8 * 7)) & 0xFF;
00092       offset += sizeof(this->torque_feed_forward);
00093       union {
00094         double real;
00095         uint64_t base;
00096       } u_kp;
00097       u_kp.real = this->kp;
00098       *(outbuffer + offset + 0) = (u_kp.base >> (8 * 0)) & 0xFF;
00099       *(outbuffer + offset + 1) = (u_kp.base >> (8 * 1)) & 0xFF;
00100       *(outbuffer + offset + 2) = (u_kp.base >> (8 * 2)) & 0xFF;
00101       *(outbuffer + offset + 3) = (u_kp.base >> (8 * 3)) & 0xFF;
00102       *(outbuffer + offset + 4) = (u_kp.base >> (8 * 4)) & 0xFF;
00103       *(outbuffer + offset + 5) = (u_kp.base >> (8 * 5)) & 0xFF;
00104       *(outbuffer + offset + 6) = (u_kp.base >> (8 * 6)) & 0xFF;
00105       *(outbuffer + offset + 7) = (u_kp.base >> (8 * 7)) & 0xFF;
00106       offset += sizeof(this->kp);
00107       union {
00108         double real;
00109         uint64_t base;
00110       } u_kd;
00111       u_kd.real = this->kd;
00112       *(outbuffer + offset + 0) = (u_kd.base >> (8 * 0)) & 0xFF;
00113       *(outbuffer + offset + 1) = (u_kd.base >> (8 * 1)) & 0xFF;
00114       *(outbuffer + offset + 2) = (u_kd.base >> (8 * 2)) & 0xFF;
00115       *(outbuffer + offset + 3) = (u_kd.base >> (8 * 3)) & 0xFF;
00116       *(outbuffer + offset + 4) = (u_kd.base >> (8 * 4)) & 0xFF;
00117       *(outbuffer + offset + 5) = (u_kd.base >> (8 * 5)) & 0xFF;
00118       *(outbuffer + offset + 6) = (u_kd.base >> (8 * 6)) & 0xFF;
00119       *(outbuffer + offset + 7) = (u_kd.base >> (8 * 7)) & 0xFF;
00120       offset += sizeof(this->kd);
00121       return offset;
00122     }
00123 
00124     virtual int deserialize(unsigned char *inbuffer)
00125     {
00126       int offset = 0;
00127       union {
00128         int32_t real;
00129         uint32_t base;
00130       } u_id;
00131       u_id.base = 0;
00132       u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00133       u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00134       u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00135       u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00136       this->id = u_id.real;
00137       offset += sizeof(this->id);
00138       union {
00139         double real;
00140         uint64_t base;
00141       } u_p_des;
00142       u_p_des.base = 0;
00143       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00144       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00145       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00146       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00147       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00148       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00149       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00150       u_p_des.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00151       this->p_des = u_p_des.real;
00152       offset += sizeof(this->p_des);
00153       union {
00154         double real;
00155         uint64_t base;
00156       } u_v_des;
00157       u_v_des.base = 0;
00158       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00159       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00160       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00161       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00162       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00163       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00164       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00165       u_v_des.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00166       this->v_des = u_v_des.real;
00167       offset += sizeof(this->v_des);
00168       union {
00169         double real;
00170         uint64_t base;
00171       } u_torque_feed_forward;
00172       u_torque_feed_forward.base = 0;
00173       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00174       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00175       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00176       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00177       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00178       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00179       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00180       u_torque_feed_forward.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00181       this->torque_feed_forward = u_torque_feed_forward.real;
00182       offset += sizeof(this->torque_feed_forward);
00183       union {
00184         double real;
00185         uint64_t base;
00186       } u_kp;
00187       u_kp.base = 0;
00188       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00189       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00190       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00191       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00192       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00193       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00194       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00195       u_kp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00196       this->kp = u_kp.real;
00197       offset += sizeof(this->kp);
00198       union {
00199         double real;
00200         uint64_t base;
00201       } u_kd;
00202       u_kd.base = 0;
00203       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00204       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00205       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00206       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00207       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00208       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00209       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00210       u_kd.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00211       this->kd = u_kd.real;
00212       offset += sizeof(this->kd);
00213      return offset;
00214     }
00215 
00216     virtual const char * getType(){ return "catchrobo_msgs/ControlStruct"; };
00217     virtual const char * getMD5(){ return "85eed48bd859421add1590c25dc8235c"; };
00218 
00219   };
00220 
00221 }
00222 #endif