Fresh import of the PX4 firmware sources.

31 files changed, 13876 insertions, 0 deletions

diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/checksum.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/checksum.h
new file mode 100644
index 000000000..b70991f5a
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/checksum.h
@@ -0,0 +1,89 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _CHECKSUM_H_
+#define _CHECKSUM_H_
+
+
+/**
+ *
+ *  CALCULATE THE CHECKSUM
+ *
+ */
+
+#define X25_INIT_CRC 0xffff
+#define X25_VALIDATE_CRC 0xf0b8
+
+/**
+ * @brief Accumulate the X.25 CRC by adding one char at a time.
+ *
+ * The checksum function adds the hash of one char at a time to the
+ * 16 bit checksum (uint16_t).
+ *
+ * @param data new char to hash
+ * @param crcAccum the already accumulated checksum
+ **/
+static inline void crc_accumulate(uint8_t data, uint16_t *crcAccum)
+{
+        /*Accumulate one byte of data into the CRC*/
+        uint8_t tmp;
+
+        tmp = data ^ (uint8_t)(*crcAccum &0xff);
+        tmp ^= (tmp<<4);
+        *crcAccum = (*crcAccum>>8) ^ (tmp<<8) ^ (tmp <<3) ^ (tmp>>4);
+}
+
+/**
+ * @brief Initiliaze the buffer for the X.25 CRC
+ *
+ * @param crcAccum the 16 bit X.25 CRC
+ */
+static inline void crc_init(uint16_t* crcAccum)
+{
+        *crcAccum = X25_INIT_CRC;
+}
+
+
+/**
+ * @brief Calculates the X.25 checksum on a byte buffer
+ *
+ * @param  pBuffer buffer containing the byte array to hash
+ * @param  length  length of the byte array
+ * @return the checksum over the buffer bytes
+ **/
+static inline uint16_t crc_calculate(uint8_t* pBuffer, uint16_t length)
+{
+        uint16_t crcTmp;
+        crc_init(&crcTmp);
+	while (length--) {
+                crc_accumulate(*pBuffer++, &crcTmp);
+        }
+        return crcTmp;
+}
+
+/**
+ * @brief Accumulate the X.25 CRC by adding an array of bytes
+ *
+ * The checksum function adds the hash of one char at a time to the
+ * 16 bit checksum (uint16_t).
+ *
+ * @param data new bytes to hash
+ * @param crcAccum the already accumulated checksum
+ **/
+static inline void crc_accumulate_buffer(uint16_t *crcAccum, const char *pBuffer, uint8_t length)
+{
+	const uint8_t *p = (const uint8_t *)pBuffer;
+	while (length--) {
+                crc_accumulate(*p++, crcAccum);
+        }
+}
+
+
+
+
+#endif /* _CHECKSUM_H_ */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/mavlink_helpers.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/mavlink_helpers.h
new file mode 100644
index 000000000..98250e1ac
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/mavlink_helpers.h
@@ -0,0 +1,488 @@
+#ifndef  _MAVLINK_HELPERS_H_
+#define  _MAVLINK_HELPERS_H_
+
+#include "string.h"
+#include "checksum.h"
+#include "mavlink_types.h"
+
+#ifndef MAVLINK_HELPER
+#define MAVLINK_HELPER
+#endif
+
+/*
+  internal function to give access to the channel status for each channel
+ */
+MAVLINK_HELPER mavlink_status_t* mavlink_get_channel_status(uint8_t chan)
+{
+	static mavlink_status_t m_mavlink_status[MAVLINK_COMM_NUM_BUFFERS];
+	return &m_mavlink_status[chan];
+}
+
+/**
+ * @brief Finalize a MAVLink message with channel assignment
+ *
+ * This function calculates the checksum and sets length and aircraft id correctly.
+ * It assumes that the message id and the payload are already correctly set. This function
+ * can also be used if the message header has already been written before (as in mavlink_msg_xxx_pack
+ * instead of mavlink_msg_xxx_pack_headerless), it just introduces little extra overhead.
+ *
+ * @param msg Message to finalize
+ * @param system_id Id of the sending (this) system, 1-127
+ * @param length Message length
+ */
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length, uint8_t crc_extra)
+#else
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length)
+#endif
+{
+	// This code part is the same for all messages;
+	uint16_t checksum;
+	msg->magic = MAVLINK_STX;
+	msg->len = length;
+	msg->sysid = system_id;
+	msg->compid = component_id;
+	// One sequence number per component
+	msg->seq = mavlink_get_channel_status(chan)->current_tx_seq;
+	mavlink_get_channel_status(chan)->current_tx_seq = mavlink_get_channel_status(chan)->current_tx_seq+1;
+	checksum = crc_calculate((uint8_t*)&msg->len, length + MAVLINK_CORE_HEADER_LEN);
+#if MAVLINK_CRC_EXTRA
+	crc_accumulate(crc_extra, &checksum);
+#endif
+	mavlink_ck_a(msg) = (uint8_t)(checksum & 0xFF);
+	mavlink_ck_b(msg) = (uint8_t)(checksum >> 8);
+
+	return length + MAVLINK_NUM_NON_PAYLOAD_BYTES;
+}
+
+
+/**
+ * @brief Finalize a MAVLink message with MAVLINK_COMM_0 as default channel
+ */
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length, uint8_t crc_extra)
+{
+	return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, length, crc_extra);
+}
+#else
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length)
+{
+	return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, length);
+}
+#endif
+
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len);
+
+/**
+ * @brief Finalize a MAVLink message with channel assignment and send
+ */
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, 
+						    uint8_t length, uint8_t crc_extra)
+#else
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, uint8_t length)
+#endif
+{
+	uint16_t checksum;
+	uint8_t buf[MAVLINK_NUM_HEADER_BYTES];
+	uint8_t ck[2];
+	mavlink_status_t *status = mavlink_get_channel_status(chan);
+	buf[0] = MAVLINK_STX;
+	buf[1] = length;
+	buf[2] = status->current_tx_seq;
+	buf[3] = mavlink_system.sysid;
+	buf[4] = mavlink_system.compid;
+	buf[5] = msgid;
+	status->current_tx_seq++;
+	checksum = crc_calculate((uint8_t*)&buf[1], MAVLINK_CORE_HEADER_LEN);
+	crc_accumulate_buffer(&checksum, packet, length);
+#if MAVLINK_CRC_EXTRA
+	crc_accumulate(crc_extra, &checksum);
+#endif
+	ck[0] = (uint8_t)(checksum & 0xFF);
+	ck[1] = (uint8_t)(checksum >> 8);
+
+	MAVLINK_START_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)length);
+	_mavlink_send_uart(chan, (const char *)buf, MAVLINK_NUM_HEADER_BYTES);
+	_mavlink_send_uart(chan, packet, length);
+	_mavlink_send_uart(chan, (const char *)ck, 2);
+	MAVLINK_END_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)length);
+}
+#endif // MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+/**
+ * @brief Pack a message to send it over a serial byte stream
+ */
+MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t *buffer, const mavlink_message_t *msg)
+{
+	memcpy(buffer, (uint8_t *)&msg->magic, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len);
+	return MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len;
+}
+
+union __mavlink_bitfield {
+	uint8_t uint8;
+	int8_t int8;
+	uint16_t uint16;
+	int16_t int16;
+	uint32_t uint32;
+	int32_t int32;
+};
+
+
+MAVLINK_HELPER void mavlink_start_checksum(mavlink_message_t* msg)
+{
+	crc_init(&msg->checksum);
+}
+
+MAVLINK_HELPER void mavlink_update_checksum(mavlink_message_t* msg, uint8_t c)
+{
+	crc_accumulate(c, &msg->checksum);
+}
+
+/**
+ * This is a convenience function which handles the complete MAVLink parsing.
+ * the function will parse one byte at a time and return the complete packet once
+ * it could be successfully decoded. Checksum and other failures will be silently
+ * ignored.
+ *
+ * @param chan     ID of the current channel. This allows to parse different channels with this function.
+ *                 a channel is not a physical message channel like a serial port, but a logic partition of
+ *                 the communication streams in this case. COMM_NB is the limit for the number of channels
+ *                 on MCU (e.g. ARM7), while COMM_NB_HIGH is the limit for the number of channels in Linux/Windows
+ * @param c        The char to barse
+ *
+ * @param returnMsg NULL if no message could be decoded, the message data else
+ * @return 0 if no message could be decoded, 1 else
+ *
+ * A typical use scenario of this function call is:
+ *
+ * @code
+ * #include <inttypes.h> // For fixed-width uint8_t type
+ *
+ * mavlink_message_t msg;
+ * int chan = 0;
+ *
+ *
+ * while(serial.bytesAvailable > 0)
+ * {
+ *   uint8_t byte = serial.getNextByte();
+ *   if (mavlink_parse_char(chan, byte, &msg))
+ *     {
+ *     printf("Received message with ID %d, sequence: %d from component %d of system %d", msg.msgid, msg.seq, msg.compid, msg.sysid);
+ *     }
+ * }
+ *
+ *
+ * @endcode
+ */
+MAVLINK_HELPER uint8_t mavlink_parse_char(uint8_t chan, uint8_t c, mavlink_message_t* r_message, mavlink_status_t* r_mavlink_status)
+{
+	static mavlink_message_t m_mavlink_message[MAVLINK_COMM_NUM_BUFFERS];
+
+        /*
+	  default message crc function. You can override this per-system to
+	  put this data in a different memory segment
+	*/
+#if MAVLINK_CRC_EXTRA
+#ifndef MAVLINK_MESSAGE_CRC
+	static const uint8_t mavlink_message_crcs[256] = MAVLINK_MESSAGE_CRCS;
+#define MAVLINK_MESSAGE_CRC(msgid) mavlink_message_crcs[msgid]
+#endif
+#endif
+
+	mavlink_message_t* rxmsg = &m_mavlink_message[chan]; ///< The currently decoded message
+	mavlink_status_t* status = mavlink_get_channel_status(chan); ///< The current decode status
+	int bufferIndex = 0;
+
+	status->msg_received = 0;
+
+	switch (status->parse_state)
+	{
+	case MAVLINK_PARSE_STATE_UNINIT:
+	case MAVLINK_PARSE_STATE_IDLE:
+		if (c == MAVLINK_STX)
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
+			rxmsg->len = 0;
+			mavlink_start_checksum(rxmsg);
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_STX:
+			if (status->msg_received 
+			/* Support shorter buffers than the
+			 default maximum packet size */
+#if (MAVLINK_MAX_PAYLOAD_LEN < 255)
+				|| c > MAVLINK_MAX_PAYLOAD_LEN
+#endif
+				)
+		{
+			status->buffer_overrun++;
+			status->parse_error++;
+			status->msg_received = 0;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+		}
+		else
+		{
+			// NOT counting STX, LENGTH, SEQ, SYSID, COMPID, MSGID, CRC1 and CRC2
+			rxmsg->len = c;
+			status->packet_idx = 0;
+			mavlink_update_checksum(rxmsg, c);
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_LENGTH;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_LENGTH:
+		rxmsg->seq = c;
+		mavlink_update_checksum(rxmsg, c);
+		status->parse_state = MAVLINK_PARSE_STATE_GOT_SEQ;
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_SEQ:
+		rxmsg->sysid = c;
+		mavlink_update_checksum(rxmsg, c);
+		status->parse_state = MAVLINK_PARSE_STATE_GOT_SYSID;
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_SYSID:
+		rxmsg->compid = c;
+		mavlink_update_checksum(rxmsg, c);
+		status->parse_state = MAVLINK_PARSE_STATE_GOT_COMPID;
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_COMPID:
+		rxmsg->msgid = c;
+		mavlink_update_checksum(rxmsg, c);
+		if (rxmsg->len == 0)
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
+		}
+		else
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_MSGID;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_MSGID:
+		_MAV_PAYLOAD(rxmsg)[status->packet_idx++] = (char)c;
+		mavlink_update_checksum(rxmsg, c);
+		if (status->packet_idx == rxmsg->len)
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_PAYLOAD:
+#if MAVLINK_CRC_EXTRA
+		mavlink_update_checksum(rxmsg, MAVLINK_MESSAGE_CRC(rxmsg->msgid));
+#endif
+		if (c != (rxmsg->checksum & 0xFF)) {
+			// Check first checksum byte
+			status->parse_error++;
+			status->msg_received = 0;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+			if (c == MAVLINK_STX)
+			{
+				status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
+				rxmsg->len = 0;
+				mavlink_start_checksum(rxmsg);
+			}
+		}
+		else
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_CRC1;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_CRC1:
+		if (c != (rxmsg->checksum >> 8)) {
+			// Check second checksum byte
+			status->parse_error++;
+			status->msg_received = 0;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+			if (c == MAVLINK_STX)
+			{
+				status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
+				rxmsg->len = 0;
+				mavlink_start_checksum(rxmsg);
+			}
+		}
+		else
+		{
+			// Successfully got message
+			status->msg_received = 1;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+			memcpy(r_message, rxmsg, sizeof(mavlink_message_t));
+		}
+		break;
+	}
+
+	bufferIndex++;
+	// If a message has been sucessfully decoded, check index
+	if (status->msg_received == 1)
+	{
+		//while(status->current_seq != rxmsg->seq)
+		//{
+		//	status->packet_rx_drop_count++;
+		//               status->current_seq++;
+		//}
+		status->current_rx_seq = rxmsg->seq;
+		// Initial condition: If no packet has been received so far, drop count is undefined
+		if (status->packet_rx_success_count == 0) status->packet_rx_drop_count = 0;
+		// Count this packet as received
+		status->packet_rx_success_count++;
+	}
+
+	r_mavlink_status->current_rx_seq = status->current_rx_seq+1;
+	r_mavlink_status->packet_rx_success_count = status->packet_rx_success_count;
+	r_mavlink_status->packet_rx_drop_count = status->parse_error;
+	status->parse_error = 0;
+	return status->msg_received;
+}
+
+/**
+ * @brief Put a bitfield of length 1-32 bit into the buffer
+ *
+ * @param b the value to add, will be encoded in the bitfield
+ * @param bits number of bits to use to encode b, e.g. 1 for boolean, 2, 3, etc.
+ * @param packet_index the position in the packet (the index of the first byte to use)
+ * @param bit_index the position in the byte (the index of the first bit to use)
+ * @param buffer packet buffer to write into
+ * @return new position of the last used byte in the buffer
+ */
+MAVLINK_HELPER uint8_t put_bitfield_n_by_index(int32_t b, uint8_t bits, uint8_t packet_index, uint8_t bit_index, uint8_t* r_bit_index, uint8_t* buffer)
+{
+	uint16_t bits_remain = bits;
+	// Transform number into network order
+	int32_t v;
+	uint8_t i_bit_index, i_byte_index, curr_bits_n;
+#if MAVLINK_NEED_BYTE_SWAP
+	union {
+		int32_t i;
+		uint8_t b[4];
+	} bin, bout;
+	bin.i = b;
+	bout.b[0] = bin.b[3];
+	bout.b[1] = bin.b[2];
+	bout.b[2] = bin.b[1];
+	bout.b[3] = bin.b[0];
+	v = bout.i;
+#else
+	v = b;
+#endif
+
+	// buffer in
+	// 01100000 01000000 00000000 11110001
+	// buffer out
+	// 11110001 00000000 01000000 01100000
+
+	// Existing partly filled byte (four free slots)
+	// 0111xxxx
+
+	// Mask n free bits
+	// 00001111 = 2^0 + 2^1 + 2^2 + 2^3 = 2^n - 1
+	// = ((uint32_t)(1 << n)) - 1; // = 2^n - 1
+
+	// Shift n bits into the right position
+	// out = in >> n;
+
+	// Mask and shift bytes
+	i_bit_index = bit_index;
+	i_byte_index = packet_index;
+	if (bit_index > 0)
+	{
+		// If bits were available at start, they were available
+		// in the byte before the current index
+		i_byte_index--;
+	}
+
+	// While bits have not been packed yet
+	while (bits_remain > 0)
+	{
+		// Bits still have to be packed
+		// there can be more than 8 bits, so
+		// we might have to pack them into more than one byte
+
+		// First pack everything we can into the current 'open' byte
+		//curr_bits_n = bits_remain << 3; // Equals  bits_remain mod 8
+		//FIXME
+		if (bits_remain <= (uint8_t)(8 - i_bit_index))
+		{
+			// Enough space
+			curr_bits_n = (uint8_t)bits_remain;
+		}
+		else
+		{
+			curr_bits_n = (8 - i_bit_index);
+		}
+		
+		// Pack these n bits into the current byte
+		// Mask out whatever was at that position with ones (xxx11111)
+		buffer[i_byte_index] &= (0xFF >> (8 - curr_bits_n));
+		// Put content to this position, by masking out the non-used part
+		buffer[i_byte_index] |= ((0x00 << curr_bits_n) & v);
+		
+		// Increment the bit index
+		i_bit_index += curr_bits_n;
+
+		// Now proceed to the next byte, if necessary
+		bits_remain -= curr_bits_n;
+		if (bits_remain > 0)
+		{
+			// Offer another 8 bits / one byte
+			i_byte_index++;
+			i_bit_index = 0;
+		}
+	}
+	
+	*r_bit_index = i_bit_index;
+	// If a partly filled byte is present, mark this as consumed
+	if (i_bit_index != 7) i_byte_index++;
+	return i_byte_index - packet_index;
+}
+
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+// To make MAVLink work on your MCU, define comm_send_ch() if you wish
+// to send 1 byte at a time, or MAVLINK_SEND_UART_BYTES() to send a
+// whole packet at a time
+
+/*
+
+#include "mavlink_types.h"
+
+void comm_send_ch(mavlink_channel_t chan, uint8_t ch)
+{
+    if (chan == MAVLINK_COMM_0)
+    {
+        uart0_transmit(ch);
+    }
+    if (chan == MAVLINK_COMM_1)
+    {
+    	uart1_transmit(ch);
+    }
+}
+ */
+
+MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len)
+{
+#ifdef MAVLINK_SEND_UART_BYTES
+	/* this is the more efficient approach, if the platform
+	   defines it */
+	MAVLINK_SEND_UART_BYTES(chan, (uint8_t *)buf, len);
+#else
+	/* fallback to one byte at a time */
+	uint16_t i;
+	for (i = 0; i < len; i++) {
+		comm_send_ch(chan, (uint8_t)buf[i]);
+	}
+#endif
+}
+#endif // MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+#endif /* _MAVLINK_HELPERS_H_ */
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/mavlink_types.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/mavlink_types.h
new file mode 100644
index 000000000..630cb84b7
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/mavlink_types.h
@@ -0,0 +1,300 @@
+#ifndef MAVLINK_TYPES_H_
+#define MAVLINK_TYPES_H_
+
+#include "inttypes.h"
+
+enum MAV_CLASS
+{
+    MAV_CLASS_GENERIC = 0,        ///< Generic autopilot, full support for everything
+    MAV_CLASS_PIXHAWK = 1,        ///< PIXHAWK autopilot, http://pixhawk.ethz.ch
+    MAV_CLASS_SLUGS = 2,          ///< SLUGS autopilot, http://slugsuav.soe.ucsc.edu
+    MAV_CLASS_ARDUPILOTMEGA = 3,  ///< ArduPilotMega / ArduCopter, http://diydrones.com
+    MAV_CLASS_OPENPILOT = 4,      ///< OpenPilot, http://openpilot.org
+    MAV_CLASS_GENERIC_MISSION_WAYPOINTS_ONLY = 5,  ///< Generic autopilot only supporting simple waypoints
+    MAV_CLASS_GENERIC_MISSION_NAVIGATION_ONLY = 6, ///< Generic autopilot supporting waypoints and other simple navigation commands
+    MAV_CLASS_GENERIC_MISSION_FULL = 7,            ///< Generic autopilot supporting the full mission command set
+    MAV_CLASS_NONE = 8,           ///< No valid autopilot
+    MAV_CLASS_NB                  ///< Number of autopilot classes
+};
+
+enum MAV_ACTION
+{
+    MAV_ACTION_HOLD = 0,
+    MAV_ACTION_MOTORS_START = 1,
+    MAV_ACTION_LAUNCH = 2,
+    MAV_ACTION_RETURN = 3,
+    MAV_ACTION_EMCY_LAND = 4,
+    MAV_ACTION_EMCY_KILL = 5,
+    MAV_ACTION_CONFIRM_KILL = 6,
+    MAV_ACTION_CONTINUE = 7,
+    MAV_ACTION_MOTORS_STOP = 8,
+    MAV_ACTION_HALT = 9,
+    MAV_ACTION_SHUTDOWN = 10,
+    MAV_ACTION_REBOOT = 11,
+    MAV_ACTION_SET_MANUAL = 12,
+    MAV_ACTION_SET_AUTO = 13,
+    MAV_ACTION_STORAGE_READ = 14,
+    MAV_ACTION_STORAGE_WRITE = 15,
+    MAV_ACTION_CALIBRATE_RC = 16,
+    MAV_ACTION_CALIBRATE_GYRO = 17,
+    MAV_ACTION_CALIBRATE_MAG = 18,
+    MAV_ACTION_CALIBRATE_ACC = 19,
+    MAV_ACTION_CALIBRATE_PRESSURE = 20,
+    MAV_ACTION_REC_START = 21,
+    MAV_ACTION_REC_PAUSE = 22,
+    MAV_ACTION_REC_STOP = 23,
+    MAV_ACTION_TAKEOFF = 24,
+    MAV_ACTION_NAVIGATE = 25,
+    MAV_ACTION_LAND = 26,
+    MAV_ACTION_LOITER = 27,
+    MAV_ACTION_SET_ORIGIN = 28,
+    MAV_ACTION_RELAY_ON = 29,
+    MAV_ACTION_RELAY_OFF = 30,
+    MAV_ACTION_GET_IMAGE = 31,
+    MAV_ACTION_VIDEO_START = 32,
+    MAV_ACTION_VIDEO_STOP = 33,
+    MAV_ACTION_RESET_MAP = 34,
+    MAV_ACTION_RESET_PLAN = 35,
+    MAV_ACTION_DELAY_BEFORE_COMMAND = 36,
+    MAV_ACTION_ASCEND_AT_RATE = 37,
+    MAV_ACTION_CHANGE_MODE = 38,
+    MAV_ACTION_LOITER_MAX_TURNS = 39,
+    MAV_ACTION_LOITER_MAX_TIME = 40,
+    MAV_ACTION_START_HILSIM = 41,
+    MAV_ACTION_STOP_HILSIM = 42,    
+    MAV_ACTION_NB        ///< Number of MAV actions
+};
+
+enum MAV_MODE
+{
+    MAV_MODE_UNINIT = 0,     ///< System is in undefined state
+    MAV_MODE_LOCKED = 1,     ///< Motors are blocked, system is safe
+    MAV_MODE_MANUAL = 2,     ///< System is allowed to be active, under manual (RC) control
+    MAV_MODE_GUIDED = 3,     ///< System is allowed to be active, under autonomous control, manual setpoint
+    MAV_MODE_AUTO =   4,     ///< System is allowed to be active, under autonomous control and navigation
+    MAV_MODE_TEST1 =  5,     ///< Generic test mode, for custom use
+    MAV_MODE_TEST2 =  6,     ///< Generic test mode, for custom use
+    MAV_MODE_TEST3 =  7,     ///< Generic test mode, for custom use
+    MAV_MODE_READY =  8,     ///< System is ready, motors are unblocked, but controllers are inactive
+    MAV_MODE_RC_TRAINING = 9 ///< System is blocked, only RC valued are read and reported back
+};
+
+enum MAV_STATE
+{
+    MAV_STATE_UNINIT = 0,
+    MAV_STATE_BOOT,
+    MAV_STATE_CALIBRATING,
+    MAV_STATE_STANDBY,
+    MAV_STATE_ACTIVE,
+    MAV_STATE_CRITICAL,
+    MAV_STATE_EMERGENCY,
+    MAV_STATE_HILSIM,
+    MAV_STATE_POWEROFF
+};
+
+enum MAV_NAV
+{
+    MAV_NAV_GROUNDED = 0,
+    MAV_NAV_LIFTOFF,
+    MAV_NAV_HOLD,
+    MAV_NAV_WAYPOINT,
+    MAV_NAV_VECTOR,
+    MAV_NAV_RETURNING,
+    MAV_NAV_LANDING,
+    MAV_NAV_LOST,
+    MAV_NAV_LOITER,
+    MAV_NAV_FREE_DRIFT
+};
+
+enum MAV_TYPE
+{
+    MAV_GENERIC = 0,
+    MAV_FIXED_WING = 1,
+    MAV_QUADROTOR = 2,
+    MAV_COAXIAL = 3,
+    MAV_HELICOPTER = 4,
+    MAV_GROUND = 5,
+    OCU = 6,
+    MAV_AIRSHIP = 7,
+    MAV_FREE_BALLOON = 8,
+    MAV_ROCKET = 9,
+    UGV_GROUND_ROVER = 10,
+    UGV_SURFACE_SHIP = 11
+};
+
+enum MAV_AUTOPILOT_TYPE
+{
+    MAV_AUTOPILOT_GENERIC = 0,
+    MAV_AUTOPILOT_PIXHAWK = 1,
+    MAV_AUTOPILOT_SLUGS = 2,
+    MAV_AUTOPILOT_ARDUPILOTMEGA = 3,
+    MAV_AUTOPILOT_NONE = 4
+};
+
+enum MAV_COMPONENT
+{
+    MAV_COMP_ID_GPS,
+    MAV_COMP_ID_WAYPOINTPLANNER,
+    MAV_COMP_ID_BLOBTRACKER,
+    MAV_COMP_ID_PATHPLANNER,
+    MAV_COMP_ID_AIRSLAM,
+    MAV_COMP_ID_MAPPER,
+    MAV_COMP_ID_CAMERA,
+    MAV_COMP_ID_RADIO = 68,
+    MAV_COMP_ID_IMU = 200,
+    MAV_COMP_ID_IMU_2 = 201,
+    MAV_COMP_ID_IMU_3 = 202,
+    MAV_COMP_ID_UDP_BRIDGE = 240,
+    MAV_COMP_ID_UART_BRIDGE = 241,
+    MAV_COMP_ID_SYSTEM_CONTROL = 250
+};
+
+enum MAV_FRAME
+{
+    MAV_FRAME_GLOBAL = 0,
+    MAV_FRAME_LOCAL = 1,
+    MAV_FRAME_MISSION = 2,
+    MAV_FRAME_GLOBAL_RELATIVE_ALT = 3,
+    MAV_FRAME_LOCAL_ENU = 4
+};
+
+enum MAVLINK_DATA_STREAM_TYPE
+{
+    MAVLINK_DATA_STREAM_IMG_JPEG,
+    MAVLINK_DATA_STREAM_IMG_BMP,
+    MAVLINK_DATA_STREAM_IMG_RAW8U,
+    MAVLINK_DATA_STREAM_IMG_RAW32U,
+    MAVLINK_DATA_STREAM_IMG_PGM,
+    MAVLINK_DATA_STREAM_IMG_PNG
+};
+
+#ifndef MAVLINK_MAX_PAYLOAD_LEN
+// it is possible to override this, but be careful!
+#define MAVLINK_MAX_PAYLOAD_LEN 255 ///< Maximum payload length
+#endif
+
+#define MAVLINK_CORE_HEADER_LEN 5 ///< Length of core header (of the comm. layer): message length (1 byte) + message sequence (1 byte) + message system id (1 byte) + message component id (1 byte) + message type id (1 byte)
+#define MAVLINK_NUM_HEADER_BYTES (MAVLINK_CORE_HEADER_LEN + 1) ///< Length of all header bytes, including core and checksum
+#define MAVLINK_NUM_CHECKSUM_BYTES 2
+#define MAVLINK_NUM_NON_PAYLOAD_BYTES (MAVLINK_NUM_HEADER_BYTES + MAVLINK_NUM_CHECKSUM_BYTES)
+
+#define MAVLINK_MAX_PACKET_LEN (MAVLINK_MAX_PAYLOAD_LEN + MAVLINK_NUM_NON_PAYLOAD_BYTES) ///< Maximum packet length
+
+typedef struct param_union {
+	union {
+    float param_float;
+    int32_t param_int32;
+    uint32_t param_uint32;
+	};
+	uint8_t type;
+} mavlink_param_union_t;
+
+typedef struct __mavlink_system {
+    uint8_t sysid;   ///< Used by the MAVLink message_xx_send() convenience function
+    uint8_t compid;  ///< Used by the MAVLink message_xx_send() convenience function
+    uint8_t type;    ///< Unused, can be used by user to store the system's type
+    uint8_t state;   ///< Unused, can be used by user to store the system's state
+    uint8_t mode;    ///< Unused, can be used by user to store the system's mode
+    uint8_t nav_mode;    ///< Unused, can be used by user to store the system's navigation mode
+} mavlink_system_t;
+
+typedef struct __mavlink_message {
+	uint16_t checksum; /// sent at end of packet
+	uint8_t magic;   ///< protocol magic marker
+	uint8_t len;     ///< Length of payload
+	uint8_t seq;     ///< Sequence of packet
+	uint8_t sysid;   ///< ID of message sender system/aircraft
+	uint8_t compid;  ///< ID of the message sender component
+	uint8_t msgid;   ///< ID of message in payload
+	uint64_t payload64[(MAVLINK_MAX_PAYLOAD_LEN+MAVLINK_NUM_CHECKSUM_BYTES+7)/8];
+} mavlink_message_t;
+
+typedef enum {
+	MAVLINK_TYPE_CHAR     = 0,
+	MAVLINK_TYPE_UINT8_T  = 1,
+	MAVLINK_TYPE_INT8_T   = 2,
+	MAVLINK_TYPE_UINT16_T = 3,
+	MAVLINK_TYPE_INT16_T  = 4,
+	MAVLINK_TYPE_UINT32_T = 5,
+	MAVLINK_TYPE_INT32_T  = 6,
+	MAVLINK_TYPE_UINT64_T = 7,
+	MAVLINK_TYPE_INT64_T  = 8,
+	MAVLINK_TYPE_FLOAT    = 9,
+	MAVLINK_TYPE_DOUBLE   = 10
+} mavlink_message_type_t;
+
+#define MAVLINK_MAX_FIELDS 64
+
+typedef struct __mavlink_field_info {
+	const char *name;             // name of this field
+	const char *print_format;     // printing format hint, or NULL
+	mavlink_message_type_t type;  // type of this field
+	unsigned array_length;        // if non-zero, field is an array
+	unsigned wire_offset;         // offset of each field in the payload
+	unsigned structure_offset;    // offset in a C structure
+} mavlink_field_info_t;
+
+// note that in this structure the order of fields is the order
+// in the XML file, not necessary the wire order
+typedef struct __mavlink_message_info {
+	const char *name;                                      // name of the message
+	unsigned num_fields;                                   // how many fields in this message
+	mavlink_field_info_t fields[MAVLINK_MAX_FIELDS];       // field information
+} mavlink_message_info_t;
+
+#define _MAV_PAYLOAD(msg) ((char *)(&(msg)->payload64[0]))
+#define _MAV_PAYLOAD_NON_CONST(msg) ((char *)(&((msg)->payload64[0])))
+
+// checksum is immediately after the payload bytes
+#define mavlink_ck_a(msg) *(msg->len + (uint8_t *)_MAV_PAYLOAD(msg))
+#define mavlink_ck_b(msg) *((msg->len+(uint16_t)1) + (uint8_t *)_MAV_PAYLOAD(msg))
+
+typedef enum {
+    MAVLINK_COMM_0,
+    MAVLINK_COMM_1,
+    MAVLINK_COMM_2,
+    MAVLINK_COMM_3
+} mavlink_channel_t;
+
+/*
+ * applications can set MAVLINK_COMM_NUM_BUFFERS to the maximum number
+ * of buffers they will use. If more are used, then the result will be
+ * a stack overrun
+ */
+#ifndef MAVLINK_COMM_NUM_BUFFERS
+#if (defined linux) | (defined __linux) | (defined  __MACH__) | (defined _WIN32)
+# define MAVLINK_COMM_NUM_BUFFERS 16
+#else
+# define MAVLINK_COMM_NUM_BUFFERS 4
+#endif
+#endif
+
+typedef enum {
+    MAVLINK_PARSE_STATE_UNINIT=0,
+    MAVLINK_PARSE_STATE_IDLE,
+    MAVLINK_PARSE_STATE_GOT_STX,
+    MAVLINK_PARSE_STATE_GOT_SEQ,
+    MAVLINK_PARSE_STATE_GOT_LENGTH,
+    MAVLINK_PARSE_STATE_GOT_SYSID,
+    MAVLINK_PARSE_STATE_GOT_COMPID,
+    MAVLINK_PARSE_STATE_GOT_MSGID,
+    MAVLINK_PARSE_STATE_GOT_PAYLOAD,
+    MAVLINK_PARSE_STATE_GOT_CRC1
+} mavlink_parse_state_t; ///< The state machine for the comm parser
+
+typedef struct __mavlink_status {
+    uint8_t msg_received;               ///< Number of received messages
+    uint8_t buffer_overrun;             ///< Number of buffer overruns
+    uint8_t parse_error;                ///< Number of parse errors
+    mavlink_parse_state_t parse_state;  ///< Parsing state machine
+    uint8_t packet_idx;                 ///< Index in current packet
+    uint8_t current_rx_seq;             ///< Sequence number of last packet received
+    uint8_t current_tx_seq;             ///< Sequence number of last packet sent
+    uint16_t packet_rx_success_count;   ///< Received packets
+    uint16_t packet_rx_drop_count;      ///< Number of packet drops
+} mavlink_status_t;
+
+#define MAVLINK_BIG_ENDIAN 0
+#define MAVLINK_LITTLE_ENDIAN 1
+
+#endif /* MAVLINK_TYPES_H_ */
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/protocol.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/protocol.h
new file mode 100644
index 000000000..05195c369
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/protocol.h
@@ -0,0 +1,319 @@
+#ifndef  _MAVLINK_PROTOCOL_H_
+#define  _MAVLINK_PROTOCOL_H_
+
+#include "string.h"
+#include "mavlink_types.h"
+
+/* 
+   If you want MAVLink on a system that is native big-endian,
+   you need to define NATIVE_BIG_ENDIAN
+*/
+#ifdef NATIVE_BIG_ENDIAN
+# define MAVLINK_NEED_BYTE_SWAP (MAVLINK_ENDIAN == MAVLINK_LITTLE_ENDIAN)
+#else
+# define MAVLINK_NEED_BYTE_SWAP (MAVLINK_ENDIAN != MAVLINK_LITTLE_ENDIAN)
+#endif
+
+#ifndef MAVLINK_STACK_BUFFER
+#define MAVLINK_STACK_BUFFER 0
+#endif
+
+#ifndef MAVLINK_AVOID_GCC_STACK_BUG
+# define MAVLINK_AVOID_GCC_STACK_BUG defined(__GNUC__)
+#endif
+
+#ifndef MAVLINK_ASSERT
+#define MAVLINK_ASSERT(x)
+#endif
+
+#ifndef MAVLINK_START_UART_SEND
+#define MAVLINK_START_UART_SEND(chan, length)
+#endif
+
+#ifndef MAVLINK_END_UART_SEND
+#define MAVLINK_END_UART_SEND(chan, length)
+#endif
+
+#ifdef MAVLINK_SEPARATE_HELPERS
+#define MAVLINK_HELPER
+#else
+#define MAVLINK_HELPER static inline
+#include "mavlink_helpers.h"
+#endif // MAVLINK_SEPARATE_HELPERS
+
+/* always include the prototypes to ensure we don't get out of sync */
+MAVLINK_HELPER mavlink_status_t* mavlink_get_channel_status(uint8_t chan);
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length, uint8_t crc_extra);
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length, uint8_t crc_extra);
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, 
+						    uint8_t length, uint8_t crc_extra);
+#endif
+#else
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length);
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length);
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, uint8_t length);
+#endif // MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t *buffer, const mavlink_message_t *msg);
+MAVLINK_HELPER void mavlink_start_checksum(mavlink_message_t* msg);
+MAVLINK_HELPER void mavlink_update_checksum(mavlink_message_t* msg, uint8_t c);
+MAVLINK_HELPER uint8_t mavlink_parse_char(uint8_t chan, uint8_t c, mavlink_message_t* r_message, mavlink_status_t* r_mavlink_status);
+MAVLINK_HELPER uint8_t put_bitfield_n_by_index(int32_t b, uint8_t bits, uint8_t packet_index, uint8_t bit_index, 
+					       uint8_t* r_bit_index, uint8_t* buffer);
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len);
+#endif
+
+/**
+ * @brief Get the required buffer size for this message
+ */
+static inline uint16_t mavlink_msg_get_send_buffer_length(const mavlink_message_t* msg)
+{
+	return msg->len + MAVLINK_NUM_NON_PAYLOAD_BYTES;
+}
+
+#if MAVLINK_NEED_BYTE_SWAP
+static inline void byte_swap_2(char *dst, const char *src)
+{
+	dst[0] = src[1];
+	dst[1] = src[0];
+}
+static inline void byte_swap_4(char *dst, const char *src)
+{
+	dst[0] = src[3];
+	dst[1] = src[2];
+	dst[2] = src[1];
+	dst[3] = src[0];
+}
+static inline void byte_swap_8(char *dst, const char *src)
+{
+	dst[0] = src[7];
+	dst[1] = src[6];
+	dst[2] = src[5];
+	dst[3] = src[4];
+	dst[4] = src[3];
+	dst[5] = src[2];
+	dst[6] = src[1];
+	dst[7] = src[0];
+}
+#elif !MAVLINK_ALIGNED_FIELDS
+static inline void byte_copy_2(char *dst, const char *src)
+{
+	dst[0] = src[0];
+	dst[1] = src[1];
+}
+static inline void byte_copy_4(char *dst, const char *src)
+{
+	dst[0] = src[0];
+	dst[1] = src[1];
+	dst[2] = src[2];
+	dst[3] = src[3];
+}
+static inline void byte_copy_8(char *dst, const char *src)
+{
+	memcpy(dst, src, 8);
+}
+#endif
+
+#define _mav_put_uint8_t(buf, wire_offset, b) buf[wire_offset] = (uint8_t)b
+#define _mav_put_int8_t(buf, wire_offset, b)  buf[wire_offset] = (int8_t)b
+#define _mav_put_char(buf, wire_offset, b)    buf[wire_offset] = b
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _mav_put_uint16_t(buf, wire_offset, b) byte_swap_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int16_t(buf, wire_offset, b)  byte_swap_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint32_t(buf, wire_offset, b) byte_swap_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int32_t(buf, wire_offset, b)  byte_swap_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint64_t(buf, wire_offset, b) byte_swap_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int64_t(buf, wire_offset, b)  byte_swap_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_float(buf, wire_offset, b)    byte_swap_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_double(buf, wire_offset, b)   byte_swap_8(&buf[wire_offset], (const char *)&b)
+#elif !MAVLINK_ALIGNED_FIELDS
+#define _mav_put_uint16_t(buf, wire_offset, b) byte_copy_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int16_t(buf, wire_offset, b)  byte_copy_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint32_t(buf, wire_offset, b) byte_copy_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int32_t(buf, wire_offset, b)  byte_copy_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint64_t(buf, wire_offset, b) byte_copy_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int64_t(buf, wire_offset, b)  byte_copy_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_float(buf, wire_offset, b)    byte_copy_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_double(buf, wire_offset, b)   byte_copy_8(&buf[wire_offset], (const char *)&b)
+#else
+#define _mav_put_uint16_t(buf, wire_offset, b) *(uint16_t *)&buf[wire_offset] = b
+#define _mav_put_int16_t(buf, wire_offset, b)  *(int16_t *)&buf[wire_offset] = b
+#define _mav_put_uint32_t(buf, wire_offset, b) *(uint32_t *)&buf[wire_offset] = b
+#define _mav_put_int32_t(buf, wire_offset, b)  *(int32_t *)&buf[wire_offset] = b
+#define _mav_put_uint64_t(buf, wire_offset, b) *(uint64_t *)&buf[wire_offset] = b
+#define _mav_put_int64_t(buf, wire_offset, b)  *(int64_t *)&buf[wire_offset] = b
+#define _mav_put_float(buf, wire_offset, b)    *(float *)&buf[wire_offset] = b
+#define _mav_put_double(buf, wire_offset, b)   *(double *)&buf[wire_offset] = b
+#endif
+
+/*
+  like memcpy(), but if src is NULL, do a memset to zero
+ */
+static void mav_array_memcpy(void *dest, const void *src, size_t n)
+{
+	if (src == NULL) {
+		memset(dest, 0, n);
+	} else {
+		memcpy(dest, src, n);
+	}
+}
+
+/*
+ * Place a char array into a buffer
+ */
+static inline void _mav_put_char_array(char *buf, uint8_t wire_offset, const char *b, uint8_t array_length)
+{
+	mav_array_memcpy(&buf[wire_offset], b, array_length);
+}
+
+/*
+ * Place a uint8_t array into a buffer
+ */
+static inline void _mav_put_uint8_t_array(char *buf, uint8_t wire_offset, const uint8_t *b, uint8_t array_length)
+{
+	mav_array_memcpy(&buf[wire_offset], b, array_length);
+}
+
+/*
+ * Place a int8_t array into a buffer
+ */
+static inline void _mav_put_int8_t_array(char *buf, uint8_t wire_offset, const int8_t *b, uint8_t array_length)
+{
+	mav_array_memcpy(&buf[wire_offset], b, array_length);
+}
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _MAV_PUT_ARRAY(TYPE, V) \
+static inline void _mav_put_ ## TYPE ##_array(char *buf, uint8_t wire_offset, const TYPE *b, uint8_t array_length) \
+{ \
+	if (b == NULL) { \
+		memset(&buf[wire_offset], 0, array_length*sizeof(TYPE)); \
+	} else { \
+		uint16_t i; \
+		for (i=0; i<array_length; i++) { \
+			_mav_put_## TYPE (buf, wire_offset+(i*sizeof(TYPE)), b[i]); \
+		} \
+	} \
+}
+#else
+#define _MAV_PUT_ARRAY(TYPE, V)					\
+static inline void _mav_put_ ## TYPE ##_array(char *buf, uint8_t wire_offset, const TYPE *b, uint8_t array_length) \
+{ \
+	mav_array_memcpy(&buf[wire_offset], b, array_length*sizeof(TYPE));	\
+}
+#endif
+
+_MAV_PUT_ARRAY(uint16_t, u16)
+_MAV_PUT_ARRAY(uint32_t, u32)
+_MAV_PUT_ARRAY(uint64_t, u64)
+_MAV_PUT_ARRAY(int16_t,  i16)
+_MAV_PUT_ARRAY(int32_t,  i32)
+_MAV_PUT_ARRAY(int64_t,  i64)
+_MAV_PUT_ARRAY(float,    f)
+_MAV_PUT_ARRAY(double,   d)
+
+#define _MAV_RETURN_char(msg, wire_offset)             _MAV_PAYLOAD(msg)[wire_offset]
+#define _MAV_RETURN_int8_t(msg, wire_offset)   (int8_t)_MAV_PAYLOAD(msg)[wire_offset]
+#define _MAV_RETURN_uint8_t(msg, wire_offset) (uint8_t)_MAV_PAYLOAD(msg)[wire_offset]
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _MAV_MSG_RETURN_TYPE(TYPE, SIZE) \
+static inline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs) \
+{ TYPE r; byte_swap_## SIZE((char*)&r, &_MAV_PAYLOAD(msg)[ofs]); return r; }
+
+_MAV_MSG_RETURN_TYPE(uint16_t, 2)
+_MAV_MSG_RETURN_TYPE(int16_t,  2)
+_MAV_MSG_RETURN_TYPE(uint32_t, 4)
+_MAV_MSG_RETURN_TYPE(int32_t,  4)
+_MAV_MSG_RETURN_TYPE(uint64_t, 8)
+_MAV_MSG_RETURN_TYPE(int64_t,  8)
+_MAV_MSG_RETURN_TYPE(float,    4)
+_MAV_MSG_RETURN_TYPE(double,   8)
+
+#elif !MAVLINK_ALIGNED_FIELDS
+#define _MAV_MSG_RETURN_TYPE(TYPE, SIZE) \
+static inline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs) \
+{ TYPE r; byte_copy_## SIZE((char*)&r, &_MAV_PAYLOAD(msg)[ofs]); return r; }
+
+_MAV_MSG_RETURN_TYPE(uint16_t, 2)
+_MAV_MSG_RETURN_TYPE(int16_t,  2)
+_MAV_MSG_RETURN_TYPE(uint32_t, 4)
+_MAV_MSG_RETURN_TYPE(int32_t,  4)
+_MAV_MSG_RETURN_TYPE(uint64_t, 8)
+_MAV_MSG_RETURN_TYPE(int64_t,  8)
+_MAV_MSG_RETURN_TYPE(float,    4)
+_MAV_MSG_RETURN_TYPE(double,   8)
+#else // nicely aligned, no swap
+#define _MAV_MSG_RETURN_TYPE(TYPE) \
+static inline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs) \
+{ return *(const TYPE *)(&_MAV_PAYLOAD(msg)[ofs]);}
+
+_MAV_MSG_RETURN_TYPE(uint16_t)
+_MAV_MSG_RETURN_TYPE(int16_t)
+_MAV_MSG_RETURN_TYPE(uint32_t)
+_MAV_MSG_RETURN_TYPE(int32_t)
+_MAV_MSG_RETURN_TYPE(uint64_t)
+_MAV_MSG_RETURN_TYPE(int64_t)
+_MAV_MSG_RETURN_TYPE(float)
+_MAV_MSG_RETURN_TYPE(double)
+#endif // MAVLINK_NEED_BYTE_SWAP
+
+static inline uint16_t _MAV_RETURN_char_array(const mavlink_message_t *msg, char *value, 
+						     uint8_t array_length, uint8_t wire_offset)
+{
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length);
+	return array_length;
+}
+
+static inline uint16_t _MAV_RETURN_uint8_t_array(const mavlink_message_t *msg, uint8_t *value, 
+							uint8_t array_length, uint8_t wire_offset)
+{
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length);
+	return array_length;
+}
+
+static inline uint16_t _MAV_RETURN_int8_t_array(const mavlink_message_t *msg, int8_t *value, 
+						       uint8_t array_length, uint8_t wire_offset)
+{
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length);
+	return array_length;
+}
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _MAV_RETURN_ARRAY(TYPE, V) \
+static inline uint16_t _MAV_RETURN_## TYPE ##_array(const mavlink_message_t *msg, TYPE *value, \
+							 uint8_t array_length, uint8_t wire_offset) \
+{ \
+	uint16_t i; \
+	for (i=0; i<array_length; i++) { \
+		value[i] = _MAV_RETURN_## TYPE (msg, wire_offset+(i*sizeof(value[0]))); \
+	} \
+	return array_length*sizeof(value[0]); \
+}
+#else
+#define _MAV_RETURN_ARRAY(TYPE, V)					\
+static inline uint16_t _MAV_RETURN_## TYPE ##_array(const mavlink_message_t *msg, TYPE *value, \
+							 uint8_t array_length, uint8_t wire_offset) \
+{ \
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length*sizeof(TYPE)); \
+	return array_length*sizeof(TYPE); \
+}
+#endif
+
+_MAV_RETURN_ARRAY(uint16_t, u16)
+_MAV_RETURN_ARRAY(uint32_t, u32)
+_MAV_RETURN_ARRAY(uint64_t, u64)
+_MAV_RETURN_ARRAY(int16_t,  i16)
+_MAV_RETURN_ARRAY(int32_t,  i32)
+_MAV_RETURN_ARRAY(int64_t,  i64)
+_MAV_RETURN_ARRAY(float,    f)
+_MAV_RETURN_ARRAY(double,   d)
+
+#endif // _MAVLINK_PROTOCOL_H_
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/mavlink.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/mavlink.h
new file mode 100644
index 000000000..5b91bfe2d
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/mavlink.h
@@ -0,0 +1,27 @@
+/** @file
+ *	@brief MAVLink comm protocol built from test.xml
+ *	@see http://pixhawk.ethz.ch/software/mavlink
+ */
+#ifndef MAVLINK_H
+#define MAVLINK_H
+
+#ifndef MAVLINK_STX
+#define MAVLINK_STX 85
+#endif
+
+#ifndef MAVLINK_ENDIAN
+#define MAVLINK_ENDIAN MAVLINK_BIG_ENDIAN
+#endif
+
+#ifndef MAVLINK_ALIGNED_FIELDS
+#define MAVLINK_ALIGNED_FIELDS 0
+#endif
+
+#ifndef MAVLINK_CRC_EXTRA
+#define MAVLINK_CRC_EXTRA 0
+#endif
+
+#include "version.h"
+#include "test.h"
+
+#endif // MAVLINK_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/mavlink_msg_test_types.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/mavlink_msg_test_types.h
new file mode 100644
index 000000000..50b4fd6bc
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/mavlink_msg_test_types.h
@@ -0,0 +1,610 @@
+// MESSAGE TEST_TYPES PACKING
+
+#define MAVLINK_MSG_ID_TEST_TYPES 0
+
+typedef struct __mavlink_test_types_t
+{
+ char c; ///< char
+ char s[10]; ///< string
+ uint8_t u8; ///< uint8_t
+ uint16_t u16; ///< uint16_t
+ uint32_t u32; ///< uint32_t
+ uint64_t u64; ///< uint64_t
+ int8_t s8; ///< int8_t
+ int16_t s16; ///< int16_t
+ int32_t s32; ///< int32_t
+ int64_t s64; ///< int64_t
+ float f; ///< float
+ double d; ///< double
+ uint8_t u8_array[3]; ///< uint8_t_array
+ uint16_t u16_array[3]; ///< uint16_t_array
+ uint32_t u32_array[3]; ///< uint32_t_array
+ uint64_t u64_array[3]; ///< uint64_t_array
+ int8_t s8_array[3]; ///< int8_t_array
+ int16_t s16_array[3]; ///< int16_t_array
+ int32_t s32_array[3]; ///< int32_t_array
+ int64_t s64_array[3]; ///< int64_t_array
+ float f_array[3]; ///< float_array
+ double d_array[3]; ///< double_array
+} mavlink_test_types_t;
+
+#define MAVLINK_MSG_ID_TEST_TYPES_LEN 179
+#define MAVLINK_MSG_ID_0_LEN 179
+
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S_LEN 10
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U8_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U16_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U32_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U64_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S8_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S16_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S32_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S64_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_F_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_D_ARRAY_LEN 3
+
+#define MAVLINK_MESSAGE_INFO_TEST_TYPES { \
+	"TEST_TYPES", \
+	22, \
+	{  { "c", NULL, MAVLINK_TYPE_CHAR, 0, 0, offsetof(mavlink_test_types_t, c) }, \
+         { "s", NULL, MAVLINK_TYPE_CHAR, 10, 1, offsetof(mavlink_test_types_t, s) }, \
+         { "u8", NULL, MAVLINK_TYPE_UINT8_T, 0, 11, offsetof(mavlink_test_types_t, u8) }, \
+         { "u16", NULL, MAVLINK_TYPE_UINT16_T, 0, 12, offsetof(mavlink_test_types_t, u16) }, \
+         { "u32", "0x%08x", MAVLINK_TYPE_UINT32_T, 0, 14, offsetof(mavlink_test_types_t, u32) }, \
+         { "u64", NULL, MAVLINK_TYPE_UINT64_T, 0, 18, offsetof(mavlink_test_types_t, u64) }, \
+         { "s8", NULL, MAVLINK_TYPE_INT8_T, 0, 26, offsetof(mavlink_test_types_t, s8) }, \
+         { "s16", NULL, MAVLINK_TYPE_INT16_T, 0, 27, offsetof(mavlink_test_types_t, s16) }, \
+         { "s32", NULL, MAVLINK_TYPE_INT32_T, 0, 29, offsetof(mavlink_test_types_t, s32) }, \
+         { "s64", NULL, MAVLINK_TYPE_INT64_T, 0, 33, offsetof(mavlink_test_types_t, s64) }, \
+         { "f", NULL, MAVLINK_TYPE_FLOAT, 0, 41, offsetof(mavlink_test_types_t, f) }, \
+         { "d", NULL, MAVLINK_TYPE_DOUBLE, 0, 45, offsetof(mavlink_test_types_t, d) }, \
+         { "u8_array", NULL, MAVLINK_TYPE_UINT8_T, 3, 53, offsetof(mavlink_test_types_t, u8_array) }, \
+         { "u16_array", NULL, MAVLINK_TYPE_UINT16_T, 3, 56, offsetof(mavlink_test_types_t, u16_array) }, \
+         { "u32_array", NULL, MAVLINK_TYPE_UINT32_T, 3, 62, offsetof(mavlink_test_types_t, u32_array) }, \
+         { "u64_array", NULL, MAVLINK_TYPE_UINT64_T, 3, 74, offsetof(mavlink_test_types_t, u64_array) }, \
+         { "s8_array", NULL, MAVLINK_TYPE_INT8_T, 3, 98, offsetof(mavlink_test_types_t, s8_array) }, \
+         { "s16_array", NULL, MAVLINK_TYPE_INT16_T, 3, 101, offsetof(mavlink_test_types_t, s16_array) }, \
+         { "s32_array", NULL, MAVLINK_TYPE_INT32_T, 3, 107, offsetof(mavlink_test_types_t, s32_array) }, \
+         { "s64_array", NULL, MAVLINK_TYPE_INT64_T, 3, 119, offsetof(mavlink_test_types_t, s64_array) }, \
+         { "f_array", NULL, MAVLINK_TYPE_FLOAT, 3, 143, offsetof(mavlink_test_types_t, f_array) }, \
+         { "d_array", NULL, MAVLINK_TYPE_DOUBLE, 3, 155, offsetof(mavlink_test_types_t, d_array) }, \
+         } \
+}
+
+
+/**
+ * @brief Pack a test_types message
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param msg The MAVLink message to compress the data into
+ *
+ * @param c char
+ * @param s string
+ * @param u8 uint8_t
+ * @param u16 uint16_t
+ * @param u32 uint32_t
+ * @param u64 uint64_t
+ * @param s8 int8_t
+ * @param s16 int16_t
+ * @param s32 int32_t
+ * @param s64 int64_t
+ * @param f float
+ * @param d double
+ * @param u8_array uint8_t_array
+ * @param u16_array uint16_t_array
+ * @param u32_array uint32_t_array
+ * @param u64_array uint64_t_array
+ * @param s8_array int8_t_array
+ * @param s16_array int16_t_array
+ * @param s32_array int32_t_array
+ * @param s64_array int64_t_array
+ * @param f_array float_array
+ * @param d_array double_array
+ * @return length of the message in bytes (excluding serial stream start sign)
+ */
+static inline uint16_t mavlink_msg_test_types_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
+						       char c, const char *s, uint8_t u8, uint16_t u16, uint32_t u32, uint64_t u64, int8_t s8, int16_t s16, int32_t s32, int64_t s64, float f, double d, const uint8_t *u8_array, const uint16_t *u16_array, const uint32_t *u32_array, const uint64_t *u64_array, const int8_t *s8_array, const int16_t *s16_array, const int32_t *s32_array, const int64_t *s64_array, const float *f_array, const double *d_array)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+	char buf[179];
+	_mav_put_char(buf, 0, c);
+	_mav_put_uint8_t(buf, 11, u8);
+	_mav_put_uint16_t(buf, 12, u16);
+	_mav_put_uint32_t(buf, 14, u32);
+	_mav_put_uint64_t(buf, 18, u64);
+	_mav_put_int8_t(buf, 26, s8);
+	_mav_put_int16_t(buf, 27, s16);
+	_mav_put_int32_t(buf, 29, s32);
+	_mav_put_int64_t(buf, 33, s64);
+	_mav_put_float(buf, 41, f);
+	_mav_put_double(buf, 45, d);
+	_mav_put_char_array(buf, 1, s, 10);
+	_mav_put_uint8_t_array(buf, 53, u8_array, 3);
+	_mav_put_uint16_t_array(buf, 56, u16_array, 3);
+	_mav_put_uint32_t_array(buf, 62, u32_array, 3);
+	_mav_put_uint64_t_array(buf, 74, u64_array, 3);
+	_mav_put_int8_t_array(buf, 98, s8_array, 3);
+	_mav_put_int16_t_array(buf, 101, s16_array, 3);
+	_mav_put_int32_t_array(buf, 107, s32_array, 3);
+	_mav_put_int64_t_array(buf, 119, s64_array, 3);
+	_mav_put_float_array(buf, 143, f_array, 3);
+	_mav_put_double_array(buf, 155, d_array, 3);
+        memcpy(_MAV_PAYLOAD(msg), buf, 179);
+#else
+	mavlink_test_types_t packet;
+	packet.c = c;
+	packet.u8 = u8;
+	packet.u16 = u16;
+	packet.u32 = u32;
+	packet.u64 = u64;
+	packet.s8 = s8;
+	packet.s16 = s16;
+	packet.s32 = s32;
+	packet.s64 = s64;
+	packet.f = f;
+	packet.d = d;
+	mav_array_memcpy(packet.s, s, sizeof(char)*10);
+	mav_array_memcpy(packet.u8_array, u8_array, sizeof(uint8_t)*3);
+	mav_array_memcpy(packet.u16_array, u16_array, sizeof(uint16_t)*3);
+	mav_array_memcpy(packet.u32_array, u32_array, sizeof(uint32_t)*3);
+	mav_array_memcpy(packet.u64_array, u64_array, sizeof(uint64_t)*3);
+	mav_array_memcpy(packet.s8_array, s8_array, sizeof(int8_t)*3);
+	mav_array_memcpy(packet.s16_array, s16_array, sizeof(int16_t)*3);
+	mav_array_memcpy(packet.s32_array, s32_array, sizeof(int32_t)*3);
+	mav_array_memcpy(packet.s64_array, s64_array, sizeof(int64_t)*3);
+	mav_array_memcpy(packet.f_array, f_array, sizeof(float)*3);
+	mav_array_memcpy(packet.d_array, d_array, sizeof(double)*3);
+        memcpy(_MAV_PAYLOAD(msg), &packet, 179);
+#endif
+
+	msg->msgid = MAVLINK_MSG_ID_TEST_TYPES;
+	return mavlink_finalize_message(msg, system_id, component_id, 179);
+}
+
+/**
+ * @brief Pack a test_types message on a channel
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param chan The MAVLink channel this message was sent over
+ * @param msg The MAVLink message to compress the data into
+ * @param c char
+ * @param s string
+ * @param u8 uint8_t
+ * @param u16 uint16_t
+ * @param u32 uint32_t
+ * @param u64 uint64_t
+ * @param s8 int8_t
+ * @param s16 int16_t
+ * @param s32 int32_t
+ * @param s64 int64_t
+ * @param f float
+ * @param d double
+ * @param u8_array uint8_t_array
+ * @param u16_array uint16_t_array
+ * @param u32_array uint32_t_array
+ * @param u64_array uint64_t_array
+ * @param s8_array int8_t_array
+ * @param s16_array int16_t_array
+ * @param s32_array int32_t_array
+ * @param s64_array int64_t_array
+ * @param f_array float_array
+ * @param d_array double_array
+ * @return length of the message in bytes (excluding serial stream start sign)
+ */
+static inline uint16_t mavlink_msg_test_types_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
+							   mavlink_message_t* msg,
+						           char c,const char *s,uint8_t u8,uint16_t u16,uint32_t u32,uint64_t u64,int8_t s8,int16_t s16,int32_t s32,int64_t s64,float f,double d,const uint8_t *u8_array,const uint16_t *u16_array,const uint32_t *u32_array,const uint64_t *u64_array,const int8_t *s8_array,const int16_t *s16_array,const int32_t *s32_array,const int64_t *s64_array,const float *f_array,const double *d_array)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+	char buf[179];
+	_mav_put_char(buf, 0, c);
+	_mav_put_uint8_t(buf, 11, u8);
+	_mav_put_uint16_t(buf, 12, u16);
+	_mav_put_uint32_t(buf, 14, u32);
+	_mav_put_uint64_t(buf, 18, u64);
+	_mav_put_int8_t(buf, 26, s8);
+	_mav_put_int16_t(buf, 27, s16);
+	_mav_put_int32_t(buf, 29, s32);
+	_mav_put_int64_t(buf, 33, s64);
+	_mav_put_float(buf, 41, f);
+	_mav_put_double(buf, 45, d);
+	_mav_put_char_array(buf, 1, s, 10);
+	_mav_put_uint8_t_array(buf, 53, u8_array, 3);
+	_mav_put_uint16_t_array(buf, 56, u16_array, 3);
+	_mav_put_uint32_t_array(buf, 62, u32_array, 3);
+	_mav_put_uint64_t_array(buf, 74, u64_array, 3);
+	_mav_put_int8_t_array(buf, 98, s8_array, 3);
+	_mav_put_int16_t_array(buf, 101, s16_array, 3);
+	_mav_put_int32_t_array(buf, 107, s32_array, 3);
+	_mav_put_int64_t_array(buf, 119, s64_array, 3);
+	_mav_put_float_array(buf, 143, f_array, 3);
+	_mav_put_double_array(buf, 155, d_array, 3);
+        memcpy(_MAV_PAYLOAD(msg), buf, 179);
+#else
+	mavlink_test_types_t packet;
+	packet.c = c;
+	packet.u8 = u8;
+	packet.u16 = u16;
+	packet.u32 = u32;
+	packet.u64 = u64;
+	packet.s8 = s8;
+	packet.s16 = s16;
+	packet.s32 = s32;
+	packet.s64 = s64;
+	packet.f = f;
+	packet.d = d;
+	mav_array_memcpy(packet.s, s, sizeof(char)*10);
+	mav_array_memcpy(packet.u8_array, u8_array, sizeof(uint8_t)*3);
+	mav_array_memcpy(packet.u16_array, u16_array, sizeof(uint16_t)*3);
+	mav_array_memcpy(packet.u32_array, u32_array, sizeof(uint32_t)*3);
+	mav_array_memcpy(packet.u64_array, u64_array, sizeof(uint64_t)*3);
+	mav_array_memcpy(packet.s8_array, s8_array, sizeof(int8_t)*3);
+	mav_array_memcpy(packet.s16_array, s16_array, sizeof(int16_t)*3);
+	mav_array_memcpy(packet.s32_array, s32_array, sizeof(int32_t)*3);
+	mav_array_memcpy(packet.s64_array, s64_array, sizeof(int64_t)*3);
+	mav_array_memcpy(packet.f_array, f_array, sizeof(float)*3);
+	mav_array_memcpy(packet.d_array, d_array, sizeof(double)*3);
+        memcpy(_MAV_PAYLOAD(msg), &packet, 179);
+#endif
+
+	msg->msgid = MAVLINK_MSG_ID_TEST_TYPES;
+	return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 179);
+}
+
+/**
+ * @brief Encode a test_types struct into a message
+ *
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param msg The MAVLink message to compress the data into
+ * @param test_types C-struct to read the message contents from
+ */
+static inline uint16_t mavlink_msg_test_types_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_test_types_t* test_types)
+{
+	return mavlink_msg_test_types_pack(system_id, component_id, msg, test_types->c, test_types->s, test_types->u8, test_types->u16, test_types->u32, test_types->u64, test_types->s8, test_types->s16, test_types->s32, test_types->s64, test_types->f, test_types->d, test_types->u8_array, test_types->u16_array, test_types->u32_array, test_types->u64_array, test_types->s8_array, test_types->s16_array, test_types->s32_array, test_types->s64_array, test_types->f_array, test_types->d_array);
+}
+
+/**
+ * @brief Send a test_types message
+ * @param chan MAVLink channel to send the message
+ *
+ * @param c char
+ * @param s string
+ * @param u8 uint8_t
+ * @param u16 uint16_t
+ * @param u32 uint32_t
+ * @param u64 uint64_t
+ * @param s8 int8_t
+ * @param s16 int16_t
+ * @param s32 int32_t
+ * @param s64 int64_t
+ * @param f float
+ * @param d double
+ * @param u8_array uint8_t_array
+ * @param u16_array uint16_t_array
+ * @param u32_array uint32_t_array
+ * @param u64_array uint64_t_array
+ * @param s8_array int8_t_array
+ * @param s16_array int16_t_array
+ * @param s32_array int32_t_array
+ * @param s64_array int64_t_array
+ * @param f_array float_array
+ * @param d_array double_array
+ */
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+static inline void mavlink_msg_test_types_send(mavlink_channel_t chan, char c, const char *s, uint8_t u8, uint16_t u16, uint32_t u32, uint64_t u64, int8_t s8, int16_t s16, int32_t s32, int64_t s64, float f, double d, const uint8_t *u8_array, const uint16_t *u16_array, const uint32_t *u32_array, const uint64_t *u64_array, const int8_t *s8_array, const int16_t *s16_array, const int32_t *s32_array, const int64_t *s64_array, const float *f_array, const double *d_array)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+	char buf[179];
+	_mav_put_char(buf, 0, c);
+	_mav_put_uint8_t(buf, 11, u8);
+	_mav_put_uint16_t(buf, 12, u16);
+	_mav_put_uint32_t(buf, 14, u32);
+	_mav_put_uint64_t(buf, 18, u64);
+	_mav_put_int8_t(buf, 26, s8);
+	_mav_put_int16_t(buf, 27, s16);
+	_mav_put_int32_t(buf, 29, s32);
+	_mav_put_int64_t(buf, 33, s64);
+	_mav_put_float(buf, 41, f);
+	_mav_put_double(buf, 45, d);
+	_mav_put_char_array(buf, 1, s, 10);
+	_mav_put_uint8_t_array(buf, 53, u8_array, 3);
+	_mav_put_uint16_t_array(buf, 56, u16_array, 3);
+	_mav_put_uint32_t_array(buf, 62, u32_array, 3);
+	_mav_put_uint64_t_array(buf, 74, u64_array, 3);
+	_mav_put_int8_t_array(buf, 98, s8_array, 3);
+	_mav_put_int16_t_array(buf, 101, s16_array, 3);
+	_mav_put_int32_t_array(buf, 107, s32_array, 3);
+	_mav_put_int64_t_array(buf, 119, s64_array, 3);
+	_mav_put_float_array(buf, 143, f_array, 3);
+	_mav_put_double_array(buf, 155, d_array, 3);
+	_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_TEST_TYPES, buf, 179);
+#else
+	mavlink_test_types_t packet;
+	packet.c = c;
+	packet.u8 = u8;
+	packet.u16 = u16;
+	packet.u32 = u32;
+	packet.u64 = u64;
+	packet.s8 = s8;
+	packet.s16 = s16;
+	packet.s32 = s32;
+	packet.s64 = s64;
+	packet.f = f;
+	packet.d = d;
+	mav_array_memcpy(packet.s, s, sizeof(char)*10);
+	mav_array_memcpy(packet.u8_array, u8_array, sizeof(uint8_t)*3);
+	mav_array_memcpy(packet.u16_array, u16_array, sizeof(uint16_t)*3);
+	mav_array_memcpy(packet.u32_array, u32_array, sizeof(uint32_t)*3);
+	mav_array_memcpy(packet.u64_array, u64_array, sizeof(uint64_t)*3);
+	mav_array_memcpy(packet.s8_array, s8_array, sizeof(int8_t)*3);
+	mav_array_memcpy(packet.s16_array, s16_array, sizeof(int16_t)*3);
+	mav_array_memcpy(packet.s32_array, s32_array, sizeof(int32_t)*3);
+	mav_array_memcpy(packet.s64_array, s64_array, sizeof(int64_t)*3);
+	mav_array_memcpy(packet.f_array, f_array, sizeof(float)*3);
+	mav_array_memcpy(packet.d_array, d_array, sizeof(double)*3);
+	_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_TEST_TYPES, (const char *)&packet, 179);
+#endif
+}
+
+#endif
+
+// MESSAGE TEST_TYPES UNPACKING
+
+
+/**
+ * @brief Get field c from test_types message
+ *
+ * @return char
+ */
+static inline char mavlink_msg_test_types_get_c(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_char(msg,  0);
+}
+
+/**
+ * @brief Get field s from test_types message
+ *
+ * @return string
+ */
+static inline uint16_t mavlink_msg_test_types_get_s(const mavlink_message_t* msg, char *s)
+{
+	return _MAV_RETURN_char_array(msg, s, 10,  1);
+}
+
+/**
+ * @brief Get field u8 from test_types message
+ *
+ * @return uint8_t
+ */
+static inline uint8_t mavlink_msg_test_types_get_u8(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint8_t(msg,  11);
+}
+
+/**
+ * @brief Get field u16 from test_types message
+ *
+ * @return uint16_t
+ */
+static inline uint16_t mavlink_msg_test_types_get_u16(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint16_t(msg,  12);
+}
+
+/**
+ * @brief Get field u32 from test_types message
+ *
+ * @return uint32_t
+ */
+static inline uint32_t mavlink_msg_test_types_get_u32(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint32_t(msg,  14);
+}
+
+/**
+ * @brief Get field u64 from test_types message
+ *
+ * @return uint64_t
+ */
+static inline uint64_t mavlink_msg_test_types_get_u64(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint64_t(msg,  18);
+}
+
+/**
+ * @brief Get field s8 from test_types message
+ *
+ * @return int8_t
+ */
+static inline int8_t mavlink_msg_test_types_get_s8(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int8_t(msg,  26);
+}
+
+/**
+ * @brief Get field s16 from test_types message
+ *
+ * @return int16_t
+ */
+static inline int16_t mavlink_msg_test_types_get_s16(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int16_t(msg,  27);
+}
+
+/**
+ * @brief Get field s32 from test_types message
+ *
+ * @return int32_t
+ */
+static inline int32_t mavlink_msg_test_types_get_s32(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int32_t(msg,  29);
+}
+
+/**
+ * @brief Get field s64 from test_types message
+ *
+ * @return int64_t
+ */
+static inline int64_t mavlink_msg_test_types_get_s64(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int64_t(msg,  33);
+}
+
+/**
+ * @brief Get field f from test_types message
+ *
+ * @return float
+ */
+static inline float mavlink_msg_test_types_get_f(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_float(msg,  41);
+}
+
+/**
+ * @brief Get field d from test_types message
+ *
+ * @return double
+ */
+static inline double mavlink_msg_test_types_get_d(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_double(msg,  45);
+}
+
+/**
+ * @brief Get field u8_array from test_types message
+ *
+ * @return uint8_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u8_array(const mavlink_message_t* msg, uint8_t *u8_array)
+{
+	return _MAV_RETURN_uint8_t_array(msg, u8_array, 3,  53);
+}
+
+/**
+ * @brief Get field u16_array from test_types message
+ *
+ * @return uint16_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u16_array(const mavlink_message_t* msg, uint16_t *u16_array)
+{
+	return _MAV_RETURN_uint16_t_array(msg, u16_array, 3,  56);
+}
+
+/**
+ * @brief Get field u32_array from test_types message
+ *
+ * @return uint32_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u32_array(const mavlink_message_t* msg, uint32_t *u32_array)
+{
+	return _MAV_RETURN_uint32_t_array(msg, u32_array, 3,  62);
+}
+
+/**
+ * @brief Get field u64_array from test_types message
+ *
+ * @return uint64_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u64_array(const mavlink_message_t* msg, uint64_t *u64_array)
+{
+	return _MAV_RETURN_uint64_t_array(msg, u64_array, 3,  74);
+}
+
+/**
+ * @brief Get field s8_array from test_types message
+ *
+ * @return int8_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s8_array(const mavlink_message_t* msg, int8_t *s8_array)
+{
+	return _MAV_RETURN_int8_t_array(msg, s8_array, 3,  98);
+}
+
+/**
+ * @brief Get field s16_array from test_types message
+ *
+ * @return int16_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s16_array(const mavlink_message_t* msg, int16_t *s16_array)
+{
+	return _MAV_RETURN_int16_t_array(msg, s16_array, 3,  101);
+}
+
+/**
+ * @brief Get field s32_array from test_types message
+ *
+ * @return int32_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s32_array(const mavlink_message_t* msg, int32_t *s32_array)
+{
+	return _MAV_RETURN_int32_t_array(msg, s32_array, 3,  107);
+}
+
+/**
+ * @brief Get field s64_array from test_types message
+ *
+ * @return int64_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s64_array(const mavlink_message_t* msg, int64_t *s64_array)
+{
+	return _MAV_RETURN_int64_t_array(msg, s64_array, 3,  119);
+}
+
+/**
+ * @brief Get field f_array from test_types message
+ *
+ * @return float_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_f_array(const mavlink_message_t* msg, float *f_array)
+{
+	return _MAV_RETURN_float_array(msg, f_array, 3,  143);
+}
+
+/**
+ * @brief Get field d_array from test_types message
+ *
+ * @return double_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_d_array(const mavlink_message_t* msg, double *d_array)
+{
+	return _MAV_RETURN_double_array(msg, d_array, 3,  155);
+}
+
+/**
+ * @brief Decode a test_types message into a struct
+ *
+ * @param msg The message to decode
+ * @param test_types C-struct to decode the message contents into
+ */
+static inline void mavlink_msg_test_types_decode(const mavlink_message_t* msg, mavlink_test_types_t* test_types)
+{
+#if MAVLINK_NEED_BYTE_SWAP
+	test_types->c = mavlink_msg_test_types_get_c(msg);
+	mavlink_msg_test_types_get_s(msg, test_types->s);
+	test_types->u8 = mavlink_msg_test_types_get_u8(msg);
+	test_types->u16 = mavlink_msg_test_types_get_u16(msg);
+	test_types->u32 = mavlink_msg_test_types_get_u32(msg);
+	test_types->u64 = mavlink_msg_test_types_get_u64(msg);
+	test_types->s8 = mavlink_msg_test_types_get_s8(msg);
+	test_types->s16 = mavlink_msg_test_types_get_s16(msg);
+	test_types->s32 = mavlink_msg_test_types_get_s32(msg);
+	test_types->s64 = mavlink_msg_test_types_get_s64(msg);
+	test_types->f = mavlink_msg_test_types_get_f(msg);
+	test_types->d = mavlink_msg_test_types_get_d(msg);
+	mavlink_msg_test_types_get_u8_array(msg, test_types->u8_array);
+	mavlink_msg_test_types_get_u16_array(msg, test_types->u16_array);
+	mavlink_msg_test_types_get_u32_array(msg, test_types->u32_array);
+	mavlink_msg_test_types_get_u64_array(msg, test_types->u64_array);
+	mavlink_msg_test_types_get_s8_array(msg, test_types->s8_array);
+	mavlink_msg_test_types_get_s16_array(msg, test_types->s16_array);
+	mavlink_msg_test_types_get_s32_array(msg, test_types->s32_array);
+	mavlink_msg_test_types_get_s64_array(msg, test_types->s64_array);
+	mavlink_msg_test_types_get_f_array(msg, test_types->f_array);
+	mavlink_msg_test_types_get_d_array(msg, test_types->d_array);
+#else
+	memcpy(test_types, _MAV_PAYLOAD(msg), 179);
+#endif
+}
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/test.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/test.h
new file mode 100644
index 000000000..23ee65986
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/test.h
@@ -0,0 +1,53 @@
+/** @file
+ *	@brief MAVLink comm protocol generated from test.xml
+ *	@see http://qgroundcontrol.org/mavlink/
+ */
+#ifndef TEST_H
+#define TEST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// MESSAGE LENGTHS AND CRCS
+
+#ifndef MAVLINK_MESSAGE_LENGTHS
+#define MAVLINK_MESSAGE_LENGTHS {179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#endif
+
+#ifndef MAVLINK_MESSAGE_CRCS
+#define MAVLINK_MESSAGE_CRCS {91, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#endif
+
+#ifndef MAVLINK_MESSAGE_INFO
+#define MAVLINK_MESSAGE_INFO {MAVLINK_MESSAGE_INFO_TEST_TYPES, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}}
+#endif
+
+#include "../protocol.h"
+
+#define MAVLINK_ENABLED_TEST
+
+
+
+// MAVLINK VERSION
+
+#ifndef MAVLINK_VERSION
+#define MAVLINK_VERSION 3
+#endif
+
+#if (MAVLINK_VERSION == 0)
+#undef MAVLINK_VERSION
+#define MAVLINK_VERSION 3
+#endif
+
+// ENUM DEFINITIONS
+
+
+
+// MESSAGE DEFINITIONS
+#include "./mavlink_msg_test_types.h"
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // TEST_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/testsuite.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/testsuite.h
new file mode 100644
index 000000000..9b0fc041b
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/testsuite.h
@@ -0,0 +1,120 @@
+/** @file
+ *	@brief MAVLink comm protocol testsuite generated from test.xml
+ *	@see http://qgroundcontrol.org/mavlink/
+ */
+#ifndef TEST_TESTSUITE_H
+#define TEST_TESTSUITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef MAVLINK_TEST_ALL
+#define MAVLINK_TEST_ALL
+
+static void mavlink_test_test(uint8_t, uint8_t, mavlink_message_t *last_msg);
+
+static void mavlink_test_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
+{
+
+	mavlink_test_test(system_id, component_id, last_msg);
+}
+#endif
+
+
+
+
+static void mavlink_test_test_types(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
+{
+	mavlink_message_t msg;
+        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
+        uint16_t i;
+	mavlink_test_types_t packet_in = {
+		'A',
+	"BCDEFGHIJ",
+	230,
+	17859,
+	963498192,
+	93372036854776941ULL,
+	211,
+	18639,
+	963498972,
+	93372036854777886LL,
+	304.0,
+	438.0,
+	{ 228, 229, 230 },
+	{ 20147, 20148, 20149 },
+	{ 963500688, 963500689, 963500690 },
+	{ 93372036854780469, 93372036854780470, 93372036854780471 },
+	{ 171, 172, 173 },
+	{ 22487, 22488, 22489 },
+	{ 963503028, 963503029, 963503030 },
+	{ 93372036854783304, 93372036854783305, 93372036854783306 },
+	{ 1018.0, 1019.0, 1020.0 },
+	{ 1208.0, 1209.0, 1210.0 },
+	};
+	mavlink_test_types_t packet1, packet2;
+        memset(&packet1, 0, sizeof(packet1));
+        	packet1.c = packet_in.c;
+        	packet1.u8 = packet_in.u8;
+        	packet1.u16 = packet_in.u16;
+        	packet1.u32 = packet_in.u32;
+        	packet1.u64 = packet_in.u64;
+        	packet1.s8 = packet_in.s8;
+        	packet1.s16 = packet_in.s16;
+        	packet1.s32 = packet_in.s32;
+        	packet1.s64 = packet_in.s64;
+        	packet1.f = packet_in.f;
+        	packet1.d = packet_in.d;
+        
+        	mav_array_memcpy(packet1.s, packet_in.s, sizeof(char)*10);
+        	mav_array_memcpy(packet1.u8_array, packet_in.u8_array, sizeof(uint8_t)*3);
+        	mav_array_memcpy(packet1.u16_array, packet_in.u16_array, sizeof(uint16_t)*3);
+        	mav_array_memcpy(packet1.u32_array, packet_in.u32_array, sizeof(uint32_t)*3);
+        	mav_array_memcpy(packet1.u64_array, packet_in.u64_array, sizeof(uint64_t)*3);
+        	mav_array_memcpy(packet1.s8_array, packet_in.s8_array, sizeof(int8_t)*3);
+        	mav_array_memcpy(packet1.s16_array, packet_in.s16_array, sizeof(int16_t)*3);
+        	mav_array_memcpy(packet1.s32_array, packet_in.s32_array, sizeof(int32_t)*3);
+        	mav_array_memcpy(packet1.s64_array, packet_in.s64_array, sizeof(int64_t)*3);
+        	mav_array_memcpy(packet1.f_array, packet_in.f_array, sizeof(float)*3);
+        	mav_array_memcpy(packet1.d_array, packet_in.d_array, sizeof(double)*3);
+        
+
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_encode(system_id, component_id, &msg, &packet1);
+	mavlink_msg_test_types_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_pack(system_id, component_id, &msg , packet1.c , packet1.s , packet1.u8 , packet1.u16 , packet1.u32 , packet1.u64 , packet1.s8 , packet1.s16 , packet1.s32 , packet1.s64 , packet1.f , packet1.d , packet1.u8_array , packet1.u16_array , packet1.u32_array , packet1.u64_array , packet1.s8_array , packet1.s16_array , packet1.s32_array , packet1.s64_array , packet1.f_array , packet1.d_array );
+	mavlink_msg_test_types_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.c , packet1.s , packet1.u8 , packet1.u16 , packet1.u32 , packet1.u64 , packet1.s8 , packet1.s16 , packet1.s32 , packet1.s64 , packet1.f , packet1.d , packet1.u8_array , packet1.u16_array , packet1.u32_array , packet1.u64_array , packet1.s8_array , packet1.s16_array , packet1.s32_array , packet1.s64_array , packet1.f_array , packet1.d_array );
+	mavlink_msg_test_types_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+        mavlink_msg_to_send_buffer(buffer, &msg);
+        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
+        	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
+        }
+	mavlink_msg_test_types_decode(last_msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+        
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_send(MAVLINK_COMM_1 , packet1.c , packet1.s , packet1.u8 , packet1.u16 , packet1.u32 , packet1.u64 , packet1.s8 , packet1.s16 , packet1.s32 , packet1.s64 , packet1.f , packet1.d , packet1.u8_array , packet1.u16_array , packet1.u32_array , packet1.u64_array , packet1.s8_array , packet1.s16_array , packet1.s32_array , packet1.s64_array , packet1.f_array , packet1.d_array );
+	mavlink_msg_test_types_decode(last_msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+}
+
+static void mavlink_test_test(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
+{
+	mavlink_test_test_types(system_id, component_id, last_msg);
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // TEST_TESTSUITE_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/version.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/version.h
new file mode 100644
index 000000000..64ca0cb38
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v0.9/test/version.h
@@ -0,0 +1,12 @@
+/** @file
+ *	@brief MAVLink comm protocol built from test.xml
+ *	@see http://pixhawk.ethz.ch/software/mavlink
+ */
+#ifndef MAVLINK_VERSION_H
+#define MAVLINK_VERSION_H
+
+#define MAVLINK_BUILD_DATE "Thu Mar  1 15:11:54 2012"
+#define MAVLINK_WIRE_PROTOCOL_VERSION "0.9"
+#define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 179
+ 
+#endif // MAVLINK_VERSION_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/checksum.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/checksum.h
new file mode 100644
index 000000000..4f4cce02f
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/checksum.h
@@ -0,0 +1,89 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _CHECKSUM_H_
+#define _CHECKSUM_H_
+
+
+/**
+ *
+ *  CALCULATE THE CHECKSUM
+ *
+ */
+
+#define X25_INIT_CRC 0xffff
+#define X25_VALIDATE_CRC 0xf0b8
+
+/**
+ * @brief Accumulate the X.25 CRC by adding one char at a time.
+ *
+ * The checksum function adds the hash of one char at a time to the
+ * 16 bit checksum (uint16_t).
+ *
+ * @param data new char to hash
+ * @param crcAccum the already accumulated checksum
+ **/
+static inline void crc_accumulate(uint8_t data, uint16_t *crcAccum)
+{
+        /*Accumulate one byte of data into the CRC*/
+        uint8_t tmp;
+
+        tmp = data ^ (uint8_t)(*crcAccum &0xff);
+        tmp ^= (tmp<<4);
+        *crcAccum = (*crcAccum>>8) ^ (tmp<<8) ^ (tmp <<3) ^ (tmp>>4);
+}
+
+/**
+ * @brief Initiliaze the buffer for the X.25 CRC
+ *
+ * @param crcAccum the 16 bit X.25 CRC
+ */
+static inline void crc_init(uint16_t* crcAccum)
+{
+        *crcAccum = X25_INIT_CRC;
+}
+
+
+/**
+ * @brief Calculates the X.25 checksum on a byte buffer
+ *
+ * @param  pBuffer buffer containing the byte array to hash
+ * @param  length  length of the byte array
+ * @return the checksum over the buffer bytes
+ **/
+static inline uint16_t crc_calculate(const uint8_t* pBuffer, uint16_t length)
+{
+        uint16_t crcTmp;
+        crc_init(&crcTmp);
+	while (length--) {
+                crc_accumulate(*pBuffer++, &crcTmp);
+        }
+        return crcTmp;
+}
+
+/**
+ * @brief Accumulate the X.25 CRC by adding an array of bytes
+ *
+ * The checksum function adds the hash of one char at a time to the
+ * 16 bit checksum (uint16_t).
+ *
+ * @param data new bytes to hash
+ * @param crcAccum the already accumulated checksum
+ **/
+static inline void crc_accumulate_buffer(uint16_t *crcAccum, const char *pBuffer, uint8_t length)
+{
+	const uint8_t *p = (const uint8_t *)pBuffer;
+	while (length--) {
+                crc_accumulate(*p++, crcAccum);
+        }
+}
+
+
+
+
+#endif /* _CHECKSUM_H_ */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_helpers.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_helpers.h
new file mode 100644
index 000000000..39d6930e5
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_helpers.h
@@ -0,0 +1,507 @@
+#ifndef  _MAVLINK_HELPERS_H_
+#define  _MAVLINK_HELPERS_H_
+
+#include "string.h"
+#include "checksum.h"
+#include "mavlink_types.h"
+
+#ifndef MAVLINK_HELPER
+#define MAVLINK_HELPER
+#endif
+
+/*
+  internal function to give access to the channel status for each channel
+ */
+MAVLINK_HELPER mavlink_status_t* mavlink_get_channel_status(uint8_t chan)
+{
+	static mavlink_status_t m_mavlink_status[MAVLINK_COMM_NUM_BUFFERS];
+	return &m_mavlink_status[chan];
+}
+
+/*
+ internal function to give access to the channel buffer for each channel
+ */
+MAVLINK_HELPER mavlink_message_t* mavlink_get_channel_buffer(uint8_t chan)
+{
+	
+#if MAVLINK_EXTERNAL_RX_BUFFER
+	// No m_mavlink_message array defined in function,
+	// has to be defined externally
+#ifndef m_mavlink_message
+#error ERROR: IF #define MAVLINK_EXTERNAL_RX_BUFFER IS SET, THE BUFFER HAS TO BE ALLOCATED OUTSIDE OF THIS FUNCTION (mavlink_message_t m_mavlink_buffer[MAVLINK_COMM_NUM_BUFFERS];)
+#endif
+#else
+	static mavlink_message_t m_mavlink_buffer[MAVLINK_COMM_NUM_BUFFERS];
+#endif
+	return &m_mavlink_buffer[chan];
+}
+
+/**
+ * @brief Finalize a MAVLink message with channel assignment
+ *
+ * This function calculates the checksum and sets length and aircraft id correctly.
+ * It assumes that the message id and the payload are already correctly set. This function
+ * can also be used if the message header has already been written before (as in mavlink_msg_xxx_pack
+ * instead of mavlink_msg_xxx_pack_headerless), it just introduces little extra overhead.
+ *
+ * @param msg Message to finalize
+ * @param system_id Id of the sending (this) system, 1-127
+ * @param length Message length
+ */
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length, uint8_t crc_extra)
+#else
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length)
+#endif
+{
+	// This code part is the same for all messages;
+	uint16_t checksum;
+	msg->magic = MAVLINK_STX;
+	msg->len = length;
+	msg->sysid = system_id;
+	msg->compid = component_id;
+	// One sequence number per component
+	msg->seq = mavlink_get_channel_status(chan)->current_tx_seq;
+	mavlink_get_channel_status(chan)->current_tx_seq = mavlink_get_channel_status(chan)->current_tx_seq+1;
+	checksum = crc_calculate((uint8_t*)&msg->len, length + MAVLINK_CORE_HEADER_LEN);
+#if MAVLINK_CRC_EXTRA
+	crc_accumulate(crc_extra, &checksum);
+#endif
+	mavlink_ck_a(msg) = (uint8_t)(checksum & 0xFF);
+	mavlink_ck_b(msg) = (uint8_t)(checksum >> 8);
+
+	return length + MAVLINK_NUM_NON_PAYLOAD_BYTES;
+}
+
+
+/**
+ * @brief Finalize a MAVLink message with MAVLINK_COMM_0 as default channel
+ */
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length, uint8_t crc_extra)
+{
+	return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, length, crc_extra);
+}
+#else
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length)
+{
+	return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, length);
+}
+#endif
+
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len);
+
+/**
+ * @brief Finalize a MAVLink message with channel assignment and send
+ */
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, 
+						    uint8_t length, uint8_t crc_extra)
+#else
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, uint8_t length)
+#endif
+{
+	uint16_t checksum;
+	uint8_t buf[MAVLINK_NUM_HEADER_BYTES];
+	uint8_t ck[2];
+	mavlink_status_t *status = mavlink_get_channel_status(chan);
+	buf[0] = MAVLINK_STX;
+	buf[1] = length;
+	buf[2] = status->current_tx_seq;
+	buf[3] = mavlink_system.sysid;
+	buf[4] = mavlink_system.compid;
+	buf[5] = msgid;
+	status->current_tx_seq++;
+	checksum = crc_calculate((uint8_t*)&buf[1], MAVLINK_CORE_HEADER_LEN);
+	crc_accumulate_buffer(&checksum, packet, length);
+#if MAVLINK_CRC_EXTRA
+	crc_accumulate(crc_extra, &checksum);
+#endif
+	ck[0] = (uint8_t)(checksum & 0xFF);
+	ck[1] = (uint8_t)(checksum >> 8);
+
+	MAVLINK_START_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)length);
+	_mavlink_send_uart(chan, (const char *)buf, MAVLINK_NUM_HEADER_BYTES);
+	_mavlink_send_uart(chan, packet, length);
+	_mavlink_send_uart(chan, (const char *)ck, 2);
+	MAVLINK_END_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)length);
+}
+#endif // MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+/**
+ * @brief Pack a message to send it over a serial byte stream
+ */
+MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t *buffer, const mavlink_message_t *msg)
+{
+	memcpy(buffer, (const uint8_t *)&msg->magic, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len);
+	return MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len;
+}
+
+union __mavlink_bitfield {
+	uint8_t uint8;
+	int8_t int8;
+	uint16_t uint16;
+	int16_t int16;
+	uint32_t uint32;
+	int32_t int32;
+};
+
+
+MAVLINK_HELPER void mavlink_start_checksum(mavlink_message_t* msg)
+{
+	crc_init(&msg->checksum);
+}
+
+MAVLINK_HELPER void mavlink_update_checksum(mavlink_message_t* msg, uint8_t c)
+{
+	crc_accumulate(c, &msg->checksum);
+}
+
+/**
+ * This is a convenience function which handles the complete MAVLink parsing.
+ * the function will parse one byte at a time and return the complete packet once
+ * it could be successfully decoded. Checksum and other failures will be silently
+ * ignored.
+ *
+ * @param chan     ID of the current channel. This allows to parse different channels with this function.
+ *                 a channel is not a physical message channel like a serial port, but a logic partition of
+ *                 the communication streams in this case. COMM_NB is the limit for the number of channels
+ *                 on MCU (e.g. ARM7), while COMM_NB_HIGH is the limit for the number of channels in Linux/Windows
+ * @param c        The char to barse
+ *
+ * @param returnMsg NULL if no message could be decoded, the message data else
+ * @return 0 if no message could be decoded, 1 else
+ *
+ * A typical use scenario of this function call is:
+ *
+ * @code
+ * #include <inttypes.h> // For fixed-width uint8_t type
+ *
+ * mavlink_message_t msg;
+ * int chan = 0;
+ *
+ *
+ * while(serial.bytesAvailable > 0)
+ * {
+ *   uint8_t byte = serial.getNextByte();
+ *   if (mavlink_parse_char(chan, byte, &msg))
+ *     {
+ *     printf("Received message with ID %d, sequence: %d from component %d of system %d", msg.msgid, msg.seq, msg.compid, msg.sysid);
+ *     }
+ * }
+ *
+ *
+ * @endcode
+ */
+MAVLINK_HELPER uint8_t mavlink_parse_char(uint8_t chan, uint8_t c, mavlink_message_t* r_message, mavlink_status_t* r_mavlink_status)
+{
+        /*
+	  default message crc function. You can override this per-system to
+	  put this data in a different memory segment
+	*/
+#if MAVLINK_CRC_EXTRA
+#ifndef MAVLINK_MESSAGE_CRC
+	static const uint8_t mavlink_message_crcs[256] = MAVLINK_MESSAGE_CRCS;
+#define MAVLINK_MESSAGE_CRC(msgid) mavlink_message_crcs[msgid]
+#endif
+#endif
+
+	mavlink_message_t* rxmsg = mavlink_get_channel_buffer(chan); ///< The currently decoded message
+	mavlink_status_t* status = mavlink_get_channel_status(chan); ///< The current decode status
+	int bufferIndex = 0;
+
+	status->msg_received = 0;
+
+	switch (status->parse_state)
+	{
+	case MAVLINK_PARSE_STATE_UNINIT:
+	case MAVLINK_PARSE_STATE_IDLE:
+		if (c == MAVLINK_STX)
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
+			rxmsg->len = 0;
+			rxmsg->magic = c;
+			mavlink_start_checksum(rxmsg);
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_STX:
+			if (status->msg_received 
+/* Support shorter buffers than the
+   default maximum packet size */
+#if (MAVLINK_MAX_PAYLOAD_LEN < 255)
+				|| c > MAVLINK_MAX_PAYLOAD_LEN
+#endif
+				)
+		{
+			status->buffer_overrun++;
+			status->parse_error++;
+			status->msg_received = 0;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+		}
+		else
+		{
+			// NOT counting STX, LENGTH, SEQ, SYSID, COMPID, MSGID, CRC1 and CRC2
+			rxmsg->len = c;
+			status->packet_idx = 0;
+			mavlink_update_checksum(rxmsg, c);
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_LENGTH;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_LENGTH:
+		rxmsg->seq = c;
+		mavlink_update_checksum(rxmsg, c);
+		status->parse_state = MAVLINK_PARSE_STATE_GOT_SEQ;
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_SEQ:
+		rxmsg->sysid = c;
+		mavlink_update_checksum(rxmsg, c);
+		status->parse_state = MAVLINK_PARSE_STATE_GOT_SYSID;
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_SYSID:
+		rxmsg->compid = c;
+		mavlink_update_checksum(rxmsg, c);
+		status->parse_state = MAVLINK_PARSE_STATE_GOT_COMPID;
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_COMPID:
+		rxmsg->msgid = c;
+		mavlink_update_checksum(rxmsg, c);
+		if (rxmsg->len == 0)
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
+		}
+		else
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_MSGID;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_MSGID:
+		_MAV_PAYLOAD_NON_CONST(rxmsg)[status->packet_idx++] = (char)c;
+		mavlink_update_checksum(rxmsg, c);
+		if (status->packet_idx == rxmsg->len)
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_PAYLOAD:
+#if MAVLINK_CRC_EXTRA
+		mavlink_update_checksum(rxmsg, MAVLINK_MESSAGE_CRC(rxmsg->msgid));
+#endif
+		if (c != (rxmsg->checksum & 0xFF)) {
+			// Check first checksum byte
+			status->parse_error++;
+			status->msg_received = 0;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+			if (c == MAVLINK_STX)
+			{
+				status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
+				rxmsg->len = 0;
+				mavlink_start_checksum(rxmsg);
+			}
+		}
+		else
+		{
+			status->parse_state = MAVLINK_PARSE_STATE_GOT_CRC1;
+			_MAV_PAYLOAD_NON_CONST(rxmsg)[status->packet_idx] = (char)c;
+		}
+		break;
+
+	case MAVLINK_PARSE_STATE_GOT_CRC1:
+		if (c != (rxmsg->checksum >> 8)) {
+			// Check second checksum byte
+			status->parse_error++;
+			status->msg_received = 0;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+			if (c == MAVLINK_STX)
+			{
+				status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
+				rxmsg->len = 0;
+				mavlink_start_checksum(rxmsg);
+			}
+		}
+		else
+		{
+			// Successfully got message
+			status->msg_received = 1;
+			status->parse_state = MAVLINK_PARSE_STATE_IDLE;
+			_MAV_PAYLOAD_NON_CONST(rxmsg)[status->packet_idx+1] = (char)c;
+			memcpy(r_message, rxmsg, sizeof(mavlink_message_t));
+		}
+		break;
+	}
+
+	bufferIndex++;
+	// If a message has been sucessfully decoded, check index
+	if (status->msg_received == 1)
+	{
+		//while(status->current_seq != rxmsg->seq)
+		//{
+		//	status->packet_rx_drop_count++;
+		//               status->current_seq++;
+		//}
+		status->current_rx_seq = rxmsg->seq;
+		// Initial condition: If no packet has been received so far, drop count is undefined
+		if (status->packet_rx_success_count == 0) status->packet_rx_drop_count = 0;
+		// Count this packet as received
+		status->packet_rx_success_count++;
+	}
+
+	r_mavlink_status->current_rx_seq = status->current_rx_seq+1;
+	r_mavlink_status->packet_rx_success_count = status->packet_rx_success_count;
+	r_mavlink_status->packet_rx_drop_count = status->parse_error;
+	status->parse_error = 0;
+	return status->msg_received;
+}
+
+/**
+ * @brief Put a bitfield of length 1-32 bit into the buffer
+ *
+ * @param b the value to add, will be encoded in the bitfield
+ * @param bits number of bits to use to encode b, e.g. 1 for boolean, 2, 3, etc.
+ * @param packet_index the position in the packet (the index of the first byte to use)
+ * @param bit_index the position in the byte (the index of the first bit to use)
+ * @param buffer packet buffer to write into
+ * @return new position of the last used byte in the buffer
+ */
+MAVLINK_HELPER uint8_t put_bitfield_n_by_index(int32_t b, uint8_t bits, uint8_t packet_index, uint8_t bit_index, uint8_t* r_bit_index, uint8_t* buffer)
+{
+	uint16_t bits_remain = bits;
+	// Transform number into network order
+	int32_t v;
+	uint8_t i_bit_index, i_byte_index, curr_bits_n;
+#if MAVLINK_NEED_BYTE_SWAP
+	union {
+		int32_t i;
+		uint8_t b[4];
+	} bin, bout;
+	bin.i = b;
+	bout.b[0] = bin.b[3];
+	bout.b[1] = bin.b[2];
+	bout.b[2] = bin.b[1];
+	bout.b[3] = bin.b[0];
+	v = bout.i;
+#else
+	v = b;
+#endif
+
+	// buffer in
+	// 01100000 01000000 00000000 11110001
+	// buffer out
+	// 11110001 00000000 01000000 01100000
+
+	// Existing partly filled byte (four free slots)
+	// 0111xxxx
+
+	// Mask n free bits
+	// 00001111 = 2^0 + 2^1 + 2^2 + 2^3 = 2^n - 1
+	// = ((uint32_t)(1 << n)) - 1; // = 2^n - 1
+
+	// Shift n bits into the right position
+	// out = in >> n;
+
+	// Mask and shift bytes
+	i_bit_index = bit_index;
+	i_byte_index = packet_index;
+	if (bit_index > 0)
+	{
+		// If bits were available at start, they were available
+		// in the byte before the current index
+		i_byte_index--;
+	}
+
+	// While bits have not been packed yet
+	while (bits_remain > 0)
+	{
+		// Bits still have to be packed
+		// there can be more than 8 bits, so
+		// we might have to pack them into more than one byte
+
+		// First pack everything we can into the current 'open' byte
+		//curr_bits_n = bits_remain << 3; // Equals  bits_remain mod 8
+		//FIXME
+		if (bits_remain <= (uint8_t)(8 - i_bit_index))
+		{
+			// Enough space
+			curr_bits_n = (uint8_t)bits_remain;
+		}
+		else
+		{
+			curr_bits_n = (8 - i_bit_index);
+		}
+		
+		// Pack these n bits into the current byte
+		// Mask out whatever was at that position with ones (xxx11111)
+		buffer[i_byte_index] &= (0xFF >> (8 - curr_bits_n));
+		// Put content to this position, by masking out the non-used part
+		buffer[i_byte_index] |= ((0x00 << curr_bits_n) & v);
+		
+		// Increment the bit index
+		i_bit_index += curr_bits_n;
+
+		// Now proceed to the next byte, if necessary
+		bits_remain -= curr_bits_n;
+		if (bits_remain > 0)
+		{
+			// Offer another 8 bits / one byte
+			i_byte_index++;
+			i_bit_index = 0;
+		}
+	}
+	
+	*r_bit_index = i_bit_index;
+	// If a partly filled byte is present, mark this as consumed
+	if (i_bit_index != 7) i_byte_index++;
+	return i_byte_index - packet_index;
+}
+
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+// To make MAVLink work on your MCU, define comm_send_ch() if you wish
+// to send 1 byte at a time, or MAVLINK_SEND_UART_BYTES() to send a
+// whole packet at a time
+
+/*
+
+#include "mavlink_types.h"
+
+void comm_send_ch(mavlink_channel_t chan, uint8_t ch)
+{
+    if (chan == MAVLINK_COMM_0)
+    {
+        uart0_transmit(ch);
+    }
+    if (chan == MAVLINK_COMM_1)
+    {
+    	uart1_transmit(ch);
+    }
+}
+ */
+
+MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len)
+{
+#ifdef MAVLINK_SEND_UART_BYTES
+	/* this is the more efficient approach, if the platform
+	   defines it */
+	MAVLINK_SEND_UART_BYTES(chan, (uint8_t *)buf, len);
+#else
+	/* fallback to one byte at a time */
+	uint16_t i;
+	for (i = 0; i < len; i++) {
+		comm_send_ch(chan, (uint8_t)buf[i]);
+	}
+#endif
+}
+#endif // MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+#endif /* _MAVLINK_HELPERS_H_ */
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_protobuf_manager.hpp b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_protobuf_manager.hpp
new file mode 100644
index 000000000..fd3ddd026
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_protobuf_manager.hpp
@@ -0,0 +1,377 @@
+#ifndef MAVLINKPROTOBUFMANAGER_HPP
+#define MAVLINKPROTOBUFMANAGER_HPP
+
+#include <deque>
+#include <google/protobuf/message.h>
+#include <iostream>
+#include <tr1/memory>
+
+#include <checksum.h>
+#include <common/mavlink.h>
+#include <mavlink_types.h>
+#include <pixhawk/pixhawk.pb.h>
+
+namespace mavlink
+{
+
+class ProtobufManager
+{
+public:
+	ProtobufManager()
+	 : mRegisteredTypeCount(0)
+	 , mStreamID(0)
+	 , mVerbose(false)
+	 , kExtendedHeaderSize(MAVLINK_EXTENDED_HEADER_LEN)
+	 , kExtendedPayloadMaxSize(MAVLINK_MAX_EXTENDED_PAYLOAD_LEN)
+	{
+		// register GLOverlay
+		{
+			std::tr1::shared_ptr<px::GLOverlay> msg(new px::GLOverlay);
+			registerType(msg);
+		}
+
+		// register ObstacleList
+		{
+			std::tr1::shared_ptr<px::ObstacleList> msg(new px::ObstacleList);
+			registerType(msg);
+		}
+
+		// register ObstacleMap
+		{
+			std::tr1::shared_ptr<px::ObstacleMap> msg(new px::ObstacleMap);
+			registerType(msg);
+		}
+
+		// register Path
+		{
+			std::tr1::shared_ptr<px::Path> msg(new px::Path);
+                        registerType(msg);
+		}
+
+		// register PointCloudXYZI
+		{
+			std::tr1::shared_ptr<px::PointCloudXYZI> msg(new px::PointCloudXYZI);
+			registerType(msg);
+		}
+
+		// register PointCloudXYZRGB
+		{
+			std::tr1::shared_ptr<px::PointCloudXYZRGB> msg(new px::PointCloudXYZRGB);
+			registerType(msg);
+		}
+
+		// register RGBDImage
+		{
+			std::tr1::shared_ptr<px::RGBDImage> msg(new px::RGBDImage);
+			registerType(msg);
+		}
+
+		srand(time(NULL));
+		mStreamID = rand() + 1;
+	}
+
+	bool fragmentMessage(uint8_t system_id, uint8_t component_id,
+						 uint8_t target_system, uint8_t target_component,
+						 const google::protobuf::Message& protobuf_msg,
+						 std::vector<mavlink_extended_message_t>& fragments) const
+	{
+		TypeMap::const_iterator it = mTypeMap.find(protobuf_msg.GetTypeName());
+		if (it == mTypeMap.end())
+		{
+			std::cout << "# WARNING: Protobuf message with type "
+					  << protobuf_msg.GetTypeName() << " is not registered."
+					  << std::endl;
+			return false;
+		}
+
+		uint8_t typecode = it->second;
+
+		std::string data = protobuf_msg.SerializeAsString();
+
+		int fragmentCount = (protobuf_msg.ByteSize() + kExtendedPayloadMaxSize - 1) / kExtendedPayloadMaxSize;
+		unsigned int offset = 0;
+
+		for (int i = 0; i < fragmentCount; ++i)
+		{
+			mavlink_extended_message_t fragment;			
+
+			// write extended header data
+			uint8_t* payload = reinterpret_cast<uint8_t*>(fragment.base_msg.payload64);
+			unsigned int length = 0;
+			uint8_t flags = 0;
+
+			if (i < fragmentCount - 1)
+			{
+				length = kExtendedPayloadMaxSize;
+				flags |= 0x1;
+			}
+			else
+			{
+				length = protobuf_msg.ByteSize() - kExtendedPayloadMaxSize * (fragmentCount - 1);
+			}
+
+			memcpy(payload, &target_system, 1);
+			memcpy(payload + 1, &target_component, 1);
+			memcpy(payload + 2, &typecode, 1);
+			memcpy(payload + 3, &length, 4);
+			memcpy(payload + 7, &mStreamID, 2);
+			memcpy(payload + 9, &offset, 4);
+			memcpy(payload + 13, &flags, 1);
+
+			fragment.base_msg.msgid = MAVLINK_MSG_ID_EXTENDED_MESSAGE;
+			mavlink_finalize_message(&fragment.base_msg, system_id, component_id, kExtendedHeaderSize, 0);
+			
+			// write extended payload data
+			fragment.extended_payload_len = length;
+			memcpy(fragment.extended_payload, &data[offset], length);
+
+			fragments.push_back(fragment);
+			offset += length;
+		}
+
+		if (mVerbose)
+		{
+			std::cerr << "# INFO: Split extended message with size "
+					  << protobuf_msg.ByteSize() << " into "
+					  << fragmentCount << " fragments." << std::endl;
+		}
+
+		return true;
+	}
+
+	bool cacheFragment(mavlink_extended_message_t& msg)
+	{
+		if (!validFragment(msg))
+		{
+			if (mVerbose)
+			{
+				std::cerr << "# WARNING: Message is not a valid fragment. "
+						  << "Dropping message..." << std::endl;
+			}
+			return false;
+		}
+
+		// read extended header
+		uint8_t* payload = reinterpret_cast<uint8_t*>(msg.base_msg.payload64);
+		uint8_t typecode = 0;
+		unsigned int length = 0;
+		unsigned short streamID = 0;
+		unsigned int offset = 0;
+		uint8_t flags = 0;
+
+		memcpy(&typecode, payload + 2, 1);
+		memcpy(&length, payload + 3, 4);
+		memcpy(&streamID, payload + 7, 2);
+		memcpy(&offset, payload + 9, 4);
+		memcpy(&flags, payload + 13, 1);
+
+		if (typecode >= mTypeMap.size())
+		{
+			std::cout << "# WARNING: Protobuf message with type code "
+					  << static_cast<int>(typecode) << " is not registered." << std::endl;
+			return false;
+		}
+
+		bool reassemble = false;
+
+		FragmentQueue::iterator it = mFragmentQueue.find(streamID);
+		if (it == mFragmentQueue.end())
+		{
+			if (offset == 0)
+			{
+				mFragmentQueue[streamID].push_back(msg);
+
+				if ((flags & 0x1) != 0x1)
+				{
+					reassemble = true;
+				}
+
+				if (mVerbose)
+				{
+					std::cerr << "# INFO: Added fragment to new queue."
+							  << std::endl;
+				}
+			}
+			else
+			{
+				if (mVerbose)
+				{
+					std::cerr << "# WARNING: Message is not a valid fragment. "
+							  << "Dropping message..." << std::endl;
+				}
+			}
+		}
+		else
+		{
+			std::deque<mavlink_extended_message_t>& queue = it->second;
+
+			if (queue.empty())
+			{
+				if (offset == 0)
+				{
+					queue.push_back(msg);
+
+					if ((flags & 0x1) != 0x1)
+					{
+						reassemble = true;
+					}
+				}
+				else
+				{
+					if (mVerbose)
+					{
+						std::cerr << "# WARNING: Message is not a valid fragment. "
+								  << "Dropping message..." << std::endl;
+					}
+				}
+			}
+			else
+			{
+				if (fragmentDataSize(queue.back()) + fragmentOffset(queue.back()) != offset)
+				{
+					if (mVerbose)
+					{
+						std::cerr << "# WARNING: Previous fragment(s) have been lost. "
+								  << "Dropping message and clearing queue..." << std::endl;
+					}
+					queue.clear();
+				}
+				else
+				{
+					queue.push_back(msg);
+
+					if ((flags & 0x1) != 0x1)
+					{
+						reassemble = true;
+					}
+				}
+			}
+		}
+
+		if (reassemble)
+		{
+			std::deque<mavlink_extended_message_t>& queue = mFragmentQueue[streamID];
+
+			std::string data;
+			for (size_t i = 0; i < queue.size(); ++i)
+			{
+				mavlink_extended_message_t& mavlink_msg = queue.at(i);
+
+				data.append(reinterpret_cast<char*>(&mavlink_msg.extended_payload[0]),
+							static_cast<size_t>(mavlink_msg.extended_payload_len));
+			}
+
+			mMessages.at(typecode)->ParseFromString(data);
+
+			mMessageAvailable.at(typecode) = true;
+
+			queue.clear();
+
+			if (mVerbose)
+			{
+				std::cerr << "# INFO: Reassembled fragments for message with typename "
+						  << mMessages.at(typecode)->GetTypeName() << " and size "
+						  << mMessages.at(typecode)->ByteSize()
+						  << "." << std::endl;
+			}
+		}
+
+		return true;
+	}
+
+	bool getMessage(std::tr1::shared_ptr<google::protobuf::Message>& msg)
+	{
+		for (size_t i = 0; i < mMessageAvailable.size(); ++i)
+		{
+			if (mMessageAvailable.at(i))
+			{
+				msg = mMessages.at(i);
+				mMessageAvailable.at(i) = false;
+
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+private:
+	void registerType(const std::tr1::shared_ptr<google::protobuf::Message>& msg)
+	{
+		mTypeMap[msg->GetTypeName()] = mRegisteredTypeCount;
+		++mRegisteredTypeCount;
+		mMessages.push_back(msg);
+		mMessageAvailable.push_back(false);
+	}
+
+	bool validFragment(const mavlink_extended_message_t& msg) const
+	{
+		if (msg.base_msg.magic != MAVLINK_STX ||
+			msg.base_msg.len != kExtendedHeaderSize ||
+			msg.base_msg.msgid != MAVLINK_MSG_ID_EXTENDED_MESSAGE)
+		{
+			return false;
+		}
+
+		uint16_t checksum;
+		checksum = crc_calculate(reinterpret_cast<const uint8_t*>(&msg.base_msg.len), MAVLINK_CORE_HEADER_LEN);
+		crc_accumulate_buffer(&checksum, reinterpret_cast<const char*>(&msg.base_msg.payload64), kExtendedHeaderSize);
+#if MAVLINK_CRC_EXTRA
+		static const uint8_t mavlink_message_crcs[256] = MAVLINK_MESSAGE_CRCS;
+		crc_accumulate(mavlink_message_crcs[msg.base_msg.msgid], &checksum);
+#endif
+
+		if (mavlink_ck_a(&(msg.base_msg)) != (uint8_t)(checksum & 0xFF) &&
+		    mavlink_ck_b(&(msg.base_msg)) != (uint8_t)(checksum >> 8))
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	unsigned int fragmentDataSize(const mavlink_extended_message_t& msg) const
+	{
+		const uint8_t* payload = reinterpret_cast<const uint8_t*>(msg.base_msg.payload64);
+
+		return *(reinterpret_cast<const unsigned int*>(payload + 3));
+	}
+
+	unsigned int fragmentOffset(const mavlink_extended_message_t& msg) const
+	{
+		const uint8_t* payload = reinterpret_cast<const uint8_t*>(msg.base_msg.payload64);
+
+		return *(reinterpret_cast<const unsigned int*>(payload + 9));
+	}
+
+	int mRegisteredTypeCount;
+	unsigned short mStreamID;
+	bool mVerbose;
+
+	typedef std::map<std::string, uint8_t> TypeMap;
+	TypeMap mTypeMap;
+	std::vector< std::tr1::shared_ptr<google::protobuf::Message> > mMessages;
+	std::vector<bool> mMessageAvailable;
+
+	typedef std::map<unsigned short, std::deque<mavlink_extended_message_t> > FragmentQueue;
+	FragmentQueue mFragmentQueue;
+
+	const int kExtendedHeaderSize;
+	/**
+	 * Extended header structure
+	 * =========================
+	 *   byte 0 - target_system
+	 *   byte 1 - target_component
+	 *   byte 2 - extended message id (type code)
+	 *   bytes 3-6 - extended payload size in bytes
+	 *   byte 7-8 - stream ID
+	 *   byte 9-12 - fragment offset
+	 *   byte 13 - fragment flags (bit 0 - 1=more fragments, 0=last fragment)
+	 */
+
+	const int kExtendedPayloadMaxSize;
+};
+
+}
+
+#endif
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_types.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_types.h
new file mode 100644
index 000000000..5fbde97f7
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/mavlink_types.h
@@ -0,0 +1,158 @@
+#ifndef MAVLINK_TYPES_H_
+#define MAVLINK_TYPES_H_
+
+#include <inttypes.h>
+
+#ifndef MAVLINK_MAX_PAYLOAD_LEN
+// it is possible to override this, but be careful!
+#define MAVLINK_MAX_PAYLOAD_LEN 255 ///< Maximum payload length
+#endif
+
+#define MAVLINK_CORE_HEADER_LEN 5 ///< Length of core header (of the comm. layer): message length (1 byte) + message sequence (1 byte) + message system id (1 byte) + message component id (1 byte) + message type id (1 byte)
+#define MAVLINK_NUM_HEADER_BYTES (MAVLINK_CORE_HEADER_LEN + 1) ///< Length of all header bytes, including core and checksum
+#define MAVLINK_NUM_CHECKSUM_BYTES 2
+#define MAVLINK_NUM_NON_PAYLOAD_BYTES (MAVLINK_NUM_HEADER_BYTES + MAVLINK_NUM_CHECKSUM_BYTES)
+
+#define MAVLINK_MAX_PACKET_LEN (MAVLINK_MAX_PAYLOAD_LEN + MAVLINK_NUM_NON_PAYLOAD_BYTES) ///< Maximum packet length
+
+#define MAVLINK_MSG_ID_EXTENDED_MESSAGE 255
+#define MAVLINK_EXTENDED_HEADER_LEN 14
+
+#if (defined _MSC_VER) | ((defined __APPLE__) & (defined __MACH__)) | (defined __linux__)
+  /* full fledged 32bit++ OS */
+  #define MAVLINK_MAX_EXTENDED_PACKET_LEN 65507
+#else
+  /* small microcontrollers */
+  #define MAVLINK_MAX_EXTENDED_PACKET_LEN 2048
+#endif
+
+#define MAVLINK_MAX_EXTENDED_PAYLOAD_LEN (MAVLINK_MAX_EXTENDED_PACKET_LEN - MAVLINK_EXTENDED_HEADER_LEN - MAVLINK_NUM_NON_PAYLOAD_BYTES)
+
+typedef struct param_union {
+	union {
+		float param_float;
+		int32_t param_int32;
+		uint32_t param_uint32;
+		uint8_t param_uint8;
+		uint8_t bytes[4];
+	};
+	uint8_t type;
+} mavlink_param_union_t;
+
+typedef struct __mavlink_system {
+    uint8_t sysid;   ///< Used by the MAVLink message_xx_send() convenience function
+    uint8_t compid;  ///< Used by the MAVLink message_xx_send() convenience function
+    uint8_t type;    ///< Unused, can be used by user to store the system's type
+    uint8_t state;   ///< Unused, can be used by user to store the system's state
+    uint8_t mode;    ///< Unused, can be used by user to store the system's mode
+    uint8_t nav_mode;    ///< Unused, can be used by user to store the system's navigation mode
+} mavlink_system_t;
+
+typedef struct __mavlink_message {
+	uint16_t checksum; /// sent at end of packet
+	uint8_t magic;   ///< protocol magic marker
+	uint8_t len;     ///< Length of payload
+	uint8_t seq;     ///< Sequence of packet
+	uint8_t sysid;   ///< ID of message sender system/aircraft
+	uint8_t compid;  ///< ID of the message sender component
+	uint8_t msgid;   ///< ID of message in payload
+	uint64_t payload64[(MAVLINK_MAX_PAYLOAD_LEN+MAVLINK_NUM_CHECKSUM_BYTES+7)/8];
+} mavlink_message_t;
+
+
+typedef struct __mavlink_extended_message {
+       mavlink_message_t base_msg;
+       int32_t extended_payload_len;   ///< Length of extended payload if any
+       uint8_t extended_payload[MAVLINK_MAX_EXTENDED_PAYLOAD_LEN];
+} mavlink_extended_message_t;
+
+
+typedef enum {
+	MAVLINK_TYPE_CHAR     = 0,
+	MAVLINK_TYPE_UINT8_T  = 1,
+	MAVLINK_TYPE_INT8_T   = 2,
+	MAVLINK_TYPE_UINT16_T = 3,
+	MAVLINK_TYPE_INT16_T  = 4,
+	MAVLINK_TYPE_UINT32_T = 5,
+	MAVLINK_TYPE_INT32_T  = 6,
+	MAVLINK_TYPE_UINT64_T = 7,
+	MAVLINK_TYPE_INT64_T  = 8,
+	MAVLINK_TYPE_FLOAT    = 9,
+	MAVLINK_TYPE_DOUBLE   = 10
+} mavlink_message_type_t;
+
+#define MAVLINK_MAX_FIELDS 64
+
+typedef struct __mavlink_field_info {
+        const char *name;                 // name of this field
+        const char *print_format;         // printing format hint, or NULL
+        mavlink_message_type_t type;      // type of this field
+        unsigned int array_length;        // if non-zero, field is an array
+        unsigned int wire_offset;         // offset of each field in the payload
+        unsigned int structure_offset;    // offset in a C structure
+} mavlink_field_info_t;
+
+// note that in this structure the order of fields is the order
+// in the XML file, not necessary the wire order
+typedef struct __mavlink_message_info {
+	const char *name;                                      // name of the message
+	unsigned num_fields;                                   // how many fields in this message
+	mavlink_field_info_t fields[MAVLINK_MAX_FIELDS];       // field information
+} mavlink_message_info_t;
+
+#define _MAV_PAYLOAD(msg) ((const char *)(&((msg)->payload64[0])))
+#define _MAV_PAYLOAD_NON_CONST(msg) ((char *)(&((msg)->payload64[0])))
+
+// checksum is immediately after the payload bytes
+#define mavlink_ck_a(msg) *((msg)->len + (uint8_t *)_MAV_PAYLOAD_NON_CONST(msg))
+#define mavlink_ck_b(msg) *(((msg)->len+(uint16_t)1) + (uint8_t *)_MAV_PAYLOAD_NON_CONST(msg))
+
+typedef enum {
+    MAVLINK_COMM_0,
+    MAVLINK_COMM_1,
+    MAVLINK_COMM_2,
+    MAVLINK_COMM_3
+} mavlink_channel_t;
+
+/*
+ * applications can set MAVLINK_COMM_NUM_BUFFERS to the maximum number
+ * of buffers they will use. If more are used, then the result will be
+ * a stack overrun
+ */
+#ifndef MAVLINK_COMM_NUM_BUFFERS
+#if (defined linux) | (defined __linux) | (defined  __MACH__) | (defined _WIN32)
+# define MAVLINK_COMM_NUM_BUFFERS 16
+#else
+# define MAVLINK_COMM_NUM_BUFFERS 4
+#endif
+#endif
+
+typedef enum {
+    MAVLINK_PARSE_STATE_UNINIT=0,
+    MAVLINK_PARSE_STATE_IDLE,
+    MAVLINK_PARSE_STATE_GOT_STX,
+    MAVLINK_PARSE_STATE_GOT_SEQ,
+    MAVLINK_PARSE_STATE_GOT_LENGTH,
+    MAVLINK_PARSE_STATE_GOT_SYSID,
+    MAVLINK_PARSE_STATE_GOT_COMPID,
+    MAVLINK_PARSE_STATE_GOT_MSGID,
+    MAVLINK_PARSE_STATE_GOT_PAYLOAD,
+    MAVLINK_PARSE_STATE_GOT_CRC1
+} mavlink_parse_state_t; ///< The state machine for the comm parser
+
+typedef struct __mavlink_status {
+    uint8_t msg_received;               ///< Number of received messages
+    uint8_t buffer_overrun;             ///< Number of buffer overruns
+    uint8_t parse_error;                ///< Number of parse errors
+    mavlink_parse_state_t parse_state;  ///< Parsing state machine
+    uint8_t packet_idx;                 ///< Index in current packet
+    uint8_t current_rx_seq;             ///< Sequence number of last packet received
+    uint8_t current_tx_seq;             ///< Sequence number of last packet sent
+    uint16_t packet_rx_success_count;   ///< Received packets
+    uint16_t packet_rx_drop_count;      ///< Number of packet drops
+} mavlink_status_t;
+
+#define MAVLINK_BIG_ENDIAN 0
+#define MAVLINK_LITTLE_ENDIAN 1
+
+#endif /* MAVLINK_TYPES_H_ */
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/pixhawk/pixhawk.pb.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/pixhawk/pixhawk.pb.h
new file mode 100644
index 000000000..7556606e9
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/pixhawk/pixhawk.pb.h
@@ -0,0 +1,3663 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: pixhawk.proto
+
+#ifndef PROTOBUF_pixhawk_2eproto__INCLUDED
+#define PROTOBUF_pixhawk_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2004000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_message_reflection.h>
+// @@protoc_insertion_point(includes)
+
+namespace px {
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_pixhawk_2eproto();
+void protobuf_AssignDesc_pixhawk_2eproto();
+void protobuf_ShutdownFile_pixhawk_2eproto();
+
+class HeaderInfo;
+class GLOverlay;
+class Obstacle;
+class ObstacleList;
+class ObstacleMap;
+class Path;
+class PointCloudXYZI;
+class PointCloudXYZI_PointXYZI;
+class PointCloudXYZRGB;
+class PointCloudXYZRGB_PointXYZRGB;
+class RGBDImage;
+class Waypoint;
+
+enum GLOverlay_CoordinateFrameType {
+  GLOverlay_CoordinateFrameType_GLOBAL = 0,
+  GLOverlay_CoordinateFrameType_LOCAL = 1
+};
+bool GLOverlay_CoordinateFrameType_IsValid(int value);
+const GLOverlay_CoordinateFrameType GLOverlay_CoordinateFrameType_CoordinateFrameType_MIN = GLOverlay_CoordinateFrameType_GLOBAL;
+const GLOverlay_CoordinateFrameType GLOverlay_CoordinateFrameType_CoordinateFrameType_MAX = GLOverlay_CoordinateFrameType_LOCAL;
+const int GLOverlay_CoordinateFrameType_CoordinateFrameType_ARRAYSIZE = GLOverlay_CoordinateFrameType_CoordinateFrameType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GLOverlay_CoordinateFrameType_descriptor();
+inline const ::std::string& GLOverlay_CoordinateFrameType_Name(GLOverlay_CoordinateFrameType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GLOverlay_CoordinateFrameType_descriptor(), value);
+}
+inline bool GLOverlay_CoordinateFrameType_Parse(
+    const ::std::string& name, GLOverlay_CoordinateFrameType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GLOverlay_CoordinateFrameType>(
+    GLOverlay_CoordinateFrameType_descriptor(), name, value);
+}
+enum GLOverlay_Mode {
+  GLOverlay_Mode_POINTS = 0,
+  GLOverlay_Mode_LINES = 1,
+  GLOverlay_Mode_LINE_STRIP = 2,
+  GLOverlay_Mode_LINE_LOOP = 3,
+  GLOverlay_Mode_TRIANGLES = 4,
+  GLOverlay_Mode_TRIANGLE_STRIP = 5,
+  GLOverlay_Mode_TRIANGLE_FAN = 6,
+  GLOverlay_Mode_QUADS = 7,
+  GLOverlay_Mode_QUAD_STRIP = 8,
+  GLOverlay_Mode_POLYGON = 9,
+  GLOverlay_Mode_SOLID_CIRCLE = 10,
+  GLOverlay_Mode_WIRE_CIRCLE = 11,
+  GLOverlay_Mode_SOLID_CUBE = 12,
+  GLOverlay_Mode_WIRE_CUBE = 13
+};
+bool GLOverlay_Mode_IsValid(int value);
+const GLOverlay_Mode GLOverlay_Mode_Mode_MIN = GLOverlay_Mode_POINTS;
+const GLOverlay_Mode GLOverlay_Mode_Mode_MAX = GLOverlay_Mode_WIRE_CUBE;
+const int GLOverlay_Mode_Mode_ARRAYSIZE = GLOverlay_Mode_Mode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GLOverlay_Mode_descriptor();
+inline const ::std::string& GLOverlay_Mode_Name(GLOverlay_Mode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GLOverlay_Mode_descriptor(), value);
+}
+inline bool GLOverlay_Mode_Parse(
+    const ::std::string& name, GLOverlay_Mode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GLOverlay_Mode>(
+    GLOverlay_Mode_descriptor(), name, value);
+}
+enum GLOverlay_Identifier {
+  GLOverlay_Identifier_END = 14,
+  GLOverlay_Identifier_VERTEX2F = 15,
+  GLOverlay_Identifier_VERTEX3F = 16,
+  GLOverlay_Identifier_ROTATEF = 17,
+  GLOverlay_Identifier_TRANSLATEF = 18,
+  GLOverlay_Identifier_SCALEF = 19,
+  GLOverlay_Identifier_PUSH_MATRIX = 20,
+  GLOverlay_Identifier_POP_MATRIX = 21,
+  GLOverlay_Identifier_COLOR3F = 22,
+  GLOverlay_Identifier_COLOR4F = 23,
+  GLOverlay_Identifier_POINTSIZE = 24,
+  GLOverlay_Identifier_LINEWIDTH = 25
+};
+bool GLOverlay_Identifier_IsValid(int value);
+const GLOverlay_Identifier GLOverlay_Identifier_Identifier_MIN = GLOverlay_Identifier_END;
+const GLOverlay_Identifier GLOverlay_Identifier_Identifier_MAX = GLOverlay_Identifier_LINEWIDTH;
+const int GLOverlay_Identifier_Identifier_ARRAYSIZE = GLOverlay_Identifier_Identifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GLOverlay_Identifier_descriptor();
+inline const ::std::string& GLOverlay_Identifier_Name(GLOverlay_Identifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GLOverlay_Identifier_descriptor(), value);
+}
+inline bool GLOverlay_Identifier_Parse(
+    const ::std::string& name, GLOverlay_Identifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GLOverlay_Identifier>(
+    GLOverlay_Identifier_descriptor(), name, value);
+}
+// ===================================================================
+
+class HeaderInfo : public ::google::protobuf::Message {
+ public:
+  HeaderInfo();
+  virtual ~HeaderInfo();
+  
+  HeaderInfo(const HeaderInfo& from);
+  
+  inline HeaderInfo& operator=(const HeaderInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const HeaderInfo& default_instance();
+  
+  void Swap(HeaderInfo* other);
+  
+  // implements Message ----------------------------------------------
+  
+  HeaderInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const HeaderInfo& from);
+  void MergeFrom(const HeaderInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required int32 source_sysid = 1;
+  inline bool has_source_sysid() const;
+  inline void clear_source_sysid();
+  static const int kSourceSysidFieldNumber = 1;
+  inline ::google::protobuf::int32 source_sysid() const;
+  inline void set_source_sysid(::google::protobuf::int32 value);
+  
+  // required int32 source_compid = 2;
+  inline bool has_source_compid() const;
+  inline void clear_source_compid();
+  static const int kSourceCompidFieldNumber = 2;
+  inline ::google::protobuf::int32 source_compid() const;
+  inline void set_source_compid(::google::protobuf::int32 value);
+  
+  // required double timestamp = 3;
+  inline bool has_timestamp() const;
+  inline void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  inline double timestamp() const;
+  inline void set_timestamp(double value);
+  
+  // @@protoc_insertion_point(class_scope:px.HeaderInfo)
+ private:
+  inline void set_has_source_sysid();
+  inline void clear_has_source_sysid();
+  inline void set_has_source_compid();
+  inline void clear_has_source_compid();
+  inline void set_has_timestamp();
+  inline void clear_has_timestamp();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::google::protobuf::int32 source_sysid_;
+  ::google::protobuf::int32 source_compid_;
+  double timestamp_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static HeaderInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GLOverlay : public ::google::protobuf::Message {
+ public:
+  GLOverlay();
+  virtual ~GLOverlay();
+  
+  GLOverlay(const GLOverlay& from);
+  
+  inline GLOverlay& operator=(const GLOverlay& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GLOverlay& default_instance();
+  
+  void Swap(GLOverlay* other);
+  
+  // implements Message ----------------------------------------------
+  
+  GLOverlay* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GLOverlay& from);
+  void MergeFrom(const GLOverlay& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  typedef GLOverlay_CoordinateFrameType CoordinateFrameType;
+  static const CoordinateFrameType GLOBAL = GLOverlay_CoordinateFrameType_GLOBAL;
+  static const CoordinateFrameType LOCAL = GLOverlay_CoordinateFrameType_LOCAL;
+  static inline bool CoordinateFrameType_IsValid(int value) {
+    return GLOverlay_CoordinateFrameType_IsValid(value);
+  }
+  static const CoordinateFrameType CoordinateFrameType_MIN =
+    GLOverlay_CoordinateFrameType_CoordinateFrameType_MIN;
+  static const CoordinateFrameType CoordinateFrameType_MAX =
+    GLOverlay_CoordinateFrameType_CoordinateFrameType_MAX;
+  static const int CoordinateFrameType_ARRAYSIZE =
+    GLOverlay_CoordinateFrameType_CoordinateFrameType_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  CoordinateFrameType_descriptor() {
+    return GLOverlay_CoordinateFrameType_descriptor();
+  }
+  static inline const ::std::string& CoordinateFrameType_Name(CoordinateFrameType value) {
+    return GLOverlay_CoordinateFrameType_Name(value);
+  }
+  static inline bool CoordinateFrameType_Parse(const ::std::string& name,
+      CoordinateFrameType* value) {
+    return GLOverlay_CoordinateFrameType_Parse(name, value);
+  }
+  
+  typedef GLOverlay_Mode Mode;
+  static const Mode POINTS = GLOverlay_Mode_POINTS;
+  static const Mode LINES = GLOverlay_Mode_LINES;
+  static const Mode LINE_STRIP = GLOverlay_Mode_LINE_STRIP;
+  static const Mode LINE_LOOP = GLOverlay_Mode_LINE_LOOP;
+  static const Mode TRIANGLES = GLOverlay_Mode_TRIANGLES;
+  static const Mode TRIANGLE_STRIP = GLOverlay_Mode_TRIANGLE_STRIP;
+  static const Mode TRIANGLE_FAN = GLOverlay_Mode_TRIANGLE_FAN;
+  static const Mode QUADS = GLOverlay_Mode_QUADS;
+  static const Mode QUAD_STRIP = GLOverlay_Mode_QUAD_STRIP;
+  static const Mode POLYGON = GLOverlay_Mode_POLYGON;
+  static const Mode SOLID_CIRCLE = GLOverlay_Mode_SOLID_CIRCLE;
+  static const Mode WIRE_CIRCLE = GLOverlay_Mode_WIRE_CIRCLE;
+  static const Mode SOLID_CUBE = GLOverlay_Mode_SOLID_CUBE;
+  static const Mode WIRE_CUBE = GLOverlay_Mode_WIRE_CUBE;
+  static inline bool Mode_IsValid(int value) {
+    return GLOverlay_Mode_IsValid(value);
+  }
+  static const Mode Mode_MIN =
+    GLOverlay_Mode_Mode_MIN;
+  static const Mode Mode_MAX =
+    GLOverlay_Mode_Mode_MAX;
+  static const int Mode_ARRAYSIZE =
+    GLOverlay_Mode_Mode_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Mode_descriptor() {
+    return GLOverlay_Mode_descriptor();
+  }
+  static inline const ::std::string& Mode_Name(Mode value) {
+    return GLOverlay_Mode_Name(value);
+  }
+  static inline bool Mode_Parse(const ::std::string& name,
+      Mode* value) {
+    return GLOverlay_Mode_Parse(name, value);
+  }
+  
+  typedef GLOverlay_Identifier Identifier;
+  static const Identifier END = GLOverlay_Identifier_END;
+  static const Identifier VERTEX2F = GLOverlay_Identifier_VERTEX2F;
+  static const Identifier VERTEX3F = GLOverlay_Identifier_VERTEX3F;
+  static const Identifier ROTATEF = GLOverlay_Identifier_ROTATEF;
+  static const Identifier TRANSLATEF = GLOverlay_Identifier_TRANSLATEF;
+  static const Identifier SCALEF = GLOverlay_Identifier_SCALEF;
+  static const Identifier PUSH_MATRIX = GLOverlay_Identifier_PUSH_MATRIX;
+  static const Identifier POP_MATRIX = GLOverlay_Identifier_POP_MATRIX;
+  static const Identifier COLOR3F = GLOverlay_Identifier_COLOR3F;
+  static const Identifier COLOR4F = GLOverlay_Identifier_COLOR4F;
+  static const Identifier POINTSIZE = GLOverlay_Identifier_POINTSIZE;
+  static const Identifier LINEWIDTH = GLOverlay_Identifier_LINEWIDTH;
+  static inline bool Identifier_IsValid(int value) {
+    return GLOverlay_Identifier_IsValid(value);
+  }
+  static const Identifier Identifier_MIN =
+    GLOverlay_Identifier_Identifier_MIN;
+  static const Identifier Identifier_MAX =
+    GLOverlay_Identifier_Identifier_MAX;
+  static const int Identifier_ARRAYSIZE =
+    GLOverlay_Identifier_Identifier_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Identifier_descriptor() {
+    return GLOverlay_Identifier_descriptor();
+  }
+  static inline const ::std::string& Identifier_Name(Identifier value) {
+    return GLOverlay_Identifier_Name(value);
+  }
+  static inline bool Identifier_Parse(const ::std::string& name,
+      Identifier* value) {
+    return GLOverlay_Identifier_Parse(name, value);
+  }
+  
+  // accessors -------------------------------------------------------
+  
+  // required .px.HeaderInfo header = 1;
+  inline bool has_header() const;
+  inline void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  inline const ::px::HeaderInfo& header() const;
+  inline ::px::HeaderInfo* mutable_header();
+  inline ::px::HeaderInfo* release_header();
+  
+  // optional string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  
+  // optional .px.GLOverlay.CoordinateFrameType coordinateFrameType = 3;
+  inline bool has_coordinateframetype() const;
+  inline void clear_coordinateframetype();
+  static const int kCoordinateFrameTypeFieldNumber = 3;
+  inline ::px::GLOverlay_CoordinateFrameType coordinateframetype() const;
+  inline void set_coordinateframetype(::px::GLOverlay_CoordinateFrameType value);
+  
+  // optional double origin_x = 4;
+  inline bool has_origin_x() const;
+  inline void clear_origin_x();
+  static const int kOriginXFieldNumber = 4;
+  inline double origin_x() const;
+  inline void set_origin_x(double value);
+  
+  // optional double origin_y = 5;
+  inline bool has_origin_y() const;
+  inline void clear_origin_y();
+  static const int kOriginYFieldNumber = 5;
+  inline double origin_y() const;
+  inline void set_origin_y(double value);
+  
+  // optional double origin_z = 6;
+  inline bool has_origin_z() const;
+  inline void clear_origin_z();
+  static const int kOriginZFieldNumber = 6;
+  inline double origin_z() const;
+  inline void set_origin_z(double value);
+  
+  // optional bytes data = 7;
+  inline bool has_data() const;
+  inline void clear_data();
+  static const int kDataFieldNumber = 7;
+  inline const ::std::string& data() const;
+  inline void set_data(const ::std::string& value);
+  inline void set_data(const char* value);
+  inline void set_data(const void* value, size_t size);
+  inline ::std::string* mutable_data();
+  inline ::std::string* release_data();
+  
+  // @@protoc_insertion_point(class_scope:px.GLOverlay)
+ private:
+  inline void set_has_header();
+  inline void clear_has_header();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_coordinateframetype();
+  inline void clear_has_coordinateframetype();
+  inline void set_has_origin_x();
+  inline void clear_has_origin_x();
+  inline void set_has_origin_y();
+  inline void clear_has_origin_y();
+  inline void set_has_origin_z();
+  inline void clear_has_origin_z();
+  inline void set_has_data();
+  inline void clear_has_data();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::px::HeaderInfo* header_;
+  ::std::string* name_;
+  double origin_x_;
+  double origin_y_;
+  double origin_z_;
+  ::std::string* data_;
+  int coordinateframetype_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static GLOverlay* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class Obstacle : public ::google::protobuf::Message {
+ public:
+  Obstacle();
+  virtual ~Obstacle();
+  
+  Obstacle(const Obstacle& from);
+  
+  inline Obstacle& operator=(const Obstacle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Obstacle& default_instance();
+  
+  void Swap(Obstacle* other);
+  
+  // implements Message ----------------------------------------------
+  
+  Obstacle* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Obstacle& from);
+  void MergeFrom(const Obstacle& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // optional float x = 1;
+  inline bool has_x() const;
+  inline void clear_x();
+  static const int kXFieldNumber = 1;
+  inline float x() const;
+  inline void set_x(float value);
+  
+  // optional float y = 2;
+  inline bool has_y() const;
+  inline void clear_y();
+  static const int kYFieldNumber = 2;
+  inline float y() const;
+  inline void set_y(float value);
+  
+  // optional float z = 3;
+  inline bool has_z() const;
+  inline void clear_z();
+  static const int kZFieldNumber = 3;
+  inline float z() const;
+  inline void set_z(float value);
+  
+  // optional float length = 4;
+  inline bool has_length() const;
+  inline void clear_length();
+  static const int kLengthFieldNumber = 4;
+  inline float length() const;
+  inline void set_length(float value);
+  
+  // optional float width = 5;
+  inline bool has_width() const;
+  inline void clear_width();
+  static const int kWidthFieldNumber = 5;
+  inline float width() const;
+  inline void set_width(float value);
+  
+  // optional float height = 6;
+  inline bool has_height() const;
+  inline void clear_height();
+  static const int kHeightFieldNumber = 6;
+  inline float height() const;
+  inline void set_height(float value);
+  
+  // @@protoc_insertion_point(class_scope:px.Obstacle)
+ private:
+  inline void set_has_x();
+  inline void clear_has_x();
+  inline void set_has_y();
+  inline void clear_has_y();
+  inline void set_has_z();
+  inline void clear_has_z();
+  inline void set_has_length();
+  inline void clear_has_length();
+  inline void set_has_width();
+  inline void clear_has_width();
+  inline void set_has_height();
+  inline void clear_has_height();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  float x_;
+  float y_;
+  float z_;
+  float length_;
+  float width_;
+  float height_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static Obstacle* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ObstacleList : public ::google::protobuf::Message {
+ public:
+  ObstacleList();
+  virtual ~ObstacleList();
+  
+  ObstacleList(const ObstacleList& from);
+  
+  inline ObstacleList& operator=(const ObstacleList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ObstacleList& default_instance();
+  
+  void Swap(ObstacleList* other);
+  
+  // implements Message ----------------------------------------------
+  
+  ObstacleList* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ObstacleList& from);
+  void MergeFrom(const ObstacleList& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required .px.HeaderInfo header = 1;
+  inline bool has_header() const;
+  inline void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  inline const ::px::HeaderInfo& header() const;
+  inline ::px::HeaderInfo* mutable_header();
+  inline ::px::HeaderInfo* release_header();
+  
+  // repeated .px.Obstacle obstacles = 2;
+  inline int obstacles_size() const;
+  inline void clear_obstacles();
+  static const int kObstaclesFieldNumber = 2;
+  inline const ::px::Obstacle& obstacles(int index) const;
+  inline ::px::Obstacle* mutable_obstacles(int index);
+  inline ::px::Obstacle* add_obstacles();
+  inline const ::google::protobuf::RepeatedPtrField< ::px::Obstacle >&
+      obstacles() const;
+  inline ::google::protobuf::RepeatedPtrField< ::px::Obstacle >*
+      mutable_obstacles();
+  
+  // @@protoc_insertion_point(class_scope:px.ObstacleList)
+ private:
+  inline void set_has_header();
+  inline void clear_has_header();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::px::HeaderInfo* header_;
+  ::google::protobuf::RepeatedPtrField< ::px::Obstacle > obstacles_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static ObstacleList* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ObstacleMap : public ::google::protobuf::Message {
+ public:
+  ObstacleMap();
+  virtual ~ObstacleMap();
+  
+  ObstacleMap(const ObstacleMap& from);
+  
+  inline ObstacleMap& operator=(const ObstacleMap& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ObstacleMap& default_instance();
+  
+  void Swap(ObstacleMap* other);
+  
+  // implements Message ----------------------------------------------
+  
+  ObstacleMap* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ObstacleMap& from);
+  void MergeFrom(const ObstacleMap& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required .px.HeaderInfo header = 1;
+  inline bool has_header() const;
+  inline void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  inline const ::px::HeaderInfo& header() const;
+  inline ::px::HeaderInfo* mutable_header();
+  inline ::px::HeaderInfo* release_header();
+  
+  // required int32 type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::google::protobuf::int32 type() const;
+  inline void set_type(::google::protobuf::int32 value);
+  
+  // optional float resolution = 3;
+  inline bool has_resolution() const;
+  inline void clear_resolution();
+  static const int kResolutionFieldNumber = 3;
+  inline float resolution() const;
+  inline void set_resolution(float value);
+  
+  // optional int32 rows = 4;
+  inline bool has_rows() const;
+  inline void clear_rows();
+  static const int kRowsFieldNumber = 4;
+  inline ::google::protobuf::int32 rows() const;
+  inline void set_rows(::google::protobuf::int32 value);
+  
+  // optional int32 cols = 5;
+  inline bool has_cols() const;
+  inline void clear_cols();
+  static const int kColsFieldNumber = 5;
+  inline ::google::protobuf::int32 cols() const;
+  inline void set_cols(::google::protobuf::int32 value);
+  
+  // optional int32 mapR0 = 6;
+  inline bool has_mapr0() const;
+  inline void clear_mapr0();
+  static const int kMapR0FieldNumber = 6;
+  inline ::google::protobuf::int32 mapr0() const;
+  inline void set_mapr0(::google::protobuf::int32 value);
+  
+  // optional int32 mapC0 = 7;
+  inline bool has_mapc0() const;
+  inline void clear_mapc0();
+  static const int kMapC0FieldNumber = 7;
+  inline ::google::protobuf::int32 mapc0() const;
+  inline void set_mapc0(::google::protobuf::int32 value);
+  
+  // optional int32 arrayR0 = 8;
+  inline bool has_arrayr0() const;
+  inline void clear_arrayr0();
+  static const int kArrayR0FieldNumber = 8;
+  inline ::google::protobuf::int32 arrayr0() const;
+  inline void set_arrayr0(::google::protobuf::int32 value);
+  
+  // optional int32 arrayC0 = 9;
+  inline bool has_arrayc0() const;
+  inline void clear_arrayc0();
+  static const int kArrayC0FieldNumber = 9;
+  inline ::google::protobuf::int32 arrayc0() const;
+  inline void set_arrayc0(::google::protobuf::int32 value);
+  
+  // optional bytes data = 10;
+  inline bool has_data() const;
+  inline void clear_data();
+  static const int kDataFieldNumber = 10;
+  inline const ::std::string& data() const;
+  inline void set_data(const ::std::string& value);
+  inline void set_data(const char* value);
+  inline void set_data(const void* value, size_t size);
+  inline ::std::string* mutable_data();
+  inline ::std::string* release_data();
+  
+  // @@protoc_insertion_point(class_scope:px.ObstacleMap)
+ private:
+  inline void set_has_header();
+  inline void clear_has_header();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_resolution();
+  inline void clear_has_resolution();
+  inline void set_has_rows();
+  inline void clear_has_rows();
+  inline void set_has_cols();
+  inline void clear_has_cols();
+  inline void set_has_mapr0();
+  inline void clear_has_mapr0();
+  inline void set_has_mapc0();
+  inline void clear_has_mapc0();
+  inline void set_has_arrayr0();
+  inline void clear_has_arrayr0();
+  inline void set_has_arrayc0();
+  inline void clear_has_arrayc0();
+  inline void set_has_data();
+  inline void clear_has_data();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::px::HeaderInfo* header_;
+  ::google::protobuf::int32 type_;
+  float resolution_;
+  ::google::protobuf::int32 rows_;
+  ::google::protobuf::int32 cols_;
+  ::google::protobuf::int32 mapr0_;
+  ::google::protobuf::int32 mapc0_;
+  ::google::protobuf::int32 arrayr0_;
+  ::google::protobuf::int32 arrayc0_;
+  ::std::string* data_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(10 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static ObstacleMap* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class Path : public ::google::protobuf::Message {
+ public:
+  Path();
+  virtual ~Path();
+  
+  Path(const Path& from);
+  
+  inline Path& operator=(const Path& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Path& default_instance();
+  
+  void Swap(Path* other);
+  
+  // implements Message ----------------------------------------------
+  
+  Path* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Path& from);
+  void MergeFrom(const Path& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required .px.HeaderInfo header = 1;
+  inline bool has_header() const;
+  inline void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  inline const ::px::HeaderInfo& header() const;
+  inline ::px::HeaderInfo* mutable_header();
+  inline ::px::HeaderInfo* release_header();
+  
+  // repeated .px.Waypoint waypoints = 2;
+  inline int waypoints_size() const;
+  inline void clear_waypoints();
+  static const int kWaypointsFieldNumber = 2;
+  inline const ::px::Waypoint& waypoints(int index) const;
+  inline ::px::Waypoint* mutable_waypoints(int index);
+  inline ::px::Waypoint* add_waypoints();
+  inline const ::google::protobuf::RepeatedPtrField< ::px::Waypoint >&
+      waypoints() const;
+  inline ::google::protobuf::RepeatedPtrField< ::px::Waypoint >*
+      mutable_waypoints();
+  
+  // @@protoc_insertion_point(class_scope:px.Path)
+ private:
+  inline void set_has_header();
+  inline void clear_has_header();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::px::HeaderInfo* header_;
+  ::google::protobuf::RepeatedPtrField< ::px::Waypoint > waypoints_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static Path* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class PointCloudXYZI_PointXYZI : public ::google::protobuf::Message {
+ public:
+  PointCloudXYZI_PointXYZI();
+  virtual ~PointCloudXYZI_PointXYZI();
+  
+  PointCloudXYZI_PointXYZI(const PointCloudXYZI_PointXYZI& from);
+  
+  inline PointCloudXYZI_PointXYZI& operator=(const PointCloudXYZI_PointXYZI& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PointCloudXYZI_PointXYZI& default_instance();
+  
+  void Swap(PointCloudXYZI_PointXYZI* other);
+  
+  // implements Message ----------------------------------------------
+  
+  PointCloudXYZI_PointXYZI* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PointCloudXYZI_PointXYZI& from);
+  void MergeFrom(const PointCloudXYZI_PointXYZI& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required float x = 1;
+  inline bool has_x() const;
+  inline void clear_x();
+  static const int kXFieldNumber = 1;
+  inline float x() const;
+  inline void set_x(float value);
+  
+  // required float y = 2;
+  inline bool has_y() const;
+  inline void clear_y();
+  static const int kYFieldNumber = 2;
+  inline float y() const;
+  inline void set_y(float value);
+  
+  // required float z = 3;
+  inline bool has_z() const;
+  inline void clear_z();
+  static const int kZFieldNumber = 3;
+  inline float z() const;
+  inline void set_z(float value);
+  
+  // required float intensity = 4;
+  inline bool has_intensity() const;
+  inline void clear_intensity();
+  static const int kIntensityFieldNumber = 4;
+  inline float intensity() const;
+  inline void set_intensity(float value);
+  
+  // @@protoc_insertion_point(class_scope:px.PointCloudXYZI.PointXYZI)
+ private:
+  inline void set_has_x();
+  inline void clear_has_x();
+  inline void set_has_y();
+  inline void clear_has_y();
+  inline void set_has_z();
+  inline void clear_has_z();
+  inline void set_has_intensity();
+  inline void clear_has_intensity();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  float x_;
+  float y_;
+  float z_;
+  float intensity_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static PointCloudXYZI_PointXYZI* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class PointCloudXYZI : public ::google::protobuf::Message {
+ public:
+  PointCloudXYZI();
+  virtual ~PointCloudXYZI();
+  
+  PointCloudXYZI(const PointCloudXYZI& from);
+  
+  inline PointCloudXYZI& operator=(const PointCloudXYZI& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PointCloudXYZI& default_instance();
+  
+  void Swap(PointCloudXYZI* other);
+  
+  // implements Message ----------------------------------------------
+  
+  PointCloudXYZI* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PointCloudXYZI& from);
+  void MergeFrom(const PointCloudXYZI& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  typedef PointCloudXYZI_PointXYZI PointXYZI;
+  
+  // accessors -------------------------------------------------------
+  
+  // required .px.HeaderInfo header = 1;
+  inline bool has_header() const;
+  inline void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  inline const ::px::HeaderInfo& header() const;
+  inline ::px::HeaderInfo* mutable_header();
+  inline ::px::HeaderInfo* release_header();
+  
+  // repeated .px.PointCloudXYZI.PointXYZI points = 2;
+  inline int points_size() const;
+  inline void clear_points();
+  static const int kPointsFieldNumber = 2;
+  inline const ::px::PointCloudXYZI_PointXYZI& points(int index) const;
+  inline ::px::PointCloudXYZI_PointXYZI* mutable_points(int index);
+  inline ::px::PointCloudXYZI_PointXYZI* add_points();
+  inline const ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZI_PointXYZI >&
+      points() const;
+  inline ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZI_PointXYZI >*
+      mutable_points();
+  
+  // @@protoc_insertion_point(class_scope:px.PointCloudXYZI)
+ private:
+  inline void set_has_header();
+  inline void clear_has_header();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::px::HeaderInfo* header_;
+  ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZI_PointXYZI > points_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static PointCloudXYZI* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class PointCloudXYZRGB_PointXYZRGB : public ::google::protobuf::Message {
+ public:
+  PointCloudXYZRGB_PointXYZRGB();
+  virtual ~PointCloudXYZRGB_PointXYZRGB();
+  
+  PointCloudXYZRGB_PointXYZRGB(const PointCloudXYZRGB_PointXYZRGB& from);
+  
+  inline PointCloudXYZRGB_PointXYZRGB& operator=(const PointCloudXYZRGB_PointXYZRGB& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PointCloudXYZRGB_PointXYZRGB& default_instance();
+  
+  void Swap(PointCloudXYZRGB_PointXYZRGB* other);
+  
+  // implements Message ----------------------------------------------
+  
+  PointCloudXYZRGB_PointXYZRGB* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PointCloudXYZRGB_PointXYZRGB& from);
+  void MergeFrom(const PointCloudXYZRGB_PointXYZRGB& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required float x = 1;
+  inline bool has_x() const;
+  inline void clear_x();
+  static const int kXFieldNumber = 1;
+  inline float x() const;
+  inline void set_x(float value);
+  
+  // required float y = 2;
+  inline bool has_y() const;
+  inline void clear_y();
+  static const int kYFieldNumber = 2;
+  inline float y() const;
+  inline void set_y(float value);
+  
+  // required float z = 3;
+  inline bool has_z() const;
+  inline void clear_z();
+  static const int kZFieldNumber = 3;
+  inline float z() const;
+  inline void set_z(float value);
+  
+  // required float rgb = 4;
+  inline bool has_rgb() const;
+  inline void clear_rgb();
+  static const int kRgbFieldNumber = 4;
+  inline float rgb() const;
+  inline void set_rgb(float value);
+  
+  // @@protoc_insertion_point(class_scope:px.PointCloudXYZRGB.PointXYZRGB)
+ private:
+  inline void set_has_x();
+  inline void clear_has_x();
+  inline void set_has_y();
+  inline void clear_has_y();
+  inline void set_has_z();
+  inline void clear_has_z();
+  inline void set_has_rgb();
+  inline void clear_has_rgb();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  float x_;
+  float y_;
+  float z_;
+  float rgb_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static PointCloudXYZRGB_PointXYZRGB* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class PointCloudXYZRGB : public ::google::protobuf::Message {
+ public:
+  PointCloudXYZRGB();
+  virtual ~PointCloudXYZRGB();
+  
+  PointCloudXYZRGB(const PointCloudXYZRGB& from);
+  
+  inline PointCloudXYZRGB& operator=(const PointCloudXYZRGB& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PointCloudXYZRGB& default_instance();
+  
+  void Swap(PointCloudXYZRGB* other);
+  
+  // implements Message ----------------------------------------------
+  
+  PointCloudXYZRGB* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PointCloudXYZRGB& from);
+  void MergeFrom(const PointCloudXYZRGB& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  typedef PointCloudXYZRGB_PointXYZRGB PointXYZRGB;
+  
+  // accessors -------------------------------------------------------
+  
+  // required .px.HeaderInfo header = 1;
+  inline bool has_header() const;
+  inline void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  inline const ::px::HeaderInfo& header() const;
+  inline ::px::HeaderInfo* mutable_header();
+  inline ::px::HeaderInfo* release_header();
+  
+  // repeated .px.PointCloudXYZRGB.PointXYZRGB points = 2;
+  inline int points_size() const;
+  inline void clear_points();
+  static const int kPointsFieldNumber = 2;
+  inline const ::px::PointCloudXYZRGB_PointXYZRGB& points(int index) const;
+  inline ::px::PointCloudXYZRGB_PointXYZRGB* mutable_points(int index);
+  inline ::px::PointCloudXYZRGB_PointXYZRGB* add_points();
+  inline const ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZRGB_PointXYZRGB >&
+      points() const;
+  inline ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZRGB_PointXYZRGB >*
+      mutable_points();
+  
+  // @@protoc_insertion_point(class_scope:px.PointCloudXYZRGB)
+ private:
+  inline void set_has_header();
+  inline void clear_has_header();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::px::HeaderInfo* header_;
+  ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZRGB_PointXYZRGB > points_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static PointCloudXYZRGB* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class RGBDImage : public ::google::protobuf::Message {
+ public:
+  RGBDImage();
+  virtual ~RGBDImage();
+  
+  RGBDImage(const RGBDImage& from);
+  
+  inline RGBDImage& operator=(const RGBDImage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RGBDImage& default_instance();
+  
+  void Swap(RGBDImage* other);
+  
+  // implements Message ----------------------------------------------
+  
+  RGBDImage* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RGBDImage& from);
+  void MergeFrom(const RGBDImage& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required .px.HeaderInfo header = 1;
+  inline bool has_header() const;
+  inline void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  inline const ::px::HeaderInfo& header() const;
+  inline ::px::HeaderInfo* mutable_header();
+  inline ::px::HeaderInfo* release_header();
+  
+  // required uint32 cols = 2;
+  inline bool has_cols() const;
+  inline void clear_cols();
+  static const int kColsFieldNumber = 2;
+  inline ::google::protobuf::uint32 cols() const;
+  inline void set_cols(::google::protobuf::uint32 value);
+  
+  // required uint32 rows = 3;
+  inline bool has_rows() const;
+  inline void clear_rows();
+  static const int kRowsFieldNumber = 3;
+  inline ::google::protobuf::uint32 rows() const;
+  inline void set_rows(::google::protobuf::uint32 value);
+  
+  // required uint32 step1 = 4;
+  inline bool has_step1() const;
+  inline void clear_step1();
+  static const int kStep1FieldNumber = 4;
+  inline ::google::protobuf::uint32 step1() const;
+  inline void set_step1(::google::protobuf::uint32 value);
+  
+  // required uint32 type1 = 5;
+  inline bool has_type1() const;
+  inline void clear_type1();
+  static const int kType1FieldNumber = 5;
+  inline ::google::protobuf::uint32 type1() const;
+  inline void set_type1(::google::protobuf::uint32 value);
+  
+  // required bytes imageData1 = 6;
+  inline bool has_imagedata1() const;
+  inline void clear_imagedata1();
+  static const int kImageData1FieldNumber = 6;
+  inline const ::std::string& imagedata1() const;
+  inline void set_imagedata1(const ::std::string& value);
+  inline void set_imagedata1(const char* value);
+  inline void set_imagedata1(const void* value, size_t size);
+  inline ::std::string* mutable_imagedata1();
+  inline ::std::string* release_imagedata1();
+  
+  // required uint32 step2 = 7;
+  inline bool has_step2() const;
+  inline void clear_step2();
+  static const int kStep2FieldNumber = 7;
+  inline ::google::protobuf::uint32 step2() const;
+  inline void set_step2(::google::protobuf::uint32 value);
+  
+  // required uint32 type2 = 8;
+  inline bool has_type2() const;
+  inline void clear_type2();
+  static const int kType2FieldNumber = 8;
+  inline ::google::protobuf::uint32 type2() const;
+  inline void set_type2(::google::protobuf::uint32 value);
+  
+  // required bytes imageData2 = 9;
+  inline bool has_imagedata2() const;
+  inline void clear_imagedata2();
+  static const int kImageData2FieldNumber = 9;
+  inline const ::std::string& imagedata2() const;
+  inline void set_imagedata2(const ::std::string& value);
+  inline void set_imagedata2(const char* value);
+  inline void set_imagedata2(const void* value, size_t size);
+  inline ::std::string* mutable_imagedata2();
+  inline ::std::string* release_imagedata2();
+  
+  // optional uint32 camera_config = 10;
+  inline bool has_camera_config() const;
+  inline void clear_camera_config();
+  static const int kCameraConfigFieldNumber = 10;
+  inline ::google::protobuf::uint32 camera_config() const;
+  inline void set_camera_config(::google::protobuf::uint32 value);
+  
+  // optional uint32 camera_type = 11;
+  inline bool has_camera_type() const;
+  inline void clear_camera_type();
+  static const int kCameraTypeFieldNumber = 11;
+  inline ::google::protobuf::uint32 camera_type() const;
+  inline void set_camera_type(::google::protobuf::uint32 value);
+  
+  // optional float roll = 12;
+  inline bool has_roll() const;
+  inline void clear_roll();
+  static const int kRollFieldNumber = 12;
+  inline float roll() const;
+  inline void set_roll(float value);
+  
+  // optional float pitch = 13;
+  inline bool has_pitch() const;
+  inline void clear_pitch();
+  static const int kPitchFieldNumber = 13;
+  inline float pitch() const;
+  inline void set_pitch(float value);
+  
+  // optional float yaw = 14;
+  inline bool has_yaw() const;
+  inline void clear_yaw();
+  static const int kYawFieldNumber = 14;
+  inline float yaw() const;
+  inline void set_yaw(float value);
+  
+  // optional float lon = 15;
+  inline bool has_lon() const;
+  inline void clear_lon();
+  static const int kLonFieldNumber = 15;
+  inline float lon() const;
+  inline void set_lon(float value);
+  
+  // optional float lat = 16;
+  inline bool has_lat() const;
+  inline void clear_lat();
+  static const int kLatFieldNumber = 16;
+  inline float lat() const;
+  inline void set_lat(float value);
+  
+  // optional float alt = 17;
+  inline bool has_alt() const;
+  inline void clear_alt();
+  static const int kAltFieldNumber = 17;
+  inline float alt() const;
+  inline void set_alt(float value);
+  
+  // optional float ground_x = 18;
+  inline bool has_ground_x() const;
+  inline void clear_ground_x();
+  static const int kGroundXFieldNumber = 18;
+  inline float ground_x() const;
+  inline void set_ground_x(float value);
+  
+  // optional float ground_y = 19;
+  inline bool has_ground_y() const;
+  inline void clear_ground_y();
+  static const int kGroundYFieldNumber = 19;
+  inline float ground_y() const;
+  inline void set_ground_y(float value);
+  
+  // optional float ground_z = 20;
+  inline bool has_ground_z() const;
+  inline void clear_ground_z();
+  static const int kGroundZFieldNumber = 20;
+  inline float ground_z() const;
+  inline void set_ground_z(float value);
+  
+  // repeated float camera_matrix = 21;
+  inline int camera_matrix_size() const;
+  inline void clear_camera_matrix();
+  static const int kCameraMatrixFieldNumber = 21;
+  inline float camera_matrix(int index) const;
+  inline void set_camera_matrix(int index, float value);
+  inline void add_camera_matrix(float value);
+  inline const ::google::protobuf::RepeatedField< float >&
+      camera_matrix() const;
+  inline ::google::protobuf::RepeatedField< float >*
+      mutable_camera_matrix();
+  
+  // @@protoc_insertion_point(class_scope:px.RGBDImage)
+ private:
+  inline void set_has_header();
+  inline void clear_has_header();
+  inline void set_has_cols();
+  inline void clear_has_cols();
+  inline void set_has_rows();
+  inline void clear_has_rows();
+  inline void set_has_step1();
+  inline void clear_has_step1();
+  inline void set_has_type1();
+  inline void clear_has_type1();
+  inline void set_has_imagedata1();
+  inline void clear_has_imagedata1();
+  inline void set_has_step2();
+  inline void clear_has_step2();
+  inline void set_has_type2();
+  inline void clear_has_type2();
+  inline void set_has_imagedata2();
+  inline void clear_has_imagedata2();
+  inline void set_has_camera_config();
+  inline void clear_has_camera_config();
+  inline void set_has_camera_type();
+  inline void clear_has_camera_type();
+  inline void set_has_roll();
+  inline void clear_has_roll();
+  inline void set_has_pitch();
+  inline void clear_has_pitch();
+  inline void set_has_yaw();
+  inline void clear_has_yaw();
+  inline void set_has_lon();
+  inline void clear_has_lon();
+  inline void set_has_lat();
+  inline void clear_has_lat();
+  inline void set_has_alt();
+  inline void clear_has_alt();
+  inline void set_has_ground_x();
+  inline void clear_has_ground_x();
+  inline void set_has_ground_y();
+  inline void clear_has_ground_y();
+  inline void set_has_ground_z();
+  inline void clear_has_ground_z();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::px::HeaderInfo* header_;
+  ::google::protobuf::uint32 cols_;
+  ::google::protobuf::uint32 rows_;
+  ::google::protobuf::uint32 step1_;
+  ::google::protobuf::uint32 type1_;
+  ::std::string* imagedata1_;
+  ::google::protobuf::uint32 step2_;
+  ::google::protobuf::uint32 type2_;
+  ::std::string* imagedata2_;
+  ::google::protobuf::uint32 camera_config_;
+  ::google::protobuf::uint32 camera_type_;
+  float roll_;
+  float pitch_;
+  float yaw_;
+  float lon_;
+  float lat_;
+  float alt_;
+  float ground_x_;
+  float ground_y_;
+  ::google::protobuf::RepeatedField< float > camera_matrix_;
+  float ground_z_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(21 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static RGBDImage* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class Waypoint : public ::google::protobuf::Message {
+ public:
+  Waypoint();
+  virtual ~Waypoint();
+  
+  Waypoint(const Waypoint& from);
+  
+  inline Waypoint& operator=(const Waypoint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Waypoint& default_instance();
+  
+  void Swap(Waypoint* other);
+  
+  // implements Message ----------------------------------------------
+  
+  Waypoint* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Waypoint& from);
+  void MergeFrom(const Waypoint& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required double x = 1;
+  inline bool has_x() const;
+  inline void clear_x();
+  static const int kXFieldNumber = 1;
+  inline double x() const;
+  inline void set_x(double value);
+  
+  // required double y = 2;
+  inline bool has_y() const;
+  inline void clear_y();
+  static const int kYFieldNumber = 2;
+  inline double y() const;
+  inline void set_y(double value);
+  
+  // optional double z = 3;
+  inline bool has_z() const;
+  inline void clear_z();
+  static const int kZFieldNumber = 3;
+  inline double z() const;
+  inline void set_z(double value);
+  
+  // optional double roll = 4;
+  inline bool has_roll() const;
+  inline void clear_roll();
+  static const int kRollFieldNumber = 4;
+  inline double roll() const;
+  inline void set_roll(double value);
+  
+  // optional double pitch = 5;
+  inline bool has_pitch() const;
+  inline void clear_pitch();
+  static const int kPitchFieldNumber = 5;
+  inline double pitch() const;
+  inline void set_pitch(double value);
+  
+  // optional double yaw = 6;
+  inline bool has_yaw() const;
+  inline void clear_yaw();
+  static const int kYawFieldNumber = 6;
+  inline double yaw() const;
+  inline void set_yaw(double value);
+  
+  // @@protoc_insertion_point(class_scope:px.Waypoint)
+ private:
+  inline void set_has_x();
+  inline void clear_has_x();
+  inline void set_has_y();
+  inline void clear_has_y();
+  inline void set_has_z();
+  inline void clear_has_z();
+  inline void set_has_roll();
+  inline void clear_has_roll();
+  inline void set_has_pitch();
+  inline void clear_has_pitch();
+  inline void set_has_yaw();
+  inline void clear_has_yaw();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  double x_;
+  double y_;
+  double z_;
+  double roll_;
+  double pitch_;
+  double yaw_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pixhawk_2eproto();
+  friend void protobuf_AssignDesc_pixhawk_2eproto();
+  friend void protobuf_ShutdownFile_pixhawk_2eproto();
+  
+  void InitAsDefaultInstance();
+  static Waypoint* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// HeaderInfo
+
+// required int32 source_sysid = 1;
+inline bool HeaderInfo::has_source_sysid() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void HeaderInfo::set_has_source_sysid() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void HeaderInfo::clear_has_source_sysid() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void HeaderInfo::clear_source_sysid() {
+  source_sysid_ = 0;
+  clear_has_source_sysid();
+}
+inline ::google::protobuf::int32 HeaderInfo::source_sysid() const {
+  return source_sysid_;
+}
+inline void HeaderInfo::set_source_sysid(::google::protobuf::int32 value) {
+  set_has_source_sysid();
+  source_sysid_ = value;
+}
+
+// required int32 source_compid = 2;
+inline bool HeaderInfo::has_source_compid() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void HeaderInfo::set_has_source_compid() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void HeaderInfo::clear_has_source_compid() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void HeaderInfo::clear_source_compid() {
+  source_compid_ = 0;
+  clear_has_source_compid();
+}
+inline ::google::protobuf::int32 HeaderInfo::source_compid() const {
+  return source_compid_;
+}
+inline void HeaderInfo::set_source_compid(::google::protobuf::int32 value) {
+  set_has_source_compid();
+  source_compid_ = value;
+}
+
+// required double timestamp = 3;
+inline bool HeaderInfo::has_timestamp() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void HeaderInfo::set_has_timestamp() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void HeaderInfo::clear_has_timestamp() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void HeaderInfo::clear_timestamp() {
+  timestamp_ = 0;
+  clear_has_timestamp();
+}
+inline double HeaderInfo::timestamp() const {
+  return timestamp_;
+}
+inline void HeaderInfo::set_timestamp(double value) {
+  set_has_timestamp();
+  timestamp_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// GLOverlay
+
+// required .px.HeaderInfo header = 1;
+inline bool GLOverlay::has_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GLOverlay::set_has_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GLOverlay::clear_has_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GLOverlay::clear_header() {
+  if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+  clear_has_header();
+}
+inline const ::px::HeaderInfo& GLOverlay::header() const {
+  return header_ != NULL ? *header_ : *default_instance_->header_;
+}
+inline ::px::HeaderInfo* GLOverlay::mutable_header() {
+  set_has_header();
+  if (header_ == NULL) header_ = new ::px::HeaderInfo;
+  return header_;
+}
+inline ::px::HeaderInfo* GLOverlay::release_header() {
+  clear_has_header();
+  ::px::HeaderInfo* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+
+// optional string name = 2;
+inline bool GLOverlay::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GLOverlay::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GLOverlay::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GLOverlay::clear_name() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& GLOverlay::name() const {
+  return *name_;
+}
+inline void GLOverlay::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void GLOverlay::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void GLOverlay::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* GLOverlay::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  return name_;
+}
+inline ::std::string* GLOverlay::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// optional .px.GLOverlay.CoordinateFrameType coordinateFrameType = 3;
+inline bool GLOverlay::has_coordinateframetype() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GLOverlay::set_has_coordinateframetype() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GLOverlay::clear_has_coordinateframetype() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GLOverlay::clear_coordinateframetype() {
+  coordinateframetype_ = 0;
+  clear_has_coordinateframetype();
+}
+inline ::px::GLOverlay_CoordinateFrameType GLOverlay::coordinateframetype() const {
+  return static_cast< ::px::GLOverlay_CoordinateFrameType >(coordinateframetype_);
+}
+inline void GLOverlay::set_coordinateframetype(::px::GLOverlay_CoordinateFrameType value) {
+  GOOGLE_DCHECK(::px::GLOverlay_CoordinateFrameType_IsValid(value));
+  set_has_coordinateframetype();
+  coordinateframetype_ = value;
+}
+
+// optional double origin_x = 4;
+inline bool GLOverlay::has_origin_x() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GLOverlay::set_has_origin_x() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GLOverlay::clear_has_origin_x() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GLOverlay::clear_origin_x() {
+  origin_x_ = 0;
+  clear_has_origin_x();
+}
+inline double GLOverlay::origin_x() const {
+  return origin_x_;
+}
+inline void GLOverlay::set_origin_x(double value) {
+  set_has_origin_x();
+  origin_x_ = value;
+}
+
+// optional double origin_y = 5;
+inline bool GLOverlay::has_origin_y() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GLOverlay::set_has_origin_y() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GLOverlay::clear_has_origin_y() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GLOverlay::clear_origin_y() {
+  origin_y_ = 0;
+  clear_has_origin_y();
+}
+inline double GLOverlay::origin_y() const {
+  return origin_y_;
+}
+inline void GLOverlay::set_origin_y(double value) {
+  set_has_origin_y();
+  origin_y_ = value;
+}
+
+// optional double origin_z = 6;
+inline bool GLOverlay::has_origin_z() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void GLOverlay::set_has_origin_z() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void GLOverlay::clear_has_origin_z() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void GLOverlay::clear_origin_z() {
+  origin_z_ = 0;
+  clear_has_origin_z();
+}
+inline double GLOverlay::origin_z() const {
+  return origin_z_;
+}
+inline void GLOverlay::set_origin_z(double value) {
+  set_has_origin_z();
+  origin_z_ = value;
+}
+
+// optional bytes data = 7;
+inline bool GLOverlay::has_data() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void GLOverlay::set_has_data() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void GLOverlay::clear_has_data() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void GLOverlay::clear_data() {
+  if (data_ != &::google::protobuf::internal::kEmptyString) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& GLOverlay::data() const {
+  return *data_;
+}
+inline void GLOverlay::set_data(const ::std::string& value) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  data_->assign(value);
+}
+inline void GLOverlay::set_data(const char* value) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  data_->assign(value);
+}
+inline void GLOverlay::set_data(const void* value, size_t size) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  data_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* GLOverlay::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  return data_;
+}
+inline ::std::string* GLOverlay::release_data() {
+  clear_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = data_;
+    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// -------------------------------------------------------------------
+
+// Obstacle
+
+// optional float x = 1;
+inline bool Obstacle::has_x() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Obstacle::set_has_x() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Obstacle::clear_has_x() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Obstacle::clear_x() {
+  x_ = 0;
+  clear_has_x();
+}
+inline float Obstacle::x() const {
+  return x_;
+}
+inline void Obstacle::set_x(float value) {
+  set_has_x();
+  x_ = value;
+}
+
+// optional float y = 2;
+inline bool Obstacle::has_y() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Obstacle::set_has_y() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Obstacle::clear_has_y() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Obstacle::clear_y() {
+  y_ = 0;
+  clear_has_y();
+}
+inline float Obstacle::y() const {
+  return y_;
+}
+inline void Obstacle::set_y(float value) {
+  set_has_y();
+  y_ = value;
+}
+
+// optional float z = 3;
+inline bool Obstacle::has_z() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Obstacle::set_has_z() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Obstacle::clear_has_z() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Obstacle::clear_z() {
+  z_ = 0;
+  clear_has_z();
+}
+inline float Obstacle::z() const {
+  return z_;
+}
+inline void Obstacle::set_z(float value) {
+  set_has_z();
+  z_ = value;
+}
+
+// optional float length = 4;
+inline bool Obstacle::has_length() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Obstacle::set_has_length() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Obstacle::clear_has_length() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Obstacle::clear_length() {
+  length_ = 0;
+  clear_has_length();
+}
+inline float Obstacle::length() const {
+  return length_;
+}
+inline void Obstacle::set_length(float value) {
+  set_has_length();
+  length_ = value;
+}
+
+// optional float width = 5;
+inline bool Obstacle::has_width() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Obstacle::set_has_width() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Obstacle::clear_has_width() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Obstacle::clear_width() {
+  width_ = 0;
+  clear_has_width();
+}
+inline float Obstacle::width() const {
+  return width_;
+}
+inline void Obstacle::set_width(float value) {
+  set_has_width();
+  width_ = value;
+}
+
+// optional float height = 6;
+inline bool Obstacle::has_height() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Obstacle::set_has_height() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Obstacle::clear_has_height() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Obstacle::clear_height() {
+  height_ = 0;
+  clear_has_height();
+}
+inline float Obstacle::height() const {
+  return height_;
+}
+inline void Obstacle::set_height(float value) {
+  set_has_height();
+  height_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// ObstacleList
+
+// required .px.HeaderInfo header = 1;
+inline bool ObstacleList::has_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ObstacleList::set_has_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ObstacleList::clear_has_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ObstacleList::clear_header() {
+  if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+  clear_has_header();
+}
+inline const ::px::HeaderInfo& ObstacleList::header() const {
+  return header_ != NULL ? *header_ : *default_instance_->header_;
+}
+inline ::px::HeaderInfo* ObstacleList::mutable_header() {
+  set_has_header();
+  if (header_ == NULL) header_ = new ::px::HeaderInfo;
+  return header_;
+}
+inline ::px::HeaderInfo* ObstacleList::release_header() {
+  clear_has_header();
+  ::px::HeaderInfo* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+
+// repeated .px.Obstacle obstacles = 2;
+inline int ObstacleList::obstacles_size() const {
+  return obstacles_.size();
+}
+inline void ObstacleList::clear_obstacles() {
+  obstacles_.Clear();
+}
+inline const ::px::Obstacle& ObstacleList::obstacles(int index) const {
+  return obstacles_.Get(index);
+}
+inline ::px::Obstacle* ObstacleList::mutable_obstacles(int index) {
+  return obstacles_.Mutable(index);
+}
+inline ::px::Obstacle* ObstacleList::add_obstacles() {
+  return obstacles_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::px::Obstacle >&
+ObstacleList::obstacles() const {
+  return obstacles_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::px::Obstacle >*
+ObstacleList::mutable_obstacles() {
+  return &obstacles_;
+}
+
+// -------------------------------------------------------------------
+
+// ObstacleMap
+
+// required .px.HeaderInfo header = 1;
+inline bool ObstacleMap::has_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ObstacleMap::set_has_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ObstacleMap::clear_has_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ObstacleMap::clear_header() {
+  if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+  clear_has_header();
+}
+inline const ::px::HeaderInfo& ObstacleMap::header() const {
+  return header_ != NULL ? *header_ : *default_instance_->header_;
+}
+inline ::px::HeaderInfo* ObstacleMap::mutable_header() {
+  set_has_header();
+  if (header_ == NULL) header_ = new ::px::HeaderInfo;
+  return header_;
+}
+inline ::px::HeaderInfo* ObstacleMap::release_header() {
+  clear_has_header();
+  ::px::HeaderInfo* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+
+// required int32 type = 2;
+inline bool ObstacleMap::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ObstacleMap::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ObstacleMap::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ObstacleMap::clear_type() {
+  type_ = 0;
+  clear_has_type();
+}
+inline ::google::protobuf::int32 ObstacleMap::type() const {
+  return type_;
+}
+inline void ObstacleMap::set_type(::google::protobuf::int32 value) {
+  set_has_type();
+  type_ = value;
+}
+
+// optional float resolution = 3;
+inline bool ObstacleMap::has_resolution() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ObstacleMap::set_has_resolution() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ObstacleMap::clear_has_resolution() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ObstacleMap::clear_resolution() {
+  resolution_ = 0;
+  clear_has_resolution();
+}
+inline float ObstacleMap::resolution() const {
+  return resolution_;
+}
+inline void ObstacleMap::set_resolution(float value) {
+  set_has_resolution();
+  resolution_ = value;
+}
+
+// optional int32 rows = 4;
+inline bool ObstacleMap::has_rows() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ObstacleMap::set_has_rows() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ObstacleMap::clear_has_rows() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ObstacleMap::clear_rows() {
+  rows_ = 0;
+  clear_has_rows();
+}
+inline ::google::protobuf::int32 ObstacleMap::rows() const {
+  return rows_;
+}
+inline void ObstacleMap::set_rows(::google::protobuf::int32 value) {
+  set_has_rows();
+  rows_ = value;
+}
+
+// optional int32 cols = 5;
+inline bool ObstacleMap::has_cols() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ObstacleMap::set_has_cols() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ObstacleMap::clear_has_cols() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ObstacleMap::clear_cols() {
+  cols_ = 0;
+  clear_has_cols();
+}
+inline ::google::protobuf::int32 ObstacleMap::cols() const {
+  return cols_;
+}
+inline void ObstacleMap::set_cols(::google::protobuf::int32 value) {
+  set_has_cols();
+  cols_ = value;
+}
+
+// optional int32 mapR0 = 6;
+inline bool ObstacleMap::has_mapr0() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ObstacleMap::set_has_mapr0() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ObstacleMap::clear_has_mapr0() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ObstacleMap::clear_mapr0() {
+  mapr0_ = 0;
+  clear_has_mapr0();
+}
+inline ::google::protobuf::int32 ObstacleMap::mapr0() const {
+  return mapr0_;
+}
+inline void ObstacleMap::set_mapr0(::google::protobuf::int32 value) {
+  set_has_mapr0();
+  mapr0_ = value;
+}
+
+// optional int32 mapC0 = 7;
+inline bool ObstacleMap::has_mapc0() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ObstacleMap::set_has_mapc0() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ObstacleMap::clear_has_mapc0() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ObstacleMap::clear_mapc0() {
+  mapc0_ = 0;
+  clear_has_mapc0();
+}
+inline ::google::protobuf::int32 ObstacleMap::mapc0() const {
+  return mapc0_;
+}
+inline void ObstacleMap::set_mapc0(::google::protobuf::int32 value) {
+  set_has_mapc0();
+  mapc0_ = value;
+}
+
+// optional int32 arrayR0 = 8;
+inline bool ObstacleMap::has_arrayr0() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ObstacleMap::set_has_arrayr0() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ObstacleMap::clear_has_arrayr0() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ObstacleMap::clear_arrayr0() {
+  arrayr0_ = 0;
+  clear_has_arrayr0();
+}
+inline ::google::protobuf::int32 ObstacleMap::arrayr0() const {
+  return arrayr0_;
+}
+inline void ObstacleMap::set_arrayr0(::google::protobuf::int32 value) {
+  set_has_arrayr0();
+  arrayr0_ = value;
+}
+
+// optional int32 arrayC0 = 9;
+inline bool ObstacleMap::has_arrayc0() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ObstacleMap::set_has_arrayc0() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ObstacleMap::clear_has_arrayc0() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ObstacleMap::clear_arrayc0() {
+  arrayc0_ = 0;
+  clear_has_arrayc0();
+}
+inline ::google::protobuf::int32 ObstacleMap::arrayc0() const {
+  return arrayc0_;
+}
+inline void ObstacleMap::set_arrayc0(::google::protobuf::int32 value) {
+  set_has_arrayc0();
+  arrayc0_ = value;
+}
+
+// optional bytes data = 10;
+inline bool ObstacleMap::has_data() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ObstacleMap::set_has_data() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ObstacleMap::clear_has_data() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ObstacleMap::clear_data() {
+  if (data_ != &::google::protobuf::internal::kEmptyString) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& ObstacleMap::data() const {
+  return *data_;
+}
+inline void ObstacleMap::set_data(const ::std::string& value) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  data_->assign(value);
+}
+inline void ObstacleMap::set_data(const char* value) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  data_->assign(value);
+}
+inline void ObstacleMap::set_data(const void* value, size_t size) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  data_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ObstacleMap::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    data_ = new ::std::string;
+  }
+  return data_;
+}
+inline ::std::string* ObstacleMap::release_data() {
+  clear_has_data();
+  if (data_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = data_;
+    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// -------------------------------------------------------------------
+
+// Path
+
+// required .px.HeaderInfo header = 1;
+inline bool Path::has_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Path::set_has_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Path::clear_has_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Path::clear_header() {
+  if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+  clear_has_header();
+}
+inline const ::px::HeaderInfo& Path::header() const {
+  return header_ != NULL ? *header_ : *default_instance_->header_;
+}
+inline ::px::HeaderInfo* Path::mutable_header() {
+  set_has_header();
+  if (header_ == NULL) header_ = new ::px::HeaderInfo;
+  return header_;
+}
+inline ::px::HeaderInfo* Path::release_header() {
+  clear_has_header();
+  ::px::HeaderInfo* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+
+// repeated .px.Waypoint waypoints = 2;
+inline int Path::waypoints_size() const {
+  return waypoints_.size();
+}
+inline void Path::clear_waypoints() {
+  waypoints_.Clear();
+}
+inline const ::px::Waypoint& Path::waypoints(int index) const {
+  return waypoints_.Get(index);
+}
+inline ::px::Waypoint* Path::mutable_waypoints(int index) {
+  return waypoints_.Mutable(index);
+}
+inline ::px::Waypoint* Path::add_waypoints() {
+  return waypoints_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::px::Waypoint >&
+Path::waypoints() const {
+  return waypoints_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::px::Waypoint >*
+Path::mutable_waypoints() {
+  return &waypoints_;
+}
+
+// -------------------------------------------------------------------
+
+// PointCloudXYZI_PointXYZI
+
+// required float x = 1;
+inline bool PointCloudXYZI_PointXYZI::has_x() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PointCloudXYZI_PointXYZI::set_has_x() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_has_x() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_x() {
+  x_ = 0;
+  clear_has_x();
+}
+inline float PointCloudXYZI_PointXYZI::x() const {
+  return x_;
+}
+inline void PointCloudXYZI_PointXYZI::set_x(float value) {
+  set_has_x();
+  x_ = value;
+}
+
+// required float y = 2;
+inline bool PointCloudXYZI_PointXYZI::has_y() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PointCloudXYZI_PointXYZI::set_has_y() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_has_y() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_y() {
+  y_ = 0;
+  clear_has_y();
+}
+inline float PointCloudXYZI_PointXYZI::y() const {
+  return y_;
+}
+inline void PointCloudXYZI_PointXYZI::set_y(float value) {
+  set_has_y();
+  y_ = value;
+}
+
+// required float z = 3;
+inline bool PointCloudXYZI_PointXYZI::has_z() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void PointCloudXYZI_PointXYZI::set_has_z() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_has_z() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_z() {
+  z_ = 0;
+  clear_has_z();
+}
+inline float PointCloudXYZI_PointXYZI::z() const {
+  return z_;
+}
+inline void PointCloudXYZI_PointXYZI::set_z(float value) {
+  set_has_z();
+  z_ = value;
+}
+
+// required float intensity = 4;
+inline bool PointCloudXYZI_PointXYZI::has_intensity() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void PointCloudXYZI_PointXYZI::set_has_intensity() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_has_intensity() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void PointCloudXYZI_PointXYZI::clear_intensity() {
+  intensity_ = 0;
+  clear_has_intensity();
+}
+inline float PointCloudXYZI_PointXYZI::intensity() const {
+  return intensity_;
+}
+inline void PointCloudXYZI_PointXYZI::set_intensity(float value) {
+  set_has_intensity();
+  intensity_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// PointCloudXYZI
+
+// required .px.HeaderInfo header = 1;
+inline bool PointCloudXYZI::has_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PointCloudXYZI::set_has_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PointCloudXYZI::clear_has_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PointCloudXYZI::clear_header() {
+  if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+  clear_has_header();
+}
+inline const ::px::HeaderInfo& PointCloudXYZI::header() const {
+  return header_ != NULL ? *header_ : *default_instance_->header_;
+}
+inline ::px::HeaderInfo* PointCloudXYZI::mutable_header() {
+  set_has_header();
+  if (header_ == NULL) header_ = new ::px::HeaderInfo;
+  return header_;
+}
+inline ::px::HeaderInfo* PointCloudXYZI::release_header() {
+  clear_has_header();
+  ::px::HeaderInfo* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+
+// repeated .px.PointCloudXYZI.PointXYZI points = 2;
+inline int PointCloudXYZI::points_size() const {
+  return points_.size();
+}
+inline void PointCloudXYZI::clear_points() {
+  points_.Clear();
+}
+inline const ::px::PointCloudXYZI_PointXYZI& PointCloudXYZI::points(int index) const {
+  return points_.Get(index);
+}
+inline ::px::PointCloudXYZI_PointXYZI* PointCloudXYZI::mutable_points(int index) {
+  return points_.Mutable(index);
+}
+inline ::px::PointCloudXYZI_PointXYZI* PointCloudXYZI::add_points() {
+  return points_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZI_PointXYZI >&
+PointCloudXYZI::points() const {
+  return points_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZI_PointXYZI >*
+PointCloudXYZI::mutable_points() {
+  return &points_;
+}
+
+// -------------------------------------------------------------------
+
+// PointCloudXYZRGB_PointXYZRGB
+
+// required float x = 1;
+inline bool PointCloudXYZRGB_PointXYZRGB::has_x() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_has_x() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_has_x() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_x() {
+  x_ = 0;
+  clear_has_x();
+}
+inline float PointCloudXYZRGB_PointXYZRGB::x() const {
+  return x_;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_x(float value) {
+  set_has_x();
+  x_ = value;
+}
+
+// required float y = 2;
+inline bool PointCloudXYZRGB_PointXYZRGB::has_y() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_has_y() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_has_y() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_y() {
+  y_ = 0;
+  clear_has_y();
+}
+inline float PointCloudXYZRGB_PointXYZRGB::y() const {
+  return y_;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_y(float value) {
+  set_has_y();
+  y_ = value;
+}
+
+// required float z = 3;
+inline bool PointCloudXYZRGB_PointXYZRGB::has_z() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_has_z() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_has_z() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_z() {
+  z_ = 0;
+  clear_has_z();
+}
+inline float PointCloudXYZRGB_PointXYZRGB::z() const {
+  return z_;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_z(float value) {
+  set_has_z();
+  z_ = value;
+}
+
+// required float rgb = 4;
+inline bool PointCloudXYZRGB_PointXYZRGB::has_rgb() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_has_rgb() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_has_rgb() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::clear_rgb() {
+  rgb_ = 0;
+  clear_has_rgb();
+}
+inline float PointCloudXYZRGB_PointXYZRGB::rgb() const {
+  return rgb_;
+}
+inline void PointCloudXYZRGB_PointXYZRGB::set_rgb(float value) {
+  set_has_rgb();
+  rgb_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// PointCloudXYZRGB
+
+// required .px.HeaderInfo header = 1;
+inline bool PointCloudXYZRGB::has_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PointCloudXYZRGB::set_has_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PointCloudXYZRGB::clear_has_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PointCloudXYZRGB::clear_header() {
+  if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+  clear_has_header();
+}
+inline const ::px::HeaderInfo& PointCloudXYZRGB::header() const {
+  return header_ != NULL ? *header_ : *default_instance_->header_;
+}
+inline ::px::HeaderInfo* PointCloudXYZRGB::mutable_header() {
+  set_has_header();
+  if (header_ == NULL) header_ = new ::px::HeaderInfo;
+  return header_;
+}
+inline ::px::HeaderInfo* PointCloudXYZRGB::release_header() {
+  clear_has_header();
+  ::px::HeaderInfo* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+
+// repeated .px.PointCloudXYZRGB.PointXYZRGB points = 2;
+inline int PointCloudXYZRGB::points_size() const {
+  return points_.size();
+}
+inline void PointCloudXYZRGB::clear_points() {
+  points_.Clear();
+}
+inline const ::px::PointCloudXYZRGB_PointXYZRGB& PointCloudXYZRGB::points(int index) const {
+  return points_.Get(index);
+}
+inline ::px::PointCloudXYZRGB_PointXYZRGB* PointCloudXYZRGB::mutable_points(int index) {
+  return points_.Mutable(index);
+}
+inline ::px::PointCloudXYZRGB_PointXYZRGB* PointCloudXYZRGB::add_points() {
+  return points_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZRGB_PointXYZRGB >&
+PointCloudXYZRGB::points() const {
+  return points_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::px::PointCloudXYZRGB_PointXYZRGB >*
+PointCloudXYZRGB::mutable_points() {
+  return &points_;
+}
+
+// -------------------------------------------------------------------
+
+// RGBDImage
+
+// required .px.HeaderInfo header = 1;
+inline bool RGBDImage::has_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RGBDImage::set_has_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RGBDImage::clear_has_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RGBDImage::clear_header() {
+  if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+  clear_has_header();
+}
+inline const ::px::HeaderInfo& RGBDImage::header() const {
+  return header_ != NULL ? *header_ : *default_instance_->header_;
+}
+inline ::px::HeaderInfo* RGBDImage::mutable_header() {
+  set_has_header();
+  if (header_ == NULL) header_ = new ::px::HeaderInfo;
+  return header_;
+}
+inline ::px::HeaderInfo* RGBDImage::release_header() {
+  clear_has_header();
+  ::px::HeaderInfo* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+
+// required uint32 cols = 2;
+inline bool RGBDImage::has_cols() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RGBDImage::set_has_cols() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RGBDImage::clear_has_cols() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RGBDImage::clear_cols() {
+  cols_ = 0u;
+  clear_has_cols();
+}
+inline ::google::protobuf::uint32 RGBDImage::cols() const {
+  return cols_;
+}
+inline void RGBDImage::set_cols(::google::protobuf::uint32 value) {
+  set_has_cols();
+  cols_ = value;
+}
+
+// required uint32 rows = 3;
+inline bool RGBDImage::has_rows() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RGBDImage::set_has_rows() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RGBDImage::clear_has_rows() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RGBDImage::clear_rows() {
+  rows_ = 0u;
+  clear_has_rows();
+}
+inline ::google::protobuf::uint32 RGBDImage::rows() const {
+  return rows_;
+}
+inline void RGBDImage::set_rows(::google::protobuf::uint32 value) {
+  set_has_rows();
+  rows_ = value;
+}
+
+// required uint32 step1 = 4;
+inline bool RGBDImage::has_step1() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void RGBDImage::set_has_step1() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void RGBDImage::clear_has_step1() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void RGBDImage::clear_step1() {
+  step1_ = 0u;
+  clear_has_step1();
+}
+inline ::google::protobuf::uint32 RGBDImage::step1() const {
+  return step1_;
+}
+inline void RGBDImage::set_step1(::google::protobuf::uint32 value) {
+  set_has_step1();
+  step1_ = value;
+}
+
+// required uint32 type1 = 5;
+inline bool RGBDImage::has_type1() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void RGBDImage::set_has_type1() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void RGBDImage::clear_has_type1() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void RGBDImage::clear_type1() {
+  type1_ = 0u;
+  clear_has_type1();
+}
+inline ::google::protobuf::uint32 RGBDImage::type1() const {
+  return type1_;
+}
+inline void RGBDImage::set_type1(::google::protobuf::uint32 value) {
+  set_has_type1();
+  type1_ = value;
+}
+
+// required bytes imageData1 = 6;
+inline bool RGBDImage::has_imagedata1() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void RGBDImage::set_has_imagedata1() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void RGBDImage::clear_has_imagedata1() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void RGBDImage::clear_imagedata1() {
+  if (imagedata1_ != &::google::protobuf::internal::kEmptyString) {
+    imagedata1_->clear();
+  }
+  clear_has_imagedata1();
+}
+inline const ::std::string& RGBDImage::imagedata1() const {
+  return *imagedata1_;
+}
+inline void RGBDImage::set_imagedata1(const ::std::string& value) {
+  set_has_imagedata1();
+  if (imagedata1_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata1_ = new ::std::string;
+  }
+  imagedata1_->assign(value);
+}
+inline void RGBDImage::set_imagedata1(const char* value) {
+  set_has_imagedata1();
+  if (imagedata1_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata1_ = new ::std::string;
+  }
+  imagedata1_->assign(value);
+}
+inline void RGBDImage::set_imagedata1(const void* value, size_t size) {
+  set_has_imagedata1();
+  if (imagedata1_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata1_ = new ::std::string;
+  }
+  imagedata1_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RGBDImage::mutable_imagedata1() {
+  set_has_imagedata1();
+  if (imagedata1_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata1_ = new ::std::string;
+  }
+  return imagedata1_;
+}
+inline ::std::string* RGBDImage::release_imagedata1() {
+  clear_has_imagedata1();
+  if (imagedata1_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = imagedata1_;
+    imagedata1_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// required uint32 step2 = 7;
+inline bool RGBDImage::has_step2() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void RGBDImage::set_has_step2() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void RGBDImage::clear_has_step2() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void RGBDImage::clear_step2() {
+  step2_ = 0u;
+  clear_has_step2();
+}
+inline ::google::protobuf::uint32 RGBDImage::step2() const {
+  return step2_;
+}
+inline void RGBDImage::set_step2(::google::protobuf::uint32 value) {
+  set_has_step2();
+  step2_ = value;
+}
+
+// required uint32 type2 = 8;
+inline bool RGBDImage::has_type2() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void RGBDImage::set_has_type2() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void RGBDImage::clear_has_type2() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void RGBDImage::clear_type2() {
+  type2_ = 0u;
+  clear_has_type2();
+}
+inline ::google::protobuf::uint32 RGBDImage::type2() const {
+  return type2_;
+}
+inline void RGBDImage::set_type2(::google::protobuf::uint32 value) {
+  set_has_type2();
+  type2_ = value;
+}
+
+// required bytes imageData2 = 9;
+inline bool RGBDImage::has_imagedata2() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void RGBDImage::set_has_imagedata2() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void RGBDImage::clear_has_imagedata2() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void RGBDImage::clear_imagedata2() {
+  if (imagedata2_ != &::google::protobuf::internal::kEmptyString) {
+    imagedata2_->clear();
+  }
+  clear_has_imagedata2();
+}
+inline const ::std::string& RGBDImage::imagedata2() const {
+  return *imagedata2_;
+}
+inline void RGBDImage::set_imagedata2(const ::std::string& value) {
+  set_has_imagedata2();
+  if (imagedata2_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata2_ = new ::std::string;
+  }
+  imagedata2_->assign(value);
+}
+inline void RGBDImage::set_imagedata2(const char* value) {
+  set_has_imagedata2();
+  if (imagedata2_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata2_ = new ::std::string;
+  }
+  imagedata2_->assign(value);
+}
+inline void RGBDImage::set_imagedata2(const void* value, size_t size) {
+  set_has_imagedata2();
+  if (imagedata2_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata2_ = new ::std::string;
+  }
+  imagedata2_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* RGBDImage::mutable_imagedata2() {
+  set_has_imagedata2();
+  if (imagedata2_ == &::google::protobuf::internal::kEmptyString) {
+    imagedata2_ = new ::std::string;
+  }
+  return imagedata2_;
+}
+inline ::std::string* RGBDImage::release_imagedata2() {
+  clear_has_imagedata2();
+  if (imagedata2_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = imagedata2_;
+    imagedata2_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// optional uint32 camera_config = 10;
+inline bool RGBDImage::has_camera_config() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void RGBDImage::set_has_camera_config() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void RGBDImage::clear_has_camera_config() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void RGBDImage::clear_camera_config() {
+  camera_config_ = 0u;
+  clear_has_camera_config();
+}
+inline ::google::protobuf::uint32 RGBDImage::camera_config() const {
+  return camera_config_;
+}
+inline void RGBDImage::set_camera_config(::google::protobuf::uint32 value) {
+  set_has_camera_config();
+  camera_config_ = value;
+}
+
+// optional uint32 camera_type = 11;
+inline bool RGBDImage::has_camera_type() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void RGBDImage::set_has_camera_type() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void RGBDImage::clear_has_camera_type() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void RGBDImage::clear_camera_type() {
+  camera_type_ = 0u;
+  clear_has_camera_type();
+}
+inline ::google::protobuf::uint32 RGBDImage::camera_type() const {
+  return camera_type_;
+}
+inline void RGBDImage::set_camera_type(::google::protobuf::uint32 value) {
+  set_has_camera_type();
+  camera_type_ = value;
+}
+
+// optional float roll = 12;
+inline bool RGBDImage::has_roll() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void RGBDImage::set_has_roll() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void RGBDImage::clear_has_roll() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void RGBDImage::clear_roll() {
+  roll_ = 0;
+  clear_has_roll();
+}
+inline float RGBDImage::roll() const {
+  return roll_;
+}
+inline void RGBDImage::set_roll(float value) {
+  set_has_roll();
+  roll_ = value;
+}
+
+// optional float pitch = 13;
+inline bool RGBDImage::has_pitch() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void RGBDImage::set_has_pitch() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void RGBDImage::clear_has_pitch() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void RGBDImage::clear_pitch() {
+  pitch_ = 0;
+  clear_has_pitch();
+}
+inline float RGBDImage::pitch() const {
+  return pitch_;
+}
+inline void RGBDImage::set_pitch(float value) {
+  set_has_pitch();
+  pitch_ = value;
+}
+
+// optional float yaw = 14;
+inline bool RGBDImage::has_yaw() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void RGBDImage::set_has_yaw() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void RGBDImage::clear_has_yaw() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void RGBDImage::clear_yaw() {
+  yaw_ = 0;
+  clear_has_yaw();
+}
+inline float RGBDImage::yaw() const {
+  return yaw_;
+}
+inline void RGBDImage::set_yaw(float value) {
+  set_has_yaw();
+  yaw_ = value;
+}
+
+// optional float lon = 15;
+inline bool RGBDImage::has_lon() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void RGBDImage::set_has_lon() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void RGBDImage::clear_has_lon() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void RGBDImage::clear_lon() {
+  lon_ = 0;
+  clear_has_lon();
+}
+inline float RGBDImage::lon() const {
+  return lon_;
+}
+inline void RGBDImage::set_lon(float value) {
+  set_has_lon();
+  lon_ = value;
+}
+
+// optional float lat = 16;
+inline bool RGBDImage::has_lat() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void RGBDImage::set_has_lat() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void RGBDImage::clear_has_lat() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void RGBDImage::clear_lat() {
+  lat_ = 0;
+  clear_has_lat();
+}
+inline float RGBDImage::lat() const {
+  return lat_;
+}
+inline void RGBDImage::set_lat(float value) {
+  set_has_lat();
+  lat_ = value;
+}
+
+// optional float alt = 17;
+inline bool RGBDImage::has_alt() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void RGBDImage::set_has_alt() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void RGBDImage::clear_has_alt() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void RGBDImage::clear_alt() {
+  alt_ = 0;
+  clear_has_alt();
+}
+inline float RGBDImage::alt() const {
+  return alt_;
+}
+inline void RGBDImage::set_alt(float value) {
+  set_has_alt();
+  alt_ = value;
+}
+
+// optional float ground_x = 18;
+inline bool RGBDImage::has_ground_x() const {
+  return (_has_bits_[0] & 0x00020000u) != 0;
+}
+inline void RGBDImage::set_has_ground_x() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void RGBDImage::clear_has_ground_x() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void RGBDImage::clear_ground_x() {
+  ground_x_ = 0;
+  clear_has_ground_x();
+}
+inline float RGBDImage::ground_x() const {
+  return ground_x_;
+}
+inline void RGBDImage::set_ground_x(float value) {
+  set_has_ground_x();
+  ground_x_ = value;
+}
+
+// optional float ground_y = 19;
+inline bool RGBDImage::has_ground_y() const {
+  return (_has_bits_[0] & 0x00040000u) != 0;
+}
+inline void RGBDImage::set_has_ground_y() {
+  _has_bits_[0] |= 0x00040000u;
+}
+inline void RGBDImage::clear_has_ground_y() {
+  _has_bits_[0] &= ~0x00040000u;
+}
+inline void RGBDImage::clear_ground_y() {
+  ground_y_ = 0;
+  clear_has_ground_y();
+}
+inline float RGBDImage::ground_y() const {
+  return ground_y_;
+}
+inline void RGBDImage::set_ground_y(float value) {
+  set_has_ground_y();
+  ground_y_ = value;
+}
+
+// optional float ground_z = 20;
+inline bool RGBDImage::has_ground_z() const {
+  return (_has_bits_[0] & 0x00080000u) != 0;
+}
+inline void RGBDImage::set_has_ground_z() {
+  _has_bits_[0] |= 0x00080000u;
+}
+inline void RGBDImage::clear_has_ground_z() {
+  _has_bits_[0] &= ~0x00080000u;
+}
+inline void RGBDImage::clear_ground_z() {
+  ground_z_ = 0;
+  clear_has_ground_z();
+}
+inline float RGBDImage::ground_z() const {
+  return ground_z_;
+}
+inline void RGBDImage::set_ground_z(float value) {
+  set_has_ground_z();
+  ground_z_ = value;
+}
+
+// repeated float camera_matrix = 21;
+inline int RGBDImage::camera_matrix_size() const {
+  return camera_matrix_.size();
+}
+inline void RGBDImage::clear_camera_matrix() {
+  camera_matrix_.Clear();
+}
+inline float RGBDImage::camera_matrix(int index) const {
+  return camera_matrix_.Get(index);
+}
+inline void RGBDImage::set_camera_matrix(int index, float value) {
+  camera_matrix_.Set(index, value);
+}
+inline void RGBDImage::add_camera_matrix(float value) {
+  camera_matrix_.Add(value);
+}
+inline const ::google::protobuf::RepeatedField< float >&
+RGBDImage::camera_matrix() const {
+  return camera_matrix_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+RGBDImage::mutable_camera_matrix() {
+  return &camera_matrix_;
+}
+
+// -------------------------------------------------------------------
+
+// Waypoint
+
+// required double x = 1;
+inline bool Waypoint::has_x() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Waypoint::set_has_x() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Waypoint::clear_has_x() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Waypoint::clear_x() {
+  x_ = 0;
+  clear_has_x();
+}
+inline double Waypoint::x() const {
+  return x_;
+}
+inline void Waypoint::set_x(double value) {
+  set_has_x();
+  x_ = value;
+}
+
+// required double y = 2;
+inline bool Waypoint::has_y() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Waypoint::set_has_y() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Waypoint::clear_has_y() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Waypoint::clear_y() {
+  y_ = 0;
+  clear_has_y();
+}
+inline double Waypoint::y() const {
+  return y_;
+}
+inline void Waypoint::set_y(double value) {
+  set_has_y();
+  y_ = value;
+}
+
+// optional double z = 3;
+inline bool Waypoint::has_z() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Waypoint::set_has_z() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Waypoint::clear_has_z() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Waypoint::clear_z() {
+  z_ = 0;
+  clear_has_z();
+}
+inline double Waypoint::z() const {
+  return z_;
+}
+inline void Waypoint::set_z(double value) {
+  set_has_z();
+  z_ = value;
+}
+
+// optional double roll = 4;
+inline bool Waypoint::has_roll() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Waypoint::set_has_roll() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Waypoint::clear_has_roll() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Waypoint::clear_roll() {
+  roll_ = 0;
+  clear_has_roll();
+}
+inline double Waypoint::roll() const {
+  return roll_;
+}
+inline void Waypoint::set_roll(double value) {
+  set_has_roll();
+  roll_ = value;
+}
+
+// optional double pitch = 5;
+inline bool Waypoint::has_pitch() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Waypoint::set_has_pitch() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Waypoint::clear_has_pitch() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Waypoint::clear_pitch() {
+  pitch_ = 0;
+  clear_has_pitch();
+}
+inline double Waypoint::pitch() const {
+  return pitch_;
+}
+inline void Waypoint::set_pitch(double value) {
+  set_has_pitch();
+  pitch_ = value;
+}
+
+// optional double yaw = 6;
+inline bool Waypoint::has_yaw() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Waypoint::set_has_yaw() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Waypoint::clear_has_yaw() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Waypoint::clear_yaw() {
+  yaw_ = 0;
+  clear_has_yaw();
+}
+inline double Waypoint::yaw() const {
+  return yaw_;
+}
+inline void Waypoint::set_yaw(double value) {
+  set_has_yaw();
+  yaw_ = value;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace px
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::px::GLOverlay_CoordinateFrameType>() {
+  return ::px::GLOverlay_CoordinateFrameType_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::px::GLOverlay_Mode>() {
+  return ::px::GLOverlay_Mode_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::px::GLOverlay_Identifier>() {
+  return ::px::GLOverlay_Identifier_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_pixhawk_2eproto__INCLUDED
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/protocol.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/protocol.h
new file mode 100644
index 000000000..7b3e3c0bd
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/protocol.h
@@ -0,0 +1,322 @@
+#ifndef  _MAVLINK_PROTOCOL_H_
+#define  _MAVLINK_PROTOCOL_H_
+
+#include "string.h"
+#include "mavlink_types.h"
+
+/* 
+   If you want MAVLink on a system that is native big-endian,
+   you need to define NATIVE_BIG_ENDIAN
+*/
+#ifdef NATIVE_BIG_ENDIAN
+# define MAVLINK_NEED_BYTE_SWAP (MAVLINK_ENDIAN == MAVLINK_LITTLE_ENDIAN)
+#else
+# define MAVLINK_NEED_BYTE_SWAP (MAVLINK_ENDIAN != MAVLINK_LITTLE_ENDIAN)
+#endif
+
+#ifndef MAVLINK_STACK_BUFFER
+#define MAVLINK_STACK_BUFFER 0
+#endif
+
+#ifndef MAVLINK_AVOID_GCC_STACK_BUG
+# define MAVLINK_AVOID_GCC_STACK_BUG defined(__GNUC__)
+#endif
+
+#ifndef MAVLINK_ASSERT
+#define MAVLINK_ASSERT(x)
+#endif
+
+#ifndef MAVLINK_START_UART_SEND
+#define MAVLINK_START_UART_SEND(chan, length)
+#endif
+
+#ifndef MAVLINK_END_UART_SEND
+#define MAVLINK_END_UART_SEND(chan, length)
+#endif
+
+#ifdef MAVLINK_SEPARATE_HELPERS
+#define MAVLINK_HELPER
+#else
+#define MAVLINK_HELPER static inline
+#include "mavlink_helpers.h"
+#endif // MAVLINK_SEPARATE_HELPERS
+
+/* always include the prototypes to ensure we don't get out of sync */
+MAVLINK_HELPER mavlink_status_t* mavlink_get_channel_status(uint8_t chan);
+#if MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length, uint8_t crc_extra);
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length, uint8_t crc_extra);
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, 
+						    uint8_t length, uint8_t crc_extra);
+#endif
+#else
+MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						      uint8_t chan, uint8_t length);
+MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, 
+						 uint8_t length);
+MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint8_t msgid, const char *packet, uint8_t length);
+#endif // MAVLINK_CRC_EXTRA
+MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t *buffer, const mavlink_message_t *msg);
+MAVLINK_HELPER void mavlink_start_checksum(mavlink_message_t* msg);
+MAVLINK_HELPER void mavlink_update_checksum(mavlink_message_t* msg, uint8_t c);
+MAVLINK_HELPER uint8_t mavlink_parse_char(uint8_t chan, uint8_t c, mavlink_message_t* r_message, mavlink_status_t* r_mavlink_status);
+MAVLINK_HELPER uint8_t put_bitfield_n_by_index(int32_t b, uint8_t bits, uint8_t packet_index, uint8_t bit_index, 
+					       uint8_t* r_bit_index, uint8_t* buffer);
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len);
+#endif
+
+/**
+ * @brief Get the required buffer size for this message
+ */
+static inline uint16_t mavlink_msg_get_send_buffer_length(const mavlink_message_t* msg)
+{
+	return msg->len + MAVLINK_NUM_NON_PAYLOAD_BYTES;
+}
+
+#if MAVLINK_NEED_BYTE_SWAP
+static inline void byte_swap_2(char *dst, const char *src)
+{
+	dst[0] = src[1];
+	dst[1] = src[0];
+}
+static inline void byte_swap_4(char *dst, const char *src)
+{
+	dst[0] = src[3];
+	dst[1] = src[2];
+	dst[2] = src[1];
+	dst[3] = src[0];
+}
+static inline void byte_swap_8(char *dst, const char *src)
+{
+	dst[0] = src[7];
+	dst[1] = src[6];
+	dst[2] = src[5];
+	dst[3] = src[4];
+	dst[4] = src[3];
+	dst[5] = src[2];
+	dst[6] = src[1];
+	dst[7] = src[0];
+}
+#elif !MAVLINK_ALIGNED_FIELDS
+static inline void byte_copy_2(char *dst, const char *src)
+{
+	dst[0] = src[0];
+	dst[1] = src[1];
+}
+static inline void byte_copy_4(char *dst, const char *src)
+{
+	dst[0] = src[0];
+	dst[1] = src[1];
+	dst[2] = src[2];
+	dst[3] = src[3];
+}
+static inline void byte_copy_8(char *dst, const char *src)
+{
+	memcpy(dst, src, 8);
+}
+#endif
+
+#define _mav_put_uint8_t(buf, wire_offset, b) buf[wire_offset] = (uint8_t)b
+#define _mav_put_int8_t(buf, wire_offset, b)  buf[wire_offset] = (int8_t)b
+#define _mav_put_char(buf, wire_offset, b)    buf[wire_offset] = b
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _mav_put_uint16_t(buf, wire_offset, b) byte_swap_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int16_t(buf, wire_offset, b)  byte_swap_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint32_t(buf, wire_offset, b) byte_swap_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int32_t(buf, wire_offset, b)  byte_swap_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint64_t(buf, wire_offset, b) byte_swap_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int64_t(buf, wire_offset, b)  byte_swap_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_float(buf, wire_offset, b)    byte_swap_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_double(buf, wire_offset, b)   byte_swap_8(&buf[wire_offset], (const char *)&b)
+#elif !MAVLINK_ALIGNED_FIELDS
+#define _mav_put_uint16_t(buf, wire_offset, b) byte_copy_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int16_t(buf, wire_offset, b)  byte_copy_2(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint32_t(buf, wire_offset, b) byte_copy_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int32_t(buf, wire_offset, b)  byte_copy_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_uint64_t(buf, wire_offset, b) byte_copy_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_int64_t(buf, wire_offset, b)  byte_copy_8(&buf[wire_offset], (const char *)&b)
+#define _mav_put_float(buf, wire_offset, b)    byte_copy_4(&buf[wire_offset], (const char *)&b)
+#define _mav_put_double(buf, wire_offset, b)   byte_copy_8(&buf[wire_offset], (const char *)&b)
+#else
+#define _mav_put_uint16_t(buf, wire_offset, b) *(uint16_t *)&buf[wire_offset] = b
+#define _mav_put_int16_t(buf, wire_offset, b)  *(int16_t *)&buf[wire_offset] = b
+#define _mav_put_uint32_t(buf, wire_offset, b) *(uint32_t *)&buf[wire_offset] = b
+#define _mav_put_int32_t(buf, wire_offset, b)  *(int32_t *)&buf[wire_offset] = b
+#define _mav_put_uint64_t(buf, wire_offset, b) *(uint64_t *)&buf[wire_offset] = b
+#define _mav_put_int64_t(buf, wire_offset, b)  *(int64_t *)&buf[wire_offset] = b
+#define _mav_put_float(buf, wire_offset, b)    *(float *)&buf[wire_offset] = b
+#define _mav_put_double(buf, wire_offset, b)   *(double *)&buf[wire_offset] = b
+#endif
+
+/*
+  like memcpy(), but if src is NULL, do a memset to zero
+*/
+static void mav_array_memcpy(void *dest, const void *src, size_t n)
+{
+	if (src == NULL) {
+		memset(dest, 0, n);
+	} else {
+		memcpy(dest, src, n);
+	}
+}
+
+/*
+ * Place a char array into a buffer
+ */
+static inline void _mav_put_char_array(char *buf, uint8_t wire_offset, const char *b, uint8_t array_length)
+{
+	mav_array_memcpy(&buf[wire_offset], b, array_length);
+
+}
+
+/*
+ * Place a uint8_t array into a buffer
+ */
+static inline void _mav_put_uint8_t_array(char *buf, uint8_t wire_offset, const uint8_t *b, uint8_t array_length)
+{
+	mav_array_memcpy(&buf[wire_offset], b, array_length);
+
+}
+
+/*
+ * Place a int8_t array into a buffer
+ */
+static inline void _mav_put_int8_t_array(char *buf, uint8_t wire_offset, const int8_t *b, uint8_t array_length)
+{
+	mav_array_memcpy(&buf[wire_offset], b, array_length);
+
+}
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _MAV_PUT_ARRAY(TYPE, V) \
+static inline void _mav_put_ ## TYPE ##_array(char *buf, uint8_t wire_offset, const TYPE *b, uint8_t array_length) \
+{ \
+	if (b == NULL) { \
+		memset(&buf[wire_offset], 0, array_length*sizeof(TYPE)); \
+	} else { \
+		uint16_t i; \
+		for (i=0; i<array_length; i++) { \
+			_mav_put_## TYPE (buf, wire_offset+(i*sizeof(TYPE)), b[i]); \
+		} \
+	} \
+}
+#else
+#define _MAV_PUT_ARRAY(TYPE, V)					\
+static inline void _mav_put_ ## TYPE ##_array(char *buf, uint8_t wire_offset, const TYPE *b, uint8_t array_length) \
+{ \
+	mav_array_memcpy(&buf[wire_offset], b, array_length*sizeof(TYPE)); \
+}
+#endif
+
+_MAV_PUT_ARRAY(uint16_t, u16)
+_MAV_PUT_ARRAY(uint32_t, u32)
+_MAV_PUT_ARRAY(uint64_t, u64)
+_MAV_PUT_ARRAY(int16_t,  i16)
+_MAV_PUT_ARRAY(int32_t,  i32)
+_MAV_PUT_ARRAY(int64_t,  i64)
+_MAV_PUT_ARRAY(float,    f)
+_MAV_PUT_ARRAY(double,   d)
+
+#define _MAV_RETURN_char(msg, wire_offset)             (const char)_MAV_PAYLOAD(msg)[wire_offset]
+#define _MAV_RETURN_int8_t(msg, wire_offset)   (const int8_t)_MAV_PAYLOAD(msg)[wire_offset]
+#define _MAV_RETURN_uint8_t(msg, wire_offset) (const uint8_t)_MAV_PAYLOAD(msg)[wire_offset]
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _MAV_MSG_RETURN_TYPE(TYPE, SIZE) \
+static inline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs) \
+{ TYPE r; byte_swap_## SIZE((char*)&r, &_MAV_PAYLOAD(msg)[ofs]); return r; }
+
+_MAV_MSG_RETURN_TYPE(uint16_t, 2)
+_MAV_MSG_RETURN_TYPE(int16_t,  2)
+_MAV_MSG_RETURN_TYPE(uint32_t, 4)
+_MAV_MSG_RETURN_TYPE(int32_t,  4)
+_MAV_MSG_RETURN_TYPE(uint64_t, 8)
+_MAV_MSG_RETURN_TYPE(int64_t,  8)
+_MAV_MSG_RETURN_TYPE(float,    4)
+_MAV_MSG_RETURN_TYPE(double,   8)
+
+#elif !MAVLINK_ALIGNED_FIELDS
+#define _MAV_MSG_RETURN_TYPE(TYPE, SIZE) \
+static inline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs) \
+{ TYPE r; byte_copy_## SIZE((char*)&r, &_MAV_PAYLOAD(msg)[ofs]); return r; }
+
+_MAV_MSG_RETURN_TYPE(uint16_t, 2)
+_MAV_MSG_RETURN_TYPE(int16_t,  2)
+_MAV_MSG_RETURN_TYPE(uint32_t, 4)
+_MAV_MSG_RETURN_TYPE(int32_t,  4)
+_MAV_MSG_RETURN_TYPE(uint64_t, 8)
+_MAV_MSG_RETURN_TYPE(int64_t,  8)
+_MAV_MSG_RETURN_TYPE(float,    4)
+_MAV_MSG_RETURN_TYPE(double,   8)
+#else // nicely aligned, no swap
+#define _MAV_MSG_RETURN_TYPE(TYPE) \
+static inline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs) \
+{ return *(const TYPE *)(&_MAV_PAYLOAD(msg)[ofs]);}
+
+_MAV_MSG_RETURN_TYPE(uint16_t)
+_MAV_MSG_RETURN_TYPE(int16_t)
+_MAV_MSG_RETURN_TYPE(uint32_t)
+_MAV_MSG_RETURN_TYPE(int32_t)
+_MAV_MSG_RETURN_TYPE(uint64_t)
+_MAV_MSG_RETURN_TYPE(int64_t)
+_MAV_MSG_RETURN_TYPE(float)
+_MAV_MSG_RETURN_TYPE(double)
+#endif // MAVLINK_NEED_BYTE_SWAP
+
+static inline uint16_t _MAV_RETURN_char_array(const mavlink_message_t *msg, char *value, 
+						     uint8_t array_length, uint8_t wire_offset)
+{
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length);
+	return array_length;
+}
+
+static inline uint16_t _MAV_RETURN_uint8_t_array(const mavlink_message_t *msg, uint8_t *value, 
+							uint8_t array_length, uint8_t wire_offset)
+{
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length);
+	return array_length;
+}
+
+static inline uint16_t _MAV_RETURN_int8_t_array(const mavlink_message_t *msg, int8_t *value, 
+						       uint8_t array_length, uint8_t wire_offset)
+{
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length);
+	return array_length;
+}
+
+#if MAVLINK_NEED_BYTE_SWAP
+#define _MAV_RETURN_ARRAY(TYPE, V) \
+static inline uint16_t _MAV_RETURN_## TYPE ##_array(const mavlink_message_t *msg, TYPE *value, \
+							 uint8_t array_length, uint8_t wire_offset) \
+{ \
+	uint16_t i; \
+	for (i=0; i<array_length; i++) { \
+		value[i] = _MAV_RETURN_## TYPE (msg, wire_offset+(i*sizeof(value[0]))); \
+	} \
+	return array_length*sizeof(value[0]); \
+}
+#else
+#define _MAV_RETURN_ARRAY(TYPE, V)					\
+static inline uint16_t _MAV_RETURN_## TYPE ##_array(const mavlink_message_t *msg, TYPE *value, \
+							 uint8_t array_length, uint8_t wire_offset) \
+{ \
+	memcpy(value, &_MAV_PAYLOAD(msg)[wire_offset], array_length*sizeof(TYPE)); \
+	return array_length*sizeof(TYPE); \
+}
+#endif
+
+_MAV_RETURN_ARRAY(uint16_t, u16)
+_MAV_RETURN_ARRAY(uint32_t, u32)
+_MAV_RETURN_ARRAY(uint64_t, u64)
+_MAV_RETURN_ARRAY(int16_t,  i16)
+_MAV_RETURN_ARRAY(int32_t,  i32)
+_MAV_RETURN_ARRAY(int64_t,  i64)
+_MAV_RETURN_ARRAY(float,    f)
+_MAV_RETURN_ARRAY(double,   d)
+
+#endif // _MAVLINK_PROTOCOL_H_
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/mavlink.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/mavlink.h
new file mode 100644
index 000000000..e596b8fba
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/mavlink.h
@@ -0,0 +1,27 @@
+/** @file
+ *	@brief MAVLink comm protocol built from test.xml
+ *	@see http://pixhawk.ethz.ch/software/mavlink
+ */
+#ifndef MAVLINK_H
+#define MAVLINK_H
+
+#ifndef MAVLINK_STX
+#define MAVLINK_STX 254
+#endif
+
+#ifndef MAVLINK_ENDIAN
+#define MAVLINK_ENDIAN MAVLINK_LITTLE_ENDIAN
+#endif
+
+#ifndef MAVLINK_ALIGNED_FIELDS
+#define MAVLINK_ALIGNED_FIELDS 1
+#endif
+
+#ifndef MAVLINK_CRC_EXTRA
+#define MAVLINK_CRC_EXTRA 1
+#endif
+
+#include "version.h"
+#include "test.h"
+
+#endif // MAVLINK_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/mavlink_msg_test_types.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/mavlink_msg_test_types.h
new file mode 100644
index 000000000..2a3a89ff9
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/mavlink_msg_test_types.h
@@ -0,0 +1,610 @@
+// MESSAGE TEST_TYPES PACKING
+
+#define MAVLINK_MSG_ID_TEST_TYPES 0
+
+typedef struct __mavlink_test_types_t
+{
+ uint64_t u64; ///< uint64_t
+ int64_t s64; ///< int64_t
+ double d; ///< double
+ uint64_t u64_array[3]; ///< uint64_t_array
+ int64_t s64_array[3]; ///< int64_t_array
+ double d_array[3]; ///< double_array
+ uint32_t u32; ///< uint32_t
+ int32_t s32; ///< int32_t
+ float f; ///< float
+ uint32_t u32_array[3]; ///< uint32_t_array
+ int32_t s32_array[3]; ///< int32_t_array
+ float f_array[3]; ///< float_array
+ uint16_t u16; ///< uint16_t
+ int16_t s16; ///< int16_t
+ uint16_t u16_array[3]; ///< uint16_t_array
+ int16_t s16_array[3]; ///< int16_t_array
+ char c; ///< char
+ char s[10]; ///< string
+ uint8_t u8; ///< uint8_t
+ int8_t s8; ///< int8_t
+ uint8_t u8_array[3]; ///< uint8_t_array
+ int8_t s8_array[3]; ///< int8_t_array
+} mavlink_test_types_t;
+
+#define MAVLINK_MSG_ID_TEST_TYPES_LEN 179
+#define MAVLINK_MSG_ID_0_LEN 179
+
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U64_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S64_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_D_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U32_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S32_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_F_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U16_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S16_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S_LEN 10
+#define MAVLINK_MSG_TEST_TYPES_FIELD_U8_ARRAY_LEN 3
+#define MAVLINK_MSG_TEST_TYPES_FIELD_S8_ARRAY_LEN 3
+
+#define MAVLINK_MESSAGE_INFO_TEST_TYPES { \
+	"TEST_TYPES", \
+	22, \
+	{  { "u64", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_test_types_t, u64) }, \
+         { "s64", NULL, MAVLINK_TYPE_INT64_T, 0, 8, offsetof(mavlink_test_types_t, s64) }, \
+         { "d", NULL, MAVLINK_TYPE_DOUBLE, 0, 16, offsetof(mavlink_test_types_t, d) }, \
+         { "u64_array", NULL, MAVLINK_TYPE_UINT64_T, 3, 24, offsetof(mavlink_test_types_t, u64_array) }, \
+         { "s64_array", NULL, MAVLINK_TYPE_INT64_T, 3, 48, offsetof(mavlink_test_types_t, s64_array) }, \
+         { "d_array", NULL, MAVLINK_TYPE_DOUBLE, 3, 72, offsetof(mavlink_test_types_t, d_array) }, \
+         { "u32", "0x%08x", MAVLINK_TYPE_UINT32_T, 0, 96, offsetof(mavlink_test_types_t, u32) }, \
+         { "s32", NULL, MAVLINK_TYPE_INT32_T, 0, 100, offsetof(mavlink_test_types_t, s32) }, \
+         { "f", NULL, MAVLINK_TYPE_FLOAT, 0, 104, offsetof(mavlink_test_types_t, f) }, \
+         { "u32_array", NULL, MAVLINK_TYPE_UINT32_T, 3, 108, offsetof(mavlink_test_types_t, u32_array) }, \
+         { "s32_array", NULL, MAVLINK_TYPE_INT32_T, 3, 120, offsetof(mavlink_test_types_t, s32_array) }, \
+         { "f_array", NULL, MAVLINK_TYPE_FLOAT, 3, 132, offsetof(mavlink_test_types_t, f_array) }, \
+         { "u16", NULL, MAVLINK_TYPE_UINT16_T, 0, 144, offsetof(mavlink_test_types_t, u16) }, \
+         { "s16", NULL, MAVLINK_TYPE_INT16_T, 0, 146, offsetof(mavlink_test_types_t, s16) }, \
+         { "u16_array", NULL, MAVLINK_TYPE_UINT16_T, 3, 148, offsetof(mavlink_test_types_t, u16_array) }, \
+         { "s16_array", NULL, MAVLINK_TYPE_INT16_T, 3, 154, offsetof(mavlink_test_types_t, s16_array) }, \
+         { "c", NULL, MAVLINK_TYPE_CHAR, 0, 160, offsetof(mavlink_test_types_t, c) }, \
+         { "s", NULL, MAVLINK_TYPE_CHAR, 10, 161, offsetof(mavlink_test_types_t, s) }, \
+         { "u8", NULL, MAVLINK_TYPE_UINT8_T, 0, 171, offsetof(mavlink_test_types_t, u8) }, \
+         { "s8", NULL, MAVLINK_TYPE_INT8_T, 0, 172, offsetof(mavlink_test_types_t, s8) }, \
+         { "u8_array", NULL, MAVLINK_TYPE_UINT8_T, 3, 173, offsetof(mavlink_test_types_t, u8_array) }, \
+         { "s8_array", NULL, MAVLINK_TYPE_INT8_T, 3, 176, offsetof(mavlink_test_types_t, s8_array) }, \
+         } \
+}
+
+
+/**
+ * @brief Pack a test_types message
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param msg The MAVLink message to compress the data into
+ *
+ * @param c char
+ * @param s string
+ * @param u8 uint8_t
+ * @param u16 uint16_t
+ * @param u32 uint32_t
+ * @param u64 uint64_t
+ * @param s8 int8_t
+ * @param s16 int16_t
+ * @param s32 int32_t
+ * @param s64 int64_t
+ * @param f float
+ * @param d double
+ * @param u8_array uint8_t_array
+ * @param u16_array uint16_t_array
+ * @param u32_array uint32_t_array
+ * @param u64_array uint64_t_array
+ * @param s8_array int8_t_array
+ * @param s16_array int16_t_array
+ * @param s32_array int32_t_array
+ * @param s64_array int64_t_array
+ * @param f_array float_array
+ * @param d_array double_array
+ * @return length of the message in bytes (excluding serial stream start sign)
+ */
+static inline uint16_t mavlink_msg_test_types_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
+						       char c, const char *s, uint8_t u8, uint16_t u16, uint32_t u32, uint64_t u64, int8_t s8, int16_t s16, int32_t s32, int64_t s64, float f, double d, const uint8_t *u8_array, const uint16_t *u16_array, const uint32_t *u32_array, const uint64_t *u64_array, const int8_t *s8_array, const int16_t *s16_array, const int32_t *s32_array, const int64_t *s64_array, const float *f_array, const double *d_array)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+	char buf[179];
+	_mav_put_uint64_t(buf, 0, u64);
+	_mav_put_int64_t(buf, 8, s64);
+	_mav_put_double(buf, 16, d);
+	_mav_put_uint32_t(buf, 96, u32);
+	_mav_put_int32_t(buf, 100, s32);
+	_mav_put_float(buf, 104, f);
+	_mav_put_uint16_t(buf, 144, u16);
+	_mav_put_int16_t(buf, 146, s16);
+	_mav_put_char(buf, 160, c);
+	_mav_put_uint8_t(buf, 171, u8);
+	_mav_put_int8_t(buf, 172, s8);
+	_mav_put_uint64_t_array(buf, 24, u64_array, 3);
+	_mav_put_int64_t_array(buf, 48, s64_array, 3);
+	_mav_put_double_array(buf, 72, d_array, 3);
+	_mav_put_uint32_t_array(buf, 108, u32_array, 3);
+	_mav_put_int32_t_array(buf, 120, s32_array, 3);
+	_mav_put_float_array(buf, 132, f_array, 3);
+	_mav_put_uint16_t_array(buf, 148, u16_array, 3);
+	_mav_put_int16_t_array(buf, 154, s16_array, 3);
+	_mav_put_char_array(buf, 161, s, 10);
+	_mav_put_uint8_t_array(buf, 173, u8_array, 3);
+	_mav_put_int8_t_array(buf, 176, s8_array, 3);
+        memcpy(_MAV_PAYLOAD(msg), buf, 179);
+#else
+	mavlink_test_types_t packet;
+	packet.u64 = u64;
+	packet.s64 = s64;
+	packet.d = d;
+	packet.u32 = u32;
+	packet.s32 = s32;
+	packet.f = f;
+	packet.u16 = u16;
+	packet.s16 = s16;
+	packet.c = c;
+	packet.u8 = u8;
+	packet.s8 = s8;
+	mav_array_memcpy(packet.u64_array, u64_array, sizeof(uint64_t)*3);
+	mav_array_memcpy(packet.s64_array, s64_array, sizeof(int64_t)*3);
+	mav_array_memcpy(packet.d_array, d_array, sizeof(double)*3);
+	mav_array_memcpy(packet.u32_array, u32_array, sizeof(uint32_t)*3);
+	mav_array_memcpy(packet.s32_array, s32_array, sizeof(int32_t)*3);
+	mav_array_memcpy(packet.f_array, f_array, sizeof(float)*3);
+	mav_array_memcpy(packet.u16_array, u16_array, sizeof(uint16_t)*3);
+	mav_array_memcpy(packet.s16_array, s16_array, sizeof(int16_t)*3);
+	mav_array_memcpy(packet.s, s, sizeof(char)*10);
+	mav_array_memcpy(packet.u8_array, u8_array, sizeof(uint8_t)*3);
+	mav_array_memcpy(packet.s8_array, s8_array, sizeof(int8_t)*3);
+        memcpy(_MAV_PAYLOAD(msg), &packet, 179);
+#endif
+
+	msg->msgid = MAVLINK_MSG_ID_TEST_TYPES;
+	return mavlink_finalize_message(msg, system_id, component_id, 179, 103);
+}
+
+/**
+ * @brief Pack a test_types message on a channel
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param chan The MAVLink channel this message was sent over
+ * @param msg The MAVLink message to compress the data into
+ * @param c char
+ * @param s string
+ * @param u8 uint8_t
+ * @param u16 uint16_t
+ * @param u32 uint32_t
+ * @param u64 uint64_t
+ * @param s8 int8_t
+ * @param s16 int16_t
+ * @param s32 int32_t
+ * @param s64 int64_t
+ * @param f float
+ * @param d double
+ * @param u8_array uint8_t_array
+ * @param u16_array uint16_t_array
+ * @param u32_array uint32_t_array
+ * @param u64_array uint64_t_array
+ * @param s8_array int8_t_array
+ * @param s16_array int16_t_array
+ * @param s32_array int32_t_array
+ * @param s64_array int64_t_array
+ * @param f_array float_array
+ * @param d_array double_array
+ * @return length of the message in bytes (excluding serial stream start sign)
+ */
+static inline uint16_t mavlink_msg_test_types_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
+							   mavlink_message_t* msg,
+						           char c,const char *s,uint8_t u8,uint16_t u16,uint32_t u32,uint64_t u64,int8_t s8,int16_t s16,int32_t s32,int64_t s64,float f,double d,const uint8_t *u8_array,const uint16_t *u16_array,const uint32_t *u32_array,const uint64_t *u64_array,const int8_t *s8_array,const int16_t *s16_array,const int32_t *s32_array,const int64_t *s64_array,const float *f_array,const double *d_array)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+	char buf[179];
+	_mav_put_uint64_t(buf, 0, u64);
+	_mav_put_int64_t(buf, 8, s64);
+	_mav_put_double(buf, 16, d);
+	_mav_put_uint32_t(buf, 96, u32);
+	_mav_put_int32_t(buf, 100, s32);
+	_mav_put_float(buf, 104, f);
+	_mav_put_uint16_t(buf, 144, u16);
+	_mav_put_int16_t(buf, 146, s16);
+	_mav_put_char(buf, 160, c);
+	_mav_put_uint8_t(buf, 171, u8);
+	_mav_put_int8_t(buf, 172, s8);
+	_mav_put_uint64_t_array(buf, 24, u64_array, 3);
+	_mav_put_int64_t_array(buf, 48, s64_array, 3);
+	_mav_put_double_array(buf, 72, d_array, 3);
+	_mav_put_uint32_t_array(buf, 108, u32_array, 3);
+	_mav_put_int32_t_array(buf, 120, s32_array, 3);
+	_mav_put_float_array(buf, 132, f_array, 3);
+	_mav_put_uint16_t_array(buf, 148, u16_array, 3);
+	_mav_put_int16_t_array(buf, 154, s16_array, 3);
+	_mav_put_char_array(buf, 161, s, 10);
+	_mav_put_uint8_t_array(buf, 173, u8_array, 3);
+	_mav_put_int8_t_array(buf, 176, s8_array, 3);
+        memcpy(_MAV_PAYLOAD(msg), buf, 179);
+#else
+	mavlink_test_types_t packet;
+	packet.u64 = u64;
+	packet.s64 = s64;
+	packet.d = d;
+	packet.u32 = u32;
+	packet.s32 = s32;
+	packet.f = f;
+	packet.u16 = u16;
+	packet.s16 = s16;
+	packet.c = c;
+	packet.u8 = u8;
+	packet.s8 = s8;
+	mav_array_memcpy(packet.u64_array, u64_array, sizeof(uint64_t)*3);
+	mav_array_memcpy(packet.s64_array, s64_array, sizeof(int64_t)*3);
+	mav_array_memcpy(packet.d_array, d_array, sizeof(double)*3);
+	mav_array_memcpy(packet.u32_array, u32_array, sizeof(uint32_t)*3);
+	mav_array_memcpy(packet.s32_array, s32_array, sizeof(int32_t)*3);
+	mav_array_memcpy(packet.f_array, f_array, sizeof(float)*3);
+	mav_array_memcpy(packet.u16_array, u16_array, sizeof(uint16_t)*3);
+	mav_array_memcpy(packet.s16_array, s16_array, sizeof(int16_t)*3);
+	mav_array_memcpy(packet.s, s, sizeof(char)*10);
+	mav_array_memcpy(packet.u8_array, u8_array, sizeof(uint8_t)*3);
+	mav_array_memcpy(packet.s8_array, s8_array, sizeof(int8_t)*3);
+        memcpy(_MAV_PAYLOAD(msg), &packet, 179);
+#endif
+
+	msg->msgid = MAVLINK_MSG_ID_TEST_TYPES;
+	return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 179, 103);
+}
+
+/**
+ * @brief Encode a test_types struct into a message
+ *
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param msg The MAVLink message to compress the data into
+ * @param test_types C-struct to read the message contents from
+ */
+static inline uint16_t mavlink_msg_test_types_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_test_types_t* test_types)
+{
+	return mavlink_msg_test_types_pack(system_id, component_id, msg, test_types->c, test_types->s, test_types->u8, test_types->u16, test_types->u32, test_types->u64, test_types->s8, test_types->s16, test_types->s32, test_types->s64, test_types->f, test_types->d, test_types->u8_array, test_types->u16_array, test_types->u32_array, test_types->u64_array, test_types->s8_array, test_types->s16_array, test_types->s32_array, test_types->s64_array, test_types->f_array, test_types->d_array);
+}
+
+/**
+ * @brief Send a test_types message
+ * @param chan MAVLink channel to send the message
+ *
+ * @param c char
+ * @param s string
+ * @param u8 uint8_t
+ * @param u16 uint16_t
+ * @param u32 uint32_t
+ * @param u64 uint64_t
+ * @param s8 int8_t
+ * @param s16 int16_t
+ * @param s32 int32_t
+ * @param s64 int64_t
+ * @param f float
+ * @param d double
+ * @param u8_array uint8_t_array
+ * @param u16_array uint16_t_array
+ * @param u32_array uint32_t_array
+ * @param u64_array uint64_t_array
+ * @param s8_array int8_t_array
+ * @param s16_array int16_t_array
+ * @param s32_array int32_t_array
+ * @param s64_array int64_t_array
+ * @param f_array float_array
+ * @param d_array double_array
+ */
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+static inline void mavlink_msg_test_types_send(mavlink_channel_t chan, char c, const char *s, uint8_t u8, uint16_t u16, uint32_t u32, uint64_t u64, int8_t s8, int16_t s16, int32_t s32, int64_t s64, float f, double d, const uint8_t *u8_array, const uint16_t *u16_array, const uint32_t *u32_array, const uint64_t *u64_array, const int8_t *s8_array, const int16_t *s16_array, const int32_t *s32_array, const int64_t *s64_array, const float *f_array, const double *d_array)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+	char buf[179];
+	_mav_put_uint64_t(buf, 0, u64);
+	_mav_put_int64_t(buf, 8, s64);
+	_mav_put_double(buf, 16, d);
+	_mav_put_uint32_t(buf, 96, u32);
+	_mav_put_int32_t(buf, 100, s32);
+	_mav_put_float(buf, 104, f);
+	_mav_put_uint16_t(buf, 144, u16);
+	_mav_put_int16_t(buf, 146, s16);
+	_mav_put_char(buf, 160, c);
+	_mav_put_uint8_t(buf, 171, u8);
+	_mav_put_int8_t(buf, 172, s8);
+	_mav_put_uint64_t_array(buf, 24, u64_array, 3);
+	_mav_put_int64_t_array(buf, 48, s64_array, 3);
+	_mav_put_double_array(buf, 72, d_array, 3);
+	_mav_put_uint32_t_array(buf, 108, u32_array, 3);
+	_mav_put_int32_t_array(buf, 120, s32_array, 3);
+	_mav_put_float_array(buf, 132, f_array, 3);
+	_mav_put_uint16_t_array(buf, 148, u16_array, 3);
+	_mav_put_int16_t_array(buf, 154, s16_array, 3);
+	_mav_put_char_array(buf, 161, s, 10);
+	_mav_put_uint8_t_array(buf, 173, u8_array, 3);
+	_mav_put_int8_t_array(buf, 176, s8_array, 3);
+	_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_TEST_TYPES, buf, 179, 103);
+#else
+	mavlink_test_types_t packet;
+	packet.u64 = u64;
+	packet.s64 = s64;
+	packet.d = d;
+	packet.u32 = u32;
+	packet.s32 = s32;
+	packet.f = f;
+	packet.u16 = u16;
+	packet.s16 = s16;
+	packet.c = c;
+	packet.u8 = u8;
+	packet.s8 = s8;
+	mav_array_memcpy(packet.u64_array, u64_array, sizeof(uint64_t)*3);
+	mav_array_memcpy(packet.s64_array, s64_array, sizeof(int64_t)*3);
+	mav_array_memcpy(packet.d_array, d_array, sizeof(double)*3);
+	mav_array_memcpy(packet.u32_array, u32_array, sizeof(uint32_t)*3);
+	mav_array_memcpy(packet.s32_array, s32_array, sizeof(int32_t)*3);
+	mav_array_memcpy(packet.f_array, f_array, sizeof(float)*3);
+	mav_array_memcpy(packet.u16_array, u16_array, sizeof(uint16_t)*3);
+	mav_array_memcpy(packet.s16_array, s16_array, sizeof(int16_t)*3);
+	mav_array_memcpy(packet.s, s, sizeof(char)*10);
+	mav_array_memcpy(packet.u8_array, u8_array, sizeof(uint8_t)*3);
+	mav_array_memcpy(packet.s8_array, s8_array, sizeof(int8_t)*3);
+	_mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_TEST_TYPES, (const char *)&packet, 179, 103);
+#endif
+}
+
+#endif
+
+// MESSAGE TEST_TYPES UNPACKING
+
+
+/**
+ * @brief Get field c from test_types message
+ *
+ * @return char
+ */
+static inline char mavlink_msg_test_types_get_c(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_char(msg,  160);
+}
+
+/**
+ * @brief Get field s from test_types message
+ *
+ * @return string
+ */
+static inline uint16_t mavlink_msg_test_types_get_s(const mavlink_message_t* msg, char *s)
+{
+	return _MAV_RETURN_char_array(msg, s, 10,  161);
+}
+
+/**
+ * @brief Get field u8 from test_types message
+ *
+ * @return uint8_t
+ */
+static inline uint8_t mavlink_msg_test_types_get_u8(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint8_t(msg,  171);
+}
+
+/**
+ * @brief Get field u16 from test_types message
+ *
+ * @return uint16_t
+ */
+static inline uint16_t mavlink_msg_test_types_get_u16(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint16_t(msg,  144);
+}
+
+/**
+ * @brief Get field u32 from test_types message
+ *
+ * @return uint32_t
+ */
+static inline uint32_t mavlink_msg_test_types_get_u32(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint32_t(msg,  96);
+}
+
+/**
+ * @brief Get field u64 from test_types message
+ *
+ * @return uint64_t
+ */
+static inline uint64_t mavlink_msg_test_types_get_u64(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_uint64_t(msg,  0);
+}
+
+/**
+ * @brief Get field s8 from test_types message
+ *
+ * @return int8_t
+ */
+static inline int8_t mavlink_msg_test_types_get_s8(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int8_t(msg,  172);
+}
+
+/**
+ * @brief Get field s16 from test_types message
+ *
+ * @return int16_t
+ */
+static inline int16_t mavlink_msg_test_types_get_s16(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int16_t(msg,  146);
+}
+
+/**
+ * @brief Get field s32 from test_types message
+ *
+ * @return int32_t
+ */
+static inline int32_t mavlink_msg_test_types_get_s32(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int32_t(msg,  100);
+}
+
+/**
+ * @brief Get field s64 from test_types message
+ *
+ * @return int64_t
+ */
+static inline int64_t mavlink_msg_test_types_get_s64(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_int64_t(msg,  8);
+}
+
+/**
+ * @brief Get field f from test_types message
+ *
+ * @return float
+ */
+static inline float mavlink_msg_test_types_get_f(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_float(msg,  104);
+}
+
+/**
+ * @brief Get field d from test_types message
+ *
+ * @return double
+ */
+static inline double mavlink_msg_test_types_get_d(const mavlink_message_t* msg)
+{
+	return _MAV_RETURN_double(msg,  16);
+}
+
+/**
+ * @brief Get field u8_array from test_types message
+ *
+ * @return uint8_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u8_array(const mavlink_message_t* msg, uint8_t *u8_array)
+{
+	return _MAV_RETURN_uint8_t_array(msg, u8_array, 3,  173);
+}
+
+/**
+ * @brief Get field u16_array from test_types message
+ *
+ * @return uint16_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u16_array(const mavlink_message_t* msg, uint16_t *u16_array)
+{
+	return _MAV_RETURN_uint16_t_array(msg, u16_array, 3,  148);
+}
+
+/**
+ * @brief Get field u32_array from test_types message
+ *
+ * @return uint32_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u32_array(const mavlink_message_t* msg, uint32_t *u32_array)
+{
+	return _MAV_RETURN_uint32_t_array(msg, u32_array, 3,  108);
+}
+
+/**
+ * @brief Get field u64_array from test_types message
+ *
+ * @return uint64_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_u64_array(const mavlink_message_t* msg, uint64_t *u64_array)
+{
+	return _MAV_RETURN_uint64_t_array(msg, u64_array, 3,  24);
+}
+
+/**
+ * @brief Get field s8_array from test_types message
+ *
+ * @return int8_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s8_array(const mavlink_message_t* msg, int8_t *s8_array)
+{
+	return _MAV_RETURN_int8_t_array(msg, s8_array, 3,  176);
+}
+
+/**
+ * @brief Get field s16_array from test_types message
+ *
+ * @return int16_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s16_array(const mavlink_message_t* msg, int16_t *s16_array)
+{
+	return _MAV_RETURN_int16_t_array(msg, s16_array, 3,  154);
+}
+
+/**
+ * @brief Get field s32_array from test_types message
+ *
+ * @return int32_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s32_array(const mavlink_message_t* msg, int32_t *s32_array)
+{
+	return _MAV_RETURN_int32_t_array(msg, s32_array, 3,  120);
+}
+
+/**
+ * @brief Get field s64_array from test_types message
+ *
+ * @return int64_t_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_s64_array(const mavlink_message_t* msg, int64_t *s64_array)
+{
+	return _MAV_RETURN_int64_t_array(msg, s64_array, 3,  48);
+}
+
+/**
+ * @brief Get field f_array from test_types message
+ *
+ * @return float_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_f_array(const mavlink_message_t* msg, float *f_array)
+{
+	return _MAV_RETURN_float_array(msg, f_array, 3,  132);
+}
+
+/**
+ * @brief Get field d_array from test_types message
+ *
+ * @return double_array
+ */
+static inline uint16_t mavlink_msg_test_types_get_d_array(const mavlink_message_t* msg, double *d_array)
+{
+	return _MAV_RETURN_double_array(msg, d_array, 3,  72);
+}
+
+/**
+ * @brief Decode a test_types message into a struct
+ *
+ * @param msg The message to decode
+ * @param test_types C-struct to decode the message contents into
+ */
+static inline void mavlink_msg_test_types_decode(const mavlink_message_t* msg, mavlink_test_types_t* test_types)
+{
+#if MAVLINK_NEED_BYTE_SWAP
+	test_types->u64 = mavlink_msg_test_types_get_u64(msg);
+	test_types->s64 = mavlink_msg_test_types_get_s64(msg);
+	test_types->d = mavlink_msg_test_types_get_d(msg);
+	mavlink_msg_test_types_get_u64_array(msg, test_types->u64_array);
+	mavlink_msg_test_types_get_s64_array(msg, test_types->s64_array);
+	mavlink_msg_test_types_get_d_array(msg, test_types->d_array);
+	test_types->u32 = mavlink_msg_test_types_get_u32(msg);
+	test_types->s32 = mavlink_msg_test_types_get_s32(msg);
+	test_types->f = mavlink_msg_test_types_get_f(msg);
+	mavlink_msg_test_types_get_u32_array(msg, test_types->u32_array);
+	mavlink_msg_test_types_get_s32_array(msg, test_types->s32_array);
+	mavlink_msg_test_types_get_f_array(msg, test_types->f_array);
+	test_types->u16 = mavlink_msg_test_types_get_u16(msg);
+	test_types->s16 = mavlink_msg_test_types_get_s16(msg);
+	mavlink_msg_test_types_get_u16_array(msg, test_types->u16_array);
+	mavlink_msg_test_types_get_s16_array(msg, test_types->s16_array);
+	test_types->c = mavlink_msg_test_types_get_c(msg);
+	mavlink_msg_test_types_get_s(msg, test_types->s);
+	test_types->u8 = mavlink_msg_test_types_get_u8(msg);
+	test_types->s8 = mavlink_msg_test_types_get_s8(msg);
+	mavlink_msg_test_types_get_u8_array(msg, test_types->u8_array);
+	mavlink_msg_test_types_get_s8_array(msg, test_types->s8_array);
+#else
+	memcpy(test_types, _MAV_PAYLOAD(msg), 179);
+#endif
+}
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/test.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/test.h
new file mode 100644
index 000000000..4dc04f889
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/test.h
@@ -0,0 +1,53 @@
+/** @file
+ *	@brief MAVLink comm protocol generated from test.xml
+ *	@see http://qgroundcontrol.org/mavlink/
+ */
+#ifndef TEST_H
+#define TEST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// MESSAGE LENGTHS AND CRCS
+
+#ifndef MAVLINK_MESSAGE_LENGTHS
+#define MAVLINK_MESSAGE_LENGTHS {179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#endif
+
+#ifndef MAVLINK_MESSAGE_CRCS
+#define MAVLINK_MESSAGE_CRCS {103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#endif
+
+#ifndef MAVLINK_MESSAGE_INFO
+#define MAVLINK_MESSAGE_INFO {MAVLINK_MESSAGE_INFO_TEST_TYPES, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}}
+#endif
+
+#include "../protocol.h"
+
+#define MAVLINK_ENABLED_TEST
+
+
+
+// MAVLINK VERSION
+
+#ifndef MAVLINK_VERSION
+#define MAVLINK_VERSION 3
+#endif
+
+#if (MAVLINK_VERSION == 0)
+#undef MAVLINK_VERSION
+#define MAVLINK_VERSION 3
+#endif
+
+// ENUM DEFINITIONS
+
+
+
+// MESSAGE DEFINITIONS
+#include "./mavlink_msg_test_types.h"
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // TEST_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/testsuite.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/testsuite.h
new file mode 100644
index 000000000..658e1ae07
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/testsuite.h
@@ -0,0 +1,120 @@
+/** @file
+ *	@brief MAVLink comm protocol testsuite generated from test.xml
+ *	@see http://qgroundcontrol.org/mavlink/
+ */
+#ifndef TEST_TESTSUITE_H
+#define TEST_TESTSUITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef MAVLINK_TEST_ALL
+#define MAVLINK_TEST_ALL
+
+static void mavlink_test_test(uint8_t, uint8_t, mavlink_message_t *last_msg);
+
+static void mavlink_test_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
+{
+
+	mavlink_test_test(system_id, component_id, last_msg);
+}
+#endif
+
+
+
+
+static void mavlink_test_test_types(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
+{
+	mavlink_message_t msg;
+        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
+        uint16_t i;
+	mavlink_test_types_t packet_in = {
+		93372036854775807ULL,
+	93372036854776311LL,
+	235.0,
+	{ 93372036854777319, 93372036854777320, 93372036854777321 },
+	{ 93372036854778831, 93372036854778832, 93372036854778833 },
+	{ 627.0, 628.0, 629.0 },
+	963502456,
+	963502664,
+	745.0,
+	{ 963503080, 963503081, 963503082 },
+	{ 963503704, 963503705, 963503706 },
+	{ 941.0, 942.0, 943.0 },
+	24723,
+	24827,
+	{ 24931, 24932, 24933 },
+	{ 25243, 25244, 25245 },
+	'E',
+	"FGHIJKLMN",
+	198,
+	9,
+	{ 76, 77, 78 },
+	{ 21, 22, 23 },
+	};
+	mavlink_test_types_t packet1, packet2;
+        memset(&packet1, 0, sizeof(packet1));
+        	packet1.u64 = packet_in.u64;
+        	packet1.s64 = packet_in.s64;
+        	packet1.d = packet_in.d;
+        	packet1.u32 = packet_in.u32;
+        	packet1.s32 = packet_in.s32;
+        	packet1.f = packet_in.f;
+        	packet1.u16 = packet_in.u16;
+        	packet1.s16 = packet_in.s16;
+        	packet1.c = packet_in.c;
+        	packet1.u8 = packet_in.u8;
+        	packet1.s8 = packet_in.s8;
+        
+        	mav_array_memcpy(packet1.u64_array, packet_in.u64_array, sizeof(uint64_t)*3);
+        	mav_array_memcpy(packet1.s64_array, packet_in.s64_array, sizeof(int64_t)*3);
+        	mav_array_memcpy(packet1.d_array, packet_in.d_array, sizeof(double)*3);
+        	mav_array_memcpy(packet1.u32_array, packet_in.u32_array, sizeof(uint32_t)*3);
+        	mav_array_memcpy(packet1.s32_array, packet_in.s32_array, sizeof(int32_t)*3);
+        	mav_array_memcpy(packet1.f_array, packet_in.f_array, sizeof(float)*3);
+        	mav_array_memcpy(packet1.u16_array, packet_in.u16_array, sizeof(uint16_t)*3);
+        	mav_array_memcpy(packet1.s16_array, packet_in.s16_array, sizeof(int16_t)*3);
+        	mav_array_memcpy(packet1.s, packet_in.s, sizeof(char)*10);
+        	mav_array_memcpy(packet1.u8_array, packet_in.u8_array, sizeof(uint8_t)*3);
+        	mav_array_memcpy(packet1.s8_array, packet_in.s8_array, sizeof(int8_t)*3);
+        
+
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_encode(system_id, component_id, &msg, &packet1);
+	mavlink_msg_test_types_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_pack(system_id, component_id, &msg , packet1.c , packet1.s , packet1.u8 , packet1.u16 , packet1.u32 , packet1.u64 , packet1.s8 , packet1.s16 , packet1.s32 , packet1.s64 , packet1.f , packet1.d , packet1.u8_array , packet1.u16_array , packet1.u32_array , packet1.u64_array , packet1.s8_array , packet1.s16_array , packet1.s32_array , packet1.s64_array , packet1.f_array , packet1.d_array );
+	mavlink_msg_test_types_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.c , packet1.s , packet1.u8 , packet1.u16 , packet1.u32 , packet1.u64 , packet1.s8 , packet1.s16 , packet1.s32 , packet1.s64 , packet1.f , packet1.d , packet1.u8_array , packet1.u16_array , packet1.u32_array , packet1.u64_array , packet1.s8_array , packet1.s16_array , packet1.s32_array , packet1.s64_array , packet1.f_array , packet1.d_array );
+	mavlink_msg_test_types_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+        mavlink_msg_to_send_buffer(buffer, &msg);
+        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
+        	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
+        }
+	mavlink_msg_test_types_decode(last_msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+        
+        memset(&packet2, 0, sizeof(packet2));
+	mavlink_msg_test_types_send(MAVLINK_COMM_1 , packet1.c , packet1.s , packet1.u8 , packet1.u16 , packet1.u32 , packet1.u64 , packet1.s8 , packet1.s16 , packet1.s32 , packet1.s64 , packet1.f , packet1.d , packet1.u8_array , packet1.u16_array , packet1.u32_array , packet1.u64_array , packet1.s8_array , packet1.s16_array , packet1.s32_array , packet1.s64_array , packet1.f_array , packet1.d_array );
+	mavlink_msg_test_types_decode(last_msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+}
+
+static void mavlink_test_test(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
+{
+	mavlink_test_test_types(system_id, component_id, last_msg);
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // TEST_TESTSUITE_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/version.h b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/version.h
new file mode 100644
index 000000000..867641e21
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/include_v1.0/test/version.h
@@ -0,0 +1,12 @@
+/** @file
+ *	@brief MAVLink comm protocol built from test.xml
+ *	@see http://pixhawk.ethz.ch/software/mavlink
+ */
+#ifndef MAVLINK_VERSION_H
+#define MAVLINK_VERSION_H
+
+#define MAVLINK_BUILD_DATE "Thu Mar  1 15:11:58 2012"
+#define MAVLINK_WIRE_PROTOCOL_VERSION "1.0"
+#define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 179
+ 
+#endif // MAVLINK_VERSION_H
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/src_v1.0/pixhawk/pixhawk.pb.cc b/mavlink/share/pyshared/pymavlink/generator/C/src_v1.0/pixhawk/pixhawk.pb.cc
new file mode 100644
index 000000000..e984f512a
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/src_v1.0/pixhawk/pixhawk.pb.cc
@@ -0,0 +1,5431 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "pixhawk.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+
+namespace px {
+
+namespace {
+
+const ::google::protobuf::Descriptor* HeaderInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  HeaderInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GLOverlay_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GLOverlay_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* GLOverlay_CoordinateFrameType_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* GLOverlay_Mode_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* GLOverlay_Identifier_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* Obstacle_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Obstacle_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ObstacleList_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ObstacleList_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ObstacleMap_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ObstacleMap_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Path_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Path_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PointCloudXYZI_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PointCloudXYZI_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PointCloudXYZI_PointXYZI_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PointCloudXYZI_PointXYZI_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PointCloudXYZRGB_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PointCloudXYZRGB_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PointCloudXYZRGB_PointXYZRGB_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PointCloudXYZRGB_PointXYZRGB_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RGBDImage_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RGBDImage_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Waypoint_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Waypoint_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_pixhawk_2eproto() {
+  protobuf_AddDesc_pixhawk_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "pixhawk.proto");
+  GOOGLE_CHECK(file != NULL);
+  HeaderInfo_descriptor_ = file->message_type(0);
+  static const int HeaderInfo_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderInfo, source_sysid_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderInfo, source_compid_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderInfo, timestamp_),
+  };
+  HeaderInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      HeaderInfo_descriptor_,
+      HeaderInfo::default_instance_,
+      HeaderInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(HeaderInfo));
+  GLOverlay_descriptor_ = file->message_type(1);
+  static const int GLOverlay_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, header_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, coordinateframetype_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, origin_x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, origin_y_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, origin_z_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, data_),
+  };
+  GLOverlay_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GLOverlay_descriptor_,
+      GLOverlay::default_instance_,
+      GLOverlay_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GLOverlay, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GLOverlay));
+  GLOverlay_CoordinateFrameType_descriptor_ = GLOverlay_descriptor_->enum_type(0);
+  GLOverlay_Mode_descriptor_ = GLOverlay_descriptor_->enum_type(1);
+  GLOverlay_Identifier_descriptor_ = GLOverlay_descriptor_->enum_type(2);
+  Obstacle_descriptor_ = file->message_type(2);
+  static const int Obstacle_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, y_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, z_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, length_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, width_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, height_),
+  };
+  Obstacle_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Obstacle_descriptor_,
+      Obstacle::default_instance_,
+      Obstacle_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Obstacle, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Obstacle));
+  ObstacleList_descriptor_ = file->message_type(3);
+  static const int ObstacleList_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleList, header_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleList, obstacles_),
+  };
+  ObstacleList_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ObstacleList_descriptor_,
+      ObstacleList::default_instance_,
+      ObstacleList_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleList, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleList, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ObstacleList));
+  ObstacleMap_descriptor_ = file->message_type(4);
+  static const int ObstacleMap_offsets_[10] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, header_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, resolution_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, rows_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, cols_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, mapr0_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, mapc0_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, arrayr0_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, arrayc0_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, data_),
+  };
+  ObstacleMap_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ObstacleMap_descriptor_,
+      ObstacleMap::default_instance_,
+      ObstacleMap_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObstacleMap, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ObstacleMap));
+  Path_descriptor_ = file->message_type(5);
+  static const int Path_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Path, header_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Path, waypoints_),
+  };
+  Path_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Path_descriptor_,
+      Path::default_instance_,
+      Path_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Path, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Path, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Path));
+  PointCloudXYZI_descriptor_ = file->message_type(6);
+  static const int PointCloudXYZI_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI, header_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI, points_),
+  };
+  PointCloudXYZI_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PointCloudXYZI_descriptor_,
+      PointCloudXYZI::default_instance_,
+      PointCloudXYZI_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PointCloudXYZI));
+  PointCloudXYZI_PointXYZI_descriptor_ = PointCloudXYZI_descriptor_->nested_type(0);
+  static const int PointCloudXYZI_PointXYZI_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI_PointXYZI, x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI_PointXYZI, y_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI_PointXYZI, z_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI_PointXYZI, intensity_),
+  };
+  PointCloudXYZI_PointXYZI_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PointCloudXYZI_PointXYZI_descriptor_,
+      PointCloudXYZI_PointXYZI::default_instance_,
+      PointCloudXYZI_PointXYZI_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI_PointXYZI, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZI_PointXYZI, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PointCloudXYZI_PointXYZI));
+  PointCloudXYZRGB_descriptor_ = file->message_type(7);
+  static const int PointCloudXYZRGB_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB, header_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB, points_),
+  };
+  PointCloudXYZRGB_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PointCloudXYZRGB_descriptor_,
+      PointCloudXYZRGB::default_instance_,
+      PointCloudXYZRGB_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PointCloudXYZRGB));
+  PointCloudXYZRGB_PointXYZRGB_descriptor_ = PointCloudXYZRGB_descriptor_->nested_type(0);
+  static const int PointCloudXYZRGB_PointXYZRGB_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB_PointXYZRGB, x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB_PointXYZRGB, y_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB_PointXYZRGB, z_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB_PointXYZRGB, rgb_),
+  };
+  PointCloudXYZRGB_PointXYZRGB_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PointCloudXYZRGB_PointXYZRGB_descriptor_,
+      PointCloudXYZRGB_PointXYZRGB::default_instance_,
+      PointCloudXYZRGB_PointXYZRGB_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB_PointXYZRGB, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PointCloudXYZRGB_PointXYZRGB, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PointCloudXYZRGB_PointXYZRGB));
+  RGBDImage_descriptor_ = file->message_type(8);
+  static const int RGBDImage_offsets_[21] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, header_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, cols_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, rows_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, step1_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, type1_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, imagedata1_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, step2_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, type2_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, imagedata2_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, camera_config_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, camera_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, roll_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, pitch_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, yaw_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, lon_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, lat_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, alt_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, ground_x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, ground_y_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, ground_z_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, camera_matrix_),
+  };
+  RGBDImage_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RGBDImage_descriptor_,
+      RGBDImage::default_instance_,
+      RGBDImage_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RGBDImage, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RGBDImage));
+  Waypoint_descriptor_ = file->message_type(9);
+  static const int Waypoint_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, y_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, z_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, roll_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, pitch_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, yaw_),
+  };
+  Waypoint_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Waypoint_descriptor_,
+      Waypoint::default_instance_,
+      Waypoint_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Waypoint, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Waypoint));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_pixhawk_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    HeaderInfo_descriptor_, &HeaderInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GLOverlay_descriptor_, &GLOverlay::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Obstacle_descriptor_, &Obstacle::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ObstacleList_descriptor_, &ObstacleList::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ObstacleMap_descriptor_, &ObstacleMap::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Path_descriptor_, &Path::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PointCloudXYZI_descriptor_, &PointCloudXYZI::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PointCloudXYZI_PointXYZI_descriptor_, &PointCloudXYZI_PointXYZI::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PointCloudXYZRGB_descriptor_, &PointCloudXYZRGB::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PointCloudXYZRGB_PointXYZRGB_descriptor_, &PointCloudXYZRGB_PointXYZRGB::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RGBDImage_descriptor_, &RGBDImage::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Waypoint_descriptor_, &Waypoint::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_pixhawk_2eproto() {
+  delete HeaderInfo::default_instance_;
+  delete HeaderInfo_reflection_;
+  delete GLOverlay::default_instance_;
+  delete GLOverlay_reflection_;
+  delete Obstacle::default_instance_;
+  delete Obstacle_reflection_;
+  delete ObstacleList::default_instance_;
+  delete ObstacleList_reflection_;
+  delete ObstacleMap::default_instance_;
+  delete ObstacleMap_reflection_;
+  delete Path::default_instance_;
+  delete Path_reflection_;
+  delete PointCloudXYZI::default_instance_;
+  delete PointCloudXYZI_reflection_;
+  delete PointCloudXYZI_PointXYZI::default_instance_;
+  delete PointCloudXYZI_PointXYZI_reflection_;
+  delete PointCloudXYZRGB::default_instance_;
+  delete PointCloudXYZRGB_reflection_;
+  delete PointCloudXYZRGB_PointXYZRGB::default_instance_;
+  delete PointCloudXYZRGB_PointXYZRGB_reflection_;
+  delete RGBDImage::default_instance_;
+  delete RGBDImage_reflection_;
+  delete Waypoint::default_instance_;
+  delete Waypoint_reflection_;
+}
+
+void protobuf_AddDesc_pixhawk_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\rpixhawk.proto\022\002px\"L\n\nHeaderInfo\022\024\n\014sou"
+    "rce_sysid\030\001 \002(\005\022\025\n\rsource_compid\030\002 \002(\005\022\021"
+    "\n\ttimestamp\030\003 \002(\001\"\377\004\n\tGLOverlay\022\036\n\006heade"
+    "r\030\001 \002(\0132\016.px.HeaderInfo\022\014\n\004name\030\002 \001(\t\022>\n"
+    "\023coordinateFrameType\030\003 \001(\0162!.px.GLOverla"
+    "y.CoordinateFrameType\022\020\n\010origin_x\030\004 \001(\001\022"
+    "\020\n\010origin_y\030\005 \001(\001\022\020\n\010origin_z\030\006 \001(\001\022\014\n\004d"
+    "ata\030\007 \001(\014\",\n\023CoordinateFrameType\022\n\n\006GLOB"
+    "AL\020\000\022\t\n\005LOCAL\020\001\"\333\001\n\004Mode\022\n\n\006POINTS\020\000\022\t\n\005"
+    "LINES\020\001\022\016\n\nLINE_STRIP\020\002\022\r\n\tLINE_LOOP\020\003\022\r"
+    "\n\tTRIANGLES\020\004\022\022\n\016TRIANGLE_STRIP\020\005\022\020\n\014TRI"
+    "ANGLE_FAN\020\006\022\t\n\005QUADS\020\007\022\016\n\nQUAD_STRIP\020\010\022\013"
+    "\n\007POLYGON\020\t\022\020\n\014SOLID_CIRCLE\020\n\022\017\n\013WIRE_CI"
+    "RCLE\020\013\022\016\n\nSOLID_CUBE\020\014\022\r\n\tWIRE_CUBE\020\r\"\263\001"
+    "\n\nIdentifier\022\007\n\003END\020\016\022\014\n\010VERTEX2F\020\017\022\014\n\010V"
+    "ERTEX3F\020\020\022\013\n\007ROTATEF\020\021\022\016\n\nTRANSLATEF\020\022\022\n"
+    "\n\006SCALEF\020\023\022\017\n\013PUSH_MATRIX\020\024\022\016\n\nPOP_MATRI"
+    "X\020\025\022\013\n\007COLOR3F\020\026\022\013\n\007COLOR4F\020\027\022\r\n\tPOINTSI"
+    "ZE\020\030\022\r\n\tLINEWIDTH\020\031\"Z\n\010Obstacle\022\t\n\001x\030\001 \001"
+    "(\002\022\t\n\001y\030\002 \001(\002\022\t\n\001z\030\003 \001(\002\022\016\n\006length\030\004 \001(\002"
+    "\022\r\n\005width\030\005 \001(\002\022\016\n\006height\030\006 \001(\002\"O\n\014Obsta"
+    "cleList\022\036\n\006header\030\001 \002(\0132\016.px.HeaderInfo\022"
+    "\037\n\tobstacles\030\002 \003(\0132\014.px.Obstacle\"\271\001\n\013Obs"
+    "tacleMap\022\036\n\006header\030\001 \002(\0132\016.px.HeaderInfo"
+    "\022\014\n\004type\030\002 \002(\005\022\022\n\nresolution\030\003 \001(\002\022\014\n\004ro"
+    "ws\030\004 \001(\005\022\014\n\004cols\030\005 \001(\005\022\r\n\005mapR0\030\006 \001(\005\022\r\n"
+    "\005mapC0\030\007 \001(\005\022\017\n\007arrayR0\030\010 \001(\005\022\017\n\007arrayC0"
+    "\030\t \001(\005\022\014\n\004data\030\n \001(\014\"G\n\004Path\022\036\n\006header\030\001"
+    " \002(\0132\016.px.HeaderInfo\022\037\n\twaypoints\030\002 \003(\0132"
+    "\014.px.Waypoint\"\237\001\n\016PointCloudXYZI\022\036\n\006head"
+    "er\030\001 \002(\0132\016.px.HeaderInfo\022,\n\006points\030\002 \003(\013"
+    "2\034.px.PointCloudXYZI.PointXYZI\032\?\n\tPointX"
+    "YZI\022\t\n\001x\030\001 \002(\002\022\t\n\001y\030\002 \002(\002\022\t\n\001z\030\003 \002(\002\022\021\n\t"
+    "intensity\030\004 \002(\002\"\241\001\n\020PointCloudXYZRGB\022\036\n\006"
+    "header\030\001 \002(\0132\016.px.HeaderInfo\0220\n\006points\030\002"
+    " \003(\0132 .px.PointCloudXYZRGB.PointXYZRGB\032;"
+    "\n\013PointXYZRGB\022\t\n\001x\030\001 \002(\002\022\t\n\001y\030\002 \002(\002\022\t\n\001z"
+    "\030\003 \002(\002\022\013\n\003rgb\030\004 \002(\002\"\365\002\n\tRGBDImage\022\036\n\006hea"
+    "der\030\001 \002(\0132\016.px.HeaderInfo\022\014\n\004cols\030\002 \002(\r\022"
+    "\014\n\004rows\030\003 \002(\r\022\r\n\005step1\030\004 \002(\r\022\r\n\005type1\030\005 "
+    "\002(\r\022\022\n\nimageData1\030\006 \002(\014\022\r\n\005step2\030\007 \002(\r\022\r"
+    "\n\005type2\030\010 \002(\r\022\022\n\nimageData2\030\t \002(\014\022\025\n\rcam"
+    "era_config\030\n \001(\r\022\023\n\013camera_type\030\013 \001(\r\022\014\n"
+    "\004roll\030\014 \001(\002\022\r\n\005pitch\030\r \001(\002\022\013\n\003yaw\030\016 \001(\002\022"
+    "\013\n\003lon\030\017 \001(\002\022\013\n\003lat\030\020 \001(\002\022\013\n\003alt\030\021 \001(\002\022\020"
+    "\n\010ground_x\030\022 \001(\002\022\020\n\010ground_y\030\023 \001(\002\022\020\n\010gr"
+    "ound_z\030\024 \001(\002\022\025\n\rcamera_matrix\030\025 \003(\002\"U\n\010W"
+    "aypoint\022\t\n\001x\030\001 \002(\001\022\t\n\001y\030\002 \002(\001\022\t\n\001z\030\003 \001(\001"
+    "\022\014\n\004roll\030\004 \001(\001\022\r\n\005pitch\030\005 \001(\001\022\013\n\003yaw\030\006 \001"
+    "(\001", 1962);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "pixhawk.proto", &protobuf_RegisterTypes);
+  HeaderInfo::default_instance_ = new HeaderInfo();
+  GLOverlay::default_instance_ = new GLOverlay();
+  Obstacle::default_instance_ = new Obstacle();
+  ObstacleList::default_instance_ = new ObstacleList();
+  ObstacleMap::default_instance_ = new ObstacleMap();
+  Path::default_instance_ = new Path();
+  PointCloudXYZI::default_instance_ = new PointCloudXYZI();
+  PointCloudXYZI_PointXYZI::default_instance_ = new PointCloudXYZI_PointXYZI();
+  PointCloudXYZRGB::default_instance_ = new PointCloudXYZRGB();
+  PointCloudXYZRGB_PointXYZRGB::default_instance_ = new PointCloudXYZRGB_PointXYZRGB();
+  RGBDImage::default_instance_ = new RGBDImage();
+  Waypoint::default_instance_ = new Waypoint();
+  HeaderInfo::default_instance_->InitAsDefaultInstance();
+  GLOverlay::default_instance_->InitAsDefaultInstance();
+  Obstacle::default_instance_->InitAsDefaultInstance();
+  ObstacleList::default_instance_->InitAsDefaultInstance();
+  ObstacleMap::default_instance_->InitAsDefaultInstance();
+  Path::default_instance_->InitAsDefaultInstance();
+  PointCloudXYZI::default_instance_->InitAsDefaultInstance();
+  PointCloudXYZI_PointXYZI::default_instance_->InitAsDefaultInstance();
+  PointCloudXYZRGB::default_instance_->InitAsDefaultInstance();
+  PointCloudXYZRGB_PointXYZRGB::default_instance_->InitAsDefaultInstance();
+  RGBDImage::default_instance_->InitAsDefaultInstance();
+  Waypoint::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pixhawk_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_pixhawk_2eproto {
+  StaticDescriptorInitializer_pixhawk_2eproto() {
+    protobuf_AddDesc_pixhawk_2eproto();
+  }
+} static_descriptor_initializer_pixhawk_2eproto_;
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int HeaderInfo::kSourceSysidFieldNumber;
+const int HeaderInfo::kSourceCompidFieldNumber;
+const int HeaderInfo::kTimestampFieldNumber;
+#endif  // !_MSC_VER
+
+HeaderInfo::HeaderInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void HeaderInfo::InitAsDefaultInstance() {
+}
+
+HeaderInfo::HeaderInfo(const HeaderInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void HeaderInfo::SharedCtor() {
+  _cached_size_ = 0;
+  source_sysid_ = 0;
+  source_compid_ = 0;
+  timestamp_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+HeaderInfo::~HeaderInfo() {
+  SharedDtor();
+}
+
+void HeaderInfo::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void HeaderInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* HeaderInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return HeaderInfo_descriptor_;
+}
+
+const HeaderInfo& HeaderInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+HeaderInfo* HeaderInfo::default_instance_ = NULL;
+
+HeaderInfo* HeaderInfo::New() const {
+  return new HeaderInfo;
+}
+
+void HeaderInfo::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    source_sysid_ = 0;
+    source_compid_ = 0;
+    timestamp_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool HeaderInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required int32 source_sysid = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &source_sysid_)));
+          set_has_source_sysid();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_source_compid;
+        break;
+      }
+      
+      // required int32 source_compid = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_source_compid:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &source_compid_)));
+          set_has_source_compid();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(25)) goto parse_timestamp;
+        break;
+      }
+      
+      // required double timestamp = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_timestamp:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &timestamp_)));
+          set_has_timestamp();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void HeaderInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required int32 source_sysid = 1;
+  if (has_source_sysid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->source_sysid(), output);
+  }
+  
+  // required int32 source_compid = 2;
+  if (has_source_compid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->source_compid(), output);
+  }
+  
+  // required double timestamp = 3;
+  if (has_timestamp()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->timestamp(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* HeaderInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required int32 source_sysid = 1;
+  if (has_source_sysid()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->source_sysid(), target);
+  }
+  
+  // required int32 source_compid = 2;
+  if (has_source_compid()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->source_compid(), target);
+  }
+  
+  // required double timestamp = 3;
+  if (has_timestamp()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->timestamp(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int HeaderInfo::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required int32 source_sysid = 1;
+    if (has_source_sysid()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->source_sysid());
+    }
+    
+    // required int32 source_compid = 2;
+    if (has_source_compid()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->source_compid());
+    }
+    
+    // required double timestamp = 3;
+    if (has_timestamp()) {
+      total_size += 1 + 8;
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void HeaderInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const HeaderInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const HeaderInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void HeaderInfo::MergeFrom(const HeaderInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_source_sysid()) {
+      set_source_sysid(from.source_sysid());
+    }
+    if (from.has_source_compid()) {
+      set_source_compid(from.source_compid());
+    }
+    if (from.has_timestamp()) {
+      set_timestamp(from.timestamp());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void HeaderInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void HeaderInfo::CopyFrom(const HeaderInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HeaderInfo::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+  
+  return true;
+}
+
+void HeaderInfo::Swap(HeaderInfo* other) {
+  if (other != this) {
+    std::swap(source_sysid_, other->source_sysid_);
+    std::swap(source_compid_, other->source_compid_);
+    std::swap(timestamp_, other->timestamp_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata HeaderInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = HeaderInfo_descriptor_;
+  metadata.reflection = HeaderInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::google::protobuf::EnumDescriptor* GLOverlay_CoordinateFrameType_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GLOverlay_CoordinateFrameType_descriptor_;
+}
+bool GLOverlay_CoordinateFrameType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const GLOverlay_CoordinateFrameType GLOverlay::GLOBAL;
+const GLOverlay_CoordinateFrameType GLOverlay::LOCAL;
+const GLOverlay_CoordinateFrameType GLOverlay::CoordinateFrameType_MIN;
+const GLOverlay_CoordinateFrameType GLOverlay::CoordinateFrameType_MAX;
+const int GLOverlay::CoordinateFrameType_ARRAYSIZE;
+#endif  // _MSC_VER
+const ::google::protobuf::EnumDescriptor* GLOverlay_Mode_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GLOverlay_Mode_descriptor_;
+}
+bool GLOverlay_Mode_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const GLOverlay_Mode GLOverlay::POINTS;
+const GLOverlay_Mode GLOverlay::LINES;
+const GLOverlay_Mode GLOverlay::LINE_STRIP;
+const GLOverlay_Mode GLOverlay::LINE_LOOP;
+const GLOverlay_Mode GLOverlay::TRIANGLES;
+const GLOverlay_Mode GLOverlay::TRIANGLE_STRIP;
+const GLOverlay_Mode GLOverlay::TRIANGLE_FAN;
+const GLOverlay_Mode GLOverlay::QUADS;
+const GLOverlay_Mode GLOverlay::QUAD_STRIP;
+const GLOverlay_Mode GLOverlay::POLYGON;
+const GLOverlay_Mode GLOverlay::SOLID_CIRCLE;
+const GLOverlay_Mode GLOverlay::WIRE_CIRCLE;
+const GLOverlay_Mode GLOverlay::SOLID_CUBE;
+const GLOverlay_Mode GLOverlay::WIRE_CUBE;
+const GLOverlay_Mode GLOverlay::Mode_MIN;
+const GLOverlay_Mode GLOverlay::Mode_MAX;
+const int GLOverlay::Mode_ARRAYSIZE;
+#endif  // _MSC_VER
+const ::google::protobuf::EnumDescriptor* GLOverlay_Identifier_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GLOverlay_Identifier_descriptor_;
+}
+bool GLOverlay_Identifier_IsValid(int value) {
+  switch(value) {
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+    case 25:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const GLOverlay_Identifier GLOverlay::END;
+const GLOverlay_Identifier GLOverlay::VERTEX2F;
+const GLOverlay_Identifier GLOverlay::VERTEX3F;
+const GLOverlay_Identifier GLOverlay::ROTATEF;
+const GLOverlay_Identifier GLOverlay::TRANSLATEF;
+const GLOverlay_Identifier GLOverlay::SCALEF;
+const GLOverlay_Identifier GLOverlay::PUSH_MATRIX;
+const GLOverlay_Identifier GLOverlay::POP_MATRIX;
+const GLOverlay_Identifier GLOverlay::COLOR3F;
+const GLOverlay_Identifier GLOverlay::COLOR4F;
+const GLOverlay_Identifier GLOverlay::POINTSIZE;
+const GLOverlay_Identifier GLOverlay::LINEWIDTH;
+const GLOverlay_Identifier GLOverlay::Identifier_MIN;
+const GLOverlay_Identifier GLOverlay::Identifier_MAX;
+const int GLOverlay::Identifier_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int GLOverlay::kHeaderFieldNumber;
+const int GLOverlay::kNameFieldNumber;
+const int GLOverlay::kCoordinateFrameTypeFieldNumber;
+const int GLOverlay::kOriginXFieldNumber;
+const int GLOverlay::kOriginYFieldNumber;
+const int GLOverlay::kOriginZFieldNumber;
+const int GLOverlay::kDataFieldNumber;
+#endif  // !_MSC_VER
+
+GLOverlay::GLOverlay()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void GLOverlay::InitAsDefaultInstance() {
+  header_ = const_cast< ::px::HeaderInfo*>(&::px::HeaderInfo::default_instance());
+}
+
+GLOverlay::GLOverlay(const GLOverlay& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void GLOverlay::SharedCtor() {
+  _cached_size_ = 0;
+  header_ = NULL;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  coordinateframetype_ = 0;
+  origin_x_ = 0;
+  origin_y_ = 0;
+  origin_z_ = 0;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GLOverlay::~GLOverlay() {
+  SharedDtor();
+}
+
+void GLOverlay::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    delete name_;
+  }
+  if (data_ != &::google::protobuf::internal::kEmptyString) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+    delete header_;
+  }
+}
+
+void GLOverlay::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GLOverlay::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GLOverlay_descriptor_;
+}
+
+const GLOverlay& GLOverlay::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+GLOverlay* GLOverlay::default_instance_ = NULL;
+
+GLOverlay* GLOverlay::New() const {
+  return new GLOverlay;
+}
+
+void GLOverlay::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_header()) {
+      if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::kEmptyString) {
+        name_->clear();
+      }
+    }
+    coordinateframetype_ = 0;
+    origin_x_ = 0;
+    origin_y_ = 0;
+    origin_z_ = 0;
+    if (has_data()) {
+      if (data_ != &::google::protobuf::internal::kEmptyString) {
+        data_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GLOverlay::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .px.HeaderInfo header = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_header()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+      
+      // optional string name = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(24)) goto parse_coordinateFrameType;
+        break;
+      }
+      
+      // optional .px.GLOverlay.CoordinateFrameType coordinateFrameType = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_coordinateFrameType:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::px::GLOverlay_CoordinateFrameType_IsValid(value)) {
+            set_coordinateframetype(static_cast< ::px::GLOverlay_CoordinateFrameType >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(3, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(33)) goto parse_origin_x;
+        break;
+      }
+      
+      // optional double origin_x = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_origin_x:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &origin_x_)));
+          set_has_origin_x();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(41)) goto parse_origin_y;
+        break;
+      }
+      
+      // optional double origin_y = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_origin_y:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &origin_y_)));
+          set_has_origin_y();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(49)) goto parse_origin_z;
+        break;
+      }
+      
+      // optional double origin_z = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_origin_z:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &origin_z_)));
+          set_has_origin_z();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(58)) goto parse_data;
+        break;
+      }
+      
+      // optional bytes data = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void GLOverlay::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->header(), output);
+  }
+  
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->name(), output);
+  }
+  
+  // optional .px.GLOverlay.CoordinateFrameType coordinateFrameType = 3;
+  if (has_coordinateframetype()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->coordinateframetype(), output);
+  }
+  
+  // optional double origin_x = 4;
+  if (has_origin_x()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(4, this->origin_x(), output);
+  }
+  
+  // optional double origin_y = 5;
+  if (has_origin_y()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(5, this->origin_y(), output);
+  }
+  
+  // optional double origin_z = 6;
+  if (has_origin_z()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(6, this->origin_z(), output);
+  }
+  
+  // optional bytes data = 7;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      7, this->data(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* GLOverlay::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->header(), target);
+  }
+  
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+  
+  // optional .px.GLOverlay.CoordinateFrameType coordinateFrameType = 3;
+  if (has_coordinateframetype()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->coordinateframetype(), target);
+  }
+  
+  // optional double origin_x = 4;
+  if (has_origin_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(4, this->origin_x(), target);
+  }
+  
+  // optional double origin_y = 5;
+  if (has_origin_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(5, this->origin_y(), target);
+  }
+  
+  // optional double origin_z = 6;
+  if (has_origin_z()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(6, this->origin_z(), target);
+  }
+  
+  // optional bytes data = 7;
+  if (has_data()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        7, this->data(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int GLOverlay::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .px.HeaderInfo header = 1;
+    if (has_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->header());
+    }
+    
+    // optional string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+    
+    // optional .px.GLOverlay.CoordinateFrameType coordinateFrameType = 3;
+    if (has_coordinateframetype()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->coordinateframetype());
+    }
+    
+    // optional double origin_x = 4;
+    if (has_origin_x()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double origin_y = 5;
+    if (has_origin_y()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double origin_z = 6;
+    if (has_origin_z()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional bytes data = 7;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GLOverlay::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GLOverlay* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GLOverlay*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GLOverlay::MergeFrom(const GLOverlay& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_header()) {
+      mutable_header()->::px::HeaderInfo::MergeFrom(from.header());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_coordinateframetype()) {
+      set_coordinateframetype(from.coordinateframetype());
+    }
+    if (from.has_origin_x()) {
+      set_origin_x(from.origin_x());
+    }
+    if (from.has_origin_y()) {
+      set_origin_y(from.origin_y());
+    }
+    if (from.has_origin_z()) {
+      set_origin_z(from.origin_z());
+    }
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GLOverlay::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GLOverlay::CopyFrom(const GLOverlay& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GLOverlay::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  if (has_header()) {
+    if (!this->header().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GLOverlay::Swap(GLOverlay* other) {
+  if (other != this) {
+    std::swap(header_, other->header_);
+    std::swap(name_, other->name_);
+    std::swap(coordinateframetype_, other->coordinateframetype_);
+    std::swap(origin_x_, other->origin_x_);
+    std::swap(origin_y_, other->origin_y_);
+    std::swap(origin_z_, other->origin_z_);
+    std::swap(data_, other->data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GLOverlay::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GLOverlay_descriptor_;
+  metadata.reflection = GLOverlay_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Obstacle::kXFieldNumber;
+const int Obstacle::kYFieldNumber;
+const int Obstacle::kZFieldNumber;
+const int Obstacle::kLengthFieldNumber;
+const int Obstacle::kWidthFieldNumber;
+const int Obstacle::kHeightFieldNumber;
+#endif  // !_MSC_VER
+
+Obstacle::Obstacle()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void Obstacle::InitAsDefaultInstance() {
+}
+
+Obstacle::Obstacle(const Obstacle& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void Obstacle::SharedCtor() {
+  _cached_size_ = 0;
+  x_ = 0;
+  y_ = 0;
+  z_ = 0;
+  length_ = 0;
+  width_ = 0;
+  height_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Obstacle::~Obstacle() {
+  SharedDtor();
+}
+
+void Obstacle::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void Obstacle::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Obstacle::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Obstacle_descriptor_;
+}
+
+const Obstacle& Obstacle::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+Obstacle* Obstacle::default_instance_ = NULL;
+
+Obstacle* Obstacle::New() const {
+  return new Obstacle;
+}
+
+void Obstacle::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    x_ = 0;
+    y_ = 0;
+    z_ = 0;
+    length_ = 0;
+    width_ = 0;
+    height_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Obstacle::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional float x = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &x_)));
+          set_has_x();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(21)) goto parse_y;
+        break;
+      }
+      
+      // optional float y = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_y:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &y_)));
+          set_has_y();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(29)) goto parse_z;
+        break;
+      }
+      
+      // optional float z = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_z:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &z_)));
+          set_has_z();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(37)) goto parse_length;
+        break;
+      }
+      
+      // optional float length = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_length:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &length_)));
+          set_has_length();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(45)) goto parse_width;
+        break;
+      }
+      
+      // optional float width = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_width:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &width_)));
+          set_has_width();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(53)) goto parse_height;
+        break;
+      }
+      
+      // optional float height = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_height:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &height_)));
+          set_has_height();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void Obstacle::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional float x = 1;
+  if (has_x()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
+  }
+  
+  // optional float y = 2;
+  if (has_y()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
+  }
+  
+  // optional float z = 3;
+  if (has_z()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->z(), output);
+  }
+  
+  // optional float length = 4;
+  if (has_length()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->length(), output);
+  }
+  
+  // optional float width = 5;
+  if (has_width()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->width(), output);
+  }
+  
+  // optional float height = 6;
+  if (has_height()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->height(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* Obstacle::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // optional float x = 1;
+  if (has_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
+  }
+  
+  // optional float y = 2;
+  if (has_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
+  }
+  
+  // optional float z = 3;
+  if (has_z()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->z(), target);
+  }
+  
+  // optional float length = 4;
+  if (has_length()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->length(), target);
+  }
+  
+  // optional float width = 5;
+  if (has_width()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->width(), target);
+  }
+  
+  // optional float height = 6;
+  if (has_height()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->height(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int Obstacle::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional float x = 1;
+    if (has_x()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float y = 2;
+    if (has_y()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float z = 3;
+    if (has_z()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float length = 4;
+    if (has_length()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float width = 5;
+    if (has_width()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float height = 6;
+    if (has_height()) {
+      total_size += 1 + 4;
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Obstacle::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Obstacle* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Obstacle*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Obstacle::MergeFrom(const Obstacle& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_x()) {
+      set_x(from.x());
+    }
+    if (from.has_y()) {
+      set_y(from.y());
+    }
+    if (from.has_z()) {
+      set_z(from.z());
+    }
+    if (from.has_length()) {
+      set_length(from.length());
+    }
+    if (from.has_width()) {
+      set_width(from.width());
+    }
+    if (from.has_height()) {
+      set_height(from.height());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Obstacle::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Obstacle::CopyFrom(const Obstacle& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Obstacle::IsInitialized() const {
+  
+  return true;
+}
+
+void Obstacle::Swap(Obstacle* other) {
+  if (other != this) {
+    std::swap(x_, other->x_);
+    std::swap(y_, other->y_);
+    std::swap(z_, other->z_);
+    std::swap(length_, other->length_);
+    std::swap(width_, other->width_);
+    std::swap(height_, other->height_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Obstacle::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Obstacle_descriptor_;
+  metadata.reflection = Obstacle_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ObstacleList::kHeaderFieldNumber;
+const int ObstacleList::kObstaclesFieldNumber;
+#endif  // !_MSC_VER
+
+ObstacleList::ObstacleList()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ObstacleList::InitAsDefaultInstance() {
+  header_ = const_cast< ::px::HeaderInfo*>(&::px::HeaderInfo::default_instance());
+}
+
+ObstacleList::ObstacleList(const ObstacleList& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ObstacleList::SharedCtor() {
+  _cached_size_ = 0;
+  header_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ObstacleList::~ObstacleList() {
+  SharedDtor();
+}
+
+void ObstacleList::SharedDtor() {
+  if (this != default_instance_) {
+    delete header_;
+  }
+}
+
+void ObstacleList::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ObstacleList::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ObstacleList_descriptor_;
+}
+
+const ObstacleList& ObstacleList::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+ObstacleList* ObstacleList::default_instance_ = NULL;
+
+ObstacleList* ObstacleList::New() const {
+  return new ObstacleList;
+}
+
+void ObstacleList::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_header()) {
+      if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+    }
+  }
+  obstacles_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ObstacleList::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .px.HeaderInfo header = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_header()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_obstacles;
+        break;
+      }
+      
+      // repeated .px.Obstacle obstacles = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_obstacles:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_obstacles()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_obstacles;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ObstacleList::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->header(), output);
+  }
+  
+  // repeated .px.Obstacle obstacles = 2;
+  for (int i = 0; i < this->obstacles_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->obstacles(i), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ObstacleList::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->header(), target);
+  }
+  
+  // repeated .px.Obstacle obstacles = 2;
+  for (int i = 0; i < this->obstacles_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->obstacles(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ObstacleList::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .px.HeaderInfo header = 1;
+    if (has_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->header());
+    }
+    
+  }
+  // repeated .px.Obstacle obstacles = 2;
+  total_size += 1 * this->obstacles_size();
+  for (int i = 0; i < this->obstacles_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->obstacles(i));
+  }
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ObstacleList::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ObstacleList* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ObstacleList*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ObstacleList::MergeFrom(const ObstacleList& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  obstacles_.MergeFrom(from.obstacles_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_header()) {
+      mutable_header()->::px::HeaderInfo::MergeFrom(from.header());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ObstacleList::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ObstacleList::CopyFrom(const ObstacleList& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ObstacleList::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  if (has_header()) {
+    if (!this->header().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ObstacleList::Swap(ObstacleList* other) {
+  if (other != this) {
+    std::swap(header_, other->header_);
+    obstacles_.Swap(&other->obstacles_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ObstacleList::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ObstacleList_descriptor_;
+  metadata.reflection = ObstacleList_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ObstacleMap::kHeaderFieldNumber;
+const int ObstacleMap::kTypeFieldNumber;
+const int ObstacleMap::kResolutionFieldNumber;
+const int ObstacleMap::kRowsFieldNumber;
+const int ObstacleMap::kColsFieldNumber;
+const int ObstacleMap::kMapR0FieldNumber;
+const int ObstacleMap::kMapC0FieldNumber;
+const int ObstacleMap::kArrayR0FieldNumber;
+const int ObstacleMap::kArrayC0FieldNumber;
+const int ObstacleMap::kDataFieldNumber;
+#endif  // !_MSC_VER
+
+ObstacleMap::ObstacleMap()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ObstacleMap::InitAsDefaultInstance() {
+  header_ = const_cast< ::px::HeaderInfo*>(&::px::HeaderInfo::default_instance());
+}
+
+ObstacleMap::ObstacleMap(const ObstacleMap& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ObstacleMap::SharedCtor() {
+  _cached_size_ = 0;
+  header_ = NULL;
+  type_ = 0;
+  resolution_ = 0;
+  rows_ = 0;
+  cols_ = 0;
+  mapr0_ = 0;
+  mapc0_ = 0;
+  arrayr0_ = 0;
+  arrayc0_ = 0;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ObstacleMap::~ObstacleMap() {
+  SharedDtor();
+}
+
+void ObstacleMap::SharedDtor() {
+  if (data_ != &::google::protobuf::internal::kEmptyString) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+    delete header_;
+  }
+}
+
+void ObstacleMap::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ObstacleMap::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ObstacleMap_descriptor_;
+}
+
+const ObstacleMap& ObstacleMap::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+ObstacleMap* ObstacleMap::default_instance_ = NULL;
+
+ObstacleMap* ObstacleMap::New() const {
+  return new ObstacleMap;
+}
+
+void ObstacleMap::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_header()) {
+      if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+    }
+    type_ = 0;
+    resolution_ = 0;
+    rows_ = 0;
+    cols_ = 0;
+    mapr0_ = 0;
+    mapc0_ = 0;
+    arrayr0_ = 0;
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    arrayc0_ = 0;
+    if (has_data()) {
+      if (data_ != &::google::protobuf::internal::kEmptyString) {
+        data_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ObstacleMap::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .px.HeaderInfo header = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_header()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_type;
+        break;
+      }
+      
+      // required int32 type = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_type:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &type_)));
+          set_has_type();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(29)) goto parse_resolution;
+        break;
+      }
+      
+      // optional float resolution = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_resolution:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &resolution_)));
+          set_has_resolution();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(32)) goto parse_rows;
+        break;
+      }
+      
+      // optional int32 rows = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_rows:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &rows_)));
+          set_has_rows();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_cols;
+        break;
+      }
+      
+      // optional int32 cols = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_cols:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &cols_)));
+          set_has_cols();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(48)) goto parse_mapR0;
+        break;
+      }
+      
+      // optional int32 mapR0 = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_mapR0:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &mapr0_)));
+          set_has_mapr0();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_mapC0;
+        break;
+      }
+      
+      // optional int32 mapC0 = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_mapC0:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &mapc0_)));
+          set_has_mapc0();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(64)) goto parse_arrayR0;
+        break;
+      }
+      
+      // optional int32 arrayR0 = 8;
+      case 8: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_arrayR0:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &arrayr0_)));
+          set_has_arrayr0();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(72)) goto parse_arrayC0;
+        break;
+      }
+      
+      // optional int32 arrayC0 = 9;
+      case 9: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_arrayC0:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &arrayc0_)));
+          set_has_arrayc0();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(82)) goto parse_data;
+        break;
+      }
+      
+      // optional bytes data = 10;
+      case 10: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ObstacleMap::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->header(), output);
+  }
+  
+  // required int32 type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->type(), output);
+  }
+  
+  // optional float resolution = 3;
+  if (has_resolution()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->resolution(), output);
+  }
+  
+  // optional int32 rows = 4;
+  if (has_rows()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->rows(), output);
+  }
+  
+  // optional int32 cols = 5;
+  if (has_cols()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->cols(), output);
+  }
+  
+  // optional int32 mapR0 = 6;
+  if (has_mapr0()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->mapr0(), output);
+  }
+  
+  // optional int32 mapC0 = 7;
+  if (has_mapc0()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->mapc0(), output);
+  }
+  
+  // optional int32 arrayR0 = 8;
+  if (has_arrayr0()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->arrayr0(), output);
+  }
+  
+  // optional int32 arrayC0 = 9;
+  if (has_arrayc0()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->arrayc0(), output);
+  }
+  
+  // optional bytes data = 10;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      10, this->data(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ObstacleMap::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->header(), target);
+  }
+  
+  // required int32 type = 2;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->type(), target);
+  }
+  
+  // optional float resolution = 3;
+  if (has_resolution()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->resolution(), target);
+  }
+  
+  // optional int32 rows = 4;
+  if (has_rows()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->rows(), target);
+  }
+  
+  // optional int32 cols = 5;
+  if (has_cols()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->cols(), target);
+  }
+  
+  // optional int32 mapR0 = 6;
+  if (has_mapr0()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->mapr0(), target);
+  }
+  
+  // optional int32 mapC0 = 7;
+  if (has_mapc0()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->mapc0(), target);
+  }
+  
+  // optional int32 arrayR0 = 8;
+  if (has_arrayr0()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->arrayr0(), target);
+  }
+  
+  // optional int32 arrayC0 = 9;
+  if (has_arrayc0()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->arrayc0(), target);
+  }
+  
+  // optional bytes data = 10;
+  if (has_data()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        10, this->data(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ObstacleMap::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .px.HeaderInfo header = 1;
+    if (has_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->header());
+    }
+    
+    // required int32 type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->type());
+    }
+    
+    // optional float resolution = 3;
+    if (has_resolution()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional int32 rows = 4;
+    if (has_rows()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->rows());
+    }
+    
+    // optional int32 cols = 5;
+    if (has_cols()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->cols());
+    }
+    
+    // optional int32 mapR0 = 6;
+    if (has_mapr0()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->mapr0());
+    }
+    
+    // optional int32 mapC0 = 7;
+    if (has_mapc0()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->mapc0());
+    }
+    
+    // optional int32 arrayR0 = 8;
+    if (has_arrayr0()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->arrayr0());
+    }
+    
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional int32 arrayC0 = 9;
+    if (has_arrayc0()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->arrayc0());
+    }
+    
+    // optional bytes data = 10;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ObstacleMap::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ObstacleMap* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ObstacleMap*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ObstacleMap::MergeFrom(const ObstacleMap& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_header()) {
+      mutable_header()->::px::HeaderInfo::MergeFrom(from.header());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_resolution()) {
+      set_resolution(from.resolution());
+    }
+    if (from.has_rows()) {
+      set_rows(from.rows());
+    }
+    if (from.has_cols()) {
+      set_cols(from.cols());
+    }
+    if (from.has_mapr0()) {
+      set_mapr0(from.mapr0());
+    }
+    if (from.has_mapc0()) {
+      set_mapc0(from.mapc0());
+    }
+    if (from.has_arrayr0()) {
+      set_arrayr0(from.arrayr0());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_arrayc0()) {
+      set_arrayc0(from.arrayc0());
+    }
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ObstacleMap::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ObstacleMap::CopyFrom(const ObstacleMap& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ObstacleMap::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  if (has_header()) {
+    if (!this->header().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ObstacleMap::Swap(ObstacleMap* other) {
+  if (other != this) {
+    std::swap(header_, other->header_);
+    std::swap(type_, other->type_);
+    std::swap(resolution_, other->resolution_);
+    std::swap(rows_, other->rows_);
+    std::swap(cols_, other->cols_);
+    std::swap(mapr0_, other->mapr0_);
+    std::swap(mapc0_, other->mapc0_);
+    std::swap(arrayr0_, other->arrayr0_);
+    std::swap(arrayc0_, other->arrayc0_);
+    std::swap(data_, other->data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ObstacleMap::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ObstacleMap_descriptor_;
+  metadata.reflection = ObstacleMap_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Path::kHeaderFieldNumber;
+const int Path::kWaypointsFieldNumber;
+#endif  // !_MSC_VER
+
+Path::Path()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void Path::InitAsDefaultInstance() {
+  header_ = const_cast< ::px::HeaderInfo*>(&::px::HeaderInfo::default_instance());
+}
+
+Path::Path(const Path& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void Path::SharedCtor() {
+  _cached_size_ = 0;
+  header_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Path::~Path() {
+  SharedDtor();
+}
+
+void Path::SharedDtor() {
+  if (this != default_instance_) {
+    delete header_;
+  }
+}
+
+void Path::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Path::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Path_descriptor_;
+}
+
+const Path& Path::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+Path* Path::default_instance_ = NULL;
+
+Path* Path::New() const {
+  return new Path;
+}
+
+void Path::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_header()) {
+      if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+    }
+  }
+  waypoints_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Path::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .px.HeaderInfo header = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_header()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_waypoints;
+        break;
+      }
+      
+      // repeated .px.Waypoint waypoints = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_waypoints:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_waypoints()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_waypoints;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void Path::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->header(), output);
+  }
+  
+  // repeated .px.Waypoint waypoints = 2;
+  for (int i = 0; i < this->waypoints_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->waypoints(i), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* Path::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->header(), target);
+  }
+  
+  // repeated .px.Waypoint waypoints = 2;
+  for (int i = 0; i < this->waypoints_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->waypoints(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int Path::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .px.HeaderInfo header = 1;
+    if (has_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->header());
+    }
+    
+  }
+  // repeated .px.Waypoint waypoints = 2;
+  total_size += 1 * this->waypoints_size();
+  for (int i = 0; i < this->waypoints_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->waypoints(i));
+  }
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Path::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Path* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Path*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Path::MergeFrom(const Path& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  waypoints_.MergeFrom(from.waypoints_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_header()) {
+      mutable_header()->::px::HeaderInfo::MergeFrom(from.header());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Path::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Path::CopyFrom(const Path& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Path::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  if (has_header()) {
+    if (!this->header().IsInitialized()) return false;
+  }
+  for (int i = 0; i < waypoints_size(); i++) {
+    if (!this->waypoints(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Path::Swap(Path* other) {
+  if (other != this) {
+    std::swap(header_, other->header_);
+    waypoints_.Swap(&other->waypoints_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Path::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Path_descriptor_;
+  metadata.reflection = Path_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int PointCloudXYZI_PointXYZI::kXFieldNumber;
+const int PointCloudXYZI_PointXYZI::kYFieldNumber;
+const int PointCloudXYZI_PointXYZI::kZFieldNumber;
+const int PointCloudXYZI_PointXYZI::kIntensityFieldNumber;
+#endif  // !_MSC_VER
+
+PointCloudXYZI_PointXYZI::PointCloudXYZI_PointXYZI()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void PointCloudXYZI_PointXYZI::InitAsDefaultInstance() {
+}
+
+PointCloudXYZI_PointXYZI::PointCloudXYZI_PointXYZI(const PointCloudXYZI_PointXYZI& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PointCloudXYZI_PointXYZI::SharedCtor() {
+  _cached_size_ = 0;
+  x_ = 0;
+  y_ = 0;
+  z_ = 0;
+  intensity_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PointCloudXYZI_PointXYZI::~PointCloudXYZI_PointXYZI() {
+  SharedDtor();
+}
+
+void PointCloudXYZI_PointXYZI::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void PointCloudXYZI_PointXYZI::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PointCloudXYZI_PointXYZI::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PointCloudXYZI_PointXYZI_descriptor_;
+}
+
+const PointCloudXYZI_PointXYZI& PointCloudXYZI_PointXYZI::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+PointCloudXYZI_PointXYZI* PointCloudXYZI_PointXYZI::default_instance_ = NULL;
+
+PointCloudXYZI_PointXYZI* PointCloudXYZI_PointXYZI::New() const {
+  return new PointCloudXYZI_PointXYZI;
+}
+
+void PointCloudXYZI_PointXYZI::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    x_ = 0;
+    y_ = 0;
+    z_ = 0;
+    intensity_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PointCloudXYZI_PointXYZI::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required float x = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &x_)));
+          set_has_x();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(21)) goto parse_y;
+        break;
+      }
+      
+      // required float y = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_y:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &y_)));
+          set_has_y();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(29)) goto parse_z;
+        break;
+      }
+      
+      // required float z = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_z:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &z_)));
+          set_has_z();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(37)) goto parse_intensity;
+        break;
+      }
+      
+      // required float intensity = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_intensity:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &intensity_)));
+          set_has_intensity();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PointCloudXYZI_PointXYZI::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required float x = 1;
+  if (has_x()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
+  }
+  
+  // required float y = 2;
+  if (has_y()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
+  }
+  
+  // required float z = 3;
+  if (has_z()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->z(), output);
+  }
+  
+  // required float intensity = 4;
+  if (has_intensity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->intensity(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PointCloudXYZI_PointXYZI::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required float x = 1;
+  if (has_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
+  }
+  
+  // required float y = 2;
+  if (has_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
+  }
+  
+  // required float z = 3;
+  if (has_z()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->z(), target);
+  }
+  
+  // required float intensity = 4;
+  if (has_intensity()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->intensity(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int PointCloudXYZI_PointXYZI::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required float x = 1;
+    if (has_x()) {
+      total_size += 1 + 4;
+    }
+    
+    // required float y = 2;
+    if (has_y()) {
+      total_size += 1 + 4;
+    }
+    
+    // required float z = 3;
+    if (has_z()) {
+      total_size += 1 + 4;
+    }
+    
+    // required float intensity = 4;
+    if (has_intensity()) {
+      total_size += 1 + 4;
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PointCloudXYZI_PointXYZI::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PointCloudXYZI_PointXYZI* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PointCloudXYZI_PointXYZI*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PointCloudXYZI_PointXYZI::MergeFrom(const PointCloudXYZI_PointXYZI& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_x()) {
+      set_x(from.x());
+    }
+    if (from.has_y()) {
+      set_y(from.y());
+    }
+    if (from.has_z()) {
+      set_z(from.z());
+    }
+    if (from.has_intensity()) {
+      set_intensity(from.intensity());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PointCloudXYZI_PointXYZI::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PointCloudXYZI_PointXYZI::CopyFrom(const PointCloudXYZI_PointXYZI& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PointCloudXYZI_PointXYZI::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
+  
+  return true;
+}
+
+void PointCloudXYZI_PointXYZI::Swap(PointCloudXYZI_PointXYZI* other) {
+  if (other != this) {
+    std::swap(x_, other->x_);
+    std::swap(y_, other->y_);
+    std::swap(z_, other->z_);
+    std::swap(intensity_, other->intensity_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PointCloudXYZI_PointXYZI::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PointCloudXYZI_PointXYZI_descriptor_;
+  metadata.reflection = PointCloudXYZI_PointXYZI_reflection_;
+  return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int PointCloudXYZI::kHeaderFieldNumber;
+const int PointCloudXYZI::kPointsFieldNumber;
+#endif  // !_MSC_VER
+
+PointCloudXYZI::PointCloudXYZI()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void PointCloudXYZI::InitAsDefaultInstance() {
+  header_ = const_cast< ::px::HeaderInfo*>(&::px::HeaderInfo::default_instance());
+}
+
+PointCloudXYZI::PointCloudXYZI(const PointCloudXYZI& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PointCloudXYZI::SharedCtor() {
+  _cached_size_ = 0;
+  header_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PointCloudXYZI::~PointCloudXYZI() {
+  SharedDtor();
+}
+
+void PointCloudXYZI::SharedDtor() {
+  if (this != default_instance_) {
+    delete header_;
+  }
+}
+
+void PointCloudXYZI::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PointCloudXYZI::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PointCloudXYZI_descriptor_;
+}
+
+const PointCloudXYZI& PointCloudXYZI::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+PointCloudXYZI* PointCloudXYZI::default_instance_ = NULL;
+
+PointCloudXYZI* PointCloudXYZI::New() const {
+  return new PointCloudXYZI;
+}
+
+void PointCloudXYZI::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_header()) {
+      if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+    }
+  }
+  points_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PointCloudXYZI::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .px.HeaderInfo header = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_header()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_points;
+        break;
+      }
+      
+      // repeated .px.PointCloudXYZI.PointXYZI points = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_points:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_points()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_points;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PointCloudXYZI::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->header(), output);
+  }
+  
+  // repeated .px.PointCloudXYZI.PointXYZI points = 2;
+  for (int i = 0; i < this->points_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->points(i), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PointCloudXYZI::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->header(), target);
+  }
+  
+  // repeated .px.PointCloudXYZI.PointXYZI points = 2;
+  for (int i = 0; i < this->points_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->points(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int PointCloudXYZI::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .px.HeaderInfo header = 1;
+    if (has_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->header());
+    }
+    
+  }
+  // repeated .px.PointCloudXYZI.PointXYZI points = 2;
+  total_size += 1 * this->points_size();
+  for (int i = 0; i < this->points_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->points(i));
+  }
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PointCloudXYZI::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PointCloudXYZI* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PointCloudXYZI*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PointCloudXYZI::MergeFrom(const PointCloudXYZI& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  points_.MergeFrom(from.points_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_header()) {
+      mutable_header()->::px::HeaderInfo::MergeFrom(from.header());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PointCloudXYZI::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PointCloudXYZI::CopyFrom(const PointCloudXYZI& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PointCloudXYZI::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  if (has_header()) {
+    if (!this->header().IsInitialized()) return false;
+  }
+  for (int i = 0; i < points_size(); i++) {
+    if (!this->points(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+void PointCloudXYZI::Swap(PointCloudXYZI* other) {
+  if (other != this) {
+    std::swap(header_, other->header_);
+    points_.Swap(&other->points_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PointCloudXYZI::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PointCloudXYZI_descriptor_;
+  metadata.reflection = PointCloudXYZI_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int PointCloudXYZRGB_PointXYZRGB::kXFieldNumber;
+const int PointCloudXYZRGB_PointXYZRGB::kYFieldNumber;
+const int PointCloudXYZRGB_PointXYZRGB::kZFieldNumber;
+const int PointCloudXYZRGB_PointXYZRGB::kRgbFieldNumber;
+#endif  // !_MSC_VER
+
+PointCloudXYZRGB_PointXYZRGB::PointCloudXYZRGB_PointXYZRGB()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void PointCloudXYZRGB_PointXYZRGB::InitAsDefaultInstance() {
+}
+
+PointCloudXYZRGB_PointXYZRGB::PointCloudXYZRGB_PointXYZRGB(const PointCloudXYZRGB_PointXYZRGB& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PointCloudXYZRGB_PointXYZRGB::SharedCtor() {
+  _cached_size_ = 0;
+  x_ = 0;
+  y_ = 0;
+  z_ = 0;
+  rgb_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PointCloudXYZRGB_PointXYZRGB::~PointCloudXYZRGB_PointXYZRGB() {
+  SharedDtor();
+}
+
+void PointCloudXYZRGB_PointXYZRGB::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void PointCloudXYZRGB_PointXYZRGB::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PointCloudXYZRGB_PointXYZRGB::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PointCloudXYZRGB_PointXYZRGB_descriptor_;
+}
+
+const PointCloudXYZRGB_PointXYZRGB& PointCloudXYZRGB_PointXYZRGB::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+PointCloudXYZRGB_PointXYZRGB* PointCloudXYZRGB_PointXYZRGB::default_instance_ = NULL;
+
+PointCloudXYZRGB_PointXYZRGB* PointCloudXYZRGB_PointXYZRGB::New() const {
+  return new PointCloudXYZRGB_PointXYZRGB;
+}
+
+void PointCloudXYZRGB_PointXYZRGB::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    x_ = 0;
+    y_ = 0;
+    z_ = 0;
+    rgb_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PointCloudXYZRGB_PointXYZRGB::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required float x = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &x_)));
+          set_has_x();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(21)) goto parse_y;
+        break;
+      }
+      
+      // required float y = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_y:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &y_)));
+          set_has_y();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(29)) goto parse_z;
+        break;
+      }
+      
+      // required float z = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_z:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &z_)));
+          set_has_z();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(37)) goto parse_rgb;
+        break;
+      }
+      
+      // required float rgb = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_rgb:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &rgb_)));
+          set_has_rgb();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PointCloudXYZRGB_PointXYZRGB::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required float x = 1;
+  if (has_x()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
+  }
+  
+  // required float y = 2;
+  if (has_y()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
+  }
+  
+  // required float z = 3;
+  if (has_z()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->z(), output);
+  }
+  
+  // required float rgb = 4;
+  if (has_rgb()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->rgb(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PointCloudXYZRGB_PointXYZRGB::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required float x = 1;
+  if (has_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
+  }
+  
+  // required float y = 2;
+  if (has_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
+  }
+  
+  // required float z = 3;
+  if (has_z()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->z(), target);
+  }
+  
+  // required float rgb = 4;
+  if (has_rgb()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->rgb(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int PointCloudXYZRGB_PointXYZRGB::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required float x = 1;
+    if (has_x()) {
+      total_size += 1 + 4;
+    }
+    
+    // required float y = 2;
+    if (has_y()) {
+      total_size += 1 + 4;
+    }
+    
+    // required float z = 3;
+    if (has_z()) {
+      total_size += 1 + 4;
+    }
+    
+    // required float rgb = 4;
+    if (has_rgb()) {
+      total_size += 1 + 4;
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PointCloudXYZRGB_PointXYZRGB::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PointCloudXYZRGB_PointXYZRGB* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PointCloudXYZRGB_PointXYZRGB*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PointCloudXYZRGB_PointXYZRGB::MergeFrom(const PointCloudXYZRGB_PointXYZRGB& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_x()) {
+      set_x(from.x());
+    }
+    if (from.has_y()) {
+      set_y(from.y());
+    }
+    if (from.has_z()) {
+      set_z(from.z());
+    }
+    if (from.has_rgb()) {
+      set_rgb(from.rgb());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PointCloudXYZRGB_PointXYZRGB::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PointCloudXYZRGB_PointXYZRGB::CopyFrom(const PointCloudXYZRGB_PointXYZRGB& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PointCloudXYZRGB_PointXYZRGB::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
+  
+  return true;
+}
+
+void PointCloudXYZRGB_PointXYZRGB::Swap(PointCloudXYZRGB_PointXYZRGB* other) {
+  if (other != this) {
+    std::swap(x_, other->x_);
+    std::swap(y_, other->y_);
+    std::swap(z_, other->z_);
+    std::swap(rgb_, other->rgb_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PointCloudXYZRGB_PointXYZRGB::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PointCloudXYZRGB_PointXYZRGB_descriptor_;
+  metadata.reflection = PointCloudXYZRGB_PointXYZRGB_reflection_;
+  return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int PointCloudXYZRGB::kHeaderFieldNumber;
+const int PointCloudXYZRGB::kPointsFieldNumber;
+#endif  // !_MSC_VER
+
+PointCloudXYZRGB::PointCloudXYZRGB()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void PointCloudXYZRGB::InitAsDefaultInstance() {
+  header_ = const_cast< ::px::HeaderInfo*>(&::px::HeaderInfo::default_instance());
+}
+
+PointCloudXYZRGB::PointCloudXYZRGB(const PointCloudXYZRGB& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PointCloudXYZRGB::SharedCtor() {
+  _cached_size_ = 0;
+  header_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PointCloudXYZRGB::~PointCloudXYZRGB() {
+  SharedDtor();
+}
+
+void PointCloudXYZRGB::SharedDtor() {
+  if (this != default_instance_) {
+    delete header_;
+  }
+}
+
+void PointCloudXYZRGB::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PointCloudXYZRGB::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PointCloudXYZRGB_descriptor_;
+}
+
+const PointCloudXYZRGB& PointCloudXYZRGB::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+PointCloudXYZRGB* PointCloudXYZRGB::default_instance_ = NULL;
+
+PointCloudXYZRGB* PointCloudXYZRGB::New() const {
+  return new PointCloudXYZRGB;
+}
+
+void PointCloudXYZRGB::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_header()) {
+      if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+    }
+  }
+  points_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PointCloudXYZRGB::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .px.HeaderInfo header = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_header()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_points;
+        break;
+      }
+      
+      // repeated .px.PointCloudXYZRGB.PointXYZRGB points = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_points:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_points()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_points;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PointCloudXYZRGB::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->header(), output);
+  }
+  
+  // repeated .px.PointCloudXYZRGB.PointXYZRGB points = 2;
+  for (int i = 0; i < this->points_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->points(i), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PointCloudXYZRGB::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->header(), target);
+  }
+  
+  // repeated .px.PointCloudXYZRGB.PointXYZRGB points = 2;
+  for (int i = 0; i < this->points_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->points(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int PointCloudXYZRGB::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .px.HeaderInfo header = 1;
+    if (has_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->header());
+    }
+    
+  }
+  // repeated .px.PointCloudXYZRGB.PointXYZRGB points = 2;
+  total_size += 1 * this->points_size();
+  for (int i = 0; i < this->points_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->points(i));
+  }
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PointCloudXYZRGB::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PointCloudXYZRGB* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PointCloudXYZRGB*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PointCloudXYZRGB::MergeFrom(const PointCloudXYZRGB& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  points_.MergeFrom(from.points_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_header()) {
+      mutable_header()->::px::HeaderInfo::MergeFrom(from.header());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PointCloudXYZRGB::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PointCloudXYZRGB::CopyFrom(const PointCloudXYZRGB& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PointCloudXYZRGB::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  if (has_header()) {
+    if (!this->header().IsInitialized()) return false;
+  }
+  for (int i = 0; i < points_size(); i++) {
+    if (!this->points(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+void PointCloudXYZRGB::Swap(PointCloudXYZRGB* other) {
+  if (other != this) {
+    std::swap(header_, other->header_);
+    points_.Swap(&other->points_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PointCloudXYZRGB::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PointCloudXYZRGB_descriptor_;
+  metadata.reflection = PointCloudXYZRGB_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RGBDImage::kHeaderFieldNumber;
+const int RGBDImage::kColsFieldNumber;
+const int RGBDImage::kRowsFieldNumber;
+const int RGBDImage::kStep1FieldNumber;
+const int RGBDImage::kType1FieldNumber;
+const int RGBDImage::kImageData1FieldNumber;
+const int RGBDImage::kStep2FieldNumber;
+const int RGBDImage::kType2FieldNumber;
+const int RGBDImage::kImageData2FieldNumber;
+const int RGBDImage::kCameraConfigFieldNumber;
+const int RGBDImage::kCameraTypeFieldNumber;
+const int RGBDImage::kRollFieldNumber;
+const int RGBDImage::kPitchFieldNumber;
+const int RGBDImage::kYawFieldNumber;
+const int RGBDImage::kLonFieldNumber;
+const int RGBDImage::kLatFieldNumber;
+const int RGBDImage::kAltFieldNumber;
+const int RGBDImage::kGroundXFieldNumber;
+const int RGBDImage::kGroundYFieldNumber;
+const int RGBDImage::kGroundZFieldNumber;
+const int RGBDImage::kCameraMatrixFieldNumber;
+#endif  // !_MSC_VER
+
+RGBDImage::RGBDImage()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void RGBDImage::InitAsDefaultInstance() {
+  header_ = const_cast< ::px::HeaderInfo*>(&::px::HeaderInfo::default_instance());
+}
+
+RGBDImage::RGBDImage(const RGBDImage& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void RGBDImage::SharedCtor() {
+  _cached_size_ = 0;
+  header_ = NULL;
+  cols_ = 0u;
+  rows_ = 0u;
+  step1_ = 0u;
+  type1_ = 0u;
+  imagedata1_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  step2_ = 0u;
+  type2_ = 0u;
+  imagedata2_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  camera_config_ = 0u;
+  camera_type_ = 0u;
+  roll_ = 0;
+  pitch_ = 0;
+  yaw_ = 0;
+  lon_ = 0;
+  lat_ = 0;
+  alt_ = 0;
+  ground_x_ = 0;
+  ground_y_ = 0;
+  ground_z_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RGBDImage::~RGBDImage() {
+  SharedDtor();
+}
+
+void RGBDImage::SharedDtor() {
+  if (imagedata1_ != &::google::protobuf::internal::kEmptyString) {
+    delete imagedata1_;
+  }
+  if (imagedata2_ != &::google::protobuf::internal::kEmptyString) {
+    delete imagedata2_;
+  }
+  if (this != default_instance_) {
+    delete header_;
+  }
+}
+
+void RGBDImage::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RGBDImage::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RGBDImage_descriptor_;
+}
+
+const RGBDImage& RGBDImage::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+RGBDImage* RGBDImage::default_instance_ = NULL;
+
+RGBDImage* RGBDImage::New() const {
+  return new RGBDImage;
+}
+
+void RGBDImage::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_header()) {
+      if (header_ != NULL) header_->::px::HeaderInfo::Clear();
+    }
+    cols_ = 0u;
+    rows_ = 0u;
+    step1_ = 0u;
+    type1_ = 0u;
+    if (has_imagedata1()) {
+      if (imagedata1_ != &::google::protobuf::internal::kEmptyString) {
+        imagedata1_->clear();
+      }
+    }
+    step2_ = 0u;
+    type2_ = 0u;
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (has_imagedata2()) {
+      if (imagedata2_ != &::google::protobuf::internal::kEmptyString) {
+        imagedata2_->clear();
+      }
+    }
+    camera_config_ = 0u;
+    camera_type_ = 0u;
+    roll_ = 0;
+    pitch_ = 0;
+    yaw_ = 0;
+    lon_ = 0;
+    lat_ = 0;
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    alt_ = 0;
+    ground_x_ = 0;
+    ground_y_ = 0;
+    ground_z_ = 0;
+  }
+  camera_matrix_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RGBDImage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .px.HeaderInfo header = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_header()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_cols;
+        break;
+      }
+      
+      // required uint32 cols = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_cols:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &cols_)));
+          set_has_cols();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(24)) goto parse_rows;
+        break;
+      }
+      
+      // required uint32 rows = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_rows:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &rows_)));
+          set_has_rows();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(32)) goto parse_step1;
+        break;
+      }
+      
+      // required uint32 step1 = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_step1:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &step1_)));
+          set_has_step1();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_type1;
+        break;
+      }
+      
+      // required uint32 type1 = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_type1:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &type1_)));
+          set_has_type1();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_imageData1;
+        break;
+      }
+      
+      // required bytes imageData1 = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_imageData1:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_imagedata1()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_step2;
+        break;
+      }
+      
+      // required uint32 step2 = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_step2:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &step2_)));
+          set_has_step2();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(64)) goto parse_type2;
+        break;
+      }
+      
+      // required uint32 type2 = 8;
+      case 8: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_type2:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &type2_)));
+          set_has_type2();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(74)) goto parse_imageData2;
+        break;
+      }
+      
+      // required bytes imageData2 = 9;
+      case 9: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_imageData2:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_imagedata2()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(80)) goto parse_camera_config;
+        break;
+      }
+      
+      // optional uint32 camera_config = 10;
+      case 10: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_camera_config:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &camera_config_)));
+          set_has_camera_config();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(88)) goto parse_camera_type;
+        break;
+      }
+      
+      // optional uint32 camera_type = 11;
+      case 11: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_camera_type:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &camera_type_)));
+          set_has_camera_type();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(101)) goto parse_roll;
+        break;
+      }
+      
+      // optional float roll = 12;
+      case 12: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_roll:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &roll_)));
+          set_has_roll();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(109)) goto parse_pitch;
+        break;
+      }
+      
+      // optional float pitch = 13;
+      case 13: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_pitch:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &pitch_)));
+          set_has_pitch();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(117)) goto parse_yaw;
+        break;
+      }
+      
+      // optional float yaw = 14;
+      case 14: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_yaw:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &yaw_)));
+          set_has_yaw();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(125)) goto parse_lon;
+        break;
+      }
+      
+      // optional float lon = 15;
+      case 15: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_lon:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &lon_)));
+          set_has_lon();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(133)) goto parse_lat;
+        break;
+      }
+      
+      // optional float lat = 16;
+      case 16: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_lat:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &lat_)));
+          set_has_lat();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(141)) goto parse_alt;
+        break;
+      }
+      
+      // optional float alt = 17;
+      case 17: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_alt:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &alt_)));
+          set_has_alt();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(149)) goto parse_ground_x;
+        break;
+      }
+      
+      // optional float ground_x = 18;
+      case 18: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_ground_x:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &ground_x_)));
+          set_has_ground_x();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(157)) goto parse_ground_y;
+        break;
+      }
+      
+      // optional float ground_y = 19;
+      case 19: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_ground_y:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &ground_y_)));
+          set_has_ground_y();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(165)) goto parse_ground_z;
+        break;
+      }
+      
+      // optional float ground_z = 20;
+      case 20: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_ground_z:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &ground_z_)));
+          set_has_ground_z();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(173)) goto parse_camera_matrix;
+        break;
+      }
+      
+      // repeated float camera_matrix = 21;
+      case 21: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
+         parse_camera_matrix:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 2, 173, input, this->mutable_camera_matrix())));
+        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
+                   == ::google::protobuf::internal::WireFormatLite::
+                      WIRETYPE_LENGTH_DELIMITED) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, this->mutable_camera_matrix())));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(173)) goto parse_camera_matrix;
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void RGBDImage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->header(), output);
+  }
+  
+  // required uint32 cols = 2;
+  if (has_cols()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->cols(), output);
+  }
+  
+  // required uint32 rows = 3;
+  if (has_rows()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->rows(), output);
+  }
+  
+  // required uint32 step1 = 4;
+  if (has_step1()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->step1(), output);
+  }
+  
+  // required uint32 type1 = 5;
+  if (has_type1()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->type1(), output);
+  }
+  
+  // required bytes imageData1 = 6;
+  if (has_imagedata1()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      6, this->imagedata1(), output);
+  }
+  
+  // required uint32 step2 = 7;
+  if (has_step2()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->step2(), output);
+  }
+  
+  // required uint32 type2 = 8;
+  if (has_type2()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->type2(), output);
+  }
+  
+  // required bytes imageData2 = 9;
+  if (has_imagedata2()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      9, this->imagedata2(), output);
+  }
+  
+  // optional uint32 camera_config = 10;
+  if (has_camera_config()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->camera_config(), output);
+  }
+  
+  // optional uint32 camera_type = 11;
+  if (has_camera_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->camera_type(), output);
+  }
+  
+  // optional float roll = 12;
+  if (has_roll()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->roll(), output);
+  }
+  
+  // optional float pitch = 13;
+  if (has_pitch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->pitch(), output);
+  }
+  
+  // optional float yaw = 14;
+  if (has_yaw()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(14, this->yaw(), output);
+  }
+  
+  // optional float lon = 15;
+  if (has_lon()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(15, this->lon(), output);
+  }
+  
+  // optional float lat = 16;
+  if (has_lat()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(16, this->lat(), output);
+  }
+  
+  // optional float alt = 17;
+  if (has_alt()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(17, this->alt(), output);
+  }
+  
+  // optional float ground_x = 18;
+  if (has_ground_x()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(18, this->ground_x(), output);
+  }
+  
+  // optional float ground_y = 19;
+  if (has_ground_y()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(19, this->ground_y(), output);
+  }
+  
+  // optional float ground_z = 20;
+  if (has_ground_z()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(20, this->ground_z(), output);
+  }
+  
+  // repeated float camera_matrix = 21;
+  for (int i = 0; i < this->camera_matrix_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(
+      21, this->camera_matrix(i), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* RGBDImage::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .px.HeaderInfo header = 1;
+  if (has_header()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->header(), target);
+  }
+  
+  // required uint32 cols = 2;
+  if (has_cols()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->cols(), target);
+  }
+  
+  // required uint32 rows = 3;
+  if (has_rows()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->rows(), target);
+  }
+  
+  // required uint32 step1 = 4;
+  if (has_step1()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->step1(), target);
+  }
+  
+  // required uint32 type1 = 5;
+  if (has_type1()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->type1(), target);
+  }
+  
+  // required bytes imageData1 = 6;
+  if (has_imagedata1()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        6, this->imagedata1(), target);
+  }
+  
+  // required uint32 step2 = 7;
+  if (has_step2()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->step2(), target);
+  }
+  
+  // required uint32 type2 = 8;
+  if (has_type2()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->type2(), target);
+  }
+  
+  // required bytes imageData2 = 9;
+  if (has_imagedata2()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        9, this->imagedata2(), target);
+  }
+  
+  // optional uint32 camera_config = 10;
+  if (has_camera_config()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->camera_config(), target);
+  }
+  
+  // optional uint32 camera_type = 11;
+  if (has_camera_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->camera_type(), target);
+  }
+  
+  // optional float roll = 12;
+  if (has_roll()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->roll(), target);
+  }
+  
+  // optional float pitch = 13;
+  if (has_pitch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->pitch(), target);
+  }
+  
+  // optional float yaw = 14;
+  if (has_yaw()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(14, this->yaw(), target);
+  }
+  
+  // optional float lon = 15;
+  if (has_lon()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(15, this->lon(), target);
+  }
+  
+  // optional float lat = 16;
+  if (has_lat()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(16, this->lat(), target);
+  }
+  
+  // optional float alt = 17;
+  if (has_alt()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(17, this->alt(), target);
+  }
+  
+  // optional float ground_x = 18;
+  if (has_ground_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(18, this->ground_x(), target);
+  }
+  
+  // optional float ground_y = 19;
+  if (has_ground_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(19, this->ground_y(), target);
+  }
+  
+  // optional float ground_z = 20;
+  if (has_ground_z()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(20, this->ground_z(), target);
+  }
+  
+  // repeated float camera_matrix = 21;
+  for (int i = 0; i < this->camera_matrix_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFloatToArray(21, this->camera_matrix(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int RGBDImage::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .px.HeaderInfo header = 1;
+    if (has_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->header());
+    }
+    
+    // required uint32 cols = 2;
+    if (has_cols()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->cols());
+    }
+    
+    // required uint32 rows = 3;
+    if (has_rows()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->rows());
+    }
+    
+    // required uint32 step1 = 4;
+    if (has_step1()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->step1());
+    }
+    
+    // required uint32 type1 = 5;
+    if (has_type1()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->type1());
+    }
+    
+    // required bytes imageData1 = 6;
+    if (has_imagedata1()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->imagedata1());
+    }
+    
+    // required uint32 step2 = 7;
+    if (has_step2()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->step2());
+    }
+    
+    // required uint32 type2 = 8;
+    if (has_type2()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->type2());
+    }
+    
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // required bytes imageData2 = 9;
+    if (has_imagedata2()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->imagedata2());
+    }
+    
+    // optional uint32 camera_config = 10;
+    if (has_camera_config()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->camera_config());
+    }
+    
+    // optional uint32 camera_type = 11;
+    if (has_camera_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->camera_type());
+    }
+    
+    // optional float roll = 12;
+    if (has_roll()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float pitch = 13;
+    if (has_pitch()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float yaw = 14;
+    if (has_yaw()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float lon = 15;
+    if (has_lon()) {
+      total_size += 1 + 4;
+    }
+    
+    // optional float lat = 16;
+    if (has_lat()) {
+      total_size += 2 + 4;
+    }
+    
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    // optional float alt = 17;
+    if (has_alt()) {
+      total_size += 2 + 4;
+    }
+    
+    // optional float ground_x = 18;
+    if (has_ground_x()) {
+      total_size += 2 + 4;
+    }
+    
+    // optional float ground_y = 19;
+    if (has_ground_y()) {
+      total_size += 2 + 4;
+    }
+    
+    // optional float ground_z = 20;
+    if (has_ground_z()) {
+      total_size += 2 + 4;
+    }
+    
+  }
+  // repeated float camera_matrix = 21;
+  {
+    int data_size = 0;
+    data_size = 4 * this->camera_matrix_size();
+    total_size += 2 * this->camera_matrix_size() + data_size;
+  }
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RGBDImage::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RGBDImage* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RGBDImage*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RGBDImage::MergeFrom(const RGBDImage& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  camera_matrix_.MergeFrom(from.camera_matrix_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_header()) {
+      mutable_header()->::px::HeaderInfo::MergeFrom(from.header());
+    }
+    if (from.has_cols()) {
+      set_cols(from.cols());
+    }
+    if (from.has_rows()) {
+      set_rows(from.rows());
+    }
+    if (from.has_step1()) {
+      set_step1(from.step1());
+    }
+    if (from.has_type1()) {
+      set_type1(from.type1());
+    }
+    if (from.has_imagedata1()) {
+      set_imagedata1(from.imagedata1());
+    }
+    if (from.has_step2()) {
+      set_step2(from.step2());
+    }
+    if (from.has_type2()) {
+      set_type2(from.type2());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_imagedata2()) {
+      set_imagedata2(from.imagedata2());
+    }
+    if (from.has_camera_config()) {
+      set_camera_config(from.camera_config());
+    }
+    if (from.has_camera_type()) {
+      set_camera_type(from.camera_type());
+    }
+    if (from.has_roll()) {
+      set_roll(from.roll());
+    }
+    if (from.has_pitch()) {
+      set_pitch(from.pitch());
+    }
+    if (from.has_yaw()) {
+      set_yaw(from.yaw());
+    }
+    if (from.has_lon()) {
+      set_lon(from.lon());
+    }
+    if (from.has_lat()) {
+      set_lat(from.lat());
+    }
+  }
+  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    if (from.has_alt()) {
+      set_alt(from.alt());
+    }
+    if (from.has_ground_x()) {
+      set_ground_x(from.ground_x());
+    }
+    if (from.has_ground_y()) {
+      set_ground_y(from.ground_y());
+    }
+    if (from.has_ground_z()) {
+      set_ground_z(from.ground_z());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RGBDImage::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RGBDImage::CopyFrom(const RGBDImage& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RGBDImage::IsInitialized() const {
+  if ((_has_bits_[0] & 0x000001ff) != 0x000001ff) return false;
+  
+  if (has_header()) {
+    if (!this->header().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RGBDImage::Swap(RGBDImage* other) {
+  if (other != this) {
+    std::swap(header_, other->header_);
+    std::swap(cols_, other->cols_);
+    std::swap(rows_, other->rows_);
+    std::swap(step1_, other->step1_);
+    std::swap(type1_, other->type1_);
+    std::swap(imagedata1_, other->imagedata1_);
+    std::swap(step2_, other->step2_);
+    std::swap(type2_, other->type2_);
+    std::swap(imagedata2_, other->imagedata2_);
+    std::swap(camera_config_, other->camera_config_);
+    std::swap(camera_type_, other->camera_type_);
+    std::swap(roll_, other->roll_);
+    std::swap(pitch_, other->pitch_);
+    std::swap(yaw_, other->yaw_);
+    std::swap(lon_, other->lon_);
+    std::swap(lat_, other->lat_);
+    std::swap(alt_, other->alt_);
+    std::swap(ground_x_, other->ground_x_);
+    std::swap(ground_y_, other->ground_y_);
+    std::swap(ground_z_, other->ground_z_);
+    camera_matrix_.Swap(&other->camera_matrix_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RGBDImage::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RGBDImage_descriptor_;
+  metadata.reflection = RGBDImage_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Waypoint::kXFieldNumber;
+const int Waypoint::kYFieldNumber;
+const int Waypoint::kZFieldNumber;
+const int Waypoint::kRollFieldNumber;
+const int Waypoint::kPitchFieldNumber;
+const int Waypoint::kYawFieldNumber;
+#endif  // !_MSC_VER
+
+Waypoint::Waypoint()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void Waypoint::InitAsDefaultInstance() {
+}
+
+Waypoint::Waypoint(const Waypoint& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void Waypoint::SharedCtor() {
+  _cached_size_ = 0;
+  x_ = 0;
+  y_ = 0;
+  z_ = 0;
+  roll_ = 0;
+  pitch_ = 0;
+  yaw_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Waypoint::~Waypoint() {
+  SharedDtor();
+}
+
+void Waypoint::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void Waypoint::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Waypoint::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Waypoint_descriptor_;
+}
+
+const Waypoint& Waypoint::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pixhawk_2eproto();  return *default_instance_;
+}
+
+Waypoint* Waypoint::default_instance_ = NULL;
+
+Waypoint* Waypoint::New() const {
+  return new Waypoint;
+}
+
+void Waypoint::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    x_ = 0;
+    y_ = 0;
+    z_ = 0;
+    roll_ = 0;
+    pitch_ = 0;
+    yaw_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Waypoint::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required double x = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &x_)));
+          set_has_x();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(17)) goto parse_y;
+        break;
+      }
+      
+      // required double y = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_y:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &y_)));
+          set_has_y();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(25)) goto parse_z;
+        break;
+      }
+      
+      // optional double z = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_z:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &z_)));
+          set_has_z();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(33)) goto parse_roll;
+        break;
+      }
+      
+      // optional double roll = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_roll:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &roll_)));
+          set_has_roll();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(41)) goto parse_pitch;
+        break;
+      }
+      
+      // optional double pitch = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_pitch:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &pitch_)));
+          set_has_pitch();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(49)) goto parse_yaw;
+        break;
+      }
+      
+      // optional double yaw = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_yaw:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &yaw_)));
+          set_has_yaw();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void Waypoint::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required double x = 1;
+  if (has_x()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->x(), output);
+  }
+  
+  // required double y = 2;
+  if (has_y()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->y(), output);
+  }
+  
+  // optional double z = 3;
+  if (has_z()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->z(), output);
+  }
+  
+  // optional double roll = 4;
+  if (has_roll()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(4, this->roll(), output);
+  }
+  
+  // optional double pitch = 5;
+  if (has_pitch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(5, this->pitch(), output);
+  }
+  
+  // optional double yaw = 6;
+  if (has_yaw()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(6, this->yaw(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* Waypoint::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required double x = 1;
+  if (has_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->x(), target);
+  }
+  
+  // required double y = 2;
+  if (has_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->y(), target);
+  }
+  
+  // optional double z = 3;
+  if (has_z()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->z(), target);
+  }
+  
+  // optional double roll = 4;
+  if (has_roll()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(4, this->roll(), target);
+  }
+  
+  // optional double pitch = 5;
+  if (has_pitch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(5, this->pitch(), target);
+  }
+  
+  // optional double yaw = 6;
+  if (has_yaw()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(6, this->yaw(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int Waypoint::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required double x = 1;
+    if (has_x()) {
+      total_size += 1 + 8;
+    }
+    
+    // required double y = 2;
+    if (has_y()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double z = 3;
+    if (has_z()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double roll = 4;
+    if (has_roll()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double pitch = 5;
+    if (has_pitch()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double yaw = 6;
+    if (has_yaw()) {
+      total_size += 1 + 8;
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Waypoint::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Waypoint* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Waypoint*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Waypoint::MergeFrom(const Waypoint& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_x()) {
+      set_x(from.x());
+    }
+    if (from.has_y()) {
+      set_y(from.y());
+    }
+    if (from.has_z()) {
+      set_z(from.z());
+    }
+    if (from.has_roll()) {
+      set_roll(from.roll());
+    }
+    if (from.has_pitch()) {
+      set_pitch(from.pitch());
+    }
+    if (from.has_yaw()) {
+      set_yaw(from.yaw());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Waypoint::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Waypoint::CopyFrom(const Waypoint& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Waypoint::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  return true;
+}
+
+void Waypoint::Swap(Waypoint* other) {
+  if (other != this) {
+    std::swap(x_, other->x_);
+    std::swap(y_, other->y_);
+    std::swap(z_, other->z_);
+    std::swap(roll_, other->roll_);
+    std::swap(pitch_, other->pitch_);
+    std::swap(yaw_, other->yaw_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Waypoint::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Waypoint_descriptor_;
+  metadata.reflection = Waypoint_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace px
+
+// @@protoc_insertion_point(global_scope)
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/posix/.gitignore b/mavlink/share/pyshared/pymavlink/generator/C/test/posix/.gitignore
new file mode 100644
index 000000000..7c98650cc
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/posix/.gitignore
@@ -0,0 +1,3 @@
+/testmav0.9
+/testmav1.0
+/testmav1.0_nonstrict
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/posix/Makefile b/mavlink/share/pyshared/pymavlink/generator/C/test/posix/Makefile
new file mode 100644
index 000000000..693150fb7
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/posix/Makefile
@@ -0,0 +1,31 @@
+CFLAGS = -g -Wall -Werror -Os
+TESTPROTOCOL = common
+ALLPROTOCOLS = minimal test common pixhawk ardupilotmega slugs ualberta
+
+all: 
+	for p in ${ALLPROTOCOLS}; do make -f Makefile build TESTPROTOCOL=$$p; done
+
+test:
+	for p in ${ALLPROTOCOLS}; do make -f Makefile testprogs TESTPROTOCOL=$$p || exit 1; done
+
+valgrindtest:
+	for p in ${ALLPROTOCOLS}; do make -f Makefile valgrindprogs TESTPROTOCOL=$$p || exit 1; done
+
+build: testmav0.9_${TESTPROTOCOL} testmav1.0_${TESTPROTOCOL}
+
+testprogs: testmav0.9_${TESTPROTOCOL} testmav1.0_${TESTPROTOCOL}
+	./testmav0.9_${TESTPROTOCOL}
+	./testmav1.0_${TESTPROTOCOL}
+
+valgrindprogs: testmav0.9_${TESTPROTOCOL} testmav1.0_${TESTPROTOCOL}
+	valgrind -q ./testmav0.9_${TESTPROTOCOL}
+	valgrind -q ./testmav1.0_${TESTPROTOCOL}
+
+clean:
+	rm -rf *.o *~ testmav1.0* testmav0.9*
+
+testmav1.0_${TESTPROTOCOL}: testmav.c
+	$(CC) $(CFLAGS) -I../../include_v1.0 -I../../include_v1.0/${TESTPROTOCOL} -o $@ testmav.c
+
+testmav0.9_${TESTPROTOCOL}: testmav.c
+	$(CC) $(CFLAGS) -I../../include_v0.9 -I../../include_v0.9/${TESTPROTOCOL} -o $@ testmav.c
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/posix/testmav.c b/mavlink/share/pyshared/pymavlink/generator/C/test/posix/testmav.c
new file mode 100644
index 000000000..2fd7fa378
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/posix/testmav.c
@@ -0,0 +1,159 @@
+/*
+  simple MAVLink testsuite for C
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+#include <stddef.h>
+
+#define MAVLINK_USE_CONVENIENCE_FUNCTIONS
+#define MAVLINK_COMM_NUM_BUFFERS 2
+
+// this trick allows us to make mavlink_message_t as small as possible
+// for this dialect, which saves some memory
+#include <version.h>
+#define MAVLINK_MAX_PAYLOAD_LEN MAVLINK_MAX_DIALECT_PAYLOAD_SIZE
+
+#include <mavlink_types.h>
+static mavlink_system_t mavlink_system = {42,11,};
+
+#define MAVLINK_ASSERT(x) assert(x)
+static void comm_send_ch(mavlink_channel_t chan, uint8_t c);
+
+static mavlink_message_t last_msg;
+
+#include <mavlink.h>
+#include <testsuite.h>
+
+static unsigned chan_counts[MAVLINK_COMM_NUM_BUFFERS];
+
+static const unsigned message_lengths[] = MAVLINK_MESSAGE_LENGTHS;
+static unsigned error_count;
+
+static const mavlink_message_info_t message_info[256] = MAVLINK_MESSAGE_INFO;
+
+static void print_one_field(mavlink_message_t *msg, const mavlink_field_info_t *f, int idx)
+{
+#define PRINT_FORMAT(f, def) (f->print_format?f->print_format:def)
+	switch (f->type) {
+	case MAVLINK_TYPE_CHAR:
+		printf(PRINT_FORMAT(f, "%c"), _MAV_RETURN_char(msg, f->wire_offset+idx*1));
+		break;
+	case MAVLINK_TYPE_UINT8_T:
+		printf(PRINT_FORMAT(f, "%u"), _MAV_RETURN_uint8_t(msg, f->wire_offset+idx*1));
+		break;
+	case MAVLINK_TYPE_INT8_T:
+		printf(PRINT_FORMAT(f, "%d"), _MAV_RETURN_int8_t(msg, f->wire_offset+idx*1));
+		break;
+	case MAVLINK_TYPE_UINT16_T:
+		printf(PRINT_FORMAT(f, "%u"), _MAV_RETURN_uint16_t(msg, f->wire_offset+idx*2));
+		break;
+	case MAVLINK_TYPE_INT16_T:
+		printf(PRINT_FORMAT(f, "%d"), _MAV_RETURN_int16_t(msg, f->wire_offset+idx*2));
+		break;
+	case MAVLINK_TYPE_UINT32_T:
+		printf(PRINT_FORMAT(f, "%lu"), (unsigned long)_MAV_RETURN_uint32_t(msg, f->wire_offset+idx*4));
+		break;
+	case MAVLINK_TYPE_INT32_T:
+		printf(PRINT_FORMAT(f, "%ld"), (long)_MAV_RETURN_int32_t(msg, f->wire_offset+idx*4));
+		break;
+	case MAVLINK_TYPE_UINT64_T:
+		printf(PRINT_FORMAT(f, "%llu"), (unsigned long long)_MAV_RETURN_uint64_t(msg, f->wire_offset+idx*8));
+		break;
+	case MAVLINK_TYPE_INT64_T:
+		printf(PRINT_FORMAT(f, "%lld"), (long long)_MAV_RETURN_int64_t(msg, f->wire_offset+idx*8));
+		break;
+	case MAVLINK_TYPE_FLOAT:
+		printf(PRINT_FORMAT(f, "%f"), (double)_MAV_RETURN_float(msg, f->wire_offset+idx*4));
+		break;
+	case MAVLINK_TYPE_DOUBLE:
+		printf(PRINT_FORMAT(f, "%f"), _MAV_RETURN_double(msg, f->wire_offset+idx*8));
+		break;
+	}
+}
+
+static void print_field(mavlink_message_t *msg, const mavlink_field_info_t *f)
+{
+	printf("%s: ", f->name);
+	if (f->array_length == 0) {
+		print_one_field(msg, f, 0);
+		printf(" ");
+	} else {
+		unsigned i;
+		/* print an array */
+		if (f->type == MAVLINK_TYPE_CHAR) {
+			printf("'%.*s'", f->array_length,
+			       f->wire_offset+(const char *)_MAV_PAYLOAD(msg));
+			
+		} else {
+			printf("[ ");
+			for (i=0; i<f->array_length; i++) {
+				print_one_field(msg, f, i);
+				if (i < f->array_length) {
+					printf(", ");
+				}
+			}
+			printf("]");
+		}
+	}
+	printf(" ");
+}
+
+static void print_message(mavlink_message_t *msg)
+{
+	const mavlink_message_info_t *m = &message_info[msg->msgid];
+	const mavlink_field_info_t *f = m->fields;
+	unsigned i;
+	printf("%s { ", m->name);
+	for (i=0; i<m->num_fields; i++) {
+		print_field(msg, &f[i]);
+	}
+	printf("}\n");
+}
+
+static void comm_send_ch(mavlink_channel_t chan, uint8_t c)
+{
+	mavlink_status_t status;
+	if (mavlink_parse_char(chan, c, &last_msg, &status)) {
+		print_message(&last_msg);
+		chan_counts[chan]++;
+		/* channel 0 gets 3 messages per message, because of
+		   the channel defaults for _pack() and _encode() */
+		if (chan == MAVLINK_COMM_0 && status.current_rx_seq != (uint8_t)(chan_counts[chan]*3)) {
+			printf("Channel 0 sequence mismatch error at packet %u (rx_seq=%u)\n", 
+			       chan_counts[chan], status.current_rx_seq);
+			error_count++;
+		} else if (chan > MAVLINK_COMM_0 && status.current_rx_seq != (uint8_t)chan_counts[chan]) {
+			printf("Channel %u sequence mismatch error at packet %u (rx_seq=%u)\n", 
+			       (unsigned)chan, chan_counts[chan], status.current_rx_seq);
+			error_count++;
+		}
+		if (message_lengths[last_msg.msgid] != last_msg.len) {
+			printf("Incorrect message length %u for message %u - expected %u\n", 
+			       (unsigned)last_msg.len, (unsigned)last_msg.msgid, message_lengths[last_msg.msgid]);
+			error_count++;
+		}
+	}
+	if (status.packet_rx_drop_count != 0) {
+		printf("Parse error at packet %u\n", chan_counts[chan]);
+		error_count++;
+	}
+}
+
+int main(void)
+{
+	mavlink_channel_t chan;
+	mavlink_test_all(11, 10, &last_msg);
+	for (chan=MAVLINK_COMM_0; chan<=MAVLINK_COMM_1; chan++) {
+		printf("Received %u messages on channel %u OK\n", 
+		       chan_counts[chan], (unsigned)chan);
+	}
+	if (error_count != 0) {
+		printf("Error count %u\n", error_count);
+		exit(1);
+	}
+	printf("No errors detected\n");
+	return 0;
+}
+
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/windows/stdafx.cpp b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/stdafx.cpp
new file mode 100644
index 000000000..98b4abf05
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/stdafx.cpp
@@ -0,0 +1,8 @@
+// stdafx.cpp : source file that includes just the standard includes

+// testmav.pch will be the pre-compiled header

+// stdafx.obj will contain the pre-compiled type information

+

+#include "stdafx.h"

+

+// TODO: reference any additional headers you need in STDAFX.H

+// and not in this file

diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/windows/stdafx.h b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/stdafx.h
new file mode 100644
index 000000000..47a0d0252
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/stdafx.h
@@ -0,0 +1,15 @@
+// stdafx.h : include file for standard system include files,

+// or project specific include files that are used frequently, but

+// are changed infrequently

+//

+

+#pragma once

+

+#include "targetver.h"

+

+#include <stdio.h>

+#include <tchar.h>

+

+

+

+// TODO: reference additional headers your program requires here

diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/windows/targetver.h b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/targetver.h
new file mode 100644
index 000000000..90e767bfc
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/targetver.h
@@ -0,0 +1,8 @@
+#pragma once

+

+// Including SDKDDKVer.h defines the highest available Windows platform.

+

+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and

+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.

+

+#include <SDKDDKVer.h>

diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.cpp b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.cpp
new file mode 100644
index 000000000..aa83caced
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.cpp
@@ -0,0 +1,154 @@
+// testmav.cpp : Defines the entry point for the console application.

+//

+

+#include "stdafx.h"

+#include "stdio.h"

+#include "stdint.h"

+#include "stddef.h"

+#include "assert.h"

+

+

+#define MAVLINK_USE_CONVENIENCE_FUNCTIONS

+#define MAVLINK_COMM_NUM_BUFFERS 2

+

+#include <mavlink_types.h>

+static mavlink_system_t mavlink_system = {42,11,};

+

+#define MAVLINK_ASSERT(x) assert(x)

+static void comm_send_ch(mavlink_channel_t chan, uint8_t c);

+

+static mavlink_message_t last_msg;

+

+#include <common/mavlink.h>

+#include <common/testsuite.h>

+

+static unsigned chan_counts[MAVLINK_COMM_NUM_BUFFERS];

+

+static const unsigned message_lengths[] = MAVLINK_MESSAGE_LENGTHS;

+static unsigned error_count;

+

+static const mavlink_message_info_t message_info[256] = MAVLINK_MESSAGE_INFO;

+

+static void print_one_field(mavlink_message_t *msg, const mavlink_field_info_t *f, int idx)

+{

+#define PRINT_FORMAT(f, def) (f->print_format?f->print_format:def)

+	switch (f->type) {

+	case MAVLINK_TYPE_CHAR:

+		printf(PRINT_FORMAT(f, "%c"), _MAV_RETURN_char(msg, f->wire_offset+idx*1));

+		break;

+	case MAVLINK_TYPE_UINT8_T:

+		printf(PRINT_FORMAT(f, "%u"), _MAV_RETURN_uint8_t(msg, f->wire_offset+idx*1));

+		break;

+	case MAVLINK_TYPE_INT8_T:

+		printf(PRINT_FORMAT(f, "%d"), _MAV_RETURN_int8_t(msg, f->wire_offset+idx*1));

+		break;

+	case MAVLINK_TYPE_UINT16_T:

+		printf(PRINT_FORMAT(f, "%u"), _MAV_RETURN_uint16_t(msg, f->wire_offset+idx*2));

+		break;

+	case MAVLINK_TYPE_INT16_T:

+		printf(PRINT_FORMAT(f, "%d"), _MAV_RETURN_int16_t(msg, f->wire_offset+idx*2));

+		break;

+	case MAVLINK_TYPE_UINT32_T:

+		printf(PRINT_FORMAT(f, "%lu"), (unsigned long)_MAV_RETURN_uint32_t(msg, f->wire_offset+idx*4));

+		break;

+	case MAVLINK_TYPE_INT32_T:

+		printf(PRINT_FORMAT(f, "%ld"), (long)_MAV_RETURN_int32_t(msg, f->wire_offset+idx*4));

+		break;

+	case MAVLINK_TYPE_UINT64_T:

+		printf(PRINT_FORMAT(f, "%llu"), (unsigned long long)_MAV_RETURN_uint64_t(msg, f->wire_offset+idx*8));

+		break;

+	case MAVLINK_TYPE_INT64_T:

+		printf(PRINT_FORMAT(f, "%lld"), (long long)_MAV_RETURN_int64_t(msg, f->wire_offset+idx*8));

+		break;

+	case MAVLINK_TYPE_FLOAT:

+		printf(PRINT_FORMAT(f, "%f"), (double)_MAV_RETURN_float(msg, f->wire_offset+idx*4));

+		break;

+	case MAVLINK_TYPE_DOUBLE:

+		printf(PRINT_FORMAT(f, "%f"), _MAV_RETURN_double(msg, f->wire_offset+idx*8));

+		break;

+	}

+}

+

+static void print_field(mavlink_message_t *msg, const mavlink_field_info_t *f)

+{

+	printf("%s: ", f->name);

+	if (f->array_length == 0) {

+		print_one_field(msg, f, 0);

+		printf(" ");

+	} else {

+		unsigned i;

+		/* print an array */

+		if (f->type == MAVLINK_TYPE_CHAR) {

+			printf("'%.*s'", f->array_length,

+			       f->wire_offset+(const char *)_MAV_PAYLOAD(msg));

+			

+		} else {

+			printf("[ ");

+			for (i=0; i<f->array_length; i++) {

+				print_one_field(msg, f, i);

+				if (i < f->array_length) {

+					printf(", ");

+				}

+			}

+			printf("]");

+		}

+	}

+	printf(" ");

+}

+

+static void print_message(mavlink_message_t *msg)

+{

+	const mavlink_message_info_t *m = &message_info[msg->msgid];

+	const mavlink_field_info_t *f = m->fields;

+	unsigned i;

+	printf("%s { ", m->name);

+	for (i=0; i<m->num_fields; i++) {

+		print_field(msg, &f[i]);

+	}

+	printf("}\n");

+}

+

+static void comm_send_ch(mavlink_channel_t chan, uint8_t c)

+{

+	mavlink_status_t status;

+	if (mavlink_parse_char(chan, c, &last_msg, &status)) {

+		print_message(&last_msg);

+		chan_counts[chan]++;

+		/* channel 0 gets 3 messages per message, because of

+		   the channel defaults for _pack() and _encode() */

+		if (chan == MAVLINK_COMM_0 && status.current_rx_seq != (uint8_t)(chan_counts[chan]*3)) {

+			printf("Channel 0 sequence mismatch error at packet %u (rx_seq=%u)\n", 

+			       chan_counts[chan], status.current_rx_seq);

+			error_count++;

+		} else if (chan > MAVLINK_COMM_0 && status.current_rx_seq != (uint8_t)chan_counts[chan]) {

+			printf("Channel %u sequence mismatch error at packet %u (rx_seq=%u)\n", 

+			       (unsigned)chan, chan_counts[chan], status.current_rx_seq);

+			error_count++;

+		}

+		if (message_lengths[last_msg.msgid] != last_msg.len) {

+			printf("Incorrect message length %u for message %u - expected %u\n", 

+			       (unsigned)last_msg.len, (unsigned)last_msg.msgid, message_lengths[last_msg.msgid]);

+			error_count++;

+		}

+	}

+	if (status.packet_rx_drop_count != 0) {

+		printf("Parse error at packet %u\n", chan_counts[chan]);

+		error_count++;

+	}

+}

+	

+int _tmain(int argc, _TCHAR* argv[])

+{

+	int chan;

+	mavlink_test_all(11, 10, &last_msg);

+	for (chan=MAVLINK_COMM_0; chan<=MAVLINK_COMM_1; chan++) {

+		printf("Received %u messages on channel %u OK\n", 

+		       chan_counts[chan], (unsigned)chan);

+	}

+	if (error_count != 0) {

+		printf("Error count %u\n", error_count);

+		return(1);

+	}

+	printf("No errors detected\n");

+	return 0;

+}

diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.sln b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.sln
new file mode 100644
index 000000000..37a305697
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.sln
@@ -0,0 +1,20 @@
+

+Microsoft Visual Studio Solution File, Format Version 11.00

+# Visual C++ Express 2010

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testmav", "testmav\testmav.vcxproj", "{02C30EBC-DF41-4C36-B2F3-79BED7E6EF9F}"

+EndProject

+Global

+	GlobalSection(SolutionConfigurationPlatforms) = preSolution

+		Debug|Win32 = Debug|Win32

+		Release|Win32 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ProjectConfigurationPlatforms) = postSolution

+		{02C30EBC-DF41-4C36-B2F3-79BED7E6EF9F}.Debug|Win32.ActiveCfg = Debug|Win32

+		{02C30EBC-DF41-4C36-B2F3-79BED7E6EF9F}.Debug|Win32.Build.0 = Debug|Win32

+		{02C30EBC-DF41-4C36-B2F3-79BED7E6EF9F}.Release|Win32.ActiveCfg = Release|Win32

+		{02C30EBC-DF41-4C36-B2F3-79BED7E6EF9F}.Release|Win32.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(SolutionProperties) = preSolution

+		HideSolutionNode = FALSE

+	EndGlobalSection

+EndGlobal

diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.suo b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.suo
new file mode 100644
index 000000000..9b2e18cff
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.suo
diff --git a/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.vcxproj b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.vcxproj
new file mode 100644
index 000000000..7181b3a41
--- /dev/null
+++ b/mavlink/share/pyshared/pymavlink/generator/C/test/windows/testmav.vcxproj
@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <ItemGroup Label="ProjectConfigurations">

+    <ProjectConfiguration Include="Debug|Win32">

+      <Configuration>Debug</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Release|Win32">

+      <Configuration>Release</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+  </ItemGroup>

+  <PropertyGroup Label="Globals">

+    <ProjectGuid>{02C30EBC-DF41-4C36-B2F3-79BED7E6EF9F}</ProjectGuid>

+    <Keyword>Win32Proj</Keyword>

+    <RootNamespace>testmav</RootNamespace>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

+    <ConfigurationType>Application</ConfigurationType>

+    <UseDebugLibraries>true</UseDebugLibraries>

+    <CharacterSet>Unicode</CharacterSet>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

+    <ConfigurationType>Application</ConfigurationType>

+    <UseDebugLibraries>false</UseDebugLibraries>

+    <WholeProgramOptimization>true</WholeProgramOptimization>

+    <CharacterSet>Unicode</CharacterSet>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

+  <ImportGroup Label="ExtensionSettings">

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <PropertyGroup Label="UserMacros" />

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <LinkIncremental>true</LinkIncremental>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <LinkIncremental>false</LinkIncremental>

+  </PropertyGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <ClCompile>

+      <PrecompiledHeader>

+      </PrecompiledHeader>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>Disabled</Optimization>

+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <AdditionalIncludeDirectories>E:\pymavlink\generator\C\include_v1.0</AdditionalIncludeDirectories>

+    </ClCompile>

+    <Link>

+      <SubSystem>Console</SubSystem>

+      <GenerateDebugInformation>true</GenerateDebugInformation>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <PrecompiledHeader>

+      </PrecompiledHeader>

+      <Optimization>MaxSpeed</Optimization>

+      <FunctionLevelLinking>true</FunctionLevelLinking>

+      <IntrinsicFunctions>true</IntrinsicFunctions>

+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+    </ClCompile>

+    <Link>

+      <SubSystem>Console</SubSystem>

+      <GenerateDebugInformation>true</GenerateDebugInformation>

+      <EnableCOMDATFolding>true</EnableCOMDATFolding>

+      <OptimizeReferences>true</OptimizeReferences>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemGroup>

+    <None Include="ReadMe.txt" />

+  </ItemGroup>

+  <ItemGroup>

+    <ClInclude Include="stdafx.h" />

+    <ClInclude Include="targetver.h" />

+  </ItemGroup>

+  <ItemGroup>

+    <ClCompile Include="stdafx.cpp" />

+    <ClCompile Include="testmav.cpp" />

+  </ItemGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

+  <ImportGroup Label="ExtensionTargets">

+  </ImportGroup>

+</Project>
\ No newline at end of file