SetPidGains.h

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