Irfan Tito Kurniawan
/
ros_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.
Revision 0:8f3710bfd298, committed 2020-09-02
- Comitter:
- irfantitok
- Date:
- Wed Sep 02 13:51:31 2020 +0000
- Commit message:
- Resolved round not found
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/BufferedSerial/Buffer/Buffer.cpp Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+
+/**
+ * @file Buffer.cpp
+ * @brief Software Buffer - Templated Ring Buffer for most data types
+ * @author sam grove
+ * @version 1.0
+ * @see
+ *
+ * Copyright (c) 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Buffer.h"
+
+template <class T>
+Buffer<T>::Buffer(uint32_t size)
+{
+ _buf = new T [size];
+ _size = size;
+ clear();
+
+ return;
+}
+
+template <class T>
+Buffer<T>::~Buffer()
+{
+ delete [] _buf;
+
+ return;
+}
+
+template <class T>
+uint32_t Buffer<T>::getSize()
+{
+ return this->_size;
+}
+
+template <class T>
+void Buffer<T>::clear(void)
+{
+ _wloc = 0;
+ _rloc = 0;
+ memset(_buf, 0, _size);
+
+ return;
+}
+
+template <class T>
+uint32_t Buffer<T>::peek(char c)
+{
+ return 1;
+}
+
+// make the linker aware of some possible types
+template class Buffer<uint8_t>;
+template class Buffer<int8_t>;
+template class Buffer<uint16_t>;
+template class Buffer<int16_t>;
+template class Buffer<uint32_t>;
+template class Buffer<int32_t>;
+template class Buffer<uint64_t>;
+template class Buffer<int64_t>;
+template class Buffer<char>;
+template class Buffer<wchar_t>;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/BufferedSerial/Buffer/Buffer.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,163 @@
+
+/**
+ * @file Buffer.h
+ * @brief Software Buffer - Templated Ring Buffer for most data types
+ * @author sam grove
+ * @version 1.0
+ * @see
+ *
+ * Copyright (c) 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BUFFER_H
+#define BUFFER_H
+
+#include <stdint.h>
+#include <string.h>
+
+/** A templated software ring buffer
+ *
+ * Example:
+ * @code
+ * #include "mbed.h"
+ * #include "Buffer.h"
+ *
+ * Buffer <char> buf;
+ *
+ * int main()
+ * {
+ * buf = 'a';
+ * buf.put('b');
+ * char *head = buf.head();
+ * puts(head);
+ *
+ * char whats_in_there[2] = {0};
+ * int pos = 0;
+ *
+ * while(buf.available())
+ * {
+ * whats_in_there[pos++] = buf;
+ * }
+ * printf("%c %c\n", whats_in_there[0], whats_in_there[1]);
+ * buf.clear();
+ * error("done\n\n\n");
+ * }
+ * @endcode
+ */
+
+template <typename T>
+class Buffer
+{
+private:
+ T *_buf;
+ volatile uint32_t _wloc;
+ volatile uint32_t _rloc;
+ uint32_t _size;
+
+public:
+ /** Create a Buffer and allocate memory for it
+ * @param size The size of the buffer
+ */
+ Buffer(uint32_t size = 0x100);
+
+ /** Get the size of the ring buffer
+ * @return the size of the ring buffer
+ */
+ uint32_t getSize();
+
+ /** Destry a Buffer and release it's allocated memory
+ */
+ ~Buffer();
+
+ /** Add a data element into the buffer
+ * @param data Something to add to the buffer
+ */
+ void put(T data);
+
+ /** Remove a data element from the buffer
+ * @return Pull the oldest element from the buffer
+ */
+ T get(void);
+
+ /** Get the address to the head of the buffer
+ * @return The address of element 0 in the buffer
+ */
+ T *head(void);
+
+ /** Reset the buffer to 0. Useful if using head() to parse packeted data
+ */
+ void clear(void);
+
+ /** Determine if anything is readable in the buffer
+ * @return 1 if something can be read, 0 otherwise
+ */
+ uint32_t available(void);
+
+ /** Overloaded operator for writing to the buffer
+ * @param data Something to put in the buffer
+ * @return
+ */
+ Buffer &operator= (T data)
+ {
+ put(data);
+ return *this;
+ }
+
+ /** Overloaded operator for reading from the buffer
+ * @return Pull the oldest element from the buffer
+ */
+ operator int(void)
+ {
+ return get();
+ }
+
+ uint32_t peek(char c);
+
+};
+
+template <class T>
+inline void Buffer<T>::put(T data)
+{
+ _buf[_wloc++] = data;
+ _wloc %= (_size-1);
+
+ return;
+}
+
+template <class T>
+inline T Buffer<T>::get(void)
+{
+ T data_pos = _buf[_rloc++];
+ _rloc %= (_size-1);
+
+ return data_pos;
+}
+
+template <class T>
+inline T *Buffer<T>::head(void)
+{
+ T *data_pos = &_buf[0];
+
+ return data_pos;
+}
+
+template <class T>
+inline uint32_t Buffer<T>::available(void)
+{
+ return (_wloc == _rloc) ? 0 : 1;
+}
+
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/BufferedSerial/BufferedSerial.cpp Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,158 @@
+/**
+ * @file BufferedSerial.cpp
+ * @brief Software Buffer - Extends mbed Serial functionallity adding irq driven TX and RX
+ * @author sam grove
+ * @version 1.0
+ * @see
+ *
+ * Copyright (c) 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BufferedSerial.h"
+#include <stdarg.h>
+
+BufferedSerial::BufferedSerial(PinName tx, PinName rx, uint32_t buf_size, uint32_t tx_multiple, const char* name)
+ : RawSerial(tx, rx) , _rxbuf(buf_size), _txbuf((uint32_t)(tx_multiple*buf_size))
+{
+ RawSerial::attach(this, &BufferedSerial::rxIrq, Serial::RxIrq);
+ this->_buf_size = buf_size;
+ this->_tx_multiple = tx_multiple;
+ return;
+}
+
+BufferedSerial::~BufferedSerial(void)
+{
+ RawSerial::attach(NULL, RawSerial::RxIrq);
+ RawSerial::attach(NULL, RawSerial::TxIrq);
+
+ return;
+}
+
+int BufferedSerial::readable(void)
+{
+ return _rxbuf.available(); // note: look if things are in the buffer
+}
+
+int BufferedSerial::writeable(void)
+{
+ return 1; // buffer allows overwriting by design, always true
+}
+
+int BufferedSerial::getc(void)
+{
+ return _rxbuf;
+}
+
+int BufferedSerial::putc(int c)
+{
+ _txbuf = (char)c;
+ BufferedSerial::prime();
+
+ return c;
+}
+
+int BufferedSerial::puts(const char *s)
+{
+ if (s != NULL) {
+ const char* ptr = s;
+
+ while(*(ptr) != 0) {
+ _txbuf = *(ptr++);
+ }
+ _txbuf = '\n'; // done per puts definition
+ BufferedSerial::prime();
+
+ return (ptr - s) + 1;
+ }
+ return 0;
+}
+
+int BufferedSerial::printf(const char* format, ...)
+{
+ char buffer[this->_buf_size];
+ memset(buffer,0,this->_buf_size);
+ int r = 0;
+
+ va_list arg;
+ va_start(arg, format);
+ r = vsprintf(buffer, format, arg);
+ // this may not hit the heap but should alert the user anyways
+ if(r > this->_buf_size) {
+ error("%s %d buffer overwrite (max_buf_size: %d exceeded: %d)!\r\n", __FILE__, __LINE__,this->_buf_size,r);
+ va_end(arg);
+ return 0;
+ }
+ va_end(arg);
+ r = BufferedSerial::write(buffer, r);
+
+ return r;
+}
+
+ssize_t BufferedSerial::write(const void *s, size_t length)
+{
+ if (s != NULL && length > 0) {
+ const char* ptr = (const char*)s;
+ const char* end = ptr + length;
+
+ while (ptr != end) {
+ _txbuf = *(ptr++);
+ }
+ BufferedSerial::prime();
+
+ return ptr - (const char*)s;
+ }
+ return 0;
+}
+
+
+void BufferedSerial::rxIrq(void)
+{
+ // read from the peripheral and make sure something is available
+ if(serial_readable(&_serial)) {
+ _rxbuf = serial_getc(&_serial); // if so load them into a buffer
+ }
+
+ return;
+}
+
+void BufferedSerial::txIrq(void)
+{
+ // see if there is room in the hardware fifo and if something is in the software fifo
+ while(serial_writable(&_serial)) {
+ if(_txbuf.available()) {
+ serial_putc(&_serial, (int)_txbuf.get());
+ } else {
+ // disable the TX interrupt when there is nothing left to send
+ RawSerial::attach(NULL, RawSerial::TxIrq);
+ break;
+ }
+ }
+
+ return;
+}
+
+void BufferedSerial::prime(void)
+{
+ // if already busy then the irq will pick this up
+ if(serial_writable(&_serial)) {
+ RawSerial::attach(NULL, RawSerial::TxIrq); // make sure not to cause contention in the irq
+ BufferedSerial::txIrq(); // only write to hardware in one place
+ RawSerial::attach(this, &BufferedSerial::txIrq, RawSerial::TxIrq);
+ }
+
+ return;
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/BufferedSerial/BufferedSerial.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,140 @@
+
+/**
+ * @file BufferedSerial.h
+ * @brief Software Buffer - Extends mbed Serial functionallity adding irq driven TX and RX
+ * @author sam grove
+ * @version 1.0
+ * @see
+ *
+ * Copyright (c) 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BUFFEREDSERIAL_H
+#define BUFFEREDSERIAL_H
+
+#include "mbed.h"
+#include "Buffer.h"
+
+/** A serial port (UART) for communication with other serial devices
+ *
+ * Can be used for Full Duplex communication, or Simplex by specifying
+ * one pin as NC (Not Connected)
+ *
+ * Example:
+ * @code
+ * #include "mbed.h"
+ * #include "BufferedSerial.h"
+ *
+ * BufferedSerial pc(USBTX, USBRX);
+ *
+ * int main()
+ * {
+ * while(1)
+ * {
+ * Timer s;
+ *
+ * s.start();
+ * pc.printf("Hello World - buffered\n");
+ * int buffered_time = s.read_us();
+ * wait(0.1f); // give time for the buffer to empty
+ *
+ * s.reset();
+ * printf("Hello World - blocking\n");
+ * int polled_time = s.read_us();
+ * s.stop();
+ * wait(0.1f); // give time for the buffer to empty
+ *
+ * pc.printf("printf buffered took %d us\n", buffered_time);
+ * pc.printf("printf blocking took %d us\n", polled_time);
+ * wait(0.5f);
+ * }
+ * }
+ * @endcode
+ */
+
+/**
+ * @class BufferedSerial
+ * @brief Software buffers and interrupt driven tx and rx for Serial
+ */
+class BufferedSerial : public RawSerial
+{
+private:
+ Buffer <char> _rxbuf;
+ Buffer <char> _txbuf;
+ uint32_t _buf_size;
+ uint32_t _tx_multiple;
+
+ void rxIrq(void);
+ void txIrq(void);
+ void prime(void);
+
+public:
+ /** Create a BufferedSerial port, connected to the specified transmit and receive pins
+ * @param tx Transmit pin
+ * @param rx Receive pin
+ * @param buf_size printf() buffer size
+ * @param tx_multiple amount of max printf() present in the internal ring buffer at one time
+ * @param name optional name
+ * @note Either tx or rx may be specified as NC if unused
+ */
+ BufferedSerial(PinName tx, PinName rx, uint32_t buf_size = 256, uint32_t tx_multiple = 4,const char* name=NULL);
+
+ /** Destroy a BufferedSerial port
+ */
+ virtual ~BufferedSerial(void);
+
+ /** Check on how many bytes are in the rx buffer
+ * @return 1 if something exists, 0 otherwise
+ */
+ virtual int readable(void);
+
+ /** Check to see if the tx buffer has room
+ * @return 1 always has room and can overwrite previous content if too small / slow
+ */
+ virtual int writeable(void);
+
+ /** Get a single byte from the BufferedSerial Port.
+ * Should check readable() before calling this.
+ * @return A byte that came in on the Serial Port
+ */
+ virtual int getc(void);
+
+ /** Write a single byte to the BufferedSerial Port.
+ * @param c The byte to write to the Serial Port
+ * @return The byte that was written to the Serial Port Buffer
+ */
+ virtual int putc(int c);
+
+ /** Write a string to the BufferedSerial Port. Must be NULL terminated
+ * @param s The string to write to the Serial Port
+ * @return The number of bytes written to the Serial Port Buffer
+ */
+ virtual int puts(const char *s);
+
+ /** Write a formatted string to the BufferedSerial Port.
+ * @param format The string + format specifiers to write to the Serial Port
+ * @return The number of bytes written to the Serial Port Buffer
+ */
+ virtual int printf(const char* format, ...);
+
+ /** Write data to the Buffered Serial Port
+ * @param s A pointer to data to send
+ * @param length The amount of data being pointed to
+ * @return The number of bytes written to the Serial Port Buffer
+ */
+ virtual ssize_t write(const void *s, std::size_t length);
+};
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/MbedHardware.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,60 @@
+/*
+ * MbedHardware
+ *
+ * Created on: Aug 17, 2011
+ * Author: nucho
+ */
+
+#ifndef ROS_MBED_HARDWARE_H_
+#define ROS_MBED_HARDWARE_H_
+
+#include "mbed.h"
+
+#include "BufferedSerial.h"
+
+class MbedHardware {
+ public:
+ MbedHardware(PinName tx, PinName rx, long baud = 57600)
+ :iostream(tx, rx){
+ baud_ = baud;
+ t.start();
+ }
+
+ MbedHardware()
+ :iostream(USBTX, USBRX) {
+ baud_ = 57600;
+ t.start();
+ }
+
+ void setBaud(long baud){
+ this->baud_= baud;
+ }
+
+ int getBaud(){return baud_;}
+
+ void init(){
+ iostream.baud(baud_);
+ }
+
+ int read(){
+ if (iostream.readable()) {
+ return iostream.getc();
+ } else {
+ return -1;
+ }
+ };
+ void write(uint8_t* data, int length) {
+ for (int i=0; i<length; i++)
+ iostream.putc(data[i]);
+ }
+
+ unsigned long time(){return t.read_ms();}
+
+protected:
+ BufferedSerial iostream;
+ long baud_;
+ Timer t;
+};
+
+
+#endif /* ROS_MBED_HARDWARE_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestAction_h
+#define _ROS_actionlib_TestAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "actionlib/TestActionGoal.h"
+#include "actionlib/TestActionResult.h"
+#include "actionlib/TestActionFeedback.h"
+
+namespace actionlib
+{
+
+ class TestAction : public ros::Msg
+ {
+ public:
+ typedef actionlib::TestActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef actionlib::TestActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef actionlib::TestActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ TestAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestAction"; };
+ const char * getMD5(){ return "991e87a72802262dfbe5d1b3cf6efc9a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestActionFeedback_h
+#define _ROS_actionlib_TestActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib/TestFeedback.h"
+
+namespace actionlib
+{
+
+ class TestActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib::TestFeedback _feedback_type;
+ _feedback_type feedback;
+
+ TestActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestActionFeedback"; };
+ const char * getMD5(){ return "6d3d0bf7fb3dda24779c010a9f3eb7cb"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestActionGoal_h
+#define _ROS_actionlib_TestActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "actionlib/TestGoal.h"
+
+namespace actionlib
+{
+
+ class TestActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef actionlib::TestGoal _goal_type;
+ _goal_type goal;
+
+ TestActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestActionGoal"; };
+ const char * getMD5(){ return "348369c5b403676156094e8c159720bf"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestActionResult_h
+#define _ROS_actionlib_TestActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib/TestResult.h"
+
+namespace actionlib
+{
+
+ class TestActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib::TestResult _result_type;
+ _result_type result;
+
+ TestActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestActionResult"; };
+ const char * getMD5(){ return "3d669e3a63aa986c667ea7b0f46ce85e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_actionlib_TestFeedback_h
+#define _ROS_actionlib_TestFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TestFeedback : public ros::Msg
+ {
+ public:
+ typedef int32_t _feedback_type;
+ _feedback_type feedback;
+
+ TestFeedback():
+ feedback(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_feedback;
+ u_feedback.real = this->feedback;
+ *(outbuffer + offset + 0) = (u_feedback.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_feedback.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_feedback.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_feedback.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->feedback);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_feedback;
+ u_feedback.base = 0;
+ u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_feedback.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->feedback = u_feedback.real;
+ offset += sizeof(this->feedback);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestFeedback"; };
+ const char * getMD5(){ return "49ceb5b32ea3af22073ede4a0328249e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_actionlib_TestGoal_h
+#define _ROS_actionlib_TestGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TestGoal : public ros::Msg
+ {
+ public:
+ typedef int32_t _goal_type;
+ _goal_type goal;
+
+ TestGoal():
+ goal(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_goal;
+ u_goal.real = this->goal;
+ *(outbuffer + offset + 0) = (u_goal.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_goal.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_goal.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_goal.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->goal);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_goal;
+ u_goal.base = 0;
+ u_goal.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_goal.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_goal.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_goal.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->goal = u_goal.real;
+ offset += sizeof(this->goal);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestGoal"; };
+ const char * getMD5(){ return "18df0149936b7aa95588e3862476ebde"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestRequestAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestRequestAction_h
+#define _ROS_actionlib_TestRequestAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "actionlib/TestRequestActionGoal.h"
+#include "actionlib/TestRequestActionResult.h"
+#include "actionlib/TestRequestActionFeedback.h"
+
+namespace actionlib
+{
+
+ class TestRequestAction : public ros::Msg
+ {
+ public:
+ typedef actionlib::TestRequestActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef actionlib::TestRequestActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef actionlib::TestRequestActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ TestRequestAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestRequestAction"; };
+ const char * getMD5(){ return "dc44b1f4045dbf0d1db54423b3b86b30"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestRequestActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestRequestActionFeedback_h
+#define _ROS_actionlib_TestRequestActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib/TestRequestFeedback.h"
+
+namespace actionlib
+{
+
+ class TestRequestActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib::TestRequestFeedback _feedback_type;
+ _feedback_type feedback;
+
+ TestRequestActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestRequestActionFeedback"; };
+ const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestRequestActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestRequestActionGoal_h
+#define _ROS_actionlib_TestRequestActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "actionlib/TestRequestGoal.h"
+
+namespace actionlib
+{
+
+ class TestRequestActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef actionlib::TestRequestGoal _goal_type;
+ _goal_type goal;
+
+ TestRequestActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestRequestActionGoal"; };
+ const char * getMD5(){ return "1889556d3fef88f821c7cb004e4251f3"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestRequestActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TestRequestActionResult_h
+#define _ROS_actionlib_TestRequestActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib/TestRequestResult.h"
+
+namespace actionlib
+{
+
+ class TestRequestActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib::TestRequestResult _result_type;
+ _result_type result;
+
+ TestRequestActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestRequestActionResult"; };
+ const char * getMD5(){ return "0476d1fdf437a3a6e7d6d0e9f5561298"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestRequestFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_actionlib_TestRequestFeedback_h
+#define _ROS_actionlib_TestRequestFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TestRequestFeedback : public ros::Msg
+ {
+ public:
+
+ TestRequestFeedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestRequestFeedback"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestRequestGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,215 @@
+#ifndef _ROS_actionlib_TestRequestGoal_h
+#define _ROS_actionlib_TestRequestGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/duration.h"
+
+namespace actionlib
+{
+
+ class TestRequestGoal : public ros::Msg
+ {
+ public:
+ typedef int32_t _terminate_status_type;
+ _terminate_status_type terminate_status;
+ typedef bool _ignore_cancel_type;
+ _ignore_cancel_type ignore_cancel;
+ typedef const char* _result_text_type;
+ _result_text_type result_text;
+ typedef int32_t _the_result_type;
+ _the_result_type the_result;
+ typedef bool _is_simple_client_type;
+ _is_simple_client_type is_simple_client;
+ typedef ros::Duration _delay_accept_type;
+ _delay_accept_type delay_accept;
+ typedef ros::Duration _delay_terminate_type;
+ _delay_terminate_type delay_terminate;
+ typedef ros::Duration _pause_status_type;
+ _pause_status_type pause_status;
+ enum { TERMINATE_SUCCESS = 0 };
+ enum { TERMINATE_ABORTED = 1 };
+ enum { TERMINATE_REJECTED = 2 };
+ enum { TERMINATE_LOSE = 3 };
+ enum { TERMINATE_DROP = 4 };
+ enum { TERMINATE_EXCEPTION = 5 };
+
+ TestRequestGoal():
+ terminate_status(0),
+ ignore_cancel(0),
+ result_text(""),
+ the_result(0),
+ is_simple_client(0),
+ delay_accept(),
+ delay_terminate(),
+ pause_status()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_terminate_status;
+ u_terminate_status.real = this->terminate_status;
+ *(outbuffer + offset + 0) = (u_terminate_status.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_terminate_status.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_terminate_status.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_terminate_status.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->terminate_status);
+ union {
+ bool real;
+ uint8_t base;
+ } u_ignore_cancel;
+ u_ignore_cancel.real = this->ignore_cancel;
+ *(outbuffer + offset + 0) = (u_ignore_cancel.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->ignore_cancel);
+ uint32_t length_result_text = strlen(this->result_text);
+ varToArr(outbuffer + offset, length_result_text);
+ offset += 4;
+ memcpy(outbuffer + offset, this->result_text, length_result_text);
+ offset += length_result_text;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_the_result;
+ u_the_result.real = this->the_result;
+ *(outbuffer + offset + 0) = (u_the_result.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_the_result.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_the_result.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_the_result.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->the_result);
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_simple_client;
+ u_is_simple_client.real = this->is_simple_client;
+ *(outbuffer + offset + 0) = (u_is_simple_client.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->is_simple_client);
+ *(outbuffer + offset + 0) = (this->delay_accept.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->delay_accept.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->delay_accept.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->delay_accept.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->delay_accept.sec);
+ *(outbuffer + offset + 0) = (this->delay_accept.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->delay_accept.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->delay_accept.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->delay_accept.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->delay_accept.nsec);
+ *(outbuffer + offset + 0) = (this->delay_terminate.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->delay_terminate.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->delay_terminate.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->delay_terminate.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->delay_terminate.sec);
+ *(outbuffer + offset + 0) = (this->delay_terminate.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->delay_terminate.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->delay_terminate.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->delay_terminate.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->delay_terminate.nsec);
+ *(outbuffer + offset + 0) = (this->pause_status.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->pause_status.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->pause_status.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->pause_status.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->pause_status.sec);
+ *(outbuffer + offset + 0) = (this->pause_status.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->pause_status.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->pause_status.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->pause_status.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->pause_status.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_terminate_status;
+ u_terminate_status.base = 0;
+ u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_terminate_status.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->terminate_status = u_terminate_status.real;
+ offset += sizeof(this->terminate_status);
+ union {
+ bool real;
+ uint8_t base;
+ } u_ignore_cancel;
+ u_ignore_cancel.base = 0;
+ u_ignore_cancel.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->ignore_cancel = u_ignore_cancel.real;
+ offset += sizeof(this->ignore_cancel);
+ uint32_t length_result_text;
+ arrToVar(length_result_text, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_result_text; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_result_text-1]=0;
+ this->result_text = (char *)(inbuffer + offset-1);
+ offset += length_result_text;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_the_result;
+ u_the_result.base = 0;
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->the_result = u_the_result.real;
+ offset += sizeof(this->the_result);
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_simple_client;
+ u_is_simple_client.base = 0;
+ u_is_simple_client.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->is_simple_client = u_is_simple_client.real;
+ offset += sizeof(this->is_simple_client);
+ this->delay_accept.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->delay_accept.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->delay_accept.sec);
+ this->delay_accept.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->delay_accept.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->delay_accept.nsec);
+ this->delay_terminate.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->delay_terminate.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->delay_terminate.sec);
+ this->delay_terminate.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->delay_terminate.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->delay_terminate.nsec);
+ this->pause_status.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->pause_status.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->pause_status.sec);
+ this->pause_status.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->pause_status.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->pause_status.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestRequestGoal"; };
+ const char * getMD5(){ return "db5d00ba98302d6c6dd3737e9a03ceea"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestRequestResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,80 @@
+#ifndef _ROS_actionlib_TestRequestResult_h
+#define _ROS_actionlib_TestRequestResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TestRequestResult : public ros::Msg
+ {
+ public:
+ typedef int32_t _the_result_type;
+ _the_result_type the_result;
+ typedef bool _is_simple_server_type;
+ _is_simple_server_type is_simple_server;
+
+ TestRequestResult():
+ the_result(0),
+ is_simple_server(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_the_result;
+ u_the_result.real = this->the_result;
+ *(outbuffer + offset + 0) = (u_the_result.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_the_result.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_the_result.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_the_result.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->the_result);
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_simple_server;
+ u_is_simple_server.real = this->is_simple_server;
+ *(outbuffer + offset + 0) = (u_is_simple_server.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->is_simple_server);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_the_result;
+ u_the_result.base = 0;
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->the_result = u_the_result.real;
+ offset += sizeof(this->the_result);
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_simple_server;
+ u_is_simple_server.base = 0;
+ u_is_simple_server.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->is_simple_server = u_is_simple_server.real;
+ offset += sizeof(this->is_simple_server);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestRequestResult"; };
+ const char * getMD5(){ return "61c2364524499c7c5017e2f3fce7ba06"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TestResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_actionlib_TestResult_h
+#define _ROS_actionlib_TestResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TestResult : public ros::Msg
+ {
+ public:
+ typedef int32_t _result_type;
+ _result_type result;
+
+ TestResult():
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_result;
+ u_result.real = this->result;
+ *(outbuffer + offset + 0) = (u_result.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_result.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_result.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_result.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_result;
+ u_result.base = 0;
+ u_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->result = u_result.real;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TestResult"; };
+ const char * getMD5(){ return "034a8e20d6a306665e3a5b340fab3f09"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TwoIntsAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TwoIntsAction_h
+#define _ROS_actionlib_TwoIntsAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "actionlib/TwoIntsActionGoal.h"
+#include "actionlib/TwoIntsActionResult.h"
+#include "actionlib/TwoIntsActionFeedback.h"
+
+namespace actionlib
+{
+
+ class TwoIntsAction : public ros::Msg
+ {
+ public:
+ typedef actionlib::TwoIntsActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef actionlib::TwoIntsActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef actionlib::TwoIntsActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ TwoIntsAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TwoIntsAction"; };
+ const char * getMD5(){ return "6d1aa538c4bd6183a2dfb7fcac41ee50"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TwoIntsActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TwoIntsActionFeedback_h
+#define _ROS_actionlib_TwoIntsActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib/TwoIntsFeedback.h"
+
+namespace actionlib
+{
+
+ class TwoIntsActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib::TwoIntsFeedback _feedback_type;
+ _feedback_type feedback;
+
+ TwoIntsActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TwoIntsActionFeedback"; };
+ const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TwoIntsActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TwoIntsActionGoal_h
+#define _ROS_actionlib_TwoIntsActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "actionlib/TwoIntsGoal.h"
+
+namespace actionlib
+{
+
+ class TwoIntsActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef actionlib::TwoIntsGoal _goal_type;
+ _goal_type goal;
+
+ TwoIntsActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TwoIntsActionGoal"; };
+ const char * getMD5(){ return "684a2db55d6ffb8046fb9d6764ce0860"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TwoIntsActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_TwoIntsActionResult_h
+#define _ROS_actionlib_TwoIntsActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib/TwoIntsResult.h"
+
+namespace actionlib
+{
+
+ class TwoIntsActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib::TwoIntsResult _result_type;
+ _result_type result;
+
+ TwoIntsActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TwoIntsActionResult"; };
+ const char * getMD5(){ return "3ba7dea8b8cddcae4528ade4ef74b6e7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TwoIntsFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_actionlib_TwoIntsFeedback_h
+#define _ROS_actionlib_TwoIntsFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TwoIntsFeedback : public ros::Msg
+ {
+ public:
+
+ TwoIntsFeedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TwoIntsFeedback"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TwoIntsGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,102 @@
+#ifndef _ROS_actionlib_TwoIntsGoal_h
+#define _ROS_actionlib_TwoIntsGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TwoIntsGoal : public ros::Msg
+ {
+ public:
+ typedef int64_t _a_type;
+ _a_type a;
+ typedef int64_t _b_type;
+ _b_type b;
+
+ TwoIntsGoal():
+ a(0),
+ b(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.real = this->a;
+ *(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->a);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_b;
+ u_b.real = this->b;
+ *(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_b.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_b.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_b.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_b.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.base = 0;
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->a = u_a.real;
+ offset += sizeof(this->a);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_b;
+ u_b.base = 0;
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->b = u_b.real;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TwoIntsGoal"; };
+ const char * getMD5(){ return "36d09b846be0b371c5f190354dd3153e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib/TwoIntsResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_actionlib_TwoIntsResult_h
+#define _ROS_actionlib_TwoIntsResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib
+{
+
+ class TwoIntsResult : public ros::Msg
+ {
+ public:
+ typedef int64_t _sum_type;
+ _sum_type sum;
+
+ TwoIntsResult():
+ sum(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_sum;
+ u_sum.real = this->sum;
+ *(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_sum.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_sum.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_sum.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_sum.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_sum;
+ u_sum.base = 0;
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->sum = u_sum.real;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib/TwoIntsResult"; };
+ const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_msgs/GoalID.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,79 @@
+#ifndef _ROS_actionlib_msgs_GoalID_h
+#define _ROS_actionlib_msgs_GoalID_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+
+namespace actionlib_msgs
+{
+
+ class GoalID : public ros::Msg
+ {
+ public:
+ typedef ros::Time _stamp_type;
+ _stamp_type stamp;
+ typedef const char* _id_type;
+ _id_type id;
+
+ GoalID():
+ stamp(),
+ id("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp.sec);
+ *(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp.nsec);
+ uint32_t length_id = strlen(this->id);
+ varToArr(outbuffer + offset, length_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->id, length_id);
+ offset += length_id;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->stamp.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp.sec);
+ this->stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp.nsec);
+ uint32_t length_id;
+ arrToVar(length_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_id-1]=0;
+ this->id = (char *)(inbuffer + offset-1);
+ offset += length_id;
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_msgs/GoalID"; };
+ const char * getMD5(){ return "302881f31927c1df708a2dbab0e80ee8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_msgs/GoalStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,78 @@
+#ifndef _ROS_actionlib_msgs_GoalStatus_h
+#define _ROS_actionlib_msgs_GoalStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "actionlib_msgs/GoalID.h"
+
+namespace actionlib_msgs
+{
+
+ class GoalStatus : public ros::Msg
+ {
+ public:
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef uint8_t _status_type;
+ _status_type status;
+ typedef const char* _text_type;
+ _text_type text;
+ enum { PENDING = 0 };
+ enum { ACTIVE = 1 };
+ enum { PREEMPTED = 2 };
+ enum { SUCCEEDED = 3 };
+ enum { ABORTED = 4 };
+ enum { REJECTED = 5 };
+ enum { PREEMPTING = 6 };
+ enum { RECALLING = 7 };
+ enum { RECALLED = 8 };
+ enum { LOST = 9 };
+
+ GoalStatus():
+ goal_id(),
+ status(0),
+ text("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->goal_id.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->status);
+ uint32_t length_text = strlen(this->text);
+ varToArr(outbuffer + offset, length_text);
+ offset += 4;
+ memcpy(outbuffer + offset, this->text, length_text);
+ offset += length_text;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ this->status = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->status);
+ uint32_t length_text;
+ arrToVar(length_text, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_text; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_text-1]=0;
+ this->text = (char *)(inbuffer + offset-1);
+ offset += length_text;
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_msgs/GoalStatus"; };
+ const char * getMD5(){ return "d388f9b87b3c471f784434d671988d4a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_msgs/GoalStatusArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_actionlib_msgs_GoalStatusArray_h
+#define _ROS_actionlib_msgs_GoalStatusArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+
+namespace actionlib_msgs
+{
+
+ class GoalStatusArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t status_list_length;
+ typedef actionlib_msgs::GoalStatus _status_list_type;
+ _status_list_type st_status_list;
+ _status_list_type * status_list;
+
+ GoalStatusArray():
+ header(),
+ status_list_length(0), status_list(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->status_list_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->status_list_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->status_list_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->status_list_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->status_list_length);
+ for( uint32_t i = 0; i < status_list_length; i++){
+ offset += this->status_list[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t status_list_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->status_list_length);
+ if(status_list_lengthT > status_list_length)
+ this->status_list = (actionlib_msgs::GoalStatus*)realloc(this->status_list, status_list_lengthT * sizeof(actionlib_msgs::GoalStatus));
+ status_list_length = status_list_lengthT;
+ for( uint32_t i = 0; i < status_list_length; i++){
+ offset += this->st_status_list.deserialize(inbuffer + offset);
+ memcpy( &(this->status_list[i]), &(this->st_status_list), sizeof(actionlib_msgs::GoalStatus));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_msgs/GoalStatusArray"; };
+ const char * getMD5(){ return "8b2b82f13216d0a8ea88bd3af735e619"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/AveragingAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_AveragingAction_h
+#define _ROS_actionlib_tutorials_AveragingAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "actionlib_tutorials/AveragingActionGoal.h"
+#include "actionlib_tutorials/AveragingActionResult.h"
+#include "actionlib_tutorials/AveragingActionFeedback.h"
+
+namespace actionlib_tutorials
+{
+
+ class AveragingAction : public ros::Msg
+ {
+ public:
+ typedef actionlib_tutorials::AveragingActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef actionlib_tutorials::AveragingActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef actionlib_tutorials::AveragingActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ AveragingAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/AveragingAction"; };
+ const char * getMD5(){ return "628678f2b4fa6a5951746a4a2d39e716"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/AveragingActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_AveragingActionFeedback_h
+#define _ROS_actionlib_tutorials_AveragingActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib_tutorials/AveragingFeedback.h"
+
+namespace actionlib_tutorials
+{
+
+ class AveragingActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib_tutorials::AveragingFeedback _feedback_type;
+ _feedback_type feedback;
+
+ AveragingActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/AveragingActionFeedback"; };
+ const char * getMD5(){ return "78a4a09241b1791069223ae7ebd5b16b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/AveragingActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_AveragingActionGoal_h
+#define _ROS_actionlib_tutorials_AveragingActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "actionlib_tutorials/AveragingGoal.h"
+
+namespace actionlib_tutorials
+{
+
+ class AveragingActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef actionlib_tutorials::AveragingGoal _goal_type;
+ _goal_type goal;
+
+ AveragingActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/AveragingActionGoal"; };
+ const char * getMD5(){ return "1561825b734ebd6039851c501e3fb570"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/AveragingActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_AveragingActionResult_h
+#define _ROS_actionlib_tutorials_AveragingActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib_tutorials/AveragingResult.h"
+
+namespace actionlib_tutorials
+{
+
+ class AveragingActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib_tutorials::AveragingResult _result_type;
+ _result_type result;
+
+ AveragingActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/AveragingActionResult"; };
+ const char * getMD5(){ return "8672cb489d347580acdcd05c5d497497"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/AveragingFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_actionlib_tutorials_AveragingFeedback_h
+#define _ROS_actionlib_tutorials_AveragingFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib_tutorials
+{
+
+ class AveragingFeedback : public ros::Msg
+ {
+ public:
+ typedef int32_t _sample_type;
+ _sample_type sample;
+ typedef float _data_type;
+ _data_type data;
+ typedef float _mean_type;
+ _mean_type mean;
+ typedef float _std_dev_type;
+ _std_dev_type std_dev;
+
+ AveragingFeedback():
+ sample(0),
+ data(0),
+ mean(0),
+ std_dev(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_sample;
+ u_sample.real = this->sample;
+ *(outbuffer + offset + 0) = (u_sample.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sample.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sample.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sample.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->sample);
+ union {
+ float real;
+ uint32_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data);
+ union {
+ float real;
+ uint32_t base;
+ } u_mean;
+ u_mean.real = this->mean;
+ *(outbuffer + offset + 0) = (u_mean.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_mean.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_mean.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_mean.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->mean);
+ union {
+ float real;
+ uint32_t base;
+ } u_std_dev;
+ u_std_dev.real = this->std_dev;
+ *(outbuffer + offset + 0) = (u_std_dev.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_std_dev.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_std_dev.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_std_dev.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->std_dev);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_sample;
+ u_sample.base = 0;
+ u_sample.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_sample.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_sample.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_sample.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->sample = u_sample.real;
+ offset += sizeof(this->sample);
+ union {
+ float real;
+ uint32_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ union {
+ float real;
+ uint32_t base;
+ } u_mean;
+ u_mean.base = 0;
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->mean = u_mean.real;
+ offset += sizeof(this->mean);
+ union {
+ float real;
+ uint32_t base;
+ } u_std_dev;
+ u_std_dev.base = 0;
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->std_dev = u_std_dev.real;
+ offset += sizeof(this->std_dev);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/AveragingFeedback"; };
+ const char * getMD5(){ return "9e8dfc53c2f2a032ca33fa80ec46fd4f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/AveragingGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_actionlib_tutorials_AveragingGoal_h
+#define _ROS_actionlib_tutorials_AveragingGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib_tutorials
+{
+
+ class AveragingGoal : public ros::Msg
+ {
+ public:
+ typedef int32_t _samples_type;
+ _samples_type samples;
+
+ AveragingGoal():
+ samples(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_samples;
+ u_samples.real = this->samples;
+ *(outbuffer + offset + 0) = (u_samples.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_samples.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_samples.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_samples.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->samples);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_samples;
+ u_samples.base = 0;
+ u_samples.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_samples.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_samples.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_samples.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->samples = u_samples.real;
+ offset += sizeof(this->samples);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/AveragingGoal"; };
+ const char * getMD5(){ return "32c9b10ef9b253faa93b93f564762c8f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/AveragingResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,86 @@
+#ifndef _ROS_actionlib_tutorials_AveragingResult_h
+#define _ROS_actionlib_tutorials_AveragingResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib_tutorials
+{
+
+ class AveragingResult : public ros::Msg
+ {
+ public:
+ typedef float _mean_type;
+ _mean_type mean;
+ typedef float _std_dev_type;
+ _std_dev_type std_dev;
+
+ AveragingResult():
+ mean(0),
+ std_dev(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_mean;
+ u_mean.real = this->mean;
+ *(outbuffer + offset + 0) = (u_mean.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_mean.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_mean.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_mean.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->mean);
+ union {
+ float real;
+ uint32_t base;
+ } u_std_dev;
+ u_std_dev.real = this->std_dev;
+ *(outbuffer + offset + 0) = (u_std_dev.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_std_dev.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_std_dev.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_std_dev.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->std_dev);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_mean;
+ u_mean.base = 0;
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_mean.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->mean = u_mean.real;
+ offset += sizeof(this->mean);
+ union {
+ float real;
+ uint32_t base;
+ } u_std_dev;
+ u_std_dev.base = 0;
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_std_dev.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->std_dev = u_std_dev.real;
+ offset += sizeof(this->std_dev);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/AveragingResult"; };
+ const char * getMD5(){ return "d5c7decf6df75ffb4367a05c1bcc7612"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/FibonacciAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_FibonacciAction_h
+#define _ROS_actionlib_tutorials_FibonacciAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "actionlib_tutorials/FibonacciActionGoal.h"
+#include "actionlib_tutorials/FibonacciActionResult.h"
+#include "actionlib_tutorials/FibonacciActionFeedback.h"
+
+namespace actionlib_tutorials
+{
+
+ class FibonacciAction : public ros::Msg
+ {
+ public:
+ typedef actionlib_tutorials::FibonacciActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef actionlib_tutorials::FibonacciActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef actionlib_tutorials::FibonacciActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ FibonacciAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/FibonacciAction"; };
+ const char * getMD5(){ return "f59df5767bf7634684781c92598b2406"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/FibonacciActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_FibonacciActionFeedback_h
+#define _ROS_actionlib_tutorials_FibonacciActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib_tutorials/FibonacciFeedback.h"
+
+namespace actionlib_tutorials
+{
+
+ class FibonacciActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib_tutorials::FibonacciFeedback _feedback_type;
+ _feedback_type feedback;
+
+ FibonacciActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/FibonacciActionFeedback"; };
+ const char * getMD5(){ return "73b8497a9f629a31c0020900e4148f07"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/FibonacciActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_FibonacciActionGoal_h
+#define _ROS_actionlib_tutorials_FibonacciActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "actionlib_tutorials/FibonacciGoal.h"
+
+namespace actionlib_tutorials
+{
+
+ class FibonacciActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef actionlib_tutorials::FibonacciGoal _goal_type;
+ _goal_type goal;
+
+ FibonacciActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/FibonacciActionGoal"; };
+ const char * getMD5(){ return "006871c7fa1d0e3d5fe2226bf17b2a94"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/FibonacciActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_actionlib_tutorials_FibonacciActionResult_h
+#define _ROS_actionlib_tutorials_FibonacciActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "actionlib_tutorials/FibonacciResult.h"
+
+namespace actionlib_tutorials
+{
+
+ class FibonacciActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef actionlib_tutorials::FibonacciResult _result_type;
+ _result_type result;
+
+ FibonacciActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/FibonacciActionResult"; };
+ const char * getMD5(){ return "bee73a9fe29ae25e966e105f5553dd03"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/FibonacciFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_actionlib_tutorials_FibonacciFeedback_h
+#define _ROS_actionlib_tutorials_FibonacciFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib_tutorials
+{
+
+ class FibonacciFeedback : public ros::Msg
+ {
+ public:
+ uint32_t sequence_length;
+ typedef int32_t _sequence_type;
+ _sequence_type st_sequence;
+ _sequence_type * sequence;
+
+ FibonacciFeedback():
+ sequence_length(0), sequence(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->sequence_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->sequence_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->sequence_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->sequence_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->sequence_length);
+ for( uint32_t i = 0; i < sequence_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_sequencei;
+ u_sequencei.real = this->sequence[i];
+ *(outbuffer + offset + 0) = (u_sequencei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sequencei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sequencei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sequencei.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->sequence[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t sequence_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->sequence_length);
+ if(sequence_lengthT > sequence_length)
+ this->sequence = (int32_t*)realloc(this->sequence, sequence_lengthT * sizeof(int32_t));
+ sequence_length = sequence_lengthT;
+ for( uint32_t i = 0; i < sequence_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_st_sequence;
+ u_st_sequence.base = 0;
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_sequence = u_st_sequence.real;
+ offset += sizeof(this->st_sequence);
+ memcpy( &(this->sequence[i]), &(this->st_sequence), sizeof(int32_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/FibonacciFeedback"; };
+ const char * getMD5(){ return "b81e37d2a31925a0e8ae261a8699cb79"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/FibonacciGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_actionlib_tutorials_FibonacciGoal_h
+#define _ROS_actionlib_tutorials_FibonacciGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib_tutorials
+{
+
+ class FibonacciGoal : public ros::Msg
+ {
+ public:
+ typedef int32_t _order_type;
+ _order_type order;
+
+ FibonacciGoal():
+ order(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_order;
+ u_order.real = this->order;
+ *(outbuffer + offset + 0) = (u_order.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_order.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_order.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_order.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->order);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_order;
+ u_order.base = 0;
+ u_order.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_order.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_order.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_order.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->order = u_order.real;
+ offset += sizeof(this->order);
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/FibonacciGoal"; };
+ const char * getMD5(){ return "6889063349a00b249bd1661df429d822"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/actionlib_tutorials/FibonacciResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_actionlib_tutorials_FibonacciResult_h
+#define _ROS_actionlib_tutorials_FibonacciResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace actionlib_tutorials
+{
+
+ class FibonacciResult : public ros::Msg
+ {
+ public:
+ uint32_t sequence_length;
+ typedef int32_t _sequence_type;
+ _sequence_type st_sequence;
+ _sequence_type * sequence;
+
+ FibonacciResult():
+ sequence_length(0), sequence(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->sequence_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->sequence_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->sequence_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->sequence_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->sequence_length);
+ for( uint32_t i = 0; i < sequence_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_sequencei;
+ u_sequencei.real = this->sequence[i];
+ *(outbuffer + offset + 0) = (u_sequencei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sequencei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sequencei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sequencei.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->sequence[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t sequence_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ sequence_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->sequence_length);
+ if(sequence_lengthT > sequence_length)
+ this->sequence = (int32_t*)realloc(this->sequence, sequence_lengthT * sizeof(int32_t));
+ sequence_length = sequence_lengthT;
+ for( uint32_t i = 0; i < sequence_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_st_sequence;
+ u_st_sequence.base = 0;
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_sequence.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_sequence = u_st_sequence.real;
+ offset += sizeof(this->st_sequence);
+ memcpy( &(this->sequence[i]), &(this->st_sequence), sizeof(int32_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "actionlib_tutorials/FibonacciResult"; };
+ const char * getMD5(){ return "b81e37d2a31925a0e8ae261a8699cb79"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/bond/Constants.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,44 @@
+#ifndef _ROS_bond_Constants_h
+#define _ROS_bond_Constants_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace bond
+{
+
+ class Constants : public ros::Msg
+ {
+ public:
+ enum { DEAD_PUBLISH_PERIOD = 0.05 };
+ enum { DEFAULT_CONNECT_TIMEOUT = 10.0 };
+ enum { DEFAULT_HEARTBEAT_TIMEOUT = 4.0 };
+ enum { DEFAULT_DISCONNECT_TIMEOUT = 2.0 };
+ enum { DEFAULT_HEARTBEAT_PERIOD = 1.0 };
+ enum { DISABLE_HEARTBEAT_TIMEOUT_PARAM = /bond_disable_heartbeat_timeout };
+
+ Constants()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "bond/Constants"; };
+ const char * getMD5(){ return "6fc594dc1d7bd7919077042712f8c8b0"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/bond/Status.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,144 @@
+#ifndef _ROS_bond_Status_h
+#define _ROS_bond_Status_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace bond
+{
+
+ class Status : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _id_type;
+ _id_type id;
+ typedef const char* _instance_id_type;
+ _instance_id_type instance_id;
+ typedef bool _active_type;
+ _active_type active;
+ typedef float _heartbeat_timeout_type;
+ _heartbeat_timeout_type heartbeat_timeout;
+ typedef float _heartbeat_period_type;
+ _heartbeat_period_type heartbeat_period;
+
+ Status():
+ header(),
+ id(""),
+ instance_id(""),
+ active(0),
+ heartbeat_timeout(0),
+ heartbeat_period(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_id = strlen(this->id);
+ varToArr(outbuffer + offset, length_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->id, length_id);
+ offset += length_id;
+ uint32_t length_instance_id = strlen(this->instance_id);
+ varToArr(outbuffer + offset, length_instance_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->instance_id, length_instance_id);
+ offset += length_instance_id;
+ union {
+ bool real;
+ uint8_t base;
+ } u_active;
+ u_active.real = this->active;
+ *(outbuffer + offset + 0) = (u_active.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->active);
+ union {
+ float real;
+ uint32_t base;
+ } u_heartbeat_timeout;
+ u_heartbeat_timeout.real = this->heartbeat_timeout;
+ *(outbuffer + offset + 0) = (u_heartbeat_timeout.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_heartbeat_timeout.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_heartbeat_timeout.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_heartbeat_timeout.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->heartbeat_timeout);
+ union {
+ float real;
+ uint32_t base;
+ } u_heartbeat_period;
+ u_heartbeat_period.real = this->heartbeat_period;
+ *(outbuffer + offset + 0) = (u_heartbeat_period.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_heartbeat_period.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_heartbeat_period.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_heartbeat_period.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->heartbeat_period);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_id;
+ arrToVar(length_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_id-1]=0;
+ this->id = (char *)(inbuffer + offset-1);
+ offset += length_id;
+ uint32_t length_instance_id;
+ arrToVar(length_instance_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_instance_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_instance_id-1]=0;
+ this->instance_id = (char *)(inbuffer + offset-1);
+ offset += length_instance_id;
+ union {
+ bool real;
+ uint8_t base;
+ } u_active;
+ u_active.base = 0;
+ u_active.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->active = u_active.real;
+ offset += sizeof(this->active);
+ union {
+ float real;
+ uint32_t base;
+ } u_heartbeat_timeout;
+ u_heartbeat_timeout.base = 0;
+ u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->heartbeat_timeout = u_heartbeat_timeout.real;
+ offset += sizeof(this->heartbeat_timeout);
+ union {
+ float real;
+ uint32_t base;
+ } u_heartbeat_period;
+ u_heartbeat_period.base = 0;
+ u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->heartbeat_period = u_heartbeat_period.real;
+ offset += sizeof(this->heartbeat_period);
+ return offset;
+ }
+
+ const char * getType(){ return "bond/Status"; };
+ const char * getMD5(){ return "eacc84bf5d65b6777d4c50f463dfb9c8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/FollowJointTrajectoryAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_FollowJointTrajectoryAction_h
+#define _ROS_control_msgs_FollowJointTrajectoryAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "control_msgs/FollowJointTrajectoryActionGoal.h"
+#include "control_msgs/FollowJointTrajectoryActionResult.h"
+#include "control_msgs/FollowJointTrajectoryActionFeedback.h"
+
+namespace control_msgs
+{
+
+ class FollowJointTrajectoryAction : public ros::Msg
+ {
+ public:
+ typedef control_msgs::FollowJointTrajectoryActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef control_msgs::FollowJointTrajectoryActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef control_msgs::FollowJointTrajectoryActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ FollowJointTrajectoryAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/FollowJointTrajectoryAction"; };
+ const char * getMD5(){ return "bc4f9b743838566551c0390c65f1a248"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/FollowJointTrajectoryActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_FollowJointTrajectoryActionFeedback_h
+#define _ROS_control_msgs_FollowJointTrajectoryActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/FollowJointTrajectoryFeedback.h"
+
+namespace control_msgs
+{
+
+ class FollowJointTrajectoryActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::FollowJointTrajectoryFeedback _feedback_type;
+ _feedback_type feedback;
+
+ FollowJointTrajectoryActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/FollowJointTrajectoryActionFeedback"; };
+ const char * getMD5(){ return "d8920dc4eae9fc107e00999cce4be641"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/FollowJointTrajectoryActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_FollowJointTrajectoryActionGoal_h
+#define _ROS_control_msgs_FollowJointTrajectoryActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "control_msgs/FollowJointTrajectoryGoal.h"
+
+namespace control_msgs
+{
+
+ class FollowJointTrajectoryActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef control_msgs::FollowJointTrajectoryGoal _goal_type;
+ _goal_type goal;
+
+ FollowJointTrajectoryActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/FollowJointTrajectoryActionGoal"; };
+ const char * getMD5(){ return "cff5c1d533bf2f82dd0138d57f4304bb"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/FollowJointTrajectoryActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_FollowJointTrajectoryActionResult_h
+#define _ROS_control_msgs_FollowJointTrajectoryActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/FollowJointTrajectoryResult.h"
+
+namespace control_msgs
+{
+
+ class FollowJointTrajectoryActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::FollowJointTrajectoryResult _result_type;
+ _result_type result;
+
+ FollowJointTrajectoryActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/FollowJointTrajectoryActionResult"; };
+ const char * getMD5(){ return "c4fb3b000dc9da4fd99699380efcc5d9"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/FollowJointTrajectoryFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,97 @@
+#ifndef _ROS_control_msgs_FollowJointTrajectoryFeedback_h
+#define _ROS_control_msgs_FollowJointTrajectoryFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "trajectory_msgs/JointTrajectoryPoint.h"
+
+namespace control_msgs
+{
+
+ class FollowJointTrajectoryFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t joint_names_length;
+ typedef char* _joint_names_type;
+ _joint_names_type st_joint_names;
+ _joint_names_type * joint_names;
+ typedef trajectory_msgs::JointTrajectoryPoint _desired_type;
+ _desired_type desired;
+ typedef trajectory_msgs::JointTrajectoryPoint _actual_type;
+ _actual_type actual;
+ typedef trajectory_msgs::JointTrajectoryPoint _error_type;
+ _error_type error;
+
+ FollowJointTrajectoryFeedback():
+ header(),
+ joint_names_length(0), joint_names(NULL),
+ desired(),
+ actual(),
+ error()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->joint_names_length);
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_joint_namesi = strlen(this->joint_names[i]);
+ varToArr(outbuffer + offset, length_joint_namesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
+ offset += length_joint_namesi;
+ }
+ offset += this->desired.serialize(outbuffer + offset);
+ offset += this->actual.serialize(outbuffer + offset);
+ offset += this->error.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->joint_names_length);
+ if(joint_names_lengthT > joint_names_length)
+ this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
+ joint_names_length = joint_names_lengthT;
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_st_joint_names;
+ arrToVar(length_st_joint_names, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_joint_names-1]=0;
+ this->st_joint_names = (char *)(inbuffer + offset-1);
+ offset += length_st_joint_names;
+ memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
+ }
+ offset += this->desired.deserialize(inbuffer + offset);
+ offset += this->actual.deserialize(inbuffer + offset);
+ offset += this->error.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/FollowJointTrajectoryFeedback"; };
+ const char * getMD5(){ return "10817c60c2486ef6b33e97dcd87f4474"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/FollowJointTrajectoryGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,119 @@
+#ifndef _ROS_control_msgs_FollowJointTrajectoryGoal_h
+#define _ROS_control_msgs_FollowJointTrajectoryGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "trajectory_msgs/JointTrajectory.h"
+#include "control_msgs/JointTolerance.h"
+#include "ros/duration.h"
+
+namespace control_msgs
+{
+
+ class FollowJointTrajectoryGoal : public ros::Msg
+ {
+ public:
+ typedef trajectory_msgs::JointTrajectory _trajectory_type;
+ _trajectory_type trajectory;
+ uint32_t path_tolerance_length;
+ typedef control_msgs::JointTolerance _path_tolerance_type;
+ _path_tolerance_type st_path_tolerance;
+ _path_tolerance_type * path_tolerance;
+ uint32_t goal_tolerance_length;
+ typedef control_msgs::JointTolerance _goal_tolerance_type;
+ _goal_tolerance_type st_goal_tolerance;
+ _goal_tolerance_type * goal_tolerance;
+ typedef ros::Duration _goal_time_tolerance_type;
+ _goal_time_tolerance_type goal_time_tolerance;
+
+ FollowJointTrajectoryGoal():
+ trajectory(),
+ path_tolerance_length(0), path_tolerance(NULL),
+ goal_tolerance_length(0), goal_tolerance(NULL),
+ goal_time_tolerance()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->trajectory.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->path_tolerance_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->path_tolerance_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->path_tolerance_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->path_tolerance_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->path_tolerance_length);
+ for( uint32_t i = 0; i < path_tolerance_length; i++){
+ offset += this->path_tolerance[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->goal_tolerance_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->goal_tolerance_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->goal_tolerance_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->goal_tolerance_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->goal_tolerance_length);
+ for( uint32_t i = 0; i < goal_tolerance_length; i++){
+ offset += this->goal_tolerance[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->goal_time_tolerance.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->goal_time_tolerance.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->goal_time_tolerance.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->goal_time_tolerance.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->goal_time_tolerance.sec);
+ *(outbuffer + offset + 0) = (this->goal_time_tolerance.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->goal_time_tolerance.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->goal_time_tolerance.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->goal_time_tolerance.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->goal_time_tolerance.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->trajectory.deserialize(inbuffer + offset);
+ uint32_t path_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->path_tolerance_length);
+ if(path_tolerance_lengthT > path_tolerance_length)
+ this->path_tolerance = (control_msgs::JointTolerance*)realloc(this->path_tolerance, path_tolerance_lengthT * sizeof(control_msgs::JointTolerance));
+ path_tolerance_length = path_tolerance_lengthT;
+ for( uint32_t i = 0; i < path_tolerance_length; i++){
+ offset += this->st_path_tolerance.deserialize(inbuffer + offset);
+ memcpy( &(this->path_tolerance[i]), &(this->st_path_tolerance), sizeof(control_msgs::JointTolerance));
+ }
+ uint32_t goal_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->goal_tolerance_length);
+ if(goal_tolerance_lengthT > goal_tolerance_length)
+ this->goal_tolerance = (control_msgs::JointTolerance*)realloc(this->goal_tolerance, goal_tolerance_lengthT * sizeof(control_msgs::JointTolerance));
+ goal_tolerance_length = goal_tolerance_lengthT;
+ for( uint32_t i = 0; i < goal_tolerance_length; i++){
+ offset += this->st_goal_tolerance.deserialize(inbuffer + offset);
+ memcpy( &(this->goal_tolerance[i]), &(this->st_goal_tolerance), sizeof(control_msgs::JointTolerance));
+ }
+ this->goal_time_tolerance.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->goal_time_tolerance.sec);
+ this->goal_time_tolerance.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->goal_time_tolerance.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/FollowJointTrajectoryGoal"; };
+ const char * getMD5(){ return "69636787b6ecbde4d61d711979bc7ecb"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/FollowJointTrajectoryResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,85 @@
+#ifndef _ROS_control_msgs_FollowJointTrajectoryResult_h
+#define _ROS_control_msgs_FollowJointTrajectoryResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class FollowJointTrajectoryResult : public ros::Msg
+ {
+ public:
+ typedef int32_t _error_code_type;
+ _error_code_type error_code;
+ typedef const char* _error_string_type;
+ _error_string_type error_string;
+ enum { SUCCESSFUL = 0 };
+ enum { INVALID_GOAL = -1 };
+ enum { INVALID_JOINTS = -2 };
+ enum { OLD_HEADER_TIMESTAMP = -3 };
+ enum { PATH_TOLERANCE_VIOLATED = -4 };
+ enum { GOAL_TOLERANCE_VIOLATED = -5 };
+
+ FollowJointTrajectoryResult():
+ error_code(0),
+ error_string("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_error_code;
+ u_error_code.real = this->error_code;
+ *(outbuffer + offset + 0) = (u_error_code.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_error_code.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_error_code.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_error_code.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->error_code);
+ uint32_t length_error_string = strlen(this->error_string);
+ varToArr(outbuffer + offset, length_error_string);
+ offset += 4;
+ memcpy(outbuffer + offset, this->error_string, length_error_string);
+ offset += length_error_string;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_error_code;
+ u_error_code.base = 0;
+ u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->error_code = u_error_code.real;
+ offset += sizeof(this->error_code);
+ uint32_t length_error_string;
+ arrToVar(length_error_string, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_error_string; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_error_string-1]=0;
+ this->error_string = (char *)(inbuffer + offset-1);
+ offset += length_error_string;
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/FollowJointTrajectoryResult"; };
+ const char * getMD5(){ return "493383b18409bfb604b4e26c676401d2"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommand.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,102 @@
+#ifndef _ROS_control_msgs_GripperCommand_h
+#define _ROS_control_msgs_GripperCommand_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class GripperCommand : public ros::Msg
+ {
+ public:
+ typedef double _position_type;
+ _position_type position;
+ typedef double _max_effort_type;
+ _max_effort_type max_effort;
+
+ GripperCommand():
+ position(0),
+ max_effort(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.real = this->position;
+ *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_effort;
+ u_max_effort.real = this->max_effort;
+ *(outbuffer + offset + 0) = (u_max_effort.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_max_effort.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_max_effort.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_max_effort.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_max_effort.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_max_effort.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_max_effort.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_max_effort.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->max_effort);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.base = 0;
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->position = u_position.real;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_effort;
+ u_max_effort.base = 0;
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->max_effort = u_max_effort.real;
+ offset += sizeof(this->max_effort);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommand"; };
+ const char * getMD5(){ return "680acaff79486f017132a7f198d40f08"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommandAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_GripperCommandAction_h
+#define _ROS_control_msgs_GripperCommandAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "control_msgs/GripperCommandActionGoal.h"
+#include "control_msgs/GripperCommandActionResult.h"
+#include "control_msgs/GripperCommandActionFeedback.h"
+
+namespace control_msgs
+{
+
+ class GripperCommandAction : public ros::Msg
+ {
+ public:
+ typedef control_msgs::GripperCommandActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef control_msgs::GripperCommandActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef control_msgs::GripperCommandActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ GripperCommandAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommandAction"; };
+ const char * getMD5(){ return "950b2a6ebe831f5d4f4ceaba3d8be01e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommandActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_GripperCommandActionFeedback_h
+#define _ROS_control_msgs_GripperCommandActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/GripperCommandFeedback.h"
+
+namespace control_msgs
+{
+
+ class GripperCommandActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::GripperCommandFeedback _feedback_type;
+ _feedback_type feedback;
+
+ GripperCommandActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommandActionFeedback"; };
+ const char * getMD5(){ return "653dff30c045f5e6ff3feb3409f4558d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommandActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_GripperCommandActionGoal_h
+#define _ROS_control_msgs_GripperCommandActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "control_msgs/GripperCommandGoal.h"
+
+namespace control_msgs
+{
+
+ class GripperCommandActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef control_msgs::GripperCommandGoal _goal_type;
+ _goal_type goal;
+
+ GripperCommandActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommandActionGoal"; };
+ const char * getMD5(){ return "aa581f648a35ed681db2ec0bf7a82bea"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommandActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_GripperCommandActionResult_h
+#define _ROS_control_msgs_GripperCommandActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/GripperCommandResult.h"
+
+namespace control_msgs
+{
+
+ class GripperCommandActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::GripperCommandResult _result_type;
+ _result_type result;
+
+ GripperCommandActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommandActionResult"; };
+ const char * getMD5(){ return "143702cb2df0f163c5283cedc5efc6b6"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommandFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,138 @@
+#ifndef _ROS_control_msgs_GripperCommandFeedback_h
+#define _ROS_control_msgs_GripperCommandFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class GripperCommandFeedback : public ros::Msg
+ {
+ public:
+ typedef double _position_type;
+ _position_type position;
+ typedef double _effort_type;
+ _effort_type effort;
+ typedef bool _stalled_type;
+ _stalled_type stalled;
+ typedef bool _reached_goal_type;
+ _reached_goal_type reached_goal;
+
+ GripperCommandFeedback():
+ position(0),
+ effort(0),
+ stalled(0),
+ reached_goal(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.real = this->position;
+ *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_effort;
+ u_effort.real = this->effort;
+ *(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->effort);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stalled;
+ u_stalled.real = this->stalled;
+ *(outbuffer + offset + 0) = (u_stalled.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->stalled);
+ union {
+ bool real;
+ uint8_t base;
+ } u_reached_goal;
+ u_reached_goal.real = this->reached_goal;
+ *(outbuffer + offset + 0) = (u_reached_goal.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->reached_goal);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.base = 0;
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->position = u_position.real;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_effort;
+ u_effort.base = 0;
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->effort = u_effort.real;
+ offset += sizeof(this->effort);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stalled;
+ u_stalled.base = 0;
+ u_stalled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->stalled = u_stalled.real;
+ offset += sizeof(this->stalled);
+ union {
+ bool real;
+ uint8_t base;
+ } u_reached_goal;
+ u_reached_goal.base = 0;
+ u_reached_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->reached_goal = u_reached_goal.real;
+ offset += sizeof(this->reached_goal);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommandFeedback"; };
+ const char * getMD5(){ return "e4cbff56d3562bcf113da5a5adeef91f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommandGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,44 @@
+#ifndef _ROS_control_msgs_GripperCommandGoal_h
+#define _ROS_control_msgs_GripperCommandGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "control_msgs/GripperCommand.h"
+
+namespace control_msgs
+{
+
+ class GripperCommandGoal : public ros::Msg
+ {
+ public:
+ typedef control_msgs::GripperCommand _command_type;
+ _command_type command;
+
+ GripperCommandGoal():
+ command()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->command.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->command.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommandGoal"; };
+ const char * getMD5(){ return "86fd82f4ddc48a4cb6856cfa69217e43"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/GripperCommandResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,138 @@
+#ifndef _ROS_control_msgs_GripperCommandResult_h
+#define _ROS_control_msgs_GripperCommandResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class GripperCommandResult : public ros::Msg
+ {
+ public:
+ typedef double _position_type;
+ _position_type position;
+ typedef double _effort_type;
+ _effort_type effort;
+ typedef bool _stalled_type;
+ _stalled_type stalled;
+ typedef bool _reached_goal_type;
+ _reached_goal_type reached_goal;
+
+ GripperCommandResult():
+ position(0),
+ effort(0),
+ stalled(0),
+ reached_goal(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.real = this->position;
+ *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_effort;
+ u_effort.real = this->effort;
+ *(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->effort);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stalled;
+ u_stalled.real = this->stalled;
+ *(outbuffer + offset + 0) = (u_stalled.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->stalled);
+ union {
+ bool real;
+ uint8_t base;
+ } u_reached_goal;
+ u_reached_goal.real = this->reached_goal;
+ *(outbuffer + offset + 0) = (u_reached_goal.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->reached_goal);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.base = 0;
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->position = u_position.real;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_effort;
+ u_effort.base = 0;
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->effort = u_effort.real;
+ offset += sizeof(this->effort);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stalled;
+ u_stalled.base = 0;
+ u_stalled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->stalled = u_stalled.real;
+ offset += sizeof(this->stalled);
+ union {
+ bool real;
+ uint8_t base;
+ } u_reached_goal;
+ u_reached_goal.base = 0;
+ u_reached_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->reached_goal = u_reached_goal.real;
+ offset += sizeof(this->reached_goal);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/GripperCommandResult"; };
+ const char * getMD5(){ return "e4cbff56d3562bcf113da5a5adeef91f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointControllerState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,382 @@
+#ifndef _ROS_control_msgs_JointControllerState_h
+#define _ROS_control_msgs_JointControllerState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace control_msgs
+{
+
+ class JointControllerState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _set_point_type;
+ _set_point_type set_point;
+ typedef double _process_value_type;
+ _process_value_type process_value;
+ typedef double _process_value_dot_type;
+ _process_value_dot_type process_value_dot;
+ typedef double _error_type;
+ _error_type error;
+ typedef double _time_step_type;
+ _time_step_type time_step;
+ typedef double _command_type;
+ _command_type command;
+ typedef double _p_type;
+ _p_type p;
+ typedef double _i_type;
+ _i_type i;
+ typedef double _d_type;
+ _d_type d;
+ typedef double _i_clamp_type;
+ _i_clamp_type i_clamp;
+ typedef bool _antiwindup_type;
+ _antiwindup_type antiwindup;
+
+ JointControllerState():
+ header(),
+ set_point(0),
+ process_value(0),
+ process_value_dot(0),
+ error(0),
+ time_step(0),
+ command(0),
+ p(0),
+ i(0),
+ d(0),
+ i_clamp(0),
+ antiwindup(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_set_point;
+ u_set_point.real = this->set_point;
+ *(outbuffer + offset + 0) = (u_set_point.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_set_point.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_set_point.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_set_point.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_set_point.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_set_point.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_set_point.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_set_point.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->set_point);
+ union {
+ double real;
+ uint64_t base;
+ } u_process_value;
+ u_process_value.real = this->process_value;
+ *(outbuffer + offset + 0) = (u_process_value.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_process_value.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_process_value.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_process_value.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_process_value.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_process_value.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_process_value.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_process_value.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->process_value);
+ union {
+ double real;
+ uint64_t base;
+ } u_process_value_dot;
+ u_process_value_dot.real = this->process_value_dot;
+ *(outbuffer + offset + 0) = (u_process_value_dot.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_process_value_dot.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_process_value_dot.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_process_value_dot.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_process_value_dot.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_process_value_dot.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_process_value_dot.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_process_value_dot.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->process_value_dot);
+ union {
+ double real;
+ uint64_t base;
+ } u_error;
+ u_error.real = this->error;
+ *(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->error);
+ union {
+ double real;
+ uint64_t base;
+ } u_time_step;
+ u_time_step.real = this->time_step;
+ *(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->time_step);
+ union {
+ double real;
+ uint64_t base;
+ } u_command;
+ u_command.real = this->command;
+ *(outbuffer + offset + 0) = (u_command.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_command.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_command.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_command.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_command.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_command.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_command.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_command.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->command);
+ union {
+ double real;
+ uint64_t base;
+ } u_p;
+ u_p.real = this->p;
+ *(outbuffer + offset + 0) = (u_p.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_p.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_p.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_p.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_p.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_p.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_p.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_p.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->p);
+ union {
+ double real;
+ uint64_t base;
+ } u_i;
+ u_i.real = this->i;
+ *(outbuffer + offset + 0) = (u_i.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_i.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_i.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_i.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_i.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_i.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_i.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_i.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->i);
+ union {
+ double real;
+ uint64_t base;
+ } u_d;
+ u_d.real = this->d;
+ *(outbuffer + offset + 0) = (u_d.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_d.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_d.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_d.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_d.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_d.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_d.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_d.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->d);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_clamp;
+ u_i_clamp.real = this->i_clamp;
+ *(outbuffer + offset + 0) = (u_i_clamp.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_i_clamp.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_i_clamp.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_i_clamp.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_i_clamp.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_i_clamp.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_i_clamp.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_i_clamp.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->i_clamp);
+ union {
+ bool real;
+ uint8_t base;
+ } u_antiwindup;
+ u_antiwindup.real = this->antiwindup;
+ *(outbuffer + offset + 0) = (u_antiwindup.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->antiwindup);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_set_point;
+ u_set_point.base = 0;
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->set_point = u_set_point.real;
+ offset += sizeof(this->set_point);
+ union {
+ double real;
+ uint64_t base;
+ } u_process_value;
+ u_process_value.base = 0;
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->process_value = u_process_value.real;
+ offset += sizeof(this->process_value);
+ union {
+ double real;
+ uint64_t base;
+ } u_process_value_dot;
+ u_process_value_dot.base = 0;
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->process_value_dot = u_process_value_dot.real;
+ offset += sizeof(this->process_value_dot);
+ union {
+ double real;
+ uint64_t base;
+ } u_error;
+ u_error.base = 0;
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->error = u_error.real;
+ offset += sizeof(this->error);
+ union {
+ double real;
+ uint64_t base;
+ } u_time_step;
+ u_time_step.base = 0;
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->time_step = u_time_step.real;
+ offset += sizeof(this->time_step);
+ union {
+ double real;
+ uint64_t base;
+ } u_command;
+ u_command.base = 0;
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->command = u_command.real;
+ offset += sizeof(this->command);
+ union {
+ double real;
+ uint64_t base;
+ } u_p;
+ u_p.base = 0;
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_p.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->p = u_p.real;
+ offset += sizeof(this->p);
+ union {
+ double real;
+ uint64_t base;
+ } u_i;
+ u_i.base = 0;
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_i.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->i = u_i.real;
+ offset += sizeof(this->i);
+ union {
+ double real;
+ uint64_t base;
+ } u_d;
+ u_d.base = 0;
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_d.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->d = u_d.real;
+ offset += sizeof(this->d);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_clamp;
+ u_i_clamp.base = 0;
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->i_clamp = u_i_clamp.real;
+ offset += sizeof(this->i_clamp);
+ union {
+ bool real;
+ uint8_t base;
+ } u_antiwindup;
+ u_antiwindup.base = 0;
+ u_antiwindup.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->antiwindup = u_antiwindup.real;
+ offset += sizeof(this->antiwindup);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointControllerState"; };
+ const char * getMD5(){ return "987ad85e4756f3aef7f1e5e7fe0595d1"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointJog.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,217 @@
+#ifndef _ROS_control_msgs_JointJog_h
+#define _ROS_control_msgs_JointJog_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace control_msgs
+{
+
+ class JointJog : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t joint_names_length;
+ typedef char* _joint_names_type;
+ _joint_names_type st_joint_names;
+ _joint_names_type * joint_names;
+ uint32_t displacements_length;
+ typedef double _displacements_type;
+ _displacements_type st_displacements;
+ _displacements_type * displacements;
+ uint32_t velocities_length;
+ typedef double _velocities_type;
+ _velocities_type st_velocities;
+ _velocities_type * velocities;
+ typedef double _duration_type;
+ _duration_type duration;
+
+ JointJog():
+ header(),
+ joint_names_length(0), joint_names(NULL),
+ displacements_length(0), displacements(NULL),
+ velocities_length(0), velocities(NULL),
+ duration(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->joint_names_length);
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_joint_namesi = strlen(this->joint_names[i]);
+ varToArr(outbuffer + offset, length_joint_namesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
+ offset += length_joint_namesi;
+ }
+ *(outbuffer + offset + 0) = (this->displacements_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->displacements_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->displacements_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->displacements_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->displacements_length);
+ for( uint32_t i = 0; i < displacements_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_displacementsi;
+ u_displacementsi.real = this->displacements[i];
+ *(outbuffer + offset + 0) = (u_displacementsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_displacementsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_displacementsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_displacementsi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_displacementsi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_displacementsi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_displacementsi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_displacementsi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->displacements[i]);
+ }
+ *(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->velocities_length);
+ for( uint32_t i = 0; i < velocities_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_velocitiesi;
+ u_velocitiesi.real = this->velocities[i];
+ *(outbuffer + offset + 0) = (u_velocitiesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_velocitiesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_velocitiesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_velocitiesi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_velocitiesi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_velocitiesi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_velocitiesi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_velocitiesi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->velocities[i]);
+ }
+ union {
+ double real;
+ uint64_t base;
+ } u_duration;
+ u_duration.real = this->duration;
+ *(outbuffer + offset + 0) = (u_duration.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_duration.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_duration.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_duration.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_duration.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_duration.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_duration.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_duration.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->duration);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->joint_names_length);
+ if(joint_names_lengthT > joint_names_length)
+ this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
+ joint_names_length = joint_names_lengthT;
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_st_joint_names;
+ arrToVar(length_st_joint_names, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_joint_names-1]=0;
+ this->st_joint_names = (char *)(inbuffer + offset-1);
+ offset += length_st_joint_names;
+ memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
+ }
+ uint32_t displacements_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->displacements_length);
+ if(displacements_lengthT > displacements_length)
+ this->displacements = (double*)realloc(this->displacements, displacements_lengthT * sizeof(double));
+ displacements_length = displacements_lengthT;
+ for( uint32_t i = 0; i < displacements_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_displacements;
+ u_st_displacements.base = 0;
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_displacements = u_st_displacements.real;
+ offset += sizeof(this->st_displacements);
+ memcpy( &(this->displacements[i]), &(this->st_displacements), sizeof(double));
+ }
+ uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->velocities_length);
+ if(velocities_lengthT > velocities_length)
+ this->velocities = (double*)realloc(this->velocities, velocities_lengthT * sizeof(double));
+ velocities_length = velocities_lengthT;
+ for( uint32_t i = 0; i < velocities_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_velocities;
+ u_st_velocities.base = 0;
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_velocities = u_st_velocities.real;
+ offset += sizeof(this->st_velocities);
+ memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(double));
+ }
+ union {
+ double real;
+ uint64_t base;
+ } u_duration;
+ u_duration.base = 0;
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_duration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->duration = u_duration.real;
+ offset += sizeof(this->duration);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointJog"; };
+ const char * getMD5(){ return "1685da700c8c2e1254afc92a5fb89c96"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTolerance.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,151 @@
+#ifndef _ROS_control_msgs_JointTolerance_h
+#define _ROS_control_msgs_JointTolerance_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class JointTolerance : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef double _position_type;
+ _position_type position;
+ typedef double _velocity_type;
+ _velocity_type velocity;
+ typedef double _acceleration_type;
+ _acceleration_type acceleration;
+
+ JointTolerance():
+ name(""),
+ position(0),
+ velocity(0),
+ acceleration(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.real = this->position;
+ *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_velocity;
+ u_velocity.real = this->velocity;
+ *(outbuffer + offset + 0) = (u_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_velocity.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_velocity.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_velocity.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_velocity.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_velocity.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->velocity);
+ union {
+ double real;
+ uint64_t base;
+ } u_acceleration;
+ u_acceleration.real = this->acceleration;
+ *(outbuffer + offset + 0) = (u_acceleration.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_acceleration.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_acceleration.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_acceleration.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_acceleration.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_acceleration.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_acceleration.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_acceleration.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->acceleration);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.base = 0;
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->position = u_position.real;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_velocity;
+ u_velocity.base = 0;
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->velocity = u_velocity.real;
+ offset += sizeof(this->velocity);
+ union {
+ double real;
+ uint64_t base;
+ } u_acceleration;
+ u_acceleration.base = 0;
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->acceleration = u_acceleration.real;
+ offset += sizeof(this->acceleration);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTolerance"; };
+ const char * getMD5(){ return "f544fe9c16cf04547e135dd6063ff5be"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_JointTrajectoryAction_h
+#define _ROS_control_msgs_JointTrajectoryAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "control_msgs/JointTrajectoryActionGoal.h"
+#include "control_msgs/JointTrajectoryActionResult.h"
+#include "control_msgs/JointTrajectoryActionFeedback.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryAction : public ros::Msg
+ {
+ public:
+ typedef control_msgs::JointTrajectoryActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef control_msgs::JointTrajectoryActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef control_msgs::JointTrajectoryActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ JointTrajectoryAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryAction"; };
+ const char * getMD5(){ return "a04ba3ee8f6a2d0985a6aeaf23d9d7ad"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_JointTrajectoryActionFeedback_h
+#define _ROS_control_msgs_JointTrajectoryActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/JointTrajectoryFeedback.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::JointTrajectoryFeedback _feedback_type;
+ _feedback_type feedback;
+
+ JointTrajectoryActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryActionFeedback"; };
+ const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_JointTrajectoryActionGoal_h
+#define _ROS_control_msgs_JointTrajectoryActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "control_msgs/JointTrajectoryGoal.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef control_msgs::JointTrajectoryGoal _goal_type;
+ _goal_type goal;
+
+ JointTrajectoryActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryActionGoal"; };
+ const char * getMD5(){ return "a99e83ef6185f9fdd7693efe99623a86"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_JointTrajectoryActionResult_h
+#define _ROS_control_msgs_JointTrajectoryActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/JointTrajectoryResult.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::JointTrajectoryResult _result_type;
+ _result_type result;
+
+ JointTrajectoryActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryActionResult"; };
+ const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryControllerState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,97 @@
+#ifndef _ROS_control_msgs_JointTrajectoryControllerState_h
+#define _ROS_control_msgs_JointTrajectoryControllerState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "trajectory_msgs/JointTrajectoryPoint.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryControllerState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t joint_names_length;
+ typedef char* _joint_names_type;
+ _joint_names_type st_joint_names;
+ _joint_names_type * joint_names;
+ typedef trajectory_msgs::JointTrajectoryPoint _desired_type;
+ _desired_type desired;
+ typedef trajectory_msgs::JointTrajectoryPoint _actual_type;
+ _actual_type actual;
+ typedef trajectory_msgs::JointTrajectoryPoint _error_type;
+ _error_type error;
+
+ JointTrajectoryControllerState():
+ header(),
+ joint_names_length(0), joint_names(NULL),
+ desired(),
+ actual(),
+ error()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->joint_names_length);
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_joint_namesi = strlen(this->joint_names[i]);
+ varToArr(outbuffer + offset, length_joint_namesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
+ offset += length_joint_namesi;
+ }
+ offset += this->desired.serialize(outbuffer + offset);
+ offset += this->actual.serialize(outbuffer + offset);
+ offset += this->error.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->joint_names_length);
+ if(joint_names_lengthT > joint_names_length)
+ this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
+ joint_names_length = joint_names_lengthT;
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_st_joint_names;
+ arrToVar(length_st_joint_names, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_joint_names-1]=0;
+ this->st_joint_names = (char *)(inbuffer + offset-1);
+ offset += length_st_joint_names;
+ memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
+ }
+ offset += this->desired.deserialize(inbuffer + offset);
+ offset += this->actual.deserialize(inbuffer + offset);
+ offset += this->error.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryControllerState"; };
+ const char * getMD5(){ return "10817c60c2486ef6b33e97dcd87f4474"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_control_msgs_JointTrajectoryFeedback_h
+#define _ROS_control_msgs_JointTrajectoryFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryFeedback : public ros::Msg
+ {
+ public:
+
+ JointTrajectoryFeedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryFeedback"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,44 @@
+#ifndef _ROS_control_msgs_JointTrajectoryGoal_h
+#define _ROS_control_msgs_JointTrajectoryGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "trajectory_msgs/JointTrajectory.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryGoal : public ros::Msg
+ {
+ public:
+ typedef trajectory_msgs::JointTrajectory _trajectory_type;
+ _trajectory_type trajectory;
+
+ JointTrajectoryGoal():
+ trajectory()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->trajectory.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->trajectory.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryGoal"; };
+ const char * getMD5(){ return "2a0eff76c870e8595636c2a562ca298e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/JointTrajectoryResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_control_msgs_JointTrajectoryResult_h
+#define _ROS_control_msgs_JointTrajectoryResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class JointTrajectoryResult : public ros::Msg
+ {
+ public:
+
+ JointTrajectoryResult()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/JointTrajectoryResult"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PidState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,420 @@
+#ifndef _ROS_control_msgs_PidState_h
+#define _ROS_control_msgs_PidState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "ros/duration.h"
+
+namespace control_msgs
+{
+
+ class PidState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef ros::Duration _timestep_type;
+ _timestep_type timestep;
+ typedef double _error_type;
+ _error_type error;
+ typedef double _error_dot_type;
+ _error_dot_type error_dot;
+ typedef double _p_error_type;
+ _p_error_type p_error;
+ typedef double _i_error_type;
+ _i_error_type i_error;
+ typedef double _d_error_type;
+ _d_error_type d_error;
+ typedef double _p_term_type;
+ _p_term_type p_term;
+ typedef double _i_term_type;
+ _i_term_type i_term;
+ typedef double _d_term_type;
+ _d_term_type d_term;
+ typedef double _i_max_type;
+ _i_max_type i_max;
+ typedef double _i_min_type;
+ _i_min_type i_min;
+ typedef double _output_type;
+ _output_type output;
+
+ PidState():
+ header(),
+ timestep(),
+ error(0),
+ error_dot(0),
+ p_error(0),
+ i_error(0),
+ d_error(0),
+ p_term(0),
+ i_term(0),
+ d_term(0),
+ i_max(0),
+ i_min(0),
+ output(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->timestep.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->timestep.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->timestep.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->timestep.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->timestep.sec);
+ *(outbuffer + offset + 0) = (this->timestep.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->timestep.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->timestep.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->timestep.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->timestep.nsec);
+ union {
+ double real;
+ uint64_t base;
+ } u_error;
+ u_error.real = this->error;
+ *(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->error);
+ union {
+ double real;
+ uint64_t base;
+ } u_error_dot;
+ u_error_dot.real = this->error_dot;
+ *(outbuffer + offset + 0) = (u_error_dot.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_error_dot.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_error_dot.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_error_dot.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_error_dot.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_error_dot.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_error_dot.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_error_dot.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->error_dot);
+ union {
+ double real;
+ uint64_t base;
+ } u_p_error;
+ u_p_error.real = this->p_error;
+ *(outbuffer + offset + 0) = (u_p_error.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_p_error.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_p_error.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_p_error.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_p_error.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_p_error.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_p_error.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_p_error.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->p_error);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_error;
+ u_i_error.real = this->i_error;
+ *(outbuffer + offset + 0) = (u_i_error.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_i_error.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_i_error.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_i_error.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_i_error.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_i_error.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_i_error.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_i_error.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->i_error);
+ union {
+ double real;
+ uint64_t base;
+ } u_d_error;
+ u_d_error.real = this->d_error;
+ *(outbuffer + offset + 0) = (u_d_error.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_d_error.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_d_error.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_d_error.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_d_error.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_d_error.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_d_error.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_d_error.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->d_error);
+ union {
+ double real;
+ uint64_t base;
+ } u_p_term;
+ u_p_term.real = this->p_term;
+ *(outbuffer + offset + 0) = (u_p_term.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_p_term.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_p_term.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_p_term.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_p_term.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_p_term.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_p_term.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_p_term.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->p_term);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_term;
+ u_i_term.real = this->i_term;
+ *(outbuffer + offset + 0) = (u_i_term.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_i_term.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_i_term.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_i_term.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_i_term.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_i_term.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_i_term.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_i_term.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->i_term);
+ union {
+ double real;
+ uint64_t base;
+ } u_d_term;
+ u_d_term.real = this->d_term;
+ *(outbuffer + offset + 0) = (u_d_term.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_d_term.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_d_term.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_d_term.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_d_term.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_d_term.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_d_term.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_d_term.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->d_term);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_max;
+ u_i_max.real = this->i_max;
+ *(outbuffer + offset + 0) = (u_i_max.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_i_max.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_i_max.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_i_max.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_i_max.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_i_max.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_i_max.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_i_max.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->i_max);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_min;
+ u_i_min.real = this->i_min;
+ *(outbuffer + offset + 0) = (u_i_min.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_i_min.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_i_min.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_i_min.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_i_min.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_i_min.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_i_min.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_i_min.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->i_min);
+ union {
+ double real;
+ uint64_t base;
+ } u_output;
+ u_output.real = this->output;
+ *(outbuffer + offset + 0) = (u_output.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_output.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_output.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_output.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_output.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_output.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_output.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_output.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->output);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->timestep.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->timestep.sec);
+ this->timestep.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->timestep.nsec);
+ union {
+ double real;
+ uint64_t base;
+ } u_error;
+ u_error.base = 0;
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->error = u_error.real;
+ offset += sizeof(this->error);
+ union {
+ double real;
+ uint64_t base;
+ } u_error_dot;
+ u_error_dot.base = 0;
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->error_dot = u_error_dot.real;
+ offset += sizeof(this->error_dot);
+ union {
+ double real;
+ uint64_t base;
+ } u_p_error;
+ u_p_error.base = 0;
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->p_error = u_p_error.real;
+ offset += sizeof(this->p_error);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_error;
+ u_i_error.base = 0;
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->i_error = u_i_error.real;
+ offset += sizeof(this->i_error);
+ union {
+ double real;
+ uint64_t base;
+ } u_d_error;
+ u_d_error.base = 0;
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->d_error = u_d_error.real;
+ offset += sizeof(this->d_error);
+ union {
+ double real;
+ uint64_t base;
+ } u_p_term;
+ u_p_term.base = 0;
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->p_term = u_p_term.real;
+ offset += sizeof(this->p_term);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_term;
+ u_i_term.base = 0;
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->i_term = u_i_term.real;
+ offset += sizeof(this->i_term);
+ union {
+ double real;
+ uint64_t base;
+ } u_d_term;
+ u_d_term.base = 0;
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->d_term = u_d_term.real;
+ offset += sizeof(this->d_term);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_max;
+ u_i_max.base = 0;
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->i_max = u_i_max.real;
+ offset += sizeof(this->i_max);
+ union {
+ double real;
+ uint64_t base;
+ } u_i_min;
+ u_i_min.base = 0;
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->i_min = u_i_min.real;
+ offset += sizeof(this->i_min);
+ union {
+ double real;
+ uint64_t base;
+ } u_output;
+ u_output.base = 0;
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_output.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->output = u_output.real;
+ offset += sizeof(this->output);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PidState"; };
+ const char * getMD5(){ return "b138ec00e886c10e73f27e8712252ea6"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PointHeadAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_PointHeadAction_h
+#define _ROS_control_msgs_PointHeadAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "control_msgs/PointHeadActionGoal.h"
+#include "control_msgs/PointHeadActionResult.h"
+#include "control_msgs/PointHeadActionFeedback.h"
+
+namespace control_msgs
+{
+
+ class PointHeadAction : public ros::Msg
+ {
+ public:
+ typedef control_msgs::PointHeadActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef control_msgs::PointHeadActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef control_msgs::PointHeadActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ PointHeadAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PointHeadAction"; };
+ const char * getMD5(){ return "7252920f1243de1b741f14f214125371"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PointHeadActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_PointHeadActionFeedback_h
+#define _ROS_control_msgs_PointHeadActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/PointHeadFeedback.h"
+
+namespace control_msgs
+{
+
+ class PointHeadActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::PointHeadFeedback _feedback_type;
+ _feedback_type feedback;
+
+ PointHeadActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PointHeadActionFeedback"; };
+ const char * getMD5(){ return "33c9244957176bbba97dd641119e8460"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PointHeadActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_PointHeadActionGoal_h
+#define _ROS_control_msgs_PointHeadActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "control_msgs/PointHeadGoal.h"
+
+namespace control_msgs
+{
+
+ class PointHeadActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef control_msgs::PointHeadGoal _goal_type;
+ _goal_type goal;
+
+ PointHeadActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PointHeadActionGoal"; };
+ const char * getMD5(){ return "b53a8323d0ba7b310ba17a2d3a82a6b8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PointHeadActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_PointHeadActionResult_h
+#define _ROS_control_msgs_PointHeadActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/PointHeadResult.h"
+
+namespace control_msgs
+{
+
+ class PointHeadActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::PointHeadResult _result_type;
+ _result_type result;
+
+ PointHeadActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PointHeadActionResult"; };
+ const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PointHeadFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_control_msgs_PointHeadFeedback_h
+#define _ROS_control_msgs_PointHeadFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class PointHeadFeedback : public ros::Msg
+ {
+ public:
+ typedef double _pointing_angle_error_type;
+ _pointing_angle_error_type pointing_angle_error;
+
+ PointHeadFeedback():
+ pointing_angle_error(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_pointing_angle_error;
+ u_pointing_angle_error.real = this->pointing_angle_error;
+ *(outbuffer + offset + 0) = (u_pointing_angle_error.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_pointing_angle_error.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_pointing_angle_error.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_pointing_angle_error.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_pointing_angle_error.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_pointing_angle_error.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_pointing_angle_error.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_pointing_angle_error.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->pointing_angle_error);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_pointing_angle_error;
+ u_pointing_angle_error.base = 0;
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->pointing_angle_error = u_pointing_angle_error.real;
+ offset += sizeof(this->pointing_angle_error);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PointHeadFeedback"; };
+ const char * getMD5(){ return "cce80d27fd763682da8805a73316cab4"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PointHeadGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,123 @@
+#ifndef _ROS_control_msgs_PointHeadGoal_h
+#define _ROS_control_msgs_PointHeadGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/PointStamped.h"
+#include "geometry_msgs/Vector3.h"
+#include "ros/duration.h"
+
+namespace control_msgs
+{
+
+ class PointHeadGoal : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::PointStamped _target_type;
+ _target_type target;
+ typedef geometry_msgs::Vector3 _pointing_axis_type;
+ _pointing_axis_type pointing_axis;
+ typedef const char* _pointing_frame_type;
+ _pointing_frame_type pointing_frame;
+ typedef ros::Duration _min_duration_type;
+ _min_duration_type min_duration;
+ typedef double _max_velocity_type;
+ _max_velocity_type max_velocity;
+
+ PointHeadGoal():
+ target(),
+ pointing_axis(),
+ pointing_frame(""),
+ min_duration(),
+ max_velocity(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->target.serialize(outbuffer + offset);
+ offset += this->pointing_axis.serialize(outbuffer + offset);
+ uint32_t length_pointing_frame = strlen(this->pointing_frame);
+ varToArr(outbuffer + offset, length_pointing_frame);
+ offset += 4;
+ memcpy(outbuffer + offset, this->pointing_frame, length_pointing_frame);
+ offset += length_pointing_frame;
+ *(outbuffer + offset + 0) = (this->min_duration.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->min_duration.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->min_duration.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->min_duration.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->min_duration.sec);
+ *(outbuffer + offset + 0) = (this->min_duration.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->min_duration.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->min_duration.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->min_duration.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->min_duration.nsec);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_velocity;
+ u_max_velocity.real = this->max_velocity;
+ *(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->max_velocity);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->target.deserialize(inbuffer + offset);
+ offset += this->pointing_axis.deserialize(inbuffer + offset);
+ uint32_t length_pointing_frame;
+ arrToVar(length_pointing_frame, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_pointing_frame; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_pointing_frame-1]=0;
+ this->pointing_frame = (char *)(inbuffer + offset-1);
+ offset += length_pointing_frame;
+ this->min_duration.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->min_duration.sec);
+ this->min_duration.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->min_duration.nsec);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_velocity;
+ u_max_velocity.base = 0;
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->max_velocity = u_max_velocity.real;
+ offset += sizeof(this->max_velocity);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PointHeadGoal"; };
+ const char * getMD5(){ return "8b92b1cd5e06c8a94c917dc3209a4c1d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/PointHeadResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_control_msgs_PointHeadResult_h
+#define _ROS_control_msgs_PointHeadResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class PointHeadResult : public ros::Msg
+ {
+ public:
+
+ PointHeadResult()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/PointHeadResult"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/QueryCalibrationState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_SERVICE_QueryCalibrationState_h
+#define _ROS_SERVICE_QueryCalibrationState_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+static const char QUERYCALIBRATIONSTATE[] = "control_msgs/QueryCalibrationState";
+
+ class QueryCalibrationStateRequest : public ros::Msg
+ {
+ public:
+
+ QueryCalibrationStateRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return QUERYCALIBRATIONSTATE; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class QueryCalibrationStateResponse : public ros::Msg
+ {
+ public:
+ typedef bool _is_calibrated_type;
+ _is_calibrated_type is_calibrated;
+
+ QueryCalibrationStateResponse():
+ is_calibrated(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_calibrated;
+ u_is_calibrated.real = this->is_calibrated;
+ *(outbuffer + offset + 0) = (u_is_calibrated.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->is_calibrated);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_calibrated;
+ u_is_calibrated.base = 0;
+ u_is_calibrated.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->is_calibrated = u_is_calibrated.real;
+ offset += sizeof(this->is_calibrated);
+ return offset;
+ }
+
+ const char * getType(){ return QUERYCALIBRATIONSTATE; };
+ const char * getMD5(){ return "28af3beedcb84986b8e470dc5470507d"; };
+
+ };
+
+ class QueryCalibrationState {
+ public:
+ typedef QueryCalibrationStateRequest Request;
+ typedef QueryCalibrationStateResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/QueryTrajectoryState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,287 @@
+#ifndef _ROS_SERVICE_QueryTrajectoryState_h
+#define _ROS_SERVICE_QueryTrajectoryState_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+
+namespace control_msgs
+{
+
+static const char QUERYTRAJECTORYSTATE[] = "control_msgs/QueryTrajectoryState";
+
+ class QueryTrajectoryStateRequest : public ros::Msg
+ {
+ public:
+ typedef ros::Time _time_type;
+ _time_type time;
+
+ QueryTrajectoryStateRequest():
+ time()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time.sec);
+ *(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->time.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time.sec);
+ this->time.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return QUERYTRAJECTORYSTATE; };
+ const char * getMD5(){ return "556a4fb76023a469987922359d08a844"; };
+
+ };
+
+ class QueryTrajectoryStateResponse : public ros::Msg
+ {
+ public:
+ uint32_t name_length;
+ typedef char* _name_type;
+ _name_type st_name;
+ _name_type * name;
+ uint32_t position_length;
+ typedef double _position_type;
+ _position_type st_position;
+ _position_type * position;
+ uint32_t velocity_length;
+ typedef double _velocity_type;
+ _velocity_type st_velocity;
+ _velocity_type * velocity;
+ uint32_t acceleration_length;
+ typedef double _acceleration_type;
+ _acceleration_type st_acceleration;
+ _acceleration_type * acceleration;
+
+ QueryTrajectoryStateResponse():
+ name_length(0), name(NULL),
+ position_length(0), position(NULL),
+ velocity_length(0), velocity(NULL),
+ acceleration_length(0), acceleration(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->name_length);
+ for( uint32_t i = 0; i < name_length; i++){
+ uint32_t length_namei = strlen(this->name[i]);
+ varToArr(outbuffer + offset, length_namei);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name[i], length_namei);
+ offset += length_namei;
+ }
+ *(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->position_length);
+ for( uint32_t i = 0; i < position_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_positioni;
+ u_positioni.real = this->position[i];
+ *(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position[i]);
+ }
+ *(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->velocity_length);
+ for( uint32_t i = 0; i < velocity_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_velocityi;
+ u_velocityi.real = this->velocity[i];
+ *(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->velocity[i]);
+ }
+ *(outbuffer + offset + 0) = (this->acceleration_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->acceleration_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->acceleration_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->acceleration_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->acceleration_length);
+ for( uint32_t i = 0; i < acceleration_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_accelerationi;
+ u_accelerationi.real = this->acceleration[i];
+ *(outbuffer + offset + 0) = (u_accelerationi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_accelerationi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_accelerationi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_accelerationi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_accelerationi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_accelerationi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_accelerationi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_accelerationi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->acceleration[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->name_length);
+ if(name_lengthT > name_length)
+ this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
+ name_length = name_lengthT;
+ for( uint32_t i = 0; i < name_length; i++){
+ uint32_t length_st_name;
+ arrToVar(length_st_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_name-1]=0;
+ this->st_name = (char *)(inbuffer + offset-1);
+ offset += length_st_name;
+ memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
+ }
+ uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->position_length);
+ if(position_lengthT > position_length)
+ this->position = (double*)realloc(this->position, position_lengthT * sizeof(double));
+ position_length = position_lengthT;
+ for( uint32_t i = 0; i < position_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_position;
+ u_st_position.base = 0;
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_position = u_st_position.real;
+ offset += sizeof(this->st_position);
+ memcpy( &(this->position[i]), &(this->st_position), sizeof(double));
+ }
+ uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->velocity_length);
+ if(velocity_lengthT > velocity_length)
+ this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double));
+ velocity_length = velocity_lengthT;
+ for( uint32_t i = 0; i < velocity_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_velocity;
+ u_st_velocity.base = 0;
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_velocity = u_st_velocity.real;
+ offset += sizeof(this->st_velocity);
+ memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double));
+ }
+ uint32_t acceleration_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->acceleration_length);
+ if(acceleration_lengthT > acceleration_length)
+ this->acceleration = (double*)realloc(this->acceleration, acceleration_lengthT * sizeof(double));
+ acceleration_length = acceleration_lengthT;
+ for( uint32_t i = 0; i < acceleration_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_acceleration;
+ u_st_acceleration.base = 0;
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_acceleration = u_st_acceleration.real;
+ offset += sizeof(this->st_acceleration);
+ memcpy( &(this->acceleration[i]), &(this->st_acceleration), sizeof(double));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return QUERYTRAJECTORYSTATE; };
+ const char * getMD5(){ return "1f1a6554ad060f44d013e71868403c1a"; };
+
+ };
+
+ class QueryTrajectoryState {
+ public:
+ typedef QueryTrajectoryStateRequest Request;
+ typedef QueryTrajectoryStateResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/SingleJointPositionAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_SingleJointPositionAction_h
+#define _ROS_control_msgs_SingleJointPositionAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "control_msgs/SingleJointPositionActionGoal.h"
+#include "control_msgs/SingleJointPositionActionResult.h"
+#include "control_msgs/SingleJointPositionActionFeedback.h"
+
+namespace control_msgs
+{
+
+ class SingleJointPositionAction : public ros::Msg
+ {
+ public:
+ typedef control_msgs::SingleJointPositionActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef control_msgs::SingleJointPositionActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef control_msgs::SingleJointPositionActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ SingleJointPositionAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/SingleJointPositionAction"; };
+ const char * getMD5(){ return "c4a786b7d53e5d0983decf967a5a779e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/SingleJointPositionActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_SingleJointPositionActionFeedback_h
+#define _ROS_control_msgs_SingleJointPositionActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/SingleJointPositionFeedback.h"
+
+namespace control_msgs
+{
+
+ class SingleJointPositionActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::SingleJointPositionFeedback _feedback_type;
+ _feedback_type feedback;
+
+ SingleJointPositionActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/SingleJointPositionActionFeedback"; };
+ const char * getMD5(){ return "3503b7cf8972f90d245850a5d8796cfa"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/SingleJointPositionActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_SingleJointPositionActionGoal_h
+#define _ROS_control_msgs_SingleJointPositionActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "control_msgs/SingleJointPositionGoal.h"
+
+namespace control_msgs
+{
+
+ class SingleJointPositionActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef control_msgs::SingleJointPositionGoal _goal_type;
+ _goal_type goal;
+
+ SingleJointPositionActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/SingleJointPositionActionGoal"; };
+ const char * getMD5(){ return "4b0d3d091471663e17749c1d0db90f61"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/SingleJointPositionActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_control_msgs_SingleJointPositionActionResult_h
+#define _ROS_control_msgs_SingleJointPositionActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "control_msgs/SingleJointPositionResult.h"
+
+namespace control_msgs
+{
+
+ class SingleJointPositionActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef control_msgs::SingleJointPositionResult _result_type;
+ _result_type result;
+
+ SingleJointPositionActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/SingleJointPositionActionResult"; };
+ const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/SingleJointPositionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,140 @@
+#ifndef _ROS_control_msgs_SingleJointPositionFeedback_h
+#define _ROS_control_msgs_SingleJointPositionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace control_msgs
+{
+
+ class SingleJointPositionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _position_type;
+ _position_type position;
+ typedef double _velocity_type;
+ _velocity_type velocity;
+ typedef double _error_type;
+ _error_type error;
+
+ SingleJointPositionFeedback():
+ header(),
+ position(0),
+ velocity(0),
+ error(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.real = this->position;
+ *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_velocity;
+ u_velocity.real = this->velocity;
+ *(outbuffer + offset + 0) = (u_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_velocity.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_velocity.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_velocity.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_velocity.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_velocity.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->velocity);
+ union {
+ double real;
+ uint64_t base;
+ } u_error;
+ u_error.real = this->error;
+ *(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->error);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.base = 0;
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->position = u_position.real;
+ offset += sizeof(this->position);
+ union {
+ double real;
+ uint64_t base;
+ } u_velocity;
+ u_velocity.base = 0;
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->velocity = u_velocity.real;
+ offset += sizeof(this->velocity);
+ union {
+ double real;
+ uint64_t base;
+ } u_error;
+ u_error.base = 0;
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->error = u_error.real;
+ offset += sizeof(this->error);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/SingleJointPositionFeedback"; };
+ const char * getMD5(){ return "8cee65610a3d08e0a1bded82f146f1fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/SingleJointPositionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,126 @@
+#ifndef _ROS_control_msgs_SingleJointPositionGoal_h
+#define _ROS_control_msgs_SingleJointPositionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/duration.h"
+
+namespace control_msgs
+{
+
+ class SingleJointPositionGoal : public ros::Msg
+ {
+ public:
+ typedef double _position_type;
+ _position_type position;
+ typedef ros::Duration _min_duration_type;
+ _min_duration_type min_duration;
+ typedef double _max_velocity_type;
+ _max_velocity_type max_velocity;
+
+ SingleJointPositionGoal():
+ position(0),
+ min_duration(),
+ max_velocity(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.real = this->position;
+ *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position);
+ *(outbuffer + offset + 0) = (this->min_duration.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->min_duration.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->min_duration.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->min_duration.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->min_duration.sec);
+ *(outbuffer + offset + 0) = (this->min_duration.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->min_duration.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->min_duration.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->min_duration.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->min_duration.nsec);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_velocity;
+ u_max_velocity.real = this->max_velocity;
+ *(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->max_velocity);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_position;
+ u_position.base = 0;
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->position = u_position.real;
+ offset += sizeof(this->position);
+ this->min_duration.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->min_duration.sec);
+ this->min_duration.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->min_duration.nsec);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_velocity;
+ u_max_velocity.base = 0;
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->max_velocity = u_max_velocity.real;
+ offset += sizeof(this->max_velocity);
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/SingleJointPositionGoal"; };
+ const char * getMD5(){ return "fbaaa562a23a013fd5053e5f72cbb35c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/control_msgs/SingleJointPositionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_control_msgs_SingleJointPositionResult_h
+#define _ROS_control_msgs_SingleJointPositionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace control_msgs
+{
+
+ class SingleJointPositionResult : public ros::Msg
+ {
+ public:
+
+ SingleJointPositionResult()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "control_msgs/SingleJointPositionResult"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/diagnostic_msgs/AddDiagnostics.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,122 @@
+#ifndef _ROS_SERVICE_AddDiagnostics_h
+#define _ROS_SERVICE_AddDiagnostics_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace diagnostic_msgs
+{
+
+static const char ADDDIAGNOSTICS[] = "diagnostic_msgs/AddDiagnostics";
+
+ class AddDiagnosticsRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _load_namespace_type;
+ _load_namespace_type load_namespace;
+
+ AddDiagnosticsRequest():
+ load_namespace("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_load_namespace = strlen(this->load_namespace);
+ varToArr(outbuffer + offset, length_load_namespace);
+ offset += 4;
+ memcpy(outbuffer + offset, this->load_namespace, length_load_namespace);
+ offset += length_load_namespace;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_load_namespace;
+ arrToVar(length_load_namespace, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_load_namespace; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_load_namespace-1]=0;
+ this->load_namespace = (char *)(inbuffer + offset-1);
+ offset += length_load_namespace;
+ return offset;
+ }
+
+ const char * getType(){ return ADDDIAGNOSTICS; };
+ const char * getMD5(){ return "c26cf6e164288fbc6050d74f838bcdf0"; };
+
+ };
+
+ class AddDiagnosticsResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _message_type;
+ _message_type message;
+
+ AddDiagnosticsResponse():
+ success(0),
+ message("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_message = strlen(this->message);
+ varToArr(outbuffer + offset, length_message);
+ offset += 4;
+ memcpy(outbuffer + offset, this->message, length_message);
+ offset += length_message;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_message;
+ arrToVar(length_message, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_message; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_message-1]=0;
+ this->message = (char *)(inbuffer + offset-1);
+ offset += length_message;
+ return offset;
+ }
+
+ const char * getType(){ return ADDDIAGNOSTICS; };
+ const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
+
+ };
+
+ class AddDiagnostics {
+ public:
+ typedef AddDiagnosticsRequest Request;
+ typedef AddDiagnosticsResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/diagnostic_msgs/DiagnosticArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_diagnostic_msgs_DiagnosticArray_h
+#define _ROS_diagnostic_msgs_DiagnosticArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "diagnostic_msgs/DiagnosticStatus.h"
+
+namespace diagnostic_msgs
+{
+
+ class DiagnosticArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t status_length;
+ typedef diagnostic_msgs::DiagnosticStatus _status_type;
+ _status_type st_status;
+ _status_type * status;
+
+ DiagnosticArray():
+ header(),
+ status_length(0), status(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->status_length);
+ for( uint32_t i = 0; i < status_length; i++){
+ offset += this->status[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->status_length);
+ if(status_lengthT > status_length)
+ this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
+ status_length = status_lengthT;
+ for( uint32_t i = 0; i < status_length; i++){
+ offset += this->st_status.deserialize(inbuffer + offset);
+ memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "diagnostic_msgs/DiagnosticArray"; };
+ const char * getMD5(){ return "60810da900de1dd6ddd437c3503511da"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/diagnostic_msgs/DiagnosticStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,137 @@
+#ifndef _ROS_diagnostic_msgs_DiagnosticStatus_h
+#define _ROS_diagnostic_msgs_DiagnosticStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "diagnostic_msgs/KeyValue.h"
+
+namespace diagnostic_msgs
+{
+
+ class DiagnosticStatus : public ros::Msg
+ {
+ public:
+ typedef int8_t _level_type;
+ _level_type level;
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _message_type;
+ _message_type message;
+ typedef const char* _hardware_id_type;
+ _hardware_id_type hardware_id;
+ uint32_t values_length;
+ typedef diagnostic_msgs::KeyValue _values_type;
+ _values_type st_values;
+ _values_type * values;
+ enum { OK = 0 };
+ enum { WARN = 1 };
+ enum { ERROR = 2 };
+ enum { STALE = 3 };
+
+ DiagnosticStatus():
+ level(0),
+ name(""),
+ message(""),
+ hardware_id(""),
+ values_length(0), values(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_level;
+ u_level.real = this->level;
+ *(outbuffer + offset + 0) = (u_level.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->level);
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_message = strlen(this->message);
+ varToArr(outbuffer + offset, length_message);
+ offset += 4;
+ memcpy(outbuffer + offset, this->message, length_message);
+ offset += length_message;
+ uint32_t length_hardware_id = strlen(this->hardware_id);
+ varToArr(outbuffer + offset, length_hardware_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->hardware_id, length_hardware_id);
+ offset += length_hardware_id;
+ *(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->values_length);
+ for( uint32_t i = 0; i < values_length; i++){
+ offset += this->values[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_level;
+ u_level.base = 0;
+ u_level.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->level = u_level.real;
+ offset += sizeof(this->level);
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_message;
+ arrToVar(length_message, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_message; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_message-1]=0;
+ this->message = (char *)(inbuffer + offset-1);
+ offset += length_message;
+ uint32_t length_hardware_id;
+ arrToVar(length_hardware_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_hardware_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_hardware_id-1]=0;
+ this->hardware_id = (char *)(inbuffer + offset-1);
+ offset += length_hardware_id;
+ uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->values_length);
+ if(values_lengthT > values_length)
+ this->values = (diagnostic_msgs::KeyValue*)realloc(this->values, values_lengthT * sizeof(diagnostic_msgs::KeyValue));
+ values_length = values_lengthT;
+ for( uint32_t i = 0; i < values_length; i++){
+ offset += this->st_values.deserialize(inbuffer + offset);
+ memcpy( &(this->values[i]), &(this->st_values), sizeof(diagnostic_msgs::KeyValue));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "diagnostic_msgs/DiagnosticStatus"; };
+ const char * getMD5(){ return "d0ce08bc6e5ba34c7754f563a9cabaf1"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/diagnostic_msgs/KeyValue.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,72 @@
+#ifndef _ROS_diagnostic_msgs_KeyValue_h
+#define _ROS_diagnostic_msgs_KeyValue_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace diagnostic_msgs
+{
+
+ class KeyValue : public ros::Msg
+ {
+ public:
+ typedef const char* _key_type;
+ _key_type key;
+ typedef const char* _value_type;
+ _value_type value;
+
+ KeyValue():
+ key(""),
+ value("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_key = strlen(this->key);
+ varToArr(outbuffer + offset, length_key);
+ offset += 4;
+ memcpy(outbuffer + offset, this->key, length_key);
+ offset += length_key;
+ uint32_t length_value = strlen(this->value);
+ varToArr(outbuffer + offset, length_value);
+ offset += 4;
+ memcpy(outbuffer + offset, this->value, length_value);
+ offset += length_value;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_key;
+ arrToVar(length_key, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_key; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_key-1]=0;
+ this->key = (char *)(inbuffer + offset-1);
+ offset += length_key;
+ uint32_t length_value;
+ arrToVar(length_value, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_value; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_value-1]=0;
+ this->value = (char *)(inbuffer + offset-1);
+ offset += length_value;
+ return offset;
+ }
+
+ const char * getType(){ return "diagnostic_msgs/KeyValue"; };
+ const char * getMD5(){ return "cf57fdc6617a881a88c16e768132149c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/diagnostic_msgs/SelfTest.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,131 @@
+#ifndef _ROS_SERVICE_SelfTest_h
+#define _ROS_SERVICE_SelfTest_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "diagnostic_msgs/DiagnosticStatus.h"
+
+namespace diagnostic_msgs
+{
+
+static const char SELFTEST[] = "diagnostic_msgs/SelfTest";
+
+ class SelfTestRequest : public ros::Msg
+ {
+ public:
+
+ SelfTestRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return SELFTEST; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class SelfTestResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _id_type;
+ _id_type id;
+ typedef int8_t _passed_type;
+ _passed_type passed;
+ uint32_t status_length;
+ typedef diagnostic_msgs::DiagnosticStatus _status_type;
+ _status_type st_status;
+ _status_type * status;
+
+ SelfTestResponse():
+ id(""),
+ passed(0),
+ status_length(0), status(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_id = strlen(this->id);
+ varToArr(outbuffer + offset, length_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->id, length_id);
+ offset += length_id;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_passed;
+ u_passed.real = this->passed;
+ *(outbuffer + offset + 0) = (u_passed.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->passed);
+ *(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->status_length);
+ for( uint32_t i = 0; i < status_length; i++){
+ offset += this->status[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_id;
+ arrToVar(length_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_id-1]=0;
+ this->id = (char *)(inbuffer + offset-1);
+ offset += length_id;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_passed;
+ u_passed.base = 0;
+ u_passed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->passed = u_passed.real;
+ offset += sizeof(this->passed);
+ uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->status_length);
+ if(status_lengthT > status_length)
+ this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
+ status_length = status_lengthT;
+ for( uint32_t i = 0; i < status_length; i++){
+ offset += this->st_status.deserialize(inbuffer + offset);
+ memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return SELFTEST; };
+ const char * getMD5(){ return "ac21b1bab7ab17546986536c22eb34e9"; };
+
+ };
+
+ class SelfTest {
+ public:
+ typedef SelfTestRequest Request;
+ typedef SelfTestResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dombabot_hardware_interface/HardwareCommand.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,65 @@
+#ifndef _ROS_dombabot_hardware_interface_HardwareCommand_h
+#define _ROS_dombabot_hardware_interface_HardwareCommand_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "dombabot_hardware_interface/LegJointCommand.h"
+
+namespace dombabot_hardware_interface
+{
+
+ class HardwareCommand : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef dombabot_hardware_interface::LegJointCommand _front_left_leg_type;
+ _front_left_leg_type front_left_leg;
+ typedef dombabot_hardware_interface::LegJointCommand _back_left_leg_type;
+ _back_left_leg_type back_left_leg;
+ typedef dombabot_hardware_interface::LegJointCommand _front_right_leg_type;
+ _front_right_leg_type front_right_leg;
+ typedef dombabot_hardware_interface::LegJointCommand _back_right_leg_type;
+ _back_right_leg_type back_right_leg;
+
+ HardwareCommand():
+ header(),
+ front_left_leg(),
+ back_left_leg(),
+ front_right_leg(),
+ back_right_leg()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->front_left_leg.serialize(outbuffer + offset);
+ offset += this->back_left_leg.serialize(outbuffer + offset);
+ offset += this->front_right_leg.serialize(outbuffer + offset);
+ offset += this->back_right_leg.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->front_left_leg.deserialize(inbuffer + offset);
+ offset += this->back_left_leg.deserialize(inbuffer + offset);
+ offset += this->front_right_leg.deserialize(inbuffer + offset);
+ offset += this->back_right_leg.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "dombabot_hardware_interface/HardwareCommand"; };
+ const char * getMD5(){ return "cbc6a08cbd91491a5cc8f16291f5ccda"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dombabot_hardware_interface/HardwareState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,65 @@
+#ifndef _ROS_dombabot_hardware_interface_HardwareState_h
+#define _ROS_dombabot_hardware_interface_HardwareState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "dombabot_hardware_interface/LegJointState.h"
+
+namespace dombabot_hardware_interface
+{
+
+ class HardwareState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef dombabot_hardware_interface::LegJointState _front_left_leg_type;
+ _front_left_leg_type front_left_leg;
+ typedef dombabot_hardware_interface::LegJointState _back_left_leg_type;
+ _back_left_leg_type back_left_leg;
+ typedef dombabot_hardware_interface::LegJointState _front_right_leg_type;
+ _front_right_leg_type front_right_leg;
+ typedef dombabot_hardware_interface::LegJointState _back_right_leg_type;
+ _back_right_leg_type back_right_leg;
+
+ HardwareState():
+ header(),
+ front_left_leg(),
+ back_left_leg(),
+ front_right_leg(),
+ back_right_leg()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->front_left_leg.serialize(outbuffer + offset);
+ offset += this->back_left_leg.serialize(outbuffer + offset);
+ offset += this->front_right_leg.serialize(outbuffer + offset);
+ offset += this->back_right_leg.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->front_left_leg.deserialize(inbuffer + offset);
+ offset += this->back_left_leg.deserialize(inbuffer + offset);
+ offset += this->front_right_leg.deserialize(inbuffer + offset);
+ offset += this->back_right_leg.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "dombabot_hardware_interface/HardwareState"; };
+ const char * getMD5(){ return "cc956b515f201fcf29fa615961599ff4"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dombabot_hardware_interface/LegJointCommand.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,54 @@
+#ifndef _ROS_dombabot_hardware_interface_LegJointCommand_h
+#define _ROS_dombabot_hardware_interface_LegJointCommand_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Float32.h"
+
+namespace dombabot_hardware_interface
+{
+
+ class LegJointCommand : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Float32 _joint_1_orientation_type;
+ _joint_1_orientation_type joint_1_orientation;
+ typedef std_msgs::Float32 _joint_2_orientation_type;
+ _joint_2_orientation_type joint_2_orientation;
+ typedef std_msgs::Float32 _joint_3_orientation_type;
+ _joint_3_orientation_type joint_3_orientation;
+
+ LegJointCommand():
+ joint_1_orientation(),
+ joint_2_orientation(),
+ joint_3_orientation()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->joint_1_orientation.serialize(outbuffer + offset);
+ offset += this->joint_2_orientation.serialize(outbuffer + offset);
+ offset += this->joint_3_orientation.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->joint_1_orientation.deserialize(inbuffer + offset);
+ offset += this->joint_2_orientation.deserialize(inbuffer + offset);
+ offset += this->joint_3_orientation.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "dombabot_hardware_interface/LegJointCommand"; };
+ const char * getMD5(){ return "269cf341827b72fb9a499eb75222d7f4"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dombabot_hardware_interface/LegJointState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,69 @@
+#ifndef _ROS_dombabot_hardware_interface_LegJointState_h
+#define _ROS_dombabot_hardware_interface_LegJointState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Float32.h"
+
+namespace dombabot_hardware_interface
+{
+
+ class LegJointState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Float32 _joint_1_orientation_type;
+ _joint_1_orientation_type joint_1_orientation;
+ typedef std_msgs::Float32 _joint_2_orientation_type;
+ _joint_2_orientation_type joint_2_orientation;
+ typedef std_msgs::Float32 _joint_3_orientation_type;
+ _joint_3_orientation_type joint_3_orientation;
+ typedef std_msgs::Float32 _joint_1_current_type;
+ _joint_1_current_type joint_1_current;
+ typedef std_msgs::Float32 _joint_2_current_type;
+ _joint_2_current_type joint_2_current;
+ typedef std_msgs::Float32 _joint_3_current_type;
+ _joint_3_current_type joint_3_current;
+
+ LegJointState():
+ joint_1_orientation(),
+ joint_2_orientation(),
+ joint_3_orientation(),
+ joint_1_current(),
+ joint_2_current(),
+ joint_3_current()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->joint_1_orientation.serialize(outbuffer + offset);
+ offset += this->joint_2_orientation.serialize(outbuffer + offset);
+ offset += this->joint_3_orientation.serialize(outbuffer + offset);
+ offset += this->joint_1_current.serialize(outbuffer + offset);
+ offset += this->joint_2_current.serialize(outbuffer + offset);
+ offset += this->joint_3_current.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->joint_1_orientation.deserialize(inbuffer + offset);
+ offset += this->joint_2_orientation.deserialize(inbuffer + offset);
+ offset += this->joint_3_orientation.deserialize(inbuffer + offset);
+ offset += this->joint_1_current.deserialize(inbuffer + offset);
+ offset += this->joint_2_current.deserialize(inbuffer + offset);
+ offset += this->joint_3_current.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "dombabot_hardware_interface/LegJointState"; };
+ const char * getMD5(){ return "497d5c9f7001ce048604e9948222b96f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/duration.cpp Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,83 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <math.h>
+#include "ros/duration.h"
+
+namespace ros
+{
+void normalizeSecNSecSigned(int32_t &sec, int32_t &nsec)
+{
+ int32_t nsec_part = nsec;
+ int32_t sec_part = sec;
+
+ while (nsec_part > 1000000000L)
+ {
+ nsec_part -= 1000000000L;
+ ++sec_part;
+ }
+ while (nsec_part < 0)
+ {
+ nsec_part += 1000000000L;
+ --sec_part;
+ }
+ sec = sec_part;
+ nsec = nsec_part;
+}
+
+Duration& Duration::operator+=(const Duration &rhs)
+{
+ sec += rhs.sec;
+ nsec += rhs.nsec;
+ normalizeSecNSecSigned(sec, nsec);
+ return *this;
+}
+
+Duration& Duration::operator-=(const Duration &rhs)
+{
+ sec += -rhs.sec;
+ nsec += -rhs.nsec;
+ normalizeSecNSecSigned(sec, nsec);
+ return *this;
+}
+
+Duration& Duration::operator*=(double scale)
+{
+ sec *= scale;
+ nsec *= scale;
+ normalizeSecNSecSigned(sec, nsec);
+ return *this;
+}
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/BoolParameter.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,73 @@
+#ifndef _ROS_dynamic_reconfigure_BoolParameter_h
+#define _ROS_dynamic_reconfigure_BoolParameter_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace dynamic_reconfigure
+{
+
+ class BoolParameter : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef bool _value_type;
+ _value_type value;
+
+ BoolParameter():
+ name(""),
+ value(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ union {
+ bool real;
+ uint8_t base;
+ } u_value;
+ u_value.real = this->value;
+ *(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ union {
+ bool real;
+ uint8_t base;
+ } u_value;
+ u_value.base = 0;
+ u_value.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->value = u_value.real;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/BoolParameter"; };
+ const char * getMD5(){ return "23f05028c1a699fb83e22401228c3a9e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/Config.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,168 @@
+#ifndef _ROS_dynamic_reconfigure_Config_h
+#define _ROS_dynamic_reconfigure_Config_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "dynamic_reconfigure/BoolParameter.h"
+#include "dynamic_reconfigure/IntParameter.h"
+#include "dynamic_reconfigure/StrParameter.h"
+#include "dynamic_reconfigure/DoubleParameter.h"
+#include "dynamic_reconfigure/GroupState.h"
+
+namespace dynamic_reconfigure
+{
+
+ class Config : public ros::Msg
+ {
+ public:
+ uint32_t bools_length;
+ typedef dynamic_reconfigure::BoolParameter _bools_type;
+ _bools_type st_bools;
+ _bools_type * bools;
+ uint32_t ints_length;
+ typedef dynamic_reconfigure::IntParameter _ints_type;
+ _ints_type st_ints;
+ _ints_type * ints;
+ uint32_t strs_length;
+ typedef dynamic_reconfigure::StrParameter _strs_type;
+ _strs_type st_strs;
+ _strs_type * strs;
+ uint32_t doubles_length;
+ typedef dynamic_reconfigure::DoubleParameter _doubles_type;
+ _doubles_type st_doubles;
+ _doubles_type * doubles;
+ uint32_t groups_length;
+ typedef dynamic_reconfigure::GroupState _groups_type;
+ _groups_type st_groups;
+ _groups_type * groups;
+
+ Config():
+ bools_length(0), bools(NULL),
+ ints_length(0), ints(NULL),
+ strs_length(0), strs(NULL),
+ doubles_length(0), doubles(NULL),
+ groups_length(0), groups(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->bools_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->bools_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->bools_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->bools_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->bools_length);
+ for( uint32_t i = 0; i < bools_length; i++){
+ offset += this->bools[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->ints_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->ints_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->ints_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->ints_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ints_length);
+ for( uint32_t i = 0; i < ints_length; i++){
+ offset += this->ints[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->strs_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->strs_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->strs_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->strs_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->strs_length);
+ for( uint32_t i = 0; i < strs_length; i++){
+ offset += this->strs[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->doubles_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->doubles_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->doubles_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->doubles_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->doubles_length);
+ for( uint32_t i = 0; i < doubles_length; i++){
+ offset += this->doubles[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->groups_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->groups_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->groups_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->groups_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->groups_length);
+ for( uint32_t i = 0; i < groups_length; i++){
+ offset += this->groups[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t bools_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ bools_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->bools_length);
+ if(bools_lengthT > bools_length)
+ this->bools = (dynamic_reconfigure::BoolParameter*)realloc(this->bools, bools_lengthT * sizeof(dynamic_reconfigure::BoolParameter));
+ bools_length = bools_lengthT;
+ for( uint32_t i = 0; i < bools_length; i++){
+ offset += this->st_bools.deserialize(inbuffer + offset);
+ memcpy( &(this->bools[i]), &(this->st_bools), sizeof(dynamic_reconfigure::BoolParameter));
+ }
+ uint32_t ints_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->ints_length);
+ if(ints_lengthT > ints_length)
+ this->ints = (dynamic_reconfigure::IntParameter*)realloc(this->ints, ints_lengthT * sizeof(dynamic_reconfigure::IntParameter));
+ ints_length = ints_lengthT;
+ for( uint32_t i = 0; i < ints_length; i++){
+ offset += this->st_ints.deserialize(inbuffer + offset);
+ memcpy( &(this->ints[i]), &(this->st_ints), sizeof(dynamic_reconfigure::IntParameter));
+ }
+ uint32_t strs_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ strs_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->strs_length);
+ if(strs_lengthT > strs_length)
+ this->strs = (dynamic_reconfigure::StrParameter*)realloc(this->strs, strs_lengthT * sizeof(dynamic_reconfigure::StrParameter));
+ strs_length = strs_lengthT;
+ for( uint32_t i = 0; i < strs_length; i++){
+ offset += this->st_strs.deserialize(inbuffer + offset);
+ memcpy( &(this->strs[i]), &(this->st_strs), sizeof(dynamic_reconfigure::StrParameter));
+ }
+ uint32_t doubles_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ doubles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->doubles_length);
+ if(doubles_lengthT > doubles_length)
+ this->doubles = (dynamic_reconfigure::DoubleParameter*)realloc(this->doubles, doubles_lengthT * sizeof(dynamic_reconfigure::DoubleParameter));
+ doubles_length = doubles_lengthT;
+ for( uint32_t i = 0; i < doubles_length; i++){
+ offset += this->st_doubles.deserialize(inbuffer + offset);
+ memcpy( &(this->doubles[i]), &(this->st_doubles), sizeof(dynamic_reconfigure::DoubleParameter));
+ }
+ uint32_t groups_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->groups_length);
+ if(groups_lengthT > groups_length)
+ this->groups = (dynamic_reconfigure::GroupState*)realloc(this->groups, groups_lengthT * sizeof(dynamic_reconfigure::GroupState));
+ groups_length = groups_lengthT;
+ for( uint32_t i = 0; i < groups_length; i++){
+ offset += this->st_groups.deserialize(inbuffer + offset);
+ memcpy( &(this->groups[i]), &(this->st_groups), sizeof(dynamic_reconfigure::GroupState));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/Config"; };
+ const char * getMD5(){ return "958f16a05573709014982821e6822580"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/ConfigDescription.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,80 @@
+#ifndef _ROS_dynamic_reconfigure_ConfigDescription_h
+#define _ROS_dynamic_reconfigure_ConfigDescription_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "dynamic_reconfigure/Group.h"
+#include "dynamic_reconfigure/Config.h"
+
+namespace dynamic_reconfigure
+{
+
+ class ConfigDescription : public ros::Msg
+ {
+ public:
+ uint32_t groups_length;
+ typedef dynamic_reconfigure::Group _groups_type;
+ _groups_type st_groups;
+ _groups_type * groups;
+ typedef dynamic_reconfigure::Config _max_type;
+ _max_type max;
+ typedef dynamic_reconfigure::Config _min_type;
+ _min_type min;
+ typedef dynamic_reconfigure::Config _dflt_type;
+ _dflt_type dflt;
+
+ ConfigDescription():
+ groups_length(0), groups(NULL),
+ max(),
+ min(),
+ dflt()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->groups_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->groups_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->groups_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->groups_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->groups_length);
+ for( uint32_t i = 0; i < groups_length; i++){
+ offset += this->groups[i].serialize(outbuffer + offset);
+ }
+ offset += this->max.serialize(outbuffer + offset);
+ offset += this->min.serialize(outbuffer + offset);
+ offset += this->dflt.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t groups_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ groups_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->groups_length);
+ if(groups_lengthT > groups_length)
+ this->groups = (dynamic_reconfigure::Group*)realloc(this->groups, groups_lengthT * sizeof(dynamic_reconfigure::Group));
+ groups_length = groups_lengthT;
+ for( uint32_t i = 0; i < groups_length; i++){
+ offset += this->st_groups.deserialize(inbuffer + offset);
+ memcpy( &(this->groups[i]), &(this->st_groups), sizeof(dynamic_reconfigure::Group));
+ }
+ offset += this->max.deserialize(inbuffer + offset);
+ offset += this->min.deserialize(inbuffer + offset);
+ offset += this->dflt.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/ConfigDescription"; };
+ const char * getMD5(){ return "757ce9d44ba8ddd801bb30bc456f946f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/DoubleParameter.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_dynamic_reconfigure_DoubleParameter_h
+#define _ROS_dynamic_reconfigure_DoubleParameter_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace dynamic_reconfigure
+{
+
+ class DoubleParameter : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef double _value_type;
+ _value_type value;
+
+ DoubleParameter():
+ name(""),
+ value(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ union {
+ double real;
+ uint64_t base;
+ } u_value;
+ u_value.real = this->value;
+ *(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_value.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_value.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_value.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_value.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ union {
+ double real;
+ uint64_t base;
+ } u_value;
+ u_value.base = 0;
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->value = u_value.real;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/DoubleParameter"; };
+ const char * getMD5(){ return "d8512f27253c0f65f928a67c329cd658"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/Group.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,146 @@
+#ifndef _ROS_dynamic_reconfigure_Group_h
+#define _ROS_dynamic_reconfigure_Group_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "dynamic_reconfigure/ParamDescription.h"
+
+namespace dynamic_reconfigure
+{
+
+ class Group : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _type_type;
+ _type_type type;
+ uint32_t parameters_length;
+ typedef dynamic_reconfigure::ParamDescription _parameters_type;
+ _parameters_type st_parameters;
+ _parameters_type * parameters;
+ typedef int32_t _parent_type;
+ _parent_type parent;
+ typedef int32_t _id_type;
+ _id_type id;
+
+ Group():
+ name(""),
+ type(""),
+ parameters_length(0), parameters(NULL),
+ parent(0),
+ id(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_type = strlen(this->type);
+ varToArr(outbuffer + offset, length_type);
+ offset += 4;
+ memcpy(outbuffer + offset, this->type, length_type);
+ offset += length_type;
+ *(outbuffer + offset + 0) = (this->parameters_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->parameters_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->parameters_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->parameters_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->parameters_length);
+ for( uint32_t i = 0; i < parameters_length; i++){
+ offset += this->parameters[i].serialize(outbuffer + offset);
+ }
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_parent;
+ u_parent.real = this->parent;
+ *(outbuffer + offset + 0) = (u_parent.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_parent.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_parent.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_parent.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->parent);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.real = this->id;
+ *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->id);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_type;
+ arrToVar(length_type, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_type; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_type-1]=0;
+ this->type = (char *)(inbuffer + offset-1);
+ offset += length_type;
+ uint32_t parameters_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ parameters_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->parameters_length);
+ if(parameters_lengthT > parameters_length)
+ this->parameters = (dynamic_reconfigure::ParamDescription*)realloc(this->parameters, parameters_lengthT * sizeof(dynamic_reconfigure::ParamDescription));
+ parameters_length = parameters_lengthT;
+ for( uint32_t i = 0; i < parameters_length; i++){
+ offset += this->st_parameters.deserialize(inbuffer + offset);
+ memcpy( &(this->parameters[i]), &(this->st_parameters), sizeof(dynamic_reconfigure::ParamDescription));
+ }
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_parent;
+ u_parent.base = 0;
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->parent = u_parent.real;
+ offset += sizeof(this->parent);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.base = 0;
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->id = u_id.real;
+ offset += sizeof(this->id);
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/Group"; };
+ const char * getMD5(){ return "9e8cd9e9423c94823db3614dd8b1cf7a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/GroupState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,121 @@
+#ifndef _ROS_dynamic_reconfigure_GroupState_h
+#define _ROS_dynamic_reconfigure_GroupState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace dynamic_reconfigure
+{
+
+ class GroupState : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef bool _state_type;
+ _state_type state;
+ typedef int32_t _id_type;
+ _id_type id;
+ typedef int32_t _parent_type;
+ _parent_type parent;
+
+ GroupState():
+ name(""),
+ state(0),
+ id(0),
+ parent(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ union {
+ bool real;
+ uint8_t base;
+ } u_state;
+ u_state.real = this->state;
+ *(outbuffer + offset + 0) = (u_state.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->state);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.real = this->id;
+ *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->id);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_parent;
+ u_parent.real = this->parent;
+ *(outbuffer + offset + 0) = (u_parent.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_parent.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_parent.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_parent.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->parent);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ union {
+ bool real;
+ uint8_t base;
+ } u_state;
+ u_state.base = 0;
+ u_state.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->state = u_state.real;
+ offset += sizeof(this->state);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.base = 0;
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->id = u_id.real;
+ offset += sizeof(this->id);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_parent;
+ u_parent.base = 0;
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_parent.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->parent = u_parent.real;
+ offset += sizeof(this->parent);
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/GroupState"; };
+ const char * getMD5(){ return "a2d87f51dc22930325041a2f8b1571f8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/IntParameter.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,79 @@
+#ifndef _ROS_dynamic_reconfigure_IntParameter_h
+#define _ROS_dynamic_reconfigure_IntParameter_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace dynamic_reconfigure
+{
+
+ class IntParameter : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef int32_t _value_type;
+ _value_type value;
+
+ IntParameter():
+ name(""),
+ value(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_value;
+ u_value.real = this->value;
+ *(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_value;
+ u_value.base = 0;
+ u_value.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_value.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_value.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_value.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->value = u_value.real;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/IntParameter"; };
+ const char * getMD5(){ return "65fedc7a0cbfb8db035e46194a350bf1"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/ParamDescription.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,119 @@
+#ifndef _ROS_dynamic_reconfigure_ParamDescription_h
+#define _ROS_dynamic_reconfigure_ParamDescription_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace dynamic_reconfigure
+{
+
+ class ParamDescription : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _type_type;
+ _type_type type;
+ typedef uint32_t _level_type;
+ _level_type level;
+ typedef const char* _description_type;
+ _description_type description;
+ typedef const char* _edit_method_type;
+ _edit_method_type edit_method;
+
+ ParamDescription():
+ name(""),
+ type(""),
+ level(0),
+ description(""),
+ edit_method("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_type = strlen(this->type);
+ varToArr(outbuffer + offset, length_type);
+ offset += 4;
+ memcpy(outbuffer + offset, this->type, length_type);
+ offset += length_type;
+ *(outbuffer + offset + 0) = (this->level >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->level >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->level >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->level >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->level);
+ uint32_t length_description = strlen(this->description);
+ varToArr(outbuffer + offset, length_description);
+ offset += 4;
+ memcpy(outbuffer + offset, this->description, length_description);
+ offset += length_description;
+ uint32_t length_edit_method = strlen(this->edit_method);
+ varToArr(outbuffer + offset, length_edit_method);
+ offset += 4;
+ memcpy(outbuffer + offset, this->edit_method, length_edit_method);
+ offset += length_edit_method;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_type;
+ arrToVar(length_type, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_type; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_type-1]=0;
+ this->type = (char *)(inbuffer + offset-1);
+ offset += length_type;
+ this->level = ((uint32_t) (*(inbuffer + offset)));
+ this->level |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->level |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->level |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->level);
+ uint32_t length_description;
+ arrToVar(length_description, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_description; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_description-1]=0;
+ this->description = (char *)(inbuffer + offset-1);
+ offset += length_description;
+ uint32_t length_edit_method;
+ arrToVar(length_edit_method, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_edit_method; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_edit_method-1]=0;
+ this->edit_method = (char *)(inbuffer + offset-1);
+ offset += length_edit_method;
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/ParamDescription"; };
+ const char * getMD5(){ return "7434fcb9348c13054e0c3b267c8cb34d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/Reconfigure.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,81 @@
+#ifndef _ROS_SERVICE_Reconfigure_h
+#define _ROS_SERVICE_Reconfigure_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "dynamic_reconfigure/Config.h"
+
+namespace dynamic_reconfigure
+{
+
+static const char RECONFIGURE[] = "dynamic_reconfigure/Reconfigure";
+
+ class ReconfigureRequest : public ros::Msg
+ {
+ public:
+ typedef dynamic_reconfigure::Config _config_type;
+ _config_type config;
+
+ ReconfigureRequest():
+ config()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->config.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->config.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return RECONFIGURE; };
+ const char * getMD5(){ return "ac41a77620a4a0348b7001641796a8a1"; };
+
+ };
+
+ class ReconfigureResponse : public ros::Msg
+ {
+ public:
+ typedef dynamic_reconfigure::Config _config_type;
+ _config_type config;
+
+ ReconfigureResponse():
+ config()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->config.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->config.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return RECONFIGURE; };
+ const char * getMD5(){ return "ac41a77620a4a0348b7001641796a8a1"; };
+
+ };
+
+ class Reconfigure {
+ public:
+ typedef ReconfigureRequest Request;
+ typedef ReconfigureResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/SensorLevels.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,41 @@
+#ifndef _ROS_dynamic_reconfigure_SensorLevels_h
+#define _ROS_dynamic_reconfigure_SensorLevels_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace dynamic_reconfigure
+{
+
+ class SensorLevels : public ros::Msg
+ {
+ public:
+ enum { RECONFIGURE_CLOSE = 3 };
+ enum { RECONFIGURE_STOP = 1 };
+ enum { RECONFIGURE_RUNNING = 0 };
+
+ SensorLevels()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/SensorLevels"; };
+ const char * getMD5(){ return "6322637bee96d5489db6e2127c47602c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/dynamic_reconfigure/StrParameter.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,72 @@
+#ifndef _ROS_dynamic_reconfigure_StrParameter_h
+#define _ROS_dynamic_reconfigure_StrParameter_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace dynamic_reconfigure
+{
+
+ class StrParameter : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _value_type;
+ _value_type value;
+
+ StrParameter():
+ name(""),
+ value("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_value = strlen(this->value);
+ varToArr(outbuffer + offset, length_value);
+ offset += 4;
+ memcpy(outbuffer + offset, this->value, length_value);
+ offset += length_value;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_value;
+ arrToVar(length_value, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_value; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_value-1]=0;
+ this->value = (char *)(inbuffer + offset-1);
+ offset += length_value;
+ return offset;
+ }
+
+ const char * getType(){ return "dynamic_reconfigure/StrParameter"; };
+ const char * getMD5(){ return "bc6ccc4a57f61779c8eaae61e9f422e0"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/BoundingBox.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,49 @@
+#ifndef _ROS_geographic_msgs_BoundingBox_h
+#define _ROS_geographic_msgs_BoundingBox_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geographic_msgs/GeoPoint.h"
+
+namespace geographic_msgs
+{
+
+ class BoundingBox : public ros::Msg
+ {
+ public:
+ typedef geographic_msgs::GeoPoint _min_pt_type;
+ _min_pt_type min_pt;
+ typedef geographic_msgs::GeoPoint _max_pt_type;
+ _max_pt_type max_pt;
+
+ BoundingBox():
+ min_pt(),
+ max_pt()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->min_pt.serialize(outbuffer + offset);
+ offset += this->max_pt.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->min_pt.deserialize(inbuffer + offset);
+ offset += this->max_pt.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/BoundingBox"; };
+ const char * getMD5(){ return "f62e8b5e390a3ac7603250d46e8f8446"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GeoPath.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_geographic_msgs_GeoPath_h
+#define _ROS_geographic_msgs_GeoPath_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geographic_msgs/GeoPoseStamped.h"
+
+namespace geographic_msgs
+{
+
+ class GeoPath : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t poses_length;
+ typedef geographic_msgs::GeoPoseStamped _poses_type;
+ _poses_type st_poses;
+ _poses_type * poses;
+
+ GeoPath():
+ header(),
+ poses_length(0), poses(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->poses_length);
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->poses[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->poses_length);
+ if(poses_lengthT > poses_length)
+ this->poses = (geographic_msgs::GeoPoseStamped*)realloc(this->poses, poses_lengthT * sizeof(geographic_msgs::GeoPoseStamped));
+ poses_length = poses_lengthT;
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->st_poses.deserialize(inbuffer + offset);
+ memcpy( &(this->poses[i]), &(this->st_poses), sizeof(geographic_msgs::GeoPoseStamped));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/GeoPath"; };
+ const char * getMD5(){ return "1476008e63041203a89257cfad97308f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GeoPoint.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_geographic_msgs_GeoPoint_h
+#define _ROS_geographic_msgs_GeoPoint_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace geographic_msgs
+{
+
+ class GeoPoint : public ros::Msg
+ {
+ public:
+ typedef double _latitude_type;
+ _latitude_type latitude;
+ typedef double _longitude_type;
+ _longitude_type longitude;
+ typedef double _altitude_type;
+ _altitude_type altitude;
+
+ GeoPoint():
+ latitude(0),
+ longitude(0),
+ altitude(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->longitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_altitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_altitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_altitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_altitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->altitude);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/GeoPoint"; };
+ const char * getMD5(){ return "c48027a852aeff972be80478ff38e81a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GeoPointStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geographic_msgs_GeoPointStamped_h
+#define _ROS_geographic_msgs_GeoPointStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geographic_msgs/GeoPoint.h"
+
+namespace geographic_msgs
+{
+
+ class GeoPointStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geographic_msgs::GeoPoint _position_type;
+ _position_type position;
+
+ GeoPointStamped():
+ header(),
+ position()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->position.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->position.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/GeoPointStamped"; };
+ const char * getMD5(){ return "ea50d268b03080563c330351a21edc89"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GeoPose.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geographic_msgs_GeoPose_h
+#define _ROS_geographic_msgs_GeoPose_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geographic_msgs/GeoPoint.h"
+#include "geometry_msgs/Quaternion.h"
+
+namespace geographic_msgs
+{
+
+ class GeoPose : public ros::Msg
+ {
+ public:
+ typedef geographic_msgs::GeoPoint _position_type;
+ _position_type position;
+ typedef geometry_msgs::Quaternion _orientation_type;
+ _orientation_type orientation;
+
+ GeoPose():
+ position(),
+ orientation()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->position.serialize(outbuffer + offset);
+ offset += this->orientation.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->position.deserialize(inbuffer + offset);
+ offset += this->orientation.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/GeoPose"; };
+ const char * getMD5(){ return "778680b5172de58b7c057d973576c784"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GeoPoseStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geographic_msgs_GeoPoseStamped_h
+#define _ROS_geographic_msgs_GeoPoseStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geographic_msgs/GeoPose.h"
+
+namespace geographic_msgs
+{
+
+ class GeoPoseStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geographic_msgs::GeoPose _pose_type;
+ _pose_type pose;
+
+ GeoPoseStamped():
+ header(),
+ pose()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->pose.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->pose.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/GeoPoseStamped"; };
+ const char * getMD5(){ return "cc409c8ed6064d8a846fa207bf3fba6b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GeographicMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_geographic_msgs_GeographicMap_h
+#define _ROS_geographic_msgs_GeographicMap_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "uuid_msgs/UniqueID.h"
+#include "geographic_msgs/BoundingBox.h"
+#include "geographic_msgs/WayPoint.h"
+#include "geographic_msgs/MapFeature.h"
+#include "geographic_msgs/KeyValue.h"
+
+namespace geographic_msgs
+{
+
+ class GeographicMap : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uuid_msgs::UniqueID _id_type;
+ _id_type id;
+ typedef geographic_msgs::BoundingBox _bounds_type;
+ _bounds_type bounds;
+ uint32_t points_length;
+ typedef geographic_msgs::WayPoint _points_type;
+ _points_type st_points;
+ _points_type * points;
+ uint32_t features_length;
+ typedef geographic_msgs::MapFeature _features_type;
+ _features_type st_features;
+ _features_type * features;
+ uint32_t props_length;
+ typedef geographic_msgs::KeyValue _props_type;
+ _props_type st_props;
+ _props_type * props;
+
+ GeographicMap():
+ header(),
+ id(),
+ bounds(),
+ points_length(0), points(NULL),
+ features_length(0), features(NULL),
+ props_length(0), props(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->id.serialize(outbuffer + offset);
+ offset += this->bounds.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->features_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->features_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->features_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->features_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->features_length);
+ for( uint32_t i = 0; i < features_length; i++){
+ offset += this->features[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->props_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->props_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->props_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->props_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->props_length);
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->props[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->id.deserialize(inbuffer + offset);
+ offset += this->bounds.deserialize(inbuffer + offset);
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (geographic_msgs::WayPoint*)realloc(this->points, points_lengthT * sizeof(geographic_msgs::WayPoint));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(geographic_msgs::WayPoint));
+ }
+ uint32_t features_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ features_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ features_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ features_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->features_length);
+ if(features_lengthT > features_length)
+ this->features = (geographic_msgs::MapFeature*)realloc(this->features, features_lengthT * sizeof(geographic_msgs::MapFeature));
+ features_length = features_lengthT;
+ for( uint32_t i = 0; i < features_length; i++){
+ offset += this->st_features.deserialize(inbuffer + offset);
+ memcpy( &(this->features[i]), &(this->st_features), sizeof(geographic_msgs::MapFeature));
+ }
+ uint32_t props_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->props_length);
+ if(props_lengthT > props_length)
+ this->props = (geographic_msgs::KeyValue*)realloc(this->props, props_lengthT * sizeof(geographic_msgs::KeyValue));
+ props_length = props_lengthT;
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->st_props.deserialize(inbuffer + offset);
+ memcpy( &(this->props[i]), &(this->st_props), sizeof(geographic_msgs::KeyValue));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/GeographicMap"; };
+ const char * getMD5(){ return "0f4ce6d2ebf9ac9c7c4f3308f6ae0731"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GeographicMapChanges.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+#ifndef _ROS_geographic_msgs_GeographicMapChanges_h
+#define _ROS_geographic_msgs_GeographicMapChanges_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geographic_msgs/GeographicMap.h"
+#include "uuid_msgs/UniqueID.h"
+
+namespace geographic_msgs
+{
+
+ class GeographicMapChanges : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geographic_msgs::GeographicMap _diffs_type;
+ _diffs_type diffs;
+ uint32_t deletes_length;
+ typedef uuid_msgs::UniqueID _deletes_type;
+ _deletes_type st_deletes;
+ _deletes_type * deletes;
+
+ GeographicMapChanges():
+ header(),
+ diffs(),
+ deletes_length(0), deletes(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->diffs.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->deletes_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->deletes_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->deletes_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->deletes_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->deletes_length);
+ for( uint32_t i = 0; i < deletes_length; i++){
+ offset += this->deletes[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->diffs.deserialize(inbuffer + offset);
+ uint32_t deletes_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ deletes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ deletes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ deletes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->deletes_length);
+ if(deletes_lengthT > deletes_length)
+ this->deletes = (uuid_msgs::UniqueID*)realloc(this->deletes, deletes_lengthT * sizeof(uuid_msgs::UniqueID));
+ deletes_length = deletes_lengthT;
+ for( uint32_t i = 0; i < deletes_length; i++){
+ offset += this->st_deletes.deserialize(inbuffer + offset);
+ memcpy( &(this->deletes[i]), &(this->st_deletes), sizeof(uuid_msgs::UniqueID));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/GeographicMapChanges"; };
+ const char * getMD5(){ return "4fd027f54298203ec12aa1c4b20e6cb8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GetGeoPath.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,170 @@
+#ifndef _ROS_SERVICE_GetGeoPath_h
+#define _ROS_SERVICE_GetGeoPath_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "uuid_msgs/UniqueID.h"
+#include "geographic_msgs/GeoPoint.h"
+#include "geographic_msgs/GeoPath.h"
+
+namespace geographic_msgs
+{
+
+static const char GETGEOPATH[] = "geographic_msgs/GetGeoPath";
+
+ class GetGeoPathRequest : public ros::Msg
+ {
+ public:
+ typedef geographic_msgs::GeoPoint _start_type;
+ _start_type start;
+ typedef geographic_msgs::GeoPoint _goal_type;
+ _goal_type goal;
+
+ GetGeoPathRequest():
+ start(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->start.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->start.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETGEOPATH; };
+ const char * getMD5(){ return "cad6de11e4ae4ca568785186e1f99f89"; };
+
+ };
+
+ class GetGeoPathResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _status_type;
+ _status_type status;
+ typedef geographic_msgs::GeoPath _plan_type;
+ _plan_type plan;
+ typedef uuid_msgs::UniqueID _network_type;
+ _network_type network;
+ typedef uuid_msgs::UniqueID _start_seg_type;
+ _start_seg_type start_seg;
+ typedef uuid_msgs::UniqueID _goal_seg_type;
+ _goal_seg_type goal_seg;
+ typedef double _distance_type;
+ _distance_type distance;
+
+ GetGeoPathResponse():
+ success(0),
+ status(""),
+ plan(),
+ network(),
+ start_seg(),
+ goal_seg(),
+ distance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_status = strlen(this->status);
+ varToArr(outbuffer + offset, length_status);
+ offset += 4;
+ memcpy(outbuffer + offset, this->status, length_status);
+ offset += length_status;
+ offset += this->plan.serialize(outbuffer + offset);
+ offset += this->network.serialize(outbuffer + offset);
+ offset += this->start_seg.serialize(outbuffer + offset);
+ offset += this->goal_seg.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_distance;
+ u_distance.real = this->distance;
+ *(outbuffer + offset + 0) = (u_distance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_distance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_distance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_distance.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_distance.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_distance.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_distance.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_distance.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->distance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_status;
+ arrToVar(length_status, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_status; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_status-1]=0;
+ this->status = (char *)(inbuffer + offset-1);
+ offset += length_status;
+ offset += this->plan.deserialize(inbuffer + offset);
+ offset += this->network.deserialize(inbuffer + offset);
+ offset += this->start_seg.deserialize(inbuffer + offset);
+ offset += this->goal_seg.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_distance;
+ u_distance.base = 0;
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_distance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->distance = u_distance.real;
+ offset += sizeof(this->distance);
+ return offset;
+ }
+
+ const char * getType(){ return GETGEOPATH; };
+ const char * getMD5(){ return "0562f4b72e4d5b8e5fa142bd7363638c"; };
+
+ };
+
+ class GetGeoPath {
+ public:
+ typedef GetGeoPathRequest Request;
+ typedef GetGeoPathResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GetGeographicMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_SERVICE_GetGeographicMap_h
+#define _ROS_SERVICE_GetGeographicMap_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geographic_msgs/GeographicMap.h"
+#include "geographic_msgs/BoundingBox.h"
+
+namespace geographic_msgs
+{
+
+static const char GETGEOGRAPHICMAP[] = "geographic_msgs/GetGeographicMap";
+
+ class GetGeographicMapRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _url_type;
+ _url_type url;
+ typedef geographic_msgs::BoundingBox _bounds_type;
+ _bounds_type bounds;
+
+ GetGeographicMapRequest():
+ url(""),
+ bounds()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_url = strlen(this->url);
+ varToArr(outbuffer + offset, length_url);
+ offset += 4;
+ memcpy(outbuffer + offset, this->url, length_url);
+ offset += length_url;
+ offset += this->bounds.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_url;
+ arrToVar(length_url, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_url; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_url-1]=0;
+ this->url = (char *)(inbuffer + offset-1);
+ offset += length_url;
+ offset += this->bounds.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETGEOGRAPHICMAP; };
+ const char * getMD5(){ return "505cc89008cb1745810d2ee4ea646d6e"; };
+
+ };
+
+ class GetGeographicMapResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _status_type;
+ _status_type status;
+ typedef geographic_msgs::GeographicMap _map_type;
+ _map_type map;
+
+ GetGeographicMapResponse():
+ success(0),
+ status(""),
+ map()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_status = strlen(this->status);
+ varToArr(outbuffer + offset, length_status);
+ offset += 4;
+ memcpy(outbuffer + offset, this->status, length_status);
+ offset += length_status;
+ offset += this->map.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_status;
+ arrToVar(length_status, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_status; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_status-1]=0;
+ this->status = (char *)(inbuffer + offset-1);
+ offset += length_status;
+ offset += this->map.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETGEOGRAPHICMAP; };
+ const char * getMD5(){ return "0910332806c65953a4f4252eb780811a"; };
+
+ };
+
+ class GetGeographicMap {
+ public:
+ typedef GetGeographicMapRequest Request;
+ typedef GetGeographicMapResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/GetRoutePlan.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,127 @@
+#ifndef _ROS_SERVICE_GetRoutePlan_h
+#define _ROS_SERVICE_GetRoutePlan_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geographic_msgs/RoutePath.h"
+#include "uuid_msgs/UniqueID.h"
+
+namespace geographic_msgs
+{
+
+static const char GETROUTEPLAN[] = "geographic_msgs/GetRoutePlan";
+
+ class GetRoutePlanRequest : public ros::Msg
+ {
+ public:
+ typedef uuid_msgs::UniqueID _network_type;
+ _network_type network;
+ typedef uuid_msgs::UniqueID _start_type;
+ _start_type start;
+ typedef uuid_msgs::UniqueID _goal_type;
+ _goal_type goal;
+
+ GetRoutePlanRequest():
+ network(),
+ start(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->network.serialize(outbuffer + offset);
+ offset += this->start.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->network.deserialize(inbuffer + offset);
+ offset += this->start.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETROUTEPLAN; };
+ const char * getMD5(){ return "e56ac34268c6d575dabb30f42da4a47a"; };
+
+ };
+
+ class GetRoutePlanResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _status_type;
+ _status_type status;
+ typedef geographic_msgs::RoutePath _plan_type;
+ _plan_type plan;
+
+ GetRoutePlanResponse():
+ success(0),
+ status(""),
+ plan()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_status = strlen(this->status);
+ varToArr(outbuffer + offset, length_status);
+ offset += 4;
+ memcpy(outbuffer + offset, this->status, length_status);
+ offset += length_status;
+ offset += this->plan.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_status;
+ arrToVar(length_status, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_status; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_status-1]=0;
+ this->status = (char *)(inbuffer + offset-1);
+ offset += length_status;
+ offset += this->plan.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETROUTEPLAN; };
+ const char * getMD5(){ return "28ee54f0ccb2ab28b46048ebc6fa5aff"; };
+
+ };
+
+ class GetRoutePlan {
+ public:
+ typedef GetRoutePlanRequest Request;
+ typedef GetRoutePlanResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/KeyValue.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,72 @@
+#ifndef _ROS_geographic_msgs_KeyValue_h
+#define _ROS_geographic_msgs_KeyValue_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace geographic_msgs
+{
+
+ class KeyValue : public ros::Msg
+ {
+ public:
+ typedef const char* _key_type;
+ _key_type key;
+ typedef const char* _value_type;
+ _value_type value;
+
+ KeyValue():
+ key(""),
+ value("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_key = strlen(this->key);
+ varToArr(outbuffer + offset, length_key);
+ offset += 4;
+ memcpy(outbuffer + offset, this->key, length_key);
+ offset += length_key;
+ uint32_t length_value = strlen(this->value);
+ varToArr(outbuffer + offset, length_value);
+ offset += 4;
+ memcpy(outbuffer + offset, this->value, length_value);
+ offset += length_value;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_key;
+ arrToVar(length_key, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_key; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_key-1]=0;
+ this->key = (char *)(inbuffer + offset-1);
+ offset += length_key;
+ uint32_t length_value;
+ arrToVar(length_value, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_value; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_value-1]=0;
+ this->value = (char *)(inbuffer + offset-1);
+ offset += length_value;
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/KeyValue"; };
+ const char * getMD5(){ return "cf57fdc6617a881a88c16e768132149c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/MapFeature.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,95 @@
+#ifndef _ROS_geographic_msgs_MapFeature_h
+#define _ROS_geographic_msgs_MapFeature_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "uuid_msgs/UniqueID.h"
+#include "geographic_msgs/KeyValue.h"
+
+namespace geographic_msgs
+{
+
+ class MapFeature : public ros::Msg
+ {
+ public:
+ typedef uuid_msgs::UniqueID _id_type;
+ _id_type id;
+ uint32_t components_length;
+ typedef uuid_msgs::UniqueID _components_type;
+ _components_type st_components;
+ _components_type * components;
+ uint32_t props_length;
+ typedef geographic_msgs::KeyValue _props_type;
+ _props_type st_props;
+ _props_type * props;
+
+ MapFeature():
+ id(),
+ components_length(0), components(NULL),
+ props_length(0), props(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->id.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->components_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->components_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->components_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->components_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->components_length);
+ for( uint32_t i = 0; i < components_length; i++){
+ offset += this->components[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->props_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->props_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->props_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->props_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->props_length);
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->props[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->id.deserialize(inbuffer + offset);
+ uint32_t components_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ components_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ components_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ components_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->components_length);
+ if(components_lengthT > components_length)
+ this->components = (uuid_msgs::UniqueID*)realloc(this->components, components_lengthT * sizeof(uuid_msgs::UniqueID));
+ components_length = components_lengthT;
+ for( uint32_t i = 0; i < components_length; i++){
+ offset += this->st_components.deserialize(inbuffer + offset);
+ memcpy( &(this->components[i]), &(this->st_components), sizeof(uuid_msgs::UniqueID));
+ }
+ uint32_t props_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->props_length);
+ if(props_lengthT > props_length)
+ this->props = (geographic_msgs::KeyValue*)realloc(this->props, props_lengthT * sizeof(geographic_msgs::KeyValue));
+ props_length = props_lengthT;
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->st_props.deserialize(inbuffer + offset);
+ memcpy( &(this->props[i]), &(this->st_props), sizeof(geographic_msgs::KeyValue));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/MapFeature"; };
+ const char * getMD5(){ return "e2505ace5e8da8a15b610eaf62bdefae"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/RouteNetwork.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_geographic_msgs_RouteNetwork_h
+#define _ROS_geographic_msgs_RouteNetwork_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "uuid_msgs/UniqueID.h"
+#include "geographic_msgs/BoundingBox.h"
+#include "geographic_msgs/WayPoint.h"
+#include "geographic_msgs/RouteSegment.h"
+#include "geographic_msgs/KeyValue.h"
+
+namespace geographic_msgs
+{
+
+ class RouteNetwork : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uuid_msgs::UniqueID _id_type;
+ _id_type id;
+ typedef geographic_msgs::BoundingBox _bounds_type;
+ _bounds_type bounds;
+ uint32_t points_length;
+ typedef geographic_msgs::WayPoint _points_type;
+ _points_type st_points;
+ _points_type * points;
+ uint32_t segments_length;
+ typedef geographic_msgs::RouteSegment _segments_type;
+ _segments_type st_segments;
+ _segments_type * segments;
+ uint32_t props_length;
+ typedef geographic_msgs::KeyValue _props_type;
+ _props_type st_props;
+ _props_type * props;
+
+ RouteNetwork():
+ header(),
+ id(),
+ bounds(),
+ points_length(0), points(NULL),
+ segments_length(0), segments(NULL),
+ props_length(0), props(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->id.serialize(outbuffer + offset);
+ offset += this->bounds.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->segments_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->segments_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->segments_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->segments_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->segments_length);
+ for( uint32_t i = 0; i < segments_length; i++){
+ offset += this->segments[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->props_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->props_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->props_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->props_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->props_length);
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->props[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->id.deserialize(inbuffer + offset);
+ offset += this->bounds.deserialize(inbuffer + offset);
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (geographic_msgs::WayPoint*)realloc(this->points, points_lengthT * sizeof(geographic_msgs::WayPoint));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(geographic_msgs::WayPoint));
+ }
+ uint32_t segments_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->segments_length);
+ if(segments_lengthT > segments_length)
+ this->segments = (geographic_msgs::RouteSegment*)realloc(this->segments, segments_lengthT * sizeof(geographic_msgs::RouteSegment));
+ segments_length = segments_lengthT;
+ for( uint32_t i = 0; i < segments_length; i++){
+ offset += this->st_segments.deserialize(inbuffer + offset);
+ memcpy( &(this->segments[i]), &(this->st_segments), sizeof(geographic_msgs::RouteSegment));
+ }
+ uint32_t props_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->props_length);
+ if(props_lengthT > props_length)
+ this->props = (geographic_msgs::KeyValue*)realloc(this->props, props_lengthT * sizeof(geographic_msgs::KeyValue));
+ props_length = props_lengthT;
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->st_props.deserialize(inbuffer + offset);
+ memcpy( &(this->props[i]), &(this->st_props), sizeof(geographic_msgs::KeyValue));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/RouteNetwork"; };
+ const char * getMD5(){ return "fd717c0a34a7c954deed32c6847f30a8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/RoutePath.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,101 @@
+#ifndef _ROS_geographic_msgs_RoutePath_h
+#define _ROS_geographic_msgs_RoutePath_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "uuid_msgs/UniqueID.h"
+#include "geographic_msgs/KeyValue.h"
+
+namespace geographic_msgs
+{
+
+ class RoutePath : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uuid_msgs::UniqueID _network_type;
+ _network_type network;
+ uint32_t segments_length;
+ typedef uuid_msgs::UniqueID _segments_type;
+ _segments_type st_segments;
+ _segments_type * segments;
+ uint32_t props_length;
+ typedef geographic_msgs::KeyValue _props_type;
+ _props_type st_props;
+ _props_type * props;
+
+ RoutePath():
+ header(),
+ network(),
+ segments_length(0), segments(NULL),
+ props_length(0), props(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->network.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->segments_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->segments_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->segments_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->segments_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->segments_length);
+ for( uint32_t i = 0; i < segments_length; i++){
+ offset += this->segments[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->props_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->props_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->props_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->props_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->props_length);
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->props[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->network.deserialize(inbuffer + offset);
+ uint32_t segments_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->segments_length);
+ if(segments_lengthT > segments_length)
+ this->segments = (uuid_msgs::UniqueID*)realloc(this->segments, segments_lengthT * sizeof(uuid_msgs::UniqueID));
+ segments_length = segments_lengthT;
+ for( uint32_t i = 0; i < segments_length; i++){
+ offset += this->st_segments.deserialize(inbuffer + offset);
+ memcpy( &(this->segments[i]), &(this->st_segments), sizeof(uuid_msgs::UniqueID));
+ }
+ uint32_t props_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->props_length);
+ if(props_lengthT > props_length)
+ this->props = (geographic_msgs::KeyValue*)realloc(this->props, props_lengthT * sizeof(geographic_msgs::KeyValue));
+ props_length = props_lengthT;
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->st_props.deserialize(inbuffer + offset);
+ memcpy( &(this->props[i]), &(this->st_props), sizeof(geographic_msgs::KeyValue));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/RoutePath"; };
+ const char * getMD5(){ return "0aa2dd809a8091bdb4466dfefecbb8cf"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/RouteSegment.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,80 @@
+#ifndef _ROS_geographic_msgs_RouteSegment_h
+#define _ROS_geographic_msgs_RouteSegment_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "uuid_msgs/UniqueID.h"
+#include "geographic_msgs/KeyValue.h"
+
+namespace geographic_msgs
+{
+
+ class RouteSegment : public ros::Msg
+ {
+ public:
+ typedef uuid_msgs::UniqueID _id_type;
+ _id_type id;
+ typedef uuid_msgs::UniqueID _start_type;
+ _start_type start;
+ typedef uuid_msgs::UniqueID _end_type;
+ _end_type end;
+ uint32_t props_length;
+ typedef geographic_msgs::KeyValue _props_type;
+ _props_type st_props;
+ _props_type * props;
+
+ RouteSegment():
+ id(),
+ start(),
+ end(),
+ props_length(0), props(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->id.serialize(outbuffer + offset);
+ offset += this->start.serialize(outbuffer + offset);
+ offset += this->end.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->props_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->props_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->props_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->props_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->props_length);
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->props[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->id.deserialize(inbuffer + offset);
+ offset += this->start.deserialize(inbuffer + offset);
+ offset += this->end.deserialize(inbuffer + offset);
+ uint32_t props_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->props_length);
+ if(props_lengthT > props_length)
+ this->props = (geographic_msgs::KeyValue*)realloc(this->props, props_lengthT * sizeof(geographic_msgs::KeyValue));
+ props_length = props_lengthT;
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->st_props.deserialize(inbuffer + offset);
+ memcpy( &(this->props[i]), &(this->st_props), sizeof(geographic_msgs::KeyValue));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/RouteSegment"; };
+ const char * getMD5(){ return "8583d1e2ddf1891c3934a5d2ed9a799c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/UpdateGeographicMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,111 @@
+#ifndef _ROS_SERVICE_UpdateGeographicMap_h
+#define _ROS_SERVICE_UpdateGeographicMap_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geographic_msgs/GeographicMapChanges.h"
+
+namespace geographic_msgs
+{
+
+static const char UPDATEGEOGRAPHICMAP[] = "geographic_msgs/UpdateGeographicMap";
+
+ class UpdateGeographicMapRequest : public ros::Msg
+ {
+ public:
+ typedef geographic_msgs::GeographicMapChanges _updates_type;
+ _updates_type updates;
+
+ UpdateGeographicMapRequest():
+ updates()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->updates.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->updates.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return UPDATEGEOGRAPHICMAP; };
+ const char * getMD5(){ return "8d8da723a1fadc5f7621a18b4e72fc3b"; };
+
+ };
+
+ class UpdateGeographicMapResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _status_type;
+ _status_type status;
+
+ UpdateGeographicMapResponse():
+ success(0),
+ status("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_status = strlen(this->status);
+ varToArr(outbuffer + offset, length_status);
+ offset += 4;
+ memcpy(outbuffer + offset, this->status, length_status);
+ offset += length_status;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_status;
+ arrToVar(length_status, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_status; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_status-1]=0;
+ this->status = (char *)(inbuffer + offset-1);
+ offset += length_status;
+ return offset;
+ }
+
+ const char * getType(){ return UPDATEGEOGRAPHICMAP; };
+ const char * getMD5(){ return "38b8954d32a849f31d78416b12bff5d1"; };
+
+ };
+
+ class UpdateGeographicMap {
+ public:
+ typedef UpdateGeographicMapRequest Request;
+ typedef UpdateGeographicMapResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geographic_msgs/WayPoint.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+#ifndef _ROS_geographic_msgs_WayPoint_h
+#define _ROS_geographic_msgs_WayPoint_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "uuid_msgs/UniqueID.h"
+#include "geographic_msgs/GeoPoint.h"
+#include "geographic_msgs/KeyValue.h"
+
+namespace geographic_msgs
+{
+
+ class WayPoint : public ros::Msg
+ {
+ public:
+ typedef uuid_msgs::UniqueID _id_type;
+ _id_type id;
+ typedef geographic_msgs::GeoPoint _position_type;
+ _position_type position;
+ uint32_t props_length;
+ typedef geographic_msgs::KeyValue _props_type;
+ _props_type st_props;
+ _props_type * props;
+
+ WayPoint():
+ id(),
+ position(),
+ props_length(0), props(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->id.serialize(outbuffer + offset);
+ offset += this->position.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->props_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->props_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->props_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->props_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->props_length);
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->props[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->id.deserialize(inbuffer + offset);
+ offset += this->position.deserialize(inbuffer + offset);
+ uint32_t props_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ props_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->props_length);
+ if(props_lengthT > props_length)
+ this->props = (geographic_msgs::KeyValue*)realloc(this->props, props_lengthT * sizeof(geographic_msgs::KeyValue));
+ props_length = props_lengthT;
+ for( uint32_t i = 0; i < props_length; i++){
+ offset += this->st_props.deserialize(inbuffer + offset);
+ memcpy( &(this->props[i]), &(this->st_props), sizeof(geographic_msgs::KeyValue));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geographic_msgs/WayPoint"; };
+ const char * getMD5(){ return "ef04f823aef332455a49eaec3f1761b7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Accel.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,49 @@
+#ifndef _ROS_geometry_msgs_Accel_h
+#define _ROS_geometry_msgs_Accel_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace geometry_msgs
+{
+
+ class Accel : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Vector3 _linear_type;
+ _linear_type linear;
+ typedef geometry_msgs::Vector3 _angular_type;
+ _angular_type angular;
+
+ Accel():
+ linear(),
+ angular()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->linear.serialize(outbuffer + offset);
+ offset += this->angular.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->linear.deserialize(inbuffer + offset);
+ offset += this->angular.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Accel"; };
+ const char * getMD5(){ return "9f195f881246fdfa2798d1d3eebca84a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/AccelStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_AccelStamped_h
+#define _ROS_geometry_msgs_AccelStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Accel.h"
+
+namespace geometry_msgs
+{
+
+ class AccelStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Accel _accel_type;
+ _accel_type accel;
+
+ AccelStamped():
+ header(),
+ accel()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->accel.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->accel.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/AccelStamped"; };
+ const char * getMD5(){ return "d8a98a5d81351b6eb0578c78557e7659"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/AccelWithCovariance.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,79 @@
+#ifndef _ROS_geometry_msgs_AccelWithCovariance_h
+#define _ROS_geometry_msgs_AccelWithCovariance_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Accel.h"
+
+namespace geometry_msgs
+{
+
+ class AccelWithCovariance : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Accel _accel_type;
+ _accel_type accel;
+ double covariance[36];
+
+ AccelWithCovariance():
+ accel(),
+ covariance()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->accel.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 36; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_covariancei;
+ u_covariancei.real = this->covariance[i];
+ *(outbuffer + offset + 0) = (u_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->covariance[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->accel.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 36; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_covariancei;
+ u_covariancei.base = 0;
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->covariance[i] = u_covariancei.real;
+ offset += sizeof(this->covariance[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/AccelWithCovariance"; };
+ const char * getMD5(){ return "ad5a718d699c6be72a02b8d6a139f334"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/AccelWithCovarianceStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_AccelWithCovarianceStamped_h
+#define _ROS_geometry_msgs_AccelWithCovarianceStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/AccelWithCovariance.h"
+
+namespace geometry_msgs
+{
+
+ class AccelWithCovarianceStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::AccelWithCovariance _accel_type;
+ _accel_type accel;
+
+ AccelWithCovarianceStamped():
+ header(),
+ accel()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->accel.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->accel.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/AccelWithCovarianceStamped"; };
+ const char * getMD5(){ return "96adb295225031ec8d57fb4251b0a886"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Inertia.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,268 @@
+#ifndef _ROS_geometry_msgs_Inertia_h
+#define _ROS_geometry_msgs_Inertia_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace geometry_msgs
+{
+
+ class Inertia : public ros::Msg
+ {
+ public:
+ typedef double _m_type;
+ _m_type m;
+ typedef geometry_msgs::Vector3 _com_type;
+ _com_type com;
+ typedef double _ixx_type;
+ _ixx_type ixx;
+ typedef double _ixy_type;
+ _ixy_type ixy;
+ typedef double _ixz_type;
+ _ixz_type ixz;
+ typedef double _iyy_type;
+ _iyy_type iyy;
+ typedef double _iyz_type;
+ _iyz_type iyz;
+ typedef double _izz_type;
+ _izz_type izz;
+
+ Inertia():
+ m(0),
+ com(),
+ ixx(0),
+ ixy(0),
+ ixz(0),
+ iyy(0),
+ iyz(0),
+ izz(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_m;
+ u_m.real = this->m;
+ *(outbuffer + offset + 0) = (u_m.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_m.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_m.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_m.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_m.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_m.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_m.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_m.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->m);
+ offset += this->com.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_ixx;
+ u_ixx.real = this->ixx;
+ *(outbuffer + offset + 0) = (u_ixx.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_ixx.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_ixx.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_ixx.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_ixx.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_ixx.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_ixx.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_ixx.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->ixx);
+ union {
+ double real;
+ uint64_t base;
+ } u_ixy;
+ u_ixy.real = this->ixy;
+ *(outbuffer + offset + 0) = (u_ixy.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_ixy.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_ixy.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_ixy.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_ixy.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_ixy.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_ixy.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_ixy.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->ixy);
+ union {
+ double real;
+ uint64_t base;
+ } u_ixz;
+ u_ixz.real = this->ixz;
+ *(outbuffer + offset + 0) = (u_ixz.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_ixz.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_ixz.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_ixz.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_ixz.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_ixz.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_ixz.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_ixz.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->ixz);
+ union {
+ double real;
+ uint64_t base;
+ } u_iyy;
+ u_iyy.real = this->iyy;
+ *(outbuffer + offset + 0) = (u_iyy.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_iyy.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_iyy.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_iyy.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_iyy.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_iyy.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_iyy.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_iyy.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->iyy);
+ union {
+ double real;
+ uint64_t base;
+ } u_iyz;
+ u_iyz.real = this->iyz;
+ *(outbuffer + offset + 0) = (u_iyz.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_iyz.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_iyz.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_iyz.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_iyz.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_iyz.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_iyz.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_iyz.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->iyz);
+ union {
+ double real;
+ uint64_t base;
+ } u_izz;
+ u_izz.real = this->izz;
+ *(outbuffer + offset + 0) = (u_izz.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_izz.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_izz.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_izz.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_izz.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_izz.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_izz.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_izz.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->izz);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_m;
+ u_m.base = 0;
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_m.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->m = u_m.real;
+ offset += sizeof(this->m);
+ offset += this->com.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_ixx;
+ u_ixx.base = 0;
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->ixx = u_ixx.real;
+ offset += sizeof(this->ixx);
+ union {
+ double real;
+ uint64_t base;
+ } u_ixy;
+ u_ixy.base = 0;
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->ixy = u_ixy.real;
+ offset += sizeof(this->ixy);
+ union {
+ double real;
+ uint64_t base;
+ } u_ixz;
+ u_ixz.base = 0;
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->ixz = u_ixz.real;
+ offset += sizeof(this->ixz);
+ union {
+ double real;
+ uint64_t base;
+ } u_iyy;
+ u_iyy.base = 0;
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->iyy = u_iyy.real;
+ offset += sizeof(this->iyy);
+ union {
+ double real;
+ uint64_t base;
+ } u_iyz;
+ u_iyz.base = 0;
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->iyz = u_iyz.real;
+ offset += sizeof(this->iyz);
+ union {
+ double real;
+ uint64_t base;
+ } u_izz;
+ u_izz.base = 0;
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_izz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->izz = u_izz.real;
+ offset += sizeof(this->izz);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Inertia"; };
+ const char * getMD5(){ return "1d26e4bb6c83ff141c5cf0d883c2b0fe"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/InertiaStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_InertiaStamped_h
+#define _ROS_geometry_msgs_InertiaStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Inertia.h"
+
+namespace geometry_msgs
+{
+
+ class InertiaStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Inertia _inertia_type;
+ _inertia_type inertia;
+
+ InertiaStamped():
+ header(),
+ inertia()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->inertia.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->inertia.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/InertiaStamped"; };
+ const char * getMD5(){ return "ddee48caeab5a966c5e8d166654a9ac7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Point.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_geometry_msgs_Point_h
+#define _ROS_geometry_msgs_Point_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace geometry_msgs
+{
+
+ class Point : public ros::Msg
+ {
+ public:
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+ typedef double _z_type;
+ _z_type z;
+
+ Point():
+ x(0),
+ y(0),
+ z(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.real = this->z;
+ *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.base = 0;
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->z = u_z.real;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Point"; };
+ const char * getMD5(){ return "4a842b65f413084dc2b10fb484ea7f17"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Point32.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,110 @@
+#ifndef _ROS_geometry_msgs_Point32_h
+#define _ROS_geometry_msgs_Point32_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace geometry_msgs
+{
+
+ class Point32 : public ros::Msg
+ {
+ public:
+ typedef float _x_type;
+ _x_type x;
+ typedef float _y_type;
+ _y_type y;
+ typedef float _z_type;
+ _z_type z;
+
+ Point32():
+ x(0),
+ y(0),
+ z(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_z;
+ u_z.real = this->z;
+ *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_z;
+ u_z.base = 0;
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->z = u_z.real;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Point32"; };
+ const char * getMD5(){ return "cc153912f1453b708d221682bc23d9ac"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/PointStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_PointStamped_h
+#define _ROS_geometry_msgs_PointStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Point.h"
+
+namespace geometry_msgs
+{
+
+ class PointStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Point _point_type;
+ _point_type point;
+
+ PointStamped():
+ header(),
+ point()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->point.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->point.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/PointStamped"; };
+ const char * getMD5(){ return "c63aecb41bfdfd6b7e1fac37c7cbe7bf"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Polygon.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,64 @@
+#ifndef _ROS_geometry_msgs_Polygon_h
+#define _ROS_geometry_msgs_Polygon_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Point32.h"
+
+namespace geometry_msgs
+{
+
+ class Polygon : public ros::Msg
+ {
+ public:
+ uint32_t points_length;
+ typedef geometry_msgs::Point32 _points_type;
+ _points_type st_points;
+ _points_type * points;
+
+ Polygon():
+ points_length(0), points(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (geometry_msgs::Point32*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point32));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point32));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Polygon"; };
+ const char * getMD5(){ return "cd60a26494a087f577976f0329fa120e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/PolygonStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_PolygonStamped_h
+#define _ROS_geometry_msgs_PolygonStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Polygon.h"
+
+namespace geometry_msgs
+{
+
+ class PolygonStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Polygon _polygon_type;
+ _polygon_type polygon;
+
+ PolygonStamped():
+ header(),
+ polygon()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->polygon.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->polygon.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/PolygonStamped"; };
+ const char * getMD5(){ return "c6be8f7dc3bee7fe9e8d296070f53340"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Pose.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_Pose_h
+#define _ROS_geometry_msgs_Pose_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Point.h"
+#include "geometry_msgs/Quaternion.h"
+
+namespace geometry_msgs
+{
+
+ class Pose : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Point _position_type;
+ _position_type position;
+ typedef geometry_msgs::Quaternion _orientation_type;
+ _orientation_type orientation;
+
+ Pose():
+ position(),
+ orientation()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->position.serialize(outbuffer + offset);
+ offset += this->orientation.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->position.deserialize(inbuffer + offset);
+ offset += this->orientation.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Pose"; };
+ const char * getMD5(){ return "e45d45a5a1ce597b249e23fb30fc871f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Pose2D.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_geometry_msgs_Pose2D_h
+#define _ROS_geometry_msgs_Pose2D_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace geometry_msgs
+{
+
+ class Pose2D : public ros::Msg
+ {
+ public:
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+ typedef double _theta_type;
+ _theta_type theta;
+
+ Pose2D():
+ x(0),
+ y(0),
+ theta(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_theta;
+ u_theta.real = this->theta;
+ *(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_theta.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_theta.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_theta.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_theta.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->theta);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_theta;
+ u_theta.base = 0;
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_theta.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->theta = u_theta.real;
+ offset += sizeof(this->theta);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Pose2D"; };
+ const char * getMD5(){ return "938fa65709584ad8e77d238529be13b8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/PoseArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_geometry_msgs_PoseArray_h
+#define _ROS_geometry_msgs_PoseArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Pose.h"
+
+namespace geometry_msgs
+{
+
+ class PoseArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t poses_length;
+ typedef geometry_msgs::Pose _poses_type;
+ _poses_type st_poses;
+ _poses_type * poses;
+
+ PoseArray():
+ header(),
+ poses_length(0), poses(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->poses_length);
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->poses[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->poses_length);
+ if(poses_lengthT > poses_length)
+ this->poses = (geometry_msgs::Pose*)realloc(this->poses, poses_lengthT * sizeof(geometry_msgs::Pose));
+ poses_length = poses_lengthT;
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->st_poses.deserialize(inbuffer + offset);
+ memcpy( &(this->poses[i]), &(this->st_poses), sizeof(geometry_msgs::Pose));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/PoseArray"; };
+ const char * getMD5(){ return "916c28c5764443f268b296bb671b9d97"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/PoseStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_PoseStamped_h
+#define _ROS_geometry_msgs_PoseStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Pose.h"
+
+namespace geometry_msgs
+{
+
+ class PoseStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Pose _pose_type;
+ _pose_type pose;
+
+ PoseStamped():
+ header(),
+ pose()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->pose.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->pose.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/PoseStamped"; };
+ const char * getMD5(){ return "d3812c3cbc69362b77dc0b19b345f8f5"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/PoseWithCovariance.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,79 @@
+#ifndef _ROS_geometry_msgs_PoseWithCovariance_h
+#define _ROS_geometry_msgs_PoseWithCovariance_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Pose.h"
+
+namespace geometry_msgs
+{
+
+ class PoseWithCovariance : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Pose _pose_type;
+ _pose_type pose;
+ double covariance[36];
+
+ PoseWithCovariance():
+ pose(),
+ covariance()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->pose.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 36; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_covariancei;
+ u_covariancei.real = this->covariance[i];
+ *(outbuffer + offset + 0) = (u_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->covariance[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->pose.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 36; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_covariancei;
+ u_covariancei.base = 0;
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->covariance[i] = u_covariancei.real;
+ offset += sizeof(this->covariance[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/PoseWithCovariance"; };
+ const char * getMD5(){ return "c23e848cf1b7533a8d7c259073a97e6f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/PoseWithCovarianceStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_PoseWithCovarianceStamped_h
+#define _ROS_geometry_msgs_PoseWithCovarianceStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/PoseWithCovariance.h"
+
+namespace geometry_msgs
+{
+
+ class PoseWithCovarianceStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::PoseWithCovariance _pose_type;
+ _pose_type pose;
+
+ PoseWithCovarianceStamped():
+ header(),
+ pose()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->pose.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->pose.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/PoseWithCovarianceStamped"; };
+ const char * getMD5(){ return "953b798c0f514ff060a53a3498ce6246"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Quaternion.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,166 @@
+#ifndef _ROS_geometry_msgs_Quaternion_h
+#define _ROS_geometry_msgs_Quaternion_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace geometry_msgs
+{
+
+ class Quaternion : public ros::Msg
+ {
+ public:
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+ typedef double _z_type;
+ _z_type z;
+ typedef double _w_type;
+ _w_type w;
+
+ Quaternion():
+ x(0),
+ y(0),
+ z(0),
+ w(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.real = this->z;
+ *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->z);
+ union {
+ double real;
+ uint64_t base;
+ } u_w;
+ u_w.real = this->w;
+ *(outbuffer + offset + 0) = (u_w.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_w.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_w.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_w.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_w.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_w.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_w.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_w.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->w);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.base = 0;
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->z = u_z.real;
+ offset += sizeof(this->z);
+ union {
+ double real;
+ uint64_t base;
+ } u_w;
+ u_w.base = 0;
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_w.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->w = u_w.real;
+ offset += sizeof(this->w);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Quaternion"; };
+ const char * getMD5(){ return "a779879fadf0160734f906b8c19c7004"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/QuaternionStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_QuaternionStamped_h
+#define _ROS_geometry_msgs_QuaternionStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Quaternion.h"
+
+namespace geometry_msgs
+{
+
+ class QuaternionStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Quaternion _quaternion_type;
+ _quaternion_type quaternion;
+
+ QuaternionStamped():
+ header(),
+ quaternion()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->quaternion.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->quaternion.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/QuaternionStamped"; };
+ const char * getMD5(){ return "e57f1e547e0e1fd13504588ffc8334e2"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Transform.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_Transform_h
+#define _ROS_geometry_msgs_Transform_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Vector3.h"
+#include "geometry_msgs/Quaternion.h"
+
+namespace geometry_msgs
+{
+
+ class Transform : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Vector3 _translation_type;
+ _translation_type translation;
+ typedef geometry_msgs::Quaternion _rotation_type;
+ _rotation_type rotation;
+
+ Transform():
+ translation(),
+ rotation()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->translation.serialize(outbuffer + offset);
+ offset += this->rotation.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->translation.deserialize(inbuffer + offset);
+ offset += this->rotation.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Transform"; };
+ const char * getMD5(){ return "ac9eff44abf714214112b05d54a3cf9b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/TransformStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,67 @@
+#ifndef _ROS_geometry_msgs_TransformStamped_h
+#define _ROS_geometry_msgs_TransformStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Transform.h"
+
+namespace geometry_msgs
+{
+
+ class TransformStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _child_frame_id_type;
+ _child_frame_id_type child_frame_id;
+ typedef geometry_msgs::Transform _transform_type;
+ _transform_type transform;
+
+ TransformStamped():
+ header(),
+ child_frame_id(""),
+ transform()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_child_frame_id = strlen(this->child_frame_id);
+ varToArr(outbuffer + offset, length_child_frame_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->child_frame_id, length_child_frame_id);
+ offset += length_child_frame_id;
+ offset += this->transform.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_child_frame_id;
+ arrToVar(length_child_frame_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_child_frame_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_child_frame_id-1]=0;
+ this->child_frame_id = (char *)(inbuffer + offset-1);
+ offset += length_child_frame_id;
+ offset += this->transform.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/TransformStamped"; };
+ const char * getMD5(){ return "b5764a33bfeb3588febc2682852579b0"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Twist.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,49 @@
+#ifndef _ROS_geometry_msgs_Twist_h
+#define _ROS_geometry_msgs_Twist_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace geometry_msgs
+{
+
+ class Twist : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Vector3 _linear_type;
+ _linear_type linear;
+ typedef geometry_msgs::Vector3 _angular_type;
+ _angular_type angular;
+
+ Twist():
+ linear(),
+ angular()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->linear.serialize(outbuffer + offset);
+ offset += this->angular.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->linear.deserialize(inbuffer + offset);
+ offset += this->angular.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Twist"; };
+ const char * getMD5(){ return "9f195f881246fdfa2798d1d3eebca84a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/TwistStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_TwistStamped_h
+#define _ROS_geometry_msgs_TwistStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Twist.h"
+
+namespace geometry_msgs
+{
+
+ class TwistStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Twist _twist_type;
+ _twist_type twist;
+
+ TwistStamped():
+ header(),
+ twist()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->twist.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->twist.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/TwistStamped"; };
+ const char * getMD5(){ return "98d34b0043a2093cf9d9345ab6eef12e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/TwistWithCovariance.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,79 @@
+#ifndef _ROS_geometry_msgs_TwistWithCovariance_h
+#define _ROS_geometry_msgs_TwistWithCovariance_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Twist.h"
+
+namespace geometry_msgs
+{
+
+ class TwistWithCovariance : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Twist _twist_type;
+ _twist_type twist;
+ double covariance[36];
+
+ TwistWithCovariance():
+ twist(),
+ covariance()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->twist.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 36; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_covariancei;
+ u_covariancei.real = this->covariance[i];
+ *(outbuffer + offset + 0) = (u_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->covariance[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->twist.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 36; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_covariancei;
+ u_covariancei.base = 0;
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->covariance[i] = u_covariancei.real;
+ offset += sizeof(this->covariance[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/TwistWithCovariance"; };
+ const char * getMD5(){ return "1fe8a28e6890a4cc3ae4c3ca5c7d82e6"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/TwistWithCovarianceStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_TwistWithCovarianceStamped_h
+#define _ROS_geometry_msgs_TwistWithCovarianceStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/TwistWithCovariance.h"
+
+namespace geometry_msgs
+{
+
+ class TwistWithCovarianceStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::TwistWithCovariance _twist_type;
+ _twist_type twist;
+
+ TwistWithCovarianceStamped():
+ header(),
+ twist()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->twist.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->twist.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/TwistWithCovarianceStamped"; };
+ const char * getMD5(){ return "8927a1a12fb2607ceea095b2dc440a96"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Vector3.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_geometry_msgs_Vector3_h
+#define _ROS_geometry_msgs_Vector3_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace geometry_msgs
+{
+
+ class Vector3 : public ros::Msg
+ {
+ public:
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+ typedef double _z_type;
+ _z_type z;
+
+ Vector3():
+ x(0),
+ y(0),
+ z(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.real = this->z;
+ *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.base = 0;
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->z = u_z.real;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Vector3"; };
+ const char * getMD5(){ return "4a842b65f413084dc2b10fb484ea7f17"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Vector3Stamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_Vector3Stamped_h
+#define _ROS_geometry_msgs_Vector3Stamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace geometry_msgs
+{
+
+ class Vector3Stamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Vector3 _vector_type;
+ _vector_type vector;
+
+ Vector3Stamped():
+ header(),
+ vector()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->vector.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->vector.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Vector3Stamped"; };
+ const char * getMD5(){ return "7b324c7325e683bf02a9b14b01090ec7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/Wrench.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,49 @@
+#ifndef _ROS_geometry_msgs_Wrench_h
+#define _ROS_geometry_msgs_Wrench_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace geometry_msgs
+{
+
+ class Wrench : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::Vector3 _force_type;
+ _force_type force;
+ typedef geometry_msgs::Vector3 _torque_type;
+ _torque_type torque;
+
+ Wrench():
+ force(),
+ torque()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->force.serialize(outbuffer + offset);
+ offset += this->torque.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->force.deserialize(inbuffer + offset);
+ offset += this->torque.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/Wrench"; };
+ const char * getMD5(){ return "4f539cf138b23283b520fd271b567936"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/geometry_msgs/WrenchStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_geometry_msgs_WrenchStamped_h
+#define _ROS_geometry_msgs_WrenchStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Wrench.h"
+
+namespace geometry_msgs
+{
+
+ class WrenchStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Wrench _wrench_type;
+ _wrench_type wrench;
+
+ WrenchStamped():
+ header(),
+ wrench()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->wrench.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->wrench.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "geometry_msgs/WrenchStamped"; };
+ const char * getMD5(){ return "d78d3cb249ce23087ade7e7d0c40cfa7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/GetMapROI.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,204 @@
+#ifndef _ROS_SERVICE_GetMapROI_h
+#define _ROS_SERVICE_GetMapROI_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "nav_msgs/OccupancyGrid.h"
+
+namespace map_msgs
+{
+
+static const char GETMAPROI[] = "map_msgs/GetMapROI";
+
+ class GetMapROIRequest : public ros::Msg
+ {
+ public:
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+ typedef double _l_x_type;
+ _l_x_type l_x;
+ typedef double _l_y_type;
+ _l_y_type l_y;
+
+ GetMapROIRequest():
+ x(0),
+ y(0),
+ l_x(0),
+ l_y(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_x;
+ u_l_x.real = this->l_x;
+ *(outbuffer + offset + 0) = (u_l_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_l_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_l_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_l_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_l_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_l_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_l_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_l_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->l_x);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_y;
+ u_l_y.real = this->l_y;
+ *(outbuffer + offset + 0) = (u_l_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_l_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_l_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_l_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_l_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_l_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_l_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_l_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->l_y);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_x;
+ u_l_x.base = 0;
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->l_x = u_l_x.real;
+ offset += sizeof(this->l_x);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_y;
+ u_l_y.base = 0;
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->l_y = u_l_y.real;
+ offset += sizeof(this->l_y);
+ return offset;
+ }
+
+ const char * getType(){ return GETMAPROI; };
+ const char * getMD5(){ return "43c2ff8f45af555c0eaf070c401e9a47"; };
+
+ };
+
+ class GetMapROIResponse : public ros::Msg
+ {
+ public:
+ typedef nav_msgs::OccupancyGrid _sub_map_type;
+ _sub_map_type sub_map;
+
+ GetMapROIResponse():
+ sub_map()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->sub_map.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->sub_map.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETMAPROI; };
+ const char * getMD5(){ return "4d1986519c00d81967d2891a606b234c"; };
+
+ };
+
+ class GetMapROI {
+ public:
+ typedef GetMapROIRequest Request;
+ typedef GetMapROIResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/GetPointMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+#ifndef _ROS_SERVICE_GetPointMap_h
+#define _ROS_SERVICE_GetPointMap_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "sensor_msgs/PointCloud2.h"
+
+namespace map_msgs
+{
+
+static const char GETPOINTMAP[] = "map_msgs/GetPointMap";
+
+ class GetPointMapRequest : public ros::Msg
+ {
+ public:
+
+ GetPointMapRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return GETPOINTMAP; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class GetPointMapResponse : public ros::Msg
+ {
+ public:
+ typedef sensor_msgs::PointCloud2 _map_type;
+ _map_type map;
+
+ GetPointMapResponse():
+ map()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->map.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->map.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETPOINTMAP; };
+ const char * getMD5(){ return "b84fbb39505086eb6a62d933c75cb7b4"; };
+
+ };
+
+ class GetPointMap {
+ public:
+ typedef GetPointMapRequest Request;
+ typedef GetPointMapResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/GetPointMapROI.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,300 @@
+#ifndef _ROS_SERVICE_GetPointMapROI_h
+#define _ROS_SERVICE_GetPointMapROI_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "sensor_msgs/PointCloud2.h"
+
+namespace map_msgs
+{
+
+static const char GETPOINTMAPROI[] = "map_msgs/GetPointMapROI";
+
+ class GetPointMapROIRequest : public ros::Msg
+ {
+ public:
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+ typedef double _z_type;
+ _z_type z;
+ typedef double _r_type;
+ _r_type r;
+ typedef double _l_x_type;
+ _l_x_type l_x;
+ typedef double _l_y_type;
+ _l_y_type l_y;
+ typedef double _l_z_type;
+ _l_z_type l_z;
+
+ GetPointMapROIRequest():
+ x(0),
+ y(0),
+ z(0),
+ r(0),
+ l_x(0),
+ l_y(0),
+ l_z(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.real = this->z;
+ *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->z);
+ union {
+ double real;
+ uint64_t base;
+ } u_r;
+ u_r.real = this->r;
+ *(outbuffer + offset + 0) = (u_r.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_r.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_r.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_r.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_r.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->r);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_x;
+ u_l_x.real = this->l_x;
+ *(outbuffer + offset + 0) = (u_l_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_l_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_l_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_l_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_l_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_l_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_l_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_l_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->l_x);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_y;
+ u_l_y.real = this->l_y;
+ *(outbuffer + offset + 0) = (u_l_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_l_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_l_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_l_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_l_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_l_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_l_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_l_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->l_y);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_z;
+ u_l_z.real = this->l_z;
+ *(outbuffer + offset + 0) = (u_l_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_l_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_l_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_l_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_l_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_l_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_l_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_l_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->l_z);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_z;
+ u_z.base = 0;
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->z = u_z.real;
+ offset += sizeof(this->z);
+ union {
+ double real;
+ uint64_t base;
+ } u_r;
+ u_r.base = 0;
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_r.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->r = u_r.real;
+ offset += sizeof(this->r);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_x;
+ u_l_x.base = 0;
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->l_x = u_l_x.real;
+ offset += sizeof(this->l_x);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_y;
+ u_l_y.base = 0;
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->l_y = u_l_y.real;
+ offset += sizeof(this->l_y);
+ union {
+ double real;
+ uint64_t base;
+ } u_l_z;
+ u_l_z.base = 0;
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->l_z = u_l_z.real;
+ offset += sizeof(this->l_z);
+ return offset;
+ }
+
+ const char * getType(){ return GETPOINTMAPROI; };
+ const char * getMD5(){ return "895f7e437a9a6dd225316872b187a303"; };
+
+ };
+
+ class GetPointMapROIResponse : public ros::Msg
+ {
+ public:
+ typedef sensor_msgs::PointCloud2 _sub_map_type;
+ _sub_map_type sub_map;
+
+ GetPointMapROIResponse():
+ sub_map()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->sub_map.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->sub_map.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETPOINTMAPROI; };
+ const char * getMD5(){ return "313769f8b0e724525c6463336cbccd63"; };
+
+ };
+
+ class GetPointMapROI {
+ public:
+ typedef GetPointMapROIRequest Request;
+ typedef GetPointMapROIResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/OccupancyGridUpdate.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,156 @@
+#ifndef _ROS_map_msgs_OccupancyGridUpdate_h
+#define _ROS_map_msgs_OccupancyGridUpdate_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace map_msgs
+{
+
+ class OccupancyGridUpdate : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef int32_t _x_type;
+ _x_type x;
+ typedef int32_t _y_type;
+ _y_type y;
+ typedef uint32_t _width_type;
+ _width_type width;
+ typedef uint32_t _height_type;
+ _height_type height;
+ uint32_t data_length;
+ typedef int8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ OccupancyGridUpdate():
+ header(),
+ x(0),
+ y(0),
+ width(0),
+ height(0),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y);
+ *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->width);
+ *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->height);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ this->width = ((uint32_t) (*(inbuffer + offset)));
+ this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->width);
+ this->height = ((uint32_t) (*(inbuffer + offset)));
+ this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->height);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "map_msgs/OccupancyGridUpdate"; };
+ const char * getMD5(){ return "b295be292b335c34718bd939deebe1c9"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/PointCloud2Update.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,65 @@
+#ifndef _ROS_map_msgs_PointCloud2Update_h
+#define _ROS_map_msgs_PointCloud2Update_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "sensor_msgs/PointCloud2.h"
+
+namespace map_msgs
+{
+
+ class PointCloud2Update : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint32_t _type_type;
+ _type_type type;
+ typedef sensor_msgs::PointCloud2 _points_type;
+ _points_type points;
+ enum { ADD = 0 };
+ enum { DELETE = 1 };
+
+ PointCloud2Update():
+ header(),
+ type(0),
+ points()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->type >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->type >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->type >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->type);
+ offset += this->points.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->type = ((uint32_t) (*(inbuffer + offset)));
+ this->type |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->type |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->type |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->type);
+ offset += this->points.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "map_msgs/PointCloud2Update"; };
+ const char * getMD5(){ return "6c58e4f249ae9cd2b24fb1ee0f99195e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/ProjectedMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_map_msgs_ProjectedMap_h
+#define _ROS_map_msgs_ProjectedMap_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "nav_msgs/OccupancyGrid.h"
+
+namespace map_msgs
+{
+
+ class ProjectedMap : public ros::Msg
+ {
+ public:
+ typedef nav_msgs::OccupancyGrid _map_type;
+ _map_type map;
+ typedef double _min_z_type;
+ _min_z_type min_z;
+ typedef double _max_z_type;
+ _max_z_type max_z;
+
+ ProjectedMap():
+ map(),
+ min_z(0),
+ max_z(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->map.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_min_z;
+ u_min_z.real = this->min_z;
+ *(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->min_z);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_z;
+ u_max_z.real = this->max_z;
+ *(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->max_z);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->map.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_min_z;
+ u_min_z.base = 0;
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->min_z = u_min_z.real;
+ offset += sizeof(this->min_z);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_z;
+ u_max_z.base = 0;
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->max_z = u_max_z.real;
+ offset += sizeof(this->max_z);
+ return offset;
+ }
+
+ const char * getType(){ return "map_msgs/ProjectedMap"; };
+ const char * getMD5(){ return "7bbe8f96e45089681dc1ea7d023cbfca"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/ProjectedMapInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,247 @@
+#ifndef _ROS_map_msgs_ProjectedMapInfo_h
+#define _ROS_map_msgs_ProjectedMapInfo_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace map_msgs
+{
+
+ class ProjectedMapInfo : public ros::Msg
+ {
+ public:
+ typedef const char* _frame_id_type;
+ _frame_id_type frame_id;
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+ typedef double _width_type;
+ _width_type width;
+ typedef double _height_type;
+ _height_type height;
+ typedef double _min_z_type;
+ _min_z_type min_z;
+ typedef double _max_z_type;
+ _max_z_type max_z;
+
+ ProjectedMapInfo():
+ frame_id(""),
+ x(0),
+ y(0),
+ width(0),
+ height(0),
+ min_z(0),
+ max_z(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_frame_id = strlen(this->frame_id);
+ varToArr(outbuffer + offset, length_frame_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->frame_id, length_frame_id);
+ offset += length_frame_id;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_width;
+ u_width.real = this->width;
+ *(outbuffer + offset + 0) = (u_width.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_width.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_width.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_width.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_width.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_width.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_width.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_width.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->width);
+ union {
+ double real;
+ uint64_t base;
+ } u_height;
+ u_height.real = this->height;
+ *(outbuffer + offset + 0) = (u_height.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_height.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_height.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_height.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_height.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_height.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_height.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_height.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->height);
+ union {
+ double real;
+ uint64_t base;
+ } u_min_z;
+ u_min_z.real = this->min_z;
+ *(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->min_z);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_z;
+ u_max_z.real = this->max_z;
+ *(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->max_z);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_frame_id;
+ arrToVar(length_frame_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_frame_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_frame_id-1]=0;
+ this->frame_id = (char *)(inbuffer + offset-1);
+ offset += length_frame_id;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ double real;
+ uint64_t base;
+ } u_width;
+ u_width.base = 0;
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_width.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->width = u_width.real;
+ offset += sizeof(this->width);
+ union {
+ double real;
+ uint64_t base;
+ } u_height;
+ u_height.base = 0;
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_height.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->height = u_height.real;
+ offset += sizeof(this->height);
+ union {
+ double real;
+ uint64_t base;
+ } u_min_z;
+ u_min_z.base = 0;
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->min_z = u_min_z.real;
+ offset += sizeof(this->min_z);
+ union {
+ double real;
+ uint64_t base;
+ } u_max_z;
+ u_max_z.base = 0;
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->max_z = u_max_z.real;
+ offset += sizeof(this->max_z);
+ return offset;
+ }
+
+ const char * getType(){ return "map_msgs/ProjectedMapInfo"; };
+ const char * getMD5(){ return "2dc10595ae94de23f22f8a6d2a0eef7a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/ProjectedMapsInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_SERVICE_ProjectedMapsInfo_h
+#define _ROS_SERVICE_ProjectedMapsInfo_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "map_msgs/ProjectedMapInfo.h"
+
+namespace map_msgs
+{
+
+static const char PROJECTEDMAPSINFO[] = "map_msgs/ProjectedMapsInfo";
+
+ class ProjectedMapsInfoRequest : public ros::Msg
+ {
+ public:
+ uint32_t projected_maps_info_length;
+ typedef map_msgs::ProjectedMapInfo _projected_maps_info_type;
+ _projected_maps_info_type st_projected_maps_info;
+ _projected_maps_info_type * projected_maps_info;
+
+ ProjectedMapsInfoRequest():
+ projected_maps_info_length(0), projected_maps_info(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->projected_maps_info_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->projected_maps_info_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->projected_maps_info_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->projected_maps_info_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->projected_maps_info_length);
+ for( uint32_t i = 0; i < projected_maps_info_length; i++){
+ offset += this->projected_maps_info[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t projected_maps_info_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->projected_maps_info_length);
+ if(projected_maps_info_lengthT > projected_maps_info_length)
+ this->projected_maps_info = (map_msgs::ProjectedMapInfo*)realloc(this->projected_maps_info, projected_maps_info_lengthT * sizeof(map_msgs::ProjectedMapInfo));
+ projected_maps_info_length = projected_maps_info_lengthT;
+ for( uint32_t i = 0; i < projected_maps_info_length; i++){
+ offset += this->st_projected_maps_info.deserialize(inbuffer + offset);
+ memcpy( &(this->projected_maps_info[i]), &(this->st_projected_maps_info), sizeof(map_msgs::ProjectedMapInfo));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return PROJECTEDMAPSINFO; };
+ const char * getMD5(){ return "d7980a33202421c8cd74565e57a4d229"; };
+
+ };
+
+ class ProjectedMapsInfoResponse : public ros::Msg
+ {
+ public:
+
+ ProjectedMapsInfoResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return PROJECTEDMAPSINFO; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class ProjectedMapsInfo {
+ public:
+ typedef ProjectedMapsInfoRequest Request;
+ typedef ProjectedMapsInfoResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/SaveMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+#ifndef _ROS_SERVICE_SaveMap_h
+#define _ROS_SERVICE_SaveMap_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/String.h"
+
+namespace map_msgs
+{
+
+static const char SAVEMAP[] = "map_msgs/SaveMap";
+
+ class SaveMapRequest : public ros::Msg
+ {
+ public:
+ typedef std_msgs::String _filename_type;
+ _filename_type filename;
+
+ SaveMapRequest():
+ filename()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->filename.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->filename.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return SAVEMAP; };
+ const char * getMD5(){ return "716e25f9d9dc76ceba197f93cbf05dc7"; };
+
+ };
+
+ class SaveMapResponse : public ros::Msg
+ {
+ public:
+
+ SaveMapResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return SAVEMAP; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class SaveMap {
+ public:
+ typedef SaveMapRequest Request;
+ typedef SaveMapResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/map_msgs/SetMapProjections.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_SERVICE_SetMapProjections_h
+#define _ROS_SERVICE_SetMapProjections_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "map_msgs/ProjectedMapInfo.h"
+
+namespace map_msgs
+{
+
+static const char SETMAPPROJECTIONS[] = "map_msgs/SetMapProjections";
+
+ class SetMapProjectionsRequest : public ros::Msg
+ {
+ public:
+
+ SetMapProjectionsRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return SETMAPPROJECTIONS; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class SetMapProjectionsResponse : public ros::Msg
+ {
+ public:
+ uint32_t projected_maps_info_length;
+ typedef map_msgs::ProjectedMapInfo _projected_maps_info_type;
+ _projected_maps_info_type st_projected_maps_info;
+ _projected_maps_info_type * projected_maps_info;
+
+ SetMapProjectionsResponse():
+ projected_maps_info_length(0), projected_maps_info(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->projected_maps_info_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->projected_maps_info_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->projected_maps_info_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->projected_maps_info_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->projected_maps_info_length);
+ for( uint32_t i = 0; i < projected_maps_info_length; i++){
+ offset += this->projected_maps_info[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t projected_maps_info_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->projected_maps_info_length);
+ if(projected_maps_info_lengthT > projected_maps_info_length)
+ this->projected_maps_info = (map_msgs::ProjectedMapInfo*)realloc(this->projected_maps_info, projected_maps_info_lengthT * sizeof(map_msgs::ProjectedMapInfo));
+ projected_maps_info_length = projected_maps_info_lengthT;
+ for( uint32_t i = 0; i < projected_maps_info_length; i++){
+ offset += this->st_projected_maps_info.deserialize(inbuffer + offset);
+ memcpy( &(this->projected_maps_info[i]), &(this->st_projected_maps_info), sizeof(map_msgs::ProjectedMapInfo));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return SETMAPPROJECTIONS; };
+ const char * getMD5(){ return "d7980a33202421c8cd74565e57a4d229"; };
+
+ };
+
+ class SetMapProjections {
+ public:
+ typedef SetMapProjectionsRequest Request;
+ typedef SetMapProjectionsResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/Actuators.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,200 @@
+#ifndef _ROS_mav_msgs_Actuators_h
+#define _ROS_mav_msgs_Actuators_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mav_msgs
+{
+
+ class Actuators : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t angles_length;
+ typedef double _angles_type;
+ _angles_type st_angles;
+ _angles_type * angles;
+ uint32_t angular_velocities_length;
+ typedef double _angular_velocities_type;
+ _angular_velocities_type st_angular_velocities;
+ _angular_velocities_type * angular_velocities;
+ uint32_t normalized_length;
+ typedef double _normalized_type;
+ _normalized_type st_normalized;
+ _normalized_type * normalized;
+
+ Actuators():
+ header(),
+ angles_length(0), angles(NULL),
+ angular_velocities_length(0), angular_velocities(NULL),
+ normalized_length(0), normalized(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->angles_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->angles_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->angles_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->angles_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angles_length);
+ for( uint32_t i = 0; i < angles_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_anglesi;
+ u_anglesi.real = this->angles[i];
+ *(outbuffer + offset + 0) = (u_anglesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_anglesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_anglesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_anglesi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_anglesi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_anglesi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_anglesi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_anglesi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->angles[i]);
+ }
+ *(outbuffer + offset + 0) = (this->angular_velocities_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->angular_velocities_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->angular_velocities_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->angular_velocities_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angular_velocities_length);
+ for( uint32_t i = 0; i < angular_velocities_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_angular_velocitiesi;
+ u_angular_velocitiesi.real = this->angular_velocities[i];
+ *(outbuffer + offset + 0) = (u_angular_velocitiesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angular_velocitiesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angular_velocitiesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angular_velocitiesi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_angular_velocitiesi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_angular_velocitiesi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_angular_velocitiesi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_angular_velocitiesi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->angular_velocities[i]);
+ }
+ *(outbuffer + offset + 0) = (this->normalized_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->normalized_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->normalized_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->normalized_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->normalized_length);
+ for( uint32_t i = 0; i < normalized_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_normalizedi;
+ u_normalizedi.real = this->normalized[i];
+ *(outbuffer + offset + 0) = (u_normalizedi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_normalizedi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_normalizedi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_normalizedi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_normalizedi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_normalizedi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_normalizedi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_normalizedi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->normalized[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t angles_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->angles_length);
+ if(angles_lengthT > angles_length)
+ this->angles = (double*)realloc(this->angles, angles_lengthT * sizeof(double));
+ angles_length = angles_lengthT;
+ for( uint32_t i = 0; i < angles_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_angles;
+ u_st_angles.base = 0;
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_angles.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_angles = u_st_angles.real;
+ offset += sizeof(this->st_angles);
+ memcpy( &(this->angles[i]), &(this->st_angles), sizeof(double));
+ }
+ uint32_t angular_velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ angular_velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ angular_velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ angular_velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->angular_velocities_length);
+ if(angular_velocities_lengthT > angular_velocities_length)
+ this->angular_velocities = (double*)realloc(this->angular_velocities, angular_velocities_lengthT * sizeof(double));
+ angular_velocities_length = angular_velocities_lengthT;
+ for( uint32_t i = 0; i < angular_velocities_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_angular_velocities;
+ u_st_angular_velocities.base = 0;
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_angular_velocities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_angular_velocities = u_st_angular_velocities.real;
+ offset += sizeof(this->st_angular_velocities);
+ memcpy( &(this->angular_velocities[i]), &(this->st_angular_velocities), sizeof(double));
+ }
+ uint32_t normalized_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ normalized_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ normalized_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ normalized_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->normalized_length);
+ if(normalized_lengthT > normalized_length)
+ this->normalized = (double*)realloc(this->normalized, normalized_lengthT * sizeof(double));
+ normalized_length = normalized_lengthT;
+ for( uint32_t i = 0; i < normalized_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_normalized;
+ u_st_normalized.base = 0;
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_normalized.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_normalized = u_st_normalized.real;
+ offset += sizeof(this->st_normalized);
+ memcpy( &(this->normalized[i]), &(this->st_normalized), sizeof(double));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/Actuators"; };
+ const char * getMD5(){ return "25741daf38ed25442e3a66a855ee8d9c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/AttitudeThrust.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_mav_msgs_AttitudeThrust_h
+#define _ROS_mav_msgs_AttitudeThrust_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Quaternion.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mav_msgs
+{
+
+ class AttitudeThrust : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Quaternion _attitude_type;
+ _attitude_type attitude;
+ typedef geometry_msgs::Vector3 _thrust_type;
+ _thrust_type thrust;
+
+ AttitudeThrust():
+ header(),
+ attitude(),
+ thrust()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->attitude.serialize(outbuffer + offset);
+ offset += this->thrust.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->attitude.deserialize(inbuffer + offset);
+ offset += this->thrust.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/AttitudeThrust"; };
+ const char * getMD5(){ return "7cee443b02735e42bda0ad5910302718"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/FilteredSensorData.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,92 @@
+#ifndef _ROS_mav_msgs_FilteredSensorData_h
+#define _ROS_mav_msgs_FilteredSensorData_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mav_msgs
+{
+
+ class FilteredSensorData : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Vector3 _accelerometer_type;
+ _accelerometer_type accelerometer;
+ typedef geometry_msgs::Vector3 _gyroscope_type;
+ _gyroscope_type gyroscope;
+ typedef geometry_msgs::Vector3 _magnetometer_type;
+ _magnetometer_type magnetometer;
+ typedef double _barometer_type;
+ _barometer_type barometer;
+
+ FilteredSensorData():
+ header(),
+ accelerometer(),
+ gyroscope(),
+ magnetometer(),
+ barometer(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->accelerometer.serialize(outbuffer + offset);
+ offset += this->gyroscope.serialize(outbuffer + offset);
+ offset += this->magnetometer.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_barometer;
+ u_barometer.real = this->barometer;
+ *(outbuffer + offset + 0) = (u_barometer.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_barometer.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_barometer.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_barometer.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_barometer.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_barometer.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_barometer.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_barometer.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->barometer);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->accelerometer.deserialize(inbuffer + offset);
+ offset += this->gyroscope.deserialize(inbuffer + offset);
+ offset += this->magnetometer.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_barometer;
+ u_barometer.base = 0;
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_barometer.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->barometer = u_barometer.real;
+ offset += sizeof(this->barometer);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/FilteredSensorData"; };
+ const char * getMD5(){ return "a9b51fae1f4ed3a8a0522b4ffe61659f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/GpsWaypoint.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,236 @@
+#ifndef _ROS_mav_msgs_GpsWaypoint_h
+#define _ROS_mav_msgs_GpsWaypoint_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mav_msgs
+{
+
+ class GpsWaypoint : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _latitude_type;
+ _latitude_type latitude;
+ typedef double _longitude_type;
+ _longitude_type longitude;
+ typedef double _altitude_type;
+ _altitude_type altitude;
+ typedef double _heading_type;
+ _heading_type heading;
+ typedef double _maxSpeed_type;
+ _maxSpeed_type maxSpeed;
+ typedef double _maxAcc_type;
+ _maxAcc_type maxAcc;
+
+ GpsWaypoint():
+ header(),
+ latitude(0),
+ longitude(0),
+ altitude(0),
+ heading(0),
+ maxSpeed(0),
+ maxAcc(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->longitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_altitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_altitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_altitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_altitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->altitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_heading;
+ u_heading.real = this->heading;
+ *(outbuffer + offset + 0) = (u_heading.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_heading.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_heading.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_heading.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_heading.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_heading.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_heading.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_heading.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->heading);
+ union {
+ double real;
+ uint64_t base;
+ } u_maxSpeed;
+ u_maxSpeed.real = this->maxSpeed;
+ *(outbuffer + offset + 0) = (u_maxSpeed.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_maxSpeed.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_maxSpeed.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_maxSpeed.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_maxSpeed.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_maxSpeed.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_maxSpeed.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_maxSpeed.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->maxSpeed);
+ union {
+ double real;
+ uint64_t base;
+ } u_maxAcc;
+ u_maxAcc.real = this->maxAcc;
+ *(outbuffer + offset + 0) = (u_maxAcc.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_maxAcc.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_maxAcc.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_maxAcc.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_maxAcc.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_maxAcc.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_maxAcc.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_maxAcc.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->maxAcc);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_heading;
+ u_heading.base = 0;
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_heading.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->heading = u_heading.real;
+ offset += sizeof(this->heading);
+ union {
+ double real;
+ uint64_t base;
+ } u_maxSpeed;
+ u_maxSpeed.base = 0;
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_maxSpeed.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->maxSpeed = u_maxSpeed.real;
+ offset += sizeof(this->maxSpeed);
+ union {
+ double real;
+ uint64_t base;
+ } u_maxAcc;
+ u_maxAcc.base = 0;
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_maxAcc.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->maxAcc = u_maxAcc.real;
+ offset += sizeof(this->maxAcc);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/GpsWaypoint"; };
+ const char * getMD5(){ return "61c3751c96f3b418f93879727f9a070a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/RateThrust.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,55 @@
+#ifndef _ROS_mav_msgs_RateThrust_h
+#define _ROS_mav_msgs_RateThrust_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mav_msgs
+{
+
+ class RateThrust : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Vector3 _angular_rates_type;
+ _angular_rates_type angular_rates;
+ typedef geometry_msgs::Vector3 _thrust_type;
+ _thrust_type thrust;
+
+ RateThrust():
+ header(),
+ angular_rates(),
+ thrust()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->angular_rates.serialize(outbuffer + offset);
+ offset += this->thrust.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->angular_rates.deserialize(inbuffer + offset);
+ offset += this->thrust.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/RateThrust"; };
+ const char * getMD5(){ return "119c5bf883bef42350d52ce5a7927c7c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/RollPitchYawrateThrust.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,146 @@
+#ifndef _ROS_mav_msgs_RollPitchYawrateThrust_h
+#define _ROS_mav_msgs_RollPitchYawrateThrust_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mav_msgs
+{
+
+ class RollPitchYawrateThrust : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _roll_type;
+ _roll_type roll;
+ typedef double _pitch_type;
+ _pitch_type pitch;
+ typedef double _yaw_rate_type;
+ _yaw_rate_type yaw_rate;
+ typedef geometry_msgs::Vector3 _thrust_type;
+ _thrust_type thrust;
+
+ RollPitchYawrateThrust():
+ header(),
+ roll(0),
+ pitch(0),
+ yaw_rate(0),
+ thrust()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_roll;
+ u_roll.real = this->roll;
+ *(outbuffer + offset + 0) = (u_roll.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_roll.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_roll.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_roll.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_roll.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_roll.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_roll.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_roll.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->roll);
+ union {
+ double real;
+ uint64_t base;
+ } u_pitch;
+ u_pitch.real = this->pitch;
+ *(outbuffer + offset + 0) = (u_pitch.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_pitch.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_pitch.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_pitch.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_pitch.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_pitch.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_pitch.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_pitch.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->pitch);
+ union {
+ double real;
+ uint64_t base;
+ } u_yaw_rate;
+ u_yaw_rate.real = this->yaw_rate;
+ *(outbuffer + offset + 0) = (u_yaw_rate.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw_rate.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw_rate.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw_rate.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_yaw_rate.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_yaw_rate.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_yaw_rate.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_yaw_rate.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->yaw_rate);
+ offset += this->thrust.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_roll;
+ u_roll.base = 0;
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_roll.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->roll = u_roll.real;
+ offset += sizeof(this->roll);
+ union {
+ double real;
+ uint64_t base;
+ } u_pitch;
+ u_pitch.base = 0;
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_pitch.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->pitch = u_pitch.real;
+ offset += sizeof(this->pitch);
+ union {
+ double real;
+ uint64_t base;
+ } u_yaw_rate;
+ u_yaw_rate.base = 0;
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_yaw_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->yaw_rate = u_yaw_rate.real;
+ offset += sizeof(this->yaw_rate);
+ offset += this->thrust.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/RollPitchYawrateThrust"; };
+ const char * getMD5(){ return "10a56a30857affade0889a3662fc2bc9"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/Status.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,294 @@
+#ifndef _ROS_mav_msgs_Status_h
+#define _ROS_mav_msgs_Status_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mav_msgs
+{
+
+ class Status : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _vehicle_name_type;
+ _vehicle_name_type vehicle_name;
+ typedef const char* _vehicle_type_type;
+ _vehicle_type_type vehicle_type;
+ typedef float _battery_voltage_type;
+ _battery_voltage_type battery_voltage;
+ typedef const char* _rc_command_mode_type;
+ _rc_command_mode_type rc_command_mode;
+ typedef bool _command_interface_enabled_type;
+ _command_interface_enabled_type command_interface_enabled;
+ typedef float _flight_time_type;
+ _flight_time_type flight_time;
+ typedef float _system_uptime_type;
+ _system_uptime_type system_uptime;
+ typedef float _cpu_load_type;
+ _cpu_load_type cpu_load;
+ typedef const char* _motor_status_type;
+ _motor_status_type motor_status;
+ typedef bool _in_air_type;
+ _in_air_type in_air;
+ typedef const char* _gps_status_type;
+ _gps_status_type gps_status;
+ typedef int32_t _gps_num_satellites_type;
+ _gps_num_satellites_type gps_num_satellites;
+ enum { RC_COMMAND_ATTITUDE = "attitude_thrust" };
+ enum { RC_COMMAND_ATTITUDE_HEIGHT = "attitude_height" };
+ enum { RC_COMMAND_POSITION = "position" };
+ enum { MOTOR_STATUS_RUNNING = "running" };
+ enum { MOTOR_STATUS_STOPPED = "stopped" };
+ enum { MOTOR_STATUS_STARTING = "starting" };
+ enum { MOTOR_STATUS_STOPPING = "stopping" };
+ enum { GPS_STATUS_LOCK = "lock" };
+ enum { GPS_STATUS_NO_LOCK = "no_lock" };
+
+ Status():
+ header(),
+ vehicle_name(""),
+ vehicle_type(""),
+ battery_voltage(0),
+ rc_command_mode(""),
+ command_interface_enabled(0),
+ flight_time(0),
+ system_uptime(0),
+ cpu_load(0),
+ motor_status(""),
+ in_air(0),
+ gps_status(""),
+ gps_num_satellites(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_vehicle_name = strlen(this->vehicle_name);
+ varToArr(outbuffer + offset, length_vehicle_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->vehicle_name, length_vehicle_name);
+ offset += length_vehicle_name;
+ uint32_t length_vehicle_type = strlen(this->vehicle_type);
+ varToArr(outbuffer + offset, length_vehicle_type);
+ offset += 4;
+ memcpy(outbuffer + offset, this->vehicle_type, length_vehicle_type);
+ offset += length_vehicle_type;
+ union {
+ float real;
+ uint32_t base;
+ } u_battery_voltage;
+ u_battery_voltage.real = this->battery_voltage;
+ *(outbuffer + offset + 0) = (u_battery_voltage.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_battery_voltage.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_battery_voltage.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_battery_voltage.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->battery_voltage);
+ uint32_t length_rc_command_mode = strlen(this->rc_command_mode);
+ varToArr(outbuffer + offset, length_rc_command_mode);
+ offset += 4;
+ memcpy(outbuffer + offset, this->rc_command_mode, length_rc_command_mode);
+ offset += length_rc_command_mode;
+ union {
+ bool real;
+ uint8_t base;
+ } u_command_interface_enabled;
+ u_command_interface_enabled.real = this->command_interface_enabled;
+ *(outbuffer + offset + 0) = (u_command_interface_enabled.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->command_interface_enabled);
+ union {
+ float real;
+ uint32_t base;
+ } u_flight_time;
+ u_flight_time.real = this->flight_time;
+ *(outbuffer + offset + 0) = (u_flight_time.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_flight_time.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_flight_time.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_flight_time.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->flight_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_system_uptime;
+ u_system_uptime.real = this->system_uptime;
+ *(outbuffer + offset + 0) = (u_system_uptime.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_system_uptime.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_system_uptime.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_system_uptime.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->system_uptime);
+ union {
+ float real;
+ uint32_t base;
+ } u_cpu_load;
+ u_cpu_load.real = this->cpu_load;
+ *(outbuffer + offset + 0) = (u_cpu_load.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_cpu_load.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_cpu_load.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_cpu_load.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->cpu_load);
+ uint32_t length_motor_status = strlen(this->motor_status);
+ varToArr(outbuffer + offset, length_motor_status);
+ offset += 4;
+ memcpy(outbuffer + offset, this->motor_status, length_motor_status);
+ offset += length_motor_status;
+ union {
+ bool real;
+ uint8_t base;
+ } u_in_air;
+ u_in_air.real = this->in_air;
+ *(outbuffer + offset + 0) = (u_in_air.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->in_air);
+ uint32_t length_gps_status = strlen(this->gps_status);
+ varToArr(outbuffer + offset, length_gps_status);
+ offset += 4;
+ memcpy(outbuffer + offset, this->gps_status, length_gps_status);
+ offset += length_gps_status;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_gps_num_satellites;
+ u_gps_num_satellites.real = this->gps_num_satellites;
+ *(outbuffer + offset + 0) = (u_gps_num_satellites.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_gps_num_satellites.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_gps_num_satellites.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_gps_num_satellites.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->gps_num_satellites);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_vehicle_name;
+ arrToVar(length_vehicle_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_vehicle_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_vehicle_name-1]=0;
+ this->vehicle_name = (char *)(inbuffer + offset-1);
+ offset += length_vehicle_name;
+ uint32_t length_vehicle_type;
+ arrToVar(length_vehicle_type, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_vehicle_type; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_vehicle_type-1]=0;
+ this->vehicle_type = (char *)(inbuffer + offset-1);
+ offset += length_vehicle_type;
+ union {
+ float real;
+ uint32_t base;
+ } u_battery_voltage;
+ u_battery_voltage.base = 0;
+ u_battery_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_battery_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_battery_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_battery_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->battery_voltage = u_battery_voltage.real;
+ offset += sizeof(this->battery_voltage);
+ uint32_t length_rc_command_mode;
+ arrToVar(length_rc_command_mode, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_rc_command_mode; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_rc_command_mode-1]=0;
+ this->rc_command_mode = (char *)(inbuffer + offset-1);
+ offset += length_rc_command_mode;
+ union {
+ bool real;
+ uint8_t base;
+ } u_command_interface_enabled;
+ u_command_interface_enabled.base = 0;
+ u_command_interface_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->command_interface_enabled = u_command_interface_enabled.real;
+ offset += sizeof(this->command_interface_enabled);
+ union {
+ float real;
+ uint32_t base;
+ } u_flight_time;
+ u_flight_time.base = 0;
+ u_flight_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_flight_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_flight_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_flight_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->flight_time = u_flight_time.real;
+ offset += sizeof(this->flight_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_system_uptime;
+ u_system_uptime.base = 0;
+ u_system_uptime.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_system_uptime.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_system_uptime.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_system_uptime.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->system_uptime = u_system_uptime.real;
+ offset += sizeof(this->system_uptime);
+ union {
+ float real;
+ uint32_t base;
+ } u_cpu_load;
+ u_cpu_load.base = 0;
+ u_cpu_load.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_cpu_load.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_cpu_load.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_cpu_load.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->cpu_load = u_cpu_load.real;
+ offset += sizeof(this->cpu_load);
+ uint32_t length_motor_status;
+ arrToVar(length_motor_status, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_motor_status; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_motor_status-1]=0;
+ this->motor_status = (char *)(inbuffer + offset-1);
+ offset += length_motor_status;
+ union {
+ bool real;
+ uint8_t base;
+ } u_in_air;
+ u_in_air.base = 0;
+ u_in_air.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->in_air = u_in_air.real;
+ offset += sizeof(this->in_air);
+ uint32_t length_gps_status;
+ arrToVar(length_gps_status, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_gps_status; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_gps_status-1]=0;
+ this->gps_status = (char *)(inbuffer + offset-1);
+ offset += length_gps_status;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_gps_num_satellites;
+ u_gps_num_satellites.base = 0;
+ u_gps_num_satellites.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_gps_num_satellites.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_gps_num_satellites.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_gps_num_satellites.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->gps_num_satellites = u_gps_num_satellites.real;
+ offset += sizeof(this->gps_num_satellites);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/Status"; };
+ const char * getMD5(){ return "e191265664a5f7c1871338dc13be0958"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_msgs/TorqueThrust.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,55 @@
+#ifndef _ROS_mav_msgs_TorqueThrust_h
+#define _ROS_mav_msgs_TorqueThrust_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mav_msgs
+{
+
+ class TorqueThrust : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Vector3 _torque_type;
+ _torque_type torque;
+ typedef geometry_msgs::Vector3 _thrust_type;
+ _thrust_type thrust;
+
+ TorqueThrust():
+ header(),
+ torque(),
+ thrust()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->torque.serialize(outbuffer + offset);
+ offset += this->thrust.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->torque.deserialize(inbuffer + offset);
+ offset += this->thrust.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_msgs/TorqueThrust"; };
+ const char * getMD5(){ return "81293743ae52683b61e39c21bc0b30db"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/PlannerService.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,127 @@
+#ifndef _ROS_SERVICE_PlannerService_h
+#define _ROS_SERVICE_PlannerService_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/PoseStamped.h"
+#include "trajectory_msgs/MultiDOFJointTrajectory.h"
+#include "geometry_msgs/Vector3.h"
+#include "mav_planning_msgs/PolynomialTrajectory4D.h"
+
+namespace mav_planning_msgs
+{
+
+static const char PLANNERSERVICE[] = "mav_planning_msgs/PlannerService";
+
+ class PlannerServiceRequest : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::PoseStamped _start_pose_type;
+ _start_pose_type start_pose;
+ typedef geometry_msgs::Vector3 _start_velocity_type;
+ _start_velocity_type start_velocity;
+ typedef geometry_msgs::PoseStamped _goal_pose_type;
+ _goal_pose_type goal_pose;
+ typedef geometry_msgs::Vector3 _goal_velocity_type;
+ _goal_velocity_type goal_velocity;
+ typedef geometry_msgs::Vector3 _bounding_box_type;
+ _bounding_box_type bounding_box;
+
+ PlannerServiceRequest():
+ start_pose(),
+ start_velocity(),
+ goal_pose(),
+ goal_velocity(),
+ bounding_box()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->start_pose.serialize(outbuffer + offset);
+ offset += this->start_velocity.serialize(outbuffer + offset);
+ offset += this->goal_pose.serialize(outbuffer + offset);
+ offset += this->goal_velocity.serialize(outbuffer + offset);
+ offset += this->bounding_box.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->start_pose.deserialize(inbuffer + offset);
+ offset += this->start_velocity.deserialize(inbuffer + offset);
+ offset += this->goal_pose.deserialize(inbuffer + offset);
+ offset += this->goal_velocity.deserialize(inbuffer + offset);
+ offset += this->bounding_box.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return PLANNERSERVICE; };
+ const char * getMD5(){ return "6090fe8ab3df1362b8c26859b8850940"; };
+
+ };
+
+ class PlannerServiceResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef mav_planning_msgs::PolynomialTrajectory4D _polynomial_plan_type;
+ _polynomial_plan_type polynomial_plan;
+ typedef trajectory_msgs::MultiDOFJointTrajectory _sampled_plan_type;
+ _sampled_plan_type sampled_plan;
+
+ PlannerServiceResponse():
+ success(0),
+ polynomial_plan(),
+ sampled_plan()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ offset += this->polynomial_plan.serialize(outbuffer + offset);
+ offset += this->sampled_plan.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ offset += this->polynomial_plan.deserialize(inbuffer + offset);
+ offset += this->sampled_plan.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return PLANNERSERVICE; };
+ const char * getMD5(){ return "2b0f390ba4c264f0182acc6839f4d8b4"; };
+
+ };
+
+ class PlannerService {
+ public:
+ typedef PlannerServiceRequest Request;
+ typedef PlannerServiceResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/Point2D.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,102 @@
+#ifndef _ROS_mav_planning_msgs_Point2D_h
+#define _ROS_mav_planning_msgs_Point2D_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mav_planning_msgs
+{
+
+ class Point2D : public ros::Msg
+ {
+ public:
+ typedef double _x_type;
+ _x_type x;
+ typedef double _y_type;
+ _y_type y;
+
+ Point2D():
+ x(0),
+ y(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ double real;
+ uint64_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_planning_msgs/Point2D"; };
+ const char * getMD5(){ return "209f516d3eb691f0663e25cb750d67c1"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/PointCloudWithPose.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_mav_planning_msgs_PointCloudWithPose_h
+#define _ROS_mav_planning_msgs_PointCloudWithPose_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/TransformStamped.h"
+#include "sensor_msgs/PointCloud2.h"
+
+namespace mav_planning_msgs
+{
+
+ class PointCloudWithPose : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::TransformStamped _sensor_pose_type;
+ _sensor_pose_type sensor_pose;
+ typedef sensor_msgs::PointCloud2 _cloud_in_sensor_frame_type;
+ _cloud_in_sensor_frame_type cloud_in_sensor_frame;
+
+ PointCloudWithPose():
+ header(),
+ sensor_pose(),
+ cloud_in_sensor_frame()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->sensor_pose.serialize(outbuffer + offset);
+ offset += this->cloud_in_sensor_frame.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->sensor_pose.deserialize(inbuffer + offset);
+ offset += this->cloud_in_sensor_frame.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_planning_msgs/PointCloudWithPose"; };
+ const char * getMD5(){ return "2a8b498d41262fbae6e2ab39e0965442"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/Polygon2D.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,64 @@
+#ifndef _ROS_mav_planning_msgs_Polygon2D_h
+#define _ROS_mav_planning_msgs_Polygon2D_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mav_planning_msgs/Point2D.h"
+
+namespace mav_planning_msgs
+{
+
+ class Polygon2D : public ros::Msg
+ {
+ public:
+ uint32_t points_length;
+ typedef mav_planning_msgs::Point2D _points_type;
+ _points_type st_points;
+ _points_type * points;
+
+ Polygon2D():
+ points_length(0), points(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (mav_planning_msgs::Point2D*)realloc(this->points, points_lengthT * sizeof(mav_planning_msgs::Point2D));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(mav_planning_msgs::Point2D));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mav_planning_msgs/Polygon2D"; };
+ const char * getMD5(){ return "8f02263beef99aa03117a577a3eb879d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/PolygonService.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,94 @@
+#ifndef _ROS_SERVICE_PolygonService_h
+#define _ROS_SERVICE_PolygonService_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mav_planning_msgs/PolygonWithHolesStamped.h"
+
+namespace mav_planning_msgs
+{
+
+static const char POLYGONSERVICE[] = "mav_planning_msgs/PolygonService";
+
+ class PolygonServiceRequest : public ros::Msg
+ {
+ public:
+ typedef mav_planning_msgs::PolygonWithHolesStamped _polygon_type;
+ _polygon_type polygon;
+
+ PolygonServiceRequest():
+ polygon()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->polygon.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->polygon.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return POLYGONSERVICE; };
+ const char * getMD5(){ return "b72bf7542ebf0f998ff6de9ed6f90873"; };
+
+ };
+
+ class PolygonServiceResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ PolygonServiceResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return POLYGONSERVICE; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class PolygonService {
+ public:
+ typedef PolygonServiceRequest Request;
+ typedef PolygonServiceResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/PolygonWithHoles.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,69 @@
+#ifndef _ROS_mav_planning_msgs_PolygonWithHoles_h
+#define _ROS_mav_planning_msgs_PolygonWithHoles_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mav_planning_msgs/Polygon2D.h"
+
+namespace mav_planning_msgs
+{
+
+ class PolygonWithHoles : public ros::Msg
+ {
+ public:
+ typedef mav_planning_msgs::Polygon2D _hull_type;
+ _hull_type hull;
+ uint32_t holes_length;
+ typedef mav_planning_msgs::Polygon2D _holes_type;
+ _holes_type st_holes;
+ _holes_type * holes;
+
+ PolygonWithHoles():
+ hull(),
+ holes_length(0), holes(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->hull.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->holes_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->holes_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->holes_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->holes_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->holes_length);
+ for( uint32_t i = 0; i < holes_length; i++){
+ offset += this->holes[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->hull.deserialize(inbuffer + offset);
+ uint32_t holes_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ holes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ holes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ holes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->holes_length);
+ if(holes_lengthT > holes_length)
+ this->holes = (mav_planning_msgs::Polygon2D*)realloc(this->holes, holes_lengthT * sizeof(mav_planning_msgs::Polygon2D));
+ holes_length = holes_lengthT;
+ for( uint32_t i = 0; i < holes_length; i++){
+ offset += this->st_holes.deserialize(inbuffer + offset);
+ memcpy( &(this->holes[i]), &(this->st_holes), sizeof(mav_planning_msgs::Polygon2D));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mav_planning_msgs/PolygonWithHoles"; };
+ const char * getMD5(){ return "df7f266352dfcf3e4d29156dd85febf9"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/PolygonWithHolesStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_mav_planning_msgs_PolygonWithHolesStamped_h
+#define _ROS_mav_planning_msgs_PolygonWithHolesStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "mav_planning_msgs/PolygonWithHoles.h"
+
+namespace mav_planning_msgs
+{
+
+ class PolygonWithHolesStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _altitude_type;
+ _altitude_type altitude;
+ typedef mav_planning_msgs::PolygonWithHoles _polygon_type;
+ _polygon_type polygon;
+
+ PolygonWithHolesStamped():
+ header(),
+ altitude(0),
+ polygon()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_altitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_altitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_altitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_altitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->altitude);
+ offset += this->polygon.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ offset += this->polygon.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "mav_planning_msgs/PolygonWithHolesStamped"; };
+ const char * getMD5(){ return "75e2ac63509c016edab7c5a5ed67059b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/PolynomialSegment4D.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,300 @@
+#ifndef _ROS_mav_planning_msgs_PolynomialSegment4D_h
+#define _ROS_mav_planning_msgs_PolynomialSegment4D_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "ros/duration.h"
+
+namespace mav_planning_msgs
+{
+
+ class PolynomialSegment4D : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef int32_t _num_coeffs_type;
+ _num_coeffs_type num_coeffs;
+ typedef ros::Duration _segment_time_type;
+ _segment_time_type segment_time;
+ uint32_t x_length;
+ typedef double _x_type;
+ _x_type st_x;
+ _x_type * x;
+ uint32_t y_length;
+ typedef double _y_type;
+ _y_type st_y;
+ _y_type * y;
+ uint32_t z_length;
+ typedef double _z_type;
+ _z_type st_z;
+ _z_type * z;
+ uint32_t yaw_length;
+ typedef double _yaw_type;
+ _yaw_type st_yaw;
+ _yaw_type * yaw;
+
+ PolynomialSegment4D():
+ header(),
+ num_coeffs(0),
+ segment_time(),
+ x_length(0), x(NULL),
+ y_length(0), y(NULL),
+ z_length(0), z(NULL),
+ yaw_length(0), yaw(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_num_coeffs;
+ u_num_coeffs.real = this->num_coeffs;
+ *(outbuffer + offset + 0) = (u_num_coeffs.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_num_coeffs.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_num_coeffs.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_num_coeffs.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->num_coeffs);
+ *(outbuffer + offset + 0) = (this->segment_time.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->segment_time.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->segment_time.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->segment_time.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->segment_time.sec);
+ *(outbuffer + offset + 0) = (this->segment_time.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->segment_time.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->segment_time.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->segment_time.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->segment_time.nsec);
+ *(outbuffer + offset + 0) = (this->x_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->x_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->x_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->x_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x_length);
+ for( uint32_t i = 0; i < x_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_xi;
+ u_xi.real = this->x[i];
+ *(outbuffer + offset + 0) = (u_xi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_xi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_xi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_xi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_xi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_xi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_xi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_xi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x[i]);
+ }
+ *(outbuffer + offset + 0) = (this->y_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->y_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->y_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->y_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y_length);
+ for( uint32_t i = 0; i < y_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_yi;
+ u_yi.real = this->y[i];
+ *(outbuffer + offset + 0) = (u_yi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_yi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_yi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_yi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_yi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y[i]);
+ }
+ *(outbuffer + offset + 0) = (this->z_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->z_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->z_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->z_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->z_length);
+ for( uint32_t i = 0; i < z_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_zi;
+ u_zi.real = this->z[i];
+ *(outbuffer + offset + 0) = (u_zi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_zi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_zi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_zi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_zi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_zi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_zi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_zi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->z[i]);
+ }
+ *(outbuffer + offset + 0) = (this->yaw_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->yaw_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->yaw_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->yaw_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw_length);
+ for( uint32_t i = 0; i < yaw_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_yawi;
+ u_yawi.real = this->yaw[i];
+ *(outbuffer + offset + 0) = (u_yawi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yawi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yawi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yawi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_yawi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_yawi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_yawi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_yawi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->yaw[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_num_coeffs;
+ u_num_coeffs.base = 0;
+ u_num_coeffs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_num_coeffs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_num_coeffs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_num_coeffs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->num_coeffs = u_num_coeffs.real;
+ offset += sizeof(this->num_coeffs);
+ this->segment_time.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->segment_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->segment_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->segment_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->segment_time.sec);
+ this->segment_time.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->segment_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->segment_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->segment_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->segment_time.nsec);
+ uint32_t x_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ x_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ x_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ x_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->x_length);
+ if(x_lengthT > x_length)
+ this->x = (double*)realloc(this->x, x_lengthT * sizeof(double));
+ x_length = x_lengthT;
+ for( uint32_t i = 0; i < x_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_x;
+ u_st_x.base = 0;
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_x = u_st_x.real;
+ offset += sizeof(this->st_x);
+ memcpy( &(this->x[i]), &(this->st_x), sizeof(double));
+ }
+ uint32_t y_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ y_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ y_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ y_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->y_length);
+ if(y_lengthT > y_length)
+ this->y = (double*)realloc(this->y, y_lengthT * sizeof(double));
+ y_length = y_lengthT;
+ for( uint32_t i = 0; i < y_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_y;
+ u_st_y.base = 0;
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_y = u_st_y.real;
+ offset += sizeof(this->st_y);
+ memcpy( &(this->y[i]), &(this->st_y), sizeof(double));
+ }
+ uint32_t z_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ z_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ z_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ z_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->z_length);
+ if(z_lengthT > z_length)
+ this->z = (double*)realloc(this->z, z_lengthT * sizeof(double));
+ z_length = z_lengthT;
+ for( uint32_t i = 0; i < z_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_z;
+ u_st_z.base = 0;
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_z = u_st_z.real;
+ offset += sizeof(this->st_z);
+ memcpy( &(this->z[i]), &(this->st_z), sizeof(double));
+ }
+ uint32_t yaw_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ yaw_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ yaw_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ yaw_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->yaw_length);
+ if(yaw_lengthT > yaw_length)
+ this->yaw = (double*)realloc(this->yaw, yaw_lengthT * sizeof(double));
+ yaw_length = yaw_lengthT;
+ for( uint32_t i = 0; i < yaw_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_yaw;
+ u_st_yaw.base = 0;
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_yaw.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_yaw = u_st_yaw.real;
+ offset += sizeof(this->st_yaw);
+ memcpy( &(this->yaw[i]), &(this->st_yaw), sizeof(double));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mav_planning_msgs/PolynomialSegment4D"; };
+ const char * getMD5(){ return "c85fa40c94ff35d242df13d4d3a57809"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mav_planning_msgs/PolynomialTrajectory4D.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_mav_planning_msgs_PolynomialTrajectory4D_h
+#define _ROS_mav_planning_msgs_PolynomialTrajectory4D_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "mav_planning_msgs/PolynomialSegment4D.h"
+
+namespace mav_planning_msgs
+{
+
+ class PolynomialTrajectory4D : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t segments_length;
+ typedef mav_planning_msgs::PolynomialSegment4D _segments_type;
+ _segments_type st_segments;
+ _segments_type * segments;
+
+ PolynomialTrajectory4D():
+ header(),
+ segments_length(0), segments(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->segments_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->segments_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->segments_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->segments_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->segments_length);
+ for( uint32_t i = 0; i < segments_length; i++){
+ offset += this->segments[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t segments_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ segments_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->segments_length);
+ if(segments_lengthT > segments_length)
+ this->segments = (mav_planning_msgs::PolynomialSegment4D*)realloc(this->segments, segments_lengthT * sizeof(mav_planning_msgs::PolynomialSegment4D));
+ segments_length = segments_lengthT;
+ for( uint32_t i = 0; i < segments_length; i++){
+ offset += this->st_segments.deserialize(inbuffer + offset);
+ memcpy( &(this->segments[i]), &(this->st_segments), sizeof(mav_planning_msgs::PolynomialSegment4D));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mav_planning_msgs/PolynomialTrajectory4D"; };
+ const char * getMD5(){ return "4d68d15524ede489eecd674bb6dc3ee8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ADSBVehicle.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,319 @@
+#ifndef _ROS_mavros_msgs_ADSBVehicle_h
+#define _ROS_mavros_msgs_ADSBVehicle_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "ros/duration.h"
+
+namespace mavros_msgs
+{
+
+ class ADSBVehicle : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint32_t _ICAO_address_type;
+ _ICAO_address_type ICAO_address;
+ typedef const char* _callsign_type;
+ _callsign_type callsign;
+ typedef double _latitude_type;
+ _latitude_type latitude;
+ typedef double _longitude_type;
+ _longitude_type longitude;
+ typedef float _altitude_type;
+ _altitude_type altitude;
+ typedef float _heading_type;
+ _heading_type heading;
+ typedef float _hor_velocity_type;
+ _hor_velocity_type hor_velocity;
+ typedef float _ver_velocity_type;
+ _ver_velocity_type ver_velocity;
+ typedef uint8_t _altitude_type_type;
+ _altitude_type_type altitude_type;
+ typedef uint8_t _emitter_type_type;
+ _emitter_type_type emitter_type;
+ typedef ros::Duration _tslc_type;
+ _tslc_type tslc;
+ typedef uint16_t _flags_type;
+ _flags_type flags;
+ typedef uint16_t _squawk_type;
+ _squawk_type squawk;
+ enum { ALT_PRESSURE_QNH = 0 };
+ enum { ALT_GEOMETRIC = 1 };
+ enum { EMITTER_NO_INFO = 0 };
+ enum { EMITTER_LIGHT = 1 };
+ enum { EMITTER_SMALL = 2 };
+ enum { EMITTER_LARGE = 3 };
+ enum { EMITTER_HIGH_VORTEX_LARGE = 4 };
+ enum { EMITTER_HEAVY = 5 };
+ enum { EMITTER_HIGHLY_MANUV = 6 };
+ enum { EMITTER_ROTOCRAFT = 7 };
+ enum { EMITTER_UNASSIGNED = 8 };
+ enum { EMITTER_GLIDER = 9 };
+ enum { EMITTER_LIGHTER_AIR = 10 };
+ enum { EMITTER_PARACHUTE = 11 };
+ enum { EMITTER_ULTRA_LIGHT = 12 };
+ enum { EMITTER_UNASSIGNED2 = 13 };
+ enum { EMITTER_UAV = 14 };
+ enum { EMITTER_SPACE = 15 };
+ enum { EMITTER_UNASSGINED3 = 16 };
+ enum { EMITTER_EMERGENCY_SURFACE = 17 };
+ enum { EMITTER_SERVICE_SURFACE = 18 };
+ enum { EMITTER_POINT_OBSTACLE = 19 };
+ enum { FLAG_VALID_COORDS = 1 };
+ enum { FLAG_VALID_ALTITUDE = 2 };
+ enum { FLAG_VALID_HEADING = 4 };
+ enum { FLAG_VALID_VELOCITY = 8 };
+ enum { FLAG_VALID_CALLSIGN = 16 };
+ enum { FLAG_VALID_SQUAWK = 32 };
+ enum { FLAG_SIMULATED = 64 };
+
+ ADSBVehicle():
+ header(),
+ ICAO_address(0),
+ callsign(""),
+ latitude(0),
+ longitude(0),
+ altitude(0),
+ heading(0),
+ hor_velocity(0),
+ ver_velocity(0),
+ altitude_type(0),
+ emitter_type(0),
+ tslc(),
+ flags(0),
+ squawk(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->ICAO_address >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->ICAO_address >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->ICAO_address >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->ICAO_address >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ICAO_address);
+ uint32_t length_callsign = strlen(this->callsign);
+ varToArr(outbuffer + offset, length_callsign);
+ offset += 4;
+ memcpy(outbuffer + offset, this->callsign, length_callsign);
+ offset += length_callsign;
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->altitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_heading;
+ u_heading.real = this->heading;
+ *(outbuffer + offset + 0) = (u_heading.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_heading.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_heading.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_heading.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->heading);
+ union {
+ float real;
+ uint32_t base;
+ } u_hor_velocity;
+ u_hor_velocity.real = this->hor_velocity;
+ *(outbuffer + offset + 0) = (u_hor_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_hor_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_hor_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_hor_velocity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->hor_velocity);
+ union {
+ float real;
+ uint32_t base;
+ } u_ver_velocity;
+ u_ver_velocity.real = this->ver_velocity;
+ *(outbuffer + offset + 0) = (u_ver_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_ver_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_ver_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_ver_velocity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ver_velocity);
+ *(outbuffer + offset + 0) = (this->altitude_type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->altitude_type);
+ *(outbuffer + offset + 0) = (this->emitter_type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->emitter_type);
+ *(outbuffer + offset + 0) = (this->tslc.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->tslc.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->tslc.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->tslc.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->tslc.sec);
+ *(outbuffer + offset + 0) = (this->tslc.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->tslc.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->tslc.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->tslc.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->tslc.nsec);
+ *(outbuffer + offset + 0) = (this->flags >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->flags >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->flags);
+ *(outbuffer + offset + 0) = (this->squawk >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->squawk >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->squawk);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->ICAO_address = ((uint32_t) (*(inbuffer + offset)));
+ this->ICAO_address |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->ICAO_address |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->ICAO_address |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->ICAO_address);
+ uint32_t length_callsign;
+ arrToVar(length_callsign, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_callsign; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_callsign-1]=0;
+ this->callsign = (char *)(inbuffer + offset-1);
+ offset += length_callsign;
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_heading;
+ u_heading.base = 0;
+ u_heading.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_heading.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_heading.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_heading.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->heading = u_heading.real;
+ offset += sizeof(this->heading);
+ union {
+ float real;
+ uint32_t base;
+ } u_hor_velocity;
+ u_hor_velocity.base = 0;
+ u_hor_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_hor_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_hor_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_hor_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->hor_velocity = u_hor_velocity.real;
+ offset += sizeof(this->hor_velocity);
+ union {
+ float real;
+ uint32_t base;
+ } u_ver_velocity;
+ u_ver_velocity.base = 0;
+ u_ver_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_ver_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_ver_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_ver_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->ver_velocity = u_ver_velocity.real;
+ offset += sizeof(this->ver_velocity);
+ this->altitude_type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->altitude_type);
+ this->emitter_type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->emitter_type);
+ this->tslc.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->tslc.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->tslc.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->tslc.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->tslc.sec);
+ this->tslc.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->tslc.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->tslc.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->tslc.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->tslc.nsec);
+ this->flags = ((uint16_t) (*(inbuffer + offset)));
+ this->flags |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->flags);
+ this->squawk = ((uint16_t) (*(inbuffer + offset)));
+ this->squawk |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->squawk);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/ADSBVehicle"; };
+ const char * getMD5(){ return "f71cc75a8e9e7b77d92f98d9a5315fd1"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ActuatorControl.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_mavros_msgs_ActuatorControl_h
+#define _ROS_mavros_msgs_ActuatorControl_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class ActuatorControl : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _group_mix_type;
+ _group_mix_type group_mix;
+ float controls[8];
+ enum { PX4_MIX_FLIGHT_CONTROL = 0 };
+ enum { PX4_MIX_FLIGHT_CONTROL_VTOL_ALT = 1 };
+ enum { PX4_MIX_PAYLOAD = 2 };
+ enum { PX4_MIX_MANUAL_PASSTHROUGH = 3 };
+
+ ActuatorControl():
+ header(),
+ group_mix(0),
+ controls()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->group_mix >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->group_mix);
+ for( uint32_t i = 0; i < 8; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_controlsi;
+ u_controlsi.real = this->controls[i];
+ *(outbuffer + offset + 0) = (u_controlsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_controlsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_controlsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_controlsi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->controls[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->group_mix = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->group_mix);
+ for( uint32_t i = 0; i < 8; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_controlsi;
+ u_controlsi.base = 0;
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->controls[i] = u_controlsi.real;
+ offset += sizeof(this->controls[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/ActuatorControl"; };
+ const char * getMD5(){ return "9eea0a80c88944fe2fb67f3b3768854b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/Altitude.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,188 @@
+#ifndef _ROS_mavros_msgs_Altitude_h
+#define _ROS_mavros_msgs_Altitude_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class Altitude : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _monotonic_type;
+ _monotonic_type monotonic;
+ typedef float _amsl_type;
+ _amsl_type amsl;
+ typedef float _local_type;
+ _local_type local;
+ typedef float _relative_type;
+ _relative_type relative;
+ typedef float _terrain_type;
+ _terrain_type terrain;
+ typedef float _bottom_clearance_type;
+ _bottom_clearance_type bottom_clearance;
+
+ Altitude():
+ header(),
+ monotonic(0),
+ amsl(0),
+ local(0),
+ relative(0),
+ terrain(0),
+ bottom_clearance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_monotonic;
+ u_monotonic.real = this->monotonic;
+ *(outbuffer + offset + 0) = (u_monotonic.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_monotonic.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_monotonic.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_monotonic.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->monotonic);
+ union {
+ float real;
+ uint32_t base;
+ } u_amsl;
+ u_amsl.real = this->amsl;
+ *(outbuffer + offset + 0) = (u_amsl.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_amsl.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_amsl.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_amsl.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->amsl);
+ union {
+ float real;
+ uint32_t base;
+ } u_local;
+ u_local.real = this->local;
+ *(outbuffer + offset + 0) = (u_local.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_local.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_local.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_local.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->local);
+ union {
+ float real;
+ uint32_t base;
+ } u_relative;
+ u_relative.real = this->relative;
+ *(outbuffer + offset + 0) = (u_relative.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_relative.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_relative.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_relative.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->relative);
+ union {
+ float real;
+ uint32_t base;
+ } u_terrain;
+ u_terrain.real = this->terrain;
+ *(outbuffer + offset + 0) = (u_terrain.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_terrain.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_terrain.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_terrain.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->terrain);
+ union {
+ float real;
+ uint32_t base;
+ } u_bottom_clearance;
+ u_bottom_clearance.real = this->bottom_clearance;
+ *(outbuffer + offset + 0) = (u_bottom_clearance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_bottom_clearance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_bottom_clearance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_bottom_clearance.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->bottom_clearance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_monotonic;
+ u_monotonic.base = 0;
+ u_monotonic.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_monotonic.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_monotonic.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_monotonic.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->monotonic = u_monotonic.real;
+ offset += sizeof(this->monotonic);
+ union {
+ float real;
+ uint32_t base;
+ } u_amsl;
+ u_amsl.base = 0;
+ u_amsl.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_amsl.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_amsl.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_amsl.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->amsl = u_amsl.real;
+ offset += sizeof(this->amsl);
+ union {
+ float real;
+ uint32_t base;
+ } u_local;
+ u_local.base = 0;
+ u_local.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_local.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_local.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_local.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->local = u_local.real;
+ offset += sizeof(this->local);
+ union {
+ float real;
+ uint32_t base;
+ } u_relative;
+ u_relative.base = 0;
+ u_relative.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_relative.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_relative.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_relative.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->relative = u_relative.real;
+ offset += sizeof(this->relative);
+ union {
+ float real;
+ uint32_t base;
+ } u_terrain;
+ u_terrain.base = 0;
+ u_terrain.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_terrain.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_terrain.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_terrain.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->terrain = u_terrain.real;
+ offset += sizeof(this->terrain);
+ union {
+ float real;
+ uint32_t base;
+ } u_bottom_clearance;
+ u_bottom_clearance.base = 0;
+ u_bottom_clearance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_bottom_clearance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_bottom_clearance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_bottom_clearance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->bottom_clearance = u_bottom_clearance.real;
+ offset += sizeof(this->bottom_clearance);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/Altitude"; };
+ const char * getMD5(){ return "1296a05dc5b6160be0ae04ba9ed3a3fa"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/AttitudeTarget.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,92 @@
+#ifndef _ROS_mavros_msgs_AttitudeTarget_h
+#define _ROS_mavros_msgs_AttitudeTarget_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Quaternion.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mavros_msgs
+{
+
+ class AttitudeTarget : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _type_mask_type;
+ _type_mask_type type_mask;
+ typedef geometry_msgs::Quaternion _orientation_type;
+ _orientation_type orientation;
+ typedef geometry_msgs::Vector3 _body_rate_type;
+ _body_rate_type body_rate;
+ typedef float _thrust_type;
+ _thrust_type thrust;
+ enum { IGNORE_ROLL_RATE = 1 };
+ enum { IGNORE_PITCH_RATE = 2 };
+ enum { IGNORE_YAW_RATE = 4 };
+ enum { IGNORE_THRUST = 64 };
+ enum { IGNORE_ATTITUDE = 128 };
+
+ AttitudeTarget():
+ header(),
+ type_mask(0),
+ orientation(),
+ body_rate(),
+ thrust(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->type_mask >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type_mask);
+ offset += this->orientation.serialize(outbuffer + offset);
+ offset += this->body_rate.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_thrust;
+ u_thrust.real = this->thrust;
+ *(outbuffer + offset + 0) = (u_thrust.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_thrust.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_thrust.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_thrust.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->thrust);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->type_mask = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type_mask);
+ offset += this->orientation.deserialize(inbuffer + offset);
+ offset += this->body_rate.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_thrust;
+ u_thrust.base = 0;
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->thrust = u_thrust.real;
+ offset += sizeof(this->thrust);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/AttitudeTarget"; };
+ const char * getMD5(){ return "456f3af666b22ccd0222ea053a86b548"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/BatteryStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,116 @@
+#ifndef _ROS_mavros_msgs_BatteryStatus_h
+#define _ROS_mavros_msgs_BatteryStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class BatteryStatus : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _voltage_type;
+ _voltage_type voltage;
+ typedef float _current_type;
+ _current_type current;
+ typedef float _remaining_type;
+ _remaining_type remaining;
+
+ BatteryStatus():
+ header(),
+ voltage(0),
+ current(0),
+ remaining(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_voltage;
+ u_voltage.real = this->voltage;
+ *(outbuffer + offset + 0) = (u_voltage.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_voltage.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_voltage.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_voltage.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->voltage);
+ union {
+ float real;
+ uint32_t base;
+ } u_current;
+ u_current.real = this->current;
+ *(outbuffer + offset + 0) = (u_current.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_current.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_current.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_current.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->current);
+ union {
+ float real;
+ uint32_t base;
+ } u_remaining;
+ u_remaining.real = this->remaining;
+ *(outbuffer + offset + 0) = (u_remaining.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_remaining.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_remaining.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_remaining.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->remaining);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_voltage;
+ u_voltage.base = 0;
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->voltage = u_voltage.real;
+ offset += sizeof(this->voltage);
+ union {
+ float real;
+ uint32_t base;
+ } u_current;
+ u_current.base = 0;
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->current = u_current.real;
+ offset += sizeof(this->current);
+ union {
+ float real;
+ uint32_t base;
+ } u_remaining;
+ u_remaining.base = 0;
+ u_remaining.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_remaining.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_remaining.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_remaining.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->remaining = u_remaining.real;
+ offset += sizeof(this->remaining);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/BatteryStatus"; };
+ const char * getMD5(){ return "8ba4ae7c602c5ae6a7e8f3ffb652dc5f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CamIMUStamp.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,86 @@
+#ifndef _ROS_mavros_msgs_CamIMUStamp_h
+#define _ROS_mavros_msgs_CamIMUStamp_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+
+namespace mavros_msgs
+{
+
+ class CamIMUStamp : public ros::Msg
+ {
+ public:
+ typedef ros::Time _frame_stamp_type;
+ _frame_stamp_type frame_stamp;
+ typedef int32_t _frame_seq_id_type;
+ _frame_seq_id_type frame_seq_id;
+
+ CamIMUStamp():
+ frame_stamp(),
+ frame_seq_id(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->frame_stamp.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->frame_stamp.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->frame_stamp.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->frame_stamp.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->frame_stamp.sec);
+ *(outbuffer + offset + 0) = (this->frame_stamp.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->frame_stamp.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->frame_stamp.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->frame_stamp.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->frame_stamp.nsec);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_frame_seq_id;
+ u_frame_seq_id.real = this->frame_seq_id;
+ *(outbuffer + offset + 0) = (u_frame_seq_id.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_frame_seq_id.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_frame_seq_id.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_frame_seq_id.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->frame_seq_id);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->frame_stamp.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->frame_stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->frame_stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->frame_stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->frame_stamp.sec);
+ this->frame_stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->frame_stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->frame_stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->frame_stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->frame_stamp.nsec);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_frame_seq_id;
+ u_frame_seq_id.base = 0;
+ u_frame_seq_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_frame_seq_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_frame_seq_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_frame_seq_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->frame_seq_id = u_frame_seq_id.real;
+ offset += sizeof(this->frame_seq_id);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/CamIMUStamp"; };
+ const char * getMD5(){ return "ac22af9031671dd528a56f12d0986660"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandBool.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,113 @@
+#ifndef _ROS_SERVICE_CommandBool_h
+#define _ROS_SERVICE_CommandBool_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDBOOL[] = "mavros_msgs/CommandBool";
+
+ class CommandBoolRequest : public ros::Msg
+ {
+ public:
+ typedef bool _value_type;
+ _value_type value;
+
+ CommandBoolRequest():
+ value(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_value;
+ u_value.real = this->value;
+ *(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_value;
+ u_value.base = 0;
+ u_value.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->value = u_value.real;
+ offset += sizeof(this->value);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDBOOL; };
+ const char * getMD5(){ return "e431d687bf4b2c65fbd94b12ae0cb5d9"; };
+
+ };
+
+ class CommandBoolResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ CommandBoolResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDBOOL; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class CommandBool {
+ public:
+ typedef CommandBoolRequest Request;
+ typedef CommandBoolResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandCode.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,152 @@
+#ifndef _ROS_mavros_msgs_CommandCode_h
+#define _ROS_mavros_msgs_CommandCode_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+ class CommandCode : public ros::Msg
+ {
+ public:
+ enum { AIRFRAME_CONFIGURATION = 2520 };
+ enum { ARM_AUTHORIZATION_REQUEST = 3001 };
+ enum { COMPONENT_ARM_DISARM = 400 };
+ enum { CONDITION_DELAY = 112 };
+ enum { CONDITION_CHANGE_ALT = 113 };
+ enum { CONDITION_DISTANCE = 114 };
+ enum { CONDITION_YAW = 115 };
+ enum { CONDITION_LAST = 159 };
+ enum { CONTROL_HIGH_LATENCY = 2600 };
+ enum { DO_FOLLOW = 32 };
+ enum { DO_FOLLOW_REPOSITION = 33 };
+ enum { DO_SET_MODE = 176 };
+ enum { DO_JUMP = 177 };
+ enum { DO_CHANGE_SPEED = 178 };
+ enum { DO_SET_HOME = 179 };
+ enum { DO_SET_PARAMETER = 180 };
+ enum { DO_SET_RELAY = 181 };
+ enum { DO_REPEAT_RELAY = 182 };
+ enum { DO_SET_SERVO = 183 };
+ enum { DO_REPEAT_SERVO = 184 };
+ enum { DO_FLIGHTTERMINATION = 185 };
+ enum { DO_CHANGE_ALTITUDE = 186 };
+ enum { DO_LAND_START = 189 };
+ enum { DO_RALLY_LAND = 190 };
+ enum { DO_GO_AROUND = 191 };
+ enum { DO_REPOSITION = 192 };
+ enum { DO_PAUSE_CONTINUE = 193 };
+ enum { DO_SET_REVERSE = 194 };
+ enum { DO_SET_ROI_LOCATION = 195 };
+ enum { DO_SET_ROI_WPNEXT_OFFSET = 196 };
+ enum { DO_SET_ROI_NONE = 197 };
+ enum { DO_CONTROL_VIDEO = 200 };
+ enum { DO_SET_ROI = 201 };
+ enum { DO_DIGICAM_CONFIGURE = 202 };
+ enum { DO_DIGICAM_CONTROL = 203 };
+ enum { DO_MOUNT_CONFIGURE = 204 };
+ enum { DO_MOUNT_CONTROL = 205 };
+ enum { DO_SET_CAM_TRIGG_DIST = 206 };
+ enum { DO_FENCE_ENABLE = 207 };
+ enum { DO_PARACHUTE = 208 };
+ enum { DO_MOTOR_TEST = 209 };
+ enum { DO_INVERTED_FLIGHT = 210 };
+ enum { DO_SET_CAM_TRIGG_INTERVAL = 214 };
+ enum { DO_MOUNT_CONTROL_QUAT = 220 };
+ enum { DO_GUIDED_MASTER = 221 };
+ enum { DO_GUIDED_LIMITS = 222 };
+ enum { DO_ENGINE_CONTROL = 223 };
+ enum { DO_SET_MISSION_CURRENT = 224 };
+ enum { DO_LAST = 240 };
+ enum { DO_JUMP_TAG = 601 };
+ enum { DO_TRIGGER_CONTROL = 2003 };
+ enum { DO_VTOL_TRANSITION = 3000 };
+ enum { GET_HOME_POSITION = 410 };
+ enum { GET_MESSAGE_INTERVAL = 510 };
+ enum { IMAGE_START_CAPTURE = 2000 };
+ enum { IMAGE_STOP_CAPTURE = 2001 };
+ enum { JUMP_TAG = 600 };
+ enum { LOGGING_START = 2510 };
+ enum { LOGGING_STOP = 2511 };
+ enum { MISSION_START = 300 };
+ enum { NAV_WAYPOINT = 16 };
+ enum { NAV_LOITER_UNLIM = 17 };
+ enum { NAV_LOITER_TURNS = 18 };
+ enum { NAV_LOITER_TIME = 19 };
+ enum { NAV_RETURN_TO_LAUNCH = 20 };
+ enum { NAV_LAND = 21 };
+ enum { NAV_TAKEOFF = 22 };
+ enum { NAV_LAND_LOCAL = 23 };
+ enum { NAV_TAKEOFF_LOCAL = 24 };
+ enum { NAV_FOLLOW = 25 };
+ enum { NAV_CONTINUE_AND_CHANGE_ALT = 30 };
+ enum { NAV_LOITER_TO_ALT = 31 };
+ enum { NAV_ROI = 80 };
+ enum { NAV_PATHPLANNING = 81 };
+ enum { NAV_SPLINE_WAYPOINT = 82 };
+ enum { NAV_VTOL_TAKEOFF = 84 };
+ enum { NAV_VTOL_LAND = 85 };
+ enum { NAV_GUIDED_ENABLE = 92 };
+ enum { NAV_DELAY = 93 };
+ enum { NAV_PAYLOAD_PLACE = 94 };
+ enum { NAV_LAST = 95 };
+ enum { NAV_SET_YAW_SPEED = 213 };
+ enum { NAV_FENCE_RETURN_POINT = 5000 };
+ enum { NAV_FENCE_POLYGON_VERTEX_INCLUSION = 5001 };
+ enum { NAV_FENCE_POLYGON_VERTEX_EXCLUSION = 5002 };
+ enum { NAV_FENCE_CIRCLE_INCLUSION = 5003 };
+ enum { NAV_FENCE_CIRCLE_EXCLUSION = 5004 };
+ enum { NAV_RALLY_POINT = 5100 };
+ enum { OVERRIDE_GOTO = 252 };
+ enum { PANORAMA_CREATE = 2800 };
+ enum { PAYLOAD_PREPARE_DEPLOY = 30001 };
+ enum { PAYLOAD_CONTROL_DEPLOY = 30002 };
+ enum { PREFLIGHT_CALIBRATION = 241 };
+ enum { PREFLIGHT_SET_SENSOR_OFFSETS = 242 };
+ enum { PREFLIGHT_UAVCAN = 243 };
+ enum { PREFLIGHT_STORAGE = 245 };
+ enum { PREFLIGHT_REBOOT_SHUTDOWN = 246 };
+ enum { REQUEST_MESSAGE = 512 };
+ enum { REQUEST_AUTOPILOT_CAPABILITIES = 520 };
+ enum { REQUEST_CAMERA_INFORMATION = 521 };
+ enum { REQUEST_CAMERA_SETTINGS = 522 };
+ enum { REQUEST_STORAGE_INFORMATION = 525 };
+ enum { REQUEST_CAMERA_CAPTURE_STATUS = 527 };
+ enum { REQUEST_FLIGHT_INFORMATION = 528 };
+ enum { RESET_CAMERA_SETTINGS = 529 };
+ enum { SET_MESSAGE_INTERVAL = 511 };
+ enum { SET_CAMERA_MODE = 530 };
+ enum { SET_GUIDED_SUBMODE_STANDARD = 4000 };
+ enum { SET_GUIDED_SUBMODE_CIRCLE = 4001 };
+ enum { START_RX_PAIR = 500 };
+ enum { STORAGE_FORMAT = 526 };
+ enum { UAVCAN_GET_NODE_INFO = 5200 };
+ enum { VIDEO_START_CAPTURE = 2500 };
+ enum { VIDEO_STOP_CAPTURE = 2501 };
+
+ CommandCode()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/CommandCode"; };
+ const char * getMD5(){ return "9c980aa1230f756ac9d693ff35accb29"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandHome.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,209 @@
+#ifndef _ROS_SERVICE_CommandHome_h
+#define _ROS_SERVICE_CommandHome_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDHOME[] = "mavros_msgs/CommandHome";
+
+ class CommandHomeRequest : public ros::Msg
+ {
+ public:
+ typedef bool _current_gps_type;
+ _current_gps_type current_gps;
+ typedef float _yaw_type;
+ _yaw_type yaw;
+ typedef float _latitude_type;
+ _latitude_type latitude;
+ typedef float _longitude_type;
+ _longitude_type longitude;
+ typedef float _altitude_type;
+ _altitude_type altitude;
+
+ CommandHomeRequest():
+ current_gps(0),
+ yaw(0),
+ latitude(0),
+ longitude(0),
+ altitude(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_current_gps;
+ u_current_gps.real = this->current_gps;
+ *(outbuffer + offset + 0) = (u_current_gps.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->current_gps);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.real = this->yaw;
+ *(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->altitude);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_current_gps;
+ u_current_gps.base = 0;
+ u_current_gps.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->current_gps = u_current_gps.real;
+ offset += sizeof(this->current_gps);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.base = 0;
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw = u_yaw.real;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDHOME; };
+ const char * getMD5(){ return "af3ed5fc0724380793eba353ee384c9a"; };
+
+ };
+
+ class CommandHomeResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ CommandHomeResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDHOME; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class CommandHome {
+ public:
+ typedef CommandHomeRequest Request;
+ typedef CommandHomeResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandInt.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,304 @@
+#ifndef _ROS_SERVICE_CommandInt_h
+#define _ROS_SERVICE_CommandInt_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDINT[] = "mavros_msgs/CommandInt";
+
+ class CommandIntRequest : public ros::Msg
+ {
+ public:
+ typedef bool _broadcast_type;
+ _broadcast_type broadcast;
+ typedef uint8_t _frame_type;
+ _frame_type frame;
+ typedef uint16_t _command_type;
+ _command_type command;
+ typedef uint8_t _current_type;
+ _current_type current;
+ typedef uint8_t _autocontinue_type;
+ _autocontinue_type autocontinue;
+ typedef float _param1_type;
+ _param1_type param1;
+ typedef float _param2_type;
+ _param2_type param2;
+ typedef float _param3_type;
+ _param3_type param3;
+ typedef float _param4_type;
+ _param4_type param4;
+ typedef int32_t _x_type;
+ _x_type x;
+ typedef int32_t _y_type;
+ _y_type y;
+ typedef float _z_type;
+ _z_type z;
+
+ CommandIntRequest():
+ broadcast(0),
+ frame(0),
+ command(0),
+ current(0),
+ autocontinue(0),
+ param1(0),
+ param2(0),
+ param3(0),
+ param4(0),
+ x(0),
+ y(0),
+ z(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_broadcast;
+ u_broadcast.real = this->broadcast;
+ *(outbuffer + offset + 0) = (u_broadcast.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->broadcast);
+ *(outbuffer + offset + 0) = (this->frame >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->frame);
+ *(outbuffer + offset + 0) = (this->command >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->command >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->command);
+ *(outbuffer + offset + 0) = (this->current >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->current);
+ *(outbuffer + offset + 0) = (this->autocontinue >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->autocontinue);
+ union {
+ float real;
+ uint32_t base;
+ } u_param1;
+ u_param1.real = this->param1;
+ *(outbuffer + offset + 0) = (u_param1.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param1.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param1.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param1.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param1);
+ union {
+ float real;
+ uint32_t base;
+ } u_param2;
+ u_param2.real = this->param2;
+ *(outbuffer + offset + 0) = (u_param2.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param2.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param2.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param2.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param2);
+ union {
+ float real;
+ uint32_t base;
+ } u_param3;
+ u_param3.real = this->param3;
+ *(outbuffer + offset + 0) = (u_param3.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param3.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param3.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param3.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param3);
+ union {
+ float real;
+ uint32_t base;
+ } u_param4;
+ u_param4.real = this->param4;
+ *(outbuffer + offset + 0) = (u_param4.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param4.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param4.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param4.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param4);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_z;
+ u_z.real = this->z;
+ *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_broadcast;
+ u_broadcast.base = 0;
+ u_broadcast.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->broadcast = u_broadcast.real;
+ offset += sizeof(this->broadcast);
+ this->frame = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->frame);
+ this->command = ((uint16_t) (*(inbuffer + offset)));
+ this->command |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->command);
+ this->current = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->current);
+ this->autocontinue = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->autocontinue);
+ union {
+ float real;
+ uint32_t base;
+ } u_param1;
+ u_param1.base = 0;
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param1 = u_param1.real;
+ offset += sizeof(this->param1);
+ union {
+ float real;
+ uint32_t base;
+ } u_param2;
+ u_param2.base = 0;
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param2 = u_param2.real;
+ offset += sizeof(this->param2);
+ union {
+ float real;
+ uint32_t base;
+ } u_param3;
+ u_param3.base = 0;
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param3 = u_param3.real;
+ offset += sizeof(this->param3);
+ union {
+ float real;
+ uint32_t base;
+ } u_param4;
+ u_param4.base = 0;
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param4 = u_param4.real;
+ offset += sizeof(this->param4);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_z;
+ u_z.base = 0;
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->z = u_z.real;
+ offset += sizeof(this->z);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDINT; };
+ const char * getMD5(){ return "6165959012c47e0f665b640c1ab12391"; };
+
+ };
+
+ class CommandIntResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ CommandIntResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDINT; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class CommandInt {
+ public:
+ typedef CommandIntRequest Request;
+ typedef CommandIntResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandLong.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,297 @@
+#ifndef _ROS_SERVICE_CommandLong_h
+#define _ROS_SERVICE_CommandLong_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDLONG[] = "mavros_msgs/CommandLong";
+
+ class CommandLongRequest : public ros::Msg
+ {
+ public:
+ typedef bool _broadcast_type;
+ _broadcast_type broadcast;
+ typedef uint16_t _command_type;
+ _command_type command;
+ typedef uint8_t _confirmation_type;
+ _confirmation_type confirmation;
+ typedef float _param1_type;
+ _param1_type param1;
+ typedef float _param2_type;
+ _param2_type param2;
+ typedef float _param3_type;
+ _param3_type param3;
+ typedef float _param4_type;
+ _param4_type param4;
+ typedef float _param5_type;
+ _param5_type param5;
+ typedef float _param6_type;
+ _param6_type param6;
+ typedef float _param7_type;
+ _param7_type param7;
+
+ CommandLongRequest():
+ broadcast(0),
+ command(0),
+ confirmation(0),
+ param1(0),
+ param2(0),
+ param3(0),
+ param4(0),
+ param5(0),
+ param6(0),
+ param7(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_broadcast;
+ u_broadcast.real = this->broadcast;
+ *(outbuffer + offset + 0) = (u_broadcast.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->broadcast);
+ *(outbuffer + offset + 0) = (this->command >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->command >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->command);
+ *(outbuffer + offset + 0) = (this->confirmation >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->confirmation);
+ union {
+ float real;
+ uint32_t base;
+ } u_param1;
+ u_param1.real = this->param1;
+ *(outbuffer + offset + 0) = (u_param1.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param1.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param1.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param1.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param1);
+ union {
+ float real;
+ uint32_t base;
+ } u_param2;
+ u_param2.real = this->param2;
+ *(outbuffer + offset + 0) = (u_param2.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param2.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param2.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param2.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param2);
+ union {
+ float real;
+ uint32_t base;
+ } u_param3;
+ u_param3.real = this->param3;
+ *(outbuffer + offset + 0) = (u_param3.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param3.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param3.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param3.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param3);
+ union {
+ float real;
+ uint32_t base;
+ } u_param4;
+ u_param4.real = this->param4;
+ *(outbuffer + offset + 0) = (u_param4.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param4.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param4.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param4.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param4);
+ union {
+ float real;
+ uint32_t base;
+ } u_param5;
+ u_param5.real = this->param5;
+ *(outbuffer + offset + 0) = (u_param5.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param5.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param5.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param5.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param5);
+ union {
+ float real;
+ uint32_t base;
+ } u_param6;
+ u_param6.real = this->param6;
+ *(outbuffer + offset + 0) = (u_param6.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param6.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param6.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param6.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param6);
+ union {
+ float real;
+ uint32_t base;
+ } u_param7;
+ u_param7.real = this->param7;
+ *(outbuffer + offset + 0) = (u_param7.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param7.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param7.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param7.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param7);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_broadcast;
+ u_broadcast.base = 0;
+ u_broadcast.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->broadcast = u_broadcast.real;
+ offset += sizeof(this->broadcast);
+ this->command = ((uint16_t) (*(inbuffer + offset)));
+ this->command |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->command);
+ this->confirmation = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->confirmation);
+ union {
+ float real;
+ uint32_t base;
+ } u_param1;
+ u_param1.base = 0;
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param1 = u_param1.real;
+ offset += sizeof(this->param1);
+ union {
+ float real;
+ uint32_t base;
+ } u_param2;
+ u_param2.base = 0;
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param2 = u_param2.real;
+ offset += sizeof(this->param2);
+ union {
+ float real;
+ uint32_t base;
+ } u_param3;
+ u_param3.base = 0;
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param3 = u_param3.real;
+ offset += sizeof(this->param3);
+ union {
+ float real;
+ uint32_t base;
+ } u_param4;
+ u_param4.base = 0;
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param4 = u_param4.real;
+ offset += sizeof(this->param4);
+ union {
+ float real;
+ uint32_t base;
+ } u_param5;
+ u_param5.base = 0;
+ u_param5.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param5.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param5.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param5.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param5 = u_param5.real;
+ offset += sizeof(this->param5);
+ union {
+ float real;
+ uint32_t base;
+ } u_param6;
+ u_param6.base = 0;
+ u_param6.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param6.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param6.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param6.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param6 = u_param6.real;
+ offset += sizeof(this->param6);
+ union {
+ float real;
+ uint32_t base;
+ } u_param7;
+ u_param7.base = 0;
+ u_param7.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param7.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param7.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param7.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param7 = u_param7.real;
+ offset += sizeof(this->param7);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDLONG; };
+ const char * getMD5(){ return "0ad16dd8ca2c8f209bfc6c32c71c0dd8"; };
+
+ };
+
+ class CommandLongResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ CommandLongResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDLONG; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class CommandLong {
+ public:
+ typedef CommandLongRequest Request;
+ typedef CommandLongResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandTOL.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,215 @@
+#ifndef _ROS_SERVICE_CommandTOL_h
+#define _ROS_SERVICE_CommandTOL_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDTOL[] = "mavros_msgs/CommandTOL";
+
+ class CommandTOLRequest : public ros::Msg
+ {
+ public:
+ typedef float _min_pitch_type;
+ _min_pitch_type min_pitch;
+ typedef float _yaw_type;
+ _yaw_type yaw;
+ typedef float _latitude_type;
+ _latitude_type latitude;
+ typedef float _longitude_type;
+ _longitude_type longitude;
+ typedef float _altitude_type;
+ _altitude_type altitude;
+
+ CommandTOLRequest():
+ min_pitch(0),
+ yaw(0),
+ latitude(0),
+ longitude(0),
+ altitude(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_min_pitch;
+ u_min_pitch.real = this->min_pitch;
+ *(outbuffer + offset + 0) = (u_min_pitch.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_min_pitch.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_min_pitch.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_min_pitch.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->min_pitch);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.real = this->yaw;
+ *(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->altitude);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_min_pitch;
+ u_min_pitch.base = 0;
+ u_min_pitch.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_min_pitch.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_min_pitch.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_min_pitch.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->min_pitch = u_min_pitch.real;
+ offset += sizeof(this->min_pitch);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.base = 0;
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw = u_yaw.real;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDTOL; };
+ const char * getMD5(){ return "5aec7e34bcfe9ec68949aebae7bcd1ec"; };
+
+ };
+
+ class CommandTOLResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ CommandTOLResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDTOL; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class CommandTOL {
+ public:
+ typedef CommandTOLRequest Request;
+ typedef CommandTOLResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandTriggerControl.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,149 @@
+#ifndef _ROS_SERVICE_CommandTriggerControl_h
+#define _ROS_SERVICE_CommandTriggerControl_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDTRIGGERCONTROL[] = "mavros_msgs/CommandTriggerControl";
+
+ class CommandTriggerControlRequest : public ros::Msg
+ {
+ public:
+ typedef bool _trigger_enable_type;
+ _trigger_enable_type trigger_enable;
+ typedef bool _sequence_reset_type;
+ _sequence_reset_type sequence_reset;
+ typedef bool _trigger_pause_type;
+ _trigger_pause_type trigger_pause;
+
+ CommandTriggerControlRequest():
+ trigger_enable(0),
+ sequence_reset(0),
+ trigger_pause(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_trigger_enable;
+ u_trigger_enable.real = this->trigger_enable;
+ *(outbuffer + offset + 0) = (u_trigger_enable.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->trigger_enable);
+ union {
+ bool real;
+ uint8_t base;
+ } u_sequence_reset;
+ u_sequence_reset.real = this->sequence_reset;
+ *(outbuffer + offset + 0) = (u_sequence_reset.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->sequence_reset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_trigger_pause;
+ u_trigger_pause.real = this->trigger_pause;
+ *(outbuffer + offset + 0) = (u_trigger_pause.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->trigger_pause);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_trigger_enable;
+ u_trigger_enable.base = 0;
+ u_trigger_enable.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->trigger_enable = u_trigger_enable.real;
+ offset += sizeof(this->trigger_enable);
+ union {
+ bool real;
+ uint8_t base;
+ } u_sequence_reset;
+ u_sequence_reset.base = 0;
+ u_sequence_reset.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->sequence_reset = u_sequence_reset.real;
+ offset += sizeof(this->sequence_reset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_trigger_pause;
+ u_trigger_pause.base = 0;
+ u_trigger_pause.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->trigger_pause = u_trigger_pause.real;
+ offset += sizeof(this->trigger_pause);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDTRIGGERCONTROL; };
+ const char * getMD5(){ return "5231f3f21be52f9682a8e030770339a5"; };
+
+ };
+
+ class CommandTriggerControlResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ CommandTriggerControlResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDTRIGGERCONTROL; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class CommandTriggerControl {
+ public:
+ typedef CommandTriggerControlRequest Request;
+ typedef CommandTriggerControlResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandTriggerInterval.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,143 @@
+#ifndef _ROS_SERVICE_CommandTriggerInterval_h
+#define _ROS_SERVICE_CommandTriggerInterval_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDTRIGGERINTERVAL[] = "mavros_msgs/CommandTriggerInterval";
+
+ class CommandTriggerIntervalRequest : public ros::Msg
+ {
+ public:
+ typedef float _cycle_time_type;
+ _cycle_time_type cycle_time;
+ typedef float _integration_time_type;
+ _integration_time_type integration_time;
+
+ CommandTriggerIntervalRequest():
+ cycle_time(0),
+ integration_time(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_cycle_time;
+ u_cycle_time.real = this->cycle_time;
+ *(outbuffer + offset + 0) = (u_cycle_time.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_cycle_time.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_cycle_time.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_cycle_time.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->cycle_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_integration_time;
+ u_integration_time.real = this->integration_time;
+ *(outbuffer + offset + 0) = (u_integration_time.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_integration_time.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_integration_time.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_integration_time.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->integration_time);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_cycle_time;
+ u_cycle_time.base = 0;
+ u_cycle_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_cycle_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_cycle_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_cycle_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->cycle_time = u_cycle_time.real;
+ offset += sizeof(this->cycle_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_integration_time;
+ u_integration_time.base = 0;
+ u_integration_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_integration_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_integration_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_integration_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->integration_time = u_integration_time.real;
+ offset += sizeof(this->integration_time);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDTRIGGERINTERVAL; };
+ const char * getMD5(){ return "54f6167a076ced593aa096ea6eb1a519"; };
+
+ };
+
+ class CommandTriggerIntervalResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ CommandTriggerIntervalResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDTRIGGERINTERVAL; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class CommandTriggerInterval {
+ public:
+ typedef CommandTriggerIntervalRequest Request;
+ typedef CommandTriggerIntervalResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CommandVtolTransition.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,110 @@
+#ifndef _ROS_SERVICE_CommandVtolTransition_h
+#define _ROS_SERVICE_CommandVtolTransition_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+static const char COMMANDVTOLTRANSITION[] = "mavros_msgs/CommandVtolTransition";
+
+ class CommandVtolTransitionRequest : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _state_type;
+ _state_type state;
+ enum { STATE_MC = 3 };
+ enum { STATE_FW = 4 };
+
+ CommandVtolTransitionRequest():
+ header(),
+ state(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->state);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->state = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->state);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDVTOLTRANSITION; };
+ const char * getMD5(){ return "0f073c606cdf8c014b856a5033900f3e"; };
+
+ };
+
+ class CommandVtolTransitionResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ CommandVtolTransitionResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return COMMANDVTOLTRANSITION; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class CommandVtolTransition {
+ public:
+ typedef CommandVtolTransitionRequest Request;
+ typedef CommandVtolTransitionResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/CompanionProcessStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,69 @@
+#ifndef _ROS_mavros_msgs_CompanionProcessStatus_h
+#define _ROS_mavros_msgs_CompanionProcessStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class CompanionProcessStatus : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _state_type;
+ _state_type state;
+ typedef uint8_t _component_type;
+ _component_type component;
+ enum { MAV_STATE_UNINIT = 0 };
+ enum { MAV_STATE_BOOT = 1 };
+ enum { MAV_STATE_CALIBRATING = 2 };
+ enum { MAV_STATE_STANDBY = 3 };
+ enum { MAV_STATE_ACTIVE = 4 };
+ enum { MAV_STATE_CRITICAL = 5 };
+ enum { MAV_STATE_EMERGENCY = 6 };
+ enum { MAV_STATE_POWEROFF = 7 };
+ enum { MAV_STATE_FLIGHT_TERMINATION = 8 };
+ enum { MAV_COMP_ID_OBSTACLE_AVOIDANCE = 196 };
+ enum { MAV_COMP_ID_VISUAL_INERTIAL_ODOMETRY = 197 };
+
+ CompanionProcessStatus():
+ header(),
+ state(0),
+ component(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->state);
+ *(outbuffer + offset + 0) = (this->component >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->component);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->state = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->state);
+ this->component = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->component);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/CompanionProcessStatus"; };
+ const char * getMD5(){ return "b6dd787fcd873e87778987b1845f4cb5"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/DebugValue.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,189 @@
+#ifndef _ROS_mavros_msgs_DebugValue_h
+#define _ROS_mavros_msgs_DebugValue_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class DebugValue : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef int32_t _index_type;
+ _index_type index;
+ typedef const char* _name_type;
+ _name_type name;
+ typedef float _value_float_type;
+ _value_float_type value_float;
+ typedef int32_t _value_int_type;
+ _value_int_type value_int;
+ uint32_t data_length;
+ typedef float _data_type;
+ _data_type st_data;
+ _data_type * data;
+ typedef uint8_t _type_type;
+ _type_type type;
+ enum { TYPE_DEBUG = 0 };
+ enum { TYPE_DEBUG_VECT = 1 };
+ enum { TYPE_DEBUG_ARRAY = 2 };
+ enum { TYPE_NAMED_VALUE_FLOAT = 3 };
+ enum { TYPE_NAMED_VALUE_INT = 4 };
+
+ DebugValue():
+ header(),
+ index(0),
+ name(""),
+ value_float(0),
+ value_int(0),
+ data_length(0), data(NULL),
+ type(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_index;
+ u_index.real = this->index;
+ *(outbuffer + offset + 0) = (u_index.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_index.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_index.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_index.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->index);
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ union {
+ float real;
+ uint32_t base;
+ } u_value_float;
+ u_value_float.real = this->value_float;
+ *(outbuffer + offset + 0) = (u_value_float.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_value_float.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_value_float.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_value_float.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->value_float);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_value_int;
+ u_value_int.real = this->value_int;
+ *(outbuffer + offset + 0) = (u_value_int.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_value_int.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_value_int.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_value_int.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->value_int);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_index;
+ u_index.base = 0;
+ u_index.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_index.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_index.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_index.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->index = u_index.real;
+ offset += sizeof(this->index);
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ union {
+ float real;
+ uint32_t base;
+ } u_value_float;
+ u_value_float.base = 0;
+ u_value_float.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_value_float.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_value_float.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_value_float.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->value_float = u_value_float.real;
+ offset += sizeof(this->value_float);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_value_int;
+ u_value_int.base = 0;
+ u_value_int.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_value_int.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_value_int.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_value_int.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->value_int = u_value_int.real;
+ offset += sizeof(this->value_int);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (float*)realloc(this->data, data_lengthT * sizeof(float));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(float));
+ }
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/DebugValue"; };
+ const char * getMD5(){ return "af412ff7223c64155e7e3c6b7508eaaa"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/EstimatorStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,260 @@
+#ifndef _ROS_mavros_msgs_EstimatorStatus_h
+#define _ROS_mavros_msgs_EstimatorStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class EstimatorStatus : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef bool _attitude_status_flag_type;
+ _attitude_status_flag_type attitude_status_flag;
+ typedef bool _velocity_horiz_status_flag_type;
+ _velocity_horiz_status_flag_type velocity_horiz_status_flag;
+ typedef bool _velocity_vert_status_flag_type;
+ _velocity_vert_status_flag_type velocity_vert_status_flag;
+ typedef bool _pos_horiz_rel_status_flag_type;
+ _pos_horiz_rel_status_flag_type pos_horiz_rel_status_flag;
+ typedef bool _pos_horiz_abs_status_flag_type;
+ _pos_horiz_abs_status_flag_type pos_horiz_abs_status_flag;
+ typedef bool _pos_vert_abs_status_flag_type;
+ _pos_vert_abs_status_flag_type pos_vert_abs_status_flag;
+ typedef bool _pos_vert_agl_status_flag_type;
+ _pos_vert_agl_status_flag_type pos_vert_agl_status_flag;
+ typedef bool _const_pos_mode_status_flag_type;
+ _const_pos_mode_status_flag_type const_pos_mode_status_flag;
+ typedef bool _pred_pos_horiz_rel_status_flag_type;
+ _pred_pos_horiz_rel_status_flag_type pred_pos_horiz_rel_status_flag;
+ typedef bool _pred_pos_horiz_abs_status_flag_type;
+ _pred_pos_horiz_abs_status_flag_type pred_pos_horiz_abs_status_flag;
+ typedef bool _gps_glitch_status_flag_type;
+ _gps_glitch_status_flag_type gps_glitch_status_flag;
+ typedef bool _accel_error_status_flag_type;
+ _accel_error_status_flag_type accel_error_status_flag;
+
+ EstimatorStatus():
+ header(),
+ attitude_status_flag(0),
+ velocity_horiz_status_flag(0),
+ velocity_vert_status_flag(0),
+ pos_horiz_rel_status_flag(0),
+ pos_horiz_abs_status_flag(0),
+ pos_vert_abs_status_flag(0),
+ pos_vert_agl_status_flag(0),
+ const_pos_mode_status_flag(0),
+ pred_pos_horiz_rel_status_flag(0),
+ pred_pos_horiz_abs_status_flag(0),
+ gps_glitch_status_flag(0),
+ accel_error_status_flag(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_attitude_status_flag;
+ u_attitude_status_flag.real = this->attitude_status_flag;
+ *(outbuffer + offset + 0) = (u_attitude_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->attitude_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_velocity_horiz_status_flag;
+ u_velocity_horiz_status_flag.real = this->velocity_horiz_status_flag;
+ *(outbuffer + offset + 0) = (u_velocity_horiz_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->velocity_horiz_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_velocity_vert_status_flag;
+ u_velocity_vert_status_flag.real = this->velocity_vert_status_flag;
+ *(outbuffer + offset + 0) = (u_velocity_vert_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->velocity_vert_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_horiz_rel_status_flag;
+ u_pos_horiz_rel_status_flag.real = this->pos_horiz_rel_status_flag;
+ *(outbuffer + offset + 0) = (u_pos_horiz_rel_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->pos_horiz_rel_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_horiz_abs_status_flag;
+ u_pos_horiz_abs_status_flag.real = this->pos_horiz_abs_status_flag;
+ *(outbuffer + offset + 0) = (u_pos_horiz_abs_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->pos_horiz_abs_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_vert_abs_status_flag;
+ u_pos_vert_abs_status_flag.real = this->pos_vert_abs_status_flag;
+ *(outbuffer + offset + 0) = (u_pos_vert_abs_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->pos_vert_abs_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_vert_agl_status_flag;
+ u_pos_vert_agl_status_flag.real = this->pos_vert_agl_status_flag;
+ *(outbuffer + offset + 0) = (u_pos_vert_agl_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->pos_vert_agl_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_const_pos_mode_status_flag;
+ u_const_pos_mode_status_flag.real = this->const_pos_mode_status_flag;
+ *(outbuffer + offset + 0) = (u_const_pos_mode_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->const_pos_mode_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pred_pos_horiz_rel_status_flag;
+ u_pred_pos_horiz_rel_status_flag.real = this->pred_pos_horiz_rel_status_flag;
+ *(outbuffer + offset + 0) = (u_pred_pos_horiz_rel_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->pred_pos_horiz_rel_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pred_pos_horiz_abs_status_flag;
+ u_pred_pos_horiz_abs_status_flag.real = this->pred_pos_horiz_abs_status_flag;
+ *(outbuffer + offset + 0) = (u_pred_pos_horiz_abs_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->pred_pos_horiz_abs_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_gps_glitch_status_flag;
+ u_gps_glitch_status_flag.real = this->gps_glitch_status_flag;
+ *(outbuffer + offset + 0) = (u_gps_glitch_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->gps_glitch_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_accel_error_status_flag;
+ u_accel_error_status_flag.real = this->accel_error_status_flag;
+ *(outbuffer + offset + 0) = (u_accel_error_status_flag.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->accel_error_status_flag);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_attitude_status_flag;
+ u_attitude_status_flag.base = 0;
+ u_attitude_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->attitude_status_flag = u_attitude_status_flag.real;
+ offset += sizeof(this->attitude_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_velocity_horiz_status_flag;
+ u_velocity_horiz_status_flag.base = 0;
+ u_velocity_horiz_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->velocity_horiz_status_flag = u_velocity_horiz_status_flag.real;
+ offset += sizeof(this->velocity_horiz_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_velocity_vert_status_flag;
+ u_velocity_vert_status_flag.base = 0;
+ u_velocity_vert_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->velocity_vert_status_flag = u_velocity_vert_status_flag.real;
+ offset += sizeof(this->velocity_vert_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_horiz_rel_status_flag;
+ u_pos_horiz_rel_status_flag.base = 0;
+ u_pos_horiz_rel_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->pos_horiz_rel_status_flag = u_pos_horiz_rel_status_flag.real;
+ offset += sizeof(this->pos_horiz_rel_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_horiz_abs_status_flag;
+ u_pos_horiz_abs_status_flag.base = 0;
+ u_pos_horiz_abs_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->pos_horiz_abs_status_flag = u_pos_horiz_abs_status_flag.real;
+ offset += sizeof(this->pos_horiz_abs_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_vert_abs_status_flag;
+ u_pos_vert_abs_status_flag.base = 0;
+ u_pos_vert_abs_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->pos_vert_abs_status_flag = u_pos_vert_abs_status_flag.real;
+ offset += sizeof(this->pos_vert_abs_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pos_vert_agl_status_flag;
+ u_pos_vert_agl_status_flag.base = 0;
+ u_pos_vert_agl_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->pos_vert_agl_status_flag = u_pos_vert_agl_status_flag.real;
+ offset += sizeof(this->pos_vert_agl_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_const_pos_mode_status_flag;
+ u_const_pos_mode_status_flag.base = 0;
+ u_const_pos_mode_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->const_pos_mode_status_flag = u_const_pos_mode_status_flag.real;
+ offset += sizeof(this->const_pos_mode_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pred_pos_horiz_rel_status_flag;
+ u_pred_pos_horiz_rel_status_flag.base = 0;
+ u_pred_pos_horiz_rel_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->pred_pos_horiz_rel_status_flag = u_pred_pos_horiz_rel_status_flag.real;
+ offset += sizeof(this->pred_pos_horiz_rel_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_pred_pos_horiz_abs_status_flag;
+ u_pred_pos_horiz_abs_status_flag.base = 0;
+ u_pred_pos_horiz_abs_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->pred_pos_horiz_abs_status_flag = u_pred_pos_horiz_abs_status_flag.real;
+ offset += sizeof(this->pred_pos_horiz_abs_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_gps_glitch_status_flag;
+ u_gps_glitch_status_flag.base = 0;
+ u_gps_glitch_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->gps_glitch_status_flag = u_gps_glitch_status_flag.real;
+ offset += sizeof(this->gps_glitch_status_flag);
+ union {
+ bool real;
+ uint8_t base;
+ } u_accel_error_status_flag;
+ u_accel_error_status_flag.base = 0;
+ u_accel_error_status_flag.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->accel_error_status_flag = u_accel_error_status_flag.real;
+ offset += sizeof(this->accel_error_status_flag);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/EstimatorStatus"; };
+ const char * getMD5(){ return "39dbcc4be3f04b68422f784827c47dd5"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ExtendedState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,68 @@
+#ifndef _ROS_mavros_msgs_ExtendedState_h
+#define _ROS_mavros_msgs_ExtendedState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class ExtendedState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _vtol_state_type;
+ _vtol_state_type vtol_state;
+ typedef uint8_t _landed_state_type;
+ _landed_state_type landed_state;
+ enum { VTOL_STATE_UNDEFINED = 0 };
+ enum { VTOL_STATE_TRANSITION_TO_FW = 1 };
+ enum { VTOL_STATE_TRANSITION_TO_MC = 2 };
+ enum { VTOL_STATE_MC = 3 };
+ enum { VTOL_STATE_FW = 4 };
+ enum { LANDED_STATE_UNDEFINED = 0 };
+ enum { LANDED_STATE_ON_GROUND = 1 };
+ enum { LANDED_STATE_IN_AIR = 2 };
+ enum { LANDED_STATE_TAKEOFF = 3 };
+ enum { LANDED_STATE_LANDING = 4 };
+
+ ExtendedState():
+ header(),
+ vtol_state(0),
+ landed_state(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->vtol_state >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->vtol_state);
+ *(outbuffer + offset + 0) = (this->landed_state >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->landed_state);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->vtol_state = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->vtol_state);
+ this->landed_state = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->landed_state);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/ExtendedState"; };
+ const char * getMD5(){ return "ae780b1800fe17b917369d21b90058bd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileChecksum.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,142 @@
+#ifndef _ROS_SERVICE_FileChecksum_h
+#define _ROS_SERVICE_FileChecksum_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILECHECKSUM[] = "mavros_msgs/FileChecksum";
+
+ class FileChecksumRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _file_path_type;
+ _file_path_type file_path;
+
+ FileChecksumRequest():
+ file_path("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_file_path = strlen(this->file_path);
+ varToArr(outbuffer + offset, length_file_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file_path, length_file_path);
+ offset += length_file_path;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_file_path;
+ arrToVar(length_file_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file_path-1]=0;
+ this->file_path = (char *)(inbuffer + offset-1);
+ offset += length_file_path;
+ return offset;
+ }
+
+ const char * getType(){ return FILECHECKSUM; };
+ const char * getMD5(){ return "a1f82596372c52a517e1fe32d1e998e8"; };
+
+ };
+
+ class FileChecksumResponse : public ros::Msg
+ {
+ public:
+ typedef uint32_t _crc32_type;
+ _crc32_type crc32;
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileChecksumResponse():
+ crc32(0),
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->crc32 >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->crc32 >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->crc32 >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->crc32 >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->crc32);
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->crc32 = ((uint32_t) (*(inbuffer + offset)));
+ this->crc32 |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->crc32 |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->crc32 |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->crc32);
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILECHECKSUM; };
+ const char * getMD5(){ return "8ecf737b97670b745ca39c7b185cc756"; };
+
+ };
+
+ class FileChecksum {
+ public:
+ typedef FileChecksumRequest Request;
+ typedef FileChecksumResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileClose.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,129 @@
+#ifndef _ROS_SERVICE_FileClose_h
+#define _ROS_SERVICE_FileClose_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILECLOSE[] = "mavros_msgs/FileClose";
+
+ class FileCloseRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _file_path_type;
+ _file_path_type file_path;
+
+ FileCloseRequest():
+ file_path("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_file_path = strlen(this->file_path);
+ varToArr(outbuffer + offset, length_file_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file_path, length_file_path);
+ offset += length_file_path;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_file_path;
+ arrToVar(length_file_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file_path-1]=0;
+ this->file_path = (char *)(inbuffer + offset-1);
+ offset += length_file_path;
+ return offset;
+ }
+
+ const char * getType(){ return FILECLOSE; };
+ const char * getMD5(){ return "a1f82596372c52a517e1fe32d1e998e8"; };
+
+ };
+
+ class FileCloseResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileCloseResponse():
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILECLOSE; };
+ const char * getMD5(){ return "85394f2e941a8937ac567a617f06157f"; };
+
+ };
+
+ class FileClose {
+ public:
+ typedef FileCloseRequest Request;
+ typedef FileCloseResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileEntry.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_mavros_msgs_FileEntry_h
+#define _ROS_mavros_msgs_FileEntry_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+ class FileEntry : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef uint8_t _type_type;
+ _type_type type;
+ typedef uint64_t _size_type;
+ _size_type size;
+ enum { TYPE_FILE = 0 };
+ enum { TYPE_DIRECTORY = 1 };
+
+ FileEntry():
+ name(""),
+ type(0),
+ size(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_size;
+ u_size.real = this->size;
+ *(outbuffer + offset + 0) = (u_size.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_size.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_size.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_size.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->size);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_size;
+ u_size.base = 0;
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->size = u_size.real;
+ offset += sizeof(this->size);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/FileEntry"; };
+ const char * getMD5(){ return "5ed706bccb946c5b3a5087569cc53ac3"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileList.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,155 @@
+#ifndef _ROS_SERVICE_FileList_h
+#define _ROS_SERVICE_FileList_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mavros_msgs/FileEntry.h"
+
+namespace mavros_msgs
+{
+
+static const char FILELIST[] = "mavros_msgs/FileList";
+
+ class FileListRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _dir_path_type;
+ _dir_path_type dir_path;
+
+ FileListRequest():
+ dir_path("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_dir_path = strlen(this->dir_path);
+ varToArr(outbuffer + offset, length_dir_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->dir_path, length_dir_path);
+ offset += length_dir_path;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_dir_path;
+ arrToVar(length_dir_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_dir_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_dir_path-1]=0;
+ this->dir_path = (char *)(inbuffer + offset-1);
+ offset += length_dir_path;
+ return offset;
+ }
+
+ const char * getType(){ return FILELIST; };
+ const char * getMD5(){ return "401d5cf5f836aaa9ebdc0897f75da874"; };
+
+ };
+
+ class FileListResponse : public ros::Msg
+ {
+ public:
+ uint32_t list_length;
+ typedef mavros_msgs::FileEntry _list_type;
+ _list_type st_list;
+ _list_type * list;
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileListResponse():
+ list_length(0), list(NULL),
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->list_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->list_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->list_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->list_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->list_length);
+ for( uint32_t i = 0; i < list_length; i++){
+ offset += this->list[i].serialize(outbuffer + offset);
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t list_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ list_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ list_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ list_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->list_length);
+ if(list_lengthT > list_length)
+ this->list = (mavros_msgs::FileEntry*)realloc(this->list, list_lengthT * sizeof(mavros_msgs::FileEntry));
+ list_length = list_lengthT;
+ for( uint32_t i = 0; i < list_length; i++){
+ offset += this->st_list.deserialize(inbuffer + offset);
+ memcpy( &(this->list[i]), &(this->st_list), sizeof(mavros_msgs::FileEntry));
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILELIST; };
+ const char * getMD5(){ return "3cf4be333d40be8a08832e3b61ed4336"; };
+
+ };
+
+ class FileList {
+ public:
+ typedef FileListRequest Request;
+ typedef FileListResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileMakeDir.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,129 @@
+#ifndef _ROS_SERVICE_FileMakeDir_h
+#define _ROS_SERVICE_FileMakeDir_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILEMAKEDIR[] = "mavros_msgs/FileMakeDir";
+
+ class FileMakeDirRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _dir_path_type;
+ _dir_path_type dir_path;
+
+ FileMakeDirRequest():
+ dir_path("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_dir_path = strlen(this->dir_path);
+ varToArr(outbuffer + offset, length_dir_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->dir_path, length_dir_path);
+ offset += length_dir_path;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_dir_path;
+ arrToVar(length_dir_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_dir_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_dir_path-1]=0;
+ this->dir_path = (char *)(inbuffer + offset-1);
+ offset += length_dir_path;
+ return offset;
+ }
+
+ const char * getType(){ return FILEMAKEDIR; };
+ const char * getMD5(){ return "401d5cf5f836aaa9ebdc0897f75da874"; };
+
+ };
+
+ class FileMakeDirResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileMakeDirResponse():
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILEMAKEDIR; };
+ const char * getMD5(){ return "85394f2e941a8937ac567a617f06157f"; };
+
+ };
+
+ class FileMakeDir {
+ public:
+ typedef FileMakeDirRequest Request;
+ typedef FileMakeDirResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileOpen.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,152 @@
+#ifndef _ROS_SERVICE_FileOpen_h
+#define _ROS_SERVICE_FileOpen_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILEOPEN[] = "mavros_msgs/FileOpen";
+
+ class FileOpenRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _file_path_type;
+ _file_path_type file_path;
+ typedef uint8_t _mode_type;
+ _mode_type mode;
+ enum { MODE_READ = 0 };
+ enum { MODE_WRITE = 1 };
+ enum { MODE_CREATE = 2 };
+
+ FileOpenRequest():
+ file_path(""),
+ mode(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_file_path = strlen(this->file_path);
+ varToArr(outbuffer + offset, length_file_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file_path, length_file_path);
+ offset += length_file_path;
+ *(outbuffer + offset + 0) = (this->mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mode);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_file_path;
+ arrToVar(length_file_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file_path-1]=0;
+ this->file_path = (char *)(inbuffer + offset-1);
+ offset += length_file_path;
+ this->mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->mode);
+ return offset;
+ }
+
+ const char * getType(){ return FILEOPEN; };
+ const char * getMD5(){ return "5d3365f008508e7b1c9862cdbc4459de"; };
+
+ };
+
+ class FileOpenResponse : public ros::Msg
+ {
+ public:
+ typedef uint32_t _size_type;
+ _size_type size;
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileOpenResponse():
+ size(0),
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->size >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->size >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->size >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->size >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->size);
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->size = ((uint32_t) (*(inbuffer + offset)));
+ this->size |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->size |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->size |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->size);
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILEOPEN; };
+ const char * getMD5(){ return "0ff9b1d5b96094ef5adccef61431a04f"; };
+
+ };
+
+ class FileOpen {
+ public:
+ typedef FileOpenRequest Request;
+ typedef FileOpenResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileRead.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,204 @@
+#ifndef _ROS_SERVICE_FileRead_h
+#define _ROS_SERVICE_FileRead_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILEREAD[] = "mavros_msgs/FileRead";
+
+ class FileReadRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _file_path_type;
+ _file_path_type file_path;
+ typedef uint64_t _offset_type;
+ _offset_type offset;
+ typedef uint64_t _size_type;
+ _size_type size;
+
+ FileReadRequest():
+ file_path(""),
+ offset(0),
+ size(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_file_path = strlen(this->file_path);
+ varToArr(outbuffer + offset, length_file_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file_path, length_file_path);
+ offset += length_file_path;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_offset;
+ u_offset.real = this->offset;
+ *(outbuffer + offset + 0) = (u_offset.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_offset.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_offset.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_offset.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->offset);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_size;
+ u_size.real = this->size;
+ *(outbuffer + offset + 0) = (u_size.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_size.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_size.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_size.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->size);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_file_path;
+ arrToVar(length_file_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file_path-1]=0;
+ this->file_path = (char *)(inbuffer + offset-1);
+ offset += length_file_path;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_offset;
+ u_offset.base = 0;
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->offset = u_offset.real;
+ offset += sizeof(this->offset);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_size;
+ u_size.base = 0;
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_size.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->size = u_size.real;
+ offset += sizeof(this->size);
+ return offset;
+ }
+
+ const char * getType(){ return FILEREAD; };
+ const char * getMD5(){ return "c83da8c18af06c9d7d1b66667fa2bb6b"; };
+
+ };
+
+ class FileReadResponse : public ros::Msg
+ {
+ public:
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileReadResponse():
+ data_length(0), data(NULL),
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILEREAD; };
+ const char * getMD5(){ return "729aa1e22d45390356095d59a2993cb4"; };
+
+ };
+
+ class FileRead {
+ public:
+ typedef FileReadRequest Request;
+ typedef FileReadResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileRemove.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,129 @@
+#ifndef _ROS_SERVICE_FileRemove_h
+#define _ROS_SERVICE_FileRemove_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILEREMOVE[] = "mavros_msgs/FileRemove";
+
+ class FileRemoveRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _file_path_type;
+ _file_path_type file_path;
+
+ FileRemoveRequest():
+ file_path("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_file_path = strlen(this->file_path);
+ varToArr(outbuffer + offset, length_file_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file_path, length_file_path);
+ offset += length_file_path;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_file_path;
+ arrToVar(length_file_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file_path-1]=0;
+ this->file_path = (char *)(inbuffer + offset-1);
+ offset += length_file_path;
+ return offset;
+ }
+
+ const char * getType(){ return FILEREMOVE; };
+ const char * getMD5(){ return "a1f82596372c52a517e1fe32d1e998e8"; };
+
+ };
+
+ class FileRemoveResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileRemoveResponse():
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILEREMOVE; };
+ const char * getMD5(){ return "85394f2e941a8937ac567a617f06157f"; };
+
+ };
+
+ class FileRemove {
+ public:
+ typedef FileRemoveRequest Request;
+ typedef FileRemoveResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileRemoveDir.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,129 @@
+#ifndef _ROS_SERVICE_FileRemoveDir_h
+#define _ROS_SERVICE_FileRemoveDir_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILEREMOVEDIR[] = "mavros_msgs/FileRemoveDir";
+
+ class FileRemoveDirRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _dir_path_type;
+ _dir_path_type dir_path;
+
+ FileRemoveDirRequest():
+ dir_path("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_dir_path = strlen(this->dir_path);
+ varToArr(outbuffer + offset, length_dir_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->dir_path, length_dir_path);
+ offset += length_dir_path;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_dir_path;
+ arrToVar(length_dir_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_dir_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_dir_path-1]=0;
+ this->dir_path = (char *)(inbuffer + offset-1);
+ offset += length_dir_path;
+ return offset;
+ }
+
+ const char * getType(){ return FILEREMOVEDIR; };
+ const char * getMD5(){ return "401d5cf5f836aaa9ebdc0897f75da874"; };
+
+ };
+
+ class FileRemoveDirResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileRemoveDirResponse():
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILEREMOVEDIR; };
+ const char * getMD5(){ return "85394f2e941a8937ac567a617f06157f"; };
+
+ };
+
+ class FileRemoveDir {
+ public:
+ typedef FileRemoveDirRequest Request;
+ typedef FileRemoveDirResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileRename.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,146 @@
+#ifndef _ROS_SERVICE_FileRename_h
+#define _ROS_SERVICE_FileRename_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILERENAME[] = "mavros_msgs/FileRename";
+
+ class FileRenameRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _old_path_type;
+ _old_path_type old_path;
+ typedef const char* _new_path_type;
+ _new_path_type new_path;
+
+ FileRenameRequest():
+ old_path(""),
+ new_path("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_old_path = strlen(this->old_path);
+ varToArr(outbuffer + offset, length_old_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->old_path, length_old_path);
+ offset += length_old_path;
+ uint32_t length_new_path = strlen(this->new_path);
+ varToArr(outbuffer + offset, length_new_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->new_path, length_new_path);
+ offset += length_new_path;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_old_path;
+ arrToVar(length_old_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_old_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_old_path-1]=0;
+ this->old_path = (char *)(inbuffer + offset-1);
+ offset += length_old_path;
+ uint32_t length_new_path;
+ arrToVar(length_new_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_new_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_new_path-1]=0;
+ this->new_path = (char *)(inbuffer + offset-1);
+ offset += length_new_path;
+ return offset;
+ }
+
+ const char * getType(){ return FILERENAME; };
+ const char * getMD5(){ return "e4a29684c4f7a3290a1bec0a9de2ed01"; };
+
+ };
+
+ class FileRenameResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileRenameResponse():
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILERENAME; };
+ const char * getMD5(){ return "85394f2e941a8937ac567a617f06157f"; };
+
+ };
+
+ class FileRename {
+ public:
+ typedef FileRenameRequest Request;
+ typedef FileRenameResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileTruncate.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,153 @@
+#ifndef _ROS_SERVICE_FileTruncate_h
+#define _ROS_SERVICE_FileTruncate_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILETRUNCATE[] = "mavros_msgs/FileTruncate";
+
+ class FileTruncateRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _file_path_type;
+ _file_path_type file_path;
+ typedef uint64_t _length_type;
+ _length_type length;
+
+ FileTruncateRequest():
+ file_path(""),
+ length(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_file_path = strlen(this->file_path);
+ varToArr(outbuffer + offset, length_file_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file_path, length_file_path);
+ offset += length_file_path;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_length;
+ u_length.real = this->length;
+ *(outbuffer + offset + 0) = (u_length.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_length.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_length.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_length.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->length);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_file_path;
+ arrToVar(length_file_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file_path-1]=0;
+ this->file_path = (char *)(inbuffer + offset-1);
+ offset += length_file_path;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_length;
+ u_length.base = 0;
+ u_length.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_length.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_length.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_length.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->length = u_length.real;
+ offset += sizeof(this->length);
+ return offset;
+ }
+
+ const char * getType(){ return FILETRUNCATE; };
+ const char * getMD5(){ return "8153dbfb1601dd12c2e69aba3171d186"; };
+
+ };
+
+ class FileTruncateResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileTruncateResponse():
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILETRUNCATE; };
+ const char * getMD5(){ return "85394f2e941a8937ac567a617f06157f"; };
+
+ };
+
+ class FileTruncate {
+ public:
+ typedef FileTruncateRequest Request;
+ typedef FileTruncateResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/FileWrite.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,180 @@
+#ifndef _ROS_SERVICE_FileWrite_h
+#define _ROS_SERVICE_FileWrite_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char FILEWRITE[] = "mavros_msgs/FileWrite";
+
+ class FileWriteRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _file_path_type;
+ _file_path_type file_path;
+ typedef uint64_t _offset_type;
+ _offset_type offset;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ FileWriteRequest():
+ file_path(""),
+ offset(0),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_file_path = strlen(this->file_path);
+ varToArr(outbuffer + offset, length_file_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file_path, length_file_path);
+ offset += length_file_path;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_offset;
+ u_offset.real = this->offset;
+ *(outbuffer + offset + 0) = (u_offset.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_offset.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_offset.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_offset.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_file_path;
+ arrToVar(length_file_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file_path-1]=0;
+ this->file_path = (char *)(inbuffer + offset-1);
+ offset += length_file_path;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_offset;
+ u_offset.base = 0;
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_offset.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->offset = u_offset.real;
+ offset += sizeof(this->offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return FILEWRITE; };
+ const char * getMD5(){ return "cf1a270aa1398f3f1fac1649fe2275ef"; };
+
+ };
+
+ class FileWriteResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef int32_t _r_errno_type;
+ _r_errno_type r_errno;
+
+ FileWriteResponse():
+ success(0),
+ r_errno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.real = this->r_errno;
+ *(outbuffer + offset + 0) = (u_r_errno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r_errno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r_errno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r_errno.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_r_errno;
+ u_r_errno.base = 0;
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r_errno.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r_errno = u_r_errno.real;
+ offset += sizeof(this->r_errno);
+ return offset;
+ }
+
+ const char * getType(){ return FILEWRITE; };
+ const char * getMD5(){ return "85394f2e941a8937ac567a617f06157f"; };
+
+ };
+
+ class FileWrite {
+ public:
+ typedef FileWriteRequest Request;
+ typedef FileWriteResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/GlobalPositionTarget.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,222 @@
+#ifndef _ROS_mavros_msgs_GlobalPositionTarget_h
+#define _ROS_mavros_msgs_GlobalPositionTarget_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mavros_msgs
+{
+
+ class GlobalPositionTarget : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _coordinate_frame_type;
+ _coordinate_frame_type coordinate_frame;
+ typedef uint16_t _type_mask_type;
+ _type_mask_type type_mask;
+ typedef double _latitude_type;
+ _latitude_type latitude;
+ typedef double _longitude_type;
+ _longitude_type longitude;
+ typedef float _altitude_type;
+ _altitude_type altitude;
+ typedef geometry_msgs::Vector3 _velocity_type;
+ _velocity_type velocity;
+ typedef geometry_msgs::Vector3 _acceleration_or_force_type;
+ _acceleration_or_force_type acceleration_or_force;
+ typedef float _yaw_type;
+ _yaw_type yaw;
+ typedef float _yaw_rate_type;
+ _yaw_rate_type yaw_rate;
+ enum { FRAME_GLOBAL_INT = 5 };
+ enum { FRAME_GLOBAL_REL_ALT = 6 };
+ enum { FRAME_GLOBAL_TERRAIN_ALT = 11 };
+ enum { IGNORE_LATITUDE = 1 };
+ enum { IGNORE_LONGITUDE = 2 };
+ enum { IGNORE_ALTITUDE = 4 };
+ enum { IGNORE_VX = 8 };
+ enum { IGNORE_VY = 16 };
+ enum { IGNORE_VZ = 32 };
+ enum { IGNORE_AFX = 64 };
+ enum { IGNORE_AFY = 128 };
+ enum { IGNORE_AFZ = 256 };
+ enum { FORCE = 512 };
+ enum { IGNORE_YAW = 1024 };
+ enum { IGNORE_YAW_RATE = 2048 };
+
+ GlobalPositionTarget():
+ header(),
+ coordinate_frame(0),
+ type_mask(0),
+ latitude(0),
+ longitude(0),
+ altitude(0),
+ velocity(),
+ acceleration_or_force(),
+ yaw(0),
+ yaw_rate(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->coordinate_frame >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->coordinate_frame);
+ *(outbuffer + offset + 0) = (this->type_mask >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->type_mask >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->type_mask);
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->altitude);
+ offset += this->velocity.serialize(outbuffer + offset);
+ offset += this->acceleration_or_force.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.real = this->yaw;
+ *(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw_rate;
+ u_yaw_rate.real = this->yaw_rate;
+ *(outbuffer + offset + 0) = (u_yaw_rate.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw_rate.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw_rate.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw_rate.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw_rate);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->coordinate_frame = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->coordinate_frame);
+ this->type_mask = ((uint16_t) (*(inbuffer + offset)));
+ this->type_mask |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->type_mask);
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ offset += this->velocity.deserialize(inbuffer + offset);
+ offset += this->acceleration_or_force.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.base = 0;
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw = u_yaw.real;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw_rate;
+ u_yaw_rate.base = 0;
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw_rate = u_yaw_rate.real;
+ offset += sizeof(this->yaw_rate);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/GlobalPositionTarget"; };
+ const char * getMD5(){ return "076ded0190b9e045f9c55264659ef102"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/HilActuatorControls.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,102 @@
+#ifndef _ROS_mavros_msgs_HilActuatorControls_h
+#define _ROS_mavros_msgs_HilActuatorControls_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class HilActuatorControls : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ float controls[16];
+ typedef uint8_t _mode_type;
+ _mode_type mode;
+ typedef uint64_t _flags_type;
+ _flags_type flags;
+
+ HilActuatorControls():
+ header(),
+ controls(),
+ mode(0),
+ flags(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 16; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_controlsi;
+ u_controlsi.real = this->controls[i];
+ *(outbuffer + offset + 0) = (u_controlsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_controlsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_controlsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_controlsi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->controls[i]);
+ }
+ *(outbuffer + offset + 0) = (this->mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mode);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_flags;
+ u_flags.real = this->flags;
+ *(outbuffer + offset + 0) = (u_flags.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_flags.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_flags.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_flags.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->flags);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 16; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_controlsi;
+ u_controlsi.base = 0;
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_controlsi.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->controls[i] = u_controlsi.real;
+ offset += sizeof(this->controls[i]);
+ }
+ this->mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->mode);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_flags;
+ u_flags.base = 0;
+ u_flags.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_flags.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_flags.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_flags.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->flags = u_flags.real;
+ offset += sizeof(this->flags);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/HilActuatorControls"; };
+ const char * getMD5(){ return "18482e8ef0330ac2fc9a0421be1d11c3"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/HilControls.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,250 @@
+#ifndef _ROS_mavros_msgs_HilControls_h
+#define _ROS_mavros_msgs_HilControls_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class HilControls : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _roll_ailerons_type;
+ _roll_ailerons_type roll_ailerons;
+ typedef float _pitch_elevator_type;
+ _pitch_elevator_type pitch_elevator;
+ typedef float _yaw_rudder_type;
+ _yaw_rudder_type yaw_rudder;
+ typedef float _throttle_type;
+ _throttle_type throttle;
+ typedef float _aux1_type;
+ _aux1_type aux1;
+ typedef float _aux2_type;
+ _aux2_type aux2;
+ typedef float _aux3_type;
+ _aux3_type aux3;
+ typedef float _aux4_type;
+ _aux4_type aux4;
+ typedef uint8_t _mode_type;
+ _mode_type mode;
+ typedef uint8_t _nav_mode_type;
+ _nav_mode_type nav_mode;
+
+ HilControls():
+ header(),
+ roll_ailerons(0),
+ pitch_elevator(0),
+ yaw_rudder(0),
+ throttle(0),
+ aux1(0),
+ aux2(0),
+ aux3(0),
+ aux4(0),
+ mode(0),
+ nav_mode(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_roll_ailerons;
+ u_roll_ailerons.real = this->roll_ailerons;
+ *(outbuffer + offset + 0) = (u_roll_ailerons.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_roll_ailerons.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_roll_ailerons.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_roll_ailerons.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->roll_ailerons);
+ union {
+ float real;
+ uint32_t base;
+ } u_pitch_elevator;
+ u_pitch_elevator.real = this->pitch_elevator;
+ *(outbuffer + offset + 0) = (u_pitch_elevator.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_pitch_elevator.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_pitch_elevator.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_pitch_elevator.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->pitch_elevator);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw_rudder;
+ u_yaw_rudder.real = this->yaw_rudder;
+ *(outbuffer + offset + 0) = (u_yaw_rudder.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw_rudder.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw_rudder.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw_rudder.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw_rudder);
+ union {
+ float real;
+ uint32_t base;
+ } u_throttle;
+ u_throttle.real = this->throttle;
+ *(outbuffer + offset + 0) = (u_throttle.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_throttle.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_throttle.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_throttle.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->throttle);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux1;
+ u_aux1.real = this->aux1;
+ *(outbuffer + offset + 0) = (u_aux1.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_aux1.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_aux1.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_aux1.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->aux1);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux2;
+ u_aux2.real = this->aux2;
+ *(outbuffer + offset + 0) = (u_aux2.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_aux2.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_aux2.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_aux2.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->aux2);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux3;
+ u_aux3.real = this->aux3;
+ *(outbuffer + offset + 0) = (u_aux3.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_aux3.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_aux3.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_aux3.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->aux3);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux4;
+ u_aux4.real = this->aux4;
+ *(outbuffer + offset + 0) = (u_aux4.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_aux4.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_aux4.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_aux4.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->aux4);
+ *(outbuffer + offset + 0) = (this->mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mode);
+ *(outbuffer + offset + 0) = (this->nav_mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->nav_mode);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_roll_ailerons;
+ u_roll_ailerons.base = 0;
+ u_roll_ailerons.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_roll_ailerons.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_roll_ailerons.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_roll_ailerons.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->roll_ailerons = u_roll_ailerons.real;
+ offset += sizeof(this->roll_ailerons);
+ union {
+ float real;
+ uint32_t base;
+ } u_pitch_elevator;
+ u_pitch_elevator.base = 0;
+ u_pitch_elevator.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_pitch_elevator.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_pitch_elevator.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_pitch_elevator.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->pitch_elevator = u_pitch_elevator.real;
+ offset += sizeof(this->pitch_elevator);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw_rudder;
+ u_yaw_rudder.base = 0;
+ u_yaw_rudder.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw_rudder.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw_rudder.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw_rudder.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw_rudder = u_yaw_rudder.real;
+ offset += sizeof(this->yaw_rudder);
+ union {
+ float real;
+ uint32_t base;
+ } u_throttle;
+ u_throttle.base = 0;
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->throttle = u_throttle.real;
+ offset += sizeof(this->throttle);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux1;
+ u_aux1.base = 0;
+ u_aux1.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_aux1.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_aux1.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_aux1.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->aux1 = u_aux1.real;
+ offset += sizeof(this->aux1);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux2;
+ u_aux2.base = 0;
+ u_aux2.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_aux2.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_aux2.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_aux2.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->aux2 = u_aux2.real;
+ offset += sizeof(this->aux2);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux3;
+ u_aux3.base = 0;
+ u_aux3.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_aux3.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_aux3.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_aux3.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->aux3 = u_aux3.real;
+ offset += sizeof(this->aux3);
+ union {
+ float real;
+ uint32_t base;
+ } u_aux4;
+ u_aux4.base = 0;
+ u_aux4.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_aux4.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_aux4.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_aux4.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->aux4 = u_aux4.real;
+ offset += sizeof(this->aux4);
+ this->mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->mode);
+ this->nav_mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->nav_mode);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/HilControls"; };
+ const char * getMD5(){ return "698148349c3a2e5720afcae2d934acca"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/HilGPS.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,160 @@
+#ifndef _ROS_mavros_msgs_HilGPS_h
+#define _ROS_mavros_msgs_HilGPS_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geographic_msgs/GeoPoint.h"
+
+namespace mavros_msgs
+{
+
+ class HilGPS : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _fix_type_type;
+ _fix_type_type fix_type;
+ typedef geographic_msgs::GeoPoint _geo_type;
+ _geo_type geo;
+ typedef uint16_t _eph_type;
+ _eph_type eph;
+ typedef uint16_t _epv_type;
+ _epv_type epv;
+ typedef uint16_t _vel_type;
+ _vel_type vel;
+ typedef int16_t _vn_type;
+ _vn_type vn;
+ typedef int16_t _ve_type;
+ _ve_type ve;
+ typedef int16_t _vd_type;
+ _vd_type vd;
+ typedef uint16_t _cog_type;
+ _cog_type cog;
+ typedef uint8_t _satellites_visible_type;
+ _satellites_visible_type satellites_visible;
+
+ HilGPS():
+ header(),
+ fix_type(0),
+ geo(),
+ eph(0),
+ epv(0),
+ vel(0),
+ vn(0),
+ ve(0),
+ vd(0),
+ cog(0),
+ satellites_visible(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->fix_type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->fix_type);
+ offset += this->geo.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->eph >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->eph >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->eph);
+ *(outbuffer + offset + 0) = (this->epv >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->epv >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->epv);
+ *(outbuffer + offset + 0) = (this->vel >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->vel >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->vel);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_vn;
+ u_vn.real = this->vn;
+ *(outbuffer + offset + 0) = (u_vn.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_vn.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->vn);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_ve;
+ u_ve.real = this->ve;
+ *(outbuffer + offset + 0) = (u_ve.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_ve.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->ve);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_vd;
+ u_vd.real = this->vd;
+ *(outbuffer + offset + 0) = (u_vd.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_vd.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->vd);
+ *(outbuffer + offset + 0) = (this->cog >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->cog >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->cog);
+ *(outbuffer + offset + 0) = (this->satellites_visible >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->satellites_visible);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->fix_type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->fix_type);
+ offset += this->geo.deserialize(inbuffer + offset);
+ this->eph = ((uint16_t) (*(inbuffer + offset)));
+ this->eph |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->eph);
+ this->epv = ((uint16_t) (*(inbuffer + offset)));
+ this->epv |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->epv);
+ this->vel = ((uint16_t) (*(inbuffer + offset)));
+ this->vel |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->vel);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_vn;
+ u_vn.base = 0;
+ u_vn.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_vn.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->vn = u_vn.real;
+ offset += sizeof(this->vn);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_ve;
+ u_ve.base = 0;
+ u_ve.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_ve.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->ve = u_ve.real;
+ offset += sizeof(this->ve);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_vd;
+ u_vd.base = 0;
+ u_vd.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_vd.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->vd = u_vd.real;
+ offset += sizeof(this->vd);
+ this->cog = ((uint16_t) (*(inbuffer + offset)));
+ this->cog |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->cog);
+ this->satellites_visible = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->satellites_visible);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/HilGPS"; };
+ const char * getMD5(){ return "313b3baf2319db196fa18376a4900a7b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/HilSensor.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,169 @@
+#ifndef _ROS_mavros_msgs_HilSensor_h
+#define _ROS_mavros_msgs_HilSensor_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mavros_msgs
+{
+
+ class HilSensor : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Vector3 _acc_type;
+ _acc_type acc;
+ typedef geometry_msgs::Vector3 _gyro_type;
+ _gyro_type gyro;
+ typedef geometry_msgs::Vector3 _mag_type;
+ _mag_type mag;
+ typedef float _abs_pressure_type;
+ _abs_pressure_type abs_pressure;
+ typedef float _diff_pressure_type;
+ _diff_pressure_type diff_pressure;
+ typedef float _pressure_alt_type;
+ _pressure_alt_type pressure_alt;
+ typedef float _temperature_type;
+ _temperature_type temperature;
+ typedef uint32_t _fields_updated_type;
+ _fields_updated_type fields_updated;
+
+ HilSensor():
+ header(),
+ acc(),
+ gyro(),
+ mag(),
+ abs_pressure(0),
+ diff_pressure(0),
+ pressure_alt(0),
+ temperature(0),
+ fields_updated(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->acc.serialize(outbuffer + offset);
+ offset += this->gyro.serialize(outbuffer + offset);
+ offset += this->mag.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_abs_pressure;
+ u_abs_pressure.real = this->abs_pressure;
+ *(outbuffer + offset + 0) = (u_abs_pressure.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_abs_pressure.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_abs_pressure.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_abs_pressure.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->abs_pressure);
+ union {
+ float real;
+ uint32_t base;
+ } u_diff_pressure;
+ u_diff_pressure.real = this->diff_pressure;
+ *(outbuffer + offset + 0) = (u_diff_pressure.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_diff_pressure.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_diff_pressure.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_diff_pressure.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->diff_pressure);
+ union {
+ float real;
+ uint32_t base;
+ } u_pressure_alt;
+ u_pressure_alt.real = this->pressure_alt;
+ *(outbuffer + offset + 0) = (u_pressure_alt.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_pressure_alt.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_pressure_alt.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_pressure_alt.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->pressure_alt);
+ union {
+ float real;
+ uint32_t base;
+ } u_temperature;
+ u_temperature.real = this->temperature;
+ *(outbuffer + offset + 0) = (u_temperature.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_temperature.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_temperature.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_temperature.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->temperature);
+ *(outbuffer + offset + 0) = (this->fields_updated >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->fields_updated >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->fields_updated >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->fields_updated >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->fields_updated);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->acc.deserialize(inbuffer + offset);
+ offset += this->gyro.deserialize(inbuffer + offset);
+ offset += this->mag.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_abs_pressure;
+ u_abs_pressure.base = 0;
+ u_abs_pressure.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_abs_pressure.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_abs_pressure.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_abs_pressure.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->abs_pressure = u_abs_pressure.real;
+ offset += sizeof(this->abs_pressure);
+ union {
+ float real;
+ uint32_t base;
+ } u_diff_pressure;
+ u_diff_pressure.base = 0;
+ u_diff_pressure.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_diff_pressure.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_diff_pressure.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_diff_pressure.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->diff_pressure = u_diff_pressure.real;
+ offset += sizeof(this->diff_pressure);
+ union {
+ float real;
+ uint32_t base;
+ } u_pressure_alt;
+ u_pressure_alt.base = 0;
+ u_pressure_alt.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_pressure_alt.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_pressure_alt.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_pressure_alt.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->pressure_alt = u_pressure_alt.real;
+ offset += sizeof(this->pressure_alt);
+ union {
+ float real;
+ uint32_t base;
+ } u_temperature;
+ u_temperature.base = 0;
+ u_temperature.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_temperature.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_temperature.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_temperature.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->temperature = u_temperature.real;
+ offset += sizeof(this->temperature);
+ this->fields_updated = ((uint32_t) (*(inbuffer + offset)));
+ this->fields_updated |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->fields_updated |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->fields_updated |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->fields_updated);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/HilSensor"; };
+ const char * getMD5(){ return "2a892891e5c40d6dd1066bf1f394b5dc"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/HilStateQuaternion.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,120 @@
+#ifndef _ROS_mavros_msgs_HilStateQuaternion_h
+#define _ROS_mavros_msgs_HilStateQuaternion_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Quaternion.h"
+#include "geometry_msgs/Vector3.h"
+#include "geographic_msgs/GeoPoint.h"
+
+namespace mavros_msgs
+{
+
+ class HilStateQuaternion : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Quaternion _orientation_type;
+ _orientation_type orientation;
+ typedef geometry_msgs::Vector3 _angular_velocity_type;
+ _angular_velocity_type angular_velocity;
+ typedef geometry_msgs::Vector3 _linear_acceleration_type;
+ _linear_acceleration_type linear_acceleration;
+ typedef geometry_msgs::Vector3 _linear_velocity_type;
+ _linear_velocity_type linear_velocity;
+ typedef geographic_msgs::GeoPoint _geo_type;
+ _geo_type geo;
+ typedef float _ind_airspeed_type;
+ _ind_airspeed_type ind_airspeed;
+ typedef float _true_airspeed_type;
+ _true_airspeed_type true_airspeed;
+
+ HilStateQuaternion():
+ header(),
+ orientation(),
+ angular_velocity(),
+ linear_acceleration(),
+ linear_velocity(),
+ geo(),
+ ind_airspeed(0),
+ true_airspeed(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->orientation.serialize(outbuffer + offset);
+ offset += this->angular_velocity.serialize(outbuffer + offset);
+ offset += this->linear_acceleration.serialize(outbuffer + offset);
+ offset += this->linear_velocity.serialize(outbuffer + offset);
+ offset += this->geo.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_ind_airspeed;
+ u_ind_airspeed.real = this->ind_airspeed;
+ *(outbuffer + offset + 0) = (u_ind_airspeed.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_ind_airspeed.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_ind_airspeed.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_ind_airspeed.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ind_airspeed);
+ union {
+ float real;
+ uint32_t base;
+ } u_true_airspeed;
+ u_true_airspeed.real = this->true_airspeed;
+ *(outbuffer + offset + 0) = (u_true_airspeed.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_true_airspeed.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_true_airspeed.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_true_airspeed.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->true_airspeed);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->orientation.deserialize(inbuffer + offset);
+ offset += this->angular_velocity.deserialize(inbuffer + offset);
+ offset += this->linear_acceleration.deserialize(inbuffer + offset);
+ offset += this->linear_velocity.deserialize(inbuffer + offset);
+ offset += this->geo.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_ind_airspeed;
+ u_ind_airspeed.base = 0;
+ u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->ind_airspeed = u_ind_airspeed.real;
+ offset += sizeof(this->ind_airspeed);
+ union {
+ float real;
+ uint32_t base;
+ } u_true_airspeed;
+ u_true_airspeed.base = 0;
+ u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->true_airspeed = u_true_airspeed.real;
+ offset += sizeof(this->true_airspeed);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/HilStateQuaternion"; };
+ const char * getMD5(){ return "c858c0f05d4ab30256be7c53edee8e3c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/HomePosition.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,68 @@
+#ifndef _ROS_mavros_msgs_HomePosition_h
+#define _ROS_mavros_msgs_HomePosition_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geographic_msgs/GeoPoint.h"
+#include "geometry_msgs/Point.h"
+#include "geometry_msgs/Quaternion.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mavros_msgs
+{
+
+ class HomePosition : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geographic_msgs::GeoPoint _geo_type;
+ _geo_type geo;
+ typedef geometry_msgs::Point _position_type;
+ _position_type position;
+ typedef geometry_msgs::Quaternion _orientation_type;
+ _orientation_type orientation;
+ typedef geometry_msgs::Vector3 _approach_type;
+ _approach_type approach;
+
+ HomePosition():
+ header(),
+ geo(),
+ position(),
+ orientation(),
+ approach()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->geo.serialize(outbuffer + offset);
+ offset += this->position.serialize(outbuffer + offset);
+ offset += this->orientation.serialize(outbuffer + offset);
+ offset += this->approach.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->geo.deserialize(inbuffer + offset);
+ offset += this->position.deserialize(inbuffer + offset);
+ offset += this->orientation.deserialize(inbuffer + offset);
+ offset += this->approach.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/HomePosition"; };
+ const char * getMD5(){ return "c1167922de8c97acdb0ec714c1dba774"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/LandingTarget.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,165 @@
+#ifndef _ROS_mavros_msgs_LandingTarget_h
+#define _ROS_mavros_msgs_LandingTarget_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Pose.h"
+
+namespace mavros_msgs
+{
+
+ class LandingTarget : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _target_num_type;
+ _target_num_type target_num;
+ typedef uint8_t _frame_type;
+ _frame_type frame;
+ float angle[2];
+ typedef float _distance_type;
+ _distance_type distance;
+ float size[2];
+ typedef geometry_msgs::Pose _pose_type;
+ _pose_type pose;
+ typedef uint8_t _type_type;
+ _type_type type;
+ enum { GLOBAL = 0 };
+ enum { LOCAL_NED = 2 };
+ enum { MISSION = 3 };
+ enum { GLOBAL_RELATIVE_ALT = 4 };
+ enum { LOCAL_ENU = 5 };
+ enum { GLOBAL_INT = 6 };
+ enum { GLOBAL_RELATIVE_ALT_INT = 7 };
+ enum { LOCAL_OFFSET_NED = 8 };
+ enum { BODY_NED = 9 };
+ enum { BODY_OFFSET_NED = 10 };
+ enum { GLOBAL_TERRAIN_ALT = 11 };
+ enum { GLOBAL_TERRAIN_ALT_INT = 12 };
+ enum { LIGHT_BEACON = 0 };
+ enum { RADIO_BEACON = 1 };
+ enum { VISION_FIDUCIAL = 2 };
+ enum { VISION_OTHER = 3 };
+
+ LandingTarget():
+ header(),
+ target_num(0),
+ frame(0),
+ angle(),
+ distance(0),
+ size(),
+ pose(),
+ type(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->target_num >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->target_num);
+ *(outbuffer + offset + 0) = (this->frame >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->frame);
+ for( uint32_t i = 0; i < 2; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_anglei;
+ u_anglei.real = this->angle[i];
+ *(outbuffer + offset + 0) = (u_anglei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_anglei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_anglei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_anglei.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angle[i]);
+ }
+ union {
+ float real;
+ uint32_t base;
+ } u_distance;
+ u_distance.real = this->distance;
+ *(outbuffer + offset + 0) = (u_distance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_distance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_distance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_distance.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->distance);
+ for( uint32_t i = 0; i < 2; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_sizei;
+ u_sizei.real = this->size[i];
+ *(outbuffer + offset + 0) = (u_sizei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sizei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sizei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sizei.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->size[i]);
+ }
+ offset += this->pose.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->target_num = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->target_num);
+ this->frame = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->frame);
+ for( uint32_t i = 0; i < 2; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_anglei;
+ u_anglei.base = 0;
+ u_anglei.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_anglei.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_anglei.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_anglei.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angle[i] = u_anglei.real;
+ offset += sizeof(this->angle[i]);
+ }
+ union {
+ float real;
+ uint32_t base;
+ } u_distance;
+ u_distance.base = 0;
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->distance = u_distance.real;
+ offset += sizeof(this->distance);
+ for( uint32_t i = 0; i < 2; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_sizei;
+ u_sizei.base = 0;
+ u_sizei.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_sizei.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_sizei.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_sizei.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->size[i] = u_sizei.real;
+ offset += sizeof(this->size[i]);
+ }
+ offset += this->pose.deserialize(inbuffer + offset);
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/LandingTarget"; };
+ const char * getMD5(){ return "76548ee08437914830bb7319d04d5490"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/LogData.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,93 @@
+#ifndef _ROS_mavros_msgs_LogData_h
+#define _ROS_mavros_msgs_LogData_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class LogData : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint16_t _id_type;
+ _id_type id;
+ typedef uint32_t _offset_type;
+ _offset_type offset;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ LogData():
+ header(),
+ id(0),
+ offset(0),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->id);
+ *(outbuffer + offset + 0) = (this->offset >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->offset >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->offset >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->offset >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->id = ((uint16_t) (*(inbuffer + offset)));
+ this->id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->id);
+ this->offset = ((uint32_t) (*(inbuffer + offset)));
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/LogData"; };
+ const char * getMD5(){ return "ccaa27ba630f8f5d02c287763eb1e91b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/LogEntry.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_mavros_msgs_LogEntry_h
+#define _ROS_mavros_msgs_LogEntry_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "ros/time.h"
+
+namespace mavros_msgs
+{
+
+ class LogEntry : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint16_t _id_type;
+ _id_type id;
+ typedef uint16_t _num_logs_type;
+ _num_logs_type num_logs;
+ typedef uint16_t _last_log_num_type;
+ _last_log_num_type last_log_num;
+ typedef ros::Time _time_utc_type;
+ _time_utc_type time_utc;
+ typedef uint32_t _size_type;
+ _size_type size;
+
+ LogEntry():
+ header(),
+ id(0),
+ num_logs(0),
+ last_log_num(0),
+ time_utc(),
+ size(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->id);
+ *(outbuffer + offset + 0) = (this->num_logs >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->num_logs >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->num_logs);
+ *(outbuffer + offset + 0) = (this->last_log_num >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->last_log_num >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->last_log_num);
+ *(outbuffer + offset + 0) = (this->time_utc.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_utc.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_utc.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_utc.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_utc.sec);
+ *(outbuffer + offset + 0) = (this->time_utc.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_utc.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_utc.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_utc.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_utc.nsec);
+ *(outbuffer + offset + 0) = (this->size >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->size >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->size >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->size >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->size);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->id = ((uint16_t) (*(inbuffer + offset)));
+ this->id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->id);
+ this->num_logs = ((uint16_t) (*(inbuffer + offset)));
+ this->num_logs |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->num_logs);
+ this->last_log_num = ((uint16_t) (*(inbuffer + offset)));
+ this->last_log_num |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->last_log_num);
+ this->time_utc.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_utc.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_utc.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_utc.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_utc.sec);
+ this->time_utc.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_utc.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_utc.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_utc.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_utc.nsec);
+ this->size = ((uint32_t) (*(inbuffer + offset)));
+ this->size |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->size |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->size |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->size);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/LogEntry"; };
+ const char * getMD5(){ return "a1428fc1ec4b2bfc8ab0c0ead7cce571"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/LogRequestData.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,123 @@
+#ifndef _ROS_SERVICE_LogRequestData_h
+#define _ROS_SERVICE_LogRequestData_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char LOGREQUESTDATA[] = "mavros_msgs/LogRequestData";
+
+ class LogRequestDataRequest : public ros::Msg
+ {
+ public:
+ typedef uint16_t _id_type;
+ _id_type id;
+ typedef uint32_t _offset_type;
+ _offset_type offset;
+ typedef uint32_t _count_type;
+ _count_type count;
+
+ LogRequestDataRequest():
+ id(0),
+ offset(0),
+ count(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->id);
+ *(outbuffer + offset + 0) = (this->offset >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->offset >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->offset >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->offset >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->offset);
+ *(outbuffer + offset + 0) = (this->count >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->count >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->count >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->count >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->count);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->id = ((uint16_t) (*(inbuffer + offset)));
+ this->id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->id);
+ this->offset = ((uint32_t) (*(inbuffer + offset)));
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->offset);
+ this->count = ((uint32_t) (*(inbuffer + offset)));
+ this->count |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->count |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->count |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->count);
+ return offset;
+ }
+
+ const char * getType(){ return LOGREQUESTDATA; };
+ const char * getMD5(){ return "9bd5fb12d79dcd29b3f845d7dd682415"; };
+
+ };
+
+ class LogRequestDataResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ LogRequestDataResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return LOGREQUESTDATA; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class LogRequestData {
+ public:
+ typedef LogRequestDataRequest Request;
+ typedef LogRequestDataResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/LogRequestEnd.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_SERVICE_LogRequestEnd_h
+#define _ROS_SERVICE_LogRequestEnd_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char LOGREQUESTEND[] = "mavros_msgs/LogRequestEnd";
+
+ class LogRequestEndRequest : public ros::Msg
+ {
+ public:
+
+ LogRequestEndRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return LOGREQUESTEND; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class LogRequestEndResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ LogRequestEndResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return LOGREQUESTEND; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class LogRequestEnd {
+ public:
+ typedef LogRequestEndRequest Request;
+ typedef LogRequestEndResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/LogRequestList.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,106 @@
+#ifndef _ROS_SERVICE_LogRequestList_h
+#define _ROS_SERVICE_LogRequestList_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char LOGREQUESTLIST[] = "mavros_msgs/LogRequestList";
+
+ class LogRequestListRequest : public ros::Msg
+ {
+ public:
+ typedef uint16_t _start_type;
+ _start_type start;
+ typedef uint16_t _end_type;
+ _end_type end;
+
+ LogRequestListRequest():
+ start(0),
+ end(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->start >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->start >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->start);
+ *(outbuffer + offset + 0) = (this->end >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->end >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->end);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->start = ((uint16_t) (*(inbuffer + offset)));
+ this->start |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->start);
+ this->end = ((uint16_t) (*(inbuffer + offset)));
+ this->end |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->end);
+ return offset;
+ }
+
+ const char * getType(){ return LOGREQUESTLIST; };
+ const char * getMD5(){ return "43d5acd48e3ef1843fa7f45876501c02"; };
+
+ };
+
+ class LogRequestListResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ LogRequestListResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return LOGREQUESTLIST; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class LogRequestList {
+ public:
+ typedef LogRequestListRequest Request;
+ typedef LogRequestListResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ManualControl.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,149 @@
+#ifndef _ROS_mavros_msgs_ManualControl_h
+#define _ROS_mavros_msgs_ManualControl_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class ManualControl : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _x_type;
+ _x_type x;
+ typedef float _y_type;
+ _y_type y;
+ typedef float _z_type;
+ _z_type z;
+ typedef float _r_type;
+ _r_type r;
+ typedef uint16_t _buttons_type;
+ _buttons_type buttons;
+
+ ManualControl():
+ header(),
+ x(0),
+ y(0),
+ z(0),
+ r(0),
+ buttons(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_z;
+ u_z.real = this->z;
+ *(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->z);
+ union {
+ float real;
+ uint32_t base;
+ } u_r;
+ u_r.real = this->r;
+ *(outbuffer + offset + 0) = (u_r.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r);
+ *(outbuffer + offset + 0) = (this->buttons >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->buttons >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->buttons);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_z;
+ u_z.base = 0;
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->z = u_z.real;
+ offset += sizeof(this->z);
+ union {
+ float real;
+ uint32_t base;
+ } u_r;
+ u_r.base = 0;
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r = u_r.real;
+ offset += sizeof(this->r);
+ this->buttons = ((uint16_t) (*(inbuffer + offset)));
+ this->buttons |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->buttons);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/ManualControl"; };
+ const char * getMD5(){ return "c41e3298484ea98e05ac502ce55af59f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/Mavlink.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,198 @@
+#ifndef _ROS_mavros_msgs_Mavlink_h
+#define _ROS_mavros_msgs_Mavlink_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class Mavlink : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _framing_status_type;
+ _framing_status_type framing_status;
+ typedef uint8_t _magic_type;
+ _magic_type magic;
+ typedef uint8_t _len_type;
+ _len_type len;
+ typedef uint8_t _incompat_flags_type;
+ _incompat_flags_type incompat_flags;
+ typedef uint8_t _compat_flags_type;
+ _compat_flags_type compat_flags;
+ typedef uint8_t _seq_type;
+ _seq_type seq;
+ typedef uint8_t _sysid_type;
+ _sysid_type sysid;
+ typedef uint8_t _compid_type;
+ _compid_type compid;
+ typedef uint32_t _msgid_type;
+ _msgid_type msgid;
+ typedef uint16_t _checksum_type;
+ _checksum_type checksum;
+ uint32_t payload64_length;
+ typedef uint64_t _payload64_type;
+ _payload64_type st_payload64;
+ _payload64_type * payload64;
+ uint32_t signature_length;
+ typedef uint8_t _signature_type;
+ _signature_type st_signature;
+ _signature_type * signature;
+ enum { FRAMING_OK = 1 };
+ enum { FRAMING_BAD_CRC = 2 };
+ enum { FRAMING_BAD_SIGNATURE = 3 };
+ enum { MAVLINK_V10 = 254 };
+ enum { MAVLINK_V20 = 253 };
+
+ Mavlink():
+ header(),
+ framing_status(0),
+ magic(0),
+ len(0),
+ incompat_flags(0),
+ compat_flags(0),
+ seq(0),
+ sysid(0),
+ compid(0),
+ msgid(0),
+ checksum(0),
+ payload64_length(0), payload64(NULL),
+ signature_length(0), signature(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->framing_status >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->framing_status);
+ *(outbuffer + offset + 0) = (this->magic >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->magic);
+ *(outbuffer + offset + 0) = (this->len >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->len);
+ *(outbuffer + offset + 0) = (this->incompat_flags >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->incompat_flags);
+ *(outbuffer + offset + 0) = (this->compat_flags >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->compat_flags);
+ *(outbuffer + offset + 0) = (this->seq >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->seq);
+ *(outbuffer + offset + 0) = (this->sysid >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->sysid);
+ *(outbuffer + offset + 0) = (this->compid >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->compid);
+ *(outbuffer + offset + 0) = (this->msgid >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->msgid >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->msgid >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->msgid >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->msgid);
+ *(outbuffer + offset + 0) = (this->checksum >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->checksum >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->checksum);
+ *(outbuffer + offset + 0) = (this->payload64_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->payload64_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->payload64_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->payload64_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->payload64_length);
+ for( uint32_t i = 0; i < payload64_length; i++){
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_payload64i;
+ u_payload64i.real = this->payload64[i];
+ *(outbuffer + offset + 0) = (u_payload64i.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_payload64i.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_payload64i.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_payload64i.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->payload64[i]);
+ }
+ *(outbuffer + offset + 0) = (this->signature_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->signature_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->signature_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->signature_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->signature_length);
+ for( uint32_t i = 0; i < signature_length; i++){
+ *(outbuffer + offset + 0) = (this->signature[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->signature[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->framing_status = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->framing_status);
+ this->magic = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->magic);
+ this->len = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->len);
+ this->incompat_flags = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->incompat_flags);
+ this->compat_flags = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->compat_flags);
+ this->seq = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->seq);
+ this->sysid = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->sysid);
+ this->compid = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->compid);
+ this->msgid = ((uint32_t) (*(inbuffer + offset)));
+ this->msgid |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->msgid |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->msgid |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->msgid);
+ this->checksum = ((uint16_t) (*(inbuffer + offset)));
+ this->checksum |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->checksum);
+ uint32_t payload64_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ payload64_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ payload64_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ payload64_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->payload64_length);
+ if(payload64_lengthT > payload64_length)
+ this->payload64 = (uint64_t*)realloc(this->payload64, payload64_lengthT * sizeof(uint64_t));
+ payload64_length = payload64_lengthT;
+ for( uint32_t i = 0; i < payload64_length; i++){
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_st_payload64;
+ u_st_payload64.base = 0;
+ u_st_payload64.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_payload64.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_payload64.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_payload64.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_payload64 = u_st_payload64.real;
+ offset += sizeof(this->st_payload64);
+ memcpy( &(this->payload64[i]), &(this->st_payload64), sizeof(uint64_t));
+ }
+ uint32_t signature_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ signature_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ signature_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ signature_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->signature_length);
+ if(signature_lengthT > signature_length)
+ this->signature = (uint8_t*)realloc(this->signature, signature_lengthT * sizeof(uint8_t));
+ signature_length = signature_lengthT;
+ for( uint32_t i = 0; i < signature_length; i++){
+ this->st_signature = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_signature);
+ memcpy( &(this->signature[i]), &(this->st_signature), sizeof(uint8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/Mavlink"; };
+ const char * getMD5(){ return "41093e1fd0f3eea1da2aa33a177e5ba6"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/MessageInterval.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,125 @@
+#ifndef _ROS_SERVICE_MessageInterval_h
+#define _ROS_SERVICE_MessageInterval_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char MESSAGEINTERVAL[] = "mavros_msgs/MessageInterval";
+
+ class MessageIntervalRequest : public ros::Msg
+ {
+ public:
+ typedef uint32_t _message_id_type;
+ _message_id_type message_id;
+ typedef float _message_rate_type;
+ _message_rate_type message_rate;
+
+ MessageIntervalRequest():
+ message_id(0),
+ message_rate(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->message_id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->message_id >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->message_id >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->message_id >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->message_id);
+ union {
+ float real;
+ uint32_t base;
+ } u_message_rate;
+ u_message_rate.real = this->message_rate;
+ *(outbuffer + offset + 0) = (u_message_rate.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_message_rate.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_message_rate.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_message_rate.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->message_rate);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->message_id = ((uint32_t) (*(inbuffer + offset)));
+ this->message_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->message_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->message_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->message_id);
+ union {
+ float real;
+ uint32_t base;
+ } u_message_rate;
+ u_message_rate.base = 0;
+ u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_message_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->message_rate = u_message_rate.real;
+ offset += sizeof(this->message_rate);
+ return offset;
+ }
+
+ const char * getType(){ return MESSAGEINTERVAL; };
+ const char * getMD5(){ return "e0211a7928924521de24f3981706be52"; };
+
+ };
+
+ class MessageIntervalResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ MessageIntervalResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return MESSAGEINTERVAL; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class MessageInterval {
+ public:
+ typedef MessageIntervalRequest Request;
+ typedef MessageIntervalResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/MountConfigure.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,191 @@
+#ifndef _ROS_SERVICE_MountConfigure_h
+#define _ROS_SERVICE_MountConfigure_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+static const char MOUNTCONFIGURE[] = "mavros_msgs/MountConfigure";
+
+ class MountConfigureRequest : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _mode_type;
+ _mode_type mode;
+ typedef bool _stabilize_roll_type;
+ _stabilize_roll_type stabilize_roll;
+ typedef bool _stabilize_pitch_type;
+ _stabilize_pitch_type stabilize_pitch;
+ typedef bool _stabilize_yaw_type;
+ _stabilize_yaw_type stabilize_yaw;
+ typedef uint8_t _roll_input_type;
+ _roll_input_type roll_input;
+ typedef uint8_t _pitch_input_type;
+ _pitch_input_type pitch_input;
+ typedef uint8_t _yaw_input_type;
+ _yaw_input_type yaw_input;
+ enum { MODE_RETRACT = 0 };
+ enum { MODE_NEUTRAL = 1 };
+ enum { MODE_MAVLINK_TARGETING = 2 };
+ enum { MODE_RC_TARGETING = 3 };
+ enum { MODE_GPS_POINT = 4 };
+ enum { INPUT_ANGLE_BODY_FRAME = 0 };
+ enum { INPUT_ANGULAR_RATE = 1 };
+ enum { INPUT_ANGLE_ABSOLUTE_FRAME = 2 };
+
+ MountConfigureRequest():
+ header(),
+ mode(0),
+ stabilize_roll(0),
+ stabilize_pitch(0),
+ stabilize_yaw(0),
+ roll_input(0),
+ pitch_input(0),
+ yaw_input(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mode);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stabilize_roll;
+ u_stabilize_roll.real = this->stabilize_roll;
+ *(outbuffer + offset + 0) = (u_stabilize_roll.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->stabilize_roll);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stabilize_pitch;
+ u_stabilize_pitch.real = this->stabilize_pitch;
+ *(outbuffer + offset + 0) = (u_stabilize_pitch.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->stabilize_pitch);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stabilize_yaw;
+ u_stabilize_yaw.real = this->stabilize_yaw;
+ *(outbuffer + offset + 0) = (u_stabilize_yaw.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->stabilize_yaw);
+ *(outbuffer + offset + 0) = (this->roll_input >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->roll_input);
+ *(outbuffer + offset + 0) = (this->pitch_input >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->pitch_input);
+ *(outbuffer + offset + 0) = (this->yaw_input >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->yaw_input);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->mode);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stabilize_roll;
+ u_stabilize_roll.base = 0;
+ u_stabilize_roll.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->stabilize_roll = u_stabilize_roll.real;
+ offset += sizeof(this->stabilize_roll);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stabilize_pitch;
+ u_stabilize_pitch.base = 0;
+ u_stabilize_pitch.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->stabilize_pitch = u_stabilize_pitch.real;
+ offset += sizeof(this->stabilize_pitch);
+ union {
+ bool real;
+ uint8_t base;
+ } u_stabilize_yaw;
+ u_stabilize_yaw.base = 0;
+ u_stabilize_yaw.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->stabilize_yaw = u_stabilize_yaw.real;
+ offset += sizeof(this->stabilize_yaw);
+ this->roll_input = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->roll_input);
+ this->pitch_input = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->pitch_input);
+ this->yaw_input = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->yaw_input);
+ return offset;
+ }
+
+ const char * getType(){ return MOUNTCONFIGURE; };
+ const char * getMD5(){ return "6abfbffc4f7b14d5b05955b1813ae50e"; };
+
+ };
+
+ class MountConfigureResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint8_t _result_type;
+ _result_type result;
+
+ MountConfigureResponse():
+ success(0),
+ result(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->result >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->result = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->result);
+ return offset;
+ }
+
+ const char * getType(){ return MOUNTCONFIGURE; };
+ const char * getMD5(){ return "1cd894375e4e3d2861d2222772894fdb"; };
+
+ };
+
+ class MountConfigure {
+ public:
+ typedef MountConfigureRequest Request;
+ typedef MountConfigureResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/MountControl.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,200 @@
+#ifndef _ROS_mavros_msgs_MountControl_h
+#define _ROS_mavros_msgs_MountControl_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class MountControl : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _mode_type;
+ _mode_type mode;
+ typedef float _pitch_type;
+ _pitch_type pitch;
+ typedef float _roll_type;
+ _roll_type roll;
+ typedef float _yaw_type;
+ _yaw_type yaw;
+ typedef float _altitude_type;
+ _altitude_type altitude;
+ typedef float _latitude_type;
+ _latitude_type latitude;
+ typedef float _longitude_type;
+ _longitude_type longitude;
+ enum { MAV_MOUNT_MODE_RETRACT = 0 };
+ enum { MAV_MOUNT_MODE_NEUTRAL = 1 };
+ enum { MAV_MOUNT_MODE_MAVLINK_TARGETING = 2 };
+ enum { MAV_MOUNT_MODE_RC_TARGETING = 3 };
+ enum { MAV_MOUNT_MODE_GPS_POINT = 4 };
+
+ MountControl():
+ header(),
+ mode(0),
+ pitch(0),
+ roll(0),
+ yaw(0),
+ altitude(0),
+ latitude(0),
+ longitude(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mode);
+ union {
+ float real;
+ uint32_t base;
+ } u_pitch;
+ u_pitch.real = this->pitch;
+ *(outbuffer + offset + 0) = (u_pitch.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_pitch.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_pitch.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_pitch.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->pitch);
+ union {
+ float real;
+ uint32_t base;
+ } u_roll;
+ u_roll.real = this->roll;
+ *(outbuffer + offset + 0) = (u_roll.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_roll.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_roll.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_roll.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->roll);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.real = this->yaw;
+ *(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->altitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->longitude);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->mode);
+ union {
+ float real;
+ uint32_t base;
+ } u_pitch;
+ u_pitch.base = 0;
+ u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->pitch = u_pitch.real;
+ offset += sizeof(this->pitch);
+ union {
+ float real;
+ uint32_t base;
+ } u_roll;
+ u_roll.base = 0;
+ u_roll.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_roll.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_roll.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_roll.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->roll = u_roll.real;
+ offset += sizeof(this->roll);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.base = 0;
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw = u_yaw.real;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/MountControl"; };
+ const char * getMD5(){ return "214cf13a68b4fed9e2a77b1b436f144e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/OnboardComputerStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,327 @@
+#ifndef _ROS_mavros_msgs_OnboardComputerStatus_h
+#define _ROS_mavros_msgs_OnboardComputerStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class OnboardComputerStatus : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _component_type;
+ _component_type component;
+ typedef uint32_t _uptime_type;
+ _uptime_type uptime;
+ typedef uint8_t _type_type;
+ _type_type type;
+ uint8_t cpu_cores[8];
+ uint8_t cpu_combined[10];
+ uint8_t gpu_cores[4];
+ uint8_t gpu_combined[10];
+ typedef int8_t _temperature_board_type;
+ _temperature_board_type temperature_board;
+ int8_t temperature_core[8];
+ int16_t fan_speed[4];
+ typedef uint32_t _ram_usage_type;
+ _ram_usage_type ram_usage;
+ typedef uint32_t _ram_total_type;
+ _ram_total_type ram_total;
+ uint32_t storage_type[4];
+ uint32_t storage_usage[4];
+ uint32_t storage_total[4];
+ uint32_t link_type[6];
+ uint32_t link_tx_rate[6];
+ uint32_t link_rx_rate[6];
+ uint32_t link_tx_max[6];
+ uint32_t link_rx_max[6];
+
+ OnboardComputerStatus():
+ header(),
+ component(0),
+ uptime(0),
+ type(0),
+ cpu_cores(),
+ cpu_combined(),
+ gpu_cores(),
+ gpu_combined(),
+ temperature_board(0),
+ temperature_core(),
+ fan_speed(),
+ ram_usage(0),
+ ram_total(0),
+ storage_type(),
+ storage_usage(),
+ storage_total(),
+ link_type(),
+ link_tx_rate(),
+ link_rx_rate(),
+ link_tx_max(),
+ link_rx_max()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->component >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->component);
+ *(outbuffer + offset + 0) = (this->uptime >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->uptime >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->uptime >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->uptime >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->uptime);
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ for( uint32_t i = 0; i < 8; i++){
+ *(outbuffer + offset + 0) = (this->cpu_cores[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->cpu_cores[i]);
+ }
+ for( uint32_t i = 0; i < 10; i++){
+ *(outbuffer + offset + 0) = (this->cpu_combined[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->cpu_combined[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ *(outbuffer + offset + 0) = (this->gpu_cores[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->gpu_cores[i]);
+ }
+ for( uint32_t i = 0; i < 10; i++){
+ *(outbuffer + offset + 0) = (this->gpu_combined[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->gpu_combined[i]);
+ }
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_temperature_board;
+ u_temperature_board.real = this->temperature_board;
+ *(outbuffer + offset + 0) = (u_temperature_board.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->temperature_board);
+ for( uint32_t i = 0; i < 8; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_temperature_corei;
+ u_temperature_corei.real = this->temperature_core[i];
+ *(outbuffer + offset + 0) = (u_temperature_corei.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->temperature_core[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_fan_speedi;
+ u_fan_speedi.real = this->fan_speed[i];
+ *(outbuffer + offset + 0) = (u_fan_speedi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_fan_speedi.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->fan_speed[i]);
+ }
+ *(outbuffer + offset + 0) = (this->ram_usage >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->ram_usage >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->ram_usage >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->ram_usage >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ram_usage);
+ *(outbuffer + offset + 0) = (this->ram_total >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->ram_total >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->ram_total >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->ram_total >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ram_total);
+ for( uint32_t i = 0; i < 4; i++){
+ *(outbuffer + offset + 0) = (this->storage_type[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->storage_type[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->storage_type[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->storage_type[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->storage_type[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ *(outbuffer + offset + 0) = (this->storage_usage[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->storage_usage[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->storage_usage[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->storage_usage[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->storage_usage[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ *(outbuffer + offset + 0) = (this->storage_total[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->storage_total[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->storage_total[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->storage_total[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->storage_total[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ *(outbuffer + offset + 0) = (this->link_type[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->link_type[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->link_type[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->link_type[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->link_type[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ *(outbuffer + offset + 0) = (this->link_tx_rate[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->link_tx_rate[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->link_tx_rate[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->link_tx_rate[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->link_tx_rate[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ *(outbuffer + offset + 0) = (this->link_rx_rate[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->link_rx_rate[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->link_rx_rate[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->link_rx_rate[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->link_rx_rate[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ *(outbuffer + offset + 0) = (this->link_tx_max[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->link_tx_max[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->link_tx_max[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->link_tx_max[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->link_tx_max[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ *(outbuffer + offset + 0) = (this->link_rx_max[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->link_rx_max[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->link_rx_max[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->link_rx_max[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->link_rx_max[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->component = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->component);
+ this->uptime = ((uint32_t) (*(inbuffer + offset)));
+ this->uptime |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->uptime |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->uptime |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->uptime);
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ for( uint32_t i = 0; i < 8; i++){
+ this->cpu_cores[i] = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->cpu_cores[i]);
+ }
+ for( uint32_t i = 0; i < 10; i++){
+ this->cpu_combined[i] = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->cpu_combined[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ this->gpu_cores[i] = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->gpu_cores[i]);
+ }
+ for( uint32_t i = 0; i < 10; i++){
+ this->gpu_combined[i] = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->gpu_combined[i]);
+ }
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_temperature_board;
+ u_temperature_board.base = 0;
+ u_temperature_board.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->temperature_board = u_temperature_board.real;
+ offset += sizeof(this->temperature_board);
+ for( uint32_t i = 0; i < 8; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_temperature_corei;
+ u_temperature_corei.base = 0;
+ u_temperature_corei.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->temperature_core[i] = u_temperature_corei.real;
+ offset += sizeof(this->temperature_core[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_fan_speedi;
+ u_fan_speedi.base = 0;
+ u_fan_speedi.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_fan_speedi.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->fan_speed[i] = u_fan_speedi.real;
+ offset += sizeof(this->fan_speed[i]);
+ }
+ this->ram_usage = ((uint32_t) (*(inbuffer + offset)));
+ this->ram_usage |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->ram_usage |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->ram_usage |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->ram_usage);
+ this->ram_total = ((uint32_t) (*(inbuffer + offset)));
+ this->ram_total |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->ram_total |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->ram_total |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->ram_total);
+ for( uint32_t i = 0; i < 4; i++){
+ this->storage_type[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->storage_type[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->storage_type[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->storage_type[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->storage_type[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ this->storage_usage[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->storage_usage[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->storage_usage[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->storage_usage[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->storage_usage[i]);
+ }
+ for( uint32_t i = 0; i < 4; i++){
+ this->storage_total[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->storage_total[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->storage_total[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->storage_total[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->storage_total[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ this->link_type[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->link_type[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->link_type[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->link_type[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->link_type[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ this->link_tx_rate[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->link_tx_rate[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->link_tx_rate[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->link_tx_rate[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->link_tx_rate[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ this->link_rx_rate[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->link_rx_rate[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->link_rx_rate[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->link_rx_rate[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->link_rx_rate[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ this->link_tx_max[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->link_tx_max[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->link_tx_max[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->link_tx_max[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->link_tx_max[i]);
+ }
+ for( uint32_t i = 0; i < 6; i++){
+ this->link_rx_max[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->link_rx_max[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->link_rx_max[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->link_rx_max[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->link_rx_max[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/OnboardComputerStatus"; };
+ const char * getMD5(){ return "aebe864fac2952ca9de45a2b65875a60"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/OpticalFlowRad.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,241 @@
+#ifndef _ROS_mavros_msgs_OpticalFlowRad_h
+#define _ROS_mavros_msgs_OpticalFlowRad_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class OpticalFlowRad : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint32_t _integration_time_us_type;
+ _integration_time_us_type integration_time_us;
+ typedef float _integrated_x_type;
+ _integrated_x_type integrated_x;
+ typedef float _integrated_y_type;
+ _integrated_y_type integrated_y;
+ typedef float _integrated_xgyro_type;
+ _integrated_xgyro_type integrated_xgyro;
+ typedef float _integrated_ygyro_type;
+ _integrated_ygyro_type integrated_ygyro;
+ typedef float _integrated_zgyro_type;
+ _integrated_zgyro_type integrated_zgyro;
+ typedef int16_t _temperature_type;
+ _temperature_type temperature;
+ typedef uint8_t _quality_type;
+ _quality_type quality;
+ typedef uint32_t _time_delta_distance_us_type;
+ _time_delta_distance_us_type time_delta_distance_us;
+ typedef float _distance_type;
+ _distance_type distance;
+
+ OpticalFlowRad():
+ header(),
+ integration_time_us(0),
+ integrated_x(0),
+ integrated_y(0),
+ integrated_xgyro(0),
+ integrated_ygyro(0),
+ integrated_zgyro(0),
+ temperature(0),
+ quality(0),
+ time_delta_distance_us(0),
+ distance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->integration_time_us >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->integration_time_us >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->integration_time_us >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->integration_time_us >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->integration_time_us);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_x;
+ u_integrated_x.real = this->integrated_x;
+ *(outbuffer + offset + 0) = (u_integrated_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_integrated_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_integrated_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_integrated_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->integrated_x);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_y;
+ u_integrated_y.real = this->integrated_y;
+ *(outbuffer + offset + 0) = (u_integrated_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_integrated_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_integrated_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_integrated_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->integrated_y);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_xgyro;
+ u_integrated_xgyro.real = this->integrated_xgyro;
+ *(outbuffer + offset + 0) = (u_integrated_xgyro.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_integrated_xgyro.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_integrated_xgyro.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_integrated_xgyro.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->integrated_xgyro);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_ygyro;
+ u_integrated_ygyro.real = this->integrated_ygyro;
+ *(outbuffer + offset + 0) = (u_integrated_ygyro.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_integrated_ygyro.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_integrated_ygyro.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_integrated_ygyro.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->integrated_ygyro);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_zgyro;
+ u_integrated_zgyro.real = this->integrated_zgyro;
+ *(outbuffer + offset + 0) = (u_integrated_zgyro.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_integrated_zgyro.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_integrated_zgyro.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_integrated_zgyro.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->integrated_zgyro);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_temperature;
+ u_temperature.real = this->temperature;
+ *(outbuffer + offset + 0) = (u_temperature.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_temperature.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->temperature);
+ *(outbuffer + offset + 0) = (this->quality >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->quality);
+ *(outbuffer + offset + 0) = (this->time_delta_distance_us >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_delta_distance_us >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_delta_distance_us >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_delta_distance_us >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_delta_distance_us);
+ union {
+ float real;
+ uint32_t base;
+ } u_distance;
+ u_distance.real = this->distance;
+ *(outbuffer + offset + 0) = (u_distance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_distance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_distance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_distance.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->distance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->integration_time_us = ((uint32_t) (*(inbuffer + offset)));
+ this->integration_time_us |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->integration_time_us |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->integration_time_us |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->integration_time_us);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_x;
+ u_integrated_x.base = 0;
+ u_integrated_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_integrated_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_integrated_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_integrated_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->integrated_x = u_integrated_x.real;
+ offset += sizeof(this->integrated_x);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_y;
+ u_integrated_y.base = 0;
+ u_integrated_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_integrated_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_integrated_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_integrated_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->integrated_y = u_integrated_y.real;
+ offset += sizeof(this->integrated_y);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_xgyro;
+ u_integrated_xgyro.base = 0;
+ u_integrated_xgyro.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_integrated_xgyro.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_integrated_xgyro.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_integrated_xgyro.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->integrated_xgyro = u_integrated_xgyro.real;
+ offset += sizeof(this->integrated_xgyro);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_ygyro;
+ u_integrated_ygyro.base = 0;
+ u_integrated_ygyro.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_integrated_ygyro.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_integrated_ygyro.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_integrated_ygyro.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->integrated_ygyro = u_integrated_ygyro.real;
+ offset += sizeof(this->integrated_ygyro);
+ union {
+ float real;
+ uint32_t base;
+ } u_integrated_zgyro;
+ u_integrated_zgyro.base = 0;
+ u_integrated_zgyro.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_integrated_zgyro.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_integrated_zgyro.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_integrated_zgyro.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->integrated_zgyro = u_integrated_zgyro.real;
+ offset += sizeof(this->integrated_zgyro);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_temperature;
+ u_temperature.base = 0;
+ u_temperature.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_temperature.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->temperature = u_temperature.real;
+ offset += sizeof(this->temperature);
+ this->quality = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->quality);
+ this->time_delta_distance_us = ((uint32_t) (*(inbuffer + offset)));
+ this->time_delta_distance_us |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_delta_distance_us |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_delta_distance_us |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_delta_distance_us);
+ union {
+ float real;
+ uint32_t base;
+ } u_distance;
+ u_distance.base = 0;
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_distance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->distance = u_distance.real;
+ offset += sizeof(this->distance);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/OpticalFlowRad"; };
+ const char * getMD5(){ return "65d93e03c6188c7ee30415b2a39ad40d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/OverrideRCIn.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,52 @@
+#ifndef _ROS_mavros_msgs_OverrideRCIn_h
+#define _ROS_mavros_msgs_OverrideRCIn_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+ class OverrideRCIn : public ros::Msg
+ {
+ public:
+ uint16_t channels[8];
+ enum { CHAN_RELEASE = 0 };
+ enum { CHAN_NOCHANGE = 65535 };
+
+ OverrideRCIn():
+ channels()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 8; i++){
+ *(outbuffer + offset + 0) = (this->channels[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->channels[i] >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->channels[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 8; i++){
+ this->channels[i] = ((uint16_t) (*(inbuffer + offset)));
+ this->channels[i] |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->channels[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/OverrideRCIn"; };
+ const char * getMD5(){ return "73b27a463a40a3eda1f9fbb1fc86d6f3"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/Param.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,85 @@
+#ifndef _ROS_mavros_msgs_Param_h
+#define _ROS_mavros_msgs_Param_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "mavros_msgs/ParamValue.h"
+
+namespace mavros_msgs
+{
+
+ class Param : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _param_id_type;
+ _param_id_type param_id;
+ typedef mavros_msgs::ParamValue _value_type;
+ _value_type value;
+ typedef uint16_t _param_index_type;
+ _param_index_type param_index;
+ typedef uint16_t _param_count_type;
+ _param_count_type param_count;
+
+ Param():
+ header(),
+ param_id(""),
+ value(),
+ param_index(0),
+ param_count(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_param_id = strlen(this->param_id);
+ varToArr(outbuffer + offset, length_param_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->param_id, length_param_id);
+ offset += length_param_id;
+ offset += this->value.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->param_index >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->param_index >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->param_index);
+ *(outbuffer + offset + 0) = (this->param_count >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->param_count >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->param_count);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_param_id;
+ arrToVar(length_param_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_param_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_param_id-1]=0;
+ this->param_id = (char *)(inbuffer + offset-1);
+ offset += length_param_id;
+ offset += this->value.deserialize(inbuffer + offset);
+ this->param_index = ((uint16_t) (*(inbuffer + offset)));
+ this->param_index |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->param_index);
+ this->param_count = ((uint16_t) (*(inbuffer + offset)));
+ this->param_count |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->param_count);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/Param"; };
+ const char * getMD5(){ return "62165a8f212050223dda9583b0f22c3c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ParamGet.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,111 @@
+#ifndef _ROS_SERVICE_ParamGet_h
+#define _ROS_SERVICE_ParamGet_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mavros_msgs/ParamValue.h"
+
+namespace mavros_msgs
+{
+
+static const char PARAMGET[] = "mavros_msgs/ParamGet";
+
+ class ParamGetRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _param_id_type;
+ _param_id_type param_id;
+
+ ParamGetRequest():
+ param_id("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_param_id = strlen(this->param_id);
+ varToArr(outbuffer + offset, length_param_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->param_id, length_param_id);
+ offset += length_param_id;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_param_id;
+ arrToVar(length_param_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_param_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_param_id-1]=0;
+ this->param_id = (char *)(inbuffer + offset-1);
+ offset += length_param_id;
+ return offset;
+ }
+
+ const char * getType(){ return PARAMGET; };
+ const char * getMD5(){ return "a0c8304d59f465712790120c3fc4b7d0"; };
+
+ };
+
+ class ParamGetResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef mavros_msgs::ParamValue _value_type;
+ _value_type value;
+
+ ParamGetResponse():
+ success(0),
+ value()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ offset += this->value.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ offset += this->value.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return PARAMGET; };
+ const char * getMD5(){ return "790d22b22b9dbf32a8e8d55578e25477"; };
+
+ };
+
+ class ParamGet {
+ public:
+ typedef ParamGetRequest Request;
+ typedef ParamGetResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ParamPull.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,119 @@
+#ifndef _ROS_SERVICE_ParamPull_h
+#define _ROS_SERVICE_ParamPull_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char PARAMPULL[] = "mavros_msgs/ParamPull";
+
+ class ParamPullRequest : public ros::Msg
+ {
+ public:
+ typedef bool _force_pull_type;
+ _force_pull_type force_pull;
+
+ ParamPullRequest():
+ force_pull(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_force_pull;
+ u_force_pull.real = this->force_pull;
+ *(outbuffer + offset + 0) = (u_force_pull.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->force_pull);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_force_pull;
+ u_force_pull.base = 0;
+ u_force_pull.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->force_pull = u_force_pull.real;
+ offset += sizeof(this->force_pull);
+ return offset;
+ }
+
+ const char * getType(){ return PARAMPULL; };
+ const char * getMD5(){ return "16415b4e049d3f92df764eeb461102b7"; };
+
+ };
+
+ class ParamPullResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint32_t _param_received_type;
+ _param_received_type param_received;
+
+ ParamPullResponse():
+ success(0),
+ param_received(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->param_received >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->param_received >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->param_received >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->param_received >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param_received);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->param_received = ((uint32_t) (*(inbuffer + offset)));
+ this->param_received |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->param_received |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->param_received |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->param_received);
+ return offset;
+ }
+
+ const char * getType(){ return PARAMPULL; };
+ const char * getMD5(){ return "5601e883220b149a3209512e966299f0"; };
+
+ };
+
+ class ParamPull {
+ public:
+ typedef ParamPullRequest Request;
+ typedef ParamPullResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ParamPush.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,101 @@
+#ifndef _ROS_SERVICE_ParamPush_h
+#define _ROS_SERVICE_ParamPush_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char PARAMPUSH[] = "mavros_msgs/ParamPush";
+
+ class ParamPushRequest : public ros::Msg
+ {
+ public:
+
+ ParamPushRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return PARAMPUSH; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class ParamPushResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint32_t _param_transfered_type;
+ _param_transfered_type param_transfered;
+
+ ParamPushResponse():
+ success(0),
+ param_transfered(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->param_transfered >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->param_transfered >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->param_transfered >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->param_transfered >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param_transfered);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->param_transfered = ((uint32_t) (*(inbuffer + offset)));
+ this->param_transfered |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->param_transfered |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->param_transfered |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->param_transfered);
+ return offset;
+ }
+
+ const char * getType(){ return PARAMPUSH; };
+ const char * getMD5(){ return "d3fc4d8cefa193382985a92a041a2a3d"; };
+
+ };
+
+ class ParamPush {
+ public:
+ typedef ParamPushRequest Request;
+ typedef ParamPushResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ParamSet.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,116 @@
+#ifndef _ROS_SERVICE_ParamSet_h
+#define _ROS_SERVICE_ParamSet_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mavros_msgs/ParamValue.h"
+
+namespace mavros_msgs
+{
+
+static const char PARAMSET[] = "mavros_msgs/ParamSet";
+
+ class ParamSetRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _param_id_type;
+ _param_id_type param_id;
+ typedef mavros_msgs::ParamValue _value_type;
+ _value_type value;
+
+ ParamSetRequest():
+ param_id(""),
+ value()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_param_id = strlen(this->param_id);
+ varToArr(outbuffer + offset, length_param_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->param_id, length_param_id);
+ offset += length_param_id;
+ offset += this->value.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_param_id;
+ arrToVar(length_param_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_param_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_param_id-1]=0;
+ this->param_id = (char *)(inbuffer + offset-1);
+ offset += length_param_id;
+ offset += this->value.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return PARAMSET; };
+ const char * getMD5(){ return "4a17f346bc27984b348c799c674a04d9"; };
+
+ };
+
+ class ParamSetResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef mavros_msgs::ParamValue _value_type;
+ _value_type value;
+
+ ParamSetResponse():
+ success(0),
+ value()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ offset += this->value.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ offset += this->value.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return PARAMSET; };
+ const char * getMD5(){ return "790d22b22b9dbf32a8e8d55578e25477"; };
+
+ };
+
+ class ParamSet {
+ public:
+ typedef ParamSetRequest Request;
+ typedef ParamSetResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/ParamValue.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,102 @@
+#ifndef _ROS_mavros_msgs_ParamValue_h
+#define _ROS_mavros_msgs_ParamValue_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+ class ParamValue : public ros::Msg
+ {
+ public:
+ typedef int64_t _integer_type;
+ _integer_type integer;
+ typedef double _real_type;
+ _real_type real;
+
+ ParamValue():
+ integer(0),
+ real(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_integer;
+ u_integer.real = this->integer;
+ *(outbuffer + offset + 0) = (u_integer.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_integer.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_integer.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_integer.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_integer.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_integer.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_integer.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_integer.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->integer);
+ union {
+ double real;
+ uint64_t base;
+ } u_real;
+ u_real.real = this->real;
+ *(outbuffer + offset + 0) = (u_real.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_real.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_real.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_real.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_real.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_real.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_real.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_real.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->real);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_integer;
+ u_integer.base = 0;
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_integer.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->integer = u_integer.real;
+ offset += sizeof(this->integer);
+ union {
+ double real;
+ uint64_t base;
+ } u_real;
+ u_real.base = 0;
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_real.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->real = u_real.real;
+ offset += sizeof(this->real);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/ParamValue"; };
+ const char * getMD5(){ return "e2cb1c7a0f6ef0c62d450cd9362c980d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/PositionTarget.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,141 @@
+#ifndef _ROS_mavros_msgs_PositionTarget_h
+#define _ROS_mavros_msgs_PositionTarget_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Point.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mavros_msgs
+{
+
+ class PositionTarget : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _coordinate_frame_type;
+ _coordinate_frame_type coordinate_frame;
+ typedef uint16_t _type_mask_type;
+ _type_mask_type type_mask;
+ typedef geometry_msgs::Point _position_type;
+ _position_type position;
+ typedef geometry_msgs::Vector3 _velocity_type;
+ _velocity_type velocity;
+ typedef geometry_msgs::Vector3 _acceleration_or_force_type;
+ _acceleration_or_force_type acceleration_or_force;
+ typedef float _yaw_type;
+ _yaw_type yaw;
+ typedef float _yaw_rate_type;
+ _yaw_rate_type yaw_rate;
+ enum { FRAME_LOCAL_NED = 1 };
+ enum { FRAME_LOCAL_OFFSET_NED = 7 };
+ enum { FRAME_BODY_NED = 8 };
+ enum { FRAME_BODY_OFFSET_NED = 9 };
+ enum { IGNORE_PX = 1 };
+ enum { IGNORE_PY = 2 };
+ enum { IGNORE_PZ = 4 };
+ enum { IGNORE_VX = 8 };
+ enum { IGNORE_VY = 16 };
+ enum { IGNORE_VZ = 32 };
+ enum { IGNORE_AFX = 64 };
+ enum { IGNORE_AFY = 128 };
+ enum { IGNORE_AFZ = 256 };
+ enum { FORCE = 512 };
+ enum { IGNORE_YAW = 1024 };
+ enum { IGNORE_YAW_RATE = 2048 };
+
+ PositionTarget():
+ header(),
+ coordinate_frame(0),
+ type_mask(0),
+ position(),
+ velocity(),
+ acceleration_or_force(),
+ yaw(0),
+ yaw_rate(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->coordinate_frame >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->coordinate_frame);
+ *(outbuffer + offset + 0) = (this->type_mask >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->type_mask >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->type_mask);
+ offset += this->position.serialize(outbuffer + offset);
+ offset += this->velocity.serialize(outbuffer + offset);
+ offset += this->acceleration_or_force.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.real = this->yaw;
+ *(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw_rate;
+ u_yaw_rate.real = this->yaw_rate;
+ *(outbuffer + offset + 0) = (u_yaw_rate.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_yaw_rate.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_yaw_rate.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_yaw_rate.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->yaw_rate);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->coordinate_frame = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->coordinate_frame);
+ this->type_mask = ((uint16_t) (*(inbuffer + offset)));
+ this->type_mask |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->type_mask);
+ offset += this->position.deserialize(inbuffer + offset);
+ offset += this->velocity.deserialize(inbuffer + offset);
+ offset += this->acceleration_or_force.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw;
+ u_yaw.base = 0;
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw = u_yaw.real;
+ offset += sizeof(this->yaw);
+ union {
+ float real;
+ uint32_t base;
+ } u_yaw_rate;
+ u_yaw_rate.base = 0;
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_yaw_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->yaw_rate = u_yaw_rate.real;
+ offset += sizeof(this->yaw_rate);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/PositionTarget"; };
+ const char * getMD5(){ return "dedb0081aaf8cb20209737746bb49117"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/RCIn.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,80 @@
+#ifndef _ROS_mavros_msgs_RCIn_h
+#define _ROS_mavros_msgs_RCIn_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class RCIn : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _rssi_type;
+ _rssi_type rssi;
+ uint32_t channels_length;
+ typedef uint16_t _channels_type;
+ _channels_type st_channels;
+ _channels_type * channels;
+
+ RCIn():
+ header(),
+ rssi(0),
+ channels_length(0), channels(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->rssi >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->rssi);
+ *(outbuffer + offset + 0) = (this->channels_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->channels_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->channels_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->channels_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->channels_length);
+ for( uint32_t i = 0; i < channels_length; i++){
+ *(outbuffer + offset + 0) = (this->channels[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->channels[i] >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->channels[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->rssi = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->rssi);
+ uint32_t channels_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->channels_length);
+ if(channels_lengthT > channels_length)
+ this->channels = (uint16_t*)realloc(this->channels, channels_lengthT * sizeof(uint16_t));
+ channels_length = channels_lengthT;
+ for( uint32_t i = 0; i < channels_length; i++){
+ this->st_channels = ((uint16_t) (*(inbuffer + offset)));
+ this->st_channels |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->st_channels);
+ memcpy( &(this->channels[i]), &(this->st_channels), sizeof(uint16_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/RCIn"; };
+ const char * getMD5(){ return "1c3eafdb5efbcda3c334e1788bbcfe39"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/RCOut.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,73 @@
+#ifndef _ROS_mavros_msgs_RCOut_h
+#define _ROS_mavros_msgs_RCOut_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class RCOut : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t channels_length;
+ typedef uint16_t _channels_type;
+ _channels_type st_channels;
+ _channels_type * channels;
+
+ RCOut():
+ header(),
+ channels_length(0), channels(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->channels_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->channels_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->channels_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->channels_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->channels_length);
+ for( uint32_t i = 0; i < channels_length; i++){
+ *(outbuffer + offset + 0) = (this->channels[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->channels[i] >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->channels[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t channels_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->channels_length);
+ if(channels_lengthT > channels_length)
+ this->channels = (uint16_t*)realloc(this->channels, channels_lengthT * sizeof(uint16_t));
+ channels_length = channels_lengthT;
+ for( uint32_t i = 0; i < channels_length; i++){
+ this->st_channels = ((uint16_t) (*(inbuffer + offset)));
+ this->st_channels |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->st_channels);
+ memcpy( &(this->channels[i]), &(this->st_channels), sizeof(uint16_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/RCOut"; };
+ const char * getMD5(){ return "52cacf104bab5ae3b103cfe176590713"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/RTCM.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,71 @@
+#ifndef _ROS_mavros_msgs_RTCM_h
+#define _ROS_mavros_msgs_RTCM_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class RTCM : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ RTCM():
+ header(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/RTCM"; };
+ const char * getMD5(){ return "8903b686ebe5db3477e83c6d0bb149f8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/RadioStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,145 @@
+#ifndef _ROS_mavros_msgs_RadioStatus_h
+#define _ROS_mavros_msgs_RadioStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class RadioStatus : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _rssi_type;
+ _rssi_type rssi;
+ typedef uint8_t _remrssi_type;
+ _remrssi_type remrssi;
+ typedef uint8_t _txbuf_type;
+ _txbuf_type txbuf;
+ typedef uint8_t _noise_type;
+ _noise_type noise;
+ typedef uint8_t _remnoise_type;
+ _remnoise_type remnoise;
+ typedef uint16_t _rxerrors_type;
+ _rxerrors_type rxerrors;
+ typedef uint16_t _fixed_type;
+ _fixed_type fixed;
+ typedef float _rssi_dbm_type;
+ _rssi_dbm_type rssi_dbm;
+ typedef float _remrssi_dbm_type;
+ _remrssi_dbm_type remrssi_dbm;
+
+ RadioStatus():
+ header(),
+ rssi(0),
+ remrssi(0),
+ txbuf(0),
+ noise(0),
+ remnoise(0),
+ rxerrors(0),
+ fixed(0),
+ rssi_dbm(0),
+ remrssi_dbm(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->rssi >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->rssi);
+ *(outbuffer + offset + 0) = (this->remrssi >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->remrssi);
+ *(outbuffer + offset + 0) = (this->txbuf >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->txbuf);
+ *(outbuffer + offset + 0) = (this->noise >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->noise);
+ *(outbuffer + offset + 0) = (this->remnoise >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->remnoise);
+ *(outbuffer + offset + 0) = (this->rxerrors >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->rxerrors >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->rxerrors);
+ *(outbuffer + offset + 0) = (this->fixed >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->fixed >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->fixed);
+ union {
+ float real;
+ uint32_t base;
+ } u_rssi_dbm;
+ u_rssi_dbm.real = this->rssi_dbm;
+ *(outbuffer + offset + 0) = (u_rssi_dbm.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_rssi_dbm.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_rssi_dbm.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_rssi_dbm.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->rssi_dbm);
+ union {
+ float real;
+ uint32_t base;
+ } u_remrssi_dbm;
+ u_remrssi_dbm.real = this->remrssi_dbm;
+ *(outbuffer + offset + 0) = (u_remrssi_dbm.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_remrssi_dbm.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_remrssi_dbm.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_remrssi_dbm.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->remrssi_dbm);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->rssi = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->rssi);
+ this->remrssi = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->remrssi);
+ this->txbuf = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->txbuf);
+ this->noise = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->noise);
+ this->remnoise = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->remnoise);
+ this->rxerrors = ((uint16_t) (*(inbuffer + offset)));
+ this->rxerrors |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->rxerrors);
+ this->fixed = ((uint16_t) (*(inbuffer + offset)));
+ this->fixed |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->fixed);
+ union {
+ float real;
+ uint32_t base;
+ } u_rssi_dbm;
+ u_rssi_dbm.base = 0;
+ u_rssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_rssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_rssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_rssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->rssi_dbm = u_rssi_dbm.real;
+ offset += sizeof(this->rssi_dbm);
+ union {
+ float real;
+ uint32_t base;
+ } u_remrssi_dbm;
+ u_remrssi_dbm.base = 0;
+ u_remrssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_remrssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_remrssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_remrssi_dbm.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->remrssi_dbm = u_remrssi_dbm.real;
+ offset += sizeof(this->remrssi_dbm);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/RadioStatus"; };
+ const char * getMD5(){ return "04e4a879bb2687140da50a1a821e2190"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/SetMavFrame.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,115 @@
+#ifndef _ROS_SERVICE_SetMavFrame_h
+#define _ROS_SERVICE_SetMavFrame_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char SETMAVFRAME[] = "mavros_msgs/SetMavFrame";
+
+ class SetMavFrameRequest : public ros::Msg
+ {
+ public:
+ typedef uint8_t _mav_frame_type;
+ _mav_frame_type mav_frame;
+ enum { FRAME_GLOBAL = 0 };
+ enum { FRAME_LOCAL_NED = 1 };
+ enum { FRAME_MISSION = 2 };
+ enum { FRAME_GLOBAL_RELATIVE_ALT = 3 };
+ enum { FRAME_LOCAL_ENU = 4 };
+ enum { FRAME_GLOBAL_INT = 5 };
+ enum { FRAME_GLOBAL_RELATIVE_ALT_INT = 6 };
+ enum { FRAME_LOCAL_OFFSET_NED = 7 };
+ enum { FRAME_BODY_NED = 8 };
+ enum { FRAME_BODY_OFFSET_NED = 9 };
+ enum { FRAME_GLOBAL_TERRAIN_ALT = 10 };
+ enum { FRAME_GLOBAL_TERRAIN_ALT_INT = 11 };
+ enum { FRAME_BODY_FRD = 12 };
+ enum { FRAME_BODY_FLU = 13 };
+ enum { FRAME_MOCAP_NED = 14 };
+ enum { FRAME_MOCAP_ENU = 15 };
+ enum { FRAME_VISION_NED = 16 };
+ enum { FRAME_VISION_ENU = 17 };
+ enum { FRAME_ESTIM_NED = 18 };
+ enum { FRAME_ESTIM_ENU = 19 };
+
+ SetMavFrameRequest():
+ mav_frame(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->mav_frame >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mav_frame);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->mav_frame = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->mav_frame);
+ return offset;
+ }
+
+ const char * getType(){ return SETMAVFRAME; };
+ const char * getMD5(){ return "4d2cf24886f660cde0f73cf6fc86e24c"; };
+
+ };
+
+ class SetMavFrameResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ SetMavFrameResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return SETMAVFRAME; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class SetMavFrame {
+ public:
+ typedef SetMavFrameRequest Request;
+ typedef SetMavFrameResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/SetMode.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,123 @@
+#ifndef _ROS_SERVICE_SetMode_h
+#define _ROS_SERVICE_SetMode_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char SETMODE[] = "mavros_msgs/SetMode";
+
+ class SetModeRequest : public ros::Msg
+ {
+ public:
+ typedef uint8_t _base_mode_type;
+ _base_mode_type base_mode;
+ typedef const char* _custom_mode_type;
+ _custom_mode_type custom_mode;
+ enum { MAV_MODE_PREFLIGHT = 0 };
+ enum { MAV_MODE_STABILIZE_DISARMED = 80 };
+ enum { MAV_MODE_STABILIZE_ARMED = 208 };
+ enum { MAV_MODE_MANUAL_DISARMED = 64 };
+ enum { MAV_MODE_MANUAL_ARMED = 192 };
+ enum { MAV_MODE_GUIDED_DISARMED = 88 };
+ enum { MAV_MODE_GUIDED_ARMED = 216 };
+ enum { MAV_MODE_AUTO_DISARMED = 92 };
+ enum { MAV_MODE_AUTO_ARMED = 220 };
+ enum { MAV_MODE_TEST_DISARMED = 66 };
+ enum { MAV_MODE_TEST_ARMED = 194 };
+
+ SetModeRequest():
+ base_mode(0),
+ custom_mode("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->base_mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->base_mode);
+ uint32_t length_custom_mode = strlen(this->custom_mode);
+ varToArr(outbuffer + offset, length_custom_mode);
+ offset += 4;
+ memcpy(outbuffer + offset, this->custom_mode, length_custom_mode);
+ offset += length_custom_mode;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->base_mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->base_mode);
+ uint32_t length_custom_mode;
+ arrToVar(length_custom_mode, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_custom_mode; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_custom_mode-1]=0;
+ this->custom_mode = (char *)(inbuffer + offset-1);
+ offset += length_custom_mode;
+ return offset;
+ }
+
+ const char * getType(){ return SETMODE; };
+ const char * getMD5(){ return "d770431847cad3a8f50a81ec70ddf0e2"; };
+
+ };
+
+ class SetModeResponse : public ros::Msg
+ {
+ public:
+ typedef bool _mode_sent_type;
+ _mode_sent_type mode_sent;
+
+ SetModeResponse():
+ mode_sent(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_mode_sent;
+ u_mode_sent.real = this->mode_sent;
+ *(outbuffer + offset + 0) = (u_mode_sent.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mode_sent);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_mode_sent;
+ u_mode_sent.base = 0;
+ u_mode_sent.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->mode_sent = u_mode_sent.real;
+ offset += sizeof(this->mode_sent);
+ return offset;
+ }
+
+ const char * getType(){ return SETMODE; };
+ const char * getMD5(){ return "a70bfe6329ecf8f8d858daa6f3db7655"; };
+
+ };
+
+ class SetMode {
+ public:
+ typedef SetModeRequest Request;
+ typedef SetModeResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/State.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,140 @@
+#ifndef _ROS_mavros_msgs_State_h
+#define _ROS_mavros_msgs_State_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class State : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef bool _connected_type;
+ _connected_type connected;
+ typedef bool _armed_type;
+ _armed_type armed;
+ typedef bool _guided_type;
+ _guided_type guided;
+ typedef bool _manual_input_type;
+ _manual_input_type manual_input;
+ typedef const char* _mode_type;
+ _mode_type mode;
+ typedef uint8_t _system_status_type;
+ _system_status_type system_status;
+
+ State():
+ header(),
+ connected(0),
+ armed(0),
+ guided(0),
+ manual_input(0),
+ mode(""),
+ system_status(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_connected;
+ u_connected.real = this->connected;
+ *(outbuffer + offset + 0) = (u_connected.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->connected);
+ union {
+ bool real;
+ uint8_t base;
+ } u_armed;
+ u_armed.real = this->armed;
+ *(outbuffer + offset + 0) = (u_armed.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->armed);
+ union {
+ bool real;
+ uint8_t base;
+ } u_guided;
+ u_guided.real = this->guided;
+ *(outbuffer + offset + 0) = (u_guided.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->guided);
+ union {
+ bool real;
+ uint8_t base;
+ } u_manual_input;
+ u_manual_input.real = this->manual_input;
+ *(outbuffer + offset + 0) = (u_manual_input.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->manual_input);
+ uint32_t length_mode = strlen(this->mode);
+ varToArr(outbuffer + offset, length_mode);
+ offset += 4;
+ memcpy(outbuffer + offset, this->mode, length_mode);
+ offset += length_mode;
+ *(outbuffer + offset + 0) = (this->system_status >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->system_status);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_connected;
+ u_connected.base = 0;
+ u_connected.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->connected = u_connected.real;
+ offset += sizeof(this->connected);
+ union {
+ bool real;
+ uint8_t base;
+ } u_armed;
+ u_armed.base = 0;
+ u_armed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->armed = u_armed.real;
+ offset += sizeof(this->armed);
+ union {
+ bool real;
+ uint8_t base;
+ } u_guided;
+ u_guided.base = 0;
+ u_guided.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->guided = u_guided.real;
+ offset += sizeof(this->guided);
+ union {
+ bool real;
+ uint8_t base;
+ } u_manual_input;
+ u_manual_input.base = 0;
+ u_manual_input.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->manual_input = u_manual_input.real;
+ offset += sizeof(this->manual_input);
+ uint32_t length_mode;
+ arrToVar(length_mode, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_mode; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_mode-1]=0;
+ this->mode = (char *)(inbuffer + offset-1);
+ offset += length_mode;
+ this->system_status = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->system_status);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/State"; };
+ const char * getMD5(){ return "ce783f756cab1193cb71ba9e90fece50"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/StatusText.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+#ifndef _ROS_mavros_msgs_StatusText_h
+#define _ROS_mavros_msgs_StatusText_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class StatusText : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _severity_type;
+ _severity_type severity;
+ typedef const char* _text_type;
+ _text_type text;
+ enum { EMERGENCY = 0 };
+ enum { ALERT = 1 };
+ enum { CRITICAL = 2 };
+ enum { ERROR = 3 };
+ enum { WARNING = 4 };
+ enum { NOTICE = 5 };
+ enum { INFO = 6 };
+ enum { DEBUG = 7 };
+
+ StatusText():
+ header(),
+ severity(0),
+ text("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->severity >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->severity);
+ uint32_t length_text = strlen(this->text);
+ varToArr(outbuffer + offset, length_text);
+ offset += 4;
+ memcpy(outbuffer + offset, this->text, length_text);
+ offset += length_text;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->severity = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->severity);
+ uint32_t length_text;
+ arrToVar(length_text, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_text; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_text-1]=0;
+ this->text = (char *)(inbuffer + offset-1);
+ offset += length_text;
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/StatusText"; };
+ const char * getMD5(){ return "6cfd33cd09e4abf5841d7be3c770a969"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/StreamRate.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,113 @@
+#ifndef _ROS_SERVICE_StreamRate_h
+#define _ROS_SERVICE_StreamRate_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char STREAMRATE[] = "mavros_msgs/StreamRate";
+
+ class StreamRateRequest : public ros::Msg
+ {
+ public:
+ typedef uint8_t _stream_id_type;
+ _stream_id_type stream_id;
+ typedef uint16_t _message_rate_type;
+ _message_rate_type message_rate;
+ typedef bool _on_off_type;
+ _on_off_type on_off;
+ enum { STREAM_ALL = 0 };
+ enum { STREAM_RAW_SENSORS = 1 };
+ enum { STREAM_EXTENDED_STATUS = 2 };
+ enum { STREAM_RC_CHANNELS = 3 };
+ enum { STREAM_RAW_CONTROLLER = 4 };
+ enum { STREAM_POSITION = 6 };
+ enum { STREAM_EXTRA1 = 10 };
+ enum { STREAM_EXTRA2 = 11 };
+ enum { STREAM_EXTRA3 = 12 };
+
+ StreamRateRequest():
+ stream_id(0),
+ message_rate(0),
+ on_off(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->stream_id >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->stream_id);
+ *(outbuffer + offset + 0) = (this->message_rate >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->message_rate >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->message_rate);
+ union {
+ bool real;
+ uint8_t base;
+ } u_on_off;
+ u_on_off.real = this->on_off;
+ *(outbuffer + offset + 0) = (u_on_off.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->on_off);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->stream_id = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->stream_id);
+ this->message_rate = ((uint16_t) (*(inbuffer + offset)));
+ this->message_rate |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->message_rate);
+ union {
+ bool real;
+ uint8_t base;
+ } u_on_off;
+ u_on_off.base = 0;
+ u_on_off.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->on_off = u_on_off.real;
+ offset += sizeof(this->on_off);
+ return offset;
+ }
+
+ const char * getType(){ return STREAMRATE; };
+ const char * getMD5(){ return "d12f7661724c8ba25f67ba597bb7d039"; };
+
+ };
+
+ class StreamRateResponse : public ros::Msg
+ {
+ public:
+
+ StreamRateResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return STREAMRATE; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class StreamRate {
+ public:
+ typedef StreamRateRequest Request;
+ typedef StreamRateResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/Thrust.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,68 @@
+#ifndef _ROS_mavros_msgs_Thrust_h
+#define _ROS_mavros_msgs_Thrust_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class Thrust : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _thrust_type;
+ _thrust_type thrust;
+
+ Thrust():
+ header(),
+ thrust(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_thrust;
+ u_thrust.real = this->thrust;
+ *(outbuffer + offset + 0) = (u_thrust.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_thrust.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_thrust.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_thrust.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->thrust);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_thrust;
+ u_thrust.base = 0;
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_thrust.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->thrust = u_thrust.real;
+ offset += sizeof(this->thrust);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/Thrust"; };
+ const char * getMD5(){ return "c61da3a8868a8b502eaf0b0abd839f57"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/TimesyncStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,156 @@
+#ifndef _ROS_mavros_msgs_TimesyncStatus_h
+#define _ROS_mavros_msgs_TimesyncStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class TimesyncStatus : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint64_t _remote_timestamp_ns_type;
+ _remote_timestamp_ns_type remote_timestamp_ns;
+ typedef int64_t _observed_offset_ns_type;
+ _observed_offset_ns_type observed_offset_ns;
+ typedef int64_t _estimated_offset_ns_type;
+ _estimated_offset_ns_type estimated_offset_ns;
+ typedef float _round_trip_time_ms_type;
+ _round_trip_time_ms_type round_trip_time_ms;
+
+ TimesyncStatus():
+ header(),
+ remote_timestamp_ns(0),
+ observed_offset_ns(0),
+ estimated_offset_ns(0),
+ round_trip_time_ms(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_remote_timestamp_ns;
+ u_remote_timestamp_ns.real = this->remote_timestamp_ns;
+ *(outbuffer + offset + 0) = (u_remote_timestamp_ns.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_remote_timestamp_ns.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_remote_timestamp_ns.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_remote_timestamp_ns.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->remote_timestamp_ns);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_observed_offset_ns;
+ u_observed_offset_ns.real = this->observed_offset_ns;
+ *(outbuffer + offset + 0) = (u_observed_offset_ns.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_observed_offset_ns.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_observed_offset_ns.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_observed_offset_ns.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_observed_offset_ns.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_observed_offset_ns.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_observed_offset_ns.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_observed_offset_ns.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->observed_offset_ns);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_estimated_offset_ns;
+ u_estimated_offset_ns.real = this->estimated_offset_ns;
+ *(outbuffer + offset + 0) = (u_estimated_offset_ns.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_estimated_offset_ns.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_estimated_offset_ns.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_estimated_offset_ns.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_estimated_offset_ns.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_estimated_offset_ns.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_estimated_offset_ns.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_estimated_offset_ns.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->estimated_offset_ns);
+ union {
+ float real;
+ uint32_t base;
+ } u_round_trip_time_ms;
+ u_round_trip_time_ms.real = this->round_trip_time_ms;
+ *(outbuffer + offset + 0) = (u_round_trip_time_ms.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_round_trip_time_ms.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_round_trip_time_ms.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_round_trip_time_ms.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->round_trip_time_ms);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_remote_timestamp_ns;
+ u_remote_timestamp_ns.base = 0;
+ u_remote_timestamp_ns.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_remote_timestamp_ns.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_remote_timestamp_ns.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_remote_timestamp_ns.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->remote_timestamp_ns = u_remote_timestamp_ns.real;
+ offset += sizeof(this->remote_timestamp_ns);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_observed_offset_ns;
+ u_observed_offset_ns.base = 0;
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_observed_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->observed_offset_ns = u_observed_offset_ns.real;
+ offset += sizeof(this->observed_offset_ns);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_estimated_offset_ns;
+ u_estimated_offset_ns.base = 0;
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_estimated_offset_ns.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->estimated_offset_ns = u_estimated_offset_ns.real;
+ offset += sizeof(this->estimated_offset_ns);
+ union {
+ float real;
+ uint32_t base;
+ } u_round_trip_time_ms;
+ u_round_trip_time_ms.base = 0;
+ u_round_trip_time_ms.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_round_trip_time_ms.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_round_trip_time_ms.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_round_trip_time_ms.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->round_trip_time_ms = u_round_trip_time_ms.real;
+ offset += sizeof(this->round_trip_time_ms);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/TimesyncStatus"; };
+ const char * getMD5(){ return "021ec8044e747bea518b441f374ba64b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/Trajectory.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,128 @@
+#ifndef _ROS_mavros_msgs_Trajectory_h
+#define _ROS_mavros_msgs_Trajectory_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "mavros_msgs/PositionTarget.h"
+
+namespace mavros_msgs
+{
+
+ class Trajectory : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _type_type;
+ _type_type type;
+ typedef mavros_msgs::PositionTarget _point_1_type;
+ _point_1_type point_1;
+ typedef mavros_msgs::PositionTarget _point_2_type;
+ _point_2_type point_2;
+ typedef mavros_msgs::PositionTarget _point_3_type;
+ _point_3_type point_3;
+ typedef mavros_msgs::PositionTarget _point_4_type;
+ _point_4_type point_4;
+ typedef mavros_msgs::PositionTarget _point_5_type;
+ _point_5_type point_5;
+ uint8_t point_valid[5];
+ uint16_t command[5];
+ float time_horizon[5];
+ enum { MAV_TRAJECTORY_REPRESENTATION_WAYPOINTS = 0 };
+ enum { MAV_TRAJECTORY_REPRESENTATION_BEZIER = 1 };
+
+ Trajectory():
+ header(),
+ type(0),
+ point_1(),
+ point_2(),
+ point_3(),
+ point_4(),
+ point_5(),
+ point_valid(),
+ command(),
+ time_horizon()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ offset += this->point_1.serialize(outbuffer + offset);
+ offset += this->point_2.serialize(outbuffer + offset);
+ offset += this->point_3.serialize(outbuffer + offset);
+ offset += this->point_4.serialize(outbuffer + offset);
+ offset += this->point_5.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 5; i++){
+ *(outbuffer + offset + 0) = (this->point_valid[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->point_valid[i]);
+ }
+ for( uint32_t i = 0; i < 5; i++){
+ *(outbuffer + offset + 0) = (this->command[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->command[i] >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->command[i]);
+ }
+ for( uint32_t i = 0; i < 5; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_time_horizoni;
+ u_time_horizoni.real = this->time_horizon[i];
+ *(outbuffer + offset + 0) = (u_time_horizoni.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_time_horizoni.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_time_horizoni.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_time_horizoni.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_horizon[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ offset += this->point_1.deserialize(inbuffer + offset);
+ offset += this->point_2.deserialize(inbuffer + offset);
+ offset += this->point_3.deserialize(inbuffer + offset);
+ offset += this->point_4.deserialize(inbuffer + offset);
+ offset += this->point_5.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 5; i++){
+ this->point_valid[i] = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->point_valid[i]);
+ }
+ for( uint32_t i = 0; i < 5; i++){
+ this->command[i] = ((uint16_t) (*(inbuffer + offset)));
+ this->command[i] |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->command[i]);
+ }
+ for( uint32_t i = 0; i < 5; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_time_horizoni;
+ u_time_horizoni.base = 0;
+ u_time_horizoni.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_time_horizoni.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_time_horizoni.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_time_horizoni.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->time_horizon[i] = u_time_horizoni.real;
+ offset += sizeof(this->time_horizon[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/Trajectory"; };
+ const char * getMD5(){ return "477b47a103394ad6be940e5705f338e8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/VFR_HUD.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,184 @@
+#ifndef _ROS_mavros_msgs_VFR_HUD_h
+#define _ROS_mavros_msgs_VFR_HUD_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class VFR_HUD : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _airspeed_type;
+ _airspeed_type airspeed;
+ typedef float _groundspeed_type;
+ _groundspeed_type groundspeed;
+ typedef int16_t _heading_type;
+ _heading_type heading;
+ typedef float _throttle_type;
+ _throttle_type throttle;
+ typedef float _altitude_type;
+ _altitude_type altitude;
+ typedef float _climb_type;
+ _climb_type climb;
+
+ VFR_HUD():
+ header(),
+ airspeed(0),
+ groundspeed(0),
+ heading(0),
+ throttle(0),
+ altitude(0),
+ climb(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_airspeed;
+ u_airspeed.real = this->airspeed;
+ *(outbuffer + offset + 0) = (u_airspeed.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_airspeed.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_airspeed.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_airspeed.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->airspeed);
+ union {
+ float real;
+ uint32_t base;
+ } u_groundspeed;
+ u_groundspeed.real = this->groundspeed;
+ *(outbuffer + offset + 0) = (u_groundspeed.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_groundspeed.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_groundspeed.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_groundspeed.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->groundspeed);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_heading;
+ u_heading.real = this->heading;
+ *(outbuffer + offset + 0) = (u_heading.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_heading.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->heading);
+ union {
+ float real;
+ uint32_t base;
+ } u_throttle;
+ u_throttle.real = this->throttle;
+ *(outbuffer + offset + 0) = (u_throttle.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_throttle.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_throttle.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_throttle.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->throttle);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->altitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_climb;
+ u_climb.real = this->climb;
+ *(outbuffer + offset + 0) = (u_climb.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_climb.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_climb.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_climb.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->climb);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_airspeed;
+ u_airspeed.base = 0;
+ u_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->airspeed = u_airspeed.real;
+ offset += sizeof(this->airspeed);
+ union {
+ float real;
+ uint32_t base;
+ } u_groundspeed;
+ u_groundspeed.base = 0;
+ u_groundspeed.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_groundspeed.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_groundspeed.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_groundspeed.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->groundspeed = u_groundspeed.real;
+ offset += sizeof(this->groundspeed);
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_heading;
+ u_heading.base = 0;
+ u_heading.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_heading.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->heading = u_heading.real;
+ offset += sizeof(this->heading);
+ union {
+ float real;
+ uint32_t base;
+ } u_throttle;
+ u_throttle.base = 0;
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_throttle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->throttle = u_throttle.real;
+ offset += sizeof(this->throttle);
+ union {
+ float real;
+ uint32_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ union {
+ float real;
+ uint32_t base;
+ } u_climb;
+ u_climb.base = 0;
+ u_climb.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_climb.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_climb.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_climb.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->climb = u_climb.real;
+ offset += sizeof(this->climb);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/VFR_HUD"; };
+ const char * getMD5(){ return "1f55e210c3d39fe105d44d8dc963655f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/VehicleInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,256 @@
+#ifndef _ROS_mavros_msgs_VehicleInfo_h
+#define _ROS_mavros_msgs_VehicleInfo_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class VehicleInfo : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _available_info_type;
+ _available_info_type available_info;
+ typedef uint8_t _sysid_type;
+ _sysid_type sysid;
+ typedef uint8_t _compid_type;
+ _compid_type compid;
+ typedef uint8_t _autopilot_type;
+ _autopilot_type autopilot;
+ typedef uint8_t _type_type;
+ _type_type type;
+ typedef uint8_t _system_status_type;
+ _system_status_type system_status;
+ typedef uint8_t _base_mode_type;
+ _base_mode_type base_mode;
+ typedef uint32_t _custom_mode_type;
+ _custom_mode_type custom_mode;
+ typedef const char* _mode_type;
+ _mode_type mode;
+ typedef uint32_t _mode_id_type;
+ _mode_id_type mode_id;
+ typedef uint64_t _capabilities_type;
+ _capabilities_type capabilities;
+ typedef uint32_t _flight_sw_version_type;
+ _flight_sw_version_type flight_sw_version;
+ typedef uint32_t _middleware_sw_version_type;
+ _middleware_sw_version_type middleware_sw_version;
+ typedef uint32_t _os_sw_version_type;
+ _os_sw_version_type os_sw_version;
+ typedef uint32_t _board_version_type;
+ _board_version_type board_version;
+ typedef uint16_t _vendor_id_type;
+ _vendor_id_type vendor_id;
+ typedef uint16_t _product_id_type;
+ _product_id_type product_id;
+ typedef uint64_t _uid_type;
+ _uid_type uid;
+ enum { HAVE_INFO_HEARTBEAT = 1 };
+ enum { HAVE_INFO_AUTOPILOT_VERSION = 2 };
+
+ VehicleInfo():
+ header(),
+ available_info(0),
+ sysid(0),
+ compid(0),
+ autopilot(0),
+ type(0),
+ system_status(0),
+ base_mode(0),
+ custom_mode(0),
+ mode(""),
+ mode_id(0),
+ capabilities(0),
+ flight_sw_version(0),
+ middleware_sw_version(0),
+ os_sw_version(0),
+ board_version(0),
+ vendor_id(0),
+ product_id(0),
+ uid(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->available_info >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->available_info);
+ *(outbuffer + offset + 0) = (this->sysid >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->sysid);
+ *(outbuffer + offset + 0) = (this->compid >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->compid);
+ *(outbuffer + offset + 0) = (this->autopilot >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->autopilot);
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ *(outbuffer + offset + 0) = (this->system_status >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->system_status);
+ *(outbuffer + offset + 0) = (this->base_mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->base_mode);
+ *(outbuffer + offset + 0) = (this->custom_mode >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->custom_mode >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->custom_mode >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->custom_mode >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->custom_mode);
+ uint32_t length_mode = strlen(this->mode);
+ varToArr(outbuffer + offset, length_mode);
+ offset += 4;
+ memcpy(outbuffer + offset, this->mode, length_mode);
+ offset += length_mode;
+ *(outbuffer + offset + 0) = (this->mode_id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->mode_id >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->mode_id >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->mode_id >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->mode_id);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_capabilities;
+ u_capabilities.real = this->capabilities;
+ *(outbuffer + offset + 0) = (u_capabilities.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_capabilities.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_capabilities.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_capabilities.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->capabilities);
+ *(outbuffer + offset + 0) = (this->flight_sw_version >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->flight_sw_version >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->flight_sw_version >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->flight_sw_version >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->flight_sw_version);
+ *(outbuffer + offset + 0) = (this->middleware_sw_version >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->middleware_sw_version >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->middleware_sw_version >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->middleware_sw_version >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->middleware_sw_version);
+ *(outbuffer + offset + 0) = (this->os_sw_version >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->os_sw_version >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->os_sw_version >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->os_sw_version >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->os_sw_version);
+ *(outbuffer + offset + 0) = (this->board_version >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->board_version >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->board_version >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->board_version >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->board_version);
+ *(outbuffer + offset + 0) = (this->vendor_id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->vendor_id >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->vendor_id);
+ *(outbuffer + offset + 0) = (this->product_id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->product_id >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->product_id);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_uid;
+ u_uid.real = this->uid;
+ *(outbuffer + offset + 0) = (u_uid.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_uid.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_uid.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_uid.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->uid);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->available_info = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->available_info);
+ this->sysid = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->sysid);
+ this->compid = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->compid);
+ this->autopilot = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->autopilot);
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ this->system_status = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->system_status);
+ this->base_mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->base_mode);
+ this->custom_mode = ((uint32_t) (*(inbuffer + offset)));
+ this->custom_mode |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->custom_mode |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->custom_mode |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->custom_mode);
+ uint32_t length_mode;
+ arrToVar(length_mode, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_mode; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_mode-1]=0;
+ this->mode = (char *)(inbuffer + offset-1);
+ offset += length_mode;
+ this->mode_id = ((uint32_t) (*(inbuffer + offset)));
+ this->mode_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->mode_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->mode_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->mode_id);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_capabilities;
+ u_capabilities.base = 0;
+ u_capabilities.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_capabilities.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_capabilities.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_capabilities.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->capabilities = u_capabilities.real;
+ offset += sizeof(this->capabilities);
+ this->flight_sw_version = ((uint32_t) (*(inbuffer + offset)));
+ this->flight_sw_version |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->flight_sw_version |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->flight_sw_version |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->flight_sw_version);
+ this->middleware_sw_version = ((uint32_t) (*(inbuffer + offset)));
+ this->middleware_sw_version |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->middleware_sw_version |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->middleware_sw_version |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->middleware_sw_version);
+ this->os_sw_version = ((uint32_t) (*(inbuffer + offset)));
+ this->os_sw_version |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->os_sw_version |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->os_sw_version |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->os_sw_version);
+ this->board_version = ((uint32_t) (*(inbuffer + offset)));
+ this->board_version |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->board_version |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->board_version |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->board_version);
+ this->vendor_id = ((uint16_t) (*(inbuffer + offset)));
+ this->vendor_id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->vendor_id);
+ this->product_id = ((uint16_t) (*(inbuffer + offset)));
+ this->product_id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->product_id);
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_uid;
+ u_uid.base = 0;
+ u_uid.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_uid.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_uid.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_uid.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->uid = u_uid.real;
+ offset += sizeof(this->uid);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/VehicleInfo"; };
+ const char * getMD5(){ return "68ac9e63349db04d0cf8dd45a9a5b283"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/VehicleInfoGet.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,148 @@
+#ifndef _ROS_SERVICE_VehicleInfoGet_h
+#define _ROS_SERVICE_VehicleInfoGet_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mavros_msgs/VehicleInfo.h"
+
+namespace mavros_msgs
+{
+
+static const char VEHICLEINFOGET[] = "mavros_msgs/VehicleInfoGet";
+
+ class VehicleInfoGetRequest : public ros::Msg
+ {
+ public:
+ typedef uint8_t _sysid_type;
+ _sysid_type sysid;
+ typedef uint8_t _compid_type;
+ _compid_type compid;
+ typedef bool _get_all_type;
+ _get_all_type get_all;
+ enum { GET_MY_SYSID = 0 };
+ enum { GET_MY_COMPID = 0 };
+
+ VehicleInfoGetRequest():
+ sysid(0),
+ compid(0),
+ get_all(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->sysid >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->sysid);
+ *(outbuffer + offset + 0) = (this->compid >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->compid);
+ union {
+ bool real;
+ uint8_t base;
+ } u_get_all;
+ u_get_all.real = this->get_all;
+ *(outbuffer + offset + 0) = (u_get_all.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->get_all);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->sysid = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->sysid);
+ this->compid = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->compid);
+ union {
+ bool real;
+ uint8_t base;
+ } u_get_all;
+ u_get_all.base = 0;
+ u_get_all.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->get_all = u_get_all.real;
+ offset += sizeof(this->get_all);
+ return offset;
+ }
+
+ const char * getType(){ return VEHICLEINFOGET; };
+ const char * getMD5(){ return "c1911e97179d4b379a979e2ab8e01e5c"; };
+
+ };
+
+ class VehicleInfoGetResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ uint32_t vehicles_length;
+ typedef mavros_msgs::VehicleInfo _vehicles_type;
+ _vehicles_type st_vehicles;
+ _vehicles_type * vehicles;
+
+ VehicleInfoGetResponse():
+ success(0),
+ vehicles_length(0), vehicles(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->vehicles_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->vehicles_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->vehicles_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->vehicles_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->vehicles_length);
+ for( uint32_t i = 0; i < vehicles_length; i++){
+ offset += this->vehicles[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t vehicles_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ vehicles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ vehicles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ vehicles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->vehicles_length);
+ if(vehicles_lengthT > vehicles_length)
+ this->vehicles = (mavros_msgs::VehicleInfo*)realloc(this->vehicles, vehicles_lengthT * sizeof(mavros_msgs::VehicleInfo));
+ vehicles_length = vehicles_lengthT;
+ for( uint32_t i = 0; i < vehicles_length; i++){
+ offset += this->st_vehicles.deserialize(inbuffer + offset);
+ memcpy( &(this->vehicles[i]), &(this->st_vehicles), sizeof(mavros_msgs::VehicleInfo));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return VEHICLEINFOGET; };
+ const char * getMD5(){ return "d6808eae4fdcafd1421caee685a286b5"; };
+
+ };
+
+ class VehicleInfoGet {
+ public:
+ typedef VehicleInfoGetRequest Request;
+ typedef VehicleInfoGetResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/Vibration.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,77 @@
+#ifndef _ROS_mavros_msgs_Vibration_h
+#define _ROS_mavros_msgs_Vibration_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace mavros_msgs
+{
+
+ class Vibration : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Vector3 _vibration_type;
+ _vibration_type vibration;
+ float clipping[3];
+
+ Vibration():
+ header(),
+ vibration(),
+ clipping()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->vibration.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 3; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_clippingi;
+ u_clippingi.real = this->clipping[i];
+ *(outbuffer + offset + 0) = (u_clippingi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_clippingi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_clippingi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_clippingi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->clipping[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->vibration.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 3; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_clippingi;
+ u_clippingi.base = 0;
+ u_clippingi.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_clippingi.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_clippingi.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_clippingi.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->clipping[i] = u_clippingi.real;
+ offset += sizeof(this->clipping[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/Vibration"; };
+ const char * getMD5(){ return "eb92bf9b7aa735dfcd06b3ede5027d02"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/Waypoint.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,287 @@
+#ifndef _ROS_mavros_msgs_Waypoint_h
+#define _ROS_mavros_msgs_Waypoint_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+ class Waypoint : public ros::Msg
+ {
+ public:
+ typedef uint8_t _frame_type;
+ _frame_type frame;
+ typedef uint16_t _command_type;
+ _command_type command;
+ typedef bool _is_current_type;
+ _is_current_type is_current;
+ typedef bool _autocontinue_type;
+ _autocontinue_type autocontinue;
+ typedef float _param1_type;
+ _param1_type param1;
+ typedef float _param2_type;
+ _param2_type param2;
+ typedef float _param3_type;
+ _param3_type param3;
+ typedef float _param4_type;
+ _param4_type param4;
+ typedef double _x_lat_type;
+ _x_lat_type x_lat;
+ typedef double _y_long_type;
+ _y_long_type y_long;
+ typedef double _z_alt_type;
+ _z_alt_type z_alt;
+ enum { FRAME_GLOBAL = 0 };
+ enum { FRAME_LOCAL_NED = 1 };
+ enum { FRAME_MISSION = 2 };
+ enum { FRAME_GLOBAL_REL_ALT = 3 };
+ enum { FRAME_LOCAL_ENU = 4 };
+
+ Waypoint():
+ frame(0),
+ command(0),
+ is_current(0),
+ autocontinue(0),
+ param1(0),
+ param2(0),
+ param3(0),
+ param4(0),
+ x_lat(0),
+ y_long(0),
+ z_alt(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->frame >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->frame);
+ *(outbuffer + offset + 0) = (this->command >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->command >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->command);
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_current;
+ u_is_current.real = this->is_current;
+ *(outbuffer + offset + 0) = (u_is_current.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->is_current);
+ union {
+ bool real;
+ uint8_t base;
+ } u_autocontinue;
+ u_autocontinue.real = this->autocontinue;
+ *(outbuffer + offset + 0) = (u_autocontinue.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->autocontinue);
+ union {
+ float real;
+ uint32_t base;
+ } u_param1;
+ u_param1.real = this->param1;
+ *(outbuffer + offset + 0) = (u_param1.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param1.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param1.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param1.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param1);
+ union {
+ float real;
+ uint32_t base;
+ } u_param2;
+ u_param2.real = this->param2;
+ *(outbuffer + offset + 0) = (u_param2.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param2.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param2.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param2.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param2);
+ union {
+ float real;
+ uint32_t base;
+ } u_param3;
+ u_param3.real = this->param3;
+ *(outbuffer + offset + 0) = (u_param3.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param3.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param3.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param3.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param3);
+ union {
+ float real;
+ uint32_t base;
+ } u_param4;
+ u_param4.real = this->param4;
+ *(outbuffer + offset + 0) = (u_param4.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_param4.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_param4.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_param4.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->param4);
+ union {
+ double real;
+ uint64_t base;
+ } u_x_lat;
+ u_x_lat.real = this->x_lat;
+ *(outbuffer + offset + 0) = (u_x_lat.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x_lat.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x_lat.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x_lat.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_x_lat.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_x_lat.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_x_lat.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_x_lat.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->x_lat);
+ union {
+ double real;
+ uint64_t base;
+ } u_y_long;
+ u_y_long.real = this->y_long;
+ *(outbuffer + offset + 0) = (u_y_long.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y_long.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y_long.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y_long.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_y_long.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_y_long.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_y_long.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_y_long.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->y_long);
+ union {
+ double real;
+ uint64_t base;
+ } u_z_alt;
+ u_z_alt.real = this->z_alt;
+ *(outbuffer + offset + 0) = (u_z_alt.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_z_alt.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_z_alt.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_z_alt.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_z_alt.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_z_alt.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_z_alt.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_z_alt.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->z_alt);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->frame = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->frame);
+ this->command = ((uint16_t) (*(inbuffer + offset)));
+ this->command |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->command);
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_current;
+ u_is_current.base = 0;
+ u_is_current.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->is_current = u_is_current.real;
+ offset += sizeof(this->is_current);
+ union {
+ bool real;
+ uint8_t base;
+ } u_autocontinue;
+ u_autocontinue.base = 0;
+ u_autocontinue.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->autocontinue = u_autocontinue.real;
+ offset += sizeof(this->autocontinue);
+ union {
+ float real;
+ uint32_t base;
+ } u_param1;
+ u_param1.base = 0;
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param1.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param1 = u_param1.real;
+ offset += sizeof(this->param1);
+ union {
+ float real;
+ uint32_t base;
+ } u_param2;
+ u_param2.base = 0;
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param2.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param2 = u_param2.real;
+ offset += sizeof(this->param2);
+ union {
+ float real;
+ uint32_t base;
+ } u_param3;
+ u_param3.base = 0;
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param3.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param3 = u_param3.real;
+ offset += sizeof(this->param3);
+ union {
+ float real;
+ uint32_t base;
+ } u_param4;
+ u_param4.base = 0;
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_param4.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->param4 = u_param4.real;
+ offset += sizeof(this->param4);
+ union {
+ double real;
+ uint64_t base;
+ } u_x_lat;
+ u_x_lat.base = 0;
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_x_lat.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->x_lat = u_x_lat.real;
+ offset += sizeof(this->x_lat);
+ union {
+ double real;
+ uint64_t base;
+ } u_y_long;
+ u_y_long.base = 0;
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_y_long.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->y_long = u_y_long.real;
+ offset += sizeof(this->y_long);
+ union {
+ double real;
+ uint64_t base;
+ } u_z_alt;
+ u_z_alt.base = 0;
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_z_alt.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->z_alt = u_z_alt.real;
+ offset += sizeof(this->z_alt);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/Waypoint"; };
+ const char * getMD5(){ return "7a0d2b53dcd6b7aff0aa748703e85e92"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/WaypointClear.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_SERVICE_WaypointClear_h
+#define _ROS_SERVICE_WaypointClear_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char WAYPOINTCLEAR[] = "mavros_msgs/WaypointClear";
+
+ class WaypointClearRequest : public ros::Msg
+ {
+ public:
+
+ WaypointClearRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTCLEAR; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class WaypointClearResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ WaypointClearResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTCLEAR; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class WaypointClear {
+ public:
+ typedef WaypointClearRequest Request;
+ typedef WaypointClearResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/WaypointList.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,73 @@
+#ifndef _ROS_mavros_msgs_WaypointList_h
+#define _ROS_mavros_msgs_WaypointList_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mavros_msgs/Waypoint.h"
+
+namespace mavros_msgs
+{
+
+ class WaypointList : public ros::Msg
+ {
+ public:
+ typedef uint16_t _current_seq_type;
+ _current_seq_type current_seq;
+ uint32_t waypoints_length;
+ typedef mavros_msgs::Waypoint _waypoints_type;
+ _waypoints_type st_waypoints;
+ _waypoints_type * waypoints;
+
+ WaypointList():
+ current_seq(0),
+ waypoints_length(0), waypoints(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->current_seq >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->current_seq >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->current_seq);
+ *(outbuffer + offset + 0) = (this->waypoints_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->waypoints_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->waypoints_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->waypoints_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->waypoints_length);
+ for( uint32_t i = 0; i < waypoints_length; i++){
+ offset += this->waypoints[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->current_seq = ((uint16_t) (*(inbuffer + offset)));
+ this->current_seq |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->current_seq);
+ uint32_t waypoints_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->waypoints_length);
+ if(waypoints_lengthT > waypoints_length)
+ this->waypoints = (mavros_msgs::Waypoint*)realloc(this->waypoints, waypoints_lengthT * sizeof(mavros_msgs::Waypoint));
+ waypoints_length = waypoints_lengthT;
+ for( uint32_t i = 0; i < waypoints_length; i++){
+ offset += this->st_waypoints.deserialize(inbuffer + offset);
+ memcpy( &(this->waypoints[i]), &(this->st_waypoints), sizeof(mavros_msgs::Waypoint));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/WaypointList"; };
+ const char * getMD5(){ return "2cacdc0c2c212eb99fdee9f12d2e1fa4"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/WaypointPull.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,101 @@
+#ifndef _ROS_SERVICE_WaypointPull_h
+#define _ROS_SERVICE_WaypointPull_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char WAYPOINTPULL[] = "mavros_msgs/WaypointPull";
+
+ class WaypointPullRequest : public ros::Msg
+ {
+ public:
+
+ WaypointPullRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTPULL; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class WaypointPullResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint32_t _wp_received_type;
+ _wp_received_type wp_received;
+
+ WaypointPullResponse():
+ success(0),
+ wp_received(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->wp_received >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->wp_received >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->wp_received >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->wp_received >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->wp_received);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->wp_received = ((uint32_t) (*(inbuffer + offset)));
+ this->wp_received |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->wp_received |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->wp_received |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->wp_received);
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTPULL; };
+ const char * getMD5(){ return "a8d9ecef8fb37028d2db2a9aa4ed7e79"; };
+
+ };
+
+ class WaypointPull {
+ public:
+ typedef WaypointPullRequest Request;
+ typedef WaypointPullResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/WaypointPush.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,136 @@
+#ifndef _ROS_SERVICE_WaypointPush_h
+#define _ROS_SERVICE_WaypointPush_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "mavros_msgs/Waypoint.h"
+
+namespace mavros_msgs
+{
+
+static const char WAYPOINTPUSH[] = "mavros_msgs/WaypointPush";
+
+ class WaypointPushRequest : public ros::Msg
+ {
+ public:
+ typedef uint16_t _start_index_type;
+ _start_index_type start_index;
+ uint32_t waypoints_length;
+ typedef mavros_msgs::Waypoint _waypoints_type;
+ _waypoints_type st_waypoints;
+ _waypoints_type * waypoints;
+
+ WaypointPushRequest():
+ start_index(0),
+ waypoints_length(0), waypoints(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->start_index >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->start_index >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->start_index);
+ *(outbuffer + offset + 0) = (this->waypoints_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->waypoints_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->waypoints_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->waypoints_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->waypoints_length);
+ for( uint32_t i = 0; i < waypoints_length; i++){
+ offset += this->waypoints[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->start_index = ((uint16_t) (*(inbuffer + offset)));
+ this->start_index |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->start_index);
+ uint32_t waypoints_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->waypoints_length);
+ if(waypoints_lengthT > waypoints_length)
+ this->waypoints = (mavros_msgs::Waypoint*)realloc(this->waypoints, waypoints_lengthT * sizeof(mavros_msgs::Waypoint));
+ waypoints_length = waypoints_lengthT;
+ for( uint32_t i = 0; i < waypoints_length; i++){
+ offset += this->st_waypoints.deserialize(inbuffer + offset);
+ memcpy( &(this->waypoints[i]), &(this->st_waypoints), sizeof(mavros_msgs::Waypoint));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTPUSH; };
+ const char * getMD5(){ return "c07581e03ec6aa8a9583354fd792c02f"; };
+
+ };
+
+ class WaypointPushResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef uint32_t _wp_transfered_type;
+ _wp_transfered_type wp_transfered;
+
+ WaypointPushResponse():
+ success(0),
+ wp_transfered(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ *(outbuffer + offset + 0) = (this->wp_transfered >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->wp_transfered >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->wp_transfered >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->wp_transfered >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->wp_transfered);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ this->wp_transfered = ((uint32_t) (*(inbuffer + offset)));
+ this->wp_transfered |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->wp_transfered |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->wp_transfered |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->wp_transfered);
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTPUSH; };
+ const char * getMD5(){ return "90e0074a42480231d34eed864d14365e"; };
+
+ };
+
+ class WaypointPush {
+ public:
+ typedef WaypointPushRequest Request;
+ typedef WaypointPushResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/WaypointReached.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,53 @@
+#ifndef _ROS_mavros_msgs_WaypointReached_h
+#define _ROS_mavros_msgs_WaypointReached_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class WaypointReached : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint16_t _wp_seq_type;
+ _wp_seq_type wp_seq;
+
+ WaypointReached():
+ header(),
+ wp_seq(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->wp_seq >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->wp_seq >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->wp_seq);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->wp_seq = ((uint16_t) (*(inbuffer + offset)));
+ this->wp_seq |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->wp_seq);
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/WaypointReached"; };
+ const char * getMD5(){ return "1cf64d072d9f6aa0a6715922bdde6a35"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/WaypointSetCurrent.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,97 @@
+#ifndef _ROS_SERVICE_WaypointSetCurrent_h
+#define _ROS_SERVICE_WaypointSetCurrent_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace mavros_msgs
+{
+
+static const char WAYPOINTSETCURRENT[] = "mavros_msgs/WaypointSetCurrent";
+
+ class WaypointSetCurrentRequest : public ros::Msg
+ {
+ public:
+ typedef uint16_t _wp_seq_type;
+ _wp_seq_type wp_seq;
+
+ WaypointSetCurrentRequest():
+ wp_seq(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->wp_seq >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->wp_seq >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->wp_seq);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->wp_seq = ((uint16_t) (*(inbuffer + offset)));
+ this->wp_seq |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->wp_seq);
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTSETCURRENT; };
+ const char * getMD5(){ return "9541369175e0776b0fef1c988db6840f"; };
+
+ };
+
+ class WaypointSetCurrentResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ WaypointSetCurrentResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return WAYPOINTSETCURRENT; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class WaypointSetCurrent {
+ public:
+ typedef WaypointSetCurrentRequest Request;
+ typedef WaypointSetCurrentResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/mavros_msgs/WheelOdomStamped.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_mavros_msgs_WheelOdomStamped_h
+#define _ROS_mavros_msgs_WheelOdomStamped_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace mavros_msgs
+{
+
+ class WheelOdomStamped : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t data_length;
+ typedef double _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ WheelOdomStamped():
+ header(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_datai.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_datai.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_datai.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_datai.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (double*)realloc(this->data, data_lengthT * sizeof(double));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(double));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "mavros_msgs/WheelOdomStamped"; };
+ const char * getMD5(){ return "fb60495edd59d3fcf90e173153ae8a9a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+#ifndef _ROS_SERVICE_GetMap_h
+#define _ROS_SERVICE_GetMap_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "nav_msgs/OccupancyGrid.h"
+
+namespace nav_msgs
+{
+
+static const char GETMAP[] = "nav_msgs/GetMap";
+
+ class GetMapRequest : public ros::Msg
+ {
+ public:
+
+ GetMapRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return GETMAP; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class GetMapResponse : public ros::Msg
+ {
+ public:
+ typedef nav_msgs::OccupancyGrid _map_type;
+ _map_type map;
+
+ GetMapResponse():
+ map()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->map.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->map.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETMAP; };
+ const char * getMD5(){ return "6cdd0a18e0aff5b0a3ca2326a89b54ff"; };
+
+ };
+
+ class GetMap {
+ public:
+ typedef GetMapRequest Request;
+ typedef GetMapResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMapAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_nav_msgs_GetMapAction_h
+#define _ROS_nav_msgs_GetMapAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "nav_msgs/GetMapActionGoal.h"
+#include "nav_msgs/GetMapActionResult.h"
+#include "nav_msgs/GetMapActionFeedback.h"
+
+namespace nav_msgs
+{
+
+ class GetMapAction : public ros::Msg
+ {
+ public:
+ typedef nav_msgs::GetMapActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef nav_msgs::GetMapActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef nav_msgs::GetMapActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ GetMapAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GetMapAction"; };
+ const char * getMD5(){ return "e611ad23fbf237c031b7536416dc7cd7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMapActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_nav_msgs_GetMapActionFeedback_h
+#define _ROS_nav_msgs_GetMapActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "nav_msgs/GetMapFeedback.h"
+
+namespace nav_msgs
+{
+
+ class GetMapActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef nav_msgs::GetMapFeedback _feedback_type;
+ _feedback_type feedback;
+
+ GetMapActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GetMapActionFeedback"; };
+ const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMapActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_nav_msgs_GetMapActionGoal_h
+#define _ROS_nav_msgs_GetMapActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "nav_msgs/GetMapGoal.h"
+
+namespace nav_msgs
+{
+
+ class GetMapActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef nav_msgs::GetMapGoal _goal_type;
+ _goal_type goal;
+
+ GetMapActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GetMapActionGoal"; };
+ const char * getMD5(){ return "4b30be6cd12b9e72826df56b481f40e0"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMapActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_nav_msgs_GetMapActionResult_h
+#define _ROS_nav_msgs_GetMapActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "nav_msgs/GetMapResult.h"
+
+namespace nav_msgs
+{
+
+ class GetMapActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef nav_msgs::GetMapResult _result_type;
+ _result_type result;
+
+ GetMapActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GetMapActionResult"; };
+ const char * getMD5(){ return "ac66e5b9a79bb4bbd33dab245236c892"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMapFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_nav_msgs_GetMapFeedback_h
+#define _ROS_nav_msgs_GetMapFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace nav_msgs
+{
+
+ class GetMapFeedback : public ros::Msg
+ {
+ public:
+
+ GetMapFeedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GetMapFeedback"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMapGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_nav_msgs_GetMapGoal_h
+#define _ROS_nav_msgs_GetMapGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace nav_msgs
+{
+
+ class GetMapGoal : public ros::Msg
+ {
+ public:
+
+ GetMapGoal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GetMapGoal"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetMapResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,44 @@
+#ifndef _ROS_nav_msgs_GetMapResult_h
+#define _ROS_nav_msgs_GetMapResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "nav_msgs/OccupancyGrid.h"
+
+namespace nav_msgs
+{
+
+ class GetMapResult : public ros::Msg
+ {
+ public:
+ typedef nav_msgs::OccupancyGrid _map_type;
+ _map_type map;
+
+ GetMapResult():
+ map()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->map.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->map.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GetMapResult"; };
+ const char * getMD5(){ return "6cdd0a18e0aff5b0a3ca2326a89b54ff"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GetPlan.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,111 @@
+#ifndef _ROS_SERVICE_GetPlan_h
+#define _ROS_SERVICE_GetPlan_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/PoseStamped.h"
+#include "nav_msgs/Path.h"
+
+namespace nav_msgs
+{
+
+static const char GETPLAN[] = "nav_msgs/GetPlan";
+
+ class GetPlanRequest : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::PoseStamped _start_type;
+ _start_type start;
+ typedef geometry_msgs::PoseStamped _goal_type;
+ _goal_type goal;
+ typedef float _tolerance_type;
+ _tolerance_type tolerance;
+
+ GetPlanRequest():
+ start(),
+ goal(),
+ tolerance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->start.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_tolerance;
+ u_tolerance.real = this->tolerance;
+ *(outbuffer + offset + 0) = (u_tolerance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_tolerance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_tolerance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_tolerance.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->tolerance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->start.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_tolerance;
+ u_tolerance.base = 0;
+ u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_tolerance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->tolerance = u_tolerance.real;
+ offset += sizeof(this->tolerance);
+ return offset;
+ }
+
+ const char * getType(){ return GETPLAN; };
+ const char * getMD5(){ return "e25a43e0752bcca599a8c2eef8282df8"; };
+
+ };
+
+ class GetPlanResponse : public ros::Msg
+ {
+ public:
+ typedef nav_msgs::Path _plan_type;
+ _plan_type plan;
+
+ GetPlanResponse():
+ plan()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->plan.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->plan.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return GETPLAN; };
+ const char * getMD5(){ return "0002bc113c0259d71f6cf8cbc9430e18"; };
+
+ };
+
+ class GetPlan {
+ public:
+ typedef GetPlanRequest Request;
+ typedef GetPlanResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/GridCells.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,118 @@
+#ifndef _ROS_nav_msgs_GridCells_h
+#define _ROS_nav_msgs_GridCells_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Point.h"
+
+namespace nav_msgs
+{
+
+ class GridCells : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _cell_width_type;
+ _cell_width_type cell_width;
+ typedef float _cell_height_type;
+ _cell_height_type cell_height;
+ uint32_t cells_length;
+ typedef geometry_msgs::Point _cells_type;
+ _cells_type st_cells;
+ _cells_type * cells;
+
+ GridCells():
+ header(),
+ cell_width(0),
+ cell_height(0),
+ cells_length(0), cells(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_cell_width;
+ u_cell_width.real = this->cell_width;
+ *(outbuffer + offset + 0) = (u_cell_width.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_cell_width.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_cell_width.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_cell_width.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->cell_width);
+ union {
+ float real;
+ uint32_t base;
+ } u_cell_height;
+ u_cell_height.real = this->cell_height;
+ *(outbuffer + offset + 0) = (u_cell_height.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_cell_height.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_cell_height.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_cell_height.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->cell_height);
+ *(outbuffer + offset + 0) = (this->cells_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->cells_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->cells_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->cells_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->cells_length);
+ for( uint32_t i = 0; i < cells_length; i++){
+ offset += this->cells[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_cell_width;
+ u_cell_width.base = 0;
+ u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_cell_width.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->cell_width = u_cell_width.real;
+ offset += sizeof(this->cell_width);
+ union {
+ float real;
+ uint32_t base;
+ } u_cell_height;
+ u_cell_height.base = 0;
+ u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_cell_height.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->cell_height = u_cell_height.real;
+ offset += sizeof(this->cell_height);
+ uint32_t cells_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ cells_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->cells_length);
+ if(cells_lengthT > cells_length)
+ this->cells = (geometry_msgs::Point*)realloc(this->cells, cells_lengthT * sizeof(geometry_msgs::Point));
+ cells_length = cells_lengthT;
+ for( uint32_t i = 0; i < cells_length; i++){
+ offset += this->st_cells.deserialize(inbuffer + offset);
+ memcpy( &(this->cells[i]), &(this->st_cells), sizeof(geometry_msgs::Point));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/GridCells"; };
+ const char * getMD5(){ return "b9e4f5df6d28e272ebde00a3994830f5"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/MapMetaData.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,118 @@
+#ifndef _ROS_nav_msgs_MapMetaData_h
+#define _ROS_nav_msgs_MapMetaData_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+#include "geometry_msgs/Pose.h"
+
+namespace nav_msgs
+{
+
+ class MapMetaData : public ros::Msg
+ {
+ public:
+ typedef ros::Time _map_load_time_type;
+ _map_load_time_type map_load_time;
+ typedef float _resolution_type;
+ _resolution_type resolution;
+ typedef uint32_t _width_type;
+ _width_type width;
+ typedef uint32_t _height_type;
+ _height_type height;
+ typedef geometry_msgs::Pose _origin_type;
+ _origin_type origin;
+
+ MapMetaData():
+ map_load_time(),
+ resolution(0),
+ width(0),
+ height(0),
+ origin()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->map_load_time.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->map_load_time.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->map_load_time.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->map_load_time.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->map_load_time.sec);
+ *(outbuffer + offset + 0) = (this->map_load_time.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->map_load_time.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->map_load_time.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->map_load_time.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->map_load_time.nsec);
+ union {
+ float real;
+ uint32_t base;
+ } u_resolution;
+ u_resolution.real = this->resolution;
+ *(outbuffer + offset + 0) = (u_resolution.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_resolution.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_resolution.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_resolution.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->resolution);
+ *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->width);
+ *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->height);
+ offset += this->origin.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->map_load_time.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->map_load_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->map_load_time.sec);
+ this->map_load_time.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->map_load_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->map_load_time.nsec);
+ union {
+ float real;
+ uint32_t base;
+ } u_resolution;
+ u_resolution.base = 0;
+ u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_resolution.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->resolution = u_resolution.real;
+ offset += sizeof(this->resolution);
+ this->width = ((uint32_t) (*(inbuffer + offset)));
+ this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->width);
+ this->height = ((uint32_t) (*(inbuffer + offset)));
+ this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->height);
+ offset += this->origin.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/MapMetaData"; };
+ const char * getMD5(){ return "10cfc8a2818024d3248802c00c95f11b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/OccupancyGrid.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_nav_msgs_OccupancyGrid_h
+#define _ROS_nav_msgs_OccupancyGrid_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "nav_msgs/MapMetaData.h"
+
+namespace nav_msgs
+{
+
+ class OccupancyGrid : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef nav_msgs::MapMetaData _info_type;
+ _info_type info;
+ uint32_t data_length;
+ typedef int8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ OccupancyGrid():
+ header(),
+ info(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->info.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->info.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/OccupancyGrid"; };
+ const char * getMD5(){ return "3381f2d731d4076ec5c71b0759edbe4e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/Odometry.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,73 @@
+#ifndef _ROS_nav_msgs_Odometry_h
+#define _ROS_nav_msgs_Odometry_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/PoseWithCovariance.h"
+#include "geometry_msgs/TwistWithCovariance.h"
+
+namespace nav_msgs
+{
+
+ class Odometry : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _child_frame_id_type;
+ _child_frame_id_type child_frame_id;
+ typedef geometry_msgs::PoseWithCovariance _pose_type;
+ _pose_type pose;
+ typedef geometry_msgs::TwistWithCovariance _twist_type;
+ _twist_type twist;
+
+ Odometry():
+ header(),
+ child_frame_id(""),
+ pose(),
+ twist()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_child_frame_id = strlen(this->child_frame_id);
+ varToArr(outbuffer + offset, length_child_frame_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->child_frame_id, length_child_frame_id);
+ offset += length_child_frame_id;
+ offset += this->pose.serialize(outbuffer + offset);
+ offset += this->twist.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_child_frame_id;
+ arrToVar(length_child_frame_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_child_frame_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_child_frame_id-1]=0;
+ this->child_frame_id = (char *)(inbuffer + offset-1);
+ offset += length_child_frame_id;
+ offset += this->pose.deserialize(inbuffer + offset);
+ offset += this->twist.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/Odometry"; };
+ const char * getMD5(){ return "cd5e73d190d741a2f92e81eda573aca7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/Path.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_nav_msgs_Path_h
+#define _ROS_nav_msgs_Path_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/PoseStamped.h"
+
+namespace nav_msgs
+{
+
+ class Path : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t poses_length;
+ typedef geometry_msgs::PoseStamped _poses_type;
+ _poses_type st_poses;
+ _poses_type * poses;
+
+ Path():
+ header(),
+ poses_length(0), poses(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->poses_length);
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->poses[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->poses_length);
+ if(poses_lengthT > poses_length)
+ this->poses = (geometry_msgs::PoseStamped*)realloc(this->poses, poses_lengthT * sizeof(geometry_msgs::PoseStamped));
+ poses_length = poses_lengthT;
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->st_poses.deserialize(inbuffer + offset);
+ memcpy( &(this->poses[i]), &(this->st_poses), sizeof(geometry_msgs::PoseStamped));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "nav_msgs/Path"; };
+ const char * getMD5(){ return "6227e2b7e9cce15051f669a5e197bbf7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nav_msgs/SetMap.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,100 @@
+#ifndef _ROS_SERVICE_SetMap_h
+#define _ROS_SERVICE_SetMap_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "nav_msgs/OccupancyGrid.h"
+#include "geometry_msgs/PoseWithCovarianceStamped.h"
+
+namespace nav_msgs
+{
+
+static const char SETMAP[] = "nav_msgs/SetMap";
+
+ class SetMapRequest : public ros::Msg
+ {
+ public:
+ typedef nav_msgs::OccupancyGrid _map_type;
+ _map_type map;
+ typedef geometry_msgs::PoseWithCovarianceStamped _initial_pose_type;
+ _initial_pose_type initial_pose;
+
+ SetMapRequest():
+ map(),
+ initial_pose()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->map.serialize(outbuffer + offset);
+ offset += this->initial_pose.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->map.deserialize(inbuffer + offset);
+ offset += this->initial_pose.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return SETMAP; };
+ const char * getMD5(){ return "91149a20d7be299b87c340df8cc94fd4"; };
+
+ };
+
+ class SetMapResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ SetMapResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return SETMAP; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class SetMap {
+ public:
+ typedef SetMapRequest Request;
+ typedef SetMapResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nodelet/NodeletList.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,107 @@
+#ifndef _ROS_SERVICE_NodeletList_h
+#define _ROS_SERVICE_NodeletList_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace nodelet
+{
+
+static const char NODELETLIST[] = "nodelet/NodeletList";
+
+ class NodeletListRequest : public ros::Msg
+ {
+ public:
+
+ NodeletListRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return NODELETLIST; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class NodeletListResponse : public ros::Msg
+ {
+ public:
+ uint32_t nodelets_length;
+ typedef char* _nodelets_type;
+ _nodelets_type st_nodelets;
+ _nodelets_type * nodelets;
+
+ NodeletListResponse():
+ nodelets_length(0), nodelets(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->nodelets_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->nodelets_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->nodelets_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->nodelets_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->nodelets_length);
+ for( uint32_t i = 0; i < nodelets_length; i++){
+ uint32_t length_nodeletsi = strlen(this->nodelets[i]);
+ varToArr(outbuffer + offset, length_nodeletsi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->nodelets[i], length_nodeletsi);
+ offset += length_nodeletsi;
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t nodelets_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ nodelets_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->nodelets_length);
+ if(nodelets_lengthT > nodelets_length)
+ this->nodelets = (char**)realloc(this->nodelets, nodelets_lengthT * sizeof(char*));
+ nodelets_length = nodelets_lengthT;
+ for( uint32_t i = 0; i < nodelets_length; i++){
+ uint32_t length_st_nodelets;
+ arrToVar(length_st_nodelets, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_nodelets; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_nodelets-1]=0;
+ this->st_nodelets = (char *)(inbuffer + offset-1);
+ offset += length_st_nodelets;
+ memcpy( &(this->nodelets[i]), &(this->st_nodelets), sizeof(char*));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return NODELETLIST; };
+ const char * getMD5(){ return "99c7b10e794f5600b8030e697e946ca7"; };
+
+ };
+
+ class NodeletList {
+ public:
+ typedef NodeletListRequest Request;
+ typedef NodeletListResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nodelet/NodeletLoad.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,250 @@
+#ifndef _ROS_SERVICE_NodeletLoad_h
+#define _ROS_SERVICE_NodeletLoad_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace nodelet
+{
+
+static const char NODELETLOAD[] = "nodelet/NodeletLoad";
+
+ class NodeletLoadRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _type_type;
+ _type_type type;
+ uint32_t remap_source_args_length;
+ typedef char* _remap_source_args_type;
+ _remap_source_args_type st_remap_source_args;
+ _remap_source_args_type * remap_source_args;
+ uint32_t remap_target_args_length;
+ typedef char* _remap_target_args_type;
+ _remap_target_args_type st_remap_target_args;
+ _remap_target_args_type * remap_target_args;
+ uint32_t my_argv_length;
+ typedef char* _my_argv_type;
+ _my_argv_type st_my_argv;
+ _my_argv_type * my_argv;
+ typedef const char* _bond_id_type;
+ _bond_id_type bond_id;
+
+ NodeletLoadRequest():
+ name(""),
+ type(""),
+ remap_source_args_length(0), remap_source_args(NULL),
+ remap_target_args_length(0), remap_target_args(NULL),
+ my_argv_length(0), my_argv(NULL),
+ bond_id("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_type = strlen(this->type);
+ varToArr(outbuffer + offset, length_type);
+ offset += 4;
+ memcpy(outbuffer + offset, this->type, length_type);
+ offset += length_type;
+ *(outbuffer + offset + 0) = (this->remap_source_args_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->remap_source_args_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->remap_source_args_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->remap_source_args_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->remap_source_args_length);
+ for( uint32_t i = 0; i < remap_source_args_length; i++){
+ uint32_t length_remap_source_argsi = strlen(this->remap_source_args[i]);
+ varToArr(outbuffer + offset, length_remap_source_argsi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->remap_source_args[i], length_remap_source_argsi);
+ offset += length_remap_source_argsi;
+ }
+ *(outbuffer + offset + 0) = (this->remap_target_args_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->remap_target_args_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->remap_target_args_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->remap_target_args_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->remap_target_args_length);
+ for( uint32_t i = 0; i < remap_target_args_length; i++){
+ uint32_t length_remap_target_argsi = strlen(this->remap_target_args[i]);
+ varToArr(outbuffer + offset, length_remap_target_argsi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->remap_target_args[i], length_remap_target_argsi);
+ offset += length_remap_target_argsi;
+ }
+ *(outbuffer + offset + 0) = (this->my_argv_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->my_argv_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->my_argv_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->my_argv_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->my_argv_length);
+ for( uint32_t i = 0; i < my_argv_length; i++){
+ uint32_t length_my_argvi = strlen(this->my_argv[i]);
+ varToArr(outbuffer + offset, length_my_argvi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->my_argv[i], length_my_argvi);
+ offset += length_my_argvi;
+ }
+ uint32_t length_bond_id = strlen(this->bond_id);
+ varToArr(outbuffer + offset, length_bond_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->bond_id, length_bond_id);
+ offset += length_bond_id;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_type;
+ arrToVar(length_type, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_type; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_type-1]=0;
+ this->type = (char *)(inbuffer + offset-1);
+ offset += length_type;
+ uint32_t remap_source_args_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ remap_source_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->remap_source_args_length);
+ if(remap_source_args_lengthT > remap_source_args_length)
+ this->remap_source_args = (char**)realloc(this->remap_source_args, remap_source_args_lengthT * sizeof(char*));
+ remap_source_args_length = remap_source_args_lengthT;
+ for( uint32_t i = 0; i < remap_source_args_length; i++){
+ uint32_t length_st_remap_source_args;
+ arrToVar(length_st_remap_source_args, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_remap_source_args; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_remap_source_args-1]=0;
+ this->st_remap_source_args = (char *)(inbuffer + offset-1);
+ offset += length_st_remap_source_args;
+ memcpy( &(this->remap_source_args[i]), &(this->st_remap_source_args), sizeof(char*));
+ }
+ uint32_t remap_target_args_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ remap_target_args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->remap_target_args_length);
+ if(remap_target_args_lengthT > remap_target_args_length)
+ this->remap_target_args = (char**)realloc(this->remap_target_args, remap_target_args_lengthT * sizeof(char*));
+ remap_target_args_length = remap_target_args_lengthT;
+ for( uint32_t i = 0; i < remap_target_args_length; i++){
+ uint32_t length_st_remap_target_args;
+ arrToVar(length_st_remap_target_args, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_remap_target_args; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_remap_target_args-1]=0;
+ this->st_remap_target_args = (char *)(inbuffer + offset-1);
+ offset += length_st_remap_target_args;
+ memcpy( &(this->remap_target_args[i]), &(this->st_remap_target_args), sizeof(char*));
+ }
+ uint32_t my_argv_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ my_argv_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->my_argv_length);
+ if(my_argv_lengthT > my_argv_length)
+ this->my_argv = (char**)realloc(this->my_argv, my_argv_lengthT * sizeof(char*));
+ my_argv_length = my_argv_lengthT;
+ for( uint32_t i = 0; i < my_argv_length; i++){
+ uint32_t length_st_my_argv;
+ arrToVar(length_st_my_argv, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_my_argv; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_my_argv-1]=0;
+ this->st_my_argv = (char *)(inbuffer + offset-1);
+ offset += length_st_my_argv;
+ memcpy( &(this->my_argv[i]), &(this->st_my_argv), sizeof(char*));
+ }
+ uint32_t length_bond_id;
+ arrToVar(length_bond_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_bond_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_bond_id-1]=0;
+ this->bond_id = (char *)(inbuffer + offset-1);
+ offset += length_bond_id;
+ return offset;
+ }
+
+ const char * getType(){ return NODELETLOAD; };
+ const char * getMD5(){ return "c6e28cc4d2e259249d96cfb50658fbec"; };
+
+ };
+
+ class NodeletLoadResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ NodeletLoadResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return NODELETLOAD; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class NodeletLoad {
+ public:
+ typedef NodeletLoadRequest Request;
+ typedef NodeletLoadResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/nodelet/NodeletUnload.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,105 @@
+#ifndef _ROS_SERVICE_NodeletUnload_h
+#define _ROS_SERVICE_NodeletUnload_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace nodelet
+{
+
+static const char NODELETUNLOAD[] = "nodelet/NodeletUnload";
+
+ class NodeletUnloadRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+
+ NodeletUnloadRequest():
+ name("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ return offset;
+ }
+
+ const char * getType(){ return NODELETUNLOAD; };
+ const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
+
+ };
+
+ class NodeletUnloadResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+
+ NodeletUnloadResponse():
+ success(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ return offset;
+ }
+
+ const char * getType(){ return NODELETUNLOAD; };
+ const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
+
+ };
+
+ class NodeletUnload {
+ public:
+ typedef NodeletUnloadRequest Request;
+ typedef NodeletUnloadResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,46 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ROS_H_
+#define _ROS_H_
+
+#include "ros/node_handle.h"
+#include "MbedHardware.h"
+
+namespace ros
+{
+ typedef NodeHandle_<MbedHardware> NodeHandle;
+}
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/duration.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,76 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ROS_DURATION_H_
+#define _ROS_DURATION_H_
+
+#include <math.h>
+#include <stdint.h>
+
+namespace ros
+{
+
+void normalizeSecNSecSigned(int32_t& sec, int32_t& nsec);
+
+class Duration
+{
+public:
+ int32_t sec, nsec;
+
+ Duration() : sec(0), nsec(0) {}
+ Duration(int32_t _sec, int32_t _nsec) : sec(_sec), nsec(_nsec)
+ {
+ normalizeSecNSecSigned(sec, nsec);
+ }
+
+ double toSec() const
+ {
+ return (double)sec + 1e-9 * (double)nsec;
+ };
+ void fromSec(double t)
+ {
+ sec = (uint32_t) floor(t);
+ nsec = (uint32_t) ((t - sec) * 1e9);
+ nsec = nsec < 0.0 ? ceil(nsec - 0.5) : floor(nsec + 0.5);
+ };
+
+ Duration& operator+=(const Duration &rhs);
+ Duration& operator-=(const Duration &rhs);
+ Duration& operator*=(double scale);
+};
+
+}
+
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/msg.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,148 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ROS_MSG_H_
+#define _ROS_MSG_H_
+
+#include <stdint.h>
+#include <stddef.h>
+
+namespace ros
+{
+
+/* Base Message Type */
+class Msg
+{
+public:
+ virtual int serialize(unsigned char *outbuffer) const = 0;
+ virtual int deserialize(unsigned char *data) = 0;
+ virtual const char * getType() = 0;
+ virtual const char * getMD5() = 0;
+
+ /**
+ * @brief This tricky function handles promoting a 32bit float to a 64bit
+ * double, so that AVR can publish messages containing float64
+ * fields, despite AVV having no native support for double.
+ *
+ * @param[out] outbuffer pointer for buffer to serialize to.
+ * @param[in] f value to serialize.
+ *
+ * @return number of bytes to advance the buffer pointer.
+ *
+ */
+ static int serializeAvrFloat64(unsigned char* outbuffer, const float f)
+ {
+ const int32_t* val = (int32_t*) &f;
+ int32_t exp = ((*val >> 23) & 255);
+ if (exp != 0)
+ {
+ exp += 1023 - 127;
+ }
+
+ int32_t sig = *val;
+ *(outbuffer++) = 0;
+ *(outbuffer++) = 0;
+ *(outbuffer++) = 0;
+ *(outbuffer++) = (sig << 5) & 0xff;
+ *(outbuffer++) = (sig >> 3) & 0xff;
+ *(outbuffer++) = (sig >> 11) & 0xff;
+ *(outbuffer++) = ((exp << 4) & 0xF0) | ((sig >> 19) & 0x0F);
+ *(outbuffer++) = (exp >> 4) & 0x7F;
+
+ // Mark negative bit as necessary.
+ if (f < 0)
+ {
+ *(outbuffer - 1) |= 0x80;
+ }
+
+ return 8;
+ }
+
+ /**
+ * @brief This tricky function handles demoting a 64bit double to a
+ * 32bit float, so that AVR can understand messages containing
+ * float64 fields, despite AVR having no native support for double.
+ *
+ * @param[in] inbuffer pointer for buffer to deserialize from.
+ * @param[out] f pointer to place the deserialized value in.
+ *
+ * @return number of bytes to advance the buffer pointer.
+ */
+ static int deserializeAvrFloat64(const unsigned char* inbuffer, float* f)
+ {
+ uint32_t* val = (uint32_t*)f;
+ inbuffer += 3;
+
+ // Copy truncated mantissa.
+ *val = ((uint32_t)(*(inbuffer++)) >> 5 & 0x07);
+ *val |= ((uint32_t)(*(inbuffer++)) & 0xff) << 3;
+ *val |= ((uint32_t)(*(inbuffer++)) & 0xff) << 11;
+ *val |= ((uint32_t)(*inbuffer) & 0x0f) << 19;
+
+ // Copy truncated exponent.
+ uint32_t exp = ((uint32_t)(*(inbuffer++)) & 0xf0) >> 4;
+ exp |= ((uint32_t)(*inbuffer) & 0x7f) << 4;
+ if (exp != 0)
+ {
+ *val |= ((exp) - 1023 + 127) << 23;
+ }
+
+ // Copy negative sign.
+ *val |= ((uint32_t)(*(inbuffer++)) & 0x80) << 24;
+
+ return 8;
+ }
+
+ // Copy data from variable into a byte array
+ template<typename A, typename V>
+ static void varToArr(A arr, const V var)
+ {
+ for (size_t i = 0; i < sizeof(V); i++)
+ arr[i] = (var >> (8 * i));
+ }
+
+ // Copy data from a byte array into variable
+ template<typename V, typename A>
+ static void arrToVar(V& var, const A arr)
+ {
+ var = 0;
+ for (size_t i = 0; i < sizeof(V); i++)
+ var |= (arr[i] << (8 * i));
+ }
+
+};
+
+} // namespace ros
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/node_handle.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,686 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROS_NODE_HANDLE_H_
+#define ROS_NODE_HANDLE_H_
+
+#include <stdint.h>
+
+#include "std_msgs/Time.h"
+#include "rosserial_msgs/TopicInfo.h"
+#include "rosserial_msgs/Log.h"
+#include "rosserial_msgs/RequestParam.h"
+
+#include "ros/msg.h"
+
+namespace ros
+{
+
+class NodeHandleBase_
+{
+public:
+ virtual int publish(int id, const Msg* msg) = 0;
+ virtual int spinOnce() = 0;
+ virtual bool connected() = 0;
+};
+}
+
+#include "ros/publisher.h"
+#include "ros/subscriber.h"
+#include "ros/service_server.h"
+#include "ros/service_client.h"
+
+namespace ros
+{
+
+const int SPIN_OK = 0;
+const int SPIN_ERR = -1;
+const int SPIN_TIMEOUT = -2;
+
+const uint8_t SYNC_SECONDS = 5;
+const uint8_t MODE_FIRST_FF = 0;
+/*
+ * The second sync byte is a protocol version. It's value is 0xff for the first
+ * version of the rosserial protocol (used up to hydro), 0xfe for the second version
+ * (introduced in hydro), 0xfd for the next, and so on. Its purpose is to enable
+ * detection of mismatched protocol versions (e.g. hydro rosserial_python with groovy
+ * rosserial_arduino. It must be changed in both this file and in
+ * rosserial_python/src/rosserial_python/SerialClient.py
+ */
+const uint8_t MODE_PROTOCOL_VER = 1;
+const uint8_t PROTOCOL_VER1 = 0xff; // through groovy
+const uint8_t PROTOCOL_VER2 = 0xfe; // in hydro
+const uint8_t PROTOCOL_VER = PROTOCOL_VER2;
+const uint8_t MODE_SIZE_L = 2;
+const uint8_t MODE_SIZE_H = 3;
+const uint8_t MODE_SIZE_CHECKSUM = 4; // checksum for msg size received from size L and H
+const uint8_t MODE_TOPIC_L = 5; // waiting for topic id
+const uint8_t MODE_TOPIC_H = 6;
+const uint8_t MODE_MESSAGE = 7;
+const uint8_t MODE_MSG_CHECKSUM = 8; // checksum for msg and topic id
+
+
+const uint8_t SERIAL_MSG_TIMEOUT = 20; // 20 milliseconds to recieve all of message data
+
+using rosserial_msgs::TopicInfo;
+
+/* Node Handle */
+template<class Hardware,
+ int MAX_SUBSCRIBERS = 25,
+ int MAX_PUBLISHERS = 25,
+ int INPUT_SIZE = 512,
+ int OUTPUT_SIZE = 512>
+class NodeHandle_ : public NodeHandleBase_
+{
+protected:
+ Hardware hardware_;
+
+ /* time used for syncing */
+ uint32_t rt_time;
+
+ /* used for computing current time */
+ uint32_t sec_offset, nsec_offset;
+
+ /* Spinonce maximum work timeout */
+ uint32_t spin_timeout_;
+
+ uint8_t message_in[INPUT_SIZE];
+ uint8_t message_out[OUTPUT_SIZE];
+
+ Publisher * publishers[MAX_PUBLISHERS];
+ Subscriber_ * subscribers[MAX_SUBSCRIBERS];
+
+ /*
+ * Setup Functions
+ */
+public:
+ NodeHandle_() : configured_(false)
+ {
+
+ for (unsigned int i = 0; i < MAX_PUBLISHERS; i++)
+ publishers[i] = 0;
+
+ for (unsigned int i = 0; i < MAX_SUBSCRIBERS; i++)
+ subscribers[i] = 0;
+
+ for (unsigned int i = 0; i < INPUT_SIZE; i++)
+ message_in[i] = 0;
+
+ for (unsigned int i = 0; i < OUTPUT_SIZE; i++)
+ message_out[i] = 0;
+
+ req_param_resp.ints_length = 0;
+ req_param_resp.ints = NULL;
+ req_param_resp.floats_length = 0;
+ req_param_resp.floats = NULL;
+ req_param_resp.ints_length = 0;
+ req_param_resp.ints = NULL;
+
+ spin_timeout_ = 0;
+ }
+
+ Hardware* getHardware()
+ {
+ return &hardware_;
+ }
+
+ /* Start serial, initialize buffers */
+ void initNode()
+ {
+ hardware_.init();
+ mode_ = 0;
+ bytes_ = 0;
+ index_ = 0;
+ topic_ = 0;
+ };
+
+ /* Start a named port, which may be network server IP, initialize buffers */
+ void initNode(char *portName)
+ {
+ hardware_.init(portName);
+ mode_ = 0;
+ bytes_ = 0;
+ index_ = 0;
+ topic_ = 0;
+ };
+
+ /**
+ * @brief Sets the maximum time in millisconds that spinOnce() can work.
+ * This will not effect the processing of the buffer, as spinOnce processes
+ * one byte at a time. It simply sets the maximum time that one call can
+ * process for. You can choose to clear the buffer if that is beneficial if
+ * SPIN_TIMEOUT is returned from spinOnce().
+ * @param timeout The timeout in milliseconds that spinOnce will function.
+ */
+ void setSpinTimeout(const uint32_t& timeout)
+ {
+ spin_timeout_ = timeout;
+ }
+
+protected:
+ //State machine variables for spinOnce
+ int mode_;
+ int bytes_;
+ int topic_;
+ int index_;
+ int checksum_;
+
+ bool configured_;
+
+ /* used for syncing the time */
+ uint32_t last_sync_time;
+ uint32_t last_sync_receive_time;
+ uint32_t last_msg_timeout_time;
+
+public:
+ /* This function goes in your loop() function, it handles
+ * serial input and callbacks for subscribers.
+ */
+
+
+ virtual int spinOnce()
+ {
+ /* restart if timed out */
+ uint32_t c_time = hardware_.time();
+ if ((c_time - last_sync_receive_time) > (SYNC_SECONDS * 2200))
+ {
+ configured_ = false;
+ }
+
+ /* reset if message has timed out */
+ if (mode_ != MODE_FIRST_FF)
+ {
+ if (c_time > last_msg_timeout_time)
+ {
+ mode_ = MODE_FIRST_FF;
+ }
+ }
+
+ /* while available buffer, read data */
+ while (true)
+ {
+ // If a timeout has been specified, check how long spinOnce has been running.
+ if (spin_timeout_ > 0)
+ {
+ // If the maximum processing timeout has been exceeded, exit with error.
+ // The next spinOnce can continue where it left off, or optionally
+ // based on the application in use, the hardware buffer could be flushed
+ // and start fresh.
+ if ((hardware_.time() - c_time) > spin_timeout_)
+ {
+ // Exit the spin, processing timeout exceeded.
+ return SPIN_TIMEOUT;
+ }
+ }
+ int data = hardware_.read();
+ if (data < 0)
+ break;
+ checksum_ += data;
+ if (mode_ == MODE_MESSAGE) /* message data being recieved */
+ {
+ message_in[index_++] = data;
+ bytes_--;
+ if (bytes_ == 0) /* is message complete? if so, checksum */
+ mode_ = MODE_MSG_CHECKSUM;
+ }
+ else if (mode_ == MODE_FIRST_FF)
+ {
+ if (data == 0xff)
+ {
+ mode_++;
+ last_msg_timeout_time = c_time + SERIAL_MSG_TIMEOUT;
+ }
+ else if (hardware_.time() - c_time > (SYNC_SECONDS * 1000))
+ {
+ /* We have been stuck in spinOnce too long, return error */
+ configured_ = false;
+ return SPIN_TIMEOUT;
+ }
+ }
+ else if (mode_ == MODE_PROTOCOL_VER)
+ {
+ if (data == PROTOCOL_VER)
+ {
+ mode_++;
+ }
+ else
+ {
+ mode_ = MODE_FIRST_FF;
+ if (configured_ == false)
+ requestSyncTime(); /* send a msg back showing our protocol version */
+ }
+ }
+ else if (mode_ == MODE_SIZE_L) /* bottom half of message size */
+ {
+ bytes_ = data;
+ index_ = 0;
+ mode_++;
+ checksum_ = data; /* first byte for calculating size checksum */
+ }
+ else if (mode_ == MODE_SIZE_H) /* top half of message size */
+ {
+ bytes_ += data << 8;
+ mode_++;
+ }
+ else if (mode_ == MODE_SIZE_CHECKSUM)
+ {
+ if ((checksum_ % 256) == 255)
+ mode_++;
+ else
+ mode_ = MODE_FIRST_FF; /* Abandon the frame if the msg len is wrong */
+ }
+ else if (mode_ == MODE_TOPIC_L) /* bottom half of topic id */
+ {
+ topic_ = data;
+ mode_++;
+ checksum_ = data; /* first byte included in checksum */
+ }
+ else if (mode_ == MODE_TOPIC_H) /* top half of topic id */
+ {
+ topic_ += data << 8;
+ mode_ = MODE_MESSAGE;
+ if (bytes_ == 0)
+ mode_ = MODE_MSG_CHECKSUM;
+ }
+ else if (mode_ == MODE_MSG_CHECKSUM) /* do checksum */
+ {
+ mode_ = MODE_FIRST_FF;
+ if ((checksum_ % 256) == 255)
+ {
+ if (topic_ == TopicInfo::ID_PUBLISHER)
+ {
+ requestSyncTime();
+ negotiateTopics();
+ last_sync_time = c_time;
+ last_sync_receive_time = c_time;
+ return SPIN_ERR;
+ }
+ else if (topic_ == TopicInfo::ID_TIME)
+ {
+ syncTime(message_in);
+ }
+ else if (topic_ == TopicInfo::ID_PARAMETER_REQUEST)
+ {
+ req_param_resp.deserialize(message_in);
+ param_recieved = true;
+ }
+ else if (topic_ == TopicInfo::ID_TX_STOP)
+ {
+ configured_ = false;
+ }
+ else
+ {
+ if (subscribers[topic_ - 100])
+ subscribers[topic_ - 100]->callback(message_in);
+ }
+ }
+ }
+ }
+
+ /* occasionally sync time */
+ if (configured_ && ((c_time - last_sync_time) > (SYNC_SECONDS * 500)))
+ {
+ requestSyncTime();
+ last_sync_time = c_time;
+ }
+
+ return SPIN_OK;
+ }
+
+
+ /* Are we connected to the PC? */
+ virtual bool connected()
+ {
+ return configured_;
+ };
+
+ /********************************************************************
+ * Time functions
+ */
+
+ void requestSyncTime()
+ {
+ std_msgs::Time t;
+ publish(TopicInfo::ID_TIME, &t);
+ rt_time = hardware_.time();
+ }
+
+ void syncTime(uint8_t * data)
+ {
+ std_msgs::Time t;
+ uint32_t offset = hardware_.time() - rt_time;
+
+ t.deserialize(data);
+ t.data.sec += offset / 1000;
+ t.data.nsec += (offset % 1000) * 1000000UL;
+
+ this->setNow(t.data);
+ last_sync_receive_time = hardware_.time();
+ }
+
+ Time now()
+ {
+ uint32_t ms = hardware_.time();
+ Time current_time;
+ current_time.sec = ms / 1000 + sec_offset;
+ current_time.nsec = (ms % 1000) * 1000000UL + nsec_offset;
+ normalizeSecNSec(current_time.sec, current_time.nsec);
+ return current_time;
+ }
+
+ void setNow(Time & new_now)
+ {
+ uint32_t ms = hardware_.time();
+ sec_offset = new_now.sec - ms / 1000 - 1;
+ nsec_offset = new_now.nsec - (ms % 1000) * 1000000UL + 1000000000UL;
+ normalizeSecNSec(sec_offset, nsec_offset);
+ }
+
+ /********************************************************************
+ * Topic Management
+ */
+
+ /* Register a new publisher */
+ bool advertise(Publisher & p)
+ {
+ for (int i = 0; i < MAX_PUBLISHERS; i++)
+ {
+ if (publishers[i] == 0) // empty slot
+ {
+ publishers[i] = &p;
+ p.id_ = i + 100 + MAX_SUBSCRIBERS;
+ p.nh_ = this;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /* Register a new subscriber */
+ template<typename SubscriberT>
+ bool subscribe(SubscriberT& s)
+ {
+ for (int i = 0; i < MAX_SUBSCRIBERS; i++)
+ {
+ if (subscribers[i] == 0) // empty slot
+ {
+ subscribers[i] = static_cast<Subscriber_*>(&s);
+ s.id_ = i + 100;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /* Register a new Service Server */
+ template<typename MReq, typename MRes, typename ObjT>
+ bool advertiseService(ServiceServer<MReq, MRes, ObjT>& srv)
+ {
+ bool v = advertise(srv.pub);
+ for (int i = 0; i < MAX_SUBSCRIBERS; i++)
+ {
+ if (subscribers[i] == 0) // empty slot
+ {
+ subscribers[i] = static_cast<Subscriber_*>(&srv);
+ srv.id_ = i + 100;
+ return v;
+ }
+ }
+ return false;
+ }
+
+ /* Register a new Service Client */
+ template<typename MReq, typename MRes>
+ bool serviceClient(ServiceClient<MReq, MRes>& srv)
+ {
+ bool v = advertise(srv.pub);
+ for (int i = 0; i < MAX_SUBSCRIBERS; i++)
+ {
+ if (subscribers[i] == 0) // empty slot
+ {
+ subscribers[i] = static_cast<Subscriber_*>(&srv);
+ srv.id_ = i + 100;
+ return v;
+ }
+ }
+ return false;
+ }
+
+ void negotiateTopics()
+ {
+ rosserial_msgs::TopicInfo ti;
+ int i;
+ for (i = 0; i < MAX_PUBLISHERS; i++)
+ {
+ if (publishers[i] != 0) // non-empty slot
+ {
+ ti.topic_id = publishers[i]->id_;
+ ti.topic_name = (char *) publishers[i]->topic_;
+ ti.message_type = (char *) publishers[i]->msg_->getType();
+ ti.md5sum = (char *) publishers[i]->msg_->getMD5();
+ ti.buffer_size = OUTPUT_SIZE;
+ publish(publishers[i]->getEndpointType(), &ti);
+ }
+ }
+ for (i = 0; i < MAX_SUBSCRIBERS; i++)
+ {
+ if (subscribers[i] != 0) // non-empty slot
+ {
+ ti.topic_id = subscribers[i]->id_;
+ ti.topic_name = (char *) subscribers[i]->topic_;
+ ti.message_type = (char *) subscribers[i]->getMsgType();
+ ti.md5sum = (char *) subscribers[i]->getMsgMD5();
+ ti.buffer_size = INPUT_SIZE;
+ publish(subscribers[i]->getEndpointType(), &ti);
+ }
+ }
+ configured_ = true;
+ }
+
+ virtual int publish(int id, const Msg * msg)
+ {
+ if (id >= 100 && !configured_)
+ return 0;
+
+ /* serialize message */
+ int l = msg->serialize(message_out + 7);
+
+ /* setup the header */
+ message_out[0] = 0xff;
+ message_out[1] = PROTOCOL_VER;
+ message_out[2] = (uint8_t)((uint16_t)l & 255);
+ message_out[3] = (uint8_t)((uint16_t)l >> 8);
+ message_out[4] = 255 - ((message_out[2] + message_out[3]) % 256);
+ message_out[5] = (uint8_t)((int16_t)id & 255);
+ message_out[6] = (uint8_t)((int16_t)id >> 8);
+
+ /* calculate checksum */
+ int chk = 0;
+ for (int i = 5; i < l + 7; i++)
+ chk += message_out[i];
+ l += 7;
+ message_out[l++] = 255 - (chk % 256);
+
+ if (l <= OUTPUT_SIZE)
+ {
+ hardware_.write(message_out, l);
+ return l;
+ }
+ else
+ {
+ logerror("Message from device dropped: message larger than buffer.");
+ return -1;
+ }
+ }
+
+ /********************************************************************
+ * Logging
+ */
+
+private:
+ void log(char byte, const char * msg)
+ {
+ rosserial_msgs::Log l;
+ l.level = byte;
+ l.msg = (char*)msg;
+ publish(rosserial_msgs::TopicInfo::ID_LOG, &l);
+ }
+
+public:
+ void logdebug(const char* msg)
+ {
+ log(rosserial_msgs::Log::ROSDEBUG, msg);
+ }
+ void loginfo(const char * msg)
+ {
+ log(rosserial_msgs::Log::INFO, msg);
+ }
+ void logwarn(const char *msg)
+ {
+ log(rosserial_msgs::Log::WARN, msg);
+ }
+ void logerror(const char*msg)
+ {
+ log(rosserial_msgs::Log::ERROR, msg);
+ }
+ void logfatal(const char*msg)
+ {
+ log(rosserial_msgs::Log::FATAL, msg);
+ }
+
+ /********************************************************************
+ * Parameters
+ */
+
+private:
+ bool param_recieved;
+ rosserial_msgs::RequestParamResponse req_param_resp;
+
+ bool requestParam(const char * name, int time_out = 1000)
+ {
+ param_recieved = false;
+ rosserial_msgs::RequestParamRequest req;
+ req.name = (char*)name;
+ publish(TopicInfo::ID_PARAMETER_REQUEST, &req);
+ uint32_t end_time = hardware_.time() + time_out;
+ while (!param_recieved)
+ {
+ spinOnce();
+ if (hardware_.time() > end_time)
+ {
+ logwarn("Failed to get param: timeout expired");
+ return false;
+ }
+ }
+ return true;
+ }
+
+public:
+ bool getParam(const char* name, int* param, int length = 1, int timeout = 1000)
+ {
+ if (requestParam(name, timeout))
+ {
+ if (length == req_param_resp.ints_length)
+ {
+ //copy it over
+ for (int i = 0; i < length; i++)
+ param[i] = req_param_resp.ints[i];
+ return true;
+ }
+ else
+ {
+ logwarn("Failed to get param: length mismatch");
+ }
+ }
+ return false;
+ }
+ bool getParam(const char* name, float* param, int length = 1, int timeout = 1000)
+ {
+ if (requestParam(name, timeout))
+ {
+ if (length == req_param_resp.floats_length)
+ {
+ //copy it over
+ for (int i = 0; i < length; i++)
+ param[i] = req_param_resp.floats[i];
+ return true;
+ }
+ else
+ {
+ logwarn("Failed to get param: length mismatch");
+ }
+ }
+ return false;
+ }
+ bool getParam(const char* name, char** param, int length = 1, int timeout = 1000)
+ {
+ if (requestParam(name, timeout))
+ {
+ if (length == req_param_resp.strings_length)
+ {
+ //copy it over
+ for (int i = 0; i < length; i++)
+ strcpy(param[i], req_param_resp.strings[i]);
+ return true;
+ }
+ else
+ {
+ logwarn("Failed to get param: length mismatch");
+ }
+ }
+ return false;
+ }
+ bool getParam(const char* name, bool* param, int length = 1, int timeout = 1000)
+ {
+ if (requestParam(name, timeout))
+ {
+ if (length == req_param_resp.ints_length)
+ {
+ //copy it over
+ for (int i = 0; i < length; i++)
+ param[i] = req_param_resp.ints[i];
+ return true;
+ }
+ else
+ {
+ logwarn("Failed to get param: length mismatch");
+ }
+ }
+ return false;
+ }
+};
+
+}
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/publisher.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,74 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ROS_PUBLISHER_H_
+#define _ROS_PUBLISHER_H_
+
+#include "rosserial_msgs/TopicInfo.h"
+#include "ros/node_handle.h"
+
+namespace ros
+{
+
+/* Generic Publisher */
+class Publisher
+{
+public:
+ Publisher(const char * topic_name, Msg * msg, int endpoint = rosserial_msgs::TopicInfo::ID_PUBLISHER) :
+ topic_(topic_name),
+ msg_(msg),
+ endpoint_(endpoint) {};
+
+ int publish(const Msg * msg)
+ {
+ return nh_->publish(id_, msg);
+ };
+ int getEndpointType()
+ {
+ return endpoint_;
+ }
+
+ const char * topic_;
+ Msg *msg_;
+ // id_ and no_ are set by NodeHandle when we advertise
+ int id_;
+ NodeHandleBase_* nh_;
+
+private:
+ int endpoint_;
+};
+
+}
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/service_client.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,95 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ROS_SERVICE_CLIENT_H_
+#define _ROS_SERVICE_CLIENT_H_
+
+#include "rosserial_msgs/TopicInfo.h"
+
+#include "ros/publisher.h"
+#include "ros/subscriber.h"
+
+namespace ros
+{
+
+template<typename MReq , typename MRes>
+class ServiceClient : public Subscriber_
+{
+public:
+ ServiceClient(const char* topic_name) :
+ pub(topic_name, &req, rosserial_msgs::TopicInfo::ID_SERVICE_CLIENT + rosserial_msgs::TopicInfo::ID_PUBLISHER)
+ {
+ this->topic_ = topic_name;
+ this->waiting = true;
+ }
+
+ virtual void call(const MReq & request, MRes & response)
+ {
+ if (!pub.nh_->connected()) return;
+ ret = &response;
+ waiting = true;
+ pub.publish(&request);
+ while (waiting && pub.nh_->connected())
+ if (pub.nh_->spinOnce() < 0) break;
+ }
+
+ // these refer to the subscriber
+ virtual void callback(unsigned char *data)
+ {
+ ret->deserialize(data);
+ waiting = false;
+ }
+ virtual const char * getMsgType()
+ {
+ return this->resp.getType();
+ }
+ virtual const char * getMsgMD5()
+ {
+ return this->resp.getMD5();
+ }
+ virtual int getEndpointType()
+ {
+ return rosserial_msgs::TopicInfo::ID_SERVICE_CLIENT + rosserial_msgs::TopicInfo::ID_SUBSCRIBER;
+ }
+
+ MReq req;
+ MRes resp;
+ MRes * ret;
+ bool waiting;
+ Publisher pub;
+};
+
+}
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/service_server.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,130 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ROS_SERVICE_SERVER_H_
+#define _ROS_SERVICE_SERVER_H_
+
+#include "rosserial_msgs/TopicInfo.h"
+
+#include "ros/publisher.h"
+#include "ros/subscriber.h"
+
+namespace ros
+{
+
+template<typename MReq , typename MRes, typename ObjT = void>
+class ServiceServer : public Subscriber_
+{
+public:
+ typedef void(ObjT::*CallbackT)(const MReq&, MRes&);
+
+ ServiceServer(const char* topic_name, CallbackT cb, ObjT* obj) :
+ pub(topic_name, &resp, rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_PUBLISHER),
+ obj_(obj)
+ {
+ this->topic_ = topic_name;
+ this->cb_ = cb;
+ }
+
+ // these refer to the subscriber
+ virtual void callback(unsigned char *data)
+ {
+ req.deserialize(data);
+ (obj_->*cb_)(req, resp);
+ pub.publish(&resp);
+ }
+ virtual const char * getMsgType()
+ {
+ return this->req.getType();
+ }
+ virtual const char * getMsgMD5()
+ {
+ return this->req.getMD5();
+ }
+ virtual int getEndpointType()
+ {
+ return rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_SUBSCRIBER;
+ }
+
+ MReq req;
+ MRes resp;
+ Publisher pub;
+private:
+ CallbackT cb_;
+ ObjT* obj_;
+};
+
+template<typename MReq , typename MRes>
+class ServiceServer<MReq, MRes, void> : public Subscriber_
+{
+public:
+ typedef void(*CallbackT)(const MReq&, MRes&);
+
+ ServiceServer(const char* topic_name, CallbackT cb) :
+ pub(topic_name, &resp, rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_PUBLISHER)
+ {
+ this->topic_ = topic_name;
+ this->cb_ = cb;
+ }
+
+ // these refer to the subscriber
+ virtual void callback(unsigned char *data)
+ {
+ req.deserialize(data);
+ cb_(req, resp);
+ pub.publish(&resp);
+ }
+ virtual const char * getMsgType()
+ {
+ return this->req.getType();
+ }
+ virtual const char * getMsgMD5()
+ {
+ return this->req.getMD5();
+ }
+ virtual int getEndpointType()
+ {
+ return rosserial_msgs::TopicInfo::ID_SERVICE_SERVER + rosserial_msgs::TopicInfo::ID_SUBSCRIBER;
+ }
+
+ MReq req;
+ MRes resp;
+ Publisher pub;
+private:
+ CallbackT cb_;
+};
+
+}
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/subscriber.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,140 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROS_SUBSCRIBER_H_
+#define ROS_SUBSCRIBER_H_
+
+#include "rosserial_msgs/TopicInfo.h"
+
+namespace ros
+{
+
+/* Base class for objects subscribers. */
+class Subscriber_
+{
+public:
+ virtual void callback(unsigned char *data) = 0;
+ virtual int getEndpointType() = 0;
+
+ // id_ is set by NodeHandle when we advertise
+ int id_;
+
+ virtual const char * getMsgType() = 0;
+ virtual const char * getMsgMD5() = 0;
+ const char * topic_;
+};
+
+/* Bound function subscriber. */
+template<typename MsgT, typename ObjT = void>
+class Subscriber: public Subscriber_
+{
+public:
+ typedef void(ObjT::*CallbackT)(const MsgT&);
+ MsgT msg;
+
+ Subscriber(const char * topic_name, CallbackT cb, ObjT* obj, int endpoint = rosserial_msgs::TopicInfo::ID_SUBSCRIBER) :
+ cb_(cb),
+ obj_(obj),
+ endpoint_(endpoint)
+ {
+ topic_ = topic_name;
+ };
+
+ virtual void callback(unsigned char* data)
+ {
+ msg.deserialize(data);
+ (obj_->*cb_)(msg);
+ }
+
+ virtual const char * getMsgType()
+ {
+ return this->msg.getType();
+ }
+ virtual const char * getMsgMD5()
+ {
+ return this->msg.getMD5();
+ }
+ virtual int getEndpointType()
+ {
+ return endpoint_;
+ }
+
+private:
+ CallbackT cb_;
+ ObjT* obj_;
+ int endpoint_;
+};
+
+/* Standalone function subscriber. */
+template<typename MsgT>
+class Subscriber<MsgT, void>: public Subscriber_
+{
+public:
+ typedef void(*CallbackT)(const MsgT&);
+ MsgT msg;
+
+ Subscriber(const char * topic_name, CallbackT cb, int endpoint = rosserial_msgs::TopicInfo::ID_SUBSCRIBER) :
+ cb_(cb),
+ endpoint_(endpoint)
+ {
+ topic_ = topic_name;
+ };
+
+ virtual void callback(unsigned char* data)
+ {
+ msg.deserialize(data);
+ this->cb_(msg);
+ }
+
+ virtual const char * getMsgType()
+ {
+ return this->msg.getType();
+ }
+ virtual const char * getMsgMD5()
+ {
+ return this->msg.getMD5();
+ }
+ virtual int getEndpointType()
+ {
+ return endpoint_;
+ }
+
+private:
+ CallbackT cb_;
+ int endpoint_;
+};
+
+}
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/ros/time.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,83 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROS_TIME_H_
+#define ROS_TIME_H_
+
+#include "ros/duration.h"
+#include <math.h>
+#include <stdint.h>
+
+namespace ros
+{
+void normalizeSecNSec(uint32_t &sec, uint32_t &nsec);
+
+class Time
+{
+public:
+ uint32_t sec, nsec;
+
+ Time() : sec(0), nsec(0) {}
+ Time(uint32_t _sec, uint32_t _nsec) : sec(_sec), nsec(_nsec)
+ {
+ normalizeSecNSec(sec, nsec);
+ }
+
+ double toSec() const
+ {
+ return (double)sec + 1e-9 * (double)nsec;
+ };
+ void fromSec(double t)
+ {
+ sec = (uint32_t) floor(t);
+ nsec = (uint32_t) ((t - sec) * 1e9);
+ nsec = nsec < 0.0 ? ceil(nsec - 0.5) : floor(nsec + 0.5);
+ };
+
+ uint32_t toNsec()
+ {
+ return (uint32_t)sec * 1000000000ull + (uint32_t)nsec;
+ };
+ Time& fromNSec(int32_t t);
+
+ Time& operator +=(const Duration &rhs);
+ Time& operator -=(const Duration &rhs);
+
+ static Time now();
+ static void setNow(Time & new_now);
+};
+
+}
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/roscpp/Empty.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_SERVICE_Empty_h
+#define _ROS_SERVICE_Empty_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace roscpp
+{
+
+static const char EMPTY[] = "roscpp/Empty";
+
+ class EmptyRequest : public ros::Msg
+ {
+ public:
+
+ EmptyRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return EMPTY; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class EmptyResponse : public ros::Msg
+ {
+ public:
+
+ EmptyResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return EMPTY; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class Empty {
+ public:
+ typedef EmptyRequest Request;
+ typedef EmptyResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/roscpp/GetLoggers.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_SERVICE_GetLoggers_h
+#define _ROS_SERVICE_GetLoggers_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "roscpp/Logger.h"
+
+namespace roscpp
+{
+
+static const char GETLOGGERS[] = "roscpp/GetLoggers";
+
+ class GetLoggersRequest : public ros::Msg
+ {
+ public:
+
+ GetLoggersRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return GETLOGGERS; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class GetLoggersResponse : public ros::Msg
+ {
+ public:
+ uint32_t loggers_length;
+ typedef roscpp::Logger _loggers_type;
+ _loggers_type st_loggers;
+ _loggers_type * loggers;
+
+ GetLoggersResponse():
+ loggers_length(0), loggers(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->loggers_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->loggers_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->loggers_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->loggers_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->loggers_length);
+ for( uint32_t i = 0; i < loggers_length; i++){
+ offset += this->loggers[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t loggers_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->loggers_length);
+ if(loggers_lengthT > loggers_length)
+ this->loggers = (roscpp::Logger*)realloc(this->loggers, loggers_lengthT * sizeof(roscpp::Logger));
+ loggers_length = loggers_lengthT;
+ for( uint32_t i = 0; i < loggers_length; i++){
+ offset += this->st_loggers.deserialize(inbuffer + offset);
+ memcpy( &(this->loggers[i]), &(this->st_loggers), sizeof(roscpp::Logger));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return GETLOGGERS; };
+ const char * getMD5(){ return "32e97e85527d4678a8f9279894bb64b0"; };
+
+ };
+
+ class GetLoggers {
+ public:
+ typedef GetLoggersRequest Request;
+ typedef GetLoggersResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/roscpp/Logger.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,72 @@
+#ifndef _ROS_roscpp_Logger_h
+#define _ROS_roscpp_Logger_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace roscpp
+{
+
+ class Logger : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _level_type;
+ _level_type level;
+
+ Logger():
+ name(""),
+ level("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_level = strlen(this->level);
+ varToArr(outbuffer + offset, length_level);
+ offset += 4;
+ memcpy(outbuffer + offset, this->level, length_level);
+ offset += length_level;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_level;
+ arrToVar(length_level, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_level; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_level-1]=0;
+ this->level = (char *)(inbuffer + offset-1);
+ offset += length_level;
+ return offset;
+ }
+
+ const char * getType(){ return "roscpp/Logger"; };
+ const char * getMD5(){ return "a6069a2ff40db7bd32143dd66e1f408e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/roscpp/SetLoggerLevel.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,104 @@
+#ifndef _ROS_SERVICE_SetLoggerLevel_h
+#define _ROS_SERVICE_SetLoggerLevel_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace roscpp
+{
+
+static const char SETLOGGERLEVEL[] = "roscpp/SetLoggerLevel";
+
+ class SetLoggerLevelRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _logger_type;
+ _logger_type logger;
+ typedef const char* _level_type;
+ _level_type level;
+
+ SetLoggerLevelRequest():
+ logger(""),
+ level("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_logger = strlen(this->logger);
+ varToArr(outbuffer + offset, length_logger);
+ offset += 4;
+ memcpy(outbuffer + offset, this->logger, length_logger);
+ offset += length_logger;
+ uint32_t length_level = strlen(this->level);
+ varToArr(outbuffer + offset, length_level);
+ offset += 4;
+ memcpy(outbuffer + offset, this->level, length_level);
+ offset += length_level;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_logger;
+ arrToVar(length_logger, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_logger; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_logger-1]=0;
+ this->logger = (char *)(inbuffer + offset-1);
+ offset += length_logger;
+ uint32_t length_level;
+ arrToVar(length_level, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_level; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_level-1]=0;
+ this->level = (char *)(inbuffer + offset-1);
+ offset += length_level;
+ return offset;
+ }
+
+ const char * getType(){ return SETLOGGERLEVEL; };
+ const char * getMD5(){ return "51da076440d78ca1684d36c868df61ea"; };
+
+ };
+
+ class SetLoggerLevelResponse : public ros::Msg
+ {
+ public:
+
+ SetLoggerLevelResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return SETLOGGERLEVEL; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class SetLoggerLevel {
+ public:
+ typedef SetLoggerLevelRequest Request;
+ typedef SetLoggerLevelResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/roscpp_tutorials/TwoInts.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,166 @@
+#ifndef _ROS_SERVICE_TwoInts_h
+#define _ROS_SERVICE_TwoInts_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace roscpp_tutorials
+{
+
+static const char TWOINTS[] = "roscpp_tutorials/TwoInts";
+
+ class TwoIntsRequest : public ros::Msg
+ {
+ public:
+ typedef int64_t _a_type;
+ _a_type a;
+ typedef int64_t _b_type;
+ _b_type b;
+
+ TwoIntsRequest():
+ a(0),
+ b(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.real = this->a;
+ *(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->a);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_b;
+ u_b.real = this->b;
+ *(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_b.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_b.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_b.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_b.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.base = 0;
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->a = u_a.real;
+ offset += sizeof(this->a);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_b;
+ u_b.base = 0;
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->b = u_b.real;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ const char * getType(){ return TWOINTS; };
+ const char * getMD5(){ return "36d09b846be0b371c5f190354dd3153e"; };
+
+ };
+
+ class TwoIntsResponse : public ros::Msg
+ {
+ public:
+ typedef int64_t _sum_type;
+ _sum_type sum;
+
+ TwoIntsResponse():
+ sum(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_sum;
+ u_sum.real = this->sum;
+ *(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_sum.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_sum.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_sum.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_sum.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_sum;
+ u_sum.base = 0;
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->sum = u_sum.real;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ const char * getType(){ return TWOINTS; };
+ const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
+
+ };
+
+ class TwoInts {
+ public:
+ typedef TwoIntsRequest Request;
+ typedef TwoIntsResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosgraph_msgs/Clock.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_rosgraph_msgs_Clock_h
+#define _ROS_rosgraph_msgs_Clock_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+
+namespace rosgraph_msgs
+{
+
+ class Clock : public ros::Msg
+ {
+ public:
+ typedef ros::Time _clock_type;
+ _clock_type clock;
+
+ Clock():
+ clock()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->clock.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->clock.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->clock.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->clock.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->clock.sec);
+ *(outbuffer + offset + 0) = (this->clock.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->clock.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->clock.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->clock.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->clock.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->clock.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->clock.sec);
+ this->clock.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->clock.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "rosgraph_msgs/Clock"; };
+ const char * getMD5(){ return "a9c97c1d230cfc112e270351a944ee47"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosgraph_msgs/Log.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,185 @@
+#ifndef _ROS_rosgraph_msgs_Log_h
+#define _ROS_rosgraph_msgs_Log_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace rosgraph_msgs
+{
+
+ class Log : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef int8_t _level_type;
+ _level_type level;
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _msg_type;
+ _msg_type msg;
+ typedef const char* _file_type;
+ _file_type file;
+ typedef const char* _function_type;
+ _function_type function;
+ typedef uint32_t _line_type;
+ _line_type line;
+ uint32_t topics_length;
+ typedef char* _topics_type;
+ _topics_type st_topics;
+ _topics_type * topics;
+ enum { DEBUG = 1 };
+ enum { INFO = 2 };
+ enum { WARN = 4 };
+ enum { ERROR = 8 };
+ enum { FATAL = 16 };
+
+ Log():
+ header(),
+ level(0),
+ name(""),
+ msg(""),
+ file(""),
+ function(""),
+ line(0),
+ topics_length(0), topics(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_level;
+ u_level.real = this->level;
+ *(outbuffer + offset + 0) = (u_level.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->level);
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_msg = strlen(this->msg);
+ varToArr(outbuffer + offset, length_msg);
+ offset += 4;
+ memcpy(outbuffer + offset, this->msg, length_msg);
+ offset += length_msg;
+ uint32_t length_file = strlen(this->file);
+ varToArr(outbuffer + offset, length_file);
+ offset += 4;
+ memcpy(outbuffer + offset, this->file, length_file);
+ offset += length_file;
+ uint32_t length_function = strlen(this->function);
+ varToArr(outbuffer + offset, length_function);
+ offset += 4;
+ memcpy(outbuffer + offset, this->function, length_function);
+ offset += length_function;
+ *(outbuffer + offset + 0) = (this->line >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->line >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->line >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->line >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->line);
+ *(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->topics_length);
+ for( uint32_t i = 0; i < topics_length; i++){
+ uint32_t length_topicsi = strlen(this->topics[i]);
+ varToArr(outbuffer + offset, length_topicsi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topics[i], length_topicsi);
+ offset += length_topicsi;
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_level;
+ u_level.base = 0;
+ u_level.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->level = u_level.real;
+ offset += sizeof(this->level);
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_msg;
+ arrToVar(length_msg, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_msg; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_msg-1]=0;
+ this->msg = (char *)(inbuffer + offset-1);
+ offset += length_msg;
+ uint32_t length_file;
+ arrToVar(length_file, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_file; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_file-1]=0;
+ this->file = (char *)(inbuffer + offset-1);
+ offset += length_file;
+ uint32_t length_function;
+ arrToVar(length_function, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_function; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_function-1]=0;
+ this->function = (char *)(inbuffer + offset-1);
+ offset += length_function;
+ this->line = ((uint32_t) (*(inbuffer + offset)));
+ this->line |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->line |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->line |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->line);
+ uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->topics_length);
+ if(topics_lengthT > topics_length)
+ this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
+ topics_length = topics_lengthT;
+ for( uint32_t i = 0; i < topics_length; i++){
+ uint32_t length_st_topics;
+ arrToVar(length_st_topics, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_topics; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_topics-1]=0;
+ this->st_topics = (char *)(inbuffer + offset-1);
+ offset += length_st_topics;
+ memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "rosgraph_msgs/Log"; };
+ const char * getMD5(){ return "acffd30cd6b6de30f120938c17c593fb"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosgraph_msgs/TopicStatistics.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,347 @@
+#ifndef _ROS_rosgraph_msgs_TopicStatistics_h
+#define _ROS_rosgraph_msgs_TopicStatistics_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+#include "ros/duration.h"
+
+namespace rosgraph_msgs
+{
+
+ class TopicStatistics : public ros::Msg
+ {
+ public:
+ typedef const char* _topic_type;
+ _topic_type topic;
+ typedef const char* _node_pub_type;
+ _node_pub_type node_pub;
+ typedef const char* _node_sub_type;
+ _node_sub_type node_sub;
+ typedef ros::Time _window_start_type;
+ _window_start_type window_start;
+ typedef ros::Time _window_stop_type;
+ _window_stop_type window_stop;
+ typedef int32_t _delivered_msgs_type;
+ _delivered_msgs_type delivered_msgs;
+ typedef int32_t _dropped_msgs_type;
+ _dropped_msgs_type dropped_msgs;
+ typedef int32_t _traffic_type;
+ _traffic_type traffic;
+ typedef ros::Duration _period_mean_type;
+ _period_mean_type period_mean;
+ typedef ros::Duration _period_stddev_type;
+ _period_stddev_type period_stddev;
+ typedef ros::Duration _period_max_type;
+ _period_max_type period_max;
+ typedef ros::Duration _stamp_age_mean_type;
+ _stamp_age_mean_type stamp_age_mean;
+ typedef ros::Duration _stamp_age_stddev_type;
+ _stamp_age_stddev_type stamp_age_stddev;
+ typedef ros::Duration _stamp_age_max_type;
+ _stamp_age_max_type stamp_age_max;
+
+ TopicStatistics():
+ topic(""),
+ node_pub(""),
+ node_sub(""),
+ window_start(),
+ window_stop(),
+ delivered_msgs(0),
+ dropped_msgs(0),
+ traffic(0),
+ period_mean(),
+ period_stddev(),
+ period_max(),
+ stamp_age_mean(),
+ stamp_age_stddev(),
+ stamp_age_max()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_topic = strlen(this->topic);
+ varToArr(outbuffer + offset, length_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic, length_topic);
+ offset += length_topic;
+ uint32_t length_node_pub = strlen(this->node_pub);
+ varToArr(outbuffer + offset, length_node_pub);
+ offset += 4;
+ memcpy(outbuffer + offset, this->node_pub, length_node_pub);
+ offset += length_node_pub;
+ uint32_t length_node_sub = strlen(this->node_sub);
+ varToArr(outbuffer + offset, length_node_sub);
+ offset += 4;
+ memcpy(outbuffer + offset, this->node_sub, length_node_sub);
+ offset += length_node_sub;
+ *(outbuffer + offset + 0) = (this->window_start.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->window_start.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->window_start.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->window_start.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->window_start.sec);
+ *(outbuffer + offset + 0) = (this->window_start.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->window_start.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->window_start.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->window_start.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->window_start.nsec);
+ *(outbuffer + offset + 0) = (this->window_stop.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->window_stop.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->window_stop.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->window_stop.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->window_stop.sec);
+ *(outbuffer + offset + 0) = (this->window_stop.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->window_stop.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->window_stop.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->window_stop.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->window_stop.nsec);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_delivered_msgs;
+ u_delivered_msgs.real = this->delivered_msgs;
+ *(outbuffer + offset + 0) = (u_delivered_msgs.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_delivered_msgs.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_delivered_msgs.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_delivered_msgs.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->delivered_msgs);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_dropped_msgs;
+ u_dropped_msgs.real = this->dropped_msgs;
+ *(outbuffer + offset + 0) = (u_dropped_msgs.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_dropped_msgs.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_dropped_msgs.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_dropped_msgs.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->dropped_msgs);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_traffic;
+ u_traffic.real = this->traffic;
+ *(outbuffer + offset + 0) = (u_traffic.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_traffic.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_traffic.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_traffic.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->traffic);
+ *(outbuffer + offset + 0) = (this->period_mean.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->period_mean.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->period_mean.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->period_mean.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->period_mean.sec);
+ *(outbuffer + offset + 0) = (this->period_mean.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->period_mean.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->period_mean.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->period_mean.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->period_mean.nsec);
+ *(outbuffer + offset + 0) = (this->period_stddev.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->period_stddev.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->period_stddev.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->period_stddev.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->period_stddev.sec);
+ *(outbuffer + offset + 0) = (this->period_stddev.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->period_stddev.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->period_stddev.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->period_stddev.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->period_stddev.nsec);
+ *(outbuffer + offset + 0) = (this->period_max.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->period_max.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->period_max.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->period_max.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->period_max.sec);
+ *(outbuffer + offset + 0) = (this->period_max.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->period_max.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->period_max.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->period_max.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->period_max.nsec);
+ *(outbuffer + offset + 0) = (this->stamp_age_mean.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp_age_mean.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp_age_mean.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp_age_mean.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp_age_mean.sec);
+ *(outbuffer + offset + 0) = (this->stamp_age_mean.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp_age_mean.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp_age_mean.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp_age_mean.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp_age_mean.nsec);
+ *(outbuffer + offset + 0) = (this->stamp_age_stddev.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp_age_stddev.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp_age_stddev.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp_age_stddev.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp_age_stddev.sec);
+ *(outbuffer + offset + 0) = (this->stamp_age_stddev.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp_age_stddev.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp_age_stddev.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp_age_stddev.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp_age_stddev.nsec);
+ *(outbuffer + offset + 0) = (this->stamp_age_max.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp_age_max.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp_age_max.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp_age_max.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp_age_max.sec);
+ *(outbuffer + offset + 0) = (this->stamp_age_max.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp_age_max.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp_age_max.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp_age_max.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp_age_max.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_topic;
+ arrToVar(length_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic-1]=0;
+ this->topic = (char *)(inbuffer + offset-1);
+ offset += length_topic;
+ uint32_t length_node_pub;
+ arrToVar(length_node_pub, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_node_pub; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_node_pub-1]=0;
+ this->node_pub = (char *)(inbuffer + offset-1);
+ offset += length_node_pub;
+ uint32_t length_node_sub;
+ arrToVar(length_node_sub, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_node_sub; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_node_sub-1]=0;
+ this->node_sub = (char *)(inbuffer + offset-1);
+ offset += length_node_sub;
+ this->window_start.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->window_start.sec);
+ this->window_start.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->window_start.nsec);
+ this->window_stop.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->window_stop.sec);
+ this->window_stop.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->window_stop.nsec);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_delivered_msgs;
+ u_delivered_msgs.base = 0;
+ u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->delivered_msgs = u_delivered_msgs.real;
+ offset += sizeof(this->delivered_msgs);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_dropped_msgs;
+ u_dropped_msgs.base = 0;
+ u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->dropped_msgs = u_dropped_msgs.real;
+ offset += sizeof(this->dropped_msgs);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_traffic;
+ u_traffic.base = 0;
+ u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->traffic = u_traffic.real;
+ offset += sizeof(this->traffic);
+ this->period_mean.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->period_mean.sec);
+ this->period_mean.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->period_mean.nsec);
+ this->period_stddev.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->period_stddev.sec);
+ this->period_stddev.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->period_stddev.nsec);
+ this->period_max.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->period_max.sec);
+ this->period_max.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->period_max.nsec);
+ this->stamp_age_mean.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp_age_mean.sec);
+ this->stamp_age_mean.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp_age_mean.nsec);
+ this->stamp_age_stddev.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp_age_stddev.sec);
+ this->stamp_age_stddev.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp_age_stddev.nsec);
+ this->stamp_age_max.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp_age_max.sec);
+ this->stamp_age_max.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp_age_max.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "rosgraph_msgs/TopicStatistics"; };
+ const char * getMD5(){ return "10152ed868c5097a5e2e4a89d7daa710"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rospy_tutorials/AddTwoInts.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,166 @@
+#ifndef _ROS_SERVICE_AddTwoInts_h
+#define _ROS_SERVICE_AddTwoInts_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rospy_tutorials
+{
+
+static const char ADDTWOINTS[] = "rospy_tutorials/AddTwoInts";
+
+ class AddTwoIntsRequest : public ros::Msg
+ {
+ public:
+ typedef int64_t _a_type;
+ _a_type a;
+ typedef int64_t _b_type;
+ _b_type b;
+
+ AddTwoIntsRequest():
+ a(0),
+ b(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.real = this->a;
+ *(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->a);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_b;
+ u_b.real = this->b;
+ *(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_b.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_b.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_b.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_b.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.base = 0;
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->a = u_a.real;
+ offset += sizeof(this->a);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_b;
+ u_b.base = 0;
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_b.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->b = u_b.real;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ const char * getType(){ return ADDTWOINTS; };
+ const char * getMD5(){ return "36d09b846be0b371c5f190354dd3153e"; };
+
+ };
+
+ class AddTwoIntsResponse : public ros::Msg
+ {
+ public:
+ typedef int64_t _sum_type;
+ _sum_type sum;
+
+ AddTwoIntsResponse():
+ sum(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_sum;
+ u_sum.real = this->sum;
+ *(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_sum.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_sum.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_sum.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_sum.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_sum;
+ u_sum.base = 0;
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_sum.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->sum = u_sum.real;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ const char * getType(){ return ADDTWOINTS; };
+ const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
+
+ };
+
+ class AddTwoInts {
+ public:
+ typedef AddTwoIntsRequest Request;
+ typedef AddTwoIntsResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rospy_tutorials/BadTwoInts.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,150 @@
+#ifndef _ROS_SERVICE_BadTwoInts_h
+#define _ROS_SERVICE_BadTwoInts_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rospy_tutorials
+{
+
+static const char BADTWOINTS[] = "rospy_tutorials/BadTwoInts";
+
+ class BadTwoIntsRequest : public ros::Msg
+ {
+ public:
+ typedef int64_t _a_type;
+ _a_type a;
+ typedef int32_t _b_type;
+ _b_type b;
+
+ BadTwoIntsRequest():
+ a(0),
+ b(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.real = this->a;
+ *(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->a);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_b;
+ u_b.real = this->b;
+ *(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_a;
+ u_a.base = 0;
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->a = u_a.real;
+ offset += sizeof(this->a);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_b;
+ u_b.base = 0;
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->b = u_b.real;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ const char * getType(){ return BADTWOINTS; };
+ const char * getMD5(){ return "29bb5c7dea8bf822f53e94b0ee5a3a56"; };
+
+ };
+
+ class BadTwoIntsResponse : public ros::Msg
+ {
+ public:
+ typedef int32_t _sum_type;
+ _sum_type sum;
+
+ BadTwoIntsResponse():
+ sum(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_sum;
+ u_sum.real = this->sum;
+ *(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_sum;
+ u_sum.base = 0;
+ u_sum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_sum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_sum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_sum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->sum = u_sum.real;
+ offset += sizeof(this->sum);
+ return offset;
+ }
+
+ const char * getType(){ return BADTWOINTS; };
+ const char * getMD5(){ return "0ba699c25c9418c0366f3595c0c8e8ec"; };
+
+ };
+
+ class BadTwoInts {
+ public:
+ typedef BadTwoIntsRequest Request;
+ typedef BadTwoIntsResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rospy_tutorials/Floats.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_rospy_tutorials_Floats_h
+#define _ROS_rospy_tutorials_Floats_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rospy_tutorials
+{
+
+ class Floats : public ros::Msg
+ {
+ public:
+ uint32_t data_length;
+ typedef float _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Floats():
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (float*)realloc(this->data, data_lengthT * sizeof(float));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(float));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "rospy_tutorials/Floats"; };
+ const char * getMD5(){ return "420cd38b6b071cd49f2970c3e2cee511"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rospy_tutorials/HeaderString.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,61 @@
+#ifndef _ROS_rospy_tutorials_HeaderString_h
+#define _ROS_rospy_tutorials_HeaderString_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace rospy_tutorials
+{
+
+ class HeaderString : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _data_type;
+ _data_type data;
+
+ HeaderString():
+ header(),
+ data("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_data = strlen(this->data);
+ varToArr(outbuffer + offset, length_data);
+ offset += 4;
+ memcpy(outbuffer + offset, this->data, length_data);
+ offset += length_data;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_data;
+ arrToVar(length_data, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_data; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_data-1]=0;
+ this->data = (char *)(inbuffer + offset-1);
+ offset += length_data;
+ return offset;
+ }
+
+ const char * getType(){ return "rospy_tutorials/HeaderString"; };
+ const char * getMD5(){ return "c99a9440709e4d4a9716d55b8270d5e7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosserial_mbed/Adc.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,92 @@
+#ifndef _ROS_rosserial_mbed_Adc_h
+#define _ROS_rosserial_mbed_Adc_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rosserial_mbed
+{
+
+ class Adc : public ros::Msg
+ {
+ public:
+ typedef uint16_t _adc0_type;
+ _adc0_type adc0;
+ typedef uint16_t _adc1_type;
+ _adc1_type adc1;
+ typedef uint16_t _adc2_type;
+ _adc2_type adc2;
+ typedef uint16_t _adc3_type;
+ _adc3_type adc3;
+ typedef uint16_t _adc4_type;
+ _adc4_type adc4;
+ typedef uint16_t _adc5_type;
+ _adc5_type adc5;
+
+ Adc():
+ adc0(0),
+ adc1(0),
+ adc2(0),
+ adc3(0),
+ adc4(0),
+ adc5(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->adc0 >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->adc0 >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->adc0);
+ *(outbuffer + offset + 0) = (this->adc1 >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->adc1 >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->adc1);
+ *(outbuffer + offset + 0) = (this->adc2 >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->adc2 >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->adc2);
+ *(outbuffer + offset + 0) = (this->adc3 >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->adc3 >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->adc3);
+ *(outbuffer + offset + 0) = (this->adc4 >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->adc4 >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->adc4);
+ *(outbuffer + offset + 0) = (this->adc5 >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->adc5 >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->adc5);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->adc0 = ((uint16_t) (*(inbuffer + offset)));
+ this->adc0 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->adc0);
+ this->adc1 = ((uint16_t) (*(inbuffer + offset)));
+ this->adc1 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->adc1);
+ this->adc2 = ((uint16_t) (*(inbuffer + offset)));
+ this->adc2 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->adc2);
+ this->adc3 = ((uint16_t) (*(inbuffer + offset)));
+ this->adc3 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->adc3);
+ this->adc4 = ((uint16_t) (*(inbuffer + offset)));
+ this->adc4 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->adc4);
+ this->adc5 = ((uint16_t) (*(inbuffer + offset)));
+ this->adc5 |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->adc5);
+ return offset;
+ }
+
+ const char * getType(){ return "rosserial_mbed/Adc"; };
+ const char * getMD5(){ return "6d7853a614e2e821319068311f2af25b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosserial_mbed/Test.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,104 @@
+#ifndef _ROS_SERVICE_Test_h
+#define _ROS_SERVICE_Test_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rosserial_mbed
+{
+
+static const char TEST[] = "rosserial_mbed/Test";
+
+ class TestRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _input_type;
+ _input_type input;
+
+ TestRequest():
+ input("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_input = strlen(this->input);
+ varToArr(outbuffer + offset, length_input);
+ offset += 4;
+ memcpy(outbuffer + offset, this->input, length_input);
+ offset += length_input;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_input;
+ arrToVar(length_input, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_input; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_input-1]=0;
+ this->input = (char *)(inbuffer + offset-1);
+ offset += length_input;
+ return offset;
+ }
+
+ const char * getType(){ return TEST; };
+ const char * getMD5(){ return "39e92f1778057359c64c7b8a7d7b19de"; };
+
+ };
+
+ class TestResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _output_type;
+ _output_type output;
+
+ TestResponse():
+ output("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_output = strlen(this->output);
+ varToArr(outbuffer + offset, length_output);
+ offset += 4;
+ memcpy(outbuffer + offset, this->output, length_output);
+ offset += length_output;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_output;
+ arrToVar(length_output, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_output; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_output-1]=0;
+ this->output = (char *)(inbuffer + offset-1);
+ offset += length_output;
+ return offset;
+ }
+
+ const char * getType(){ return TEST; };
+ const char * getMD5(){ return "0825d95fdfa2c8f4bbb4e9c74bccd3fd"; };
+
+ };
+
+ class Test {
+ public:
+ typedef TestRequest Request;
+ typedef TestResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosserial_msgs/Log.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,67 @@
+#ifndef _ROS_rosserial_msgs_Log_h
+#define _ROS_rosserial_msgs_Log_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rosserial_msgs
+{
+
+ class Log : public ros::Msg
+ {
+ public:
+ typedef uint8_t _level_type;
+ _level_type level;
+ typedef const char* _msg_type;
+ _msg_type msg;
+ enum { ROSDEBUG = 0 };
+ enum { INFO = 1 };
+ enum { WARN = 2 };
+ enum { ERROR = 3 };
+ enum { FATAL = 4 };
+
+ Log():
+ level(0),
+ msg("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->level >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->level);
+ uint32_t length_msg = strlen(this->msg);
+ varToArr(outbuffer + offset, length_msg);
+ offset += 4;
+ memcpy(outbuffer + offset, this->msg, length_msg);
+ offset += length_msg;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->level = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->level);
+ uint32_t length_msg;
+ arrToVar(length_msg, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_msg; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_msg-1]=0;
+ this->msg = (char *)(inbuffer + offset-1);
+ offset += length_msg;
+ return offset;
+ }
+
+ const char * getType(){ return "rosserial_msgs/Log"; };
+ const char * getMD5(){ return "11abd731c25933261cd6183bd12d6295"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosserial_msgs/RequestMessageInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,121 @@
+#ifndef _ROS_SERVICE_RequestMessageInfo_h
+#define _ROS_SERVICE_RequestMessageInfo_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rosserial_msgs
+{
+
+static const char REQUESTMESSAGEINFO[] = "rosserial_msgs/RequestMessageInfo";
+
+ class RequestMessageInfoRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _type_type;
+ _type_type type;
+
+ RequestMessageInfoRequest():
+ type("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_type = strlen(this->type);
+ varToArr(outbuffer + offset, length_type);
+ offset += 4;
+ memcpy(outbuffer + offset, this->type, length_type);
+ offset += length_type;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_type;
+ arrToVar(length_type, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_type; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_type-1]=0;
+ this->type = (char *)(inbuffer + offset-1);
+ offset += length_type;
+ return offset;
+ }
+
+ const char * getType(){ return REQUESTMESSAGEINFO; };
+ const char * getMD5(){ return "dc67331de85cf97091b7d45e5c64ab75"; };
+
+ };
+
+ class RequestMessageInfoResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _md5_type;
+ _md5_type md5;
+ typedef const char* _definition_type;
+ _definition_type definition;
+
+ RequestMessageInfoResponse():
+ md5(""),
+ definition("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_md5 = strlen(this->md5);
+ varToArr(outbuffer + offset, length_md5);
+ offset += 4;
+ memcpy(outbuffer + offset, this->md5, length_md5);
+ offset += length_md5;
+ uint32_t length_definition = strlen(this->definition);
+ varToArr(outbuffer + offset, length_definition);
+ offset += 4;
+ memcpy(outbuffer + offset, this->definition, length_definition);
+ offset += length_definition;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_md5;
+ arrToVar(length_md5, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_md5; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_md5-1]=0;
+ this->md5 = (char *)(inbuffer + offset-1);
+ offset += length_md5;
+ uint32_t length_definition;
+ arrToVar(length_definition, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_definition; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_definition-1]=0;
+ this->definition = (char *)(inbuffer + offset-1);
+ offset += length_definition;
+ return offset;
+ }
+
+ const char * getType(){ return REQUESTMESSAGEINFO; };
+ const char * getMD5(){ return "fe452186a069bed40f09b8628fe5eac8"; };
+
+ };
+
+ class RequestMessageInfo {
+ public:
+ typedef RequestMessageInfoRequest Request;
+ typedef RequestMessageInfoResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosserial_msgs/RequestParam.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,212 @@
+#ifndef _ROS_SERVICE_RequestParam_h
+#define _ROS_SERVICE_RequestParam_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rosserial_msgs
+{
+
+static const char REQUESTPARAM[] = "rosserial_msgs/RequestParam";
+
+ class RequestParamRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+
+ RequestParamRequest():
+ name("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ return offset;
+ }
+
+ const char * getType(){ return REQUESTPARAM; };
+ const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
+
+ };
+
+ class RequestParamResponse : public ros::Msg
+ {
+ public:
+ uint32_t ints_length;
+ typedef int32_t _ints_type;
+ _ints_type st_ints;
+ _ints_type * ints;
+ uint32_t floats_length;
+ typedef float _floats_type;
+ _floats_type st_floats;
+ _floats_type * floats;
+ uint32_t strings_length;
+ typedef char* _strings_type;
+ _strings_type st_strings;
+ _strings_type * strings;
+
+ RequestParamResponse():
+ ints_length(0), ints(NULL),
+ floats_length(0), floats(NULL),
+ strings_length(0), strings(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->ints_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->ints_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->ints_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->ints_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ints_length);
+ for( uint32_t i = 0; i < ints_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_intsi;
+ u_intsi.real = this->ints[i];
+ *(outbuffer + offset + 0) = (u_intsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_intsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_intsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_intsi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ints[i]);
+ }
+ *(outbuffer + offset + 0) = (this->floats_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->floats_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->floats_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->floats_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->floats_length);
+ for( uint32_t i = 0; i < floats_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_floatsi;
+ u_floatsi.real = this->floats[i];
+ *(outbuffer + offset + 0) = (u_floatsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_floatsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_floatsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_floatsi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->floats[i]);
+ }
+ *(outbuffer + offset + 0) = (this->strings_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->strings_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->strings_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->strings_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->strings_length);
+ for( uint32_t i = 0; i < strings_length; i++){
+ uint32_t length_stringsi = strlen(this->strings[i]);
+ varToArr(outbuffer + offset, length_stringsi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->strings[i], length_stringsi);
+ offset += length_stringsi;
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t ints_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->ints_length);
+ if(ints_lengthT > ints_length)
+ this->ints = (int32_t*)realloc(this->ints, ints_lengthT * sizeof(int32_t));
+ ints_length = ints_lengthT;
+ for( uint32_t i = 0; i < ints_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_st_ints;
+ u_st_ints.base = 0;
+ u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_ints = u_st_ints.real;
+ offset += sizeof(this->st_ints);
+ memcpy( &(this->ints[i]), &(this->st_ints), sizeof(int32_t));
+ }
+ uint32_t floats_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->floats_length);
+ if(floats_lengthT > floats_length)
+ this->floats = (float*)realloc(this->floats, floats_lengthT * sizeof(float));
+ floats_length = floats_lengthT;
+ for( uint32_t i = 0; i < floats_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_floats;
+ u_st_floats.base = 0;
+ u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_floats = u_st_floats.real;
+ offset += sizeof(this->st_floats);
+ memcpy( &(this->floats[i]), &(this->st_floats), sizeof(float));
+ }
+ uint32_t strings_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->strings_length);
+ if(strings_lengthT > strings_length)
+ this->strings = (char**)realloc(this->strings, strings_lengthT * sizeof(char*));
+ strings_length = strings_lengthT;
+ for( uint32_t i = 0; i < strings_length; i++){
+ uint32_t length_st_strings;
+ arrToVar(length_st_strings, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_strings; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_strings-1]=0;
+ this->st_strings = (char *)(inbuffer + offset-1);
+ offset += length_st_strings;
+ memcpy( &(this->strings[i]), &(this->st_strings), sizeof(char*));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return REQUESTPARAM; };
+ const char * getMD5(){ return "9f0e98bda65981986ddf53afa7a40e49"; };
+
+ };
+
+ class RequestParam {
+ public:
+ typedef RequestParamRequest Request;
+ typedef RequestParamResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosserial_msgs/RequestServiceInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,138 @@
+#ifndef _ROS_SERVICE_RequestServiceInfo_h
+#define _ROS_SERVICE_RequestServiceInfo_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rosserial_msgs
+{
+
+static const char REQUESTSERVICEINFO[] = "rosserial_msgs/RequestServiceInfo";
+
+ class RequestServiceInfoRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _service_type;
+ _service_type service;
+
+ RequestServiceInfoRequest():
+ service("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_service = strlen(this->service);
+ varToArr(outbuffer + offset, length_service);
+ offset += 4;
+ memcpy(outbuffer + offset, this->service, length_service);
+ offset += length_service;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_service;
+ arrToVar(length_service, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_service; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_service-1]=0;
+ this->service = (char *)(inbuffer + offset-1);
+ offset += length_service;
+ return offset;
+ }
+
+ const char * getType(){ return REQUESTSERVICEINFO; };
+ const char * getMD5(){ return "1cbcfa13b08f6d36710b9af8741e6112"; };
+
+ };
+
+ class RequestServiceInfoResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _service_md5_type;
+ _service_md5_type service_md5;
+ typedef const char* _request_md5_type;
+ _request_md5_type request_md5;
+ typedef const char* _response_md5_type;
+ _response_md5_type response_md5;
+
+ RequestServiceInfoResponse():
+ service_md5(""),
+ request_md5(""),
+ response_md5("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_service_md5 = strlen(this->service_md5);
+ varToArr(outbuffer + offset, length_service_md5);
+ offset += 4;
+ memcpy(outbuffer + offset, this->service_md5, length_service_md5);
+ offset += length_service_md5;
+ uint32_t length_request_md5 = strlen(this->request_md5);
+ varToArr(outbuffer + offset, length_request_md5);
+ offset += 4;
+ memcpy(outbuffer + offset, this->request_md5, length_request_md5);
+ offset += length_request_md5;
+ uint32_t length_response_md5 = strlen(this->response_md5);
+ varToArr(outbuffer + offset, length_response_md5);
+ offset += 4;
+ memcpy(outbuffer + offset, this->response_md5, length_response_md5);
+ offset += length_response_md5;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_service_md5;
+ arrToVar(length_service_md5, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_service_md5; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_service_md5-1]=0;
+ this->service_md5 = (char *)(inbuffer + offset-1);
+ offset += length_service_md5;
+ uint32_t length_request_md5;
+ arrToVar(length_request_md5, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_request_md5; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_request_md5-1]=0;
+ this->request_md5 = (char *)(inbuffer + offset-1);
+ offset += length_request_md5;
+ uint32_t length_response_md5;
+ arrToVar(length_response_md5, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_response_md5; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_response_md5-1]=0;
+ this->response_md5 = (char *)(inbuffer + offset-1);
+ offset += length_response_md5;
+ return offset;
+ }
+
+ const char * getType(){ return REQUESTSERVICEINFO; };
+ const char * getMD5(){ return "c3d6dd25b909596479fbbc6559fa6874"; };
+
+ };
+
+ class RequestServiceInfo {
+ public:
+ typedef RequestServiceInfoRequest Request;
+ typedef RequestServiceInfoResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/rosserial_msgs/TopicInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,130 @@
+#ifndef _ROS_rosserial_msgs_TopicInfo_h
+#define _ROS_rosserial_msgs_TopicInfo_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace rosserial_msgs
+{
+
+ class TopicInfo : public ros::Msg
+ {
+ public:
+ typedef uint16_t _topic_id_type;
+ _topic_id_type topic_id;
+ typedef const char* _topic_name_type;
+ _topic_name_type topic_name;
+ typedef const char* _message_type_type;
+ _message_type_type message_type;
+ typedef const char* _md5sum_type;
+ _md5sum_type md5sum;
+ typedef int32_t _buffer_size_type;
+ _buffer_size_type buffer_size;
+ enum { ID_PUBLISHER = 0 };
+ enum { ID_SUBSCRIBER = 1 };
+ enum { ID_SERVICE_SERVER = 2 };
+ enum { ID_SERVICE_CLIENT = 4 };
+ enum { ID_PARAMETER_REQUEST = 6 };
+ enum { ID_LOG = 7 };
+ enum { ID_TIME = 10 };
+ enum { ID_TX_STOP = 11 };
+
+ TopicInfo():
+ topic_id(0),
+ topic_name(""),
+ message_type(""),
+ md5sum(""),
+ buffer_size(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->topic_id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->topic_id >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->topic_id);
+ uint32_t length_topic_name = strlen(this->topic_name);
+ varToArr(outbuffer + offset, length_topic_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic_name, length_topic_name);
+ offset += length_topic_name;
+ uint32_t length_message_type = strlen(this->message_type);
+ varToArr(outbuffer + offset, length_message_type);
+ offset += 4;
+ memcpy(outbuffer + offset, this->message_type, length_message_type);
+ offset += length_message_type;
+ uint32_t length_md5sum = strlen(this->md5sum);
+ varToArr(outbuffer + offset, length_md5sum);
+ offset += 4;
+ memcpy(outbuffer + offset, this->md5sum, length_md5sum);
+ offset += length_md5sum;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_buffer_size;
+ u_buffer_size.real = this->buffer_size;
+ *(outbuffer + offset + 0) = (u_buffer_size.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_buffer_size.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_buffer_size.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_buffer_size.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->buffer_size);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->topic_id = ((uint16_t) (*(inbuffer + offset)));
+ this->topic_id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->topic_id);
+ uint32_t length_topic_name;
+ arrToVar(length_topic_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic_name-1]=0;
+ this->topic_name = (char *)(inbuffer + offset-1);
+ offset += length_topic_name;
+ uint32_t length_message_type;
+ arrToVar(length_message_type, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_message_type; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_message_type-1]=0;
+ this->message_type = (char *)(inbuffer + offset-1);
+ offset += length_message_type;
+ uint32_t length_md5sum;
+ arrToVar(length_md5sum, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_md5sum; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_md5sum-1]=0;
+ this->md5sum = (char *)(inbuffer + offset-1);
+ offset += length_md5sum;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_buffer_size;
+ u_buffer_size.base = 0;
+ u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->buffer_size = u_buffer_size.real;
+ offset += sizeof(this->buffer_size);
+ return offset;
+ }
+
+ const char * getType(){ return "rosserial_msgs/TopicInfo"; };
+ const char * getMD5(){ return "0ad51f88fc44892f8c10684077646005"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/BatteryState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,326 @@
+#ifndef _ROS_sensor_msgs_BatteryState_h
+#define _ROS_sensor_msgs_BatteryState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class BatteryState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _voltage_type;
+ _voltage_type voltage;
+ typedef float _current_type;
+ _current_type current;
+ typedef float _charge_type;
+ _charge_type charge;
+ typedef float _capacity_type;
+ _capacity_type capacity;
+ typedef float _design_capacity_type;
+ _design_capacity_type design_capacity;
+ typedef float _percentage_type;
+ _percentage_type percentage;
+ typedef uint8_t _power_supply_status_type;
+ _power_supply_status_type power_supply_status;
+ typedef uint8_t _power_supply_health_type;
+ _power_supply_health_type power_supply_health;
+ typedef uint8_t _power_supply_technology_type;
+ _power_supply_technology_type power_supply_technology;
+ typedef bool _present_type;
+ _present_type present;
+ uint32_t cell_voltage_length;
+ typedef float _cell_voltage_type;
+ _cell_voltage_type st_cell_voltage;
+ _cell_voltage_type * cell_voltage;
+ typedef const char* _location_type;
+ _location_type location;
+ typedef const char* _serial_number_type;
+ _serial_number_type serial_number;
+ enum { POWER_SUPPLY_STATUS_UNKNOWN = 0 };
+ enum { POWER_SUPPLY_STATUS_CHARGING = 1 };
+ enum { POWER_SUPPLY_STATUS_DISCHARGING = 2 };
+ enum { POWER_SUPPLY_STATUS_NOT_CHARGING = 3 };
+ enum { POWER_SUPPLY_STATUS_FULL = 4 };
+ enum { POWER_SUPPLY_HEALTH_UNKNOWN = 0 };
+ enum { POWER_SUPPLY_HEALTH_GOOD = 1 };
+ enum { POWER_SUPPLY_HEALTH_OVERHEAT = 2 };
+ enum { POWER_SUPPLY_HEALTH_DEAD = 3 };
+ enum { POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4 };
+ enum { POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5 };
+ enum { POWER_SUPPLY_HEALTH_COLD = 6 };
+ enum { POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7 };
+ enum { POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8 };
+ enum { POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0 };
+ enum { POWER_SUPPLY_TECHNOLOGY_NIMH = 1 };
+ enum { POWER_SUPPLY_TECHNOLOGY_LION = 2 };
+ enum { POWER_SUPPLY_TECHNOLOGY_LIPO = 3 };
+ enum { POWER_SUPPLY_TECHNOLOGY_LIFE = 4 };
+ enum { POWER_SUPPLY_TECHNOLOGY_NICD = 5 };
+ enum { POWER_SUPPLY_TECHNOLOGY_LIMN = 6 };
+
+ BatteryState():
+ header(),
+ voltage(0),
+ current(0),
+ charge(0),
+ capacity(0),
+ design_capacity(0),
+ percentage(0),
+ power_supply_status(0),
+ power_supply_health(0),
+ power_supply_technology(0),
+ present(0),
+ cell_voltage_length(0), cell_voltage(NULL),
+ location(""),
+ serial_number("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_voltage;
+ u_voltage.real = this->voltage;
+ *(outbuffer + offset + 0) = (u_voltage.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_voltage.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_voltage.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_voltage.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->voltage);
+ union {
+ float real;
+ uint32_t base;
+ } u_current;
+ u_current.real = this->current;
+ *(outbuffer + offset + 0) = (u_current.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_current.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_current.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_current.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->current);
+ union {
+ float real;
+ uint32_t base;
+ } u_charge;
+ u_charge.real = this->charge;
+ *(outbuffer + offset + 0) = (u_charge.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_charge.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_charge.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_charge.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->charge);
+ union {
+ float real;
+ uint32_t base;
+ } u_capacity;
+ u_capacity.real = this->capacity;
+ *(outbuffer + offset + 0) = (u_capacity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_capacity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_capacity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_capacity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->capacity);
+ union {
+ float real;
+ uint32_t base;
+ } u_design_capacity;
+ u_design_capacity.real = this->design_capacity;
+ *(outbuffer + offset + 0) = (u_design_capacity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_design_capacity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_design_capacity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_design_capacity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->design_capacity);
+ union {
+ float real;
+ uint32_t base;
+ } u_percentage;
+ u_percentage.real = this->percentage;
+ *(outbuffer + offset + 0) = (u_percentage.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_percentage.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_percentage.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_percentage.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->percentage);
+ *(outbuffer + offset + 0) = (this->power_supply_status >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->power_supply_status);
+ *(outbuffer + offset + 0) = (this->power_supply_health >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->power_supply_health);
+ *(outbuffer + offset + 0) = (this->power_supply_technology >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->power_supply_technology);
+ union {
+ bool real;
+ uint8_t base;
+ } u_present;
+ u_present.real = this->present;
+ *(outbuffer + offset + 0) = (u_present.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->present);
+ *(outbuffer + offset + 0) = (this->cell_voltage_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->cell_voltage_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->cell_voltage_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->cell_voltage_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->cell_voltage_length);
+ for( uint32_t i = 0; i < cell_voltage_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_cell_voltagei;
+ u_cell_voltagei.real = this->cell_voltage[i];
+ *(outbuffer + offset + 0) = (u_cell_voltagei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_cell_voltagei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_cell_voltagei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_cell_voltagei.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->cell_voltage[i]);
+ }
+ uint32_t length_location = strlen(this->location);
+ varToArr(outbuffer + offset, length_location);
+ offset += 4;
+ memcpy(outbuffer + offset, this->location, length_location);
+ offset += length_location;
+ uint32_t length_serial_number = strlen(this->serial_number);
+ varToArr(outbuffer + offset, length_serial_number);
+ offset += 4;
+ memcpy(outbuffer + offset, this->serial_number, length_serial_number);
+ offset += length_serial_number;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_voltage;
+ u_voltage.base = 0;
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->voltage = u_voltage.real;
+ offset += sizeof(this->voltage);
+ union {
+ float real;
+ uint32_t base;
+ } u_current;
+ u_current.base = 0;
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_current.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->current = u_current.real;
+ offset += sizeof(this->current);
+ union {
+ float real;
+ uint32_t base;
+ } u_charge;
+ u_charge.base = 0;
+ u_charge.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_charge.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_charge.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_charge.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->charge = u_charge.real;
+ offset += sizeof(this->charge);
+ union {
+ float real;
+ uint32_t base;
+ } u_capacity;
+ u_capacity.base = 0;
+ u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_capacity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->capacity = u_capacity.real;
+ offset += sizeof(this->capacity);
+ union {
+ float real;
+ uint32_t base;
+ } u_design_capacity;
+ u_design_capacity.base = 0;
+ u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_design_capacity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->design_capacity = u_design_capacity.real;
+ offset += sizeof(this->design_capacity);
+ union {
+ float real;
+ uint32_t base;
+ } u_percentage;
+ u_percentage.base = 0;
+ u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_percentage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->percentage = u_percentage.real;
+ offset += sizeof(this->percentage);
+ this->power_supply_status = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->power_supply_status);
+ this->power_supply_health = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->power_supply_health);
+ this->power_supply_technology = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->power_supply_technology);
+ union {
+ bool real;
+ uint8_t base;
+ } u_present;
+ u_present.base = 0;
+ u_present.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->present = u_present.real;
+ offset += sizeof(this->present);
+ uint32_t cell_voltage_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ cell_voltage_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->cell_voltage_length);
+ if(cell_voltage_lengthT > cell_voltage_length)
+ this->cell_voltage = (float*)realloc(this->cell_voltage, cell_voltage_lengthT * sizeof(float));
+ cell_voltage_length = cell_voltage_lengthT;
+ for( uint32_t i = 0; i < cell_voltage_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_cell_voltage;
+ u_st_cell_voltage.base = 0;
+ u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_cell_voltage.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_cell_voltage = u_st_cell_voltage.real;
+ offset += sizeof(this->st_cell_voltage);
+ memcpy( &(this->cell_voltage[i]), &(this->st_cell_voltage), sizeof(float));
+ }
+ uint32_t length_location;
+ arrToVar(length_location, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_location; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_location-1]=0;
+ this->location = (char *)(inbuffer + offset-1);
+ offset += length_location;
+ uint32_t length_serial_number;
+ arrToVar(length_serial_number, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_serial_number; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_serial_number-1]=0;
+ this->serial_number = (char *)(inbuffer + offset-1);
+ offset += length_serial_number;
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/BatteryState"; };
+ const char * getMD5(){ return "476f837fa6771f6e16e3bf4ef96f8770"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/CameraInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,276 @@
+#ifndef _ROS_sensor_msgs_CameraInfo_h
+#define _ROS_sensor_msgs_CameraInfo_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "sensor_msgs/RegionOfInterest.h"
+
+namespace sensor_msgs
+{
+
+ class CameraInfo : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint32_t _height_type;
+ _height_type height;
+ typedef uint32_t _width_type;
+ _width_type width;
+ typedef const char* _distortion_model_type;
+ _distortion_model_type distortion_model;
+ uint32_t D_length;
+ typedef double _D_type;
+ _D_type st_D;
+ _D_type * D;
+ double K[9];
+ double R[9];
+ double P[12];
+ typedef uint32_t _binning_x_type;
+ _binning_x_type binning_x;
+ typedef uint32_t _binning_y_type;
+ _binning_y_type binning_y;
+ typedef sensor_msgs::RegionOfInterest _roi_type;
+ _roi_type roi;
+
+ CameraInfo():
+ header(),
+ height(0),
+ width(0),
+ distortion_model(""),
+ D_length(0), D(NULL),
+ K(),
+ R(),
+ P(),
+ binning_x(0),
+ binning_y(0),
+ roi()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->height);
+ *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->width);
+ uint32_t length_distortion_model = strlen(this->distortion_model);
+ varToArr(outbuffer + offset, length_distortion_model);
+ offset += 4;
+ memcpy(outbuffer + offset, this->distortion_model, length_distortion_model);
+ offset += length_distortion_model;
+ *(outbuffer + offset + 0) = (this->D_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->D_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->D_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->D_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->D_length);
+ for( uint32_t i = 0; i < D_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_Di;
+ u_Di.real = this->D[i];
+ *(outbuffer + offset + 0) = (u_Di.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_Di.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_Di.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_Di.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_Di.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_Di.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_Di.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_Di.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->D[i]);
+ }
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_Ki;
+ u_Ki.real = this->K[i];
+ *(outbuffer + offset + 0) = (u_Ki.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_Ki.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_Ki.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_Ki.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_Ki.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_Ki.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_Ki.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_Ki.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->K[i]);
+ }
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_Ri;
+ u_Ri.real = this->R[i];
+ *(outbuffer + offset + 0) = (u_Ri.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_Ri.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_Ri.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_Ri.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_Ri.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_Ri.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_Ri.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_Ri.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->R[i]);
+ }
+ for( uint32_t i = 0; i < 12; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_Pi;
+ u_Pi.real = this->P[i];
+ *(outbuffer + offset + 0) = (u_Pi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_Pi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_Pi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_Pi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_Pi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_Pi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_Pi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_Pi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->P[i]);
+ }
+ *(outbuffer + offset + 0) = (this->binning_x >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->binning_x >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->binning_x >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->binning_x >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->binning_x);
+ *(outbuffer + offset + 0) = (this->binning_y >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->binning_y >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->binning_y >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->binning_y >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->binning_y);
+ offset += this->roi.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->height = ((uint32_t) (*(inbuffer + offset)));
+ this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->height);
+ this->width = ((uint32_t) (*(inbuffer + offset)));
+ this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->width);
+ uint32_t length_distortion_model;
+ arrToVar(length_distortion_model, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_distortion_model; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_distortion_model-1]=0;
+ this->distortion_model = (char *)(inbuffer + offset-1);
+ offset += length_distortion_model;
+ uint32_t D_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ D_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ D_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ D_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->D_length);
+ if(D_lengthT > D_length)
+ this->D = (double*)realloc(this->D, D_lengthT * sizeof(double));
+ D_length = D_lengthT;
+ for( uint32_t i = 0; i < D_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_D;
+ u_st_D.base = 0;
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_D.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_D = u_st_D.real;
+ offset += sizeof(this->st_D);
+ memcpy( &(this->D[i]), &(this->st_D), sizeof(double));
+ }
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_Ki;
+ u_Ki.base = 0;
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_Ki.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->K[i] = u_Ki.real;
+ offset += sizeof(this->K[i]);
+ }
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_Ri;
+ u_Ri.base = 0;
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_Ri.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->R[i] = u_Ri.real;
+ offset += sizeof(this->R[i]);
+ }
+ for( uint32_t i = 0; i < 12; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_Pi;
+ u_Pi.base = 0;
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_Pi.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->P[i] = u_Pi.real;
+ offset += sizeof(this->P[i]);
+ }
+ this->binning_x = ((uint32_t) (*(inbuffer + offset)));
+ this->binning_x |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->binning_x |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->binning_x |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->binning_x);
+ this->binning_y = ((uint32_t) (*(inbuffer + offset)));
+ this->binning_y |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->binning_y |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->binning_y |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->binning_y);
+ offset += this->roi.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/CameraInfo"; };
+ const char * getMD5(){ return "c9a58c1b0b154e0e6da7578cb991d214"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/ChannelFloat32.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,99 @@
+#ifndef _ROS_sensor_msgs_ChannelFloat32_h
+#define _ROS_sensor_msgs_ChannelFloat32_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace sensor_msgs
+{
+
+ class ChannelFloat32 : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ uint32_t values_length;
+ typedef float _values_type;
+ _values_type st_values;
+ _values_type * values;
+
+ ChannelFloat32():
+ name(""),
+ values_length(0), values(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ *(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->values_length);
+ for( uint32_t i = 0; i < values_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_valuesi;
+ u_valuesi.real = this->values[i];
+ *(outbuffer + offset + 0) = (u_valuesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_valuesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_valuesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_valuesi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->values[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->values_length);
+ if(values_lengthT > values_length)
+ this->values = (float*)realloc(this->values, values_lengthT * sizeof(float));
+ values_length = values_lengthT;
+ for( uint32_t i = 0; i < values_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_values;
+ u_st_values.base = 0;
+ u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_values = u_st_values.real;
+ offset += sizeof(this->st_values);
+ memcpy( &(this->values[i]), &(this->st_values), sizeof(float));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/ChannelFloat32"; };
+ const char * getMD5(){ return "3d40139cdd33dfedcb71ffeeeb42ae7f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/CompressedImage.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_sensor_msgs_CompressedImage_h
+#define _ROS_sensor_msgs_CompressedImage_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class CompressedImage : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _format_type;
+ _format_type format;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ CompressedImage():
+ header(),
+ format(""),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_format = strlen(this->format);
+ varToArr(outbuffer + offset, length_format);
+ offset += 4;
+ memcpy(outbuffer + offset, this->format, length_format);
+ offset += length_format;
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_format;
+ arrToVar(length_format, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_format; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_format-1]=0;
+ this->format = (char *)(inbuffer + offset-1);
+ offset += length_format;
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/CompressedImage"; };
+ const char * getMD5(){ return "8f7a12909da2c9d3332d540a0977563f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/FluidPressure.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_sensor_msgs_FluidPressure_h
+#define _ROS_sensor_msgs_FluidPressure_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class FluidPressure : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _fluid_pressure_type;
+ _fluid_pressure_type fluid_pressure;
+ typedef double _variance_type;
+ _variance_type variance;
+
+ FluidPressure():
+ header(),
+ fluid_pressure(0),
+ variance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_fluid_pressure;
+ u_fluid_pressure.real = this->fluid_pressure;
+ *(outbuffer + offset + 0) = (u_fluid_pressure.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_fluid_pressure.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_fluid_pressure.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_fluid_pressure.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_fluid_pressure.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_fluid_pressure.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_fluid_pressure.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_fluid_pressure.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->fluid_pressure);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.real = this->variance;
+ *(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_fluid_pressure;
+ u_fluid_pressure.base = 0;
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_fluid_pressure.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->fluid_pressure = u_fluid_pressure.real;
+ offset += sizeof(this->fluid_pressure);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.base = 0;
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->variance = u_variance.real;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/FluidPressure"; };
+ const char * getMD5(){ return "804dc5cea1c5306d6a2eb80b9833befe"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/Illuminance.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_sensor_msgs_Illuminance_h
+#define _ROS_sensor_msgs_Illuminance_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class Illuminance : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _illuminance_type;
+ _illuminance_type illuminance;
+ typedef double _variance_type;
+ _variance_type variance;
+
+ Illuminance():
+ header(),
+ illuminance(0),
+ variance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_illuminance;
+ u_illuminance.real = this->illuminance;
+ *(outbuffer + offset + 0) = (u_illuminance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_illuminance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_illuminance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_illuminance.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_illuminance.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_illuminance.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_illuminance.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_illuminance.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->illuminance);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.real = this->variance;
+ *(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_illuminance;
+ u_illuminance.base = 0;
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_illuminance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->illuminance = u_illuminance.real;
+ offset += sizeof(this->illuminance);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.base = 0;
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->variance = u_variance.real;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/Illuminance"; };
+ const char * getMD5(){ return "8cf5febb0952fca9d650c3d11a81a188"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/Image.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_sensor_msgs_Image_h
+#define _ROS_sensor_msgs_Image_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class Image : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint32_t _height_type;
+ _height_type height;
+ typedef uint32_t _width_type;
+ _width_type width;
+ typedef const char* _encoding_type;
+ _encoding_type encoding;
+ typedef uint8_t _is_bigendian_type;
+ _is_bigendian_type is_bigendian;
+ typedef uint32_t _step_type;
+ _step_type step;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Image():
+ header(),
+ height(0),
+ width(0),
+ encoding(""),
+ is_bigendian(0),
+ step(0),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->height);
+ *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->width);
+ uint32_t length_encoding = strlen(this->encoding);
+ varToArr(outbuffer + offset, length_encoding);
+ offset += 4;
+ memcpy(outbuffer + offset, this->encoding, length_encoding);
+ offset += length_encoding;
+ *(outbuffer + offset + 0) = (this->is_bigendian >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->is_bigendian);
+ *(outbuffer + offset + 0) = (this->step >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->step >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->step >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->step >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->step);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->height = ((uint32_t) (*(inbuffer + offset)));
+ this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->height);
+ this->width = ((uint32_t) (*(inbuffer + offset)));
+ this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->width);
+ uint32_t length_encoding;
+ arrToVar(length_encoding, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_encoding; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_encoding-1]=0;
+ this->encoding = (char *)(inbuffer + offset-1);
+ offset += length_encoding;
+ this->is_bigendian = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->is_bigendian);
+ this->step = ((uint32_t) (*(inbuffer + offset)));
+ this->step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->step);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/Image"; };
+ const char * getMD5(){ return "060021388200f6f0f447d0fcd9c64743"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/Imu.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,166 @@
+#ifndef _ROS_sensor_msgs_Imu_h
+#define _ROS_sensor_msgs_Imu_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Quaternion.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace sensor_msgs
+{
+
+ class Imu : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Quaternion _orientation_type;
+ _orientation_type orientation;
+ double orientation_covariance[9];
+ typedef geometry_msgs::Vector3 _angular_velocity_type;
+ _angular_velocity_type angular_velocity;
+ double angular_velocity_covariance[9];
+ typedef geometry_msgs::Vector3 _linear_acceleration_type;
+ _linear_acceleration_type linear_acceleration;
+ double linear_acceleration_covariance[9];
+
+ Imu():
+ header(),
+ orientation(),
+ orientation_covariance(),
+ angular_velocity(),
+ angular_velocity_covariance(),
+ linear_acceleration(),
+ linear_acceleration_covariance()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->orientation.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_orientation_covariancei;
+ u_orientation_covariancei.real = this->orientation_covariance[i];
+ *(outbuffer + offset + 0) = (u_orientation_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_orientation_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_orientation_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_orientation_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_orientation_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_orientation_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_orientation_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_orientation_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->orientation_covariance[i]);
+ }
+ offset += this->angular_velocity.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_angular_velocity_covariancei;
+ u_angular_velocity_covariancei.real = this->angular_velocity_covariance[i];
+ *(outbuffer + offset + 0) = (u_angular_velocity_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angular_velocity_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angular_velocity_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angular_velocity_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_angular_velocity_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_angular_velocity_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_angular_velocity_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_angular_velocity_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->angular_velocity_covariance[i]);
+ }
+ offset += this->linear_acceleration.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_linear_acceleration_covariancei;
+ u_linear_acceleration_covariancei.real = this->linear_acceleration_covariance[i];
+ *(outbuffer + offset + 0) = (u_linear_acceleration_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_linear_acceleration_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_linear_acceleration_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_linear_acceleration_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_linear_acceleration_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_linear_acceleration_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_linear_acceleration_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_linear_acceleration_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->linear_acceleration_covariance[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->orientation.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_orientation_covariancei;
+ u_orientation_covariancei.base = 0;
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_orientation_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->orientation_covariance[i] = u_orientation_covariancei.real;
+ offset += sizeof(this->orientation_covariance[i]);
+ }
+ offset += this->angular_velocity.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_angular_velocity_covariancei;
+ u_angular_velocity_covariancei.base = 0;
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_angular_velocity_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->angular_velocity_covariance[i] = u_angular_velocity_covariancei.real;
+ offset += sizeof(this->angular_velocity_covariance[i]);
+ }
+ offset += this->linear_acceleration.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_linear_acceleration_covariancei;
+ u_linear_acceleration_covariancei.base = 0;
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_linear_acceleration_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->linear_acceleration_covariance[i] = u_linear_acceleration_covariancei.real;
+ offset += sizeof(this->linear_acceleration_covariance[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/Imu"; };
+ const char * getMD5(){ return "6a62c6daae103f4ff57a132d6f95cec2"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/JointState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,237 @@
+#ifndef _ROS_sensor_msgs_JointState_h
+#define _ROS_sensor_msgs_JointState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class JointState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t name_length;
+ typedef char* _name_type;
+ _name_type st_name;
+ _name_type * name;
+ uint32_t position_length;
+ typedef double _position_type;
+ _position_type st_position;
+ _position_type * position;
+ uint32_t velocity_length;
+ typedef double _velocity_type;
+ _velocity_type st_velocity;
+ _velocity_type * velocity;
+ uint32_t effort_length;
+ typedef double _effort_type;
+ _effort_type st_effort;
+ _effort_type * effort;
+
+ JointState():
+ header(),
+ name_length(0), name(NULL),
+ position_length(0), position(NULL),
+ velocity_length(0), velocity(NULL),
+ effort_length(0), effort(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->name_length);
+ for( uint32_t i = 0; i < name_length; i++){
+ uint32_t length_namei = strlen(this->name[i]);
+ varToArr(outbuffer + offset, length_namei);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name[i], length_namei);
+ offset += length_namei;
+ }
+ *(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->position_length);
+ for( uint32_t i = 0; i < position_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_positioni;
+ u_positioni.real = this->position[i];
+ *(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position[i]);
+ }
+ *(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->velocity_length);
+ for( uint32_t i = 0; i < velocity_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_velocityi;
+ u_velocityi.real = this->velocity[i];
+ *(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->velocity[i]);
+ }
+ *(outbuffer + offset + 0) = (this->effort_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->effort_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->effort_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->effort_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->effort_length);
+ for( uint32_t i = 0; i < effort_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_efforti;
+ u_efforti.real = this->effort[i];
+ *(outbuffer + offset + 0) = (u_efforti.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_efforti.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_efforti.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_efforti.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_efforti.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_efforti.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_efforti.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_efforti.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->effort[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->name_length);
+ if(name_lengthT > name_length)
+ this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
+ name_length = name_lengthT;
+ for( uint32_t i = 0; i < name_length; i++){
+ uint32_t length_st_name;
+ arrToVar(length_st_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_name-1]=0;
+ this->st_name = (char *)(inbuffer + offset-1);
+ offset += length_st_name;
+ memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
+ }
+ uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->position_length);
+ if(position_lengthT > position_length)
+ this->position = (double*)realloc(this->position, position_lengthT * sizeof(double));
+ position_length = position_lengthT;
+ for( uint32_t i = 0; i < position_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_position;
+ u_st_position.base = 0;
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_position = u_st_position.real;
+ offset += sizeof(this->st_position);
+ memcpy( &(this->position[i]), &(this->st_position), sizeof(double));
+ }
+ uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->velocity_length);
+ if(velocity_lengthT > velocity_length)
+ this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double));
+ velocity_length = velocity_lengthT;
+ for( uint32_t i = 0; i < velocity_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_velocity;
+ u_st_velocity.base = 0;
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_velocity = u_st_velocity.real;
+ offset += sizeof(this->st_velocity);
+ memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double));
+ }
+ uint32_t effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->effort_length);
+ if(effort_lengthT > effort_length)
+ this->effort = (double*)realloc(this->effort, effort_lengthT * sizeof(double));
+ effort_length = effort_lengthT;
+ for( uint32_t i = 0; i < effort_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_effort;
+ u_st_effort.base = 0;
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_effort = u_st_effort.real;
+ offset += sizeof(this->st_effort);
+ memcpy( &(this->effort[i]), &(this->st_effort), sizeof(double));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/JointState"; };
+ const char * getMD5(){ return "3066dcd76a6cfaef579bd0f34173e9fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/Joy.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,132 @@
+#ifndef _ROS_sensor_msgs_Joy_h
+#define _ROS_sensor_msgs_Joy_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class Joy : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t axes_length;
+ typedef float _axes_type;
+ _axes_type st_axes;
+ _axes_type * axes;
+ uint32_t buttons_length;
+ typedef int32_t _buttons_type;
+ _buttons_type st_buttons;
+ _buttons_type * buttons;
+
+ Joy():
+ header(),
+ axes_length(0), axes(NULL),
+ buttons_length(0), buttons(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->axes_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->axes_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->axes_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->axes_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->axes_length);
+ for( uint32_t i = 0; i < axes_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_axesi;
+ u_axesi.real = this->axes[i];
+ *(outbuffer + offset + 0) = (u_axesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_axesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_axesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_axesi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->axes[i]);
+ }
+ *(outbuffer + offset + 0) = (this->buttons_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->buttons_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->buttons_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->buttons_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->buttons_length);
+ for( uint32_t i = 0; i < buttons_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_buttonsi;
+ u_buttonsi.real = this->buttons[i];
+ *(outbuffer + offset + 0) = (u_buttonsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_buttonsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_buttonsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_buttonsi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->buttons[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t axes_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->axes_length);
+ if(axes_lengthT > axes_length)
+ this->axes = (float*)realloc(this->axes, axes_lengthT * sizeof(float));
+ axes_length = axes_lengthT;
+ for( uint32_t i = 0; i < axes_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_axes;
+ u_st_axes.base = 0;
+ u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_axes = u_st_axes.real;
+ offset += sizeof(this->st_axes);
+ memcpy( &(this->axes[i]), &(this->st_axes), sizeof(float));
+ }
+ uint32_t buttons_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->buttons_length);
+ if(buttons_lengthT > buttons_length)
+ this->buttons = (int32_t*)realloc(this->buttons, buttons_lengthT * sizeof(int32_t));
+ buttons_length = buttons_lengthT;
+ for( uint32_t i = 0; i < buttons_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_st_buttons;
+ u_st_buttons.base = 0;
+ u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_buttons = u_st_buttons.real;
+ offset += sizeof(this->st_buttons);
+ memcpy( &(this->buttons[i]), &(this->st_buttons), sizeof(int32_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/Joy"; };
+ const char * getMD5(){ return "5a9ea5f83505693b71e785041e67a8bb"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/JoyFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,79 @@
+#ifndef _ROS_sensor_msgs_JoyFeedback_h
+#define _ROS_sensor_msgs_JoyFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace sensor_msgs
+{
+
+ class JoyFeedback : public ros::Msg
+ {
+ public:
+ typedef uint8_t _type_type;
+ _type_type type;
+ typedef uint8_t _id_type;
+ _id_type id;
+ typedef float _intensity_type;
+ _intensity_type intensity;
+ enum { TYPE_LED = 0 };
+ enum { TYPE_RUMBLE = 1 };
+ enum { TYPE_BUZZER = 2 };
+
+ JoyFeedback():
+ type(0),
+ id(0),
+ intensity(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ *(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->id);
+ union {
+ float real;
+ uint32_t base;
+ } u_intensity;
+ u_intensity.real = this->intensity;
+ *(outbuffer + offset + 0) = (u_intensity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_intensity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_intensity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_intensity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->intensity);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ this->id = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->id);
+ union {
+ float real;
+ uint32_t base;
+ } u_intensity;
+ u_intensity.base = 0;
+ u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_intensity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->intensity = u_intensity.real;
+ offset += sizeof(this->intensity);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/JoyFeedback"; };
+ const char * getMD5(){ return "f4dcd73460360d98f36e55ee7f2e46f1"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/JoyFeedbackArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,64 @@
+#ifndef _ROS_sensor_msgs_JoyFeedbackArray_h
+#define _ROS_sensor_msgs_JoyFeedbackArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "sensor_msgs/JoyFeedback.h"
+
+namespace sensor_msgs
+{
+
+ class JoyFeedbackArray : public ros::Msg
+ {
+ public:
+ uint32_t array_length;
+ typedef sensor_msgs::JoyFeedback _array_type;
+ _array_type st_array;
+ _array_type * array;
+
+ JoyFeedbackArray():
+ array_length(0), array(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->array_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->array_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->array_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->array_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->array_length);
+ for( uint32_t i = 0; i < array_length; i++){
+ offset += this->array[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t array_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ array_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ array_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ array_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->array_length);
+ if(array_lengthT > array_length)
+ this->array = (sensor_msgs::JoyFeedback*)realloc(this->array, array_lengthT * sizeof(sensor_msgs::JoyFeedback));
+ array_length = array_lengthT;
+ for( uint32_t i = 0; i < array_length; i++){
+ offset += this->st_array.deserialize(inbuffer + offset);
+ memcpy( &(this->array[i]), &(this->st_array), sizeof(sensor_msgs::JoyFeedback));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/JoyFeedbackArray"; };
+ const char * getMD5(){ return "cde5730a895b1fc4dee6f91b754b213d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/LaserEcho.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_sensor_msgs_LaserEcho_h
+#define _ROS_sensor_msgs_LaserEcho_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace sensor_msgs
+{
+
+ class LaserEcho : public ros::Msg
+ {
+ public:
+ uint32_t echoes_length;
+ typedef float _echoes_type;
+ _echoes_type st_echoes;
+ _echoes_type * echoes;
+
+ LaserEcho():
+ echoes_length(0), echoes(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->echoes_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->echoes_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->echoes_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->echoes_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->echoes_length);
+ for( uint32_t i = 0; i < echoes_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_echoesi;
+ u_echoesi.real = this->echoes[i];
+ *(outbuffer + offset + 0) = (u_echoesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_echoesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_echoesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_echoesi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->echoes[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t echoes_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ echoes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->echoes_length);
+ if(echoes_lengthT > echoes_length)
+ this->echoes = (float*)realloc(this->echoes, echoes_lengthT * sizeof(float));
+ echoes_length = echoes_lengthT;
+ for( uint32_t i = 0; i < echoes_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_echoes;
+ u_st_echoes.base = 0;
+ u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_echoes.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_echoes = u_st_echoes.real;
+ offset += sizeof(this->st_echoes);
+ memcpy( &(this->echoes[i]), &(this->st_echoes), sizeof(float));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/LaserEcho"; };
+ const char * getMD5(){ return "8bc5ae449b200fba4d552b4225586696"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/LaserScan.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,300 @@
+#ifndef _ROS_sensor_msgs_LaserScan_h
+#define _ROS_sensor_msgs_LaserScan_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class LaserScan : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _angle_min_type;
+ _angle_min_type angle_min;
+ typedef float _angle_max_type;
+ _angle_max_type angle_max;
+ typedef float _angle_increment_type;
+ _angle_increment_type angle_increment;
+ typedef float _time_increment_type;
+ _time_increment_type time_increment;
+ typedef float _scan_time_type;
+ _scan_time_type scan_time;
+ typedef float _range_min_type;
+ _range_min_type range_min;
+ typedef float _range_max_type;
+ _range_max_type range_max;
+ uint32_t ranges_length;
+ typedef float _ranges_type;
+ _ranges_type st_ranges;
+ _ranges_type * ranges;
+ uint32_t intensities_length;
+ typedef float _intensities_type;
+ _intensities_type st_intensities;
+ _intensities_type * intensities;
+
+ LaserScan():
+ header(),
+ angle_min(0),
+ angle_max(0),
+ angle_increment(0),
+ time_increment(0),
+ scan_time(0),
+ range_min(0),
+ range_max(0),
+ ranges_length(0), ranges(NULL),
+ intensities_length(0), intensities(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_min;
+ u_angle_min.real = this->angle_min;
+ *(outbuffer + offset + 0) = (u_angle_min.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angle_min.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angle_min.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angle_min.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angle_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_max;
+ u_angle_max.real = this->angle_max;
+ *(outbuffer + offset + 0) = (u_angle_max.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angle_max.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angle_max.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angle_max.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angle_max);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_increment;
+ u_angle_increment.real = this->angle_increment;
+ *(outbuffer + offset + 0) = (u_angle_increment.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angle_increment.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angle_increment.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angle_increment.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angle_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_time_increment;
+ u_time_increment.real = this->time_increment;
+ *(outbuffer + offset + 0) = (u_time_increment.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_time_increment.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_time_increment.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_time_increment.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_scan_time;
+ u_scan_time.real = this->scan_time;
+ *(outbuffer + offset + 0) = (u_scan_time.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_scan_time.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_scan_time.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_scan_time.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->scan_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_min;
+ u_range_min.real = this->range_min;
+ *(outbuffer + offset + 0) = (u_range_min.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_range_min.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_range_min.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_range_min.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->range_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_max;
+ u_range_max.real = this->range_max;
+ *(outbuffer + offset + 0) = (u_range_max.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_range_max.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_range_max.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_range_max.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->range_max);
+ *(outbuffer + offset + 0) = (this->ranges_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->ranges_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->ranges_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->ranges_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ranges_length);
+ for( uint32_t i = 0; i < ranges_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_rangesi;
+ u_rangesi.real = this->ranges[i];
+ *(outbuffer + offset + 0) = (u_rangesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_rangesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_rangesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_rangesi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ranges[i]);
+ }
+ *(outbuffer + offset + 0) = (this->intensities_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->intensities_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->intensities_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->intensities_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->intensities_length);
+ for( uint32_t i = 0; i < intensities_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_intensitiesi;
+ u_intensitiesi.real = this->intensities[i];
+ *(outbuffer + offset + 0) = (u_intensitiesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_intensitiesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_intensitiesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_intensitiesi.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->intensities[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_min;
+ u_angle_min.base = 0;
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angle_min = u_angle_min.real;
+ offset += sizeof(this->angle_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_max;
+ u_angle_max.base = 0;
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angle_max = u_angle_max.real;
+ offset += sizeof(this->angle_max);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_increment;
+ u_angle_increment.base = 0;
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angle_increment = u_angle_increment.real;
+ offset += sizeof(this->angle_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_time_increment;
+ u_time_increment.base = 0;
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->time_increment = u_time_increment.real;
+ offset += sizeof(this->time_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_scan_time;
+ u_scan_time.base = 0;
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->scan_time = u_scan_time.real;
+ offset += sizeof(this->scan_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_min;
+ u_range_min.base = 0;
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->range_min = u_range_min.real;
+ offset += sizeof(this->range_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_max;
+ u_range_max.base = 0;
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->range_max = u_range_max.real;
+ offset += sizeof(this->range_max);
+ uint32_t ranges_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->ranges_length);
+ if(ranges_lengthT > ranges_length)
+ this->ranges = (float*)realloc(this->ranges, ranges_lengthT * sizeof(float));
+ ranges_length = ranges_lengthT;
+ for( uint32_t i = 0; i < ranges_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_ranges;
+ u_st_ranges.base = 0;
+ u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_ranges.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_ranges = u_st_ranges.real;
+ offset += sizeof(this->st_ranges);
+ memcpy( &(this->ranges[i]), &(this->st_ranges), sizeof(float));
+ }
+ uint32_t intensities_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->intensities_length);
+ if(intensities_lengthT > intensities_length)
+ this->intensities = (float*)realloc(this->intensities, intensities_lengthT * sizeof(float));
+ intensities_length = intensities_lengthT;
+ for( uint32_t i = 0; i < intensities_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_intensities;
+ u_st_intensities.base = 0;
+ u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_intensities.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_intensities = u_st_intensities.real;
+ offset += sizeof(this->st_intensities);
+ memcpy( &(this->intensities[i]), &(this->st_intensities), sizeof(float));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/LaserScan"; };
+ const char * getMD5(){ return "90c7ef2dc6895d81024acba2ac42f369"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/MagneticField.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,85 @@
+#ifndef _ROS_sensor_msgs_MagneticField_h
+#define _ROS_sensor_msgs_MagneticField_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Vector3.h"
+
+namespace sensor_msgs
+{
+
+ class MagneticField : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Vector3 _magnetic_field_type;
+ _magnetic_field_type magnetic_field;
+ double magnetic_field_covariance[9];
+
+ MagneticField():
+ header(),
+ magnetic_field(),
+ magnetic_field_covariance()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->magnetic_field.serialize(outbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_magnetic_field_covariancei;
+ u_magnetic_field_covariancei.real = this->magnetic_field_covariance[i];
+ *(outbuffer + offset + 0) = (u_magnetic_field_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_magnetic_field_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_magnetic_field_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_magnetic_field_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_magnetic_field_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_magnetic_field_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_magnetic_field_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_magnetic_field_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->magnetic_field_covariance[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->magnetic_field.deserialize(inbuffer + offset);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_magnetic_field_covariancei;
+ u_magnetic_field_covariancei.base = 0;
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_magnetic_field_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->magnetic_field_covariance[i] = u_magnetic_field_covariancei.real;
+ offset += sizeof(this->magnetic_field_covariance[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/MagneticField"; };
+ const char * getMD5(){ return "2f3b0b43eed0c9501de0fa3ff89a45aa"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/MultiDOFJointState.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,159 @@
+#ifndef _ROS_sensor_msgs_MultiDOFJointState_h
+#define _ROS_sensor_msgs_MultiDOFJointState_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Transform.h"
+#include "geometry_msgs/Twist.h"
+#include "geometry_msgs/Wrench.h"
+
+namespace sensor_msgs
+{
+
+ class MultiDOFJointState : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t joint_names_length;
+ typedef char* _joint_names_type;
+ _joint_names_type st_joint_names;
+ _joint_names_type * joint_names;
+ uint32_t transforms_length;
+ typedef geometry_msgs::Transform _transforms_type;
+ _transforms_type st_transforms;
+ _transforms_type * transforms;
+ uint32_t twist_length;
+ typedef geometry_msgs::Twist _twist_type;
+ _twist_type st_twist;
+ _twist_type * twist;
+ uint32_t wrench_length;
+ typedef geometry_msgs::Wrench _wrench_type;
+ _wrench_type st_wrench;
+ _wrench_type * wrench;
+
+ MultiDOFJointState():
+ header(),
+ joint_names_length(0), joint_names(NULL),
+ transforms_length(0), transforms(NULL),
+ twist_length(0), twist(NULL),
+ wrench_length(0), wrench(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->joint_names_length);
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_joint_namesi = strlen(this->joint_names[i]);
+ varToArr(outbuffer + offset, length_joint_namesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
+ offset += length_joint_namesi;
+ }
+ *(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->transforms_length);
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->transforms[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->twist_length);
+ for( uint32_t i = 0; i < twist_length; i++){
+ offset += this->twist[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->wrench_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->wrench_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->wrench_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->wrench_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->wrench_length);
+ for( uint32_t i = 0; i < wrench_length; i++){
+ offset += this->wrench[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->joint_names_length);
+ if(joint_names_lengthT > joint_names_length)
+ this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
+ joint_names_length = joint_names_lengthT;
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_st_joint_names;
+ arrToVar(length_st_joint_names, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_joint_names-1]=0;
+ this->st_joint_names = (char *)(inbuffer + offset-1);
+ offset += length_st_joint_names;
+ memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
+ }
+ uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->transforms_length);
+ if(transforms_lengthT > transforms_length)
+ this->transforms = (geometry_msgs::Transform*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::Transform));
+ transforms_length = transforms_lengthT;
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->st_transforms.deserialize(inbuffer + offset);
+ memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::Transform));
+ }
+ uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->twist_length);
+ if(twist_lengthT > twist_length)
+ this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
+ twist_length = twist_lengthT;
+ for( uint32_t i = 0; i < twist_length; i++){
+ offset += this->st_twist.deserialize(inbuffer + offset);
+ memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
+ }
+ uint32_t wrench_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->wrench_length);
+ if(wrench_lengthT > wrench_length)
+ this->wrench = (geometry_msgs::Wrench*)realloc(this->wrench, wrench_lengthT * sizeof(geometry_msgs::Wrench));
+ wrench_length = wrench_lengthT;
+ for( uint32_t i = 0; i < wrench_length; i++){
+ offset += this->st_wrench.deserialize(inbuffer + offset);
+ memcpy( &(this->wrench[i]), &(this->st_wrench), sizeof(geometry_msgs::Wrench));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/MultiDOFJointState"; };
+ const char * getMD5(){ return "690f272f0640d2631c305eeb8301e59d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/MultiEchoLaserScan.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,263 @@
+#ifndef _ROS_sensor_msgs_MultiEchoLaserScan_h
+#define _ROS_sensor_msgs_MultiEchoLaserScan_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "sensor_msgs/LaserEcho.h"
+
+namespace sensor_msgs
+{
+
+ class MultiEchoLaserScan : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef float _angle_min_type;
+ _angle_min_type angle_min;
+ typedef float _angle_max_type;
+ _angle_max_type angle_max;
+ typedef float _angle_increment_type;
+ _angle_increment_type angle_increment;
+ typedef float _time_increment_type;
+ _time_increment_type time_increment;
+ typedef float _scan_time_type;
+ _scan_time_type scan_time;
+ typedef float _range_min_type;
+ _range_min_type range_min;
+ typedef float _range_max_type;
+ _range_max_type range_max;
+ uint32_t ranges_length;
+ typedef sensor_msgs::LaserEcho _ranges_type;
+ _ranges_type st_ranges;
+ _ranges_type * ranges;
+ uint32_t intensities_length;
+ typedef sensor_msgs::LaserEcho _intensities_type;
+ _intensities_type st_intensities;
+ _intensities_type * intensities;
+
+ MultiEchoLaserScan():
+ header(),
+ angle_min(0),
+ angle_max(0),
+ angle_increment(0),
+ time_increment(0),
+ scan_time(0),
+ range_min(0),
+ range_max(0),
+ ranges_length(0), ranges(NULL),
+ intensities_length(0), intensities(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_min;
+ u_angle_min.real = this->angle_min;
+ *(outbuffer + offset + 0) = (u_angle_min.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angle_min.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angle_min.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angle_min.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angle_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_max;
+ u_angle_max.real = this->angle_max;
+ *(outbuffer + offset + 0) = (u_angle_max.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angle_max.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angle_max.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angle_max.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angle_max);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_increment;
+ u_angle_increment.real = this->angle_increment;
+ *(outbuffer + offset + 0) = (u_angle_increment.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angle_increment.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angle_increment.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angle_increment.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angle_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_time_increment;
+ u_time_increment.real = this->time_increment;
+ *(outbuffer + offset + 0) = (u_time_increment.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_time_increment.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_time_increment.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_time_increment.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_scan_time;
+ u_scan_time.real = this->scan_time;
+ *(outbuffer + offset + 0) = (u_scan_time.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_scan_time.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_scan_time.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_scan_time.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->scan_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_min;
+ u_range_min.real = this->range_min;
+ *(outbuffer + offset + 0) = (u_range_min.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_range_min.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_range_min.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_range_min.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->range_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_max;
+ u_range_max.real = this->range_max;
+ *(outbuffer + offset + 0) = (u_range_max.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_range_max.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_range_max.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_range_max.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->range_max);
+ *(outbuffer + offset + 0) = (this->ranges_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->ranges_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->ranges_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->ranges_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->ranges_length);
+ for( uint32_t i = 0; i < ranges_length; i++){
+ offset += this->ranges[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->intensities_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->intensities_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->intensities_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->intensities_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->intensities_length);
+ for( uint32_t i = 0; i < intensities_length; i++){
+ offset += this->intensities[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_min;
+ u_angle_min.base = 0;
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angle_min = u_angle_min.real;
+ offset += sizeof(this->angle_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_max;
+ u_angle_max.base = 0;
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angle_max = u_angle_max.real;
+ offset += sizeof(this->angle_max);
+ union {
+ float real;
+ uint32_t base;
+ } u_angle_increment;
+ u_angle_increment.base = 0;
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angle_increment = u_angle_increment.real;
+ offset += sizeof(this->angle_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_time_increment;
+ u_time_increment.base = 0;
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->time_increment = u_time_increment.real;
+ offset += sizeof(this->time_increment);
+ union {
+ float real;
+ uint32_t base;
+ } u_scan_time;
+ u_scan_time.base = 0;
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->scan_time = u_scan_time.real;
+ offset += sizeof(this->scan_time);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_min;
+ u_range_min.base = 0;
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->range_min = u_range_min.real;
+ offset += sizeof(this->range_min);
+ union {
+ float real;
+ uint32_t base;
+ } u_range_max;
+ u_range_max.base = 0;
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->range_max = u_range_max.real;
+ offset += sizeof(this->range_max);
+ uint32_t ranges_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->ranges_length);
+ if(ranges_lengthT > ranges_length)
+ this->ranges = (sensor_msgs::LaserEcho*)realloc(this->ranges, ranges_lengthT * sizeof(sensor_msgs::LaserEcho));
+ ranges_length = ranges_lengthT;
+ for( uint32_t i = 0; i < ranges_length; i++){
+ offset += this->st_ranges.deserialize(inbuffer + offset);
+ memcpy( &(this->ranges[i]), &(this->st_ranges), sizeof(sensor_msgs::LaserEcho));
+ }
+ uint32_t intensities_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->intensities_length);
+ if(intensities_lengthT > intensities_length)
+ this->intensities = (sensor_msgs::LaserEcho*)realloc(this->intensities, intensities_lengthT * sizeof(sensor_msgs::LaserEcho));
+ intensities_length = intensities_lengthT;
+ for( uint32_t i = 0; i < intensities_length; i++){
+ offset += this->st_intensities.deserialize(inbuffer + offset);
+ memcpy( &(this->intensities[i]), &(this->st_intensities), sizeof(sensor_msgs::LaserEcho));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/MultiEchoLaserScan"; };
+ const char * getMD5(){ return "6fefb0c6da89d7c8abe4b339f5c2f8fb"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/NavSatFix.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,192 @@
+#ifndef _ROS_sensor_msgs_NavSatFix_h
+#define _ROS_sensor_msgs_NavSatFix_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "sensor_msgs/NavSatStatus.h"
+
+namespace sensor_msgs
+{
+
+ class NavSatFix : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef sensor_msgs::NavSatStatus _status_type;
+ _status_type status;
+ typedef double _latitude_type;
+ _latitude_type latitude;
+ typedef double _longitude_type;
+ _longitude_type longitude;
+ typedef double _altitude_type;
+ _altitude_type altitude;
+ double position_covariance[9];
+ typedef uint8_t _position_covariance_type_type;
+ _position_covariance_type_type position_covariance_type;
+ enum { COVARIANCE_TYPE_UNKNOWN = 0 };
+ enum { COVARIANCE_TYPE_APPROXIMATED = 1 };
+ enum { COVARIANCE_TYPE_DIAGONAL_KNOWN = 2 };
+ enum { COVARIANCE_TYPE_KNOWN = 3 };
+
+ NavSatFix():
+ header(),
+ status(),
+ latitude(0),
+ longitude(0),
+ altitude(0),
+ position_covariance(),
+ position_covariance_type(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.real = this->latitude;
+ *(outbuffer + offset + 0) = (u_latitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_latitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_latitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_latitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_latitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_latitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_latitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_latitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.real = this->longitude;
+ *(outbuffer + offset + 0) = (u_longitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_longitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_longitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_longitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_longitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_longitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_longitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_longitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->longitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.real = this->altitude;
+ *(outbuffer + offset + 0) = (u_altitude.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_altitude.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_altitude.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_altitude.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_altitude.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_altitude.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_altitude.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_altitude.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->altitude);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_position_covariancei;
+ u_position_covariancei.real = this->position_covariance[i];
+ *(outbuffer + offset + 0) = (u_position_covariancei.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_position_covariancei.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_position_covariancei.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_position_covariancei.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_position_covariancei.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_position_covariancei.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_position_covariancei.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_position_covariancei.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->position_covariance[i]);
+ }
+ *(outbuffer + offset + 0) = (this->position_covariance_type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->position_covariance_type);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_latitude;
+ u_latitude.base = 0;
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_latitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->latitude = u_latitude.real;
+ offset += sizeof(this->latitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_longitude;
+ u_longitude.base = 0;
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_longitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->longitude = u_longitude.real;
+ offset += sizeof(this->longitude);
+ union {
+ double real;
+ uint64_t base;
+ } u_altitude;
+ u_altitude.base = 0;
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_altitude.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->altitude = u_altitude.real;
+ offset += sizeof(this->altitude);
+ for( uint32_t i = 0; i < 9; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_position_covariancei;
+ u_position_covariancei.base = 0;
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_position_covariancei.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->position_covariance[i] = u_position_covariancei.real;
+ offset += sizeof(this->position_covariance[i]);
+ }
+ this->position_covariance_type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->position_covariance_type);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/NavSatFix"; };
+ const char * getMD5(){ return "2d3a8cd499b9b4a0249fb98fd05cfa48"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/NavSatStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,73 @@
+#ifndef _ROS_sensor_msgs_NavSatStatus_h
+#define _ROS_sensor_msgs_NavSatStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace sensor_msgs
+{
+
+ class NavSatStatus : public ros::Msg
+ {
+ public:
+ typedef int8_t _status_type;
+ _status_type status;
+ typedef uint16_t _service_type;
+ _service_type service;
+ enum { STATUS_NO_FIX = -1 };
+ enum { STATUS_FIX = 0 };
+ enum { STATUS_SBAS_FIX = 1 };
+ enum { STATUS_GBAS_FIX = 2 };
+ enum { SERVICE_GPS = 1 };
+ enum { SERVICE_GLONASS = 2 };
+ enum { SERVICE_COMPASS = 4 };
+ enum { SERVICE_GALILEO = 8 };
+
+ NavSatStatus():
+ status(0),
+ service(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_status;
+ u_status.real = this->status;
+ *(outbuffer + offset + 0) = (u_status.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->status);
+ *(outbuffer + offset + 0) = (this->service >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->service >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->service);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_status;
+ u_status.base = 0;
+ u_status.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->status = u_status.real;
+ offset += sizeof(this->status);
+ this->service = ((uint16_t) (*(inbuffer + offset)));
+ this->service |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->service);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/NavSatStatus"; };
+ const char * getMD5(){ return "331cdbddfa4bc96ffc3b9ad98900a54c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/PointCloud.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_sensor_msgs_PointCloud_h
+#define _ROS_sensor_msgs_PointCloud_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Point32.h"
+#include "sensor_msgs/ChannelFloat32.h"
+
+namespace sensor_msgs
+{
+
+ class PointCloud : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t points_length;
+ typedef geometry_msgs::Point32 _points_type;
+ _points_type st_points;
+ _points_type * points;
+ uint32_t channels_length;
+ typedef sensor_msgs::ChannelFloat32 _channels_type;
+ _channels_type st_channels;
+ _channels_type * channels;
+
+ PointCloud():
+ header(),
+ points_length(0), points(NULL),
+ channels_length(0), channels(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->channels_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->channels_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->channels_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->channels_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->channels_length);
+ for( uint32_t i = 0; i < channels_length; i++){
+ offset += this->channels[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (geometry_msgs::Point32*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point32));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point32));
+ }
+ uint32_t channels_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ channels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->channels_length);
+ if(channels_lengthT > channels_length)
+ this->channels = (sensor_msgs::ChannelFloat32*)realloc(this->channels, channels_lengthT * sizeof(sensor_msgs::ChannelFloat32));
+ channels_length = channels_lengthT;
+ for( uint32_t i = 0; i < channels_length; i++){
+ offset += this->st_channels.deserialize(inbuffer + offset);
+ memcpy( &(this->channels[i]), &(this->st_channels), sizeof(sensor_msgs::ChannelFloat32));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/PointCloud"; };
+ const char * getMD5(){ return "d8e9c3f5afbdd8a130fd1d2763945fca"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/PointCloud2.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,185 @@
+#ifndef _ROS_sensor_msgs_PointCloud2_h
+#define _ROS_sensor_msgs_PointCloud2_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "sensor_msgs/PointField.h"
+
+namespace sensor_msgs
+{
+
+ class PointCloud2 : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint32_t _height_type;
+ _height_type height;
+ typedef uint32_t _width_type;
+ _width_type width;
+ uint32_t fields_length;
+ typedef sensor_msgs::PointField _fields_type;
+ _fields_type st_fields;
+ _fields_type * fields;
+ typedef bool _is_bigendian_type;
+ _is_bigendian_type is_bigendian;
+ typedef uint32_t _point_step_type;
+ _point_step_type point_step;
+ typedef uint32_t _row_step_type;
+ _row_step_type row_step;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+ typedef bool _is_dense_type;
+ _is_dense_type is_dense;
+
+ PointCloud2():
+ header(),
+ height(0),
+ width(0),
+ fields_length(0), fields(NULL),
+ is_bigendian(0),
+ point_step(0),
+ row_step(0),
+ data_length(0), data(NULL),
+ is_dense(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->height);
+ *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->width);
+ *(outbuffer + offset + 0) = (this->fields_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->fields_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->fields_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->fields_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->fields_length);
+ for( uint32_t i = 0; i < fields_length; i++){
+ offset += this->fields[i].serialize(outbuffer + offset);
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_bigendian;
+ u_is_bigendian.real = this->is_bigendian;
+ *(outbuffer + offset + 0) = (u_is_bigendian.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->is_bigendian);
+ *(outbuffer + offset + 0) = (this->point_step >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->point_step >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->point_step >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->point_step >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->point_step);
+ *(outbuffer + offset + 0) = (this->row_step >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->row_step >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->row_step >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->row_step >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->row_step);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_dense;
+ u_is_dense.real = this->is_dense;
+ *(outbuffer + offset + 0) = (u_is_dense.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->is_dense);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->height = ((uint32_t) (*(inbuffer + offset)));
+ this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->height);
+ this->width = ((uint32_t) (*(inbuffer + offset)));
+ this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->width);
+ uint32_t fields_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ fields_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->fields_length);
+ if(fields_lengthT > fields_length)
+ this->fields = (sensor_msgs::PointField*)realloc(this->fields, fields_lengthT * sizeof(sensor_msgs::PointField));
+ fields_length = fields_lengthT;
+ for( uint32_t i = 0; i < fields_length; i++){
+ offset += this->st_fields.deserialize(inbuffer + offset);
+ memcpy( &(this->fields[i]), &(this->st_fields), sizeof(sensor_msgs::PointField));
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_bigendian;
+ u_is_bigendian.base = 0;
+ u_is_bigendian.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->is_bigendian = u_is_bigendian.real;
+ offset += sizeof(this->is_bigendian);
+ this->point_step = ((uint32_t) (*(inbuffer + offset)));
+ this->point_step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->point_step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->point_step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->point_step);
+ this->row_step = ((uint32_t) (*(inbuffer + offset)));
+ this->row_step |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->row_step |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->row_step |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->row_step);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_is_dense;
+ u_is_dense.base = 0;
+ u_is_dense.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->is_dense = u_is_dense.real;
+ offset += sizeof(this->is_dense);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/PointCloud2"; };
+ const char * getMD5(){ return "1158d486dd51d683ce2f1be655c3c181"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/PointField.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_sensor_msgs_PointField_h
+#define _ROS_sensor_msgs_PointField_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace sensor_msgs
+{
+
+ class PointField : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef uint32_t _offset_type;
+ _offset_type offset;
+ typedef uint8_t _datatype_type;
+ _datatype_type datatype;
+ typedef uint32_t _count_type;
+ _count_type count;
+ enum { INT8 = 1 };
+ enum { UINT8 = 2 };
+ enum { INT16 = 3 };
+ enum { UINT16 = 4 };
+ enum { INT32 = 5 };
+ enum { UINT32 = 6 };
+ enum { FLOAT32 = 7 };
+ enum { FLOAT64 = 8 };
+
+ PointField():
+ name(""),
+ offset(0),
+ datatype(0),
+ count(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ *(outbuffer + offset + 0) = (this->offset >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->offset >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->offset >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->offset >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->offset);
+ *(outbuffer + offset + 0) = (this->datatype >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->datatype);
+ *(outbuffer + offset + 0) = (this->count >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->count >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->count >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->count >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->count);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ this->offset = ((uint32_t) (*(inbuffer + offset)));
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->offset);
+ this->datatype = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->datatype);
+ this->count = ((uint32_t) (*(inbuffer + offset)));
+ this->count |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->count |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->count |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->count);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/PointField"; };
+ const char * getMD5(){ return "268eacb2962780ceac86cbd17e328150"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/Range.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,149 @@
+#ifndef _ROS_sensor_msgs_Range_h
+#define _ROS_sensor_msgs_Range_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class Range : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef uint8_t _radiation_type_type;
+ _radiation_type_type radiation_type;
+ typedef float _field_of_view_type;
+ _field_of_view_type field_of_view;
+ typedef float _min_range_type;
+ _min_range_type min_range;
+ typedef float _max_range_type;
+ _max_range_type max_range;
+ typedef float _range_type;
+ _range_type range;
+ enum { ULTRASOUND = 0 };
+ enum { INFRARED = 1 };
+
+ Range():
+ header(),
+ radiation_type(0),
+ field_of_view(0),
+ min_range(0),
+ max_range(0),
+ range(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->radiation_type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->radiation_type);
+ union {
+ float real;
+ uint32_t base;
+ } u_field_of_view;
+ u_field_of_view.real = this->field_of_view;
+ *(outbuffer + offset + 0) = (u_field_of_view.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_field_of_view.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_field_of_view.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_field_of_view.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->field_of_view);
+ union {
+ float real;
+ uint32_t base;
+ } u_min_range;
+ u_min_range.real = this->min_range;
+ *(outbuffer + offset + 0) = (u_min_range.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_min_range.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_min_range.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_min_range.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->min_range);
+ union {
+ float real;
+ uint32_t base;
+ } u_max_range;
+ u_max_range.real = this->max_range;
+ *(outbuffer + offset + 0) = (u_max_range.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_max_range.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_max_range.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_max_range.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->max_range);
+ union {
+ float real;
+ uint32_t base;
+ } u_range;
+ u_range.real = this->range;
+ *(outbuffer + offset + 0) = (u_range.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_range.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_range.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_range.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->range);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->radiation_type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->radiation_type);
+ union {
+ float real;
+ uint32_t base;
+ } u_field_of_view;
+ u_field_of_view.base = 0;
+ u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_field_of_view.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->field_of_view = u_field_of_view.real;
+ offset += sizeof(this->field_of_view);
+ union {
+ float real;
+ uint32_t base;
+ } u_min_range;
+ u_min_range.base = 0;
+ u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_min_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->min_range = u_min_range.real;
+ offset += sizeof(this->min_range);
+ union {
+ float real;
+ uint32_t base;
+ } u_max_range;
+ u_max_range.base = 0;
+ u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_max_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->max_range = u_max_range.real;
+ offset += sizeof(this->max_range);
+ union {
+ float real;
+ uint32_t base;
+ } u_range;
+ u_range.base = 0;
+ u_range.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_range.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_range.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_range.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->range = u_range.real;
+ offset += sizeof(this->range);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/Range"; };
+ const char * getMD5(){ return "c005c34273dc426c67a020a87bc24148"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/RegionOfInterest.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_sensor_msgs_RegionOfInterest_h
+#define _ROS_sensor_msgs_RegionOfInterest_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace sensor_msgs
+{
+
+ class RegionOfInterest : public ros::Msg
+ {
+ public:
+ typedef uint32_t _x_offset_type;
+ _x_offset_type x_offset;
+ typedef uint32_t _y_offset_type;
+ _y_offset_type y_offset;
+ typedef uint32_t _height_type;
+ _height_type height;
+ typedef uint32_t _width_type;
+ _width_type width;
+ typedef bool _do_rectify_type;
+ _do_rectify_type do_rectify;
+
+ RegionOfInterest():
+ x_offset(0),
+ y_offset(0),
+ height(0),
+ width(0),
+ do_rectify(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->x_offset >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->x_offset >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->x_offset >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->x_offset >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x_offset);
+ *(outbuffer + offset + 0) = (this->y_offset >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->y_offset >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->y_offset >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->y_offset >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y_offset);
+ *(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->height);
+ *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->width);
+ union {
+ bool real;
+ uint8_t base;
+ } u_do_rectify;
+ u_do_rectify.real = this->do_rectify;
+ *(outbuffer + offset + 0) = (u_do_rectify.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->do_rectify);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->x_offset = ((uint32_t) (*(inbuffer + offset)));
+ this->x_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->x_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->x_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->x_offset);
+ this->y_offset = ((uint32_t) (*(inbuffer + offset)));
+ this->y_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->y_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->y_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->y_offset);
+ this->height = ((uint32_t) (*(inbuffer + offset)));
+ this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->height);
+ this->width = ((uint32_t) (*(inbuffer + offset)));
+ this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->width);
+ union {
+ bool real;
+ uint8_t base;
+ } u_do_rectify;
+ u_do_rectify.base = 0;
+ u_do_rectify.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->do_rectify = u_do_rectify.real;
+ offset += sizeof(this->do_rectify);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/RegionOfInterest"; };
+ const char * getMD5(){ return "bdb633039d588fcccb441a4d43ccfe09"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/RelativeHumidity.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_sensor_msgs_RelativeHumidity_h
+#define _ROS_sensor_msgs_RelativeHumidity_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class RelativeHumidity : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _relative_humidity_type;
+ _relative_humidity_type relative_humidity;
+ typedef double _variance_type;
+ _variance_type variance;
+
+ RelativeHumidity():
+ header(),
+ relative_humidity(0),
+ variance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_relative_humidity;
+ u_relative_humidity.real = this->relative_humidity;
+ *(outbuffer + offset + 0) = (u_relative_humidity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_relative_humidity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_relative_humidity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_relative_humidity.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_relative_humidity.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_relative_humidity.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_relative_humidity.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_relative_humidity.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->relative_humidity);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.real = this->variance;
+ *(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_relative_humidity;
+ u_relative_humidity.base = 0;
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_relative_humidity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->relative_humidity = u_relative_humidity.real;
+ offset += sizeof(this->relative_humidity);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.base = 0;
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->variance = u_variance.real;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/RelativeHumidity"; };
+ const char * getMD5(){ return "8730015b05955b7e992ce29a2678d90f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/SetCameraInfo.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,111 @@
+#ifndef _ROS_SERVICE_SetCameraInfo_h
+#define _ROS_SERVICE_SetCameraInfo_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "sensor_msgs/CameraInfo.h"
+
+namespace sensor_msgs
+{
+
+static const char SETCAMERAINFO[] = "sensor_msgs/SetCameraInfo";
+
+ class SetCameraInfoRequest : public ros::Msg
+ {
+ public:
+ typedef sensor_msgs::CameraInfo _camera_info_type;
+ _camera_info_type camera_info;
+
+ SetCameraInfoRequest():
+ camera_info()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->camera_info.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->camera_info.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return SETCAMERAINFO; };
+ const char * getMD5(){ return "ee34be01fdeee563d0d99cd594d5581d"; };
+
+ };
+
+ class SetCameraInfoResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _status_message_type;
+ _status_message_type status_message;
+
+ SetCameraInfoResponse():
+ success(0),
+ status_message("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_status_message = strlen(this->status_message);
+ varToArr(outbuffer + offset, length_status_message);
+ offset += 4;
+ memcpy(outbuffer + offset, this->status_message, length_status_message);
+ offset += length_status_message;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_status_message;
+ arrToVar(length_status_message, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_status_message; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_status_message-1]=0;
+ this->status_message = (char *)(inbuffer + offset-1);
+ offset += length_status_message;
+ return offset;
+ }
+
+ const char * getType(){ return SETCAMERAINFO; };
+ const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
+
+ };
+
+ class SetCameraInfo {
+ public:
+ typedef SetCameraInfoRequest Request;
+ typedef SetCameraInfoResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/Temperature.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_sensor_msgs_Temperature_h
+#define _ROS_sensor_msgs_Temperature_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace sensor_msgs
+{
+
+ class Temperature : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef double _temperature_type;
+ _temperature_type temperature;
+ typedef double _variance_type;
+ _variance_type variance;
+
+ Temperature():
+ header(),
+ temperature(0),
+ variance(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_temperature;
+ u_temperature.real = this->temperature;
+ *(outbuffer + offset + 0) = (u_temperature.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_temperature.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_temperature.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_temperature.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_temperature.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_temperature.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_temperature.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_temperature.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->temperature);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.real = this->variance;
+ *(outbuffer + offset + 0) = (u_variance.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_variance.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_variance.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_variance.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_variance.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_variance.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_variance.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_variance.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ union {
+ double real;
+ uint64_t base;
+ } u_temperature;
+ u_temperature.base = 0;
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_temperature.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->temperature = u_temperature.real;
+ offset += sizeof(this->temperature);
+ union {
+ double real;
+ uint64_t base;
+ } u_variance;
+ u_variance.base = 0;
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_variance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->variance = u_variance.real;
+ offset += sizeof(this->variance);
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/Temperature"; };
+ const char * getMD5(){ return "ff71b307acdbe7c871a5a6d7ed359100"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/sensor_msgs/TimeReference.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,85 @@
+#ifndef _ROS_sensor_msgs_TimeReference_h
+#define _ROS_sensor_msgs_TimeReference_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "ros/time.h"
+
+namespace sensor_msgs
+{
+
+ class TimeReference : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef ros::Time _time_ref_type;
+ _time_ref_type time_ref;
+ typedef const char* _source_type;
+ _source_type source;
+
+ TimeReference():
+ header(),
+ time_ref(),
+ source("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->time_ref.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_ref.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_ref.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_ref.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_ref.sec);
+ *(outbuffer + offset + 0) = (this->time_ref.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_ref.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_ref.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_ref.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_ref.nsec);
+ uint32_t length_source = strlen(this->source);
+ varToArr(outbuffer + offset, length_source);
+ offset += 4;
+ memcpy(outbuffer + offset, this->source, length_source);
+ offset += length_source;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ this->time_ref.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_ref.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_ref.sec);
+ this->time_ref.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_ref.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_ref.nsec);
+ uint32_t length_source;
+ arrToVar(length_source, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_source; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_source-1]=0;
+ this->source = (char *)(inbuffer + offset-1);
+ offset += length_source;
+ return offset;
+ }
+
+ const char * getType(){ return "sensor_msgs/TimeReference"; };
+ const char * getMD5(){ return "fded64a0265108ba86c3d38fb11c0c16"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/shape_msgs/Mesh.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,90 @@
+#ifndef _ROS_shape_msgs_Mesh_h
+#define _ROS_shape_msgs_Mesh_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "shape_msgs/MeshTriangle.h"
+#include "geometry_msgs/Point.h"
+
+namespace shape_msgs
+{
+
+ class Mesh : public ros::Msg
+ {
+ public:
+ uint32_t triangles_length;
+ typedef shape_msgs::MeshTriangle _triangles_type;
+ _triangles_type st_triangles;
+ _triangles_type * triangles;
+ uint32_t vertices_length;
+ typedef geometry_msgs::Point _vertices_type;
+ _vertices_type st_vertices;
+ _vertices_type * vertices;
+
+ Mesh():
+ triangles_length(0), triangles(NULL),
+ vertices_length(0), vertices(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->triangles_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->triangles_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->triangles_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->triangles_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->triangles_length);
+ for( uint32_t i = 0; i < triangles_length; i++){
+ offset += this->triangles[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->vertices_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->vertices_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->vertices_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->vertices_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->vertices_length);
+ for( uint32_t i = 0; i < vertices_length; i++){
+ offset += this->vertices[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t triangles_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ triangles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->triangles_length);
+ if(triangles_lengthT > triangles_length)
+ this->triangles = (shape_msgs::MeshTriangle*)realloc(this->triangles, triangles_lengthT * sizeof(shape_msgs::MeshTriangle));
+ triangles_length = triangles_lengthT;
+ for( uint32_t i = 0; i < triangles_length; i++){
+ offset += this->st_triangles.deserialize(inbuffer + offset);
+ memcpy( &(this->triangles[i]), &(this->st_triangles), sizeof(shape_msgs::MeshTriangle));
+ }
+ uint32_t vertices_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->vertices_length);
+ if(vertices_lengthT > vertices_length)
+ this->vertices = (geometry_msgs::Point*)realloc(this->vertices, vertices_lengthT * sizeof(geometry_msgs::Point));
+ vertices_length = vertices_lengthT;
+ for( uint32_t i = 0; i < vertices_length; i++){
+ offset += this->st_vertices.deserialize(inbuffer + offset);
+ memcpy( &(this->vertices[i]), &(this->st_vertices), sizeof(geometry_msgs::Point));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "shape_msgs/Mesh"; };
+ const char * getMD5(){ return "1ffdae9486cd3316a121c578b47a85cc"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/shape_msgs/MeshTriangle.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,54 @@
+#ifndef _ROS_shape_msgs_MeshTriangle_h
+#define _ROS_shape_msgs_MeshTriangle_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace shape_msgs
+{
+
+ class MeshTriangle : public ros::Msg
+ {
+ public:
+ uint32_t vertex_indices[3];
+
+ MeshTriangle():
+ vertex_indices()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 3; i++){
+ *(outbuffer + offset + 0) = (this->vertex_indices[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->vertex_indices[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->vertex_indices[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->vertex_indices[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->vertex_indices[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 3; i++){
+ this->vertex_indices[i] = ((uint32_t) (*(inbuffer + offset)));
+ this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->vertex_indices[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->vertex_indices[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "shape_msgs/MeshTriangle"; };
+ const char * getMD5(){ return "23688b2e6d2de3d32fe8af104a903253"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/shape_msgs/Plane.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,73 @@
+#ifndef _ROS_shape_msgs_Plane_h
+#define _ROS_shape_msgs_Plane_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace shape_msgs
+{
+
+ class Plane : public ros::Msg
+ {
+ public:
+ double coef[4];
+
+ Plane():
+ coef()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 4; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_coefi;
+ u_coefi.real = this->coef[i];
+ *(outbuffer + offset + 0) = (u_coefi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_coefi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_coefi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_coefi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_coefi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_coefi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_coefi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_coefi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->coef[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 4; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_coefi;
+ u_coefi.base = 0;
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_coefi.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->coef[i] = u_coefi.real;
+ offset += sizeof(this->coef[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "shape_msgs/Plane"; };
+ const char * getMD5(){ return "2c1b92ed8f31492f8e73f6a4a44ca796"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/shape_msgs/SolidPrimitive.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,109 @@
+#ifndef _ROS_shape_msgs_SolidPrimitive_h
+#define _ROS_shape_msgs_SolidPrimitive_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace shape_msgs
+{
+
+ class SolidPrimitive : public ros::Msg
+ {
+ public:
+ typedef uint8_t _type_type;
+ _type_type type;
+ uint32_t dimensions_length;
+ typedef double _dimensions_type;
+ _dimensions_type st_dimensions;
+ _dimensions_type * dimensions;
+ enum { BOX = 1 };
+ enum { SPHERE = 2 };
+ enum { CYLINDER = 3 };
+ enum { CONE = 4 };
+ enum { BOX_X = 0 };
+ enum { BOX_Y = 1 };
+ enum { BOX_Z = 2 };
+ enum { SPHERE_RADIUS = 0 };
+ enum { CYLINDER_HEIGHT = 0 };
+ enum { CYLINDER_RADIUS = 1 };
+ enum { CONE_HEIGHT = 0 };
+ enum { CONE_RADIUS = 1 };
+
+ SolidPrimitive():
+ type(0),
+ dimensions_length(0), dimensions(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ *(outbuffer + offset + 0) = (this->dimensions_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->dimensions_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->dimensions_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->dimensions_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->dimensions_length);
+ for( uint32_t i = 0; i < dimensions_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_dimensionsi;
+ u_dimensionsi.real = this->dimensions[i];
+ *(outbuffer + offset + 0) = (u_dimensionsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_dimensionsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_dimensionsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_dimensionsi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_dimensionsi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_dimensionsi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_dimensionsi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_dimensionsi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->dimensions[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ uint32_t dimensions_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ dimensions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->dimensions_length);
+ if(dimensions_lengthT > dimensions_length)
+ this->dimensions = (double*)realloc(this->dimensions, dimensions_lengthT * sizeof(double));
+ dimensions_length = dimensions_lengthT;
+ for( uint32_t i = 0; i < dimensions_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_dimensions;
+ u_st_dimensions.base = 0;
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_dimensions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_dimensions = u_st_dimensions.real;
+ offset += sizeof(this->st_dimensions);
+ memcpy( &(this->dimensions[i]), &(this->st_dimensions), sizeof(double));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "shape_msgs/SolidPrimitive"; };
+ const char * getMD5(){ return "d8f8cbc74c5ff283fca29569ccefb45d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/smach_msgs/SmachContainerInitialStatusCmd.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,109 @@
+#ifndef _ROS_smach_msgs_SmachContainerInitialStatusCmd_h
+#define _ROS_smach_msgs_SmachContainerInitialStatusCmd_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace smach_msgs
+{
+
+ class SmachContainerInitialStatusCmd : public ros::Msg
+ {
+ public:
+ typedef const char* _path_type;
+ _path_type path;
+ uint32_t initial_states_length;
+ typedef char* _initial_states_type;
+ _initial_states_type st_initial_states;
+ _initial_states_type * initial_states;
+ typedef const char* _local_data_type;
+ _local_data_type local_data;
+
+ SmachContainerInitialStatusCmd():
+ path(""),
+ initial_states_length(0), initial_states(NULL),
+ local_data("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_path = strlen(this->path);
+ varToArr(outbuffer + offset, length_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->path, length_path);
+ offset += length_path;
+ *(outbuffer + offset + 0) = (this->initial_states_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->initial_states_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->initial_states_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->initial_states_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->initial_states_length);
+ for( uint32_t i = 0; i < initial_states_length; i++){
+ uint32_t length_initial_statesi = strlen(this->initial_states[i]);
+ varToArr(outbuffer + offset, length_initial_statesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->initial_states[i], length_initial_statesi);
+ offset += length_initial_statesi;
+ }
+ uint32_t length_local_data = strlen(this->local_data);
+ varToArr(outbuffer + offset, length_local_data);
+ offset += 4;
+ memcpy(outbuffer + offset, this->local_data, length_local_data);
+ offset += length_local_data;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_path;
+ arrToVar(length_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_path-1]=0;
+ this->path = (char *)(inbuffer + offset-1);
+ offset += length_path;
+ uint32_t initial_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->initial_states_length);
+ if(initial_states_lengthT > initial_states_length)
+ this->initial_states = (char**)realloc(this->initial_states, initial_states_lengthT * sizeof(char*));
+ initial_states_length = initial_states_lengthT;
+ for( uint32_t i = 0; i < initial_states_length; i++){
+ uint32_t length_st_initial_states;
+ arrToVar(length_st_initial_states, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_initial_states; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_initial_states-1]=0;
+ this->st_initial_states = (char *)(inbuffer + offset-1);
+ offset += length_st_initial_states;
+ memcpy( &(this->initial_states[i]), &(this->st_initial_states), sizeof(char*));
+ }
+ uint32_t length_local_data;
+ arrToVar(length_local_data, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_local_data; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_local_data-1]=0;
+ this->local_data = (char *)(inbuffer + offset-1);
+ offset += length_local_data;
+ return offset;
+ }
+
+ const char * getType(){ return "smach_msgs/SmachContainerInitialStatusCmd"; };
+ const char * getMD5(){ return "45f8cf31fc29b829db77f23001f788d6"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/smach_msgs/SmachContainerStatus.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,169 @@
+#ifndef _ROS_smach_msgs_SmachContainerStatus_h
+#define _ROS_smach_msgs_SmachContainerStatus_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace smach_msgs
+{
+
+ class SmachContainerStatus : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _path_type;
+ _path_type path;
+ uint32_t initial_states_length;
+ typedef char* _initial_states_type;
+ _initial_states_type st_initial_states;
+ _initial_states_type * initial_states;
+ uint32_t active_states_length;
+ typedef char* _active_states_type;
+ _active_states_type st_active_states;
+ _active_states_type * active_states;
+ typedef const char* _local_data_type;
+ _local_data_type local_data;
+ typedef const char* _info_type;
+ _info_type info;
+
+ SmachContainerStatus():
+ header(),
+ path(""),
+ initial_states_length(0), initial_states(NULL),
+ active_states_length(0), active_states(NULL),
+ local_data(""),
+ info("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_path = strlen(this->path);
+ varToArr(outbuffer + offset, length_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->path, length_path);
+ offset += length_path;
+ *(outbuffer + offset + 0) = (this->initial_states_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->initial_states_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->initial_states_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->initial_states_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->initial_states_length);
+ for( uint32_t i = 0; i < initial_states_length; i++){
+ uint32_t length_initial_statesi = strlen(this->initial_states[i]);
+ varToArr(outbuffer + offset, length_initial_statesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->initial_states[i], length_initial_statesi);
+ offset += length_initial_statesi;
+ }
+ *(outbuffer + offset + 0) = (this->active_states_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->active_states_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->active_states_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->active_states_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->active_states_length);
+ for( uint32_t i = 0; i < active_states_length; i++){
+ uint32_t length_active_statesi = strlen(this->active_states[i]);
+ varToArr(outbuffer + offset, length_active_statesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->active_states[i], length_active_statesi);
+ offset += length_active_statesi;
+ }
+ uint32_t length_local_data = strlen(this->local_data);
+ varToArr(outbuffer + offset, length_local_data);
+ offset += 4;
+ memcpy(outbuffer + offset, this->local_data, length_local_data);
+ offset += length_local_data;
+ uint32_t length_info = strlen(this->info);
+ varToArr(outbuffer + offset, length_info);
+ offset += 4;
+ memcpy(outbuffer + offset, this->info, length_info);
+ offset += length_info;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_path;
+ arrToVar(length_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_path-1]=0;
+ this->path = (char *)(inbuffer + offset-1);
+ offset += length_path;
+ uint32_t initial_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->initial_states_length);
+ if(initial_states_lengthT > initial_states_length)
+ this->initial_states = (char**)realloc(this->initial_states, initial_states_lengthT * sizeof(char*));
+ initial_states_length = initial_states_lengthT;
+ for( uint32_t i = 0; i < initial_states_length; i++){
+ uint32_t length_st_initial_states;
+ arrToVar(length_st_initial_states, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_initial_states; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_initial_states-1]=0;
+ this->st_initial_states = (char *)(inbuffer + offset-1);
+ offset += length_st_initial_states;
+ memcpy( &(this->initial_states[i]), &(this->st_initial_states), sizeof(char*));
+ }
+ uint32_t active_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->active_states_length);
+ if(active_states_lengthT > active_states_length)
+ this->active_states = (char**)realloc(this->active_states, active_states_lengthT * sizeof(char*));
+ active_states_length = active_states_lengthT;
+ for( uint32_t i = 0; i < active_states_length; i++){
+ uint32_t length_st_active_states;
+ arrToVar(length_st_active_states, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_active_states; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_active_states-1]=0;
+ this->st_active_states = (char *)(inbuffer + offset-1);
+ offset += length_st_active_states;
+ memcpy( &(this->active_states[i]), &(this->st_active_states), sizeof(char*));
+ }
+ uint32_t length_local_data;
+ arrToVar(length_local_data, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_local_data; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_local_data-1]=0;
+ this->local_data = (char *)(inbuffer + offset-1);
+ offset += length_local_data;
+ uint32_t length_info;
+ arrToVar(length_info, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_info; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_info-1]=0;
+ this->info = (char *)(inbuffer + offset-1);
+ offset += length_info;
+ return offset;
+ }
+
+ const char * getType(){ return "smach_msgs/SmachContainerStatus"; };
+ const char * getMD5(){ return "5ba2bb79ac19e3842d562a191f2a675b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/smach_msgs/SmachContainerStructure.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,246 @@
+#ifndef _ROS_smach_msgs_SmachContainerStructure_h
+#define _ROS_smach_msgs_SmachContainerStructure_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace smach_msgs
+{
+
+ class SmachContainerStructure : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _path_type;
+ _path_type path;
+ uint32_t children_length;
+ typedef char* _children_type;
+ _children_type st_children;
+ _children_type * children;
+ uint32_t internal_outcomes_length;
+ typedef char* _internal_outcomes_type;
+ _internal_outcomes_type st_internal_outcomes;
+ _internal_outcomes_type * internal_outcomes;
+ uint32_t outcomes_from_length;
+ typedef char* _outcomes_from_type;
+ _outcomes_from_type st_outcomes_from;
+ _outcomes_from_type * outcomes_from;
+ uint32_t outcomes_to_length;
+ typedef char* _outcomes_to_type;
+ _outcomes_to_type st_outcomes_to;
+ _outcomes_to_type * outcomes_to;
+ uint32_t container_outcomes_length;
+ typedef char* _container_outcomes_type;
+ _container_outcomes_type st_container_outcomes;
+ _container_outcomes_type * container_outcomes;
+
+ SmachContainerStructure():
+ header(),
+ path(""),
+ children_length(0), children(NULL),
+ internal_outcomes_length(0), internal_outcomes(NULL),
+ outcomes_from_length(0), outcomes_from(NULL),
+ outcomes_to_length(0), outcomes_to(NULL),
+ container_outcomes_length(0), container_outcomes(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_path = strlen(this->path);
+ varToArr(outbuffer + offset, length_path);
+ offset += 4;
+ memcpy(outbuffer + offset, this->path, length_path);
+ offset += length_path;
+ *(outbuffer + offset + 0) = (this->children_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->children_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->children_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->children_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->children_length);
+ for( uint32_t i = 0; i < children_length; i++){
+ uint32_t length_childreni = strlen(this->children[i]);
+ varToArr(outbuffer + offset, length_childreni);
+ offset += 4;
+ memcpy(outbuffer + offset, this->children[i], length_childreni);
+ offset += length_childreni;
+ }
+ *(outbuffer + offset + 0) = (this->internal_outcomes_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->internal_outcomes_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->internal_outcomes_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->internal_outcomes_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->internal_outcomes_length);
+ for( uint32_t i = 0; i < internal_outcomes_length; i++){
+ uint32_t length_internal_outcomesi = strlen(this->internal_outcomes[i]);
+ varToArr(outbuffer + offset, length_internal_outcomesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->internal_outcomes[i], length_internal_outcomesi);
+ offset += length_internal_outcomesi;
+ }
+ *(outbuffer + offset + 0) = (this->outcomes_from_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->outcomes_from_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->outcomes_from_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->outcomes_from_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->outcomes_from_length);
+ for( uint32_t i = 0; i < outcomes_from_length; i++){
+ uint32_t length_outcomes_fromi = strlen(this->outcomes_from[i]);
+ varToArr(outbuffer + offset, length_outcomes_fromi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->outcomes_from[i], length_outcomes_fromi);
+ offset += length_outcomes_fromi;
+ }
+ *(outbuffer + offset + 0) = (this->outcomes_to_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->outcomes_to_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->outcomes_to_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->outcomes_to_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->outcomes_to_length);
+ for( uint32_t i = 0; i < outcomes_to_length; i++){
+ uint32_t length_outcomes_toi = strlen(this->outcomes_to[i]);
+ varToArr(outbuffer + offset, length_outcomes_toi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->outcomes_to[i], length_outcomes_toi);
+ offset += length_outcomes_toi;
+ }
+ *(outbuffer + offset + 0) = (this->container_outcomes_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->container_outcomes_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->container_outcomes_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->container_outcomes_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->container_outcomes_length);
+ for( uint32_t i = 0; i < container_outcomes_length; i++){
+ uint32_t length_container_outcomesi = strlen(this->container_outcomes[i]);
+ varToArr(outbuffer + offset, length_container_outcomesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->container_outcomes[i], length_container_outcomesi);
+ offset += length_container_outcomesi;
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_path;
+ arrToVar(length_path, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_path; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_path-1]=0;
+ this->path = (char *)(inbuffer + offset-1);
+ offset += length_path;
+ uint32_t children_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ children_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ children_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ children_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->children_length);
+ if(children_lengthT > children_length)
+ this->children = (char**)realloc(this->children, children_lengthT * sizeof(char*));
+ children_length = children_lengthT;
+ for( uint32_t i = 0; i < children_length; i++){
+ uint32_t length_st_children;
+ arrToVar(length_st_children, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_children; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_children-1]=0;
+ this->st_children = (char *)(inbuffer + offset-1);
+ offset += length_st_children;
+ memcpy( &(this->children[i]), &(this->st_children), sizeof(char*));
+ }
+ uint32_t internal_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->internal_outcomes_length);
+ if(internal_outcomes_lengthT > internal_outcomes_length)
+ this->internal_outcomes = (char**)realloc(this->internal_outcomes, internal_outcomes_lengthT * sizeof(char*));
+ internal_outcomes_length = internal_outcomes_lengthT;
+ for( uint32_t i = 0; i < internal_outcomes_length; i++){
+ uint32_t length_st_internal_outcomes;
+ arrToVar(length_st_internal_outcomes, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_internal_outcomes; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_internal_outcomes-1]=0;
+ this->st_internal_outcomes = (char *)(inbuffer + offset-1);
+ offset += length_st_internal_outcomes;
+ memcpy( &(this->internal_outcomes[i]), &(this->st_internal_outcomes), sizeof(char*));
+ }
+ uint32_t outcomes_from_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->outcomes_from_length);
+ if(outcomes_from_lengthT > outcomes_from_length)
+ this->outcomes_from = (char**)realloc(this->outcomes_from, outcomes_from_lengthT * sizeof(char*));
+ outcomes_from_length = outcomes_from_lengthT;
+ for( uint32_t i = 0; i < outcomes_from_length; i++){
+ uint32_t length_st_outcomes_from;
+ arrToVar(length_st_outcomes_from, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_outcomes_from; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_outcomes_from-1]=0;
+ this->st_outcomes_from = (char *)(inbuffer + offset-1);
+ offset += length_st_outcomes_from;
+ memcpy( &(this->outcomes_from[i]), &(this->st_outcomes_from), sizeof(char*));
+ }
+ uint32_t outcomes_to_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->outcomes_to_length);
+ if(outcomes_to_lengthT > outcomes_to_length)
+ this->outcomes_to = (char**)realloc(this->outcomes_to, outcomes_to_lengthT * sizeof(char*));
+ outcomes_to_length = outcomes_to_lengthT;
+ for( uint32_t i = 0; i < outcomes_to_length; i++){
+ uint32_t length_st_outcomes_to;
+ arrToVar(length_st_outcomes_to, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_outcomes_to; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_outcomes_to-1]=0;
+ this->st_outcomes_to = (char *)(inbuffer + offset-1);
+ offset += length_st_outcomes_to;
+ memcpy( &(this->outcomes_to[i]), &(this->st_outcomes_to), sizeof(char*));
+ }
+ uint32_t container_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->container_outcomes_length);
+ if(container_outcomes_lengthT > container_outcomes_length)
+ this->container_outcomes = (char**)realloc(this->container_outcomes, container_outcomes_lengthT * sizeof(char*));
+ container_outcomes_length = container_outcomes_lengthT;
+ for( uint32_t i = 0; i < container_outcomes_length; i++){
+ uint32_t length_st_container_outcomes;
+ arrToVar(length_st_container_outcomes, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_container_outcomes; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_container_outcomes-1]=0;
+ this->st_container_outcomes = (char *)(inbuffer + offset-1);
+ offset += length_st_container_outcomes;
+ memcpy( &(this->container_outcomes[i]), &(this->st_container_outcomes), sizeof(char*));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "smach_msgs/SmachContainerStructure"; };
+ const char * getMD5(){ return "3d3d1e0d0f99779ee9e58101a5dcf7ea"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Bool.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_std_msgs_Bool_h
+#define _ROS_std_msgs_Bool_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Bool : public ros::Msg
+ {
+ public:
+ typedef bool _data_type;
+ _data_type data;
+
+ Bool():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Bool"; };
+ const char * getMD5(){ return "8b94c1b53db61fb6aed406028ad6332a"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Byte.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_std_msgs_Byte_h
+#define _ROS_std_msgs_Byte_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Byte : public ros::Msg
+ {
+ public:
+ typedef int8_t _data_type;
+ _data_type data;
+
+ Byte():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Byte"; };
+ const char * getMD5(){ return "ad736a2e8818154c487bb80fe42ce43b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/ByteMultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_std_msgs_ByteMultiArray_h
+#define _ROS_std_msgs_ByteMultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class ByteMultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef int8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ ByteMultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/ByteMultiArray"; };
+ const char * getMD5(){ return "70ea476cbcfd65ac2f68f3cda1e891fe"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Char.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,45 @@
+#ifndef _ROS_std_msgs_Char_h
+#define _ROS_std_msgs_Char_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Char : public ros::Msg
+ {
+ public:
+ typedef uint8_t _data_type;
+ _data_type data;
+
+ Char():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Char"; };
+ const char * getMD5(){ return "1bf77f25acecdedba0e224b162199717"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/ColorRGBA.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,134 @@
+#ifndef _ROS_std_msgs_ColorRGBA_h
+#define _ROS_std_msgs_ColorRGBA_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class ColorRGBA : public ros::Msg
+ {
+ public:
+ typedef float _r_type;
+ _r_type r;
+ typedef float _g_type;
+ _g_type g;
+ typedef float _b_type;
+ _b_type b;
+ typedef float _a_type;
+ _a_type a;
+
+ ColorRGBA():
+ r(0),
+ g(0),
+ b(0),
+ a(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_r;
+ u_r.real = this->r;
+ *(outbuffer + offset + 0) = (u_r.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_r.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_r.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_r.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->r);
+ union {
+ float real;
+ uint32_t base;
+ } u_g;
+ u_g.real = this->g;
+ *(outbuffer + offset + 0) = (u_g.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_g.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_g.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_g.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->g);
+ union {
+ float real;
+ uint32_t base;
+ } u_b;
+ u_b.real = this->b;
+ *(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->b);
+ union {
+ float real;
+ uint32_t base;
+ } u_a;
+ u_a.real = this->a;
+ *(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->a);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_r;
+ u_r.base = 0;
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_r.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->r = u_r.real;
+ offset += sizeof(this->r);
+ union {
+ float real;
+ uint32_t base;
+ } u_g;
+ u_g.base = 0;
+ u_g.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_g.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_g.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_g.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->g = u_g.real;
+ offset += sizeof(this->g);
+ union {
+ float real;
+ uint32_t base;
+ } u_b;
+ u_b.base = 0;
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_b.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->b = u_b.real;
+ offset += sizeof(this->b);
+ union {
+ float real;
+ uint32_t base;
+ } u_a;
+ u_a.base = 0;
+ u_a.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_a.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_a.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_a.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->a = u_a.real;
+ offset += sizeof(this->a);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/ColorRGBA"; };
+ const char * getMD5(){ return "a29a96539573343b1310c73607334b00"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Duration.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_std_msgs_Duration_h
+#define _ROS_std_msgs_Duration_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/duration.h"
+
+namespace std_msgs
+{
+
+ class Duration : public ros::Msg
+ {
+ public:
+ typedef ros::Duration _data_type;
+ _data_type data;
+
+ Duration():
+ data()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data.sec);
+ *(outbuffer + offset + 0) = (this->data.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->data.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->data.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->data.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->data.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data.sec);
+ this->data.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Duration"; };
+ const char * getMD5(){ return "3e286caf4241d664e55f3ad380e2ae46"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Empty.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_std_msgs_Empty_h
+#define _ROS_std_msgs_Empty_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Empty : public ros::Msg
+ {
+ public:
+
+ Empty()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Empty"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Float32.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_std_msgs_Float32_h
+#define _ROS_std_msgs_Float32_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Float32 : public ros::Msg
+ {
+ public:
+ typedef float _data_type;
+ _data_type data;
+
+ Float32():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Float32"; };
+ const char * getMD5(){ return "73fcbf46b49191e672908e50842a83d4"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Float32MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_std_msgs_Float32MultiArray_h
+#define _ROS_std_msgs_Float32MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class Float32MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef float _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Float32MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (float*)realloc(this->data, data_lengthT * sizeof(float));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ float real;
+ uint32_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(float));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Float32MultiArray"; };
+ const char * getMD5(){ return "6a40e0ffa6a17a503ac3f8616991b1f6"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Float64.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_std_msgs_Float64_h
+#define _ROS_std_msgs_Float64_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Float64 : public ros::Msg
+ {
+ public:
+ typedef double _data_type;
+ _data_type data;
+
+ Float64():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_data.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_data.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_data.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_data.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ double real;
+ uint64_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Float64"; };
+ const char * getMD5(){ return "fdb28210bfa9d7c91146260178d9a584"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Float64MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_std_msgs_Float64MultiArray_h
+#define _ROS_std_msgs_Float64MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class Float64MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef double _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Float64MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_datai.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_datai.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_datai.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_datai.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (double*)realloc(this->data, data_lengthT * sizeof(double));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(double));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Float64MultiArray"; };
+ const char * getMD5(){ return "4b7d974086d4060e7db4613a7e6c3ba4"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Header.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,92 @@
+#ifndef _ROS_std_msgs_Header_h
+#define _ROS_std_msgs_Header_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+
+namespace std_msgs
+{
+
+ class Header : public ros::Msg
+ {
+ public:
+ typedef uint32_t _seq_type;
+ _seq_type seq;
+ typedef ros::Time _stamp_type;
+ _stamp_type stamp;
+ typedef const char* _frame_id_type;
+ _frame_id_type frame_id;
+
+ Header():
+ seq(0),
+ stamp(),
+ frame_id("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->seq >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->seq >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->seq >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->seq >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->seq);
+ *(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp.sec);
+ *(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stamp.nsec);
+ uint32_t length_frame_id = strlen(this->frame_id);
+ varToArr(outbuffer + offset, length_frame_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->frame_id, length_frame_id);
+ offset += length_frame_id;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->seq = ((uint32_t) (*(inbuffer + offset)));
+ this->seq |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->seq |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->seq |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->seq);
+ this->stamp.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp.sec);
+ this->stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stamp.nsec);
+ uint32_t length_frame_id;
+ arrToVar(length_frame_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_frame_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_frame_id-1]=0;
+ this->frame_id = (char *)(inbuffer + offset-1);
+ offset += length_frame_id;
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Header"; };
+ const char * getMD5(){ return "2176decaecbce78abc3b96ef049fabed"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int16.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,58 @@
+#ifndef _ROS_std_msgs_Int16_h
+#define _ROS_std_msgs_Int16_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Int16 : public ros::Msg
+ {
+ public:
+ typedef int16_t _data_type;
+ _data_type data;
+
+ Int16():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_data.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int16"; };
+ const char * getMD5(){ return "8524586e34fbd7cb1c08c5f5f1ca0e57"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int16MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,84 @@
+#ifndef _ROS_std_msgs_Int16MultiArray_h
+#define _ROS_std_msgs_Int16MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class Int16MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef int16_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Int16MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (int16_t*)realloc(this->data, data_lengthT * sizeof(int16_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int16_t real;
+ uint16_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(int16_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int16MultiArray"; };
+ const char * getMD5(){ return "d9338d7f523fcb692fae9d0a0e9f067c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int32.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_std_msgs_Int32_h
+#define _ROS_std_msgs_Int32_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Int32 : public ros::Msg
+ {
+ public:
+ typedef int32_t _data_type;
+ _data_type data;
+
+ Int32():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int32"; };
+ const char * getMD5(){ return "da5909fbe378aeaf85e547e830cc1bb7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int32MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_std_msgs_Int32MultiArray_h
+#define _ROS_std_msgs_Int32MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class Int32MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef int32_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Int32MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (int32_t*)realloc(this->data, data_lengthT * sizeof(int32_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(int32_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int32MultiArray"; };
+ const char * getMD5(){ return "1d99f79f8b325b44fee908053e9c945b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int64.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_std_msgs_Int64_h
+#define _ROS_std_msgs_Int64_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Int64 : public ros::Msg
+ {
+ public:
+ typedef int64_t _data_type;
+ _data_type data;
+
+ Int64():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_data.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_data.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_data.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_data.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int64"; };
+ const char * getMD5(){ return "34add168574510e6e17f5d23ecc077ef"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int64MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,96 @@
+#ifndef _ROS_std_msgs_Int64MultiArray_h
+#define _ROS_std_msgs_Int64MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class Int64MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef int64_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Int64MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_datai.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_datai.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_datai.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_datai.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (int64_t*)realloc(this->data, data_lengthT * sizeof(int64_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(int64_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int64MultiArray"; };
+ const char * getMD5(){ return "54865aa6c65be0448113a2afc6a49270"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int8.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_std_msgs_Int8_h
+#define _ROS_std_msgs_Int8_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class Int8 : public ros::Msg
+ {
+ public:
+ typedef int8_t _data_type;
+ _data_type data;
+
+ Int8():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int8"; };
+ const char * getMD5(){ return "27ffa0c9c4b8fb8492252bcad9e5c57b"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Int8MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,82 @@
+#ifndef _ROS_std_msgs_Int8MultiArray_h
+#define _ROS_std_msgs_Int8MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class Int8MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef int8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ Int8MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ int8_t real;
+ uint8_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Int8MultiArray"; };
+ const char * getMD5(){ return "d7c1af35a1b4781bbe79e03dd94b7c13"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/MultiArrayDimension.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,81 @@
+#ifndef _ROS_std_msgs_MultiArrayDimension_h
+#define _ROS_std_msgs_MultiArrayDimension_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class MultiArrayDimension : public ros::Msg
+ {
+ public:
+ typedef const char* _label_type;
+ _label_type label;
+ typedef uint32_t _size_type;
+ _size_type size;
+ typedef uint32_t _stride_type;
+ _stride_type stride;
+
+ MultiArrayDimension():
+ label(""),
+ size(0),
+ stride(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_label = strlen(this->label);
+ varToArr(outbuffer + offset, length_label);
+ offset += 4;
+ memcpy(outbuffer + offset, this->label, length_label);
+ offset += length_label;
+ *(outbuffer + offset + 0) = (this->size >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->size >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->size >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->size >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->size);
+ *(outbuffer + offset + 0) = (this->stride >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->stride >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->stride >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->stride >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->stride);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_label;
+ arrToVar(length_label, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_label; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_label-1]=0;
+ this->label = (char *)(inbuffer + offset-1);
+ offset += length_label;
+ this->size = ((uint32_t) (*(inbuffer + offset)));
+ this->size |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->size |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->size |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->size);
+ this->stride = ((uint32_t) (*(inbuffer + offset)));
+ this->stride |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->stride |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->stride |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->stride);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/MultiArrayDimension"; };
+ const char * getMD5(){ return "4cd0c83a8683deae40ecdac60e53bfa8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/MultiArrayLayout.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,77 @@
+#ifndef _ROS_std_msgs_MultiArrayLayout_h
+#define _ROS_std_msgs_MultiArrayLayout_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayDimension.h"
+
+namespace std_msgs
+{
+
+ class MultiArrayLayout : public ros::Msg
+ {
+ public:
+ uint32_t dim_length;
+ typedef std_msgs::MultiArrayDimension _dim_type;
+ _dim_type st_dim;
+ _dim_type * dim;
+ typedef uint32_t _data_offset_type;
+ _data_offset_type data_offset;
+
+ MultiArrayLayout():
+ dim_length(0), dim(NULL),
+ data_offset(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->dim_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->dim_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->dim_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->dim_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->dim_length);
+ for( uint32_t i = 0; i < dim_length; i++){
+ offset += this->dim[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->data_offset >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_offset >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_offset >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_offset >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t dim_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->dim_length);
+ if(dim_lengthT > dim_length)
+ this->dim = (std_msgs::MultiArrayDimension*)realloc(this->dim, dim_lengthT * sizeof(std_msgs::MultiArrayDimension));
+ dim_length = dim_lengthT;
+ for( uint32_t i = 0; i < dim_length; i++){
+ offset += this->st_dim.deserialize(inbuffer + offset);
+ memcpy( &(this->dim[i]), &(this->st_dim), sizeof(std_msgs::MultiArrayDimension));
+ }
+ this->data_offset = ((uint32_t) (*(inbuffer + offset)));
+ this->data_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->data_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->data_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_offset);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/MultiArrayLayout"; };
+ const char * getMD5(){ return "0fed2a11c13e11c5571b4e2a995a91a3"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/String.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,55 @@
+#ifndef _ROS_std_msgs_String_h
+#define _ROS_std_msgs_String_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class String : public ros::Msg
+ {
+ public:
+ typedef const char* _data_type;
+ _data_type data;
+
+ String():
+ data("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_data = strlen(this->data);
+ varToArr(outbuffer + offset, length_data);
+ offset += 4;
+ memcpy(outbuffer + offset, this->data, length_data);
+ offset += length_data;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_data;
+ arrToVar(length_data, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_data; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_data-1]=0;
+ this->data = (char *)(inbuffer + offset-1);
+ offset += length_data;
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/String"; };
+ const char * getMD5(){ return "992ce8a1687cec8c8bd883ec73ca41d1"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/Time.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_std_msgs_Time_h
+#define _ROS_std_msgs_Time_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+
+namespace std_msgs
+{
+
+ class Time : public ros::Msg
+ {
+ public:
+ typedef ros::Time _data_type;
+ _data_type data;
+
+ Time():
+ data()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data.sec);
+ *(outbuffer + offset + 0) = (this->data.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->data.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->data.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->data.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->data.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data.sec);
+ this->data.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/Time"; };
+ const char * getMD5(){ return "cd7166c74c552c311fbcc2fe5a7bc289"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt16.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,47 @@
+#ifndef _ROS_std_msgs_UInt16_h
+#define _ROS_std_msgs_UInt16_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class UInt16 : public ros::Msg
+ {
+ public:
+ typedef uint16_t _data_type;
+ _data_type data;
+
+ UInt16():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->data = ((uint16_t) (*(inbuffer + offset)));
+ this->data |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt16"; };
+ const char * getMD5(){ return "1df79edf208b629fe6b81923a544552d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt16MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,73 @@
+#ifndef _ROS_std_msgs_UInt16MultiArray_h
+#define _ROS_std_msgs_UInt16MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class UInt16MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef uint16_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ UInt16MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint16_t*)realloc(this->data, data_lengthT * sizeof(uint16_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint16_t) (*(inbuffer + offset)));
+ this->st_data |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint16_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt16MultiArray"; };
+ const char * getMD5(){ return "52f264f1c973c4b73790d384c6cb4484"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt32.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,51 @@
+#ifndef _ROS_std_msgs_UInt32_h
+#define _ROS_std_msgs_UInt32_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class UInt32 : public ros::Msg
+ {
+ public:
+ typedef uint32_t _data_type;
+ _data_type data;
+
+ UInt32():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->data = ((uint32_t) (*(inbuffer + offset)));
+ this->data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt32"; };
+ const char * getMD5(){ return "304a39449588c7f8ce2df6e8001c5fce"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt32MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,77 @@
+#ifndef _ROS_std_msgs_UInt32MultiArray_h
+#define _ROS_std_msgs_UInt32MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class UInt32MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef uint32_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ UInt32MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data[i] >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data[i] >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint32_t*)realloc(this->data, data_lengthT * sizeof(uint32_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint32_t) (*(inbuffer + offset)));
+ this->st_data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->st_data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->st_data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint32_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt32MultiArray"; };
+ const char * getMD5(){ return "4d6a180abc9be191b96a7eda6c8a233d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt64.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,62 @@
+#ifndef _ROS_std_msgs_UInt64_h
+#define _ROS_std_msgs_UInt64_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class UInt64 : public ros::Msg
+ {
+ public:
+ typedef uint64_t _data_type;
+ _data_type data;
+
+ UInt64():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt64"; };
+ const char * getMD5(){ return "1b2a79973e8bf53d7b53acb71299cb57"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt64MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,88 @@
+#ifndef _ROS_std_msgs_UInt64MultiArray_h
+#define _ROS_std_msgs_UInt64MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class UInt64MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef uint64_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ UInt64MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_datai;
+ u_datai.real = this->data[i];
+ *(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint64_t*)realloc(this->data, data_lengthT * sizeof(uint64_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_st_data;
+ u_st_data.base = 0;
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->st_data = u_st_data.real;
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint64_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt64MultiArray"; };
+ const char * getMD5(){ return "6088f127afb1d6c72927aa1247e945af"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt8.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,45 @@
+#ifndef _ROS_std_msgs_UInt8_h
+#define _ROS_std_msgs_UInt8_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_msgs
+{
+
+ class UInt8 : public ros::Msg
+ {
+ public:
+ typedef uint8_t _data_type;
+ _data_type data;
+
+ UInt8():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt8"; };
+ const char * getMD5(){ return "7c8164229e7d2c17eb95e9231617fdee"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_msgs/UInt8MultiArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,71 @@
+#ifndef _ROS_std_msgs_UInt8MultiArray_h
+#define _ROS_std_msgs_UInt8MultiArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/MultiArrayLayout.h"
+
+namespace std_msgs
+{
+
+ class UInt8MultiArray : public ros::Msg
+ {
+ public:
+ typedef std_msgs::MultiArrayLayout _layout_type;
+ _layout_type layout;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+
+ UInt8MultiArray():
+ layout(),
+ data_length(0), data(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->layout.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->layout.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "std_msgs/UInt8MultiArray"; };
+ const char * getMD5(){ return "82373f1612381bb6ee473b5cd6f5d89c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_srvs/Empty.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+#ifndef _ROS_SERVICE_Empty_h
+#define _ROS_SERVICE_Empty_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_srvs
+{
+
+static const char EMPTY[] = "std_srvs/Empty";
+
+ class EmptyRequest : public ros::Msg
+ {
+ public:
+
+ EmptyRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return EMPTY; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class EmptyResponse : public ros::Msg
+ {
+ public:
+
+ EmptyResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return EMPTY; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class Empty {
+ public:
+ typedef EmptyRequest Request;
+ typedef EmptyResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_srvs/SetBool.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,123 @@
+#ifndef _ROS_SERVICE_SetBool_h
+#define _ROS_SERVICE_SetBool_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_srvs
+{
+
+static const char SETBOOL[] = "std_srvs/SetBool";
+
+ class SetBoolRequest : public ros::Msg
+ {
+ public:
+ typedef bool _data_type;
+ _data_type data;
+
+ SetBoolRequest():
+ data(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_data;
+ u_data.real = this->data;
+ *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_data;
+ u_data.base = 0;
+ u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->data = u_data.real;
+ offset += sizeof(this->data);
+ return offset;
+ }
+
+ const char * getType(){ return SETBOOL; };
+ const char * getMD5(){ return "8b94c1b53db61fb6aed406028ad6332a"; };
+
+ };
+
+ class SetBoolResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _message_type;
+ _message_type message;
+
+ SetBoolResponse():
+ success(0),
+ message("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_message = strlen(this->message);
+ varToArr(outbuffer + offset, length_message);
+ offset += 4;
+ memcpy(outbuffer + offset, this->message, length_message);
+ offset += length_message;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_message;
+ arrToVar(length_message, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_message; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_message-1]=0;
+ this->message = (char *)(inbuffer + offset-1);
+ offset += length_message;
+ return offset;
+ }
+
+ const char * getType(){ return SETBOOL; };
+ const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
+
+ };
+
+ class SetBool {
+ public:
+ typedef SetBoolRequest Request;
+ typedef SetBoolResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/std_srvs/Trigger.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,105 @@
+#ifndef _ROS_SERVICE_Trigger_h
+#define _ROS_SERVICE_Trigger_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace std_srvs
+{
+
+static const char TRIGGER[] = "std_srvs/Trigger";
+
+ class TriggerRequest : public ros::Msg
+ {
+ public:
+
+ TriggerRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return TRIGGER; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class TriggerResponse : public ros::Msg
+ {
+ public:
+ typedef bool _success_type;
+ _success_type success;
+ typedef const char* _message_type;
+ _message_type message;
+
+ TriggerResponse():
+ success(0),
+ message("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.real = this->success;
+ *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->success);
+ uint32_t length_message = strlen(this->message);
+ varToArr(outbuffer + offset, length_message);
+ offset += 4;
+ memcpy(outbuffer + offset, this->message, length_message);
+ offset += length_message;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ bool real;
+ uint8_t base;
+ } u_success;
+ u_success.base = 0;
+ u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->success = u_success.real;
+ offset += sizeof(this->success);
+ uint32_t length_message;
+ arrToVar(length_message, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_message; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_message-1]=0;
+ this->message = (char *)(inbuffer + offset-1);
+ offset += length_message;
+ return offset;
+ }
+
+ const char * getType(){ return TRIGGER; };
+ const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
+
+ };
+
+ class Trigger {
+ public:
+ typedef TriggerRequest Request;
+ typedef TriggerResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/stereo_msgs/DisparityImage.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,176 @@
+#ifndef _ROS_stereo_msgs_DisparityImage_h
+#define _ROS_stereo_msgs_DisparityImage_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "sensor_msgs/Image.h"
+#include "sensor_msgs/RegionOfInterest.h"
+
+namespace stereo_msgs
+{
+
+ class DisparityImage : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef sensor_msgs::Image _image_type;
+ _image_type image;
+ typedef float _f_type;
+ _f_type f;
+ typedef float _T_type;
+ _T_type T;
+ typedef sensor_msgs::RegionOfInterest _valid_window_type;
+ _valid_window_type valid_window;
+ typedef float _min_disparity_type;
+ _min_disparity_type min_disparity;
+ typedef float _max_disparity_type;
+ _max_disparity_type max_disparity;
+ typedef float _delta_d_type;
+ _delta_d_type delta_d;
+
+ DisparityImage():
+ header(),
+ image(),
+ f(0),
+ T(0),
+ valid_window(),
+ min_disparity(0),
+ max_disparity(0),
+ delta_d(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->image.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_f;
+ u_f.real = this->f;
+ *(outbuffer + offset + 0) = (u_f.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_f.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_f.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_f.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->f);
+ union {
+ float real;
+ uint32_t base;
+ } u_T;
+ u_T.real = this->T;
+ *(outbuffer + offset + 0) = (u_T.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_T.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_T.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_T.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->T);
+ offset += this->valid_window.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_min_disparity;
+ u_min_disparity.real = this->min_disparity;
+ *(outbuffer + offset + 0) = (u_min_disparity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_min_disparity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_min_disparity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_min_disparity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->min_disparity);
+ union {
+ float real;
+ uint32_t base;
+ } u_max_disparity;
+ u_max_disparity.real = this->max_disparity;
+ *(outbuffer + offset + 0) = (u_max_disparity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_max_disparity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_max_disparity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_max_disparity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->max_disparity);
+ union {
+ float real;
+ uint32_t base;
+ } u_delta_d;
+ u_delta_d.real = this->delta_d;
+ *(outbuffer + offset + 0) = (u_delta_d.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_delta_d.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_delta_d.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_delta_d.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->delta_d);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->image.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_f;
+ u_f.base = 0;
+ u_f.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_f.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_f.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_f.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->f = u_f.real;
+ offset += sizeof(this->f);
+ union {
+ float real;
+ uint32_t base;
+ } u_T;
+ u_T.base = 0;
+ u_T.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_T.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_T.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_T.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->T = u_T.real;
+ offset += sizeof(this->T);
+ offset += this->valid_window.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_min_disparity;
+ u_min_disparity.base = 0;
+ u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->min_disparity = u_min_disparity.real;
+ offset += sizeof(this->min_disparity);
+ union {
+ float real;
+ uint32_t base;
+ } u_max_disparity;
+ u_max_disparity.base = 0;
+ u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->max_disparity = u_max_disparity.real;
+ offset += sizeof(this->max_disparity);
+ union {
+ float real;
+ uint32_t base;
+ } u_delta_d;
+ u_delta_d.base = 0;
+ u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->delta_d = u_delta_d.real;
+ offset += sizeof(this->delta_d);
+ return offset;
+ }
+
+ const char * getType(){ return "stereo_msgs/DisparityImage"; };
+ const char * getMD5(){ return "04a177815f75271039fa21f16acad8c9"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf/FrameGraph.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_SERVICE_FrameGraph_h
+#define _ROS_SERVICE_FrameGraph_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace tf
+{
+
+static const char FRAMEGRAPH[] = "tf/FrameGraph";
+
+ class FrameGraphRequest : public ros::Msg
+ {
+ public:
+
+ FrameGraphRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return FRAMEGRAPH; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class FrameGraphResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _dot_graph_type;
+ _dot_graph_type dot_graph;
+
+ FrameGraphResponse():
+ dot_graph("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_dot_graph = strlen(this->dot_graph);
+ varToArr(outbuffer + offset, length_dot_graph);
+ offset += 4;
+ memcpy(outbuffer + offset, this->dot_graph, length_dot_graph);
+ offset += length_dot_graph;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_dot_graph;
+ arrToVar(length_dot_graph, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_dot_graph; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_dot_graph-1]=0;
+ this->dot_graph = (char *)(inbuffer + offset-1);
+ offset += length_dot_graph;
+ return offset;
+ }
+
+ const char * getType(){ return FRAMEGRAPH; };
+ const char * getMD5(){ return "c4af9ac907e58e906eb0b6e3c58478c0"; };
+
+ };
+
+ class FrameGraph {
+ public:
+ typedef FrameGraphRequest Request;
+ typedef FrameGraphResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf/tf.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROS_TF_H_
+#define ROS_TF_H_
+
+#include "geometry_msgs/TransformStamped.h"
+
+namespace tf
+{
+
+static inline geometry_msgs::Quaternion createQuaternionFromYaw(double yaw)
+{
+ geometry_msgs::Quaternion q;
+ q.x = 0;
+ q.y = 0;
+ q.z = sin(yaw * 0.5);
+ q.w = cos(yaw * 0.5);
+ return q;
+}
+
+}
+
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf/tfMessage.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,64 @@
+#ifndef _ROS_tf_tfMessage_h
+#define _ROS_tf_tfMessage_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/TransformStamped.h"
+
+namespace tf
+{
+
+ class tfMessage : public ros::Msg
+ {
+ public:
+ uint32_t transforms_length;
+ typedef geometry_msgs::TransformStamped _transforms_type;
+ _transforms_type st_transforms;
+ _transforms_type * transforms;
+
+ tfMessage():
+ transforms_length(0), transforms(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->transforms_length);
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->transforms[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->transforms_length);
+ if(transforms_lengthT > transforms_length)
+ this->transforms = (geometry_msgs::TransformStamped*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
+ transforms_length = transforms_lengthT;
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->st_transforms.deserialize(inbuffer + offset);
+ memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::TransformStamped));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "tf/tfMessage"; };
+ const char * getMD5(){ return "94810edda583a504dfda3829e70d7eec"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf/transform_broadcaster.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,69 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROS_TRANSFORM_BROADCASTER_H_
+#define ROS_TRANSFORM_BROADCASTER_H_
+
+#include "ros.h"
+#include "tfMessage.h"
+
+namespace tf
+{
+
+class TransformBroadcaster
+{
+public:
+ TransformBroadcaster() : publisher_("/tf", &internal_msg) {}
+
+ void init(ros::NodeHandle &nh)
+ {
+ nh.advertise(publisher_);
+ }
+
+ void sendTransform(geometry_msgs::TransformStamped &transform)
+ {
+ internal_msg.transforms_length = 1;
+ internal_msg.transforms = &transform;
+ publisher_.publish(&internal_msg);
+ }
+
+private:
+ tf::tfMessage internal_msg;
+ ros::Publisher publisher_;
+};
+
+}
+
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/FrameGraph.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_SERVICE_FrameGraph_h
+#define _ROS_SERVICE_FrameGraph_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace tf2_msgs
+{
+
+static const char FRAMEGRAPH[] = "tf2_msgs/FrameGraph";
+
+ class FrameGraphRequest : public ros::Msg
+ {
+ public:
+
+ FrameGraphRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return FRAMEGRAPH; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class FrameGraphResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _frame_yaml_type;
+ _frame_yaml_type frame_yaml;
+
+ FrameGraphResponse():
+ frame_yaml("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_frame_yaml = strlen(this->frame_yaml);
+ varToArr(outbuffer + offset, length_frame_yaml);
+ offset += 4;
+ memcpy(outbuffer + offset, this->frame_yaml, length_frame_yaml);
+ offset += length_frame_yaml;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_frame_yaml;
+ arrToVar(length_frame_yaml, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_frame_yaml; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_frame_yaml-1]=0;
+ this->frame_yaml = (char *)(inbuffer + offset-1);
+ offset += length_frame_yaml;
+ return offset;
+ }
+
+ const char * getType(){ return FRAMEGRAPH; };
+ const char * getMD5(){ return "437ea58e9463815a0d511c7326b686b0"; };
+
+ };
+
+ class FrameGraph {
+ public:
+ typedef FrameGraphRequest Request;
+ typedef FrameGraphResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/LookupTransformAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_tf2_msgs_LookupTransformAction_h
+#define _ROS_tf2_msgs_LookupTransformAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "tf2_msgs/LookupTransformActionGoal.h"
+#include "tf2_msgs/LookupTransformActionResult.h"
+#include "tf2_msgs/LookupTransformActionFeedback.h"
+
+namespace tf2_msgs
+{
+
+ class LookupTransformAction : public ros::Msg
+ {
+ public:
+ typedef tf2_msgs::LookupTransformActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef tf2_msgs::LookupTransformActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef tf2_msgs::LookupTransformActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ LookupTransformAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/LookupTransformAction"; };
+ const char * getMD5(){ return "7ee01ba91a56c2245c610992dbaa3c37"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/LookupTransformActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_tf2_msgs_LookupTransformActionFeedback_h
+#define _ROS_tf2_msgs_LookupTransformActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "tf2_msgs/LookupTransformFeedback.h"
+
+namespace tf2_msgs
+{
+
+ class LookupTransformActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef tf2_msgs::LookupTransformFeedback _feedback_type;
+ _feedback_type feedback;
+
+ LookupTransformActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/LookupTransformActionFeedback"; };
+ const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/LookupTransformActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_tf2_msgs_LookupTransformActionGoal_h
+#define _ROS_tf2_msgs_LookupTransformActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "tf2_msgs/LookupTransformGoal.h"
+
+namespace tf2_msgs
+{
+
+ class LookupTransformActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef tf2_msgs::LookupTransformGoal _goal_type;
+ _goal_type goal;
+
+ LookupTransformActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/LookupTransformActionGoal"; };
+ const char * getMD5(){ return "f2e7bcdb75c847978d0351a13e699da5"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/LookupTransformActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_tf2_msgs_LookupTransformActionResult_h
+#define _ROS_tf2_msgs_LookupTransformActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "tf2_msgs/LookupTransformResult.h"
+
+namespace tf2_msgs
+{
+
+ class LookupTransformActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef tf2_msgs::LookupTransformResult _result_type;
+ _result_type result;
+
+ LookupTransformActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/LookupTransformActionResult"; };
+ const char * getMD5(){ return "ac26ce75a41384fa8bb4dc10f491ab90"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/LookupTransformFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_tf2_msgs_LookupTransformFeedback_h
+#define _ROS_tf2_msgs_LookupTransformFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace tf2_msgs
+{
+
+ class LookupTransformFeedback : public ros::Msg
+ {
+ public:
+
+ LookupTransformFeedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/LookupTransformFeedback"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/LookupTransformGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,178 @@
+#ifndef _ROS_tf2_msgs_LookupTransformGoal_h
+#define _ROS_tf2_msgs_LookupTransformGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/time.h"
+#include "ros/duration.h"
+
+namespace tf2_msgs
+{
+
+ class LookupTransformGoal : public ros::Msg
+ {
+ public:
+ typedef const char* _target_frame_type;
+ _target_frame_type target_frame;
+ typedef const char* _source_frame_type;
+ _source_frame_type source_frame;
+ typedef ros::Time _source_time_type;
+ _source_time_type source_time;
+ typedef ros::Duration _timeout_type;
+ _timeout_type timeout;
+ typedef ros::Time _target_time_type;
+ _target_time_type target_time;
+ typedef const char* _fixed_frame_type;
+ _fixed_frame_type fixed_frame;
+ typedef bool _advanced_type;
+ _advanced_type advanced;
+
+ LookupTransformGoal():
+ target_frame(""),
+ source_frame(""),
+ source_time(),
+ timeout(),
+ target_time(),
+ fixed_frame(""),
+ advanced(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_target_frame = strlen(this->target_frame);
+ varToArr(outbuffer + offset, length_target_frame);
+ offset += 4;
+ memcpy(outbuffer + offset, this->target_frame, length_target_frame);
+ offset += length_target_frame;
+ uint32_t length_source_frame = strlen(this->source_frame);
+ varToArr(outbuffer + offset, length_source_frame);
+ offset += 4;
+ memcpy(outbuffer + offset, this->source_frame, length_source_frame);
+ offset += length_source_frame;
+ *(outbuffer + offset + 0) = (this->source_time.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->source_time.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->source_time.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->source_time.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->source_time.sec);
+ *(outbuffer + offset + 0) = (this->source_time.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->source_time.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->source_time.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->source_time.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->source_time.nsec);
+ *(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->timeout.sec);
+ *(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->timeout.nsec);
+ *(outbuffer + offset + 0) = (this->target_time.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->target_time.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->target_time.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->target_time.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->target_time.sec);
+ *(outbuffer + offset + 0) = (this->target_time.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->target_time.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->target_time.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->target_time.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->target_time.nsec);
+ uint32_t length_fixed_frame = strlen(this->fixed_frame);
+ varToArr(outbuffer + offset, length_fixed_frame);
+ offset += 4;
+ memcpy(outbuffer + offset, this->fixed_frame, length_fixed_frame);
+ offset += length_fixed_frame;
+ union {
+ bool real;
+ uint8_t base;
+ } u_advanced;
+ u_advanced.real = this->advanced;
+ *(outbuffer + offset + 0) = (u_advanced.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->advanced);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_target_frame;
+ arrToVar(length_target_frame, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_target_frame; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_target_frame-1]=0;
+ this->target_frame = (char *)(inbuffer + offset-1);
+ offset += length_target_frame;
+ uint32_t length_source_frame;
+ arrToVar(length_source_frame, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_source_frame; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_source_frame-1]=0;
+ this->source_frame = (char *)(inbuffer + offset-1);
+ offset += length_source_frame;
+ this->source_time.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->source_time.sec);
+ this->source_time.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->source_time.nsec);
+ this->timeout.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->timeout.sec);
+ this->timeout.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->timeout.nsec);
+ this->target_time.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->target_time.sec);
+ this->target_time.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->target_time.nsec);
+ uint32_t length_fixed_frame;
+ arrToVar(length_fixed_frame, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_fixed_frame; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_fixed_frame-1]=0;
+ this->fixed_frame = (char *)(inbuffer + offset-1);
+ offset += length_fixed_frame;
+ union {
+ bool real;
+ uint8_t base;
+ } u_advanced;
+ u_advanced.base = 0;
+ u_advanced.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->advanced = u_advanced.real;
+ offset += sizeof(this->advanced);
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/LookupTransformGoal"; };
+ const char * getMD5(){ return "35e3720468131d675a18bb6f3e5f22f8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/LookupTransformResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,50 @@
+#ifndef _ROS_tf2_msgs_LookupTransformResult_h
+#define _ROS_tf2_msgs_LookupTransformResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/TransformStamped.h"
+#include "tf2_msgs/TF2Error.h"
+
+namespace tf2_msgs
+{
+
+ class LookupTransformResult : public ros::Msg
+ {
+ public:
+ typedef geometry_msgs::TransformStamped _transform_type;
+ _transform_type transform;
+ typedef tf2_msgs::TF2Error _error_type;
+ _error_type error;
+
+ LookupTransformResult():
+ transform(),
+ error()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->transform.serialize(outbuffer + offset);
+ offset += this->error.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->transform.deserialize(inbuffer + offset);
+ offset += this->error.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/LookupTransformResult"; };
+ const char * getMD5(){ return "3fe5db6a19ca9cfb675418c5ad875c36"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/TF2Error.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,69 @@
+#ifndef _ROS_tf2_msgs_TF2Error_h
+#define _ROS_tf2_msgs_TF2Error_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace tf2_msgs
+{
+
+ class TF2Error : public ros::Msg
+ {
+ public:
+ typedef uint8_t _error_type;
+ _error_type error;
+ typedef const char* _error_string_type;
+ _error_string_type error_string;
+ enum { NO_ERROR = 0 };
+ enum { LOOKUP_ERROR = 1 };
+ enum { CONNECTIVITY_ERROR = 2 };
+ enum { EXTRAPOLATION_ERROR = 3 };
+ enum { INVALID_ARGUMENT_ERROR = 4 };
+ enum { TIMEOUT_ERROR = 5 };
+ enum { TRANSFORM_ERROR = 6 };
+
+ TF2Error():
+ error(0),
+ error_string("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->error >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->error);
+ uint32_t length_error_string = strlen(this->error_string);
+ varToArr(outbuffer + offset, length_error_string);
+ offset += 4;
+ memcpy(outbuffer + offset, this->error_string, length_error_string);
+ offset += length_error_string;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->error = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->error);
+ uint32_t length_error_string;
+ arrToVar(length_error_string, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_error_string; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_error_string-1]=0;
+ this->error_string = (char *)(inbuffer + offset-1);
+ offset += length_error_string;
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/TF2Error"; };
+ const char * getMD5(){ return "bc6848fd6fd750c92e38575618a4917d"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/tf2_msgs/TFMessage.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,64 @@
+#ifndef _ROS_tf2_msgs_TFMessage_h
+#define _ROS_tf2_msgs_TFMessage_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/TransformStamped.h"
+
+namespace tf2_msgs
+{
+
+ class TFMessage : public ros::Msg
+ {
+ public:
+ uint32_t transforms_length;
+ typedef geometry_msgs::TransformStamped _transforms_type;
+ _transforms_type st_transforms;
+ _transforms_type * transforms;
+
+ TFMessage():
+ transforms_length(0), transforms(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->transforms_length);
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->transforms[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->transforms_length);
+ if(transforms_lengthT > transforms_length)
+ this->transforms = (geometry_msgs::TransformStamped*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
+ transforms_length = transforms_lengthT;
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->st_transforms.deserialize(inbuffer + offset);
+ memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::TransformStamped));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "tf2_msgs/TFMessage"; };
+ const char * getMD5(){ return "94810edda583a504dfda3829e70d7eec"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/theora_image_transport/Packet.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,183 @@
+#ifndef _ROS_theora_image_transport_Packet_h
+#define _ROS_theora_image_transport_Packet_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+
+namespace theora_image_transport
+{
+
+ class Packet : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t data_length;
+ typedef uint8_t _data_type;
+ _data_type st_data;
+ _data_type * data;
+ typedef int32_t _b_o_s_type;
+ _b_o_s_type b_o_s;
+ typedef int32_t _e_o_s_type;
+ _e_o_s_type e_o_s;
+ typedef int64_t _granulepos_type;
+ _granulepos_type granulepos;
+ typedef int64_t _packetno_type;
+ _packetno_type packetno;
+
+ Packet():
+ header(),
+ data_length(0), data(NULL),
+ b_o_s(0),
+ e_o_s(0),
+ granulepos(0),
+ packetno(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->data_length);
+ for( uint32_t i = 0; i < data_length; i++){
+ *(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->data[i]);
+ }
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_b_o_s;
+ u_b_o_s.real = this->b_o_s;
+ *(outbuffer + offset + 0) = (u_b_o_s.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_b_o_s.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_b_o_s.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_b_o_s.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->b_o_s);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_e_o_s;
+ u_e_o_s.real = this->e_o_s;
+ *(outbuffer + offset + 0) = (u_e_o_s.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_e_o_s.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_e_o_s.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_e_o_s.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->e_o_s);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_granulepos;
+ u_granulepos.real = this->granulepos;
+ *(outbuffer + offset + 0) = (u_granulepos.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_granulepos.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_granulepos.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_granulepos.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_granulepos.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_granulepos.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_granulepos.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_granulepos.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->granulepos);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_packetno;
+ u_packetno.real = this->packetno;
+ *(outbuffer + offset + 0) = (u_packetno.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_packetno.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_packetno.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_packetno.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_packetno.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_packetno.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_packetno.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_packetno.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->packetno);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->data_length);
+ if(data_lengthT > data_length)
+ this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
+ data_length = data_lengthT;
+ for( uint32_t i = 0; i < data_length; i++){
+ this->st_data = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->st_data);
+ memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
+ }
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_b_o_s;
+ u_b_o_s.base = 0;
+ u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->b_o_s = u_b_o_s.real;
+ offset += sizeof(this->b_o_s);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_e_o_s;
+ u_e_o_s.base = 0;
+ u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->e_o_s = u_e_o_s.real;
+ offset += sizeof(this->e_o_s);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_granulepos;
+ u_granulepos.base = 0;
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->granulepos = u_granulepos.real;
+ offset += sizeof(this->granulepos);
+ union {
+ int64_t real;
+ uint64_t base;
+ } u_packetno;
+ u_packetno.base = 0;
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->packetno = u_packetno.real;
+ offset += sizeof(this->packetno);
+ return offset;
+ }
+
+ const char * getType(){ return "theora_image_transport/Packet"; };
+ const char * getMD5(){ return "33ac4e14a7cff32e7e0d65f18bb410f3"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/time.cpp Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,70 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2011, Willow Garage, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Willow Garage, Inc. nor the names of its
+ * contributors may be used to endorse or promote prducts derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "ros/time.h"
+
+namespace ros
+{
+void normalizeSecNSec(uint32_t& sec, uint32_t& nsec)
+{
+ uint32_t nsec_part = nsec % 1000000000UL;
+ uint32_t sec_part = nsec / 1000000000UL;
+ sec += sec_part;
+ nsec = nsec_part;
+}
+
+Time& Time::fromNSec(int32_t t)
+{
+ sec = t / 1000000000;
+ nsec = t % 1000000000;
+ normalizeSecNSec(sec, nsec);
+ return *this;
+}
+
+Time& Time::operator +=(const Duration &rhs)
+{
+ sec += rhs.sec;
+ nsec += rhs.nsec;
+ normalizeSecNSec(sec, nsec);
+ return *this;
+}
+
+Time& Time::operator -=(const Duration &rhs)
+{
+ sec += -rhs.sec;
+ nsec += -rhs.nsec;
+ normalizeSecNSec(sec, nsec);
+ return *this;
+}
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/DemuxAdd.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_SERVICE_DemuxAdd_h
+#define _ROS_SERVICE_DemuxAdd_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char DEMUXADD[] = "topic_tools/DemuxAdd";
+
+ class DemuxAddRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _topic_type;
+ _topic_type topic;
+
+ DemuxAddRequest():
+ topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_topic = strlen(this->topic);
+ varToArr(outbuffer + offset, length_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic, length_topic);
+ offset += length_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_topic;
+ arrToVar(length_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic-1]=0;
+ this->topic = (char *)(inbuffer + offset-1);
+ offset += length_topic;
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXADD; };
+ const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
+
+ };
+
+ class DemuxAddResponse : public ros::Msg
+ {
+ public:
+
+ DemuxAddResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXADD; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class DemuxAdd {
+ public:
+ typedef DemuxAddRequest Request;
+ typedef DemuxAddResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/DemuxDelete.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_SERVICE_DemuxDelete_h
+#define _ROS_SERVICE_DemuxDelete_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char DEMUXDELETE[] = "topic_tools/DemuxDelete";
+
+ class DemuxDeleteRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _topic_type;
+ _topic_type topic;
+
+ DemuxDeleteRequest():
+ topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_topic = strlen(this->topic);
+ varToArr(outbuffer + offset, length_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic, length_topic);
+ offset += length_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_topic;
+ arrToVar(length_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic-1]=0;
+ this->topic = (char *)(inbuffer + offset-1);
+ offset += length_topic;
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXDELETE; };
+ const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
+
+ };
+
+ class DemuxDeleteResponse : public ros::Msg
+ {
+ public:
+
+ DemuxDeleteResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXDELETE; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class DemuxDelete {
+ public:
+ typedef DemuxDeleteRequest Request;
+ typedef DemuxDeleteResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/DemuxList.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,107 @@
+#ifndef _ROS_SERVICE_DemuxList_h
+#define _ROS_SERVICE_DemuxList_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char DEMUXLIST[] = "topic_tools/DemuxList";
+
+ class DemuxListRequest : public ros::Msg
+ {
+ public:
+
+ DemuxListRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXLIST; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class DemuxListResponse : public ros::Msg
+ {
+ public:
+ uint32_t topics_length;
+ typedef char* _topics_type;
+ _topics_type st_topics;
+ _topics_type * topics;
+
+ DemuxListResponse():
+ topics_length(0), topics(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->topics_length);
+ for( uint32_t i = 0; i < topics_length; i++){
+ uint32_t length_topicsi = strlen(this->topics[i]);
+ varToArr(outbuffer + offset, length_topicsi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topics[i], length_topicsi);
+ offset += length_topicsi;
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->topics_length);
+ if(topics_lengthT > topics_length)
+ this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
+ topics_length = topics_lengthT;
+ for( uint32_t i = 0; i < topics_length; i++){
+ uint32_t length_st_topics;
+ arrToVar(length_st_topics, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_topics; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_topics-1]=0;
+ this->st_topics = (char *)(inbuffer + offset-1);
+ offset += length_st_topics;
+ memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXLIST; };
+ const char * getMD5(){ return "b0eef9a05d4e829092fc2f2c3c2aad3d"; };
+
+ };
+
+ class DemuxList {
+ public:
+ typedef DemuxListRequest Request;
+ typedef DemuxListResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/DemuxSelect.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,104 @@
+#ifndef _ROS_SERVICE_DemuxSelect_h
+#define _ROS_SERVICE_DemuxSelect_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char DEMUXSELECT[] = "topic_tools/DemuxSelect";
+
+ class DemuxSelectRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _topic_type;
+ _topic_type topic;
+
+ DemuxSelectRequest():
+ topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_topic = strlen(this->topic);
+ varToArr(outbuffer + offset, length_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic, length_topic);
+ offset += length_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_topic;
+ arrToVar(length_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic-1]=0;
+ this->topic = (char *)(inbuffer + offset-1);
+ offset += length_topic;
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXSELECT; };
+ const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
+
+ };
+
+ class DemuxSelectResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _prev_topic_type;
+ _prev_topic_type prev_topic;
+
+ DemuxSelectResponse():
+ prev_topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_prev_topic = strlen(this->prev_topic);
+ varToArr(outbuffer + offset, length_prev_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->prev_topic, length_prev_topic);
+ offset += length_prev_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_prev_topic;
+ arrToVar(length_prev_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_prev_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_prev_topic-1]=0;
+ this->prev_topic = (char *)(inbuffer + offset-1);
+ offset += length_prev_topic;
+ return offset;
+ }
+
+ const char * getType(){ return DEMUXSELECT; };
+ const char * getMD5(){ return "3db0a473debdbafea387c9e49358c320"; };
+
+ };
+
+ class DemuxSelect {
+ public:
+ typedef DemuxSelectRequest Request;
+ typedef DemuxSelectResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/MuxAdd.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_SERVICE_MuxAdd_h
+#define _ROS_SERVICE_MuxAdd_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char MUXADD[] = "topic_tools/MuxAdd";
+
+ class MuxAddRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _topic_type;
+ _topic_type topic;
+
+ MuxAddRequest():
+ topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_topic = strlen(this->topic);
+ varToArr(outbuffer + offset, length_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic, length_topic);
+ offset += length_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_topic;
+ arrToVar(length_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic-1]=0;
+ this->topic = (char *)(inbuffer + offset-1);
+ offset += length_topic;
+ return offset;
+ }
+
+ const char * getType(){ return MUXADD; };
+ const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
+
+ };
+
+ class MuxAddResponse : public ros::Msg
+ {
+ public:
+
+ MuxAddResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return MUXADD; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class MuxAdd {
+ public:
+ typedef MuxAddRequest Request;
+ typedef MuxAddResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/MuxDelete.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_SERVICE_MuxDelete_h
+#define _ROS_SERVICE_MuxDelete_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char MUXDELETE[] = "topic_tools/MuxDelete";
+
+ class MuxDeleteRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _topic_type;
+ _topic_type topic;
+
+ MuxDeleteRequest():
+ topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_topic = strlen(this->topic);
+ varToArr(outbuffer + offset, length_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic, length_topic);
+ offset += length_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_topic;
+ arrToVar(length_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic-1]=0;
+ this->topic = (char *)(inbuffer + offset-1);
+ offset += length_topic;
+ return offset;
+ }
+
+ const char * getType(){ return MUXDELETE; };
+ const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
+
+ };
+
+ class MuxDeleteResponse : public ros::Msg
+ {
+ public:
+
+ MuxDeleteResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return MUXDELETE; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class MuxDelete {
+ public:
+ typedef MuxDeleteRequest Request;
+ typedef MuxDeleteResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/MuxList.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,107 @@
+#ifndef _ROS_SERVICE_MuxList_h
+#define _ROS_SERVICE_MuxList_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char MUXLIST[] = "topic_tools/MuxList";
+
+ class MuxListRequest : public ros::Msg
+ {
+ public:
+
+ MuxListRequest()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return MUXLIST; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class MuxListResponse : public ros::Msg
+ {
+ public:
+ uint32_t topics_length;
+ typedef char* _topics_type;
+ _topics_type st_topics;
+ _topics_type * topics;
+
+ MuxListResponse():
+ topics_length(0), topics(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->topics_length);
+ for( uint32_t i = 0; i < topics_length; i++){
+ uint32_t length_topicsi = strlen(this->topics[i]);
+ varToArr(outbuffer + offset, length_topicsi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topics[i], length_topicsi);
+ offset += length_topicsi;
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->topics_length);
+ if(topics_lengthT > topics_length)
+ this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
+ topics_length = topics_lengthT;
+ for( uint32_t i = 0; i < topics_length; i++){
+ uint32_t length_st_topics;
+ arrToVar(length_st_topics, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_topics; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_topics-1]=0;
+ this->st_topics = (char *)(inbuffer + offset-1);
+ offset += length_st_topics;
+ memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return MUXLIST; };
+ const char * getMD5(){ return "b0eef9a05d4e829092fc2f2c3c2aad3d"; };
+
+ };
+
+ class MuxList {
+ public:
+ typedef MuxListRequest Request;
+ typedef MuxListResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/topic_tools/MuxSelect.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,104 @@
+#ifndef _ROS_SERVICE_MuxSelect_h
+#define _ROS_SERVICE_MuxSelect_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace topic_tools
+{
+
+static const char MUXSELECT[] = "topic_tools/MuxSelect";
+
+ class MuxSelectRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _topic_type;
+ _topic_type topic;
+
+ MuxSelectRequest():
+ topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_topic = strlen(this->topic);
+ varToArr(outbuffer + offset, length_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->topic, length_topic);
+ offset += length_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_topic;
+ arrToVar(length_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_topic-1]=0;
+ this->topic = (char *)(inbuffer + offset-1);
+ offset += length_topic;
+ return offset;
+ }
+
+ const char * getType(){ return MUXSELECT; };
+ const char * getMD5(){ return "d8f94bae31b356b24d0427f80426d0c3"; };
+
+ };
+
+ class MuxSelectResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _prev_topic_type;
+ _prev_topic_type prev_topic;
+
+ MuxSelectResponse():
+ prev_topic("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_prev_topic = strlen(this->prev_topic);
+ varToArr(outbuffer + offset, length_prev_topic);
+ offset += 4;
+ memcpy(outbuffer + offset, this->prev_topic, length_prev_topic);
+ offset += length_prev_topic;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_prev_topic;
+ arrToVar(length_prev_topic, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_prev_topic; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_prev_topic-1]=0;
+ this->prev_topic = (char *)(inbuffer + offset-1);
+ offset += length_prev_topic;
+ return offset;
+ }
+
+ const char * getType(){ return MUXSELECT; };
+ const char * getMD5(){ return "3db0a473debdbafea387c9e49358c320"; };
+
+ };
+
+ class MuxSelect {
+ public:
+ typedef MuxSelectRequest Request;
+ typedef MuxSelectResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/trajectory_msgs/JointTrajectory.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,107 @@
+#ifndef _ROS_trajectory_msgs_JointTrajectory_h
+#define _ROS_trajectory_msgs_JointTrajectory_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "trajectory_msgs/JointTrajectoryPoint.h"
+
+namespace trajectory_msgs
+{
+
+ class JointTrajectory : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t joint_names_length;
+ typedef char* _joint_names_type;
+ _joint_names_type st_joint_names;
+ _joint_names_type * joint_names;
+ uint32_t points_length;
+ typedef trajectory_msgs::JointTrajectoryPoint _points_type;
+ _points_type st_points;
+ _points_type * points;
+
+ JointTrajectory():
+ header(),
+ joint_names_length(0), joint_names(NULL),
+ points_length(0), points(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->joint_names_length);
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_joint_namesi = strlen(this->joint_names[i]);
+ varToArr(outbuffer + offset, length_joint_namesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
+ offset += length_joint_namesi;
+ }
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->joint_names_length);
+ if(joint_names_lengthT > joint_names_length)
+ this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
+ joint_names_length = joint_names_lengthT;
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_st_joint_names;
+ arrToVar(length_st_joint_names, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_joint_names-1]=0;
+ this->st_joint_names = (char *)(inbuffer + offset-1);
+ offset += length_st_joint_names;
+ memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
+ }
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (trajectory_msgs::JointTrajectoryPoint*)realloc(this->points, points_lengthT * sizeof(trajectory_msgs::JointTrajectoryPoint));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(trajectory_msgs::JointTrajectoryPoint));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "trajectory_msgs/JointTrajectory"; };
+ const char * getMD5(){ return "65b4f94a94d1ed67169da35a02f33d3f"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/trajectory_msgs/JointTrajectoryPoint.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,270 @@
+#ifndef _ROS_trajectory_msgs_JointTrajectoryPoint_h
+#define _ROS_trajectory_msgs_JointTrajectoryPoint_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "ros/duration.h"
+
+namespace trajectory_msgs
+{
+
+ class JointTrajectoryPoint : public ros::Msg
+ {
+ public:
+ uint32_t positions_length;
+ typedef double _positions_type;
+ _positions_type st_positions;
+ _positions_type * positions;
+ uint32_t velocities_length;
+ typedef double _velocities_type;
+ _velocities_type st_velocities;
+ _velocities_type * velocities;
+ uint32_t accelerations_length;
+ typedef double _accelerations_type;
+ _accelerations_type st_accelerations;
+ _accelerations_type * accelerations;
+ uint32_t effort_length;
+ typedef double _effort_type;
+ _effort_type st_effort;
+ _effort_type * effort;
+ typedef ros::Duration _time_from_start_type;
+ _time_from_start_type time_from_start;
+
+ JointTrajectoryPoint():
+ positions_length(0), positions(NULL),
+ velocities_length(0), velocities(NULL),
+ accelerations_length(0), accelerations(NULL),
+ effort_length(0), effort(NULL),
+ time_from_start()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->positions_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->positions_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->positions_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->positions_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->positions_length);
+ for( uint32_t i = 0; i < positions_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_positionsi;
+ u_positionsi.real = this->positions[i];
+ *(outbuffer + offset + 0) = (u_positionsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_positionsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_positionsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_positionsi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_positionsi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_positionsi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_positionsi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_positionsi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->positions[i]);
+ }
+ *(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->velocities_length);
+ for( uint32_t i = 0; i < velocities_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_velocitiesi;
+ u_velocitiesi.real = this->velocities[i];
+ *(outbuffer + offset + 0) = (u_velocitiesi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_velocitiesi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_velocitiesi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_velocitiesi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_velocitiesi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_velocitiesi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_velocitiesi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_velocitiesi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->velocities[i]);
+ }
+ *(outbuffer + offset + 0) = (this->accelerations_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->accelerations_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->accelerations_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->accelerations_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->accelerations_length);
+ for( uint32_t i = 0; i < accelerations_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_accelerationsi;
+ u_accelerationsi.real = this->accelerations[i];
+ *(outbuffer + offset + 0) = (u_accelerationsi.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_accelerationsi.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_accelerationsi.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_accelerationsi.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_accelerationsi.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_accelerationsi.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_accelerationsi.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_accelerationsi.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->accelerations[i]);
+ }
+ *(outbuffer + offset + 0) = (this->effort_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->effort_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->effort_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->effort_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->effort_length);
+ for( uint32_t i = 0; i < effort_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_efforti;
+ u_efforti.real = this->effort[i];
+ *(outbuffer + offset + 0) = (u_efforti.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_efforti.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_efforti.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_efforti.base >> (8 * 3)) & 0xFF;
+ *(outbuffer + offset + 4) = (u_efforti.base >> (8 * 4)) & 0xFF;
+ *(outbuffer + offset + 5) = (u_efforti.base >> (8 * 5)) & 0xFF;
+ *(outbuffer + offset + 6) = (u_efforti.base >> (8 * 6)) & 0xFF;
+ *(outbuffer + offset + 7) = (u_efforti.base >> (8 * 7)) & 0xFF;
+ offset += sizeof(this->effort[i]);
+ }
+ *(outbuffer + offset + 0) = (this->time_from_start.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_from_start.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_from_start.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_from_start.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_from_start.sec);
+ *(outbuffer + offset + 0) = (this->time_from_start.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_from_start.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_from_start.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_from_start.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_from_start.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->positions_length);
+ if(positions_lengthT > positions_length)
+ this->positions = (double*)realloc(this->positions, positions_lengthT * sizeof(double));
+ positions_length = positions_lengthT;
+ for( uint32_t i = 0; i < positions_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_positions;
+ u_st_positions.base = 0;
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_positions = u_st_positions.real;
+ offset += sizeof(this->st_positions);
+ memcpy( &(this->positions[i]), &(this->st_positions), sizeof(double));
+ }
+ uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->velocities_length);
+ if(velocities_lengthT > velocities_length)
+ this->velocities = (double*)realloc(this->velocities, velocities_lengthT * sizeof(double));
+ velocities_length = velocities_lengthT;
+ for( uint32_t i = 0; i < velocities_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_velocities;
+ u_st_velocities.base = 0;
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_velocities = u_st_velocities.real;
+ offset += sizeof(this->st_velocities);
+ memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(double));
+ }
+ uint32_t accelerations_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->accelerations_length);
+ if(accelerations_lengthT > accelerations_length)
+ this->accelerations = (double*)realloc(this->accelerations, accelerations_lengthT * sizeof(double));
+ accelerations_length = accelerations_lengthT;
+ for( uint32_t i = 0; i < accelerations_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_accelerations;
+ u_st_accelerations.base = 0;
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_accelerations.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_accelerations = u_st_accelerations.real;
+ offset += sizeof(this->st_accelerations);
+ memcpy( &(this->accelerations[i]), &(this->st_accelerations), sizeof(double));
+ }
+ uint32_t effort_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ effort_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->effort_length);
+ if(effort_lengthT > effort_length)
+ this->effort = (double*)realloc(this->effort, effort_lengthT * sizeof(double));
+ effort_length = effort_lengthT;
+ for( uint32_t i = 0; i < effort_length; i++){
+ union {
+ double real;
+ uint64_t base;
+ } u_st_effort;
+ u_st_effort.base = 0;
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
+ u_st_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
+ this->st_effort = u_st_effort.real;
+ offset += sizeof(this->st_effort);
+ memcpy( &(this->effort[i]), &(this->st_effort), sizeof(double));
+ }
+ this->time_from_start.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_from_start.sec);
+ this->time_from_start.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_from_start.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "trajectory_msgs/JointTrajectoryPoint"; };
+ const char * getMD5(){ return "f3cd1e1c4d320c79d6985c904ae5dcd3"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/trajectory_msgs/MultiDOFJointTrajectory.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,107 @@
+#ifndef _ROS_trajectory_msgs_MultiDOFJointTrajectory_h
+#define _ROS_trajectory_msgs_MultiDOFJointTrajectory_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "trajectory_msgs/MultiDOFJointTrajectoryPoint.h"
+
+namespace trajectory_msgs
+{
+
+ class MultiDOFJointTrajectory : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ uint32_t joint_names_length;
+ typedef char* _joint_names_type;
+ _joint_names_type st_joint_names;
+ _joint_names_type * joint_names;
+ uint32_t points_length;
+ typedef trajectory_msgs::MultiDOFJointTrajectoryPoint _points_type;
+ _points_type st_points;
+ _points_type * points;
+
+ MultiDOFJointTrajectory():
+ header(),
+ joint_names_length(0), joint_names(NULL),
+ points_length(0), points(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->joint_names_length);
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_joint_namesi = strlen(this->joint_names[i]);
+ varToArr(outbuffer + offset, length_joint_namesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
+ offset += length_joint_namesi;
+ }
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->joint_names_length);
+ if(joint_names_lengthT > joint_names_length)
+ this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
+ joint_names_length = joint_names_lengthT;
+ for( uint32_t i = 0; i < joint_names_length; i++){
+ uint32_t length_st_joint_names;
+ arrToVar(length_st_joint_names, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_joint_names-1]=0;
+ this->st_joint_names = (char *)(inbuffer + offset-1);
+ offset += length_st_joint_names;
+ memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
+ }
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (trajectory_msgs::MultiDOFJointTrajectoryPoint*)realloc(this->points, points_lengthT * sizeof(trajectory_msgs::MultiDOFJointTrajectoryPoint));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(trajectory_msgs::MultiDOFJointTrajectoryPoint));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "trajectory_msgs/MultiDOFJointTrajectory"; };
+ const char * getMD5(){ return "ef145a45a5f47b77b7f5cdde4b16c942"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/trajectory_msgs/MultiDOFJointTrajectoryPoint.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,139 @@
+#ifndef _ROS_trajectory_msgs_MultiDOFJointTrajectoryPoint_h
+#define _ROS_trajectory_msgs_MultiDOFJointTrajectoryPoint_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Transform.h"
+#include "geometry_msgs/Twist.h"
+#include "ros/duration.h"
+
+namespace trajectory_msgs
+{
+
+ class MultiDOFJointTrajectoryPoint : public ros::Msg
+ {
+ public:
+ uint32_t transforms_length;
+ typedef geometry_msgs::Transform _transforms_type;
+ _transforms_type st_transforms;
+ _transforms_type * transforms;
+ uint32_t velocities_length;
+ typedef geometry_msgs::Twist _velocities_type;
+ _velocities_type st_velocities;
+ _velocities_type * velocities;
+ uint32_t accelerations_length;
+ typedef geometry_msgs::Twist _accelerations_type;
+ _accelerations_type st_accelerations;
+ _accelerations_type * accelerations;
+ typedef ros::Duration _time_from_start_type;
+ _time_from_start_type time_from_start;
+
+ MultiDOFJointTrajectoryPoint():
+ transforms_length(0), transforms(NULL),
+ velocities_length(0), velocities(NULL),
+ accelerations_length(0), accelerations(NULL),
+ time_from_start()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->transforms_length);
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->transforms[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->velocities_length);
+ for( uint32_t i = 0; i < velocities_length; i++){
+ offset += this->velocities[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->accelerations_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->accelerations_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->accelerations_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->accelerations_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->accelerations_length);
+ for( uint32_t i = 0; i < accelerations_length; i++){
+ offset += this->accelerations[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->time_from_start.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_from_start.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_from_start.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_from_start.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_from_start.sec);
+ *(outbuffer + offset + 0) = (this->time_from_start.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->time_from_start.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->time_from_start.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->time_from_start.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->time_from_start.nsec);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->transforms_length);
+ if(transforms_lengthT > transforms_length)
+ this->transforms = (geometry_msgs::Transform*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::Transform));
+ transforms_length = transforms_lengthT;
+ for( uint32_t i = 0; i < transforms_length; i++){
+ offset += this->st_transforms.deserialize(inbuffer + offset);
+ memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::Transform));
+ }
+ uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->velocities_length);
+ if(velocities_lengthT > velocities_length)
+ this->velocities = (geometry_msgs::Twist*)realloc(this->velocities, velocities_lengthT * sizeof(geometry_msgs::Twist));
+ velocities_length = velocities_lengthT;
+ for( uint32_t i = 0; i < velocities_length; i++){
+ offset += this->st_velocities.deserialize(inbuffer + offset);
+ memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(geometry_msgs::Twist));
+ }
+ uint32_t accelerations_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ accelerations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->accelerations_length);
+ if(accelerations_lengthT > accelerations_length)
+ this->accelerations = (geometry_msgs::Twist*)realloc(this->accelerations, accelerations_lengthT * sizeof(geometry_msgs::Twist));
+ accelerations_length = accelerations_lengthT;
+ for( uint32_t i = 0; i < accelerations_length; i++){
+ offset += this->st_accelerations.deserialize(inbuffer + offset);
+ memcpy( &(this->accelerations[i]), &(this->st_accelerations), sizeof(geometry_msgs::Twist));
+ }
+ this->time_from_start.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_from_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_from_start.sec);
+ this->time_from_start.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->time_from_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->time_from_start.nsec);
+ return offset;
+ }
+
+ const char * getType(){ return "trajectory_msgs/MultiDOFJointTrajectoryPoint"; };
+ const char * getMD5(){ return "3ebe08d1abd5b65862d50e09430db776"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/ShapeAction.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_turtle_actionlib_ShapeAction_h
+#define _ROS_turtle_actionlib_ShapeAction_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "turtle_actionlib/ShapeActionGoal.h"
+#include "turtle_actionlib/ShapeActionResult.h"
+#include "turtle_actionlib/ShapeActionFeedback.h"
+
+namespace turtle_actionlib
+{
+
+ class ShapeAction : public ros::Msg
+ {
+ public:
+ typedef turtle_actionlib::ShapeActionGoal _action_goal_type;
+ _action_goal_type action_goal;
+ typedef turtle_actionlib::ShapeActionResult _action_result_type;
+ _action_result_type action_result;
+ typedef turtle_actionlib::ShapeActionFeedback _action_feedback_type;
+ _action_feedback_type action_feedback;
+
+ ShapeAction():
+ action_goal(),
+ action_result(),
+ action_feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->action_goal.serialize(outbuffer + offset);
+ offset += this->action_result.serialize(outbuffer + offset);
+ offset += this->action_feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->action_goal.deserialize(inbuffer + offset);
+ offset += this->action_result.deserialize(inbuffer + offset);
+ offset += this->action_feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/ShapeAction"; };
+ const char * getMD5(){ return "d73b17d6237a925511f5d7727a1dc903"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/ShapeActionFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_turtle_actionlib_ShapeActionFeedback_h
+#define _ROS_turtle_actionlib_ShapeActionFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "turtle_actionlib/ShapeFeedback.h"
+
+namespace turtle_actionlib
+{
+
+ class ShapeActionFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef turtle_actionlib::ShapeFeedback _feedback_type;
+ _feedback_type feedback;
+
+ ShapeActionFeedback():
+ header(),
+ status(),
+ feedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->feedback.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->feedback.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/ShapeActionFeedback"; };
+ const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/ShapeActionGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_turtle_actionlib_ShapeActionGoal_h
+#define _ROS_turtle_actionlib_ShapeActionGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalID.h"
+#include "turtle_actionlib/ShapeGoal.h"
+
+namespace turtle_actionlib
+{
+
+ class ShapeActionGoal : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalID _goal_id_type;
+ _goal_id_type goal_id;
+ typedef turtle_actionlib::ShapeGoal _goal_type;
+ _goal_type goal;
+
+ ShapeActionGoal():
+ header(),
+ goal_id(),
+ goal()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->goal_id.serialize(outbuffer + offset);
+ offset += this->goal.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->goal_id.deserialize(inbuffer + offset);
+ offset += this->goal.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/ShapeActionGoal"; };
+ const char * getMD5(){ return "dbfccd187f2ec9c593916447ffd6cc77"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/ShapeActionResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,56 @@
+#ifndef _ROS_turtle_actionlib_ShapeActionResult_h
+#define _ROS_turtle_actionlib_ShapeActionResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "actionlib_msgs/GoalStatus.h"
+#include "turtle_actionlib/ShapeResult.h"
+
+namespace turtle_actionlib
+{
+
+ class ShapeActionResult : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef actionlib_msgs::GoalStatus _status_type;
+ _status_type status;
+ typedef turtle_actionlib::ShapeResult _result_type;
+ _result_type result;
+
+ ShapeActionResult():
+ header(),
+ status(),
+ result()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->status.serialize(outbuffer + offset);
+ offset += this->result.serialize(outbuffer + offset);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->status.deserialize(inbuffer + offset);
+ offset += this->result.deserialize(inbuffer + offset);
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/ShapeActionResult"; };
+ const char * getMD5(){ return "c8d13d5d140f1047a2e4d3bf5c045822"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/ShapeFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,38 @@
+#ifndef _ROS_turtle_actionlib_ShapeFeedback_h
+#define _ROS_turtle_actionlib_ShapeFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtle_actionlib
+{
+
+ class ShapeFeedback : public ros::Msg
+ {
+ public:
+
+ ShapeFeedback()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/ShapeFeedback"; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/ShapeGoal.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,86 @@
+#ifndef _ROS_turtle_actionlib_ShapeGoal_h
+#define _ROS_turtle_actionlib_ShapeGoal_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtle_actionlib
+{
+
+ class ShapeGoal : public ros::Msg
+ {
+ public:
+ typedef int32_t _edges_type;
+ _edges_type edges;
+ typedef float _radius_type;
+ _radius_type radius;
+
+ ShapeGoal():
+ edges(0),
+ radius(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_edges;
+ u_edges.real = this->edges;
+ *(outbuffer + offset + 0) = (u_edges.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_edges.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_edges.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_edges.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->edges);
+ union {
+ float real;
+ uint32_t base;
+ } u_radius;
+ u_radius.real = this->radius;
+ *(outbuffer + offset + 0) = (u_radius.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_radius.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_radius.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_radius.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->radius);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_edges;
+ u_edges.base = 0;
+ u_edges.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_edges.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_edges.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_edges.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->edges = u_edges.real;
+ offset += sizeof(this->edges);
+ union {
+ float real;
+ uint32_t base;
+ } u_radius;
+ u_radius.base = 0;
+ u_radius.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_radius.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_radius.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_radius.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->radius = u_radius.real;
+ offset += sizeof(this->radius);
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/ShapeGoal"; };
+ const char * getMD5(){ return "3b9202ab7292cebe5a95ab2bf6b9c091"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/ShapeResult.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,86 @@
+#ifndef _ROS_turtle_actionlib_ShapeResult_h
+#define _ROS_turtle_actionlib_ShapeResult_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtle_actionlib
+{
+
+ class ShapeResult : public ros::Msg
+ {
+ public:
+ typedef float _interior_angle_type;
+ _interior_angle_type interior_angle;
+ typedef float _apothem_type;
+ _apothem_type apothem;
+
+ ShapeResult():
+ interior_angle(0),
+ apothem(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_interior_angle;
+ u_interior_angle.real = this->interior_angle;
+ *(outbuffer + offset + 0) = (u_interior_angle.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_interior_angle.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_interior_angle.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_interior_angle.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->interior_angle);
+ union {
+ float real;
+ uint32_t base;
+ } u_apothem;
+ u_apothem.real = this->apothem;
+ *(outbuffer + offset + 0) = (u_apothem.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_apothem.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_apothem.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_apothem.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->apothem);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_interior_angle;
+ u_interior_angle.base = 0;
+ u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_interior_angle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->interior_angle = u_interior_angle.real;
+ offset += sizeof(this->interior_angle);
+ union {
+ float real;
+ uint32_t base;
+ } u_apothem;
+ u_apothem.base = 0;
+ u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_apothem.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->apothem = u_apothem.real;
+ offset += sizeof(this->apothem);
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/ShapeResult"; };
+ const char * getMD5(){ return "b06c6e2225f820dbc644270387cd1a7c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtle_actionlib/Velocity.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,86 @@
+#ifndef _ROS_turtle_actionlib_Velocity_h
+#define _ROS_turtle_actionlib_Velocity_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtle_actionlib
+{
+
+ class Velocity : public ros::Msg
+ {
+ public:
+ typedef float _linear_type;
+ _linear_type linear;
+ typedef float _angular_type;
+ _angular_type angular;
+
+ Velocity():
+ linear(0),
+ angular(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_linear;
+ u_linear.real = this->linear;
+ *(outbuffer + offset + 0) = (u_linear.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_linear.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_linear.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_linear.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->linear);
+ union {
+ float real;
+ uint32_t base;
+ } u_angular;
+ u_angular.real = this->angular;
+ *(outbuffer + offset + 0) = (u_angular.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angular.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angular.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angular.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angular);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_linear;
+ u_linear.base = 0;
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->linear = u_linear.real;
+ offset += sizeof(this->linear);
+ union {
+ float real;
+ uint32_t base;
+ } u_angular;
+ u_angular.base = 0;
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angular = u_angular.real;
+ offset += sizeof(this->angular);
+ return offset;
+ }
+
+ const char * getType(){ return "turtle_actionlib/Velocity"; };
+ const char * getMD5(){ return "9d5c2dcd348ac8f76ce2a4307bd63a13"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtlesim/Color.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,59 @@
+#ifndef _ROS_turtlesim_Color_h
+#define _ROS_turtlesim_Color_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtlesim
+{
+
+ class Color : public ros::Msg
+ {
+ public:
+ typedef uint8_t _r_type;
+ _r_type r;
+ typedef uint8_t _g_type;
+ _g_type g;
+ typedef uint8_t _b_type;
+ _b_type b;
+
+ Color():
+ r(0),
+ g(0),
+ b(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->r);
+ *(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->g);
+ *(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->r = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->r);
+ this->g = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->g);
+ this->b = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->b);
+ return offset;
+ }
+
+ const char * getType(){ return "turtlesim/Color"; };
+ const char * getMD5(){ return "353891e354491c51aabe32df673fb446"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtlesim/Kill.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,87 @@
+#ifndef _ROS_SERVICE_Kill_h
+#define _ROS_SERVICE_Kill_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtlesim
+{
+
+static const char KILL[] = "turtlesim/Kill";
+
+ class KillRequest : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+
+ KillRequest():
+ name("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ return offset;
+ }
+
+ const char * getType(){ return KILL; };
+ const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
+
+ };
+
+ class KillResponse : public ros::Msg
+ {
+ public:
+
+ KillResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return KILL; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class Kill {
+ public:
+ typedef KillRequest Request;
+ typedef KillResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtlesim/Pose.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,158 @@
+#ifndef _ROS_turtlesim_Pose_h
+#define _ROS_turtlesim_Pose_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtlesim
+{
+
+ class Pose : public ros::Msg
+ {
+ public:
+ typedef float _x_type;
+ _x_type x;
+ typedef float _y_type;
+ _y_type y;
+ typedef float _theta_type;
+ _theta_type theta;
+ typedef float _linear_velocity_type;
+ _linear_velocity_type linear_velocity;
+ typedef float _angular_velocity_type;
+ _angular_velocity_type angular_velocity;
+
+ Pose():
+ x(0),
+ y(0),
+ theta(0),
+ linear_velocity(0),
+ angular_velocity(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_theta;
+ u_theta.real = this->theta;
+ *(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->theta);
+ union {
+ float real;
+ uint32_t base;
+ } u_linear_velocity;
+ u_linear_velocity.real = this->linear_velocity;
+ *(outbuffer + offset + 0) = (u_linear_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_linear_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_linear_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_linear_velocity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->linear_velocity);
+ union {
+ float real;
+ uint32_t base;
+ } u_angular_velocity;
+ u_angular_velocity.real = this->angular_velocity;
+ *(outbuffer + offset + 0) = (u_angular_velocity.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angular_velocity.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angular_velocity.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angular_velocity.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angular_velocity);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_theta;
+ u_theta.base = 0;
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->theta = u_theta.real;
+ offset += sizeof(this->theta);
+ union {
+ float real;
+ uint32_t base;
+ } u_linear_velocity;
+ u_linear_velocity.base = 0;
+ u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->linear_velocity = u_linear_velocity.real;
+ offset += sizeof(this->linear_velocity);
+ union {
+ float real;
+ uint32_t base;
+ } u_angular_velocity;
+ u_angular_velocity.base = 0;
+ u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angular_velocity = u_angular_velocity.real;
+ offset += sizeof(this->angular_velocity);
+ return offset;
+ }
+
+ const char * getType(){ return "turtlesim/Pose"; };
+ const char * getMD5(){ return "863b248d5016ca62ea2e895ae5265cf9"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtlesim/SetPen.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,105 @@
+#ifndef _ROS_SERVICE_SetPen_h
+#define _ROS_SERVICE_SetPen_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtlesim
+{
+
+static const char SETPEN[] = "turtlesim/SetPen";
+
+ class SetPenRequest : public ros::Msg
+ {
+ public:
+ typedef uint8_t _r_type;
+ _r_type r;
+ typedef uint8_t _g_type;
+ _g_type g;
+ typedef uint8_t _b_type;
+ _b_type b;
+ typedef uint8_t _width_type;
+ _width_type width;
+ typedef uint8_t _off_type;
+ _off_type off;
+
+ SetPenRequest():
+ r(0),
+ g(0),
+ b(0),
+ width(0),
+ off(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->r);
+ *(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->g);
+ *(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->b);
+ *(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->width);
+ *(outbuffer + offset + 0) = (this->off >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->off);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->r = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->r);
+ this->g = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->g);
+ this->b = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->b);
+ this->width = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->width);
+ this->off = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->off);
+ return offset;
+ }
+
+ const char * getType(){ return SETPEN; };
+ const char * getMD5(){ return "9f452acce566bf0c0954594f69a8e41b"; };
+
+ };
+
+ class SetPenResponse : public ros::Msg
+ {
+ public:
+
+ SetPenResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return SETPEN; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class SetPen {
+ public:
+ typedef SetPenRequest Request;
+ typedef SetPenResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtlesim/Spawn.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,176 @@
+#ifndef _ROS_SERVICE_Spawn_h
+#define _ROS_SERVICE_Spawn_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtlesim
+{
+
+static const char SPAWN[] = "turtlesim/Spawn";
+
+ class SpawnRequest : public ros::Msg
+ {
+ public:
+ typedef float _x_type;
+ _x_type x;
+ typedef float _y_type;
+ _y_type y;
+ typedef float _theta_type;
+ _theta_type theta;
+ typedef const char* _name_type;
+ _name_type name;
+
+ SpawnRequest():
+ x(0),
+ y(0),
+ theta(0),
+ name("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_theta;
+ u_theta.real = this->theta;
+ *(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->theta);
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_theta;
+ u_theta.base = 0;
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->theta = u_theta.real;
+ offset += sizeof(this->theta);
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ return offset;
+ }
+
+ const char * getType(){ return SPAWN; };
+ const char * getMD5(){ return "57f001c49ab7b11d699f8606c1f4f7ff"; };
+
+ };
+
+ class SpawnResponse : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+
+ SpawnResponse():
+ name("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ return offset;
+ }
+
+ const char * getType(){ return SPAWN; };
+ const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
+
+ };
+
+ class Spawn {
+ public:
+ typedef SpawnRequest Request;
+ typedef SpawnResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtlesim/TeleportAbsolute.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,142 @@
+#ifndef _ROS_SERVICE_TeleportAbsolute_h
+#define _ROS_SERVICE_TeleportAbsolute_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtlesim
+{
+
+static const char TELEPORTABSOLUTE[] = "turtlesim/TeleportAbsolute";
+
+ class TeleportAbsoluteRequest : public ros::Msg
+ {
+ public:
+ typedef float _x_type;
+ _x_type x;
+ typedef float _y_type;
+ _y_type y;
+ typedef float _theta_type;
+ _theta_type theta;
+
+ TeleportAbsoluteRequest():
+ x(0),
+ y(0),
+ theta(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.real = this->x;
+ *(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.real = this->y;
+ *(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_theta;
+ u_theta.real = this->theta;
+ *(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->theta);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_x;
+ u_x.base = 0;
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->x = u_x.real;
+ offset += sizeof(this->x);
+ union {
+ float real;
+ uint32_t base;
+ } u_y;
+ u_y.base = 0;
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->y = u_y.real;
+ offset += sizeof(this->y);
+ union {
+ float real;
+ uint32_t base;
+ } u_theta;
+ u_theta.base = 0;
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->theta = u_theta.real;
+ offset += sizeof(this->theta);
+ return offset;
+ }
+
+ const char * getType(){ return TELEPORTABSOLUTE; };
+ const char * getMD5(){ return "a130bc60ee6513855dc62ea83fcc5b20"; };
+
+ };
+
+ class TeleportAbsoluteResponse : public ros::Msg
+ {
+ public:
+
+ TeleportAbsoluteResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return TELEPORTABSOLUTE; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class TeleportAbsolute {
+ public:
+ typedef TeleportAbsoluteRequest Request;
+ typedef TeleportAbsoluteResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/turtlesim/TeleportRelative.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,118 @@
+#ifndef _ROS_SERVICE_TeleportRelative_h
+#define _ROS_SERVICE_TeleportRelative_h
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace turtlesim
+{
+
+static const char TELEPORTRELATIVE[] = "turtlesim/TeleportRelative";
+
+ class TeleportRelativeRequest : public ros::Msg
+ {
+ public:
+ typedef float _linear_type;
+ _linear_type linear;
+ typedef float _angular_type;
+ _angular_type angular;
+
+ TeleportRelativeRequest():
+ linear(0),
+ angular(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_linear;
+ u_linear.real = this->linear;
+ *(outbuffer + offset + 0) = (u_linear.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_linear.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_linear.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_linear.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->linear);
+ union {
+ float real;
+ uint32_t base;
+ } u_angular;
+ u_angular.real = this->angular;
+ *(outbuffer + offset + 0) = (u_angular.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_angular.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_angular.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_angular.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->angular);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ union {
+ float real;
+ uint32_t base;
+ } u_linear;
+ u_linear.base = 0;
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_linear.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->linear = u_linear.real;
+ offset += sizeof(this->linear);
+ union {
+ float real;
+ uint32_t base;
+ } u_angular;
+ u_angular.base = 0;
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_angular.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->angular = u_angular.real;
+ offset += sizeof(this->angular);
+ return offset;
+ }
+
+ const char * getType(){ return TELEPORTRELATIVE; };
+ const char * getMD5(){ return "9d5c2dcd348ac8f76ce2a4307bd63a13"; };
+
+ };
+
+ class TeleportRelativeResponse : public ros::Msg
+ {
+ public:
+
+ TeleportRelativeResponse()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ return offset;
+ }
+
+ const char * getType(){ return TELEPORTRELATIVE; };
+ const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
+
+ };
+
+ class TeleportRelative {
+ public:
+ typedef TeleportRelativeRequest Request;
+ typedef TeleportRelativeResponse Response;
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/uuid_msgs/UniqueID.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,48 @@
+#ifndef _ROS_uuid_msgs_UniqueID_h
+#define _ROS_uuid_msgs_UniqueID_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace uuid_msgs
+{
+
+ class UniqueID : public ros::Msg
+ {
+ public:
+ uint8_t uuid[16];
+
+ UniqueID():
+ uuid()
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 16; i++){
+ *(outbuffer + offset + 0) = (this->uuid[i] >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->uuid[i]);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ for( uint32_t i = 0; i < 16; i++){
+ this->uuid[i] = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->uuid[i]);
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "uuid_msgs/UniqueID"; };
+ const char * getMD5(){ return "fec2a93b6f5367ee8112c9c0b41ff310"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/ImageMarker.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,262 @@
+#ifndef _ROS_visualization_msgs_ImageMarker_h
+#define _ROS_visualization_msgs_ImageMarker_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Point.h"
+#include "std_msgs/ColorRGBA.h"
+#include "ros/duration.h"
+
+namespace visualization_msgs
+{
+
+ class ImageMarker : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _ns_type;
+ _ns_type ns;
+ typedef int32_t _id_type;
+ _id_type id;
+ typedef int32_t _type_type;
+ _type_type type;
+ typedef int32_t _action_type;
+ _action_type action;
+ typedef geometry_msgs::Point _position_type;
+ _position_type position;
+ typedef float _scale_type;
+ _scale_type scale;
+ typedef std_msgs::ColorRGBA _outline_color_type;
+ _outline_color_type outline_color;
+ typedef uint8_t _filled_type;
+ _filled_type filled;
+ typedef std_msgs::ColorRGBA _fill_color_type;
+ _fill_color_type fill_color;
+ typedef ros::Duration _lifetime_type;
+ _lifetime_type lifetime;
+ uint32_t points_length;
+ typedef geometry_msgs::Point _points_type;
+ _points_type st_points;
+ _points_type * points;
+ uint32_t outline_colors_length;
+ typedef std_msgs::ColorRGBA _outline_colors_type;
+ _outline_colors_type st_outline_colors;
+ _outline_colors_type * outline_colors;
+ enum { CIRCLE = 0 };
+ enum { LINE_STRIP = 1 };
+ enum { LINE_LIST = 2 };
+ enum { POLYGON = 3 };
+ enum { POINTS = 4 };
+ enum { ADD = 0 };
+ enum { REMOVE = 1 };
+
+ ImageMarker():
+ header(),
+ ns(""),
+ id(0),
+ type(0),
+ action(0),
+ position(),
+ scale(0),
+ outline_color(),
+ filled(0),
+ fill_color(),
+ lifetime(),
+ points_length(0), points(NULL),
+ outline_colors_length(0), outline_colors(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_ns = strlen(this->ns);
+ varToArr(outbuffer + offset, length_ns);
+ offset += 4;
+ memcpy(outbuffer + offset, this->ns, length_ns);
+ offset += length_ns;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.real = this->id;
+ *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->id);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_type;
+ u_type.real = this->type;
+ *(outbuffer + offset + 0) = (u_type.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_type.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_type.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_type.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->type);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_action;
+ u_action.real = this->action;
+ *(outbuffer + offset + 0) = (u_action.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_action.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_action.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_action.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->action);
+ offset += this->position.serialize(outbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_scale;
+ u_scale.real = this->scale;
+ *(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->scale);
+ offset += this->outline_color.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->filled >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->filled);
+ offset += this->fill_color.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->lifetime.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->lifetime.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->lifetime.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->lifetime.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->lifetime.sec);
+ *(outbuffer + offset + 0) = (this->lifetime.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->lifetime.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->lifetime.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->lifetime.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->lifetime.nsec);
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->outline_colors_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->outline_colors_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->outline_colors_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->outline_colors_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->outline_colors_length);
+ for( uint32_t i = 0; i < outline_colors_length; i++){
+ offset += this->outline_colors[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_ns;
+ arrToVar(length_ns, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_ns; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_ns-1]=0;
+ this->ns = (char *)(inbuffer + offset-1);
+ offset += length_ns;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.base = 0;
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->id = u_id.real;
+ offset += sizeof(this->id);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_type;
+ u_type.base = 0;
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->type = u_type.real;
+ offset += sizeof(this->type);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_action;
+ u_action.base = 0;
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->action = u_action.real;
+ offset += sizeof(this->action);
+ offset += this->position.deserialize(inbuffer + offset);
+ union {
+ float real;
+ uint32_t base;
+ } u_scale;
+ u_scale.base = 0;
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->scale = u_scale.real;
+ offset += sizeof(this->scale);
+ offset += this->outline_color.deserialize(inbuffer + offset);
+ this->filled = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->filled);
+ offset += this->fill_color.deserialize(inbuffer + offset);
+ this->lifetime.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->lifetime.sec);
+ this->lifetime.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->lifetime.nsec);
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (geometry_msgs::Point*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point));
+ }
+ uint32_t outline_colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->outline_colors_length);
+ if(outline_colors_lengthT > outline_colors_length)
+ this->outline_colors = (std_msgs::ColorRGBA*)realloc(this->outline_colors, outline_colors_lengthT * sizeof(std_msgs::ColorRGBA));
+ outline_colors_length = outline_colors_lengthT;
+ for( uint32_t i = 0; i < outline_colors_length; i++){
+ offset += this->st_outline_colors.deserialize(inbuffer + offset);
+ memcpy( &(this->outline_colors[i]), &(this->st_outline_colors), sizeof(std_msgs::ColorRGBA));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/ImageMarker"; };
+ const char * getMD5(){ return "1de93c67ec8858b831025a08fbf1b35c"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/InteractiveMarker.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,160 @@
+#ifndef _ROS_visualization_msgs_InteractiveMarker_h
+#define _ROS_visualization_msgs_InteractiveMarker_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Pose.h"
+#include "visualization_msgs/MenuEntry.h"
+#include "visualization_msgs/InteractiveMarkerControl.h"
+
+namespace visualization_msgs
+{
+
+ class InteractiveMarker : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Pose _pose_type;
+ _pose_type pose;
+ typedef const char* _name_type;
+ _name_type name;
+ typedef const char* _description_type;
+ _description_type description;
+ typedef float _scale_type;
+ _scale_type scale;
+ uint32_t menu_entries_length;
+ typedef visualization_msgs::MenuEntry _menu_entries_type;
+ _menu_entries_type st_menu_entries;
+ _menu_entries_type * menu_entries;
+ uint32_t controls_length;
+ typedef visualization_msgs::InteractiveMarkerControl _controls_type;
+ _controls_type st_controls;
+ _controls_type * controls;
+
+ InteractiveMarker():
+ header(),
+ pose(),
+ name(""),
+ description(""),
+ scale(0),
+ menu_entries_length(0), menu_entries(NULL),
+ controls_length(0), controls(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->pose.serialize(outbuffer + offset);
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ uint32_t length_description = strlen(this->description);
+ varToArr(outbuffer + offset, length_description);
+ offset += 4;
+ memcpy(outbuffer + offset, this->description, length_description);
+ offset += length_description;
+ union {
+ float real;
+ uint32_t base;
+ } u_scale;
+ u_scale.real = this->scale;
+ *(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->scale);
+ *(outbuffer + offset + 0) = (this->menu_entries_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->menu_entries_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->menu_entries_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->menu_entries_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->menu_entries_length);
+ for( uint32_t i = 0; i < menu_entries_length; i++){
+ offset += this->menu_entries[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->controls_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->controls_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->controls_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->controls_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->controls_length);
+ for( uint32_t i = 0; i < controls_length; i++){
+ offset += this->controls[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->pose.deserialize(inbuffer + offset);
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ uint32_t length_description;
+ arrToVar(length_description, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_description; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_description-1]=0;
+ this->description = (char *)(inbuffer + offset-1);
+ offset += length_description;
+ union {
+ float real;
+ uint32_t base;
+ } u_scale;
+ u_scale.base = 0;
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_scale.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->scale = u_scale.real;
+ offset += sizeof(this->scale);
+ uint32_t menu_entries_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->menu_entries_length);
+ if(menu_entries_lengthT > menu_entries_length)
+ this->menu_entries = (visualization_msgs::MenuEntry*)realloc(this->menu_entries, menu_entries_lengthT * sizeof(visualization_msgs::MenuEntry));
+ menu_entries_length = menu_entries_lengthT;
+ for( uint32_t i = 0; i < menu_entries_length; i++){
+ offset += this->st_menu_entries.deserialize(inbuffer + offset);
+ memcpy( &(this->menu_entries[i]), &(this->st_menu_entries), sizeof(visualization_msgs::MenuEntry));
+ }
+ uint32_t controls_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->controls_length);
+ if(controls_lengthT > controls_length)
+ this->controls = (visualization_msgs::InteractiveMarkerControl*)realloc(this->controls, controls_lengthT * sizeof(visualization_msgs::InteractiveMarkerControl));
+ controls_length = controls_lengthT;
+ for( uint32_t i = 0; i < controls_length; i++){
+ offset += this->st_controls.deserialize(inbuffer + offset);
+ memcpy( &(this->controls[i]), &(this->st_controls), sizeof(visualization_msgs::InteractiveMarkerControl));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/InteractiveMarker"; };
+ const char * getMD5(){ return "dd86d22909d5a3364b384492e35c10af"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/InteractiveMarkerControl.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,167 @@
+#ifndef _ROS_visualization_msgs_InteractiveMarkerControl_h
+#define _ROS_visualization_msgs_InteractiveMarkerControl_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "geometry_msgs/Quaternion.h"
+#include "visualization_msgs/Marker.h"
+
+namespace visualization_msgs
+{
+
+ class InteractiveMarkerControl : public ros::Msg
+ {
+ public:
+ typedef const char* _name_type;
+ _name_type name;
+ typedef geometry_msgs::Quaternion _orientation_type;
+ _orientation_type orientation;
+ typedef uint8_t _orientation_mode_type;
+ _orientation_mode_type orientation_mode;
+ typedef uint8_t _interaction_mode_type;
+ _interaction_mode_type interaction_mode;
+ typedef bool _always_visible_type;
+ _always_visible_type always_visible;
+ uint32_t markers_length;
+ typedef visualization_msgs::Marker _markers_type;
+ _markers_type st_markers;
+ _markers_type * markers;
+ typedef bool _independent_marker_orientation_type;
+ _independent_marker_orientation_type independent_marker_orientation;
+ typedef const char* _description_type;
+ _description_type description;
+ enum { INHERIT = 0 };
+ enum { FIXED = 1 };
+ enum { VIEW_FACING = 2 };
+ enum { NONE = 0 };
+ enum { MENU = 1 };
+ enum { BUTTON = 2 };
+ enum { MOVE_AXIS = 3 };
+ enum { MOVE_PLANE = 4 };
+ enum { ROTATE_AXIS = 5 };
+ enum { MOVE_ROTATE = 6 };
+ enum { MOVE_3D = 7 };
+ enum { ROTATE_3D = 8 };
+ enum { MOVE_ROTATE_3D = 9 };
+
+ InteractiveMarkerControl():
+ name(""),
+ orientation(),
+ orientation_mode(0),
+ interaction_mode(0),
+ always_visible(0),
+ markers_length(0), markers(NULL),
+ independent_marker_orientation(0),
+ description("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ offset += this->orientation.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->orientation_mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->orientation_mode);
+ *(outbuffer + offset + 0) = (this->interaction_mode >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->interaction_mode);
+ union {
+ bool real;
+ uint8_t base;
+ } u_always_visible;
+ u_always_visible.real = this->always_visible;
+ *(outbuffer + offset + 0) = (u_always_visible.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->always_visible);
+ *(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->markers_length);
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->markers[i].serialize(outbuffer + offset);
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_independent_marker_orientation;
+ u_independent_marker_orientation.real = this->independent_marker_orientation;
+ *(outbuffer + offset + 0) = (u_independent_marker_orientation.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->independent_marker_orientation);
+ uint32_t length_description = strlen(this->description);
+ varToArr(outbuffer + offset, length_description);
+ offset += 4;
+ memcpy(outbuffer + offset, this->description, length_description);
+ offset += length_description;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ offset += this->orientation.deserialize(inbuffer + offset);
+ this->orientation_mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->orientation_mode);
+ this->interaction_mode = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->interaction_mode);
+ union {
+ bool real;
+ uint8_t base;
+ } u_always_visible;
+ u_always_visible.base = 0;
+ u_always_visible.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->always_visible = u_always_visible.real;
+ offset += sizeof(this->always_visible);
+ uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->markers_length);
+ if(markers_lengthT > markers_length)
+ this->markers = (visualization_msgs::Marker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::Marker));
+ markers_length = markers_lengthT;
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->st_markers.deserialize(inbuffer + offset);
+ memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::Marker));
+ }
+ union {
+ bool real;
+ uint8_t base;
+ } u_independent_marker_orientation;
+ u_independent_marker_orientation.base = 0;
+ u_independent_marker_orientation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->independent_marker_orientation = u_independent_marker_orientation.real;
+ offset += sizeof(this->independent_marker_orientation);
+ uint32_t length_description;
+ arrToVar(length_description, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_description; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_description-1]=0;
+ this->description = (char *)(inbuffer + offset-1);
+ offset += length_description;
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/InteractiveMarkerControl"; };
+ const char * getMD5(){ return "b3c81e785788195d1840b86c28da1aac"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/InteractiveMarkerFeedback.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,151 @@
+#ifndef _ROS_visualization_msgs_InteractiveMarkerFeedback_h
+#define _ROS_visualization_msgs_InteractiveMarkerFeedback_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Pose.h"
+#include "geometry_msgs/Point.h"
+
+namespace visualization_msgs
+{
+
+ class InteractiveMarkerFeedback : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _client_id_type;
+ _client_id_type client_id;
+ typedef const char* _marker_name_type;
+ _marker_name_type marker_name;
+ typedef const char* _control_name_type;
+ _control_name_type control_name;
+ typedef uint8_t _event_type_type;
+ _event_type_type event_type;
+ typedef geometry_msgs::Pose _pose_type;
+ _pose_type pose;
+ typedef uint32_t _menu_entry_id_type;
+ _menu_entry_id_type menu_entry_id;
+ typedef geometry_msgs::Point _mouse_point_type;
+ _mouse_point_type mouse_point;
+ typedef bool _mouse_point_valid_type;
+ _mouse_point_valid_type mouse_point_valid;
+ enum { KEEP_ALIVE = 0 };
+ enum { POSE_UPDATE = 1 };
+ enum { MENU_SELECT = 2 };
+ enum { BUTTON_CLICK = 3 };
+ enum { MOUSE_DOWN = 4 };
+ enum { MOUSE_UP = 5 };
+
+ InteractiveMarkerFeedback():
+ header(),
+ client_id(""),
+ marker_name(""),
+ control_name(""),
+ event_type(0),
+ pose(),
+ menu_entry_id(0),
+ mouse_point(),
+ mouse_point_valid(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_client_id = strlen(this->client_id);
+ varToArr(outbuffer + offset, length_client_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->client_id, length_client_id);
+ offset += length_client_id;
+ uint32_t length_marker_name = strlen(this->marker_name);
+ varToArr(outbuffer + offset, length_marker_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->marker_name, length_marker_name);
+ offset += length_marker_name;
+ uint32_t length_control_name = strlen(this->control_name);
+ varToArr(outbuffer + offset, length_control_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->control_name, length_control_name);
+ offset += length_control_name;
+ *(outbuffer + offset + 0) = (this->event_type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->event_type);
+ offset += this->pose.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->menu_entry_id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->menu_entry_id >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->menu_entry_id >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->menu_entry_id >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->menu_entry_id);
+ offset += this->mouse_point.serialize(outbuffer + offset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_mouse_point_valid;
+ u_mouse_point_valid.real = this->mouse_point_valid;
+ *(outbuffer + offset + 0) = (u_mouse_point_valid.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mouse_point_valid);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_client_id;
+ arrToVar(length_client_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_client_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_client_id-1]=0;
+ this->client_id = (char *)(inbuffer + offset-1);
+ offset += length_client_id;
+ uint32_t length_marker_name;
+ arrToVar(length_marker_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_marker_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_marker_name-1]=0;
+ this->marker_name = (char *)(inbuffer + offset-1);
+ offset += length_marker_name;
+ uint32_t length_control_name;
+ arrToVar(length_control_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_control_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_control_name-1]=0;
+ this->control_name = (char *)(inbuffer + offset-1);
+ offset += length_control_name;
+ this->event_type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->event_type);
+ offset += this->pose.deserialize(inbuffer + offset);
+ this->menu_entry_id = ((uint32_t) (*(inbuffer + offset)));
+ this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->menu_entry_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->menu_entry_id);
+ offset += this->mouse_point.deserialize(inbuffer + offset);
+ union {
+ bool real;
+ uint8_t base;
+ } u_mouse_point_valid;
+ u_mouse_point_valid.base = 0;
+ u_mouse_point_valid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->mouse_point_valid = u_mouse_point_valid.real;
+ offset += sizeof(this->mouse_point_valid);
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/InteractiveMarkerFeedback"; };
+ const char * getMD5(){ return "ab0f1eee058667e28c19ff3ffc3f4b78"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/InteractiveMarkerInit.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,105 @@
+#ifndef _ROS_visualization_msgs_InteractiveMarkerInit_h
+#define _ROS_visualization_msgs_InteractiveMarkerInit_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "visualization_msgs/InteractiveMarker.h"
+
+namespace visualization_msgs
+{
+
+ class InteractiveMarkerInit : public ros::Msg
+ {
+ public:
+ typedef const char* _server_id_type;
+ _server_id_type server_id;
+ typedef uint64_t _seq_num_type;
+ _seq_num_type seq_num;
+ uint32_t markers_length;
+ typedef visualization_msgs::InteractiveMarker _markers_type;
+ _markers_type st_markers;
+ _markers_type * markers;
+
+ InteractiveMarkerInit():
+ server_id(""),
+ seq_num(0),
+ markers_length(0), markers(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_server_id = strlen(this->server_id);
+ varToArr(outbuffer + offset, length_server_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->server_id, length_server_id);
+ offset += length_server_id;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_seq_num;
+ u_seq_num.real = this->seq_num;
+ *(outbuffer + offset + 0) = (u_seq_num.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_seq_num.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_seq_num.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_seq_num.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->seq_num);
+ *(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->markers_length);
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->markers[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_server_id;
+ arrToVar(length_server_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_server_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_server_id-1]=0;
+ this->server_id = (char *)(inbuffer + offset-1);
+ offset += length_server_id;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_seq_num;
+ u_seq_num.base = 0;
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->seq_num = u_seq_num.real;
+ offset += sizeof(this->seq_num);
+ uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->markers_length);
+ if(markers_lengthT > markers_length)
+ this->markers = (visualization_msgs::InteractiveMarker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::InteractiveMarker));
+ markers_length = markers_lengthT;
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->st_markers.deserialize(inbuffer + offset);
+ memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::InteractiveMarker));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/InteractiveMarkerInit"; };
+ const char * getMD5(){ return "d5f2c5045a72456d228676ab91048734"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/InteractiveMarkerPose.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,67 @@
+#ifndef _ROS_visualization_msgs_InteractiveMarkerPose_h
+#define _ROS_visualization_msgs_InteractiveMarkerPose_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Pose.h"
+
+namespace visualization_msgs
+{
+
+ class InteractiveMarkerPose : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef geometry_msgs::Pose _pose_type;
+ _pose_type pose;
+ typedef const char* _name_type;
+ _name_type name;
+
+ InteractiveMarkerPose():
+ header(),
+ pose(),
+ name("")
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ offset += this->pose.serialize(outbuffer + offset);
+ uint32_t length_name = strlen(this->name);
+ varToArr(outbuffer + offset, length_name);
+ offset += 4;
+ memcpy(outbuffer + offset, this->name, length_name);
+ offset += length_name;
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ offset += this->pose.deserialize(inbuffer + offset);
+ uint32_t length_name;
+ arrToVar(length_name, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_name; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_name-1]=0;
+ this->name = (char *)(inbuffer + offset-1);
+ offset += length_name;
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/InteractiveMarkerPose"; };
+ const char * getMD5(){ return "a6e6833209a196a38d798dadb02c81f8"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/InteractiveMarkerUpdate.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,177 @@
+#ifndef _ROS_visualization_msgs_InteractiveMarkerUpdate_h
+#define _ROS_visualization_msgs_InteractiveMarkerUpdate_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "visualization_msgs/InteractiveMarker.h"
+#include "visualization_msgs/InteractiveMarkerPose.h"
+
+namespace visualization_msgs
+{
+
+ class InteractiveMarkerUpdate : public ros::Msg
+ {
+ public:
+ typedef const char* _server_id_type;
+ _server_id_type server_id;
+ typedef uint64_t _seq_num_type;
+ _seq_num_type seq_num;
+ typedef uint8_t _type_type;
+ _type_type type;
+ uint32_t markers_length;
+ typedef visualization_msgs::InteractiveMarker _markers_type;
+ _markers_type st_markers;
+ _markers_type * markers;
+ uint32_t poses_length;
+ typedef visualization_msgs::InteractiveMarkerPose _poses_type;
+ _poses_type st_poses;
+ _poses_type * poses;
+ uint32_t erases_length;
+ typedef char* _erases_type;
+ _erases_type st_erases;
+ _erases_type * erases;
+ enum { KEEP_ALIVE = 0 };
+ enum { UPDATE = 1 };
+
+ InteractiveMarkerUpdate():
+ server_id(""),
+ seq_num(0),
+ type(0),
+ markers_length(0), markers(NULL),
+ poses_length(0), poses(NULL),
+ erases_length(0), erases(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ uint32_t length_server_id = strlen(this->server_id);
+ varToArr(outbuffer + offset, length_server_id);
+ offset += 4;
+ memcpy(outbuffer + offset, this->server_id, length_server_id);
+ offset += length_server_id;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_seq_num;
+ u_seq_num.real = this->seq_num;
+ *(outbuffer + offset + 0) = (u_seq_num.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_seq_num.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_seq_num.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_seq_num.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->seq_num);
+ *(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->type);
+ *(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->markers_length);
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->markers[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->poses_length);
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->poses[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->erases_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->erases_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->erases_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->erases_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->erases_length);
+ for( uint32_t i = 0; i < erases_length; i++){
+ uint32_t length_erasesi = strlen(this->erases[i]);
+ varToArr(outbuffer + offset, length_erasesi);
+ offset += 4;
+ memcpy(outbuffer + offset, this->erases[i], length_erasesi);
+ offset += length_erasesi;
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t length_server_id;
+ arrToVar(length_server_id, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_server_id; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_server_id-1]=0;
+ this->server_id = (char *)(inbuffer + offset-1);
+ offset += length_server_id;
+ union {
+ uint64_t real;
+ uint32_t base;
+ } u_seq_num;
+ u_seq_num.base = 0;
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_seq_num.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->seq_num = u_seq_num.real;
+ offset += sizeof(this->seq_num);
+ this->type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->type);
+ uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->markers_length);
+ if(markers_lengthT > markers_length)
+ this->markers = (visualization_msgs::InteractiveMarker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::InteractiveMarker));
+ markers_length = markers_lengthT;
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->st_markers.deserialize(inbuffer + offset);
+ memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::InteractiveMarker));
+ }
+ uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->poses_length);
+ if(poses_lengthT > poses_length)
+ this->poses = (visualization_msgs::InteractiveMarkerPose*)realloc(this->poses, poses_lengthT * sizeof(visualization_msgs::InteractiveMarkerPose));
+ poses_length = poses_lengthT;
+ for( uint32_t i = 0; i < poses_length; i++){
+ offset += this->st_poses.deserialize(inbuffer + offset);
+ memcpy( &(this->poses[i]), &(this->st_poses), sizeof(visualization_msgs::InteractiveMarkerPose));
+ }
+ uint32_t erases_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->erases_length);
+ if(erases_lengthT > erases_length)
+ this->erases = (char**)realloc(this->erases, erases_lengthT * sizeof(char*));
+ erases_length = erases_lengthT;
+ for( uint32_t i = 0; i < erases_length; i++){
+ uint32_t length_st_erases;
+ arrToVar(length_st_erases, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_st_erases; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_st_erases-1]=0;
+ this->st_erases = (char *)(inbuffer + offset-1);
+ offset += length_st_erases;
+ memcpy( &(this->erases[i]), &(this->st_erases), sizeof(char*));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/InteractiveMarkerUpdate"; };
+ const char * getMD5(){ return "710d308d0a9276d65945e92dd30b3946"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/Marker.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,312 @@
+#ifndef _ROS_visualization_msgs_Marker_h
+#define _ROS_visualization_msgs_Marker_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "std_msgs/Header.h"
+#include "geometry_msgs/Pose.h"
+#include "geometry_msgs/Vector3.h"
+#include "std_msgs/ColorRGBA.h"
+#include "ros/duration.h"
+#include "geometry_msgs/Point.h"
+
+namespace visualization_msgs
+{
+
+ class Marker : public ros::Msg
+ {
+ public:
+ typedef std_msgs::Header _header_type;
+ _header_type header;
+ typedef const char* _ns_type;
+ _ns_type ns;
+ typedef int32_t _id_type;
+ _id_type id;
+ typedef int32_t _type_type;
+ _type_type type;
+ typedef int32_t _action_type;
+ _action_type action;
+ typedef geometry_msgs::Pose _pose_type;
+ _pose_type pose;
+ typedef geometry_msgs::Vector3 _scale_type;
+ _scale_type scale;
+ typedef std_msgs::ColorRGBA _color_type;
+ _color_type color;
+ typedef ros::Duration _lifetime_type;
+ _lifetime_type lifetime;
+ typedef bool _frame_locked_type;
+ _frame_locked_type frame_locked;
+ uint32_t points_length;
+ typedef geometry_msgs::Point _points_type;
+ _points_type st_points;
+ _points_type * points;
+ uint32_t colors_length;
+ typedef std_msgs::ColorRGBA _colors_type;
+ _colors_type st_colors;
+ _colors_type * colors;
+ typedef const char* _text_type;
+ _text_type text;
+ typedef const char* _mesh_resource_type;
+ _mesh_resource_type mesh_resource;
+ typedef bool _mesh_use_embedded_materials_type;
+ _mesh_use_embedded_materials_type mesh_use_embedded_materials;
+ enum { ARROW = 0 };
+ enum { CUBE = 1 };
+ enum { SPHERE = 2 };
+ enum { CYLINDER = 3 };
+ enum { LINE_STRIP = 4 };
+ enum { LINE_LIST = 5 };
+ enum { CUBE_LIST = 6 };
+ enum { SPHERE_LIST = 7 };
+ enum { POINTS = 8 };
+ enum { TEXT_VIEW_FACING = 9 };
+ enum { MESH_RESOURCE = 10 };
+ enum { TRIANGLE_LIST = 11 };
+ enum { ADD = 0 };
+ enum { MODIFY = 0 };
+ enum { DELETE = 2 };
+ enum { DELETEALL = 3 };
+
+ Marker():
+ header(),
+ ns(""),
+ id(0),
+ type(0),
+ action(0),
+ pose(),
+ scale(),
+ color(),
+ lifetime(),
+ frame_locked(0),
+ points_length(0), points(NULL),
+ colors_length(0), colors(NULL),
+ text(""),
+ mesh_resource(""),
+ mesh_use_embedded_materials(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ offset += this->header.serialize(outbuffer + offset);
+ uint32_t length_ns = strlen(this->ns);
+ varToArr(outbuffer + offset, length_ns);
+ offset += 4;
+ memcpy(outbuffer + offset, this->ns, length_ns);
+ offset += length_ns;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.real = this->id;
+ *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->id);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_type;
+ u_type.real = this->type;
+ *(outbuffer + offset + 0) = (u_type.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_type.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_type.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_type.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->type);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_action;
+ u_action.real = this->action;
+ *(outbuffer + offset + 0) = (u_action.base >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (u_action.base >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (u_action.base >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (u_action.base >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->action);
+ offset += this->pose.serialize(outbuffer + offset);
+ offset += this->scale.serialize(outbuffer + offset);
+ offset += this->color.serialize(outbuffer + offset);
+ *(outbuffer + offset + 0) = (this->lifetime.sec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->lifetime.sec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->lifetime.sec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->lifetime.sec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->lifetime.sec);
+ *(outbuffer + offset + 0) = (this->lifetime.nsec >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->lifetime.nsec >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->lifetime.nsec >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->lifetime.nsec >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->lifetime.nsec);
+ union {
+ bool real;
+ uint8_t base;
+ } u_frame_locked;
+ u_frame_locked.real = this->frame_locked;
+ *(outbuffer + offset + 0) = (u_frame_locked.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->frame_locked);
+ *(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->points_length);
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->points[i].serialize(outbuffer + offset);
+ }
+ *(outbuffer + offset + 0) = (this->colors_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->colors_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->colors_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->colors_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->colors_length);
+ for( uint32_t i = 0; i < colors_length; i++){
+ offset += this->colors[i].serialize(outbuffer + offset);
+ }
+ uint32_t length_text = strlen(this->text);
+ varToArr(outbuffer + offset, length_text);
+ offset += 4;
+ memcpy(outbuffer + offset, this->text, length_text);
+ offset += length_text;
+ uint32_t length_mesh_resource = strlen(this->mesh_resource);
+ varToArr(outbuffer + offset, length_mesh_resource);
+ offset += 4;
+ memcpy(outbuffer + offset, this->mesh_resource, length_mesh_resource);
+ offset += length_mesh_resource;
+ union {
+ bool real;
+ uint8_t base;
+ } u_mesh_use_embedded_materials;
+ u_mesh_use_embedded_materials.real = this->mesh_use_embedded_materials;
+ *(outbuffer + offset + 0) = (u_mesh_use_embedded_materials.base >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->mesh_use_embedded_materials);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ offset += this->header.deserialize(inbuffer + offset);
+ uint32_t length_ns;
+ arrToVar(length_ns, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_ns; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_ns-1]=0;
+ this->ns = (char *)(inbuffer + offset-1);
+ offset += length_ns;
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_id;
+ u_id.base = 0;
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->id = u_id.real;
+ offset += sizeof(this->id);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_type;
+ u_type.base = 0;
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_type.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->type = u_type.real;
+ offset += sizeof(this->type);
+ union {
+ int32_t real;
+ uint32_t base;
+ } u_action;
+ u_action.base = 0;
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ u_action.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ this->action = u_action.real;
+ offset += sizeof(this->action);
+ offset += this->pose.deserialize(inbuffer + offset);
+ offset += this->scale.deserialize(inbuffer + offset);
+ offset += this->color.deserialize(inbuffer + offset);
+ this->lifetime.sec = ((uint32_t) (*(inbuffer + offset)));
+ this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->lifetime.sec);
+ this->lifetime.nsec = ((uint32_t) (*(inbuffer + offset)));
+ this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->lifetime.nsec);
+ union {
+ bool real;
+ uint8_t base;
+ } u_frame_locked;
+ u_frame_locked.base = 0;
+ u_frame_locked.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->frame_locked = u_frame_locked.real;
+ offset += sizeof(this->frame_locked);
+ uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->points_length);
+ if(points_lengthT > points_length)
+ this->points = (geometry_msgs::Point*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point));
+ points_length = points_lengthT;
+ for( uint32_t i = 0; i < points_length; i++){
+ offset += this->st_points.deserialize(inbuffer + offset);
+ memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point));
+ }
+ uint32_t colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->colors_length);
+ if(colors_lengthT > colors_length)
+ this->colors = (std_msgs::ColorRGBA*)realloc(this->colors, colors_lengthT * sizeof(std_msgs::ColorRGBA));
+ colors_length = colors_lengthT;
+ for( uint32_t i = 0; i < colors_length; i++){
+ offset += this->st_colors.deserialize(inbuffer + offset);
+ memcpy( &(this->colors[i]), &(this->st_colors), sizeof(std_msgs::ColorRGBA));
+ }
+ uint32_t length_text;
+ arrToVar(length_text, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_text; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_text-1]=0;
+ this->text = (char *)(inbuffer + offset-1);
+ offset += length_text;
+ uint32_t length_mesh_resource;
+ arrToVar(length_mesh_resource, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_mesh_resource; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_mesh_resource-1]=0;
+ this->mesh_resource = (char *)(inbuffer + offset-1);
+ offset += length_mesh_resource;
+ union {
+ bool real;
+ uint8_t base;
+ } u_mesh_use_embedded_materials;
+ u_mesh_use_embedded_materials.base = 0;
+ u_mesh_use_embedded_materials.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
+ this->mesh_use_embedded_materials = u_mesh_use_embedded_materials.real;
+ offset += sizeof(this->mesh_use_embedded_materials);
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/Marker"; };
+ const char * getMD5(){ return "4048c9de2a16f4ae8e0538085ebf1b97"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/MarkerArray.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,64 @@
+#ifndef _ROS_visualization_msgs_MarkerArray_h
+#define _ROS_visualization_msgs_MarkerArray_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+#include "visualization_msgs/Marker.h"
+
+namespace visualization_msgs
+{
+
+ class MarkerArray : public ros::Msg
+ {
+ public:
+ uint32_t markers_length;
+ typedef visualization_msgs::Marker _markers_type;
+ _markers_type st_markers;
+ _markers_type * markers;
+
+ MarkerArray():
+ markers_length(0), markers(NULL)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->markers_length);
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->markers[i].serialize(outbuffer + offset);
+ }
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->markers_length);
+ if(markers_lengthT > markers_length)
+ this->markers = (visualization_msgs::Marker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::Marker));
+ markers_length = markers_lengthT;
+ for( uint32_t i = 0; i < markers_length; i++){
+ offset += this->st_markers.deserialize(inbuffer + offset);
+ memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::Marker));
+ }
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/MarkerArray"; };
+ const char * getMD5(){ return "d155b9ce5188fbaf89745847fd5882d7"; };
+
+ };
+
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ros_lib/visualization_msgs/MenuEntry.h Wed Sep 02 13:51:31 2020 +0000
@@ -0,0 +1,108 @@
+#ifndef _ROS_visualization_msgs_MenuEntry_h
+#define _ROS_visualization_msgs_MenuEntry_h
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include "ros/msg.h"
+
+namespace visualization_msgs
+{
+
+ class MenuEntry : public ros::Msg
+ {
+ public:
+ typedef uint32_t _id_type;
+ _id_type id;
+ typedef uint32_t _parent_id_type;
+ _parent_id_type parent_id;
+ typedef const char* _title_type;
+ _title_type title;
+ typedef const char* _command_type;
+ _command_type command;
+ typedef uint8_t _command_type_type;
+ _command_type_type command_type;
+ enum { FEEDBACK = 0 };
+ enum { ROSRUN = 1 };
+ enum { ROSLAUNCH = 2 };
+
+ MenuEntry():
+ id(0),
+ parent_id(0),
+ title(""),
+ command(""),
+ command_type(0)
+ {
+ }
+
+ virtual int serialize(unsigned char *outbuffer) const
+ {
+ int offset = 0;
+ *(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->id);
+ *(outbuffer + offset + 0) = (this->parent_id >> (8 * 0)) & 0xFF;
+ *(outbuffer + offset + 1) = (this->parent_id >> (8 * 1)) & 0xFF;
+ *(outbuffer + offset + 2) = (this->parent_id >> (8 * 2)) & 0xFF;
+ *(outbuffer + offset + 3) = (this->parent_id >> (8 * 3)) & 0xFF;
+ offset += sizeof(this->parent_id);
+ uint32_t length_title = strlen(this->title);
+ varToArr(outbuffer + offset, length_title);
+ offset += 4;
+ memcpy(outbuffer + offset, this->title, length_title);
+ offset += length_title;
+ uint32_t length_command = strlen(this->command);
+ varToArr(outbuffer + offset, length_command);
+ offset += 4;
+ memcpy(outbuffer + offset, this->command, length_command);
+ offset += length_command;
+ *(outbuffer + offset + 0) = (this->command_type >> (8 * 0)) & 0xFF;
+ offset += sizeof(this->command_type);
+ return offset;
+ }
+
+ virtual int deserialize(unsigned char *inbuffer)
+ {
+ int offset = 0;
+ this->id = ((uint32_t) (*(inbuffer + offset)));
+ this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->id);
+ this->parent_id = ((uint32_t) (*(inbuffer + offset)));
+ this->parent_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
+ this->parent_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
+ this->parent_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
+ offset += sizeof(this->parent_id);
+ uint32_t length_title;
+ arrToVar(length_title, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_title; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_title-1]=0;
+ this->title = (char *)(inbuffer + offset-1);
+ offset += length_title;
+ uint32_t length_command;
+ arrToVar(length_command, (inbuffer + offset));
+ offset += 4;
+ for(unsigned int k= offset; k< offset+length_command; ++k){
+ inbuffer[k-1]=inbuffer[k];
+ }
+ inbuffer[offset+length_command-1]=0;
+ this->command = (char *)(inbuffer + offset-1);
+ offset += length_command;
+ this->command_type = ((uint8_t) (*(inbuffer + offset)));
+ offset += sizeof(this->command_type);
+ return offset;
+ }
+
+ const char * getType(){ return "visualization_msgs/MenuEntry"; };
+ const char * getMD5(){ return "b90ec63024573de83b57aa93eb39be2d"; };
+
+ };
+
+}
+#endif