Browse Source

增加EV2 fmub 相关消息

LiuYang 1 month ago
parent
commit
794028ea22

+ 29 - 0
msg_definitions/VKFly.xml

@@ -108,6 +108,7 @@
       <entry value="25" name="VKFLY_COMP_ID_BAT9"></entry>
       <entry value="30" name="VKFLY_COMP_ID_ASPD0"></entry>
       <entry value="31" name="VKFLY_COMP_ID_ASPD1"></entry>
+      <entry value="32" name="VKFLY_COMP_ID_EV2FMUB"></entry>
     </enum>
 
     <enum name="VKFLY_FS_ACTION">
@@ -488,6 +489,9 @@
       <entry value="18" name="VKFLY_RTL_REASON_ASPD_LOW">
         <description>Trigger rtl mode by transform time out.</description>
       </entry>
+      <entry value="19" name="VKFLY_RTL_REASON_FMUB_TAKEOVER">
+        <description>Trigger rtl mode by fmub takeover.</description>
+      </entry>
     </enum>
 
     <enum name="VKFLY_LOITER_REASON">
@@ -1180,6 +1184,31 @@
       <field type="uint8_t" name="target_comp">Target compid id.</field>
     </message>
 
+    <message id="53200" name="FMUB_STATUS">
+      <description>EV2 FMU backup status.</description>
+      <field type="uint32_t" name="timestamp" units="ms">timestamp from systemboot in ms.</field>
+      <field type="float" name="roll" units="rad">euler roll angle.</field>
+      <field type="float" name="pitch" units="rad">euler pitch angle.</field>
+      <field type="float" name="yaw" units="rad">euler yaw angle.</field>
+      <field type="float" name="vn" units="m/s">velocity in northward axis.</field>
+      <field type="float" name="ve" units="m/s">velocity in eastward axis.</field>
+      <field type="float" name="vd" units="m/s">velocity in downward axis.</field>
+      <field type="float" name="ax" units="m/s/s">acceleration in x axis.</field>
+      <field type="float" name="ay" units="m/s/s">acceleration in y axis.</field>
+      <field type="float" name="az" units="m/s/s">acceleration in z axis.</field>
+      <field type="float" name="gx" units="rad/s">angular velocity in x axis.</field>
+      <field type="float" name="gy" units="rad/s">angular velocity in y axis.</field>
+      <field type="float" name="gz" units="rad/s">angular velocity in z axis.</field>
+      <field type="int32_t" name="lat" units="degE7">latitude.</field>
+      <field type="int32_t" name="lon" units="degE7">longitude.</field>
+      <field type="float" name="amsl" units="m">altitude above mean sea level.</field>
+      <field type="int32_t" name="ins_status"></field>
+      <field type="int32_t" name="ins_flag"></field>
+      <field type="uint16_t" name="throttle" min="0" max="100" increment="1">throttle output.</field>
+      <field type="uint8_t" name="flight_mode">flight mode.</field>
+      <field type="uint8_t" name="btake_status" min="0" max="1" increment="1">backup takeover status.</field>
+    </message>
+
     <message id="53300" name="QINGXIE_BMS">
       <description>VKFLY transfer update terminate. Send this message to terminate a update file
         transfer.</description>

+ 2 - 2
readme.md

@@ -924,7 +924,7 @@ comp_id 为 0 时, 飞控将回复多个消息逐个返回所有可获取设备
 | data_len     | data段字节长度        |
 | data         | 转发的数据内容        |
 
-### 2.29 外部惯导 VK_EXTERNAL_INS_NAV
+### 2.30 外部惯导 VK_EXTERNAL_INS_NAV
 
 飞控将收到的外部惯导数据通过此包向地面站转发
 
@@ -2004,7 +2004,7 @@ VKins 系统的状态数据自定义消息, 主要用于一些自定状态的传
 
 | id  | 设备     |
 | --- | -------- |
-| 0   | 无       |
+| 0   | 无(透传) |
 | 1   | 思翼吊舱 |
 | 2   | 普宙吊舱 |
 | 3   | 睿铂吊舱 |

File diff suppressed because it is too large
+ 1 - 1
v2.0/VKFly/VKFly.h


+ 1 - 1
v2.0/VKFly/mavlink.h

@@ -6,7 +6,7 @@
 #ifndef MAVLINK_H
 #define MAVLINK_H
 
-#define MAVLINK_PRIMARY_XML_HASH 414775501008155445
+#define MAVLINK_PRIMARY_XML_HASH 78985157704652124
 
 #ifndef MAVLINK_STX
 #define MAVLINK_STX 253

+ 820 - 0
v2.0/VKFly/mavlink_msg_fmub_status.h

@@ -0,0 +1,820 @@
+#pragma once
+// MESSAGE FMUB_STATUS PACKING
+
+#define MAVLINK_MSG_ID_FMUB_STATUS 53200
+
+
+typedef struct __mavlink_fmub_status_t {
+ uint32_t timestamp; /*< [ms] timestamp from systemboot in ms.*/
+ float roll; /*< [rad] euler roll angle.*/
+ float pitch; /*< [rad] euler pitch angle.*/
+ float yaw; /*< [rad] euler yaw angle.*/
+ float vn; /*< [m/s] velocity in northward axis.*/
+ float ve; /*< [m/s] velocity in eastward axis.*/
+ float vd; /*< [m/s] velocity in downward axis.*/
+ float ax; /*< [m/s/s] acceleration in x axis.*/
+ float ay; /*< [m/s/s] acceleration in y axis.*/
+ float az; /*< [m/s/s] acceleration in z axis.*/
+ float gx; /*< [rad/s] angular velocity in x axis.*/
+ float gy; /*< [rad/s] angular velocity in y axis.*/
+ float gz; /*< [rad/s] angular velocity in z axis.*/
+ int32_t lat; /*< [degE7] latitude.*/
+ int32_t lon; /*< [degE7] longitude.*/
+ float amsl; /*< [m] altitude above mean sea level.*/
+ int32_t ins_status; /*<  */
+ int32_t ins_flag; /*<  */
+ uint16_t throttle; /*<  throttle output.*/
+ uint8_t flight_mode; /*<  flight mode.*/
+ uint8_t btake_status; /*<  backup takeover status.*/
+} mavlink_fmub_status_t;
+
+#define MAVLINK_MSG_ID_FMUB_STATUS_LEN 76
+#define MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN 76
+#define MAVLINK_MSG_ID_53200_LEN 76
+#define MAVLINK_MSG_ID_53200_MIN_LEN 76
+
+#define MAVLINK_MSG_ID_FMUB_STATUS_CRC 45
+#define MAVLINK_MSG_ID_53200_CRC 45
+
+
+
+#if MAVLINK_COMMAND_24BIT
+#define MAVLINK_MESSAGE_INFO_FMUB_STATUS { \
+    53200, \
+    "FMUB_STATUS", \
+    21, \
+    {  { "timestamp", NULL, MAVLINK_TYPE_UINT32_T, 0, 0, offsetof(mavlink_fmub_status_t, timestamp) }, \
+         { "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_fmub_status_t, roll) }, \
+         { "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_fmub_status_t, pitch) }, \
+         { "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_fmub_status_t, yaw) }, \
+         { "vn", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_fmub_status_t, vn) }, \
+         { "ve", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_fmub_status_t, ve) }, \
+         { "vd", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_fmub_status_t, vd) }, \
+         { "ax", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_fmub_status_t, ax) }, \
+         { "ay", NULL, MAVLINK_TYPE_FLOAT, 0, 32, offsetof(mavlink_fmub_status_t, ay) }, \
+         { "az", NULL, MAVLINK_TYPE_FLOAT, 0, 36, offsetof(mavlink_fmub_status_t, az) }, \
+         { "gx", NULL, MAVLINK_TYPE_FLOAT, 0, 40, offsetof(mavlink_fmub_status_t, gx) }, \
+         { "gy", NULL, MAVLINK_TYPE_FLOAT, 0, 44, offsetof(mavlink_fmub_status_t, gy) }, \
+         { "gz", NULL, MAVLINK_TYPE_FLOAT, 0, 48, offsetof(mavlink_fmub_status_t, gz) }, \
+         { "lat", NULL, MAVLINK_TYPE_INT32_T, 0, 52, offsetof(mavlink_fmub_status_t, lat) }, \
+         { "lon", NULL, MAVLINK_TYPE_INT32_T, 0, 56, offsetof(mavlink_fmub_status_t, lon) }, \
+         { "amsl", NULL, MAVLINK_TYPE_FLOAT, 0, 60, offsetof(mavlink_fmub_status_t, amsl) }, \
+         { "ins_status", NULL, MAVLINK_TYPE_INT32_T, 0, 64, offsetof(mavlink_fmub_status_t, ins_status) }, \
+         { "ins_flag", NULL, MAVLINK_TYPE_INT32_T, 0, 68, offsetof(mavlink_fmub_status_t, ins_flag) }, \
+         { "throttle", NULL, MAVLINK_TYPE_UINT16_T, 0, 72, offsetof(mavlink_fmub_status_t, throttle) }, \
+         { "flight_mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 74, offsetof(mavlink_fmub_status_t, flight_mode) }, \
+         { "btake_status", NULL, MAVLINK_TYPE_UINT8_T, 0, 75, offsetof(mavlink_fmub_status_t, btake_status) }, \
+         } \
+}
+#else
+#define MAVLINK_MESSAGE_INFO_FMUB_STATUS { \
+    "FMUB_STATUS", \
+    21, \
+    {  { "timestamp", NULL, MAVLINK_TYPE_UINT32_T, 0, 0, offsetof(mavlink_fmub_status_t, timestamp) }, \
+         { "roll", NULL, MAVLINK_TYPE_FLOAT, 0, 4, offsetof(mavlink_fmub_status_t, roll) }, \
+         { "pitch", NULL, MAVLINK_TYPE_FLOAT, 0, 8, offsetof(mavlink_fmub_status_t, pitch) }, \
+         { "yaw", NULL, MAVLINK_TYPE_FLOAT, 0, 12, offsetof(mavlink_fmub_status_t, yaw) }, \
+         { "vn", NULL, MAVLINK_TYPE_FLOAT, 0, 16, offsetof(mavlink_fmub_status_t, vn) }, \
+         { "ve", NULL, MAVLINK_TYPE_FLOAT, 0, 20, offsetof(mavlink_fmub_status_t, ve) }, \
+         { "vd", NULL, MAVLINK_TYPE_FLOAT, 0, 24, offsetof(mavlink_fmub_status_t, vd) }, \
+         { "ax", NULL, MAVLINK_TYPE_FLOAT, 0, 28, offsetof(mavlink_fmub_status_t, ax) }, \
+         { "ay", NULL, MAVLINK_TYPE_FLOAT, 0, 32, offsetof(mavlink_fmub_status_t, ay) }, \
+         { "az", NULL, MAVLINK_TYPE_FLOAT, 0, 36, offsetof(mavlink_fmub_status_t, az) }, \
+         { "gx", NULL, MAVLINK_TYPE_FLOAT, 0, 40, offsetof(mavlink_fmub_status_t, gx) }, \
+         { "gy", NULL, MAVLINK_TYPE_FLOAT, 0, 44, offsetof(mavlink_fmub_status_t, gy) }, \
+         { "gz", NULL, MAVLINK_TYPE_FLOAT, 0, 48, offsetof(mavlink_fmub_status_t, gz) }, \
+         { "lat", NULL, MAVLINK_TYPE_INT32_T, 0, 52, offsetof(mavlink_fmub_status_t, lat) }, \
+         { "lon", NULL, MAVLINK_TYPE_INT32_T, 0, 56, offsetof(mavlink_fmub_status_t, lon) }, \
+         { "amsl", NULL, MAVLINK_TYPE_FLOAT, 0, 60, offsetof(mavlink_fmub_status_t, amsl) }, \
+         { "ins_status", NULL, MAVLINK_TYPE_INT32_T, 0, 64, offsetof(mavlink_fmub_status_t, ins_status) }, \
+         { "ins_flag", NULL, MAVLINK_TYPE_INT32_T, 0, 68, offsetof(mavlink_fmub_status_t, ins_flag) }, \
+         { "throttle", NULL, MAVLINK_TYPE_UINT16_T, 0, 72, offsetof(mavlink_fmub_status_t, throttle) }, \
+         { "flight_mode", NULL, MAVLINK_TYPE_UINT8_T, 0, 74, offsetof(mavlink_fmub_status_t, flight_mode) }, \
+         { "btake_status", NULL, MAVLINK_TYPE_UINT8_T, 0, 75, offsetof(mavlink_fmub_status_t, btake_status) }, \
+         } \
+}
+#endif
+
+/**
+ * @brief Pack a fmub_status 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 timestamp [ms] timestamp from systemboot in ms.
+ * @param roll [rad] euler roll angle.
+ * @param pitch [rad] euler pitch angle.
+ * @param yaw [rad] euler yaw angle.
+ * @param vn [m/s] velocity in northward axis.
+ * @param ve [m/s] velocity in eastward axis.
+ * @param vd [m/s] velocity in downward axis.
+ * @param ax [m/s/s] acceleration in x axis.
+ * @param ay [m/s/s] acceleration in y axis.
+ * @param az [m/s/s] acceleration in z axis.
+ * @param gx [rad/s] angular velocity in x axis.
+ * @param gy [rad/s] angular velocity in y axis.
+ * @param gz [rad/s] angular velocity in z axis.
+ * @param lat [degE7] latitude.
+ * @param lon [degE7] longitude.
+ * @param amsl [m] altitude above mean sea level.
+ * @param ins_status  
+ * @param ins_flag  
+ * @param throttle  throttle output.
+ * @param flight_mode  flight mode.
+ * @param btake_status  backup takeover status.
+ * @return length of the message in bytes (excluding serial stream start sign)
+ */
+static inline uint16_t mavlink_msg_fmub_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
+                               uint32_t timestamp, float roll, float pitch, float yaw, float vn, float ve, float vd, float ax, float ay, float az, float gx, float gy, float gz, int32_t lat, int32_t lon, float amsl, int32_t ins_status, int32_t ins_flag, uint16_t throttle, uint8_t flight_mode, uint8_t btake_status)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+    char buf[MAVLINK_MSG_ID_FMUB_STATUS_LEN];
+    _mav_put_uint32_t(buf, 0, timestamp);
+    _mav_put_float(buf, 4, roll);
+    _mav_put_float(buf, 8, pitch);
+    _mav_put_float(buf, 12, yaw);
+    _mav_put_float(buf, 16, vn);
+    _mav_put_float(buf, 20, ve);
+    _mav_put_float(buf, 24, vd);
+    _mav_put_float(buf, 28, ax);
+    _mav_put_float(buf, 32, ay);
+    _mav_put_float(buf, 36, az);
+    _mav_put_float(buf, 40, gx);
+    _mav_put_float(buf, 44, gy);
+    _mav_put_float(buf, 48, gz);
+    _mav_put_int32_t(buf, 52, lat);
+    _mav_put_int32_t(buf, 56, lon);
+    _mav_put_float(buf, 60, amsl);
+    _mav_put_int32_t(buf, 64, ins_status);
+    _mav_put_int32_t(buf, 68, ins_flag);
+    _mav_put_uint16_t(buf, 72, throttle);
+    _mav_put_uint8_t(buf, 74, flight_mode);
+    _mav_put_uint8_t(buf, 75, btake_status);
+
+        memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+#else
+    mavlink_fmub_status_t packet;
+    packet.timestamp = timestamp;
+    packet.roll = roll;
+    packet.pitch = pitch;
+    packet.yaw = yaw;
+    packet.vn = vn;
+    packet.ve = ve;
+    packet.vd = vd;
+    packet.ax = ax;
+    packet.ay = ay;
+    packet.az = az;
+    packet.gx = gx;
+    packet.gy = gy;
+    packet.gz = gz;
+    packet.lat = lat;
+    packet.lon = lon;
+    packet.amsl = amsl;
+    packet.ins_status = ins_status;
+    packet.ins_flag = ins_flag;
+    packet.throttle = throttle;
+    packet.flight_mode = flight_mode;
+    packet.btake_status = btake_status;
+
+        memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+#endif
+
+    msg->msgid = MAVLINK_MSG_ID_FMUB_STATUS;
+    return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+}
+
+/**
+ * @brief Pack a fmub_status message
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param status MAVLink status structure
+ * @param msg The MAVLink message to compress the data into
+ *
+ * @param timestamp [ms] timestamp from systemboot in ms.
+ * @param roll [rad] euler roll angle.
+ * @param pitch [rad] euler pitch angle.
+ * @param yaw [rad] euler yaw angle.
+ * @param vn [m/s] velocity in northward axis.
+ * @param ve [m/s] velocity in eastward axis.
+ * @param vd [m/s] velocity in downward axis.
+ * @param ax [m/s/s] acceleration in x axis.
+ * @param ay [m/s/s] acceleration in y axis.
+ * @param az [m/s/s] acceleration in z axis.
+ * @param gx [rad/s] angular velocity in x axis.
+ * @param gy [rad/s] angular velocity in y axis.
+ * @param gz [rad/s] angular velocity in z axis.
+ * @param lat [degE7] latitude.
+ * @param lon [degE7] longitude.
+ * @param amsl [m] altitude above mean sea level.
+ * @param ins_status  
+ * @param ins_flag  
+ * @param throttle  throttle output.
+ * @param flight_mode  flight mode.
+ * @param btake_status  backup takeover status.
+ * @return length of the message in bytes (excluding serial stream start sign)
+ */
+static inline uint16_t mavlink_msg_fmub_status_pack_status(uint8_t system_id, uint8_t component_id, mavlink_status_t *_status, mavlink_message_t* msg,
+                               uint32_t timestamp, float roll, float pitch, float yaw, float vn, float ve, float vd, float ax, float ay, float az, float gx, float gy, float gz, int32_t lat, int32_t lon, float amsl, int32_t ins_status, int32_t ins_flag, uint16_t throttle, uint8_t flight_mode, uint8_t btake_status)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+    char buf[MAVLINK_MSG_ID_FMUB_STATUS_LEN];
+    _mav_put_uint32_t(buf, 0, timestamp);
+    _mav_put_float(buf, 4, roll);
+    _mav_put_float(buf, 8, pitch);
+    _mav_put_float(buf, 12, yaw);
+    _mav_put_float(buf, 16, vn);
+    _mav_put_float(buf, 20, ve);
+    _mav_put_float(buf, 24, vd);
+    _mav_put_float(buf, 28, ax);
+    _mav_put_float(buf, 32, ay);
+    _mav_put_float(buf, 36, az);
+    _mav_put_float(buf, 40, gx);
+    _mav_put_float(buf, 44, gy);
+    _mav_put_float(buf, 48, gz);
+    _mav_put_int32_t(buf, 52, lat);
+    _mav_put_int32_t(buf, 56, lon);
+    _mav_put_float(buf, 60, amsl);
+    _mav_put_int32_t(buf, 64, ins_status);
+    _mav_put_int32_t(buf, 68, ins_flag);
+    _mav_put_uint16_t(buf, 72, throttle);
+    _mav_put_uint8_t(buf, 74, flight_mode);
+    _mav_put_uint8_t(buf, 75, btake_status);
+
+        memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+#else
+    mavlink_fmub_status_t packet;
+    packet.timestamp = timestamp;
+    packet.roll = roll;
+    packet.pitch = pitch;
+    packet.yaw = yaw;
+    packet.vn = vn;
+    packet.ve = ve;
+    packet.vd = vd;
+    packet.ax = ax;
+    packet.ay = ay;
+    packet.az = az;
+    packet.gx = gx;
+    packet.gy = gy;
+    packet.gz = gz;
+    packet.lat = lat;
+    packet.lon = lon;
+    packet.amsl = amsl;
+    packet.ins_status = ins_status;
+    packet.ins_flag = ins_flag;
+    packet.throttle = throttle;
+    packet.flight_mode = flight_mode;
+    packet.btake_status = btake_status;
+
+        memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+#endif
+
+    msg->msgid = MAVLINK_MSG_ID_FMUB_STATUS;
+#if MAVLINK_CRC_EXTRA
+    return mavlink_finalize_message_buffer(msg, system_id, component_id, _status, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+#else
+    return mavlink_finalize_message_buffer(msg, system_id, component_id, _status, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+#endif
+}
+
+/**
+ * @brief Pack a fmub_status 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 will be sent over
+ * @param msg The MAVLink message to compress the data into
+ * @param timestamp [ms] timestamp from systemboot in ms.
+ * @param roll [rad] euler roll angle.
+ * @param pitch [rad] euler pitch angle.
+ * @param yaw [rad] euler yaw angle.
+ * @param vn [m/s] velocity in northward axis.
+ * @param ve [m/s] velocity in eastward axis.
+ * @param vd [m/s] velocity in downward axis.
+ * @param ax [m/s/s] acceleration in x axis.
+ * @param ay [m/s/s] acceleration in y axis.
+ * @param az [m/s/s] acceleration in z axis.
+ * @param gx [rad/s] angular velocity in x axis.
+ * @param gy [rad/s] angular velocity in y axis.
+ * @param gz [rad/s] angular velocity in z axis.
+ * @param lat [degE7] latitude.
+ * @param lon [degE7] longitude.
+ * @param amsl [m] altitude above mean sea level.
+ * @param ins_status  
+ * @param ins_flag  
+ * @param throttle  throttle output.
+ * @param flight_mode  flight mode.
+ * @param btake_status  backup takeover status.
+ * @return length of the message in bytes (excluding serial stream start sign)
+ */
+static inline uint16_t mavlink_msg_fmub_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
+                               mavlink_message_t* msg,
+                                   uint32_t timestamp,float roll,float pitch,float yaw,float vn,float ve,float vd,float ax,float ay,float az,float gx,float gy,float gz,int32_t lat,int32_t lon,float amsl,int32_t ins_status,int32_t ins_flag,uint16_t throttle,uint8_t flight_mode,uint8_t btake_status)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+    char buf[MAVLINK_MSG_ID_FMUB_STATUS_LEN];
+    _mav_put_uint32_t(buf, 0, timestamp);
+    _mav_put_float(buf, 4, roll);
+    _mav_put_float(buf, 8, pitch);
+    _mav_put_float(buf, 12, yaw);
+    _mav_put_float(buf, 16, vn);
+    _mav_put_float(buf, 20, ve);
+    _mav_put_float(buf, 24, vd);
+    _mav_put_float(buf, 28, ax);
+    _mav_put_float(buf, 32, ay);
+    _mav_put_float(buf, 36, az);
+    _mav_put_float(buf, 40, gx);
+    _mav_put_float(buf, 44, gy);
+    _mav_put_float(buf, 48, gz);
+    _mav_put_int32_t(buf, 52, lat);
+    _mav_put_int32_t(buf, 56, lon);
+    _mav_put_float(buf, 60, amsl);
+    _mav_put_int32_t(buf, 64, ins_status);
+    _mav_put_int32_t(buf, 68, ins_flag);
+    _mav_put_uint16_t(buf, 72, throttle);
+    _mav_put_uint8_t(buf, 74, flight_mode);
+    _mav_put_uint8_t(buf, 75, btake_status);
+
+        memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+#else
+    mavlink_fmub_status_t packet;
+    packet.timestamp = timestamp;
+    packet.roll = roll;
+    packet.pitch = pitch;
+    packet.yaw = yaw;
+    packet.vn = vn;
+    packet.ve = ve;
+    packet.vd = vd;
+    packet.ax = ax;
+    packet.ay = ay;
+    packet.az = az;
+    packet.gx = gx;
+    packet.gy = gy;
+    packet.gz = gz;
+    packet.lat = lat;
+    packet.lon = lon;
+    packet.amsl = amsl;
+    packet.ins_status = ins_status;
+    packet.ins_flag = ins_flag;
+    packet.throttle = throttle;
+    packet.flight_mode = flight_mode;
+    packet.btake_status = btake_status;
+
+        memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+#endif
+
+    msg->msgid = MAVLINK_MSG_ID_FMUB_STATUS;
+    return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+}
+
+/**
+ * @brief Encode a fmub_status struct
+ *
+ * @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 fmub_status C-struct to read the message contents from
+ */
+static inline uint16_t mavlink_msg_fmub_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_fmub_status_t* fmub_status)
+{
+    return mavlink_msg_fmub_status_pack(system_id, component_id, msg, fmub_status->timestamp, fmub_status->roll, fmub_status->pitch, fmub_status->yaw, fmub_status->vn, fmub_status->ve, fmub_status->vd, fmub_status->ax, fmub_status->ay, fmub_status->az, fmub_status->gx, fmub_status->gy, fmub_status->gz, fmub_status->lat, fmub_status->lon, fmub_status->amsl, fmub_status->ins_status, fmub_status->ins_flag, fmub_status->throttle, fmub_status->flight_mode, fmub_status->btake_status);
+}
+
+/**
+ * @brief Encode a fmub_status struct 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 will be sent over
+ * @param msg The MAVLink message to compress the data into
+ * @param fmub_status C-struct to read the message contents from
+ */
+static inline uint16_t mavlink_msg_fmub_status_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_fmub_status_t* fmub_status)
+{
+    return mavlink_msg_fmub_status_pack_chan(system_id, component_id, chan, msg, fmub_status->timestamp, fmub_status->roll, fmub_status->pitch, fmub_status->yaw, fmub_status->vn, fmub_status->ve, fmub_status->vd, fmub_status->ax, fmub_status->ay, fmub_status->az, fmub_status->gx, fmub_status->gy, fmub_status->gz, fmub_status->lat, fmub_status->lon, fmub_status->amsl, fmub_status->ins_status, fmub_status->ins_flag, fmub_status->throttle, fmub_status->flight_mode, fmub_status->btake_status);
+}
+
+/**
+ * @brief Encode a fmub_status struct with provided status structure
+ *
+ * @param system_id ID of this system
+ * @param component_id ID of this component (e.g. 200 for IMU)
+ * @param status MAVLink status structure
+ * @param msg The MAVLink message to compress the data into
+ * @param fmub_status C-struct to read the message contents from
+ */
+static inline uint16_t mavlink_msg_fmub_status_encode_status(uint8_t system_id, uint8_t component_id, mavlink_status_t* _status, mavlink_message_t* msg, const mavlink_fmub_status_t* fmub_status)
+{
+    return mavlink_msg_fmub_status_pack_status(system_id, component_id, _status, msg,  fmub_status->timestamp, fmub_status->roll, fmub_status->pitch, fmub_status->yaw, fmub_status->vn, fmub_status->ve, fmub_status->vd, fmub_status->ax, fmub_status->ay, fmub_status->az, fmub_status->gx, fmub_status->gy, fmub_status->gz, fmub_status->lat, fmub_status->lon, fmub_status->amsl, fmub_status->ins_status, fmub_status->ins_flag, fmub_status->throttle, fmub_status->flight_mode, fmub_status->btake_status);
+}
+
+/**
+ * @brief Send a fmub_status message
+ * @param chan MAVLink channel to send the message
+ *
+ * @param timestamp [ms] timestamp from systemboot in ms.
+ * @param roll [rad] euler roll angle.
+ * @param pitch [rad] euler pitch angle.
+ * @param yaw [rad] euler yaw angle.
+ * @param vn [m/s] velocity in northward axis.
+ * @param ve [m/s] velocity in eastward axis.
+ * @param vd [m/s] velocity in downward axis.
+ * @param ax [m/s/s] acceleration in x axis.
+ * @param ay [m/s/s] acceleration in y axis.
+ * @param az [m/s/s] acceleration in z axis.
+ * @param gx [rad/s] angular velocity in x axis.
+ * @param gy [rad/s] angular velocity in y axis.
+ * @param gz [rad/s] angular velocity in z axis.
+ * @param lat [degE7] latitude.
+ * @param lon [degE7] longitude.
+ * @param amsl [m] altitude above mean sea level.
+ * @param ins_status  
+ * @param ins_flag  
+ * @param throttle  throttle output.
+ * @param flight_mode  flight mode.
+ * @param btake_status  backup takeover status.
+ */
+#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
+
+static inline void mavlink_msg_fmub_status_send(mavlink_channel_t chan, uint32_t timestamp, float roll, float pitch, float yaw, float vn, float ve, float vd, float ax, float ay, float az, float gx, float gy, float gz, int32_t lat, int32_t lon, float amsl, int32_t ins_status, int32_t ins_flag, uint16_t throttle, uint8_t flight_mode, uint8_t btake_status)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+    char buf[MAVLINK_MSG_ID_FMUB_STATUS_LEN];
+    _mav_put_uint32_t(buf, 0, timestamp);
+    _mav_put_float(buf, 4, roll);
+    _mav_put_float(buf, 8, pitch);
+    _mav_put_float(buf, 12, yaw);
+    _mav_put_float(buf, 16, vn);
+    _mav_put_float(buf, 20, ve);
+    _mav_put_float(buf, 24, vd);
+    _mav_put_float(buf, 28, ax);
+    _mav_put_float(buf, 32, ay);
+    _mav_put_float(buf, 36, az);
+    _mav_put_float(buf, 40, gx);
+    _mav_put_float(buf, 44, gy);
+    _mav_put_float(buf, 48, gz);
+    _mav_put_int32_t(buf, 52, lat);
+    _mav_put_int32_t(buf, 56, lon);
+    _mav_put_float(buf, 60, amsl);
+    _mav_put_int32_t(buf, 64, ins_status);
+    _mav_put_int32_t(buf, 68, ins_flag);
+    _mav_put_uint16_t(buf, 72, throttle);
+    _mav_put_uint8_t(buf, 74, flight_mode);
+    _mav_put_uint8_t(buf, 75, btake_status);
+
+    _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FMUB_STATUS, buf, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+#else
+    mavlink_fmub_status_t packet;
+    packet.timestamp = timestamp;
+    packet.roll = roll;
+    packet.pitch = pitch;
+    packet.yaw = yaw;
+    packet.vn = vn;
+    packet.ve = ve;
+    packet.vd = vd;
+    packet.ax = ax;
+    packet.ay = ay;
+    packet.az = az;
+    packet.gx = gx;
+    packet.gy = gy;
+    packet.gz = gz;
+    packet.lat = lat;
+    packet.lon = lon;
+    packet.amsl = amsl;
+    packet.ins_status = ins_status;
+    packet.ins_flag = ins_flag;
+    packet.throttle = throttle;
+    packet.flight_mode = flight_mode;
+    packet.btake_status = btake_status;
+
+    _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FMUB_STATUS, (const char *)&packet, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+#endif
+}
+
+/**
+ * @brief Send a fmub_status message
+ * @param chan MAVLink channel to send the message
+ * @param struct The MAVLink struct to serialize
+ */
+static inline void mavlink_msg_fmub_status_send_struct(mavlink_channel_t chan, const mavlink_fmub_status_t* fmub_status)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+    mavlink_msg_fmub_status_send(chan, fmub_status->timestamp, fmub_status->roll, fmub_status->pitch, fmub_status->yaw, fmub_status->vn, fmub_status->ve, fmub_status->vd, fmub_status->ax, fmub_status->ay, fmub_status->az, fmub_status->gx, fmub_status->gy, fmub_status->gz, fmub_status->lat, fmub_status->lon, fmub_status->amsl, fmub_status->ins_status, fmub_status->ins_flag, fmub_status->throttle, fmub_status->flight_mode, fmub_status->btake_status);
+#else
+    _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FMUB_STATUS, (const char *)fmub_status, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+#endif
+}
+
+#if MAVLINK_MSG_ID_FMUB_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
+/*
+  This variant of _send() can be used to save stack space by reusing
+  memory from the receive buffer.  The caller provides a
+  mavlink_message_t which is the size of a full mavlink message. This
+  is usually the receive buffer for the channel, and allows a reply to an
+  incoming message with minimum stack space usage.
+ */
+static inline void mavlink_msg_fmub_status_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint32_t timestamp, float roll, float pitch, float yaw, float vn, float ve, float vd, float ax, float ay, float az, float gx, float gy, float gz, int32_t lat, int32_t lon, float amsl, int32_t ins_status, int32_t ins_flag, uint16_t throttle, uint8_t flight_mode, uint8_t btake_status)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+    char *buf = (char *)msgbuf;
+    _mav_put_uint32_t(buf, 0, timestamp);
+    _mav_put_float(buf, 4, roll);
+    _mav_put_float(buf, 8, pitch);
+    _mav_put_float(buf, 12, yaw);
+    _mav_put_float(buf, 16, vn);
+    _mav_put_float(buf, 20, ve);
+    _mav_put_float(buf, 24, vd);
+    _mav_put_float(buf, 28, ax);
+    _mav_put_float(buf, 32, ay);
+    _mav_put_float(buf, 36, az);
+    _mav_put_float(buf, 40, gx);
+    _mav_put_float(buf, 44, gy);
+    _mav_put_float(buf, 48, gz);
+    _mav_put_int32_t(buf, 52, lat);
+    _mav_put_int32_t(buf, 56, lon);
+    _mav_put_float(buf, 60, amsl);
+    _mav_put_int32_t(buf, 64, ins_status);
+    _mav_put_int32_t(buf, 68, ins_flag);
+    _mav_put_uint16_t(buf, 72, throttle);
+    _mav_put_uint8_t(buf, 74, flight_mode);
+    _mav_put_uint8_t(buf, 75, btake_status);
+
+    _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FMUB_STATUS, buf, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+#else
+    mavlink_fmub_status_t *packet = (mavlink_fmub_status_t *)msgbuf;
+    packet->timestamp = timestamp;
+    packet->roll = roll;
+    packet->pitch = pitch;
+    packet->yaw = yaw;
+    packet->vn = vn;
+    packet->ve = ve;
+    packet->vd = vd;
+    packet->ax = ax;
+    packet->ay = ay;
+    packet->az = az;
+    packet->gx = gx;
+    packet->gy = gy;
+    packet->gz = gz;
+    packet->lat = lat;
+    packet->lon = lon;
+    packet->amsl = amsl;
+    packet->ins_status = ins_status;
+    packet->ins_flag = ins_flag;
+    packet->throttle = throttle;
+    packet->flight_mode = flight_mode;
+    packet->btake_status = btake_status;
+
+    _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FMUB_STATUS, (const char *)packet, MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN, MAVLINK_MSG_ID_FMUB_STATUS_LEN, MAVLINK_MSG_ID_FMUB_STATUS_CRC);
+#endif
+}
+#endif
+
+#endif
+
+// MESSAGE FMUB_STATUS UNPACKING
+
+
+/**
+ * @brief Get field timestamp from fmub_status message
+ *
+ * @return [ms] timestamp from systemboot in ms.
+ */
+static inline uint32_t mavlink_msg_fmub_status_get_timestamp(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_uint32_t(msg,  0);
+}
+
+/**
+ * @brief Get field roll from fmub_status message
+ *
+ * @return [rad] euler roll angle.
+ */
+static inline float mavlink_msg_fmub_status_get_roll(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  4);
+}
+
+/**
+ * @brief Get field pitch from fmub_status message
+ *
+ * @return [rad] euler pitch angle.
+ */
+static inline float mavlink_msg_fmub_status_get_pitch(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  8);
+}
+
+/**
+ * @brief Get field yaw from fmub_status message
+ *
+ * @return [rad] euler yaw angle.
+ */
+static inline float mavlink_msg_fmub_status_get_yaw(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  12);
+}
+
+/**
+ * @brief Get field vn from fmub_status message
+ *
+ * @return [m/s] velocity in northward axis.
+ */
+static inline float mavlink_msg_fmub_status_get_vn(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  16);
+}
+
+/**
+ * @brief Get field ve from fmub_status message
+ *
+ * @return [m/s] velocity in eastward axis.
+ */
+static inline float mavlink_msg_fmub_status_get_ve(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  20);
+}
+
+/**
+ * @brief Get field vd from fmub_status message
+ *
+ * @return [m/s] velocity in downward axis.
+ */
+static inline float mavlink_msg_fmub_status_get_vd(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  24);
+}
+
+/**
+ * @brief Get field ax from fmub_status message
+ *
+ * @return [m/s/s] acceleration in x axis.
+ */
+static inline float mavlink_msg_fmub_status_get_ax(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  28);
+}
+
+/**
+ * @brief Get field ay from fmub_status message
+ *
+ * @return [m/s/s] acceleration in y axis.
+ */
+static inline float mavlink_msg_fmub_status_get_ay(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  32);
+}
+
+/**
+ * @brief Get field az from fmub_status message
+ *
+ * @return [m/s/s] acceleration in z axis.
+ */
+static inline float mavlink_msg_fmub_status_get_az(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  36);
+}
+
+/**
+ * @brief Get field gx from fmub_status message
+ *
+ * @return [rad/s] angular velocity in x axis.
+ */
+static inline float mavlink_msg_fmub_status_get_gx(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  40);
+}
+
+/**
+ * @brief Get field gy from fmub_status message
+ *
+ * @return [rad/s] angular velocity in y axis.
+ */
+static inline float mavlink_msg_fmub_status_get_gy(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  44);
+}
+
+/**
+ * @brief Get field gz from fmub_status message
+ *
+ * @return [rad/s] angular velocity in z axis.
+ */
+static inline float mavlink_msg_fmub_status_get_gz(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  48);
+}
+
+/**
+ * @brief Get field lat from fmub_status message
+ *
+ * @return [degE7] latitude.
+ */
+static inline int32_t mavlink_msg_fmub_status_get_lat(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_int32_t(msg,  52);
+}
+
+/**
+ * @brief Get field lon from fmub_status message
+ *
+ * @return [degE7] longitude.
+ */
+static inline int32_t mavlink_msg_fmub_status_get_lon(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_int32_t(msg,  56);
+}
+
+/**
+ * @brief Get field amsl from fmub_status message
+ *
+ * @return [m] altitude above mean sea level.
+ */
+static inline float mavlink_msg_fmub_status_get_amsl(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_float(msg,  60);
+}
+
+/**
+ * @brief Get field ins_status from fmub_status message
+ *
+ * @return  
+ */
+static inline int32_t mavlink_msg_fmub_status_get_ins_status(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_int32_t(msg,  64);
+}
+
+/**
+ * @brief Get field ins_flag from fmub_status message
+ *
+ * @return  
+ */
+static inline int32_t mavlink_msg_fmub_status_get_ins_flag(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_int32_t(msg,  68);
+}
+
+/**
+ * @brief Get field throttle from fmub_status message
+ *
+ * @return  throttle output.
+ */
+static inline uint16_t mavlink_msg_fmub_status_get_throttle(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_uint16_t(msg,  72);
+}
+
+/**
+ * @brief Get field flight_mode from fmub_status message
+ *
+ * @return  flight mode.
+ */
+static inline uint8_t mavlink_msg_fmub_status_get_flight_mode(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_uint8_t(msg,  74);
+}
+
+/**
+ * @brief Get field btake_status from fmub_status message
+ *
+ * @return  backup takeover status.
+ */
+static inline uint8_t mavlink_msg_fmub_status_get_btake_status(const mavlink_message_t* msg)
+{
+    return _MAV_RETURN_uint8_t(msg,  75);
+}
+
+/**
+ * @brief Decode a fmub_status message into a struct
+ *
+ * @param msg The message to decode
+ * @param fmub_status C-struct to decode the message contents into
+ */
+static inline void mavlink_msg_fmub_status_decode(const mavlink_message_t* msg, mavlink_fmub_status_t* fmub_status)
+{
+#if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
+    fmub_status->timestamp = mavlink_msg_fmub_status_get_timestamp(msg);
+    fmub_status->roll = mavlink_msg_fmub_status_get_roll(msg);
+    fmub_status->pitch = mavlink_msg_fmub_status_get_pitch(msg);
+    fmub_status->yaw = mavlink_msg_fmub_status_get_yaw(msg);
+    fmub_status->vn = mavlink_msg_fmub_status_get_vn(msg);
+    fmub_status->ve = mavlink_msg_fmub_status_get_ve(msg);
+    fmub_status->vd = mavlink_msg_fmub_status_get_vd(msg);
+    fmub_status->ax = mavlink_msg_fmub_status_get_ax(msg);
+    fmub_status->ay = mavlink_msg_fmub_status_get_ay(msg);
+    fmub_status->az = mavlink_msg_fmub_status_get_az(msg);
+    fmub_status->gx = mavlink_msg_fmub_status_get_gx(msg);
+    fmub_status->gy = mavlink_msg_fmub_status_get_gy(msg);
+    fmub_status->gz = mavlink_msg_fmub_status_get_gz(msg);
+    fmub_status->lat = mavlink_msg_fmub_status_get_lat(msg);
+    fmub_status->lon = mavlink_msg_fmub_status_get_lon(msg);
+    fmub_status->amsl = mavlink_msg_fmub_status_get_amsl(msg);
+    fmub_status->ins_status = mavlink_msg_fmub_status_get_ins_status(msg);
+    fmub_status->ins_flag = mavlink_msg_fmub_status_get_ins_flag(msg);
+    fmub_status->throttle = mavlink_msg_fmub_status_get_throttle(msg);
+    fmub_status->flight_mode = mavlink_msg_fmub_status_get_flight_mode(msg);
+    fmub_status->btake_status = mavlink_msg_fmub_status_get_btake_status(msg);
+#else
+        uint8_t len = msg->len < MAVLINK_MSG_ID_FMUB_STATUS_LEN? msg->len : MAVLINK_MSG_ID_FMUB_STATUS_LEN;
+        memset(fmub_status, 0, MAVLINK_MSG_ID_FMUB_STATUS_LEN);
+    memcpy(fmub_status, _MAV_PAYLOAD(msg), len);
+#endif
+}

+ 80 - 0
v2.0/VKFly/testsuite.h

@@ -1626,6 +1626,85 @@ static void mavlink_test_vk_update_terminate(uint8_t system_id, uint8_t componen
 #endif
 }
 
+static void mavlink_test_fmub_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
+{
+#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
+    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
+        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_FMUB_STATUS >= 256) {
+            return;
+        }
+#endif
+    mavlink_message_t msg;
+        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
+        uint16_t i;
+    mavlink_fmub_status_t packet_in = {
+        963497464,45.0,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,353.0,963500168,963500376,437.0,963500792,963501000,20979,99,166
+    };
+    mavlink_fmub_status_t packet1, packet2;
+        memset(&packet1, 0, sizeof(packet1));
+        packet1.timestamp = packet_in.timestamp;
+        packet1.roll = packet_in.roll;
+        packet1.pitch = packet_in.pitch;
+        packet1.yaw = packet_in.yaw;
+        packet1.vn = packet_in.vn;
+        packet1.ve = packet_in.ve;
+        packet1.vd = packet_in.vd;
+        packet1.ax = packet_in.ax;
+        packet1.ay = packet_in.ay;
+        packet1.az = packet_in.az;
+        packet1.gx = packet_in.gx;
+        packet1.gy = packet_in.gy;
+        packet1.gz = packet_in.gz;
+        packet1.lat = packet_in.lat;
+        packet1.lon = packet_in.lon;
+        packet1.amsl = packet_in.amsl;
+        packet1.ins_status = packet_in.ins_status;
+        packet1.ins_flag = packet_in.ins_flag;
+        packet1.throttle = packet_in.throttle;
+        packet1.flight_mode = packet_in.flight_mode;
+        packet1.btake_status = packet_in.btake_status;
+        
+        
+#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
+        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
+           // cope with extensions
+           memset(MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_FMUB_STATUS_MIN_LEN);
+        }
+#endif
+        memset(&packet2, 0, sizeof(packet2));
+    mavlink_msg_fmub_status_encode(system_id, component_id, &msg, &packet1);
+    mavlink_msg_fmub_status_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+    mavlink_msg_fmub_status_pack(system_id, component_id, &msg , packet1.timestamp , packet1.roll , packet1.pitch , packet1.yaw , packet1.vn , packet1.ve , packet1.vd , packet1.ax , packet1.ay , packet1.az , packet1.gx , packet1.gy , packet1.gz , packet1.lat , packet1.lon , packet1.amsl , packet1.ins_status , packet1.ins_flag , packet1.throttle , packet1.flight_mode , packet1.btake_status );
+    mavlink_msg_fmub_status_decode(&msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+        memset(&packet2, 0, sizeof(packet2));
+    mavlink_msg_fmub_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.timestamp , packet1.roll , packet1.pitch , packet1.yaw , packet1.vn , packet1.ve , packet1.vd , packet1.ax , packet1.ay , packet1.az , packet1.gx , packet1.gy , packet1.gz , packet1.lat , packet1.lon , packet1.amsl , packet1.ins_status , packet1.ins_flag , packet1.throttle , packet1.flight_mode , packet1.btake_status );
+    mavlink_msg_fmub_status_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_fmub_status_decode(last_msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+        
+        memset(&packet2, 0, sizeof(packet2));
+    mavlink_msg_fmub_status_send(MAVLINK_COMM_1 , packet1.timestamp , packet1.roll , packet1.pitch , packet1.yaw , packet1.vn , packet1.ve , packet1.vd , packet1.ax , packet1.ay , packet1.az , packet1.gx , packet1.gy , packet1.gz , packet1.lat , packet1.lon , packet1.amsl , packet1.ins_status , packet1.ins_flag , packet1.throttle , packet1.flight_mode , packet1.btake_status );
+    mavlink_msg_fmub_status_decode(last_msg, &packet2);
+        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
+
+#ifdef MAVLINK_HAVE_GET_MESSAGE_INFO
+    MAVLINK_ASSERT(mavlink_get_message_info_by_name("FMUB_STATUS") != NULL);
+    MAVLINK_ASSERT(mavlink_get_message_info_by_id(MAVLINK_MSG_ID_FMUB_STATUS) != NULL);
+#endif
+}
+
 static void mavlink_test_qingxie_bms(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
 {
 #ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
@@ -1733,6 +1812,7 @@ static void mavlink_test_VKFly(uint8_t system_id, uint8_t component_id, mavlink_
     mavlink_test_vk_fw_update_data_request(system_id, component_id, last_msg);
     mavlink_test_vk_fw_update_data(system_id, component_id, last_msg);
     mavlink_test_vk_update_terminate(system_id, component_id, last_msg);
+    mavlink_test_fmub_status(system_id, component_id, last_msg);
     mavlink_test_qingxie_bms(system_id, component_id, last_msg);
 }
 

+ 1 - 1
v2.0/VKFly/version.h

@@ -7,7 +7,7 @@
 #ifndef MAVLINK_VERSION_H
 #define MAVLINK_VERSION_H
 
-#define MAVLINK_BUILD_DATE "Mon Oct 06 2025"
+#define MAVLINK_BUILD_DATE "Mon Oct 27 2025"
 #define MAVLINK_WIRE_PROTOCOL_VERSION "2.0"
 #define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 255
  

+ 1 - 1
v2.0/common/common.h

@@ -10,7 +10,7 @@
     #error Wrong include order: MAVLINK_COMMON.H MUST NOT BE DIRECTLY USED. Include mavlink.h from the same directory instead or set ALL AND EVERY defines from MAVLINK.H manually accordingly, including the #define MAVLINK_H call.
 #endif
 
-#define MAVLINK_COMMON_XML_HASH -4402396047576202426
+#define MAVLINK_COMMON_XML_HASH 1506392497819245865
 
 #ifdef __cplusplus
 extern "C" {

+ 1 - 1
v2.0/common/mavlink.h

@@ -6,7 +6,7 @@
 #ifndef MAVLINK_H
 #define MAVLINK_H
 
-#define MAVLINK_PRIMARY_XML_HASH -4402396047576202426
+#define MAVLINK_PRIMARY_XML_HASH 1506392497819245865
 
 #ifndef MAVLINK_STX
 #define MAVLINK_STX 253

+ 28 - 0
v2.0/common/mavlink_msg_battery_info.h

@@ -122,6 +122,7 @@ typedef struct __mavlink_battery_info_t {
  * @param name  Battery device name. Formatted as manufacturer name then product name, separated with an underscore (in ASCII characters), 0 terminated. All 0: field not provided.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint8_t id, uint8_t battery_function, uint8_t type, uint8_t state_of_health, uint8_t cells_in_series, uint16_t cycle_count, uint16_t weight, float discharge_minimum_voltage, float charging_minimum_voltage, float resting_minimum_voltage, float charging_maximum_voltage, float charging_maximum_current, float nominal_voltage, float discharge_maximum_current, float discharge_maximum_burst_current, float design_capacity, float full_charge_capacity, const char *manufacture_date, const char *serial_number, const char *name)
 {
@@ -293,6 +294,7 @@ static inline uint16_t mavlink_msg_battery_info_pack_status(uint8_t system_id, u
  * @param name  Battery device name. Formatted as manufacturer name then product name, separated with an underscore (in ASCII characters), 0 terminated. All 0: field not provided.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint8_t id,uint8_t battery_function,uint8_t type,uint8_t state_of_health,uint8_t cells_in_series,uint16_t cycle_count,uint16_t weight,float discharge_minimum_voltage,float charging_minimum_voltage,float resting_minimum_voltage,float charging_maximum_voltage,float charging_maximum_current,float nominal_voltage,float discharge_maximum_current,float discharge_maximum_burst_current,float design_capacity,float full_charge_capacity,const char *manufacture_date,const char *serial_number,const char *name)
@@ -357,6 +359,7 @@ static inline uint16_t mavlink_msg_battery_info_pack_chan(uint8_t system_id, uin
  * @param msg The MAVLink message to compress the data into
  * @param battery_info C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_battery_info_t* battery_info)
 {
     return mavlink_msg_battery_info_pack(system_id, component_id, msg, battery_info->id, battery_info->battery_function, battery_info->type, battery_info->state_of_health, battery_info->cells_in_series, battery_info->cycle_count, battery_info->weight, battery_info->discharge_minimum_voltage, battery_info->charging_minimum_voltage, battery_info->resting_minimum_voltage, battery_info->charging_maximum_voltage, battery_info->charging_maximum_current, battery_info->nominal_voltage, battery_info->discharge_maximum_current, battery_info->discharge_maximum_burst_current, battery_info->design_capacity, battery_info->full_charge_capacity, battery_info->manufacture_date, battery_info->serial_number, battery_info->name);
@@ -371,6 +374,7 @@ static inline uint16_t mavlink_msg_battery_info_encode(uint8_t system_id, uint8_
  * @param msg The MAVLink message to compress the data into
  * @param battery_info C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_battery_info_t* battery_info)
 {
     return mavlink_msg_battery_info_pack_chan(system_id, component_id, chan, msg, battery_info->id, battery_info->battery_function, battery_info->type, battery_info->state_of_health, battery_info->cells_in_series, battery_info->cycle_count, battery_info->weight, battery_info->discharge_minimum_voltage, battery_info->charging_minimum_voltage, battery_info->resting_minimum_voltage, battery_info->charging_maximum_voltage, battery_info->charging_maximum_current, battery_info->nominal_voltage, battery_info->discharge_maximum_current, battery_info->discharge_maximum_burst_current, battery_info->design_capacity, battery_info->full_charge_capacity, battery_info->manufacture_date, battery_info->serial_number, battery_info->name);
@@ -417,6 +421,7 @@ static inline uint16_t mavlink_msg_battery_info_encode_status(uint8_t system_id,
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_battery_info_send(mavlink_channel_t chan, uint8_t id, uint8_t battery_function, uint8_t type, uint8_t state_of_health, uint8_t cells_in_series, uint16_t cycle_count, uint16_t weight, float discharge_minimum_voltage, float charging_minimum_voltage, float resting_minimum_voltage, float charging_maximum_voltage, float charging_maximum_current, float nominal_voltage, float discharge_maximum_current, float discharge_maximum_burst_current, float design_capacity, float full_charge_capacity, const char *manufacture_date, const char *serial_number, const char *name)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -473,6 +478,7 @@ static inline void mavlink_msg_battery_info_send(mavlink_channel_t chan, uint8_t
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_battery_info_send_struct(mavlink_channel_t chan, const mavlink_battery_info_t* battery_info)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -490,6 +496,7 @@ static inline void mavlink_msg_battery_info_send_struct(mavlink_channel_t chan,
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_battery_info_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t id, uint8_t battery_function, uint8_t type, uint8_t state_of_health, uint8_t cells_in_series, uint16_t cycle_count, uint16_t weight, float discharge_minimum_voltage, float charging_minimum_voltage, float resting_minimum_voltage, float charging_maximum_voltage, float charging_maximum_current, float nominal_voltage, float discharge_maximum_current, float discharge_maximum_burst_current, float design_capacity, float full_charge_capacity, const char *manufacture_date, const char *serial_number, const char *name)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -552,6 +559,7 @@ static inline void mavlink_msg_battery_info_send_buf(mavlink_message_t *msgbuf,
  *
  * @return  Battery ID
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_battery_info_get_id(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  44);
@@ -562,6 +570,7 @@ static inline uint8_t mavlink_msg_battery_info_get_id(const mavlink_message_t* m
  *
  * @return  Function of the battery.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_battery_info_get_battery_function(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  45);
@@ -572,6 +581,7 @@ static inline uint8_t mavlink_msg_battery_info_get_battery_function(const mavlin
  *
  * @return  Type (chemistry) of the battery.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_battery_info_get_type(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  46);
@@ -582,6 +592,7 @@ static inline uint8_t mavlink_msg_battery_info_get_type(const mavlink_message_t*
  *
  * @return [%] State of Health (SOH) estimate. Typically 100% at the time of manufacture and will decrease over time and use. -1: field not provided.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_battery_info_get_state_of_health(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  47);
@@ -592,6 +603,7 @@ static inline uint8_t mavlink_msg_battery_info_get_state_of_health(const mavlink
  *
  * @return  Number of battery cells in series. 0: field not provided.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_battery_info_get_cells_in_series(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  48);
@@ -602,6 +614,7 @@ static inline uint8_t mavlink_msg_battery_info_get_cells_in_series(const mavlink
  *
  * @return  Lifetime count of the number of charge/discharge cycles (https://en.wikipedia.org/wiki/Charge_cycle). UINT16_MAX: field not provided.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_get_cycle_count(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  40);
@@ -612,6 +625,7 @@ static inline uint16_t mavlink_msg_battery_info_get_cycle_count(const mavlink_me
  *
  * @return [g] Battery weight. 0: field not provided.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_get_weight(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  42);
@@ -622,6 +636,7 @@ static inline uint16_t mavlink_msg_battery_info_get_weight(const mavlink_message
  *
  * @return [V] Minimum per-cell voltage when discharging. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_discharge_minimum_voltage(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  0);
@@ -632,6 +647,7 @@ static inline float mavlink_msg_battery_info_get_discharge_minimum_voltage(const
  *
  * @return [V] Minimum per-cell voltage when charging. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_charging_minimum_voltage(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  4);
@@ -642,6 +658,7 @@ static inline float mavlink_msg_battery_info_get_charging_minimum_voltage(const
  *
  * @return [V] Minimum per-cell voltage when resting. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_resting_minimum_voltage(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  8);
@@ -652,6 +669,7 @@ static inline float mavlink_msg_battery_info_get_resting_minimum_voltage(const m
  *
  * @return [V] Maximum per-cell voltage when charged. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_charging_maximum_voltage(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  12);
@@ -662,6 +680,7 @@ static inline float mavlink_msg_battery_info_get_charging_maximum_voltage(const
  *
  * @return [A] Maximum pack continuous charge current. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_charging_maximum_current(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  16);
@@ -672,6 +691,7 @@ static inline float mavlink_msg_battery_info_get_charging_maximum_current(const
  *
  * @return [V] Battery nominal voltage. Used for conversion between Wh and Ah. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_nominal_voltage(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  20);
@@ -682,6 +702,7 @@ static inline float mavlink_msg_battery_info_get_nominal_voltage(const mavlink_m
  *
  * @return [A] Maximum pack discharge current. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_discharge_maximum_current(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  24);
@@ -692,6 +713,7 @@ static inline float mavlink_msg_battery_info_get_discharge_maximum_current(const
  *
  * @return [A] Maximum pack discharge burst current. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_discharge_maximum_burst_current(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  28);
@@ -702,6 +724,7 @@ static inline float mavlink_msg_battery_info_get_discharge_maximum_burst_current
  *
  * @return [Ah] Fully charged design capacity. 0: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_design_capacity(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  32);
@@ -712,6 +735,7 @@ static inline float mavlink_msg_battery_info_get_design_capacity(const mavlink_m
  *
  * @return [Ah] Predicted battery capacity when fully charged (accounting for battery degradation). NAN: field not provided.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_battery_info_get_full_charge_capacity(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  36);
@@ -722,6 +746,7 @@ static inline float mavlink_msg_battery_info_get_full_charge_capacity(const mavl
  *
  * @return  Manufacture date (DDMMYYYY) in ASCII characters, 0 terminated. All 0: field not provided.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_get_manufacture_date(const mavlink_message_t* msg, char *manufacture_date)
 {
     return _MAV_RETURN_char_array(msg, manufacture_date, 9,  49);
@@ -732,6 +757,7 @@ static inline uint16_t mavlink_msg_battery_info_get_manufacture_date(const mavli
  *
  * @return  Serial number in ASCII characters, 0 terminated. All 0: field not provided.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_get_serial_number(const mavlink_message_t* msg, char *serial_number)
 {
     return _MAV_RETURN_char_array(msg, serial_number, 32,  58);
@@ -742,6 +768,7 @@ static inline uint16_t mavlink_msg_battery_info_get_serial_number(const mavlink_
  *
  * @return  Battery device name. Formatted as manufacturer name then product name, separated with an underscore (in ASCII characters), 0 terminated. All 0: field not provided.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_battery_info_get_name(const mavlink_message_t* msg, char *name)
 {
     return _MAV_RETURN_char_array(msg, name, 50,  90);
@@ -753,6 +780,7 @@ static inline uint16_t mavlink_msg_battery_info_get_name(const mavlink_message_t
  * @param msg The message to decode
  * @param battery_info C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_battery_info_decode(const mavlink_message_t* msg, mavlink_battery_info_t* battery_info)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 11 - 0
v2.0/common/mavlink_msg_command_cancel.h

@@ -52,6 +52,7 @@ typedef struct __mavlink_command_cancel_t {
  * @param command  Command ID (of command to cancel).
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_command_cancel_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint8_t target_system, uint8_t target_component, uint16_t command)
 {
@@ -125,6 +126,7 @@ static inline uint16_t mavlink_msg_command_cancel_pack_status(uint8_t system_id,
  * @param command  Command ID (of command to cancel).
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_command_cancel_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint8_t target_system,uint8_t target_component,uint16_t command)
@@ -157,6 +159,7 @@ static inline uint16_t mavlink_msg_command_cancel_pack_chan(uint8_t system_id, u
  * @param msg The MAVLink message to compress the data into
  * @param command_cancel C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_command_cancel_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_command_cancel_t* command_cancel)
 {
     return mavlink_msg_command_cancel_pack(system_id, component_id, msg, command_cancel->target_system, command_cancel->target_component, command_cancel->command);
@@ -171,6 +174,7 @@ static inline uint16_t mavlink_msg_command_cancel_encode(uint8_t system_id, uint
  * @param msg The MAVLink message to compress the data into
  * @param command_cancel C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_command_cancel_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_command_cancel_t* command_cancel)
 {
     return mavlink_msg_command_cancel_pack_chan(system_id, component_id, chan, msg, command_cancel->target_system, command_cancel->target_component, command_cancel->command);
@@ -200,6 +204,7 @@ static inline uint16_t mavlink_msg_command_cancel_encode_status(uint8_t system_i
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_command_cancel_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t command)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -224,6 +229,7 @@ static inline void mavlink_msg_command_cancel_send(mavlink_channel_t chan, uint8
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_command_cancel_send_struct(mavlink_channel_t chan, const mavlink_command_cancel_t* command_cancel)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -241,6 +247,7 @@ static inline void mavlink_msg_command_cancel_send_struct(mavlink_channel_t chan
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_command_cancel_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t target_system, uint8_t target_component, uint16_t command)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -271,6 +278,7 @@ static inline void mavlink_msg_command_cancel_send_buf(mavlink_message_t *msgbuf
  *
  * @return  System executing long running command. Should not be broadcast (0).
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_command_cancel_get_target_system(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  2);
@@ -281,6 +289,7 @@ static inline uint8_t mavlink_msg_command_cancel_get_target_system(const mavlink
  *
  * @return  Component executing long running command.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_command_cancel_get_target_component(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  3);
@@ -291,6 +300,7 @@ static inline uint8_t mavlink_msg_command_cancel_get_target_component(const mavl
  *
  * @return  Command ID (of command to cancel).
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_command_cancel_get_command(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  0);
@@ -302,6 +312,7 @@ static inline uint16_t mavlink_msg_command_cancel_get_command(const mavlink_mess
  * @param msg The message to decode
  * @param command_cancel C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_command_cancel_decode(const mavlink_message_t* msg, mavlink_command_cancel_t* command_cancel)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 11 - 0
v2.0/common/mavlink_msg_component_metadata.h

@@ -52,6 +52,7 @@ typedef struct __mavlink_component_metadata_t {
  * @param uri  MAVLink FTP URI for the general metadata file (COMP_METADATA_TYPE_GENERAL), which may be compressed with xz. The file contains general component metadata, and may contain URI links for additional metadata (see COMP_METADATA_TYPE). The information is static from boot, and may be generated at compile time. The string needs to be zero terminated.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_component_metadata_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint32_t time_boot_ms, uint32_t file_crc, const char *uri)
 {
@@ -121,6 +122,7 @@ static inline uint16_t mavlink_msg_component_metadata_pack_status(uint8_t system
  * @param uri  MAVLink FTP URI for the general metadata file (COMP_METADATA_TYPE_GENERAL), which may be compressed with xz. The file contains general component metadata, and may contain URI links for additional metadata (see COMP_METADATA_TYPE). The information is static from boot, and may be generated at compile time. The string needs to be zero terminated.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_component_metadata_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint32_t time_boot_ms,uint32_t file_crc,const char *uri)
@@ -151,6 +153,7 @@ static inline uint16_t mavlink_msg_component_metadata_pack_chan(uint8_t system_i
  * @param msg The MAVLink message to compress the data into
  * @param component_metadata C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_component_metadata_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_component_metadata_t* component_metadata)
 {
     return mavlink_msg_component_metadata_pack(system_id, component_id, msg, component_metadata->time_boot_ms, component_metadata->file_crc, component_metadata->uri);
@@ -165,6 +168,7 @@ static inline uint16_t mavlink_msg_component_metadata_encode(uint8_t system_id,
  * @param msg The MAVLink message to compress the data into
  * @param component_metadata C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_component_metadata_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_component_metadata_t* component_metadata)
 {
     return mavlink_msg_component_metadata_pack_chan(system_id, component_id, chan, msg, component_metadata->time_boot_ms, component_metadata->file_crc, component_metadata->uri);
@@ -194,6 +198,7 @@ static inline uint16_t mavlink_msg_component_metadata_encode_status(uint8_t syst
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_component_metadata_send(mavlink_channel_t chan, uint32_t time_boot_ms, uint32_t file_crc, const char *uri)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -216,6 +221,7 @@ static inline void mavlink_msg_component_metadata_send(mavlink_channel_t chan, u
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_component_metadata_send_struct(mavlink_channel_t chan, const mavlink_component_metadata_t* component_metadata)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -233,6 +239,7 @@ static inline void mavlink_msg_component_metadata_send_struct(mavlink_channel_t
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_component_metadata_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint32_t time_boot_ms, uint32_t file_crc, const char *uri)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -261,6 +268,7 @@ static inline void mavlink_msg_component_metadata_send_buf(mavlink_message_t *ms
  *
  * @return [ms] Timestamp (time since system boot).
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_component_metadata_get_time_boot_ms(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  0);
@@ -271,6 +279,7 @@ static inline uint32_t mavlink_msg_component_metadata_get_time_boot_ms(const mav
  *
  * @return  CRC32 of the general metadata file.
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_component_metadata_get_file_crc(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  4);
@@ -281,6 +290,7 @@ static inline uint32_t mavlink_msg_component_metadata_get_file_crc(const mavlink
  *
  * @return  MAVLink FTP URI for the general metadata file (COMP_METADATA_TYPE_GENERAL), which may be compressed with xz. The file contains general component metadata, and may contain URI links for additional metadata (see COMP_METADATA_TYPE). The information is static from boot, and may be generated at compile time. The string needs to be zero terminated.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_component_metadata_get_uri(const mavlink_message_t* msg, char *uri)
 {
     return _MAV_RETURN_char_array(msg, uri, 100,  8);
@@ -292,6 +302,7 @@ static inline uint16_t mavlink_msg_component_metadata_get_uri(const mavlink_mess
  * @param msg The message to decode
  * @param component_metadata C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_component_metadata_decode(const mavlink_message_t* msg, mavlink_component_metadata_t* component_metadata)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 10 - 0
v2.0/common/mavlink_msg_current_event_sequence.h

@@ -48,6 +48,7 @@ typedef struct __mavlink_current_event_sequence_t {
  * @param flags  Flag bitset.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_current_event_sequence_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint16_t sequence, uint8_t flags)
 {
@@ -115,6 +116,7 @@ static inline uint16_t mavlink_msg_current_event_sequence_pack_status(uint8_t sy
  * @param flags  Flag bitset.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_current_event_sequence_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint16_t sequence,uint8_t flags)
@@ -145,6 +147,7 @@ static inline uint16_t mavlink_msg_current_event_sequence_pack_chan(uint8_t syst
  * @param msg The MAVLink message to compress the data into
  * @param current_event_sequence C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_current_event_sequence_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_current_event_sequence_t* current_event_sequence)
 {
     return mavlink_msg_current_event_sequence_pack(system_id, component_id, msg, current_event_sequence->sequence, current_event_sequence->flags);
@@ -159,6 +162,7 @@ static inline uint16_t mavlink_msg_current_event_sequence_encode(uint8_t system_
  * @param msg The MAVLink message to compress the data into
  * @param current_event_sequence C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_current_event_sequence_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_current_event_sequence_t* current_event_sequence)
 {
     return mavlink_msg_current_event_sequence_pack_chan(system_id, component_id, chan, msg, current_event_sequence->sequence, current_event_sequence->flags);
@@ -187,6 +191,7 @@ static inline uint16_t mavlink_msg_current_event_sequence_encode_status(uint8_t
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_current_event_sequence_send(mavlink_channel_t chan, uint16_t sequence, uint8_t flags)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -209,6 +214,7 @@ static inline void mavlink_msg_current_event_sequence_send(mavlink_channel_t cha
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_current_event_sequence_send_struct(mavlink_channel_t chan, const mavlink_current_event_sequence_t* current_event_sequence)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -226,6 +232,7 @@ static inline void mavlink_msg_current_event_sequence_send_struct(mavlink_channe
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_current_event_sequence_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint16_t sequence, uint8_t flags)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -254,6 +261,7 @@ static inline void mavlink_msg_current_event_sequence_send_buf(mavlink_message_t
  *
  * @return  Sequence number.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_current_event_sequence_get_sequence(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  0);
@@ -264,6 +272,7 @@ static inline uint16_t mavlink_msg_current_event_sequence_get_sequence(const mav
  *
  * @return  Flag bitset.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_current_event_sequence_get_flags(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  2);
@@ -275,6 +284,7 @@ static inline uint8_t mavlink_msg_current_event_sequence_get_flags(const mavlink
  * @param msg The message to decode
  * @param current_event_sequence C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_current_event_sequence_decode(const mavlink_message_t* msg, mavlink_current_event_sequence_t* current_event_sequence)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 17 - 0
v2.0/common/mavlink_msg_esc_info.h

@@ -78,6 +78,7 @@ typedef struct __mavlink_esc_info_t {
  * @param temperature [cdegC] Temperature of each ESC. INT16_MAX: if data not supplied by ESC.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint8_t index, uint64_t time_usec, uint16_t counter, uint8_t count, uint8_t connection_type, uint8_t info, const uint16_t *failure_flags, const uint32_t *error_count, const int16_t *temperature)
 {
@@ -183,6 +184,7 @@ static inline uint16_t mavlink_msg_esc_info_pack_status(uint8_t system_id, uint8
  * @param temperature [cdegC] Temperature of each ESC. INT16_MAX: if data not supplied by ESC.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint8_t index,uint64_t time_usec,uint16_t counter,uint8_t count,uint8_t connection_type,uint8_t info,const uint16_t *failure_flags,const uint32_t *error_count,const int16_t *temperature)
@@ -225,6 +227,7 @@ static inline uint16_t mavlink_msg_esc_info_pack_chan(uint8_t system_id, uint8_t
  * @param msg The MAVLink message to compress the data into
  * @param esc_info C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_esc_info_t* esc_info)
 {
     return mavlink_msg_esc_info_pack(system_id, component_id, msg, esc_info->index, esc_info->time_usec, esc_info->counter, esc_info->count, esc_info->connection_type, esc_info->info, esc_info->failure_flags, esc_info->error_count, esc_info->temperature);
@@ -239,6 +242,7 @@ static inline uint16_t mavlink_msg_esc_info_encode(uint8_t system_id, uint8_t co
  * @param msg The MAVLink message to compress the data into
  * @param esc_info C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_esc_info_t* esc_info)
 {
     return mavlink_msg_esc_info_pack_chan(system_id, component_id, chan, msg, esc_info->index, esc_info->time_usec, esc_info->counter, esc_info->count, esc_info->connection_type, esc_info->info, esc_info->failure_flags, esc_info->error_count, esc_info->temperature);
@@ -274,6 +278,7 @@ static inline uint16_t mavlink_msg_esc_info_encode_status(uint8_t system_id, uin
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_esc_info_send(mavlink_channel_t chan, uint8_t index, uint64_t time_usec, uint16_t counter, uint8_t count, uint8_t connection_type, uint8_t info, const uint16_t *failure_flags, const uint32_t *error_count, const int16_t *temperature)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -308,6 +313,7 @@ static inline void mavlink_msg_esc_info_send(mavlink_channel_t chan, uint8_t ind
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_esc_info_send_struct(mavlink_channel_t chan, const mavlink_esc_info_t* esc_info)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -325,6 +331,7 @@ static inline void mavlink_msg_esc_info_send_struct(mavlink_channel_t chan, cons
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_esc_info_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t index, uint64_t time_usec, uint16_t counter, uint8_t count, uint8_t connection_type, uint8_t info, const uint16_t *failure_flags, const uint32_t *error_count, const int16_t *temperature)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -365,6 +372,7 @@ static inline void mavlink_msg_esc_info_send_buf(mavlink_message_t *msgbuf, mavl
  *
  * @return  Index of the first ESC in this message. minValue = 0, maxValue = 60, increment = 4.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_esc_info_get_index(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  42);
@@ -375,6 +383,7 @@ static inline uint8_t mavlink_msg_esc_info_get_index(const mavlink_message_t* ms
  *
  * @return [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude the number.
  */
+MAVLINK_WIP
 static inline uint64_t mavlink_msg_esc_info_get_time_usec(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint64_t(msg,  0);
@@ -385,6 +394,7 @@ static inline uint64_t mavlink_msg_esc_info_get_time_usec(const mavlink_message_
  *
  * @return  Counter of data packets received.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_get_counter(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  24);
@@ -395,6 +405,7 @@ static inline uint16_t mavlink_msg_esc_info_get_counter(const mavlink_message_t*
  *
  * @return  Total number of ESCs in all messages of this type. Message fields with an index higher than this should be ignored because they contain invalid data.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_esc_info_get_count(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  43);
@@ -405,6 +416,7 @@ static inline uint8_t mavlink_msg_esc_info_get_count(const mavlink_message_t* ms
  *
  * @return  Connection type protocol for all ESC.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_esc_info_get_connection_type(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  44);
@@ -415,6 +427,7 @@ static inline uint8_t mavlink_msg_esc_info_get_connection_type(const mavlink_mes
  *
  * @return  Information regarding online/offline status of each ESC.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_esc_info_get_info(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  45);
@@ -425,6 +438,7 @@ static inline uint8_t mavlink_msg_esc_info_get_info(const mavlink_message_t* msg
  *
  * @return  Bitmap of ESC failure flags.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_get_failure_flags(const mavlink_message_t* msg, uint16_t *failure_flags)
 {
     return _MAV_RETURN_uint16_t_array(msg, failure_flags, 4,  26);
@@ -435,6 +449,7 @@ static inline uint16_t mavlink_msg_esc_info_get_failure_flags(const mavlink_mess
  *
  * @return  Number of reported errors by each ESC since boot.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_get_error_count(const mavlink_message_t* msg, uint32_t *error_count)
 {
     return _MAV_RETURN_uint32_t_array(msg, error_count, 4,  8);
@@ -445,6 +460,7 @@ static inline uint16_t mavlink_msg_esc_info_get_error_count(const mavlink_messag
  *
  * @return [cdegC] Temperature of each ESC. INT16_MAX: if data not supplied by ESC.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_info_get_temperature(const mavlink_message_t* msg, int16_t *temperature)
 {
     return _MAV_RETURN_int16_t_array(msg, temperature, 4,  34);
@@ -456,6 +472,7 @@ static inline uint16_t mavlink_msg_esc_info_get_temperature(const mavlink_messag
  * @param msg The message to decode
  * @param esc_info C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_esc_info_decode(const mavlink_message_t* msg, mavlink_esc_info_t* esc_info)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 13 - 0
v2.0/common/mavlink_msg_esc_status.h

@@ -62,6 +62,7 @@ typedef struct __mavlink_esc_status_t {
  * @param current [A] Current measured from each ESC.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint8_t index, uint64_t time_usec, const int32_t *rpm, const float *voltage, const float *current)
 {
@@ -143,6 +144,7 @@ static inline uint16_t mavlink_msg_esc_status_pack_status(uint8_t system_id, uin
  * @param current [A] Current measured from each ESC.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint8_t index,uint64_t time_usec,const int32_t *rpm,const float *voltage,const float *current)
@@ -177,6 +179,7 @@ static inline uint16_t mavlink_msg_esc_status_pack_chan(uint8_t system_id, uint8
  * @param msg The MAVLink message to compress the data into
  * @param esc_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_esc_status_t* esc_status)
 {
     return mavlink_msg_esc_status_pack(system_id, component_id, msg, esc_status->index, esc_status->time_usec, esc_status->rpm, esc_status->voltage, esc_status->current);
@@ -191,6 +194,7 @@ static inline uint16_t mavlink_msg_esc_status_encode(uint8_t system_id, uint8_t
  * @param msg The MAVLink message to compress the data into
  * @param esc_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_status_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_esc_status_t* esc_status)
 {
     return mavlink_msg_esc_status_pack_chan(system_id, component_id, chan, msg, esc_status->index, esc_status->time_usec, esc_status->rpm, esc_status->voltage, esc_status->current);
@@ -222,6 +226,7 @@ static inline uint16_t mavlink_msg_esc_status_encode_status(uint8_t system_id, u
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_esc_status_send(mavlink_channel_t chan, uint8_t index, uint64_t time_usec, const int32_t *rpm, const float *voltage, const float *current)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -248,6 +253,7 @@ static inline void mavlink_msg_esc_status_send(mavlink_channel_t chan, uint8_t i
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_esc_status_send_struct(mavlink_channel_t chan, const mavlink_esc_status_t* esc_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -265,6 +271,7 @@ static inline void mavlink_msg_esc_status_send_struct(mavlink_channel_t chan, co
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_esc_status_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t index, uint64_t time_usec, const int32_t *rpm, const float *voltage, const float *current)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -297,6 +304,7 @@ static inline void mavlink_msg_esc_status_send_buf(mavlink_message_t *msgbuf, ma
  *
  * @return  Index of the first ESC in this message. minValue = 0, maxValue = 60, increment = 4.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_esc_status_get_index(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  56);
@@ -307,6 +315,7 @@ static inline uint8_t mavlink_msg_esc_status_get_index(const mavlink_message_t*
  *
  * @return [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude the number.
  */
+MAVLINK_WIP
 static inline uint64_t mavlink_msg_esc_status_get_time_usec(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint64_t(msg,  0);
@@ -317,6 +326,7 @@ static inline uint64_t mavlink_msg_esc_status_get_time_usec(const mavlink_messag
  *
  * @return [rpm] Reported motor RPM from each ESC (negative for reverse rotation).
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_status_get_rpm(const mavlink_message_t* msg, int32_t *rpm)
 {
     return _MAV_RETURN_int32_t_array(msg, rpm, 4,  8);
@@ -327,6 +337,7 @@ static inline uint16_t mavlink_msg_esc_status_get_rpm(const mavlink_message_t* m
  *
  * @return [V] Voltage measured from each ESC.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_status_get_voltage(const mavlink_message_t* msg, float *voltage)
 {
     return _MAV_RETURN_float_array(msg, voltage, 4,  24);
@@ -337,6 +348,7 @@ static inline uint16_t mavlink_msg_esc_status_get_voltage(const mavlink_message_
  *
  * @return [A] Current measured from each ESC.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_esc_status_get_current(const mavlink_message_t* msg, float *current)
 {
     return _MAV_RETURN_float_array(msg, current, 4,  40);
@@ -348,6 +360,7 @@ static inline uint16_t mavlink_msg_esc_status_get_current(const mavlink_message_
  * @param msg The message to decode
  * @param esc_status C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_esc_status_decode(const mavlink_message_t* msg, mavlink_esc_status_t* esc_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 15 - 0
v2.0/common/mavlink_msg_event.h

@@ -68,6 +68,7 @@ typedef struct __mavlink_event_t {
  * @param arguments  Arguments (depend on event ID).
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_event_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint8_t destination_component, uint8_t destination_system, uint32_t id, uint32_t event_time_boot_ms, uint16_t sequence, uint8_t log_levels, const uint8_t *arguments)
 {
@@ -161,6 +162,7 @@ static inline uint16_t mavlink_msg_event_pack_status(uint8_t system_id, uint8_t
  * @param arguments  Arguments (depend on event ID).
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_event_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint8_t destination_component,uint8_t destination_system,uint32_t id,uint32_t event_time_boot_ms,uint16_t sequence,uint8_t log_levels,const uint8_t *arguments)
@@ -199,6 +201,7 @@ static inline uint16_t mavlink_msg_event_pack_chan(uint8_t system_id, uint8_t co
  * @param msg The MAVLink message to compress the data into
  * @param event C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_event_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_event_t* event)
 {
     return mavlink_msg_event_pack(system_id, component_id, msg, event->destination_component, event->destination_system, event->id, event->event_time_boot_ms, event->sequence, event->log_levels, event->arguments);
@@ -213,6 +216,7 @@ static inline uint16_t mavlink_msg_event_encode(uint8_t system_id, uint8_t compo
  * @param msg The MAVLink message to compress the data into
  * @param event C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_event_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_event_t* event)
 {
     return mavlink_msg_event_pack_chan(system_id, component_id, chan, msg, event->destination_component, event->destination_system, event->id, event->event_time_boot_ms, event->sequence, event->log_levels, event->arguments);
@@ -246,6 +250,7 @@ static inline uint16_t mavlink_msg_event_encode_status(uint8_t system_id, uint8_
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_event_send(mavlink_channel_t chan, uint8_t destination_component, uint8_t destination_system, uint32_t id, uint32_t event_time_boot_ms, uint16_t sequence, uint8_t log_levels, const uint8_t *arguments)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -276,6 +281,7 @@ static inline void mavlink_msg_event_send(mavlink_channel_t chan, uint8_t destin
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_event_send_struct(mavlink_channel_t chan, const mavlink_event_t* event)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -293,6 +299,7 @@ static inline void mavlink_msg_event_send_struct(mavlink_channel_t chan, const m
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_event_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t destination_component, uint8_t destination_system, uint32_t id, uint32_t event_time_boot_ms, uint16_t sequence, uint8_t log_levels, const uint8_t *arguments)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -329,6 +336,7 @@ static inline void mavlink_msg_event_send_buf(mavlink_message_t *msgbuf, mavlink
  *
  * @return  Component ID
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_event_get_destination_component(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  10);
@@ -339,6 +347,7 @@ static inline uint8_t mavlink_msg_event_get_destination_component(const mavlink_
  *
  * @return  System ID
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_event_get_destination_system(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  11);
@@ -349,6 +358,7 @@ static inline uint8_t mavlink_msg_event_get_destination_system(const mavlink_mes
  *
  * @return  Event ID (as defined in the component metadata)
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_event_get_id(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  0);
@@ -359,6 +369,7 @@ static inline uint32_t mavlink_msg_event_get_id(const mavlink_message_t* msg)
  *
  * @return [ms] Timestamp (time since system boot when the event happened).
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_event_get_event_time_boot_ms(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  4);
@@ -369,6 +380,7 @@ static inline uint32_t mavlink_msg_event_get_event_time_boot_ms(const mavlink_me
  *
  * @return  Sequence number.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_event_get_sequence(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  8);
@@ -379,6 +391,7 @@ static inline uint16_t mavlink_msg_event_get_sequence(const mavlink_message_t* m
  *
  * @return  Log levels: 4 bits MSB: internal (for logging purposes), 4 bits LSB: external. Levels: Emergency = 0, Alert = 1, Critical = 2, Error = 3, Warning = 4, Notice = 5, Info = 6, Debug = 7, Protocol = 8, Disabled = 9
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_event_get_log_levels(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  12);
@@ -389,6 +402,7 @@ static inline uint8_t mavlink_msg_event_get_log_levels(const mavlink_message_t*
  *
  * @return  Arguments (depend on event ID).
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_event_get_arguments(const mavlink_message_t* msg, uint8_t *arguments)
 {
     return _MAV_RETURN_uint8_t_array(msg, arguments, 40,  13);
@@ -400,6 +414,7 @@ static inline uint16_t mavlink_msg_event_get_arguments(const mavlink_message_t*
  * @param msg The message to decode
  * @param event C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_event_decode(const mavlink_message_t* msg, mavlink_event_t* event)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 19 - 0
v2.0/common/mavlink_msg_link_node_status.h

@@ -84,6 +84,7 @@ typedef struct __mavlink_link_node_status_t {
  * @param messages_lost  Messages lost (estimated from counting seq)
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_link_node_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint64_t timestamp, uint8_t tx_buf, uint8_t rx_buf, uint32_t tx_rate, uint32_t rx_rate, uint16_t rx_parse_err, uint16_t tx_overflows, uint16_t rx_overflows, uint32_t messages_sent, uint32_t messages_received, uint32_t messages_lost)
 {
@@ -205,6 +206,7 @@ static inline uint16_t mavlink_msg_link_node_status_pack_status(uint8_t system_i
  * @param messages_lost  Messages lost (estimated from counting seq)
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_link_node_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint64_t timestamp,uint8_t tx_buf,uint8_t rx_buf,uint32_t tx_rate,uint32_t rx_rate,uint16_t rx_parse_err,uint16_t tx_overflows,uint16_t rx_overflows,uint32_t messages_sent,uint32_t messages_received,uint32_t messages_lost)
@@ -253,6 +255,7 @@ static inline uint16_t mavlink_msg_link_node_status_pack_chan(uint8_t system_id,
  * @param msg The MAVLink message to compress the data into
  * @param link_node_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_link_node_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_link_node_status_t* link_node_status)
 {
     return mavlink_msg_link_node_status_pack(system_id, component_id, msg, link_node_status->timestamp, link_node_status->tx_buf, link_node_status->rx_buf, link_node_status->tx_rate, link_node_status->rx_rate, link_node_status->rx_parse_err, link_node_status->tx_overflows, link_node_status->rx_overflows, link_node_status->messages_sent, link_node_status->messages_received, link_node_status->messages_lost);
@@ -267,6 +270,7 @@ static inline uint16_t mavlink_msg_link_node_status_encode(uint8_t system_id, ui
  * @param msg The MAVLink message to compress the data into
  * @param link_node_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_link_node_status_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_link_node_status_t* link_node_status)
 {
     return mavlink_msg_link_node_status_pack_chan(system_id, component_id, chan, msg, link_node_status->timestamp, link_node_status->tx_buf, link_node_status->rx_buf, link_node_status->tx_rate, link_node_status->rx_rate, link_node_status->rx_parse_err, link_node_status->tx_overflows, link_node_status->rx_overflows, link_node_status->messages_sent, link_node_status->messages_received, link_node_status->messages_lost);
@@ -304,6 +308,7 @@ static inline uint16_t mavlink_msg_link_node_status_encode_status(uint8_t system
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_link_node_status_send(mavlink_channel_t chan, uint64_t timestamp, uint8_t tx_buf, uint8_t rx_buf, uint32_t tx_rate, uint32_t rx_rate, uint16_t rx_parse_err, uint16_t tx_overflows, uint16_t rx_overflows, uint32_t messages_sent, uint32_t messages_received, uint32_t messages_lost)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -344,6 +349,7 @@ static inline void mavlink_msg_link_node_status_send(mavlink_channel_t chan, uin
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_link_node_status_send_struct(mavlink_channel_t chan, const mavlink_link_node_status_t* link_node_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -361,6 +367,7 @@ static inline void mavlink_msg_link_node_status_send_struct(mavlink_channel_t ch
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_link_node_status_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint64_t timestamp, uint8_t tx_buf, uint8_t rx_buf, uint32_t tx_rate, uint32_t rx_rate, uint16_t rx_parse_err, uint16_t tx_overflows, uint16_t rx_overflows, uint32_t messages_sent, uint32_t messages_received, uint32_t messages_lost)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -407,6 +414,7 @@ static inline void mavlink_msg_link_node_status_send_buf(mavlink_message_t *msgb
  *
  * @return [ms] Timestamp (time since system boot).
  */
+MAVLINK_WIP
 static inline uint64_t mavlink_msg_link_node_status_get_timestamp(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint64_t(msg,  0);
@@ -417,6 +425,7 @@ static inline uint64_t mavlink_msg_link_node_status_get_timestamp(const mavlink_
  *
  * @return [%] Remaining free transmit buffer space
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_link_node_status_get_tx_buf(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  34);
@@ -427,6 +436,7 @@ static inline uint8_t mavlink_msg_link_node_status_get_tx_buf(const mavlink_mess
  *
  * @return [%] Remaining free receive buffer space
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_link_node_status_get_rx_buf(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  35);
@@ -437,6 +447,7 @@ static inline uint8_t mavlink_msg_link_node_status_get_rx_buf(const mavlink_mess
  *
  * @return [bytes/s] Transmit rate
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_link_node_status_get_tx_rate(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  8);
@@ -447,6 +458,7 @@ static inline uint32_t mavlink_msg_link_node_status_get_tx_rate(const mavlink_me
  *
  * @return [bytes/s] Receive rate
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_link_node_status_get_rx_rate(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  12);
@@ -457,6 +469,7 @@ static inline uint32_t mavlink_msg_link_node_status_get_rx_rate(const mavlink_me
  *
  * @return [bytes] Number of bytes that could not be parsed correctly.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_link_node_status_get_rx_parse_err(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  28);
@@ -467,6 +480,7 @@ static inline uint16_t mavlink_msg_link_node_status_get_rx_parse_err(const mavli
  *
  * @return [bytes] Transmit buffer overflows. This number wraps around as it reaches UINT16_MAX
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_link_node_status_get_tx_overflows(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  30);
@@ -477,6 +491,7 @@ static inline uint16_t mavlink_msg_link_node_status_get_tx_overflows(const mavli
  *
  * @return [bytes] Receive buffer overflows. This number wraps around as it reaches UINT16_MAX
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_link_node_status_get_rx_overflows(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  32);
@@ -487,6 +502,7 @@ static inline uint16_t mavlink_msg_link_node_status_get_rx_overflows(const mavli
  *
  * @return  Messages sent
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_link_node_status_get_messages_sent(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  16);
@@ -497,6 +513,7 @@ static inline uint32_t mavlink_msg_link_node_status_get_messages_sent(const mavl
  *
  * @return  Messages received (estimated from counting seq)
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_link_node_status_get_messages_received(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  20);
@@ -507,6 +524,7 @@ static inline uint32_t mavlink_msg_link_node_status_get_messages_received(const
  *
  * @return  Messages lost (estimated from counting seq)
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_link_node_status_get_messages_lost(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  24);
@@ -518,6 +536,7 @@ static inline uint32_t mavlink_msg_link_node_status_get_messages_lost(const mavl
  * @param msg The message to decode
  * @param link_node_status C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_link_node_status_decode(const mavlink_message_t* msg, mavlink_link_node_status_t* link_node_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 28 - 0
v2.0/common/mavlink_msg_onboard_computer_status.h

@@ -133,6 +133,7 @@ typedef struct __mavlink_onboard_computer_status_t {
  * @param link_rx_max [KiB/s] Network capacity to the component system. A value of UINT32_MAX implies the field is unused.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint64_t time_usec, uint32_t uptime, uint8_t type, const uint8_t *cpu_cores, const uint8_t *cpu_combined, const uint8_t *gpu_cores, const uint8_t *gpu_combined, int8_t temperature_board, const int8_t *temperature_core, const int16_t *fan_speed, uint32_t ram_usage, uint32_t ram_total, const uint32_t *storage_type, const uint32_t *storage_usage, const uint32_t *storage_total, const uint32_t *link_type, const uint32_t *link_tx_rate, const uint32_t *link_rx_rate, const uint32_t *link_tx_max, const uint32_t *link_rx_max)
 {
@@ -304,6 +305,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_pack_status(uint8_t s
  * @param link_rx_max [KiB/s] Network capacity to the component system. A value of UINT32_MAX implies the field is unused.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint64_t time_usec,uint32_t uptime,uint8_t type,const uint8_t *cpu_cores,const uint8_t *cpu_combined,const uint8_t *gpu_cores,const uint8_t *gpu_combined,int8_t temperature_board,const int8_t *temperature_core,const int16_t *fan_speed,uint32_t ram_usage,uint32_t ram_total,const uint32_t *storage_type,const uint32_t *storage_usage,const uint32_t *storage_total,const uint32_t *link_type,const uint32_t *link_tx_rate,const uint32_t *link_rx_rate,const uint32_t *link_tx_max,const uint32_t *link_rx_max)
@@ -368,6 +370,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_pack_chan(uint8_t sys
  * @param msg The MAVLink message to compress the data into
  * @param onboard_computer_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_onboard_computer_status_t* onboard_computer_status)
 {
     return mavlink_msg_onboard_computer_status_pack(system_id, component_id, msg, onboard_computer_status->time_usec, onboard_computer_status->uptime, onboard_computer_status->type, onboard_computer_status->cpu_cores, onboard_computer_status->cpu_combined, onboard_computer_status->gpu_cores, onboard_computer_status->gpu_combined, onboard_computer_status->temperature_board, onboard_computer_status->temperature_core, onboard_computer_status->fan_speed, onboard_computer_status->ram_usage, onboard_computer_status->ram_total, onboard_computer_status->storage_type, onboard_computer_status->storage_usage, onboard_computer_status->storage_total, onboard_computer_status->link_type, onboard_computer_status->link_tx_rate, onboard_computer_status->link_rx_rate, onboard_computer_status->link_tx_max, onboard_computer_status->link_rx_max);
@@ -382,6 +385,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_encode(uint8_t system
  * @param msg The MAVLink message to compress the data into
  * @param onboard_computer_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_onboard_computer_status_t* onboard_computer_status)
 {
     return mavlink_msg_onboard_computer_status_pack_chan(system_id, component_id, chan, msg, onboard_computer_status->time_usec, onboard_computer_status->uptime, onboard_computer_status->type, onboard_computer_status->cpu_cores, onboard_computer_status->cpu_combined, onboard_computer_status->gpu_cores, onboard_computer_status->gpu_combined, onboard_computer_status->temperature_board, onboard_computer_status->temperature_core, onboard_computer_status->fan_speed, onboard_computer_status->ram_usage, onboard_computer_status->ram_total, onboard_computer_status->storage_type, onboard_computer_status->storage_usage, onboard_computer_status->storage_total, onboard_computer_status->link_type, onboard_computer_status->link_tx_rate, onboard_computer_status->link_rx_rate, onboard_computer_status->link_tx_max, onboard_computer_status->link_rx_max);
@@ -428,6 +432,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_encode_status(uint8_t
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_onboard_computer_status_send(mavlink_channel_t chan, uint64_t time_usec, uint32_t uptime, uint8_t type, const uint8_t *cpu_cores, const uint8_t *cpu_combined, const uint8_t *gpu_cores, const uint8_t *gpu_combined, int8_t temperature_board, const int8_t *temperature_core, const int16_t *fan_speed, uint32_t ram_usage, uint32_t ram_total, const uint32_t *storage_type, const uint32_t *storage_usage, const uint32_t *storage_total, const uint32_t *link_type, const uint32_t *link_tx_rate, const uint32_t *link_rx_rate, const uint32_t *link_tx_max, const uint32_t *link_rx_max)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -484,6 +489,7 @@ static inline void mavlink_msg_onboard_computer_status_send(mavlink_channel_t ch
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_onboard_computer_status_send_struct(mavlink_channel_t chan, const mavlink_onboard_computer_status_t* onboard_computer_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -501,6 +507,7 @@ static inline void mavlink_msg_onboard_computer_status_send_struct(mavlink_chann
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_onboard_computer_status_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint64_t time_usec, uint32_t uptime, uint8_t type, const uint8_t *cpu_cores, const uint8_t *cpu_combined, const uint8_t *gpu_cores, const uint8_t *gpu_combined, int8_t temperature_board, const int8_t *temperature_core, const int16_t *fan_speed, uint32_t ram_usage, uint32_t ram_total, const uint32_t *storage_type, const uint32_t *storage_usage, const uint32_t *storage_total, const uint32_t *link_type, const uint32_t *link_tx_rate, const uint32_t *link_rx_rate, const uint32_t *link_tx_max, const uint32_t *link_rx_max)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -563,6 +570,7 @@ static inline void mavlink_msg_onboard_computer_status_send_buf(mavlink_message_
  *
  * @return [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
  */
+MAVLINK_WIP
 static inline uint64_t mavlink_msg_onboard_computer_status_get_time_usec(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint64_t(msg,  0);
@@ -573,6 +581,7 @@ static inline uint64_t mavlink_msg_onboard_computer_status_get_time_usec(const m
  *
  * @return [ms] Time since system boot.
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_onboard_computer_status_get_uptime(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  8);
@@ -583,6 +592,7 @@ static inline uint32_t mavlink_msg_onboard_computer_status_get_uptime(const mavl
  *
  * @return  Type of the onboard computer: 0: Mission computer primary, 1: Mission computer backup 1, 2: Mission computer backup 2, 3: Compute node, 4-5: Compute spares, 6-9: Payload computers.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_onboard_computer_status_get_type(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  196);
@@ -593,6 +603,7 @@ static inline uint8_t mavlink_msg_onboard_computer_status_get_type(const mavlink
  *
  * @return  CPU usage on the component in percent (100 - idle). A value of UINT8_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_cpu_cores(const mavlink_message_t* msg, uint8_t *cpu_cores)
 {
     return _MAV_RETURN_uint8_t_array(msg, cpu_cores, 8,  197);
@@ -603,6 +614,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_cpu_cores(const m
  *
  * @return  Combined CPU usage as the last 10 slices of 100 MS (a histogram). This allows to identify spikes in load that max out the system, but only for a short amount of time. A value of UINT8_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_cpu_combined(const mavlink_message_t* msg, uint8_t *cpu_combined)
 {
     return _MAV_RETURN_uint8_t_array(msg, cpu_combined, 10,  205);
@@ -613,6 +625,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_cpu_combined(cons
  *
  * @return  GPU usage on the component in percent (100 - idle). A value of UINT8_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_gpu_cores(const mavlink_message_t* msg, uint8_t *gpu_cores)
 {
     return _MAV_RETURN_uint8_t_array(msg, gpu_cores, 4,  215);
@@ -623,6 +636,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_gpu_cores(const m
  *
  * @return  Combined GPU usage as the last 10 slices of 100 MS (a histogram). This allows to identify spikes in load that max out the system, but only for a short amount of time. A value of UINT8_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_gpu_combined(const mavlink_message_t* msg, uint8_t *gpu_combined)
 {
     return _MAV_RETURN_uint8_t_array(msg, gpu_combined, 10,  219);
@@ -633,6 +647,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_gpu_combined(cons
  *
  * @return [degC] Temperature of the board. A value of INT8_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline int8_t mavlink_msg_onboard_computer_status_get_temperature_board(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int8_t(msg,  229);
@@ -643,6 +658,7 @@ static inline int8_t mavlink_msg_onboard_computer_status_get_temperature_board(c
  *
  * @return [degC] Temperature of the CPU core. A value of INT8_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_temperature_core(const mavlink_message_t* msg, int8_t *temperature_core)
 {
     return _MAV_RETURN_int8_t_array(msg, temperature_core, 8,  230);
@@ -653,6 +669,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_temperature_core(
  *
  * @return [rpm] Fan speeds. A value of INT16_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_fan_speed(const mavlink_message_t* msg, int16_t *fan_speed)
 {
     return _MAV_RETURN_int16_t_array(msg, fan_speed, 4,  188);
@@ -663,6 +680,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_fan_speed(const m
  *
  * @return [MiB] Amount of used RAM on the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_onboard_computer_status_get_ram_usage(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  12);
@@ -673,6 +691,7 @@ static inline uint32_t mavlink_msg_onboard_computer_status_get_ram_usage(const m
  *
  * @return [MiB] Total amount of RAM on the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint32_t mavlink_msg_onboard_computer_status_get_ram_total(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint32_t(msg,  16);
@@ -683,6 +702,7 @@ static inline uint32_t mavlink_msg_onboard_computer_status_get_ram_total(const m
  *
  * @return  Storage type: 0: HDD, 1: SSD, 2: EMMC, 3: SD card (non-removable), 4: SD card (removable). A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_storage_type(const mavlink_message_t* msg, uint32_t *storage_type)
 {
     return _MAV_RETURN_uint32_t_array(msg, storage_type, 4,  20);
@@ -693,6 +713,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_storage_type(cons
  *
  * @return [MiB] Amount of used storage space on the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_storage_usage(const mavlink_message_t* msg, uint32_t *storage_usage)
 {
     return _MAV_RETURN_uint32_t_array(msg, storage_usage, 4,  36);
@@ -703,6 +724,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_storage_usage(con
  *
  * @return [MiB] Total amount of storage space on the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_storage_total(const mavlink_message_t* msg, uint32_t *storage_total)
 {
     return _MAV_RETURN_uint32_t_array(msg, storage_total, 4,  52);
@@ -713,6 +735,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_storage_total(con
  *
  * @return  Link type: 0-9: UART, 10-19: Wired network, 20-29: Wifi, 30-39: Point-to-point proprietary, 40-49: Mesh proprietary
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_link_type(const mavlink_message_t* msg, uint32_t *link_type)
 {
     return _MAV_RETURN_uint32_t_array(msg, link_type, 6,  68);
@@ -723,6 +746,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_link_type(const m
  *
  * @return [KiB/s] Network traffic from the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_link_tx_rate(const mavlink_message_t* msg, uint32_t *link_tx_rate)
 {
     return _MAV_RETURN_uint32_t_array(msg, link_tx_rate, 6,  92);
@@ -733,6 +757,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_link_tx_rate(cons
  *
  * @return [KiB/s] Network traffic to the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_link_rx_rate(const mavlink_message_t* msg, uint32_t *link_rx_rate)
 {
     return _MAV_RETURN_uint32_t_array(msg, link_rx_rate, 6,  116);
@@ -743,6 +768,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_link_rx_rate(cons
  *
  * @return [KiB/s] Network capacity from the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_link_tx_max(const mavlink_message_t* msg, uint32_t *link_tx_max)
 {
     return _MAV_RETURN_uint32_t_array(msg, link_tx_max, 6,  140);
@@ -753,6 +779,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_link_tx_max(const
  *
  * @return [KiB/s] Network capacity to the component system. A value of UINT32_MAX implies the field is unused.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_onboard_computer_status_get_link_rx_max(const mavlink_message_t* msg, uint32_t *link_rx_max)
 {
     return _MAV_RETURN_uint32_t_array(msg, link_rx_max, 6,  164);
@@ -764,6 +791,7 @@ static inline uint16_t mavlink_msg_onboard_computer_status_get_link_rx_max(const
  * @param msg The message to decode
  * @param onboard_computer_status C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_onboard_computer_status_decode(const mavlink_message_t* msg, mavlink_onboard_computer_status_t* onboard_computer_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 14 - 0
v2.0/common/mavlink_msg_orbit_execution_status.h

@@ -64,6 +64,7 @@ typedef struct __mavlink_orbit_execution_status_t {
  * @param z [m] Altitude of center point. Coordinate system depends on frame field.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_orbit_execution_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint64_t time_usec, float radius, uint8_t frame, int32_t x, int32_t y, float z)
 {
@@ -155,6 +156,7 @@ static inline uint16_t mavlink_msg_orbit_execution_status_pack_status(uint8_t sy
  * @param z [m] Altitude of center point. Coordinate system depends on frame field.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_orbit_execution_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint64_t time_usec,float radius,uint8_t frame,int32_t x,int32_t y,float z)
@@ -193,6 +195,7 @@ static inline uint16_t mavlink_msg_orbit_execution_status_pack_chan(uint8_t syst
  * @param msg The MAVLink message to compress the data into
  * @param orbit_execution_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_orbit_execution_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_orbit_execution_status_t* orbit_execution_status)
 {
     return mavlink_msg_orbit_execution_status_pack(system_id, component_id, msg, orbit_execution_status->time_usec, orbit_execution_status->radius, orbit_execution_status->frame, orbit_execution_status->x, orbit_execution_status->y, orbit_execution_status->z);
@@ -207,6 +210,7 @@ static inline uint16_t mavlink_msg_orbit_execution_status_encode(uint8_t system_
  * @param msg The MAVLink message to compress the data into
  * @param orbit_execution_status C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_orbit_execution_status_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_orbit_execution_status_t* orbit_execution_status)
 {
     return mavlink_msg_orbit_execution_status_pack_chan(system_id, component_id, chan, msg, orbit_execution_status->time_usec, orbit_execution_status->radius, orbit_execution_status->frame, orbit_execution_status->x, orbit_execution_status->y, orbit_execution_status->z);
@@ -239,6 +243,7 @@ static inline uint16_t mavlink_msg_orbit_execution_status_encode_status(uint8_t
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_orbit_execution_status_send(mavlink_channel_t chan, uint64_t time_usec, float radius, uint8_t frame, int32_t x, int32_t y, float z)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -269,6 +274,7 @@ static inline void mavlink_msg_orbit_execution_status_send(mavlink_channel_t cha
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_orbit_execution_status_send_struct(mavlink_channel_t chan, const mavlink_orbit_execution_status_t* orbit_execution_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -286,6 +292,7 @@ static inline void mavlink_msg_orbit_execution_status_send_struct(mavlink_channe
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_orbit_execution_status_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint64_t time_usec, float radius, uint8_t frame, int32_t x, int32_t y, float z)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -322,6 +329,7 @@ static inline void mavlink_msg_orbit_execution_status_send_buf(mavlink_message_t
  *
  * @return [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
  */
+MAVLINK_WIP
 static inline uint64_t mavlink_msg_orbit_execution_status_get_time_usec(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint64_t(msg,  0);
@@ -332,6 +340,7 @@ static inline uint64_t mavlink_msg_orbit_execution_status_get_time_usec(const ma
  *
  * @return [m] Radius of the orbit circle. Positive values orbit clockwise, negative values orbit counter-clockwise.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_orbit_execution_status_get_radius(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  8);
@@ -342,6 +351,7 @@ static inline float mavlink_msg_orbit_execution_status_get_radius(const mavlink_
  *
  * @return  The coordinate system of the fields: x, y, z.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_orbit_execution_status_get_frame(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  24);
@@ -352,6 +362,7 @@ static inline uint8_t mavlink_msg_orbit_execution_status_get_frame(const mavlink
  *
  * @return  X coordinate of center point. Coordinate system depends on frame field: local = x position in meters * 1e4, global = latitude in degrees * 1e7.
  */
+MAVLINK_WIP
 static inline int32_t mavlink_msg_orbit_execution_status_get_x(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int32_t(msg,  12);
@@ -362,6 +373,7 @@ static inline int32_t mavlink_msg_orbit_execution_status_get_x(const mavlink_mes
  *
  * @return  Y coordinate of center point.  Coordinate system depends on frame field: local = x position in meters * 1e4, global = latitude in degrees * 1e7.
  */
+MAVLINK_WIP
 static inline int32_t mavlink_msg_orbit_execution_status_get_y(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int32_t(msg,  16);
@@ -372,6 +384,7 @@ static inline int32_t mavlink_msg_orbit_execution_status_get_y(const mavlink_mes
  *
  * @return [m] Altitude of center point. Coordinate system depends on frame field.
  */
+MAVLINK_WIP
 static inline float mavlink_msg_orbit_execution_status_get_z(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_float(msg,  20);
@@ -383,6 +396,7 @@ static inline float mavlink_msg_orbit_execution_status_get_z(const mavlink_messa
  * @param msg The message to decode
  * @param orbit_execution_status C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_orbit_execution_status_decode(const mavlink_message_t* msg, mavlink_orbit_execution_status_t* orbit_execution_status)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 12 - 0
v2.0/common/mavlink_msg_request_event.h

@@ -56,6 +56,7 @@ typedef struct __mavlink_request_event_t {
  * @param last_sequence  Last sequence number of the requested event.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_request_event_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint8_t target_system, uint8_t target_component, uint16_t first_sequence, uint16_t last_sequence)
 {
@@ -135,6 +136,7 @@ static inline uint16_t mavlink_msg_request_event_pack_status(uint8_t system_id,
  * @param last_sequence  Last sequence number of the requested event.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_request_event_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint8_t target_system,uint8_t target_component,uint16_t first_sequence,uint16_t last_sequence)
@@ -169,6 +171,7 @@ static inline uint16_t mavlink_msg_request_event_pack_chan(uint8_t system_id, ui
  * @param msg The MAVLink message to compress the data into
  * @param request_event C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_request_event_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_request_event_t* request_event)
 {
     return mavlink_msg_request_event_pack(system_id, component_id, msg, request_event->target_system, request_event->target_component, request_event->first_sequence, request_event->last_sequence);
@@ -183,6 +186,7 @@ static inline uint16_t mavlink_msg_request_event_encode(uint8_t system_id, uint8
  * @param msg The MAVLink message to compress the data into
  * @param request_event C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_request_event_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_request_event_t* request_event)
 {
     return mavlink_msg_request_event_pack_chan(system_id, component_id, chan, msg, request_event->target_system, request_event->target_component, request_event->first_sequence, request_event->last_sequence);
@@ -213,6 +217,7 @@ static inline uint16_t mavlink_msg_request_event_encode_status(uint8_t system_id
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_request_event_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t first_sequence, uint16_t last_sequence)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -239,6 +244,7 @@ static inline void mavlink_msg_request_event_send(mavlink_channel_t chan, uint8_
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_request_event_send_struct(mavlink_channel_t chan, const mavlink_request_event_t* request_event)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -256,6 +262,7 @@ static inline void mavlink_msg_request_event_send_struct(mavlink_channel_t chan,
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_request_event_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t target_system, uint8_t target_component, uint16_t first_sequence, uint16_t last_sequence)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -288,6 +295,7 @@ static inline void mavlink_msg_request_event_send_buf(mavlink_message_t *msgbuf,
  *
  * @return  System ID
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_request_event_get_target_system(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  4);
@@ -298,6 +306,7 @@ static inline uint8_t mavlink_msg_request_event_get_target_system(const mavlink_
  *
  * @return  Component ID
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_request_event_get_target_component(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  5);
@@ -308,6 +317,7 @@ static inline uint8_t mavlink_msg_request_event_get_target_component(const mavli
  *
  * @return  First sequence number of the requested event.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_request_event_get_first_sequence(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  0);
@@ -318,6 +328,7 @@ static inline uint16_t mavlink_msg_request_event_get_first_sequence(const mavlin
  *
  * @return  Last sequence number of the requested event.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_request_event_get_last_sequence(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  2);
@@ -329,6 +340,7 @@ static inline uint16_t mavlink_msg_request_event_get_last_sequence(const mavlink
  * @param msg The message to decode
  * @param request_event C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_request_event_decode(const mavlink_message_t* msg, mavlink_request_event_t* request_event)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 13 - 0
v2.0/common/mavlink_msg_response_event_error.h

@@ -60,6 +60,7 @@ typedef struct __mavlink_response_event_error_t {
  * @param reason  Error reason.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_response_event_error_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint8_t target_system, uint8_t target_component, uint16_t sequence, uint16_t sequence_oldest_available, uint8_t reason)
 {
@@ -145,6 +146,7 @@ static inline uint16_t mavlink_msg_response_event_error_pack_status(uint8_t syst
  * @param reason  Error reason.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_response_event_error_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint8_t target_system,uint8_t target_component,uint16_t sequence,uint16_t sequence_oldest_available,uint8_t reason)
@@ -181,6 +183,7 @@ static inline uint16_t mavlink_msg_response_event_error_pack_chan(uint8_t system
  * @param msg The MAVLink message to compress the data into
  * @param response_event_error C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_response_event_error_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_response_event_error_t* response_event_error)
 {
     return mavlink_msg_response_event_error_pack(system_id, component_id, msg, response_event_error->target_system, response_event_error->target_component, response_event_error->sequence, response_event_error->sequence_oldest_available, response_event_error->reason);
@@ -195,6 +198,7 @@ static inline uint16_t mavlink_msg_response_event_error_encode(uint8_t system_id
  * @param msg The MAVLink message to compress the data into
  * @param response_event_error C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_response_event_error_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_response_event_error_t* response_event_error)
 {
     return mavlink_msg_response_event_error_pack_chan(system_id, component_id, chan, msg, response_event_error->target_system, response_event_error->target_component, response_event_error->sequence, response_event_error->sequence_oldest_available, response_event_error->reason);
@@ -226,6 +230,7 @@ static inline uint16_t mavlink_msg_response_event_error_encode_status(uint8_t sy
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_response_event_error_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, uint16_t sequence, uint16_t sequence_oldest_available, uint8_t reason)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -254,6 +259,7 @@ static inline void mavlink_msg_response_event_error_send(mavlink_channel_t chan,
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_response_event_error_send_struct(mavlink_channel_t chan, const mavlink_response_event_error_t* response_event_error)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -271,6 +277,7 @@ static inline void mavlink_msg_response_event_error_send_struct(mavlink_channel_
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_response_event_error_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t target_system, uint8_t target_component, uint16_t sequence, uint16_t sequence_oldest_available, uint8_t reason)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -305,6 +312,7 @@ static inline void mavlink_msg_response_event_error_send_buf(mavlink_message_t *
  *
  * @return  System ID
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_response_event_error_get_target_system(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  4);
@@ -315,6 +323,7 @@ static inline uint8_t mavlink_msg_response_event_error_get_target_system(const m
  *
  * @return  Component ID
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_response_event_error_get_target_component(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  5);
@@ -325,6 +334,7 @@ static inline uint8_t mavlink_msg_response_event_error_get_target_component(cons
  *
  * @return  Sequence number.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_response_event_error_get_sequence(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  0);
@@ -335,6 +345,7 @@ static inline uint16_t mavlink_msg_response_event_error_get_sequence(const mavli
  *
  * @return  Oldest Sequence number that is still available after the sequence set in REQUEST_EVENT.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_response_event_error_get_sequence_oldest_available(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  2);
@@ -345,6 +356,7 @@ static inline uint16_t mavlink_msg_response_event_error_get_sequence_oldest_avai
  *
  * @return  Error reason.
  */
+MAVLINK_WIP
 static inline uint8_t mavlink_msg_response_event_error_get_reason(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint8_t(msg,  6);
@@ -356,6 +368,7 @@ static inline uint8_t mavlink_msg_response_event_error_get_reason(const mavlink_
  * @param msg The message to decode
  * @param response_event_error C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_response_event_error_decode(const mavlink_message_t* msg, mavlink_response_event_error_t* response_event_error)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 13 - 0
v2.0/common/mavlink_msg_time_estimate_to_target.h

@@ -60,6 +60,7 @@ typedef struct __mavlink_time_estimate_to_target_t {
  * @param commanded_action [s] Estimated time for completing the current commanded action (i.e. Go To, Takeoff, Land, etc.). -1 means no action active and/or no estimate available.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_time_estimate_to_target_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                int32_t safe_return, int32_t land, int32_t mission_next_item, int32_t mission_end, int32_t commanded_action)
 {
@@ -145,6 +146,7 @@ static inline uint16_t mavlink_msg_time_estimate_to_target_pack_status(uint8_t s
  * @param commanded_action [s] Estimated time for completing the current commanded action (i.e. Go To, Takeoff, Land, etc.). -1 means no action active and/or no estimate available.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_time_estimate_to_target_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    int32_t safe_return,int32_t land,int32_t mission_next_item,int32_t mission_end,int32_t commanded_action)
@@ -181,6 +183,7 @@ static inline uint16_t mavlink_msg_time_estimate_to_target_pack_chan(uint8_t sys
  * @param msg The MAVLink message to compress the data into
  * @param time_estimate_to_target C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_time_estimate_to_target_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_time_estimate_to_target_t* time_estimate_to_target)
 {
     return mavlink_msg_time_estimate_to_target_pack(system_id, component_id, msg, time_estimate_to_target->safe_return, time_estimate_to_target->land, time_estimate_to_target->mission_next_item, time_estimate_to_target->mission_end, time_estimate_to_target->commanded_action);
@@ -195,6 +198,7 @@ static inline uint16_t mavlink_msg_time_estimate_to_target_encode(uint8_t system
  * @param msg The MAVLink message to compress the data into
  * @param time_estimate_to_target C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_time_estimate_to_target_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_time_estimate_to_target_t* time_estimate_to_target)
 {
     return mavlink_msg_time_estimate_to_target_pack_chan(system_id, component_id, chan, msg, time_estimate_to_target->safe_return, time_estimate_to_target->land, time_estimate_to_target->mission_next_item, time_estimate_to_target->mission_end, time_estimate_to_target->commanded_action);
@@ -226,6 +230,7 @@ static inline uint16_t mavlink_msg_time_estimate_to_target_encode_status(uint8_t
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_time_estimate_to_target_send(mavlink_channel_t chan, int32_t safe_return, int32_t land, int32_t mission_next_item, int32_t mission_end, int32_t commanded_action)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -254,6 +259,7 @@ static inline void mavlink_msg_time_estimate_to_target_send(mavlink_channel_t ch
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_time_estimate_to_target_send_struct(mavlink_channel_t chan, const mavlink_time_estimate_to_target_t* time_estimate_to_target)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -271,6 +277,7 @@ static inline void mavlink_msg_time_estimate_to_target_send_struct(mavlink_chann
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_time_estimate_to_target_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  int32_t safe_return, int32_t land, int32_t mission_next_item, int32_t mission_end, int32_t commanded_action)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -305,6 +312,7 @@ static inline void mavlink_msg_time_estimate_to_target_send_buf(mavlink_message_
  *
  * @return [s] Estimated time to complete the vehicle's configured "safe return" action from its current position (e.g. RTL, Smart RTL, etc.). -1 indicates that the vehicle is landed, or that no time estimate available.
  */
+MAVLINK_WIP
 static inline int32_t mavlink_msg_time_estimate_to_target_get_safe_return(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int32_t(msg,  0);
@@ -315,6 +323,7 @@ static inline int32_t mavlink_msg_time_estimate_to_target_get_safe_return(const
  *
  * @return [s] Estimated time for vehicle to complete the LAND action from its current position. -1 indicates that the vehicle is landed, or that no time estimate available.
  */
+MAVLINK_WIP
 static inline int32_t mavlink_msg_time_estimate_to_target_get_land(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int32_t(msg,  4);
@@ -325,6 +334,7 @@ static inline int32_t mavlink_msg_time_estimate_to_target_get_land(const mavlink
  *
  * @return [s] Estimated time for reaching/completing the currently active mission item. -1 means no time estimate available.
  */
+MAVLINK_WIP
 static inline int32_t mavlink_msg_time_estimate_to_target_get_mission_next_item(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int32_t(msg,  8);
@@ -335,6 +345,7 @@ static inline int32_t mavlink_msg_time_estimate_to_target_get_mission_next_item(
  *
  * @return [s] Estimated time for completing the current mission. -1 means no mission active and/or no estimate available.
  */
+MAVLINK_WIP
 static inline int32_t mavlink_msg_time_estimate_to_target_get_mission_end(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int32_t(msg,  12);
@@ -345,6 +356,7 @@ static inline int32_t mavlink_msg_time_estimate_to_target_get_mission_end(const
  *
  * @return [s] Estimated time for completing the current commanded action (i.e. Go To, Takeoff, Land, etc.). -1 means no action active and/or no estimate available.
  */
+MAVLINK_WIP
 static inline int32_t mavlink_msg_time_estimate_to_target_get_commanded_action(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_int32_t(msg,  16);
@@ -356,6 +368,7 @@ static inline int32_t mavlink_msg_time_estimate_to_target_get_commanded_action(c
  * @param msg The message to decode
  * @param time_estimate_to_target C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_time_estimate_to_target_decode(const mavlink_message_t* msg, mavlink_time_estimate_to_target_t* time_estimate_to_target)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 1 - 1
v2.0/common/version.h

@@ -7,7 +7,7 @@
 #ifndef MAVLINK_VERSION_H
 #define MAVLINK_VERSION_H
 
-#define MAVLINK_BUILD_DATE "Mon Oct 06 2025"
+#define MAVLINK_BUILD_DATE "Mon Oct 27 2025"
 #define MAVLINK_WIRE_PROTOCOL_VERSION "2.0"
 #define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 255
  

+ 6 - 2
v2.0/mavlink_helpers.h

@@ -12,6 +12,10 @@
 
 #include "mavlink_sha256.h"
 
+#ifndef MAVLINK_SIGNING_TIMESTAMP_LIMIT
+#define MAVLINK_SIGNING_TIMESTAMP_LIMIT 60
+#endif
+
 #ifdef MAVLINK_USE_CXX_NAMESPACE
 namespace mavlink {
 #endif
@@ -174,8 +178,8 @@ MAVLINK_HELPER bool mavlink_signature_check(mavlink_signing_t *signing,
                         signing->last_status = MAVLINK_SIGNING_STATUS_TOO_MANY_STREAMS;
                         return false;
 		}
-		// new stream. Only accept if timestamp is not more than 1 minute old
-		if (tstamp.t64 + 6000*1000UL < signing->timestamp) {
+        // new stream. Only accept if timestamp is not more than 1 minute old by default
+        if (tstamp.t64 + MAVLINK_SIGNING_TIMESTAMP_LIMIT*100000UL < signing->timestamp) {
                         signing->last_status = MAVLINK_SIGNING_STATUS_OLD_TIMESTAMP;
                         return false;
 		}

+ 1 - 1
v2.0/minimal/mavlink.h

@@ -6,7 +6,7 @@
 #ifndef MAVLINK_H
 #define MAVLINK_H
 
-#define MAVLINK_PRIMARY_XML_HASH -8283319395198565426
+#define MAVLINK_PRIMARY_XML_HASH -6686777932665073691
 
 #ifndef MAVLINK_STX
 #define MAVLINK_STX 253

+ 13 - 0
v2.0/minimal/mavlink_msg_protocol_version.h

@@ -61,6 +61,7 @@ typedef struct __mavlink_protocol_version_t {
  * @param library_version_hash  The first 8 bytes (not characters printed in hex!) of the git hash.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
                                uint16_t version, uint16_t min_version, uint16_t max_version, const uint8_t *spec_version_hash, const uint8_t *library_version_hash)
 {
@@ -142,6 +143,7 @@ static inline uint16_t mavlink_msg_protocol_version_pack_status(uint8_t system_i
  * @param library_version_hash  The first 8 bytes (not characters printed in hex!) of the git hash.
  * @return length of the message in bytes (excluding serial stream start sign)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
                                mavlink_message_t* msg,
                                    uint16_t version,uint16_t min_version,uint16_t max_version,const uint8_t *spec_version_hash,const uint8_t *library_version_hash)
@@ -176,6 +178,7 @@ static inline uint16_t mavlink_msg_protocol_version_pack_chan(uint8_t system_id,
  * @param msg The MAVLink message to compress the data into
  * @param protocol_version C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_protocol_version_t* protocol_version)
 {
     return mavlink_msg_protocol_version_pack(system_id, component_id, msg, protocol_version->version, protocol_version->min_version, protocol_version->max_version, protocol_version->spec_version_hash, protocol_version->library_version_hash);
@@ -190,6 +193,7 @@ static inline uint16_t mavlink_msg_protocol_version_encode(uint8_t system_id, ui
  * @param msg The MAVLink message to compress the data into
  * @param protocol_version C-struct to read the message contents from
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_protocol_version_t* protocol_version)
 {
     return mavlink_msg_protocol_version_pack_chan(system_id, component_id, chan, msg, protocol_version->version, protocol_version->min_version, protocol_version->max_version, protocol_version->spec_version_hash, protocol_version->library_version_hash);
@@ -221,6 +225,7 @@ static inline uint16_t mavlink_msg_protocol_version_encode_status(uint8_t system
  */
 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 
+MAVLINK_WIP
 static inline void mavlink_msg_protocol_version_send(mavlink_channel_t chan, uint16_t version, uint16_t min_version, uint16_t max_version, const uint8_t *spec_version_hash, const uint8_t *library_version_hash)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -247,6 +252,7 @@ static inline void mavlink_msg_protocol_version_send(mavlink_channel_t chan, uin
  * @param chan MAVLink channel to send the message
  * @param struct The MAVLink struct to serialize
  */
+MAVLINK_WIP
 static inline void mavlink_msg_protocol_version_send_struct(mavlink_channel_t chan, const mavlink_protocol_version_t* protocol_version)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -264,6 +270,7 @@ static inline void mavlink_msg_protocol_version_send_struct(mavlink_channel_t ch
   is usually the receive buffer for the channel, and allows a reply to an
   incoming message with minimum stack space usage.
  */
+MAVLINK_WIP
 static inline void mavlink_msg_protocol_version_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint16_t version, uint16_t min_version, uint16_t max_version, const uint8_t *spec_version_hash, const uint8_t *library_version_hash)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
@@ -296,6 +303,7 @@ static inline void mavlink_msg_protocol_version_send_buf(mavlink_message_t *msgb
  *
  * @return  Currently active MAVLink version number * 100: v1.0 is 100, v2.0 is 200, etc.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_get_version(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  0);
@@ -306,6 +314,7 @@ static inline uint16_t mavlink_msg_protocol_version_get_version(const mavlink_me
  *
  * @return  Minimum MAVLink version supported
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_get_min_version(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  2);
@@ -316,6 +325,7 @@ static inline uint16_t mavlink_msg_protocol_version_get_min_version(const mavlin
  *
  * @return  Maximum MAVLink version supported (set to the same value as version by default)
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_get_max_version(const mavlink_message_t* msg)
 {
     return _MAV_RETURN_uint16_t(msg,  4);
@@ -326,6 +336,7 @@ static inline uint16_t mavlink_msg_protocol_version_get_max_version(const mavlin
  *
  * @return  The first 8 bytes (not characters printed in hex!) of the git hash.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_get_spec_version_hash(const mavlink_message_t* msg, uint8_t *spec_version_hash)
 {
     return _MAV_RETURN_uint8_t_array(msg, spec_version_hash, 8,  6);
@@ -336,6 +347,7 @@ static inline uint16_t mavlink_msg_protocol_version_get_spec_version_hash(const
  *
  * @return  The first 8 bytes (not characters printed in hex!) of the git hash.
  */
+MAVLINK_WIP
 static inline uint16_t mavlink_msg_protocol_version_get_library_version_hash(const mavlink_message_t* msg, uint8_t *library_version_hash)
 {
     return _MAV_RETURN_uint8_t_array(msg, library_version_hash, 8,  14);
@@ -347,6 +359,7 @@ static inline uint16_t mavlink_msg_protocol_version_get_library_version_hash(con
  * @param msg The message to decode
  * @param protocol_version C-struct to decode the message contents into
  */
+MAVLINK_WIP
 static inline void mavlink_msg_protocol_version_decode(const mavlink_message_t* msg, mavlink_protocol_version_t* protocol_version)
 {
 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS

+ 1 - 1
v2.0/minimal/minimal.h

@@ -10,7 +10,7 @@
     #error Wrong include order: MAVLINK_MINIMAL.H MUST NOT BE DIRECTLY USED. Include mavlink.h from the same directory instead or set ALL AND EVERY defines from MAVLINK.H manually accordingly, including the #define MAVLINK_H call.
 #endif
 
-#define MAVLINK_MINIMAL_XML_HASH -8283319395198565426
+#define MAVLINK_MINIMAL_XML_HASH -6686777932665073691
 
 #ifdef __cplusplus
 extern "C" {

+ 1 - 1
v2.0/minimal/version.h

@@ -7,7 +7,7 @@
 #ifndef MAVLINK_VERSION_H
 #define MAVLINK_VERSION_H
 
-#define MAVLINK_BUILD_DATE "Mon Oct 06 2025"
+#define MAVLINK_BUILD_DATE "Mon Oct 27 2025"
 #define MAVLINK_WIRE_PROTOCOL_VERSION "2.0"
 #define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 22
  

+ 8 - 0
v2.0/protocol.h

@@ -33,6 +33,14 @@
 #define MAVLINK_END_UART_SEND(chan, length)
 #endif
 
+/*
+  to get warnings when any WIP message is used, add this:
+  #define MAVLINK_WIP __attribute__((warning("MAVLink work in progress")))
+*/
+#ifndef MAVLINK_WIP
+#define MAVLINK_WIP
+#endif
+
 /* option to provide alternative implementation of mavlink_helpers.h */
 #ifdef MAVLINK_SEPARATE_HELPERS
 

+ 1 - 1
v2.0/standard/mavlink.h

@@ -6,7 +6,7 @@
 #ifndef MAVLINK_H
 #define MAVLINK_H
 
-#define MAVLINK_PRIMARY_XML_HASH 8854942251188693210
+#define MAVLINK_PRIMARY_XML_HASH 545504450770710352
 
 #ifndef MAVLINK_STX
 #define MAVLINK_STX 253

+ 1 - 1
v2.0/standard/standard.h

@@ -10,7 +10,7 @@
     #error Wrong include order: MAVLINK_STANDARD.H MUST NOT BE DIRECTLY USED. Include mavlink.h from the same directory instead or set ALL AND EVERY defines from MAVLINK.H manually accordingly, including the #define MAVLINK_H call.
 #endif
 
-#define MAVLINK_STANDARD_XML_HASH 8854942251188693210
+#define MAVLINK_STANDARD_XML_HASH 545504450770710352
 
 #ifdef __cplusplus
 extern "C" {

+ 1 - 1
v2.0/standard/version.h

@@ -7,7 +7,7 @@
 #ifndef MAVLINK_VERSION_H
 #define MAVLINK_VERSION_H
 
-#define MAVLINK_BUILD_DATE "Mon Oct 06 2025"
+#define MAVLINK_BUILD_DATE "Mon Oct 27 2025"
 #define MAVLINK_WIRE_PROTOCOL_VERSION "2.0"
 #define MAVLINK_MAX_DIALECT_PAYLOAD_SIZE 22
  

Some files were not shown because too many files changed in this diff