增加悬停原因FMB接管

msg_definitions/VKFly.xml

@@ -511,6 +511,7 @@
       <entry value="16" name="VLFLY_LOITER_REASON_QUIT_FORMATION"></entry>
       <entry value="17" name="VLFLY_LOITER_REASON_H2P_LOW"></entry>
       <entry value="18" name="VLFLY_LOITER_REASON_ECU_FUEL_LOW"></entry>
+      <entry value="19" name="VLFLY_LOITER_REASON_FMUB_TAKEOVER"></entry>
       <entry value="21" name="VLFLY_LOITER_REASON_WPDATA_ERR"></entry>
     </enum>
 

v2.0/VKFly/VKFly.h

@@ -10,7 +10,7 @@
     #error Wrong include order: MAVLINK_VKFLY.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_VKFLY_XML_HASH 78985157704652124
+#define MAVLINK_VKFLY_XML_HASH 6608795056306455779
 
 #ifdef __cplusplus
 extern "C" {
@@ -369,6 +369,7 @@ typedef enum VKFLY_LOITER_REASON
    VLFLY_LOITER_REASON_QUIT_FORMATION=16, /*  | */
    VLFLY_LOITER_REASON_H2P_LOW=17, /*  | */
    VLFLY_LOITER_REASON_ECU_FUEL_LOW=18, /*  | */
+   VLFLY_LOITER_REASON_FMUB_TAKEOVER=19, /*  | */
    VLFLY_LOITER_REASON_WPDATA_ERR=21, /*  | */
    VKFLY_LOITER_REASON_ENUM_END=22, /*  | */
 } VKFLY_LOITER_REASON;

v2.0/VKFly/mavlink.h

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

v2.0/VKFly/mavlink_msg_fmub_status.h

@@ -505,7 +505,7 @@ static inline void mavlink_msg_fmub_status_send_struct(mavlink_channel_t chan, c
 
 #if MAVLINK_MSG_ID_FMUB_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_qingxie_bms.h

@@ -535,7 +535,7 @@ static inline void mavlink_msg_qingxie_bms_send_struct(mavlink_channel_t chan, c
 
 #if MAVLINK_MSG_ID_QINGXIE_BMS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_bms_status.h

@@ -121,7 +121,7 @@ static inline uint16_t mavlink_msg_vk_bms_status_pack(uint8_t system_id, uint8_t
     packet.cap_percent = cap_percent;
     packet.bat_id = bat_id;
     packet.health = health;
-    mav_array_assign_uint16_t(packet.cell_volt, cell_volt, 30);
+    mav_array_memcpy(packet.cell_volt, cell_volt, sizeof(uint16_t)*30);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_BMS_STATUS_LEN);
 #endif
 
@@ -247,7 +247,7 @@ static inline uint16_t mavlink_msg_vk_bms_status_pack_chan(uint8_t system_id, ui
     packet.cap_percent = cap_percent;
     packet.bat_id = bat_id;
     packet.health = health;
-    mav_array_assign_uint16_t(packet.cell_volt, cell_volt, 30);
+    mav_array_memcpy(packet.cell_volt, cell_volt, sizeof(uint16_t)*30);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_BMS_STATUS_LEN);
 #endif
 
@@ -346,7 +346,7 @@ static inline void mavlink_msg_vk_bms_status_send(mavlink_channel_t chan, uint32
     packet.cap_percent = cap_percent;
     packet.bat_id = bat_id;
     packet.health = health;
-    mav_array_assign_uint16_t(packet.cell_volt, cell_volt, 30);
+    mav_array_memcpy(packet.cell_volt, cell_volt, sizeof(uint16_t)*30);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_BMS_STATUS, (const char *)&packet, MAVLINK_MSG_ID_VK_BMS_STATUS_MIN_LEN, MAVLINK_MSG_ID_VK_BMS_STATUS_LEN, MAVLINK_MSG_ID_VK_BMS_STATUS_CRC);
 #endif
 }
@@ -367,7 +367,7 @@ static inline void mavlink_msg_vk_bms_status_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_VK_BMS_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -401,7 +401,7 @@ static inline void mavlink_msg_vk_bms_status_send_buf(mavlink_message_t *msgbuf,
     packet->cap_percent = cap_percent;
     packet->bat_id = bat_id;
     packet->health = health;
-    mav_array_assign_uint16_t(packet->cell_volt, cell_volt, 30);
+    mav_array_memcpy(packet->cell_volt, cell_volt, sizeof(uint16_t)*30);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_BMS_STATUS, (const char *)packet, MAVLINK_MSG_ID_VK_BMS_STATUS_MIN_LEN, MAVLINK_MSG_ID_VK_BMS_STATUS_LEN, MAVLINK_MSG_ID_VK_BMS_STATUS_CRC);
 #endif
 }

v2.0/VKFly/mavlink_msg_vk_comp_version.h

@@ -89,12 +89,12 @@ static inline uint16_t mavlink_msg_vk_comp_version_pack(uint8_t system_id, uint8
 #else
     mavlink_vk_comp_version_t packet;
     packet.comp_id = comp_id;
-    mav_array_assign_uint8_t(packet.hw_ver, hw_ver, 16);
-    mav_array_assign_uint8_t(packet.fw_ver, fw_ver, 16);
-    mav_array_assign_uint8_t(packet.SN, SN, 16);
-    mav_array_assign_uint8_t(packet.manufactory, manufactory, 16);
-    mav_array_assign_uint8_t(packet.model, model, 16);
-    mav_array_assign_uint8_t(packet.priv_data, priv_data, 16);
+    mav_array_memcpy(packet.hw_ver, hw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.fw_ver, fw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.SN, SN, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.manufactory, manufactory, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.model, model, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.priv_data, priv_data, sizeof(uint8_t)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_COMP_VERSION_LEN);
 #endif
 
@@ -183,12 +183,12 @@ static inline uint16_t mavlink_msg_vk_comp_version_pack_chan(uint8_t system_id,
 #else
     mavlink_vk_comp_version_t packet;
     packet.comp_id = comp_id;
-    mav_array_assign_uint8_t(packet.hw_ver, hw_ver, 16);
-    mav_array_assign_uint8_t(packet.fw_ver, fw_ver, 16);
-    mav_array_assign_uint8_t(packet.SN, SN, 16);
-    mav_array_assign_uint8_t(packet.manufactory, manufactory, 16);
-    mav_array_assign_uint8_t(packet.model, model, 16);
-    mav_array_assign_uint8_t(packet.priv_data, priv_data, 16);
+    mav_array_memcpy(packet.hw_ver, hw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.fw_ver, fw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.SN, SN, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.manufactory, manufactory, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.model, model, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.priv_data, priv_data, sizeof(uint8_t)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_COMP_VERSION_LEN);
 #endif
 
@@ -266,12 +266,12 @@ static inline void mavlink_msg_vk_comp_version_send(mavlink_channel_t chan, uint
 #else
     mavlink_vk_comp_version_t packet;
     packet.comp_id = comp_id;
-    mav_array_assign_uint8_t(packet.hw_ver, hw_ver, 16);
-    mav_array_assign_uint8_t(packet.fw_ver, fw_ver, 16);
-    mav_array_assign_uint8_t(packet.SN, SN, 16);
-    mav_array_assign_uint8_t(packet.manufactory, manufactory, 16);
-    mav_array_assign_uint8_t(packet.model, model, 16);
-    mav_array_assign_uint8_t(packet.priv_data, priv_data, 16);
+    mav_array_memcpy(packet.hw_ver, hw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.fw_ver, fw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.SN, SN, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.manufactory, manufactory, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.model, model, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet.priv_data, priv_data, sizeof(uint8_t)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_COMP_VERSION, (const char *)&packet, MAVLINK_MSG_ID_VK_COMP_VERSION_MIN_LEN, MAVLINK_MSG_ID_VK_COMP_VERSION_LEN, MAVLINK_MSG_ID_VK_COMP_VERSION_CRC);
 #endif
 }
@@ -292,7 +292,7 @@ static inline void mavlink_msg_vk_comp_version_send_struct(mavlink_channel_t cha
 
 #if MAVLINK_MSG_ID_VK_COMP_VERSION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -313,12 +313,12 @@ static inline void mavlink_msg_vk_comp_version_send_buf(mavlink_message_t *msgbu
 #else
     mavlink_vk_comp_version_t *packet = (mavlink_vk_comp_version_t *)msgbuf;
     packet->comp_id = comp_id;
-    mav_array_assign_uint8_t(packet->hw_ver, hw_ver, 16);
-    mav_array_assign_uint8_t(packet->fw_ver, fw_ver, 16);
-    mav_array_assign_uint8_t(packet->SN, SN, 16);
-    mav_array_assign_uint8_t(packet->manufactory, manufactory, 16);
-    mav_array_assign_uint8_t(packet->model, model, 16);
-    mav_array_assign_uint8_t(packet->priv_data, priv_data, 16);
+    mav_array_memcpy(packet->hw_ver, hw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet->fw_ver, fw_ver, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet->SN, SN, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet->manufactory, manufactory, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet->model, model, sizeof(uint8_t)*16);
+    mav_array_memcpy(packet->priv_data, priv_data, sizeof(uint8_t)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_COMP_VERSION, (const char *)packet, MAVLINK_MSG_ID_VK_COMP_VERSION_MIN_LEN, MAVLINK_MSG_ID_VK_COMP_VERSION_LEN, MAVLINK_MSG_ID_VK_COMP_VERSION_CRC);
 #endif
 }

v2.0/VKFly/mavlink_msg_vk_digi_esc_status.h

@@ -93,11 +93,11 @@ static inline uint16_t mavlink_msg_vk_digi_esc_status_pack(uint8_t system_id, ui
     mavlink_vk_digi_esc_status_t packet;
     packet.timestamp = timestamp;
     packet.index = index;
-    mav_array_assign_int32_t(packet.rpm, rpm, 4);
-    mav_array_assign_float(packet.voltage, voltage, 4);
-    mav_array_assign_float(packet.current, current, 4);
-    mav_array_assign_uint32_t(packet.status, status, 4);
-    mav_array_assign_int16_t(packet.temperature, temperature, 4);
+    mav_array_memcpy(packet.rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet.voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet.current, current, sizeof(float)*4);
+    mav_array_memcpy(packet.status, status, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet.temperature, temperature, sizeof(int16_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_LEN);
 #endif
 
@@ -191,11 +191,11 @@ static inline uint16_t mavlink_msg_vk_digi_esc_status_pack_chan(uint8_t system_i
     mavlink_vk_digi_esc_status_t packet;
     packet.timestamp = timestamp;
     packet.index = index;
-    mav_array_assign_int32_t(packet.rpm, rpm, 4);
-    mav_array_assign_float(packet.voltage, voltage, 4);
-    mav_array_assign_float(packet.current, current, 4);
-    mav_array_assign_uint32_t(packet.status, status, 4);
-    mav_array_assign_int16_t(packet.temperature, temperature, 4);
+    mav_array_memcpy(packet.rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet.voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet.current, current, sizeof(float)*4);
+    mav_array_memcpy(packet.status, status, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet.temperature, temperature, sizeof(int16_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_LEN);
 #endif
 
@@ -276,11 +276,11 @@ static inline void mavlink_msg_vk_digi_esc_status_send(mavlink_channel_t chan, u
     mavlink_vk_digi_esc_status_t packet;
     packet.timestamp = timestamp;
     packet.index = index;
-    mav_array_assign_int32_t(packet.rpm, rpm, 4);
-    mav_array_assign_float(packet.voltage, voltage, 4);
-    mav_array_assign_float(packet.current, current, 4);
-    mav_array_assign_uint32_t(packet.status, status, 4);
-    mav_array_assign_int16_t(packet.temperature, temperature, 4);
+    mav_array_memcpy(packet.rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet.voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet.current, current, sizeof(float)*4);
+    mav_array_memcpy(packet.status, status, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet.temperature, temperature, sizeof(int16_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS, (const char *)&packet, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_MIN_LEN, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_LEN, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_CRC);
 #endif
 }
@@ -301,7 +301,7 @@ static inline void mavlink_msg_vk_digi_esc_status_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -323,11 +323,11 @@ static inline void mavlink_msg_vk_digi_esc_status_send_buf(mavlink_message_t *ms
     mavlink_vk_digi_esc_status_t *packet = (mavlink_vk_digi_esc_status_t *)msgbuf;
     packet->timestamp = timestamp;
     packet->index = index;
-    mav_array_assign_int32_t(packet->rpm, rpm, 4);
-    mav_array_assign_float(packet->voltage, voltage, 4);
-    mav_array_assign_float(packet->current, current, 4);
-    mav_array_assign_uint32_t(packet->status, status, 4);
-    mav_array_assign_int16_t(packet->temperature, temperature, 4);
+    mav_array_memcpy(packet->rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet->voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet->current, current, sizeof(float)*4);
+    mav_array_memcpy(packet->status, status, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet->temperature, temperature, sizeof(int16_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS, (const char *)packet, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_MIN_LEN, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_LEN, MAVLINK_MSG_ID_VK_DIGI_ESC_STATUS_CRC);
 #endif
 }

v2.0/VKFly/mavlink_msg_vk_engine_ecu_staus.h

@@ -159,7 +159,7 @@ static inline uint16_t mavlink_msg_vk_engine_ecu_staus_pack(uint8_t system_id, u
     packet.fault = fault;
     packet.engine_state = engine_state;
     packet.index = index;
-    mav_array_assign_uint8_t(packet.reserve, reserve, 4);
+    mav_array_memcpy(packet.reserve, reserve, sizeof(uint8_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_LEN);
 #endif
 
@@ -323,7 +323,7 @@ static inline uint16_t mavlink_msg_vk_engine_ecu_staus_pack_chan(uint8_t system_
     packet.fault = fault;
     packet.engine_state = engine_state;
     packet.index = index;
-    mav_array_assign_uint8_t(packet.reserve, reserve, 4);
+    mav_array_memcpy(packet.reserve, reserve, sizeof(uint8_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_LEN);
 #endif
 
@@ -441,7 +441,7 @@ static inline void mavlink_msg_vk_engine_ecu_staus_send(mavlink_channel_t chan,
     packet.fault = fault;
     packet.engine_state = engine_state;
     packet.index = index;
-    mav_array_assign_uint8_t(packet.reserve, reserve, 4);
+    mav_array_memcpy(packet.reserve, reserve, sizeof(uint8_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS, (const char *)&packet, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_MIN_LEN, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_LEN, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_CRC);
 #endif
 }
@@ -462,7 +462,7 @@ static inline void mavlink_msg_vk_engine_ecu_staus_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -510,7 +510,7 @@ static inline void mavlink_msg_vk_engine_ecu_staus_send_buf(mavlink_message_t *m
     packet->fault = fault;
     packet->engine_state = engine_state;
     packet->index = index;
-    mav_array_assign_uint8_t(packet->reserve, reserve, 4);
+    mav_array_memcpy(packet->reserve, reserve, sizeof(uint8_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS, (const char *)packet, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_MIN_LEN, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_LEN, MAVLINK_MSG_ID_VK_ENGINE_ECU_STAUS_CRC);
 #endif
 }

v2.0/VKFly/mavlink_msg_vk_external_ins_nav.h

@@ -580,7 +580,7 @@ static inline void mavlink_msg_vk_external_ins_nav_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_EXTERNAL_INS_NAV_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_fixedwing_control_value.h

@@ -285,7 +285,7 @@ static inline void mavlink_msg_vk_fixedwing_control_value_send_struct(mavlink_ch
 
 #if MAVLINK_MSG_ID_VK_FIXEDWING_CONTROL_VALUE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_fixedwing_rtl_circle_wp.h

@@ -250,7 +250,7 @@ static inline void mavlink_msg_vk_fixedwing_rtl_circle_wp_send_struct(mavlink_ch
 
 #if MAVLINK_MSG_ID_VK_FIXEDWING_RTL_CIRCLE_WP_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_fixedwing_servo_signal.h

@@ -59,7 +59,7 @@ static inline uint16_t mavlink_msg_vk_fixedwing_servo_signal_pack(uint8_t system
 #else
     mavlink_vk_fixedwing_servo_signal_t packet;
     packet.timestamp = timestamp;
-    mav_array_assign_uint16_t(packet.servo_signal, servo_signal, 16);
+    mav_array_memcpy(packet.servo_signal, servo_signal, sizeof(uint16_t)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_LEN);
 #endif
 
@@ -123,7 +123,7 @@ static inline uint16_t mavlink_msg_vk_fixedwing_servo_signal_pack_chan(uint8_t s
 #else
     mavlink_vk_fixedwing_servo_signal_t packet;
     packet.timestamp = timestamp;
-    mav_array_assign_uint16_t(packet.servo_signal, servo_signal, 16);
+    mav_array_memcpy(packet.servo_signal, servo_signal, sizeof(uint16_t)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_LEN);
 #endif
 
@@ -191,7 +191,7 @@ static inline void mavlink_msg_vk_fixedwing_servo_signal_send(mavlink_channel_t
 #else
     mavlink_vk_fixedwing_servo_signal_t packet;
     packet.timestamp = timestamp;
-    mav_array_assign_uint16_t(packet.servo_signal, servo_signal, 16);
+    mav_array_memcpy(packet.servo_signal, servo_signal, sizeof(uint16_t)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL, (const char *)&packet, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_MIN_LEN, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_LEN, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_CRC);
 #endif
 }
@@ -212,7 +212,7 @@ static inline void mavlink_msg_vk_fixedwing_servo_signal_send_struct(mavlink_cha
 
 #if MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -228,7 +228,7 @@ static inline void mavlink_msg_vk_fixedwing_servo_signal_send_buf(mavlink_messag
 #else
     mavlink_vk_fixedwing_servo_signal_t *packet = (mavlink_vk_fixedwing_servo_signal_t *)msgbuf;
     packet->timestamp = timestamp;
-    mav_array_assign_uint16_t(packet->servo_signal, servo_signal, 16);
+    mav_array_memcpy(packet->servo_signal, servo_signal, sizeof(uint16_t)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL, (const char *)packet, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_MIN_LEN, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_LEN, MAVLINK_MSG_ID_VK_FIXEDWING_SERVO_SIGNAL_CRC);
 #endif
 }

v2.0/VKFly/mavlink_msg_vk_formation_leader.h

@@ -430,7 +430,7 @@ static inline void mavlink_msg_vk_formation_leader_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_FORMATION_LEADER_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_fw_update_ack.h

@@ -205,7 +205,7 @@ static inline void mavlink_msg_vk_fw_update_ack_send_struct(mavlink_channel_t ch
 
 #if MAVLINK_MSG_ID_VK_FW_UPDATE_ACK_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_fw_update_begin.h

@@ -235,7 +235,7 @@ static inline void mavlink_msg_vk_fw_update_begin_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_FW_UPDATE_BEGIN_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_fw_update_data.h

@@ -67,7 +67,7 @@ static inline uint16_t mavlink_msg_vk_fw_update_data_pack(uint8_t system_id, uin
     mavlink_vk_fw_update_data_t packet;
     packet.offset = offset;
     packet.count = count;
-    mav_array_assign_uint8_t(packet.data, data, 128);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*128);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_LEN);
 #endif
 
@@ -139,7 +139,7 @@ static inline uint16_t mavlink_msg_vk_fw_update_data_pack_chan(uint8_t system_id
     mavlink_vk_fw_update_data_t packet;
     packet.offset = offset;
     packet.count = count;
-    mav_array_assign_uint8_t(packet.data, data, 128);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*128);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_LEN);
 #endif
 
@@ -211,7 +211,7 @@ static inline void mavlink_msg_vk_fw_update_data_send(mavlink_channel_t chan, ui
     mavlink_vk_fw_update_data_t packet;
     packet.offset = offset;
     packet.count = count;
-    mav_array_assign_uint8_t(packet.data, data, 128);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*128);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA, (const char *)&packet, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_MIN_LEN, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_LEN, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_CRC);
 #endif
 }
@@ -232,7 +232,7 @@ static inline void mavlink_msg_vk_fw_update_data_send_struct(mavlink_channel_t c
 
 #if MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -250,7 +250,7 @@ static inline void mavlink_msg_vk_fw_update_data_send_buf(mavlink_message_t *msg
     mavlink_vk_fw_update_data_t *packet = (mavlink_vk_fw_update_data_t *)msgbuf;
     packet->offset = offset;
     packet->count = count;
-    mav_array_assign_uint8_t(packet->data, data, 128);
+    mav_array_memcpy(packet->data, data, sizeof(uint8_t)*128);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA, (const char *)packet, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_MIN_LEN, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_LEN, MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_CRC);
 #endif
 }

v2.0/VKFly/mavlink_msg_vk_fw_update_data_request.h

@@ -220,7 +220,7 @@ static inline void mavlink_msg_vk_fw_update_data_request_send_struct(mavlink_cha
 
 #if MAVLINK_MSG_ID_VK_FW_UPDATE_DATA_REQUEST_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_mosaich_gps_raw.h

@@ -485,7 +485,7 @@ static inline void mavlink_msg_vk_mosaich_gps_raw_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_MOSAICH_GPS_RAW_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_parachute_status.h

@@ -280,7 +280,7 @@ static inline void mavlink_msg_vk_parachute_status_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_PARACHUTE_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_payload_data_relay.h

@@ -71,7 +71,7 @@ static inline uint16_t mavlink_msg_vk_payload_data_relay_pack(uint8_t system_id,
     packet.payload_addr = payload_addr;
     packet.reserve = reserve;
     packet.data_len = data_len;
-    mav_array_assign_uint8_t(packet.data, data, 128);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*128);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_LEN);
 #endif
 
@@ -147,7 +147,7 @@ static inline uint16_t mavlink_msg_vk_payload_data_relay_pack_chan(uint8_t syste
     packet.payload_addr = payload_addr;
     packet.reserve = reserve;
     packet.data_len = data_len;
-    mav_array_assign_uint8_t(packet.data, data, 128);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*128);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_LEN);
 #endif
 
@@ -221,7 +221,7 @@ static inline void mavlink_msg_vk_payload_data_relay_send(mavlink_channel_t chan
     packet.payload_addr = payload_addr;
     packet.reserve = reserve;
     packet.data_len = data_len;
-    mav_array_assign_uint8_t(packet.data, data, 128);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*128);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY, (const char *)&packet, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_MIN_LEN, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_LEN, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_CRC);
 #endif
 }
@@ -242,7 +242,7 @@ static inline void mavlink_msg_vk_payload_data_relay_send_struct(mavlink_channel
 
 #if MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -262,7 +262,7 @@ static inline void mavlink_msg_vk_payload_data_relay_send_buf(mavlink_message_t
     packet->payload_addr = payload_addr;
     packet->reserve = reserve;
     packet->data_len = data_len;
-    mav_array_assign_uint8_t(packet->data, data, 128);
+    mav_array_memcpy(packet->data, data, sizeof(uint8_t)*128);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY, (const char *)packet, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_MIN_LEN, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_LEN, MAVLINK_MSG_ID_VK_PAYLOAD_DATA_RELAY_CRC);
 #endif
 }

v2.0/VKFly/mavlink_msg_vk_roi_target.h

@@ -265,7 +265,7 @@ static inline void mavlink_msg_vk_roi_target_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_VK_ROI_TARGET_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_rtk_base_pvt.h

@@ -385,7 +385,7 @@ static inline void mavlink_msg_vk_rtk_base_pvt_send_struct(mavlink_channel_t cha
 
 #if MAVLINK_MSG_ID_VK_RTK_BASE_PVT_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_update_terminate.h

@@ -220,7 +220,7 @@ static inline void mavlink_msg_vk_update_terminate_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_VK_UPDATE_TERMINATE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vk_weigher_state.h

@@ -265,7 +265,7 @@ static inline void mavlink_msg_vk_weigher_state_send_struct(mavlink_channel_t ch
 
 #if MAVLINK_MSG_ID_VK_WEIGHER_STATE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vkfly_edu_status.h

@@ -490,7 +490,7 @@ static inline void mavlink_msg_vkfly_edu_status_send_struct(mavlink_channel_t ch
 
 #if MAVLINK_MSG_ID_VKFLY_EDU_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vkfly_edu_status_ack.h

@@ -220,7 +220,7 @@ static inline void mavlink_msg_vkfly_edu_status_ack_send_struct(mavlink_channel_
 
 #if MAVLINK_MSG_ID_VKFLY_EDU_STATUS_ACK_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vkfmu_status.h

@@ -340,7 +340,7 @@ static inline void mavlink_msg_vkfmu_status_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_VKFMU_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/mavlink_msg_vkins_status.h

@@ -470,7 +470,7 @@ static inline void mavlink_msg_vkins_status_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_VKINS_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/VKFly/version.h

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

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 1506392497819245865
+#define MAVLINK_COMMON_XML_HASH 532765549818708498
 
 #ifdef __cplusplus
 extern "C" {

v2.0/common/mavlink.h

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

v2.0/common/mavlink_msg_actuator_control_target.h

@@ -65,7 +65,7 @@ static inline uint16_t mavlink_msg_actuator_control_target_pack(uint8_t system_i
     mavlink_actuator_control_target_t packet;
     packet.time_usec = time_usec;
     packet.group_mlx = group_mlx;
-    mav_array_assign_float(packet.controls, controls, 8);
+    mav_array_memcpy(packet.controls, controls, sizeof(float)*8);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_LEN);
 #endif
 
@@ -135,7 +135,7 @@ static inline uint16_t mavlink_msg_actuator_control_target_pack_chan(uint8_t sys
     mavlink_actuator_control_target_t packet;
     packet.time_usec = time_usec;
     packet.group_mlx = group_mlx;
-    mav_array_assign_float(packet.controls, controls, 8);
+    mav_array_memcpy(packet.controls, controls, sizeof(float)*8);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_LEN);
 #endif
 
@@ -206,7 +206,7 @@ static inline void mavlink_msg_actuator_control_target_send(mavlink_channel_t ch
     mavlink_actuator_control_target_t packet;
     packet.time_usec = time_usec;
     packet.group_mlx = group_mlx;
-    mav_array_assign_float(packet.controls, controls, 8);
+    mav_array_memcpy(packet.controls, controls, sizeof(float)*8);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET, (const char *)&packet, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_CRC);
 #endif
 }
@@ -227,7 +227,7 @@ static inline void mavlink_msg_actuator_control_target_send_struct(mavlink_chann
 
 #if MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -245,7 +245,7 @@ static inline void mavlink_msg_actuator_control_target_send_buf(mavlink_message_
     mavlink_actuator_control_target_t *packet = (mavlink_actuator_control_target_t *)msgbuf;
     packet->time_usec = time_usec;
     packet->group_mlx = group_mlx;
-    mav_array_assign_float(packet->controls, controls, 8);
+    mav_array_memcpy(packet->controls, controls, sizeof(float)*8);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET, (const char *)packet, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_CRC);
 #endif
 }

v2.0/common/mavlink_msg_actuator_output_status.h

@@ -65,7 +65,7 @@ static inline uint16_t mavlink_msg_actuator_output_status_pack(uint8_t system_id
     mavlink_actuator_output_status_t packet;
     packet.time_usec = time_usec;
     packet.active = active;
-    mav_array_assign_float(packet.actuator, actuator, 32);
+    mav_array_memcpy(packet.actuator, actuator, sizeof(float)*32);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_LEN);
 #endif
 
@@ -135,7 +135,7 @@ static inline uint16_t mavlink_msg_actuator_output_status_pack_chan(uint8_t syst
     mavlink_actuator_output_status_t packet;
     packet.time_usec = time_usec;
     packet.active = active;
-    mav_array_assign_float(packet.actuator, actuator, 32);
+    mav_array_memcpy(packet.actuator, actuator, sizeof(float)*32);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_LEN);
 #endif
 
@@ -206,7 +206,7 @@ static inline void mavlink_msg_actuator_output_status_send(mavlink_channel_t cha
     mavlink_actuator_output_status_t packet;
     packet.time_usec = time_usec;
     packet.active = active;
-    mav_array_assign_float(packet.actuator, actuator, 32);
+    mav_array_memcpy(packet.actuator, actuator, sizeof(float)*32);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS, (const char *)&packet, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_MIN_LEN, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_LEN, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_CRC);
 #endif
 }
@@ -227,7 +227,7 @@ static inline void mavlink_msg_actuator_output_status_send_struct(mavlink_channe
 
 #if MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -245,7 +245,7 @@ static inline void mavlink_msg_actuator_output_status_send_buf(mavlink_message_t
     mavlink_actuator_output_status_t *packet = (mavlink_actuator_output_status_t *)msgbuf;
     packet->time_usec = time_usec;
     packet->active = active;
-    mav_array_assign_float(packet->actuator, actuator, 32);
+    mav_array_memcpy(packet->actuator, actuator, sizeof(float)*32);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS, (const char *)packet, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_MIN_LEN, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_LEN, MAVLINK_MSG_ID_ACTUATOR_OUTPUT_STATUS_CRC);
 #endif
 }

v2.0/common/mavlink_msg_adsb_vehicle.h

@@ -125,7 +125,7 @@ static inline uint16_t mavlink_msg_adsb_vehicle_pack(uint8_t system_id, uint8_t
     packet.altitude_type = altitude_type;
     packet.emitter_type = emitter_type;
     packet.tslc = tslc;
-    mav_array_assign_char(packet.callsign, callsign, 9);
+    mav_array_memcpy(packet.callsign, callsign, sizeof(char)*9);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ADSB_VEHICLE_LEN);
 #endif
 
@@ -255,7 +255,7 @@ static inline uint16_t mavlink_msg_adsb_vehicle_pack_chan(uint8_t system_id, uin
     packet.altitude_type = altitude_type;
     packet.emitter_type = emitter_type;
     packet.tslc = tslc;
-    mav_array_assign_char(packet.callsign, callsign, 9);
+    mav_array_memcpy(packet.callsign, callsign, sizeof(char)*9);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ADSB_VEHICLE_LEN);
 #endif
 
@@ -356,7 +356,7 @@ static inline void mavlink_msg_adsb_vehicle_send(mavlink_channel_t chan, uint32_
     packet.altitude_type = altitude_type;
     packet.emitter_type = emitter_type;
     packet.tslc = tslc;
-    mav_array_assign_char(packet.callsign, callsign, 9);
+    mav_array_memcpy(packet.callsign, callsign, sizeof(char)*9);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ADSB_VEHICLE, (const char *)&packet, MAVLINK_MSG_ID_ADSB_VEHICLE_MIN_LEN, MAVLINK_MSG_ID_ADSB_VEHICLE_LEN, MAVLINK_MSG_ID_ADSB_VEHICLE_CRC);
 #endif
 }
@@ -377,7 +377,7 @@ static inline void mavlink_msg_adsb_vehicle_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_ADSB_VEHICLE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -415,7 +415,7 @@ static inline void mavlink_msg_adsb_vehicle_send_buf(mavlink_message_t *msgbuf,
     packet->altitude_type = altitude_type;
     packet->emitter_type = emitter_type;
     packet->tslc = tslc;
-    mav_array_assign_char(packet->callsign, callsign, 9);
+    mav_array_memcpy(packet->callsign, callsign, sizeof(char)*9);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ADSB_VEHICLE, (const char *)packet, MAVLINK_MSG_ID_ADSB_VEHICLE_MIN_LEN, MAVLINK_MSG_ID_ADSB_VEHICLE_LEN, MAVLINK_MSG_ID_ADSB_VEHICLE_CRC);
 #endif
 }

v2.0/common/mavlink_msg_ais_vessel.h

@@ -149,8 +149,8 @@ static inline uint16_t mavlink_msg_ais_vessel_pack(uint8_t system_id, uint8_t co
     packet.type = type;
     packet.dimension_port = dimension_port;
     packet.dimension_starboard = dimension_starboard;
-    mav_array_assign_char(packet.callsign, callsign, 7);
-    mav_array_assign_char(packet.name, name, 20);
+    mav_array_memcpy(packet.callsign, callsign, sizeof(char)*7);
+    mav_array_memcpy(packet.name, name, sizeof(char)*20);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AIS_VESSEL_LEN);
 #endif
 
@@ -303,8 +303,8 @@ static inline uint16_t mavlink_msg_ais_vessel_pack_chan(uint8_t system_id, uint8
     packet.type = type;
     packet.dimension_port = dimension_port;
     packet.dimension_starboard = dimension_starboard;
-    mav_array_assign_char(packet.callsign, callsign, 7);
-    mav_array_assign_char(packet.name, name, 20);
+    mav_array_memcpy(packet.callsign, callsign, sizeof(char)*7);
+    mav_array_memcpy(packet.name, name, sizeof(char)*20);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AIS_VESSEL_LEN);
 #endif
 
@@ -416,8 +416,8 @@ static inline void mavlink_msg_ais_vessel_send(mavlink_channel_t chan, uint32_t
     packet.type = type;
     packet.dimension_port = dimension_port;
     packet.dimension_starboard = dimension_starboard;
-    mav_array_assign_char(packet.callsign, callsign, 7);
-    mav_array_assign_char(packet.name, name, 20);
+    mav_array_memcpy(packet.callsign, callsign, sizeof(char)*7);
+    mav_array_memcpy(packet.name, name, sizeof(char)*20);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AIS_VESSEL, (const char *)&packet, MAVLINK_MSG_ID_AIS_VESSEL_MIN_LEN, MAVLINK_MSG_ID_AIS_VESSEL_LEN, MAVLINK_MSG_ID_AIS_VESSEL_CRC);
 #endif
 }
@@ -438,7 +438,7 @@ static inline void mavlink_msg_ais_vessel_send_struct(mavlink_channel_t chan, co
 
 #if MAVLINK_MSG_ID_AIS_VESSEL_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -483,8 +483,8 @@ static inline void mavlink_msg_ais_vessel_send_buf(mavlink_message_t *msgbuf, ma
     packet->type = type;
     packet->dimension_port = dimension_port;
     packet->dimension_starboard = dimension_starboard;
-    mav_array_assign_char(packet->callsign, callsign, 7);
-    mav_array_assign_char(packet->name, name, 20);
+    mav_array_memcpy(packet->callsign, callsign, sizeof(char)*7);
+    mav_array_memcpy(packet->name, name, sizeof(char)*20);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AIS_VESSEL, (const char *)packet, MAVLINK_MSG_ID_AIS_VESSEL_MIN_LEN, MAVLINK_MSG_ID_AIS_VESSEL_LEN, MAVLINK_MSG_ID_AIS_VESSEL_CRC);
 #endif
 }

v2.0/common/mavlink_msg_altitude.h

@@ -295,7 +295,7 @@ static inline void mavlink_msg_altitude_send_struct(mavlink_channel_t chan, cons
 
 #if MAVLINK_MSG_ID_ALTITUDE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_att_pos_mocap.h

@@ -83,8 +83,8 @@ static inline uint16_t mavlink_msg_att_pos_mocap_pack(uint8_t system_id, uint8_t
     packet.x = x;
     packet.y = y;
     packet.z = z;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_float(packet.covariance, covariance, 21);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*21);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATT_POS_MOCAP_LEN);
 #endif
 
@@ -171,8 +171,8 @@ static inline uint16_t mavlink_msg_att_pos_mocap_pack_chan(uint8_t system_id, ui
     packet.x = x;
     packet.y = y;
     packet.z = z;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_float(packet.covariance, covariance, 21);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*21);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATT_POS_MOCAP_LEN);
 #endif
 
@@ -251,8 +251,8 @@ static inline void mavlink_msg_att_pos_mocap_send(mavlink_channel_t chan, uint64
     packet.x = x;
     packet.y = y;
     packet.z = z;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_float(packet.covariance, covariance, 21);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*21);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATT_POS_MOCAP, (const char *)&packet, MAVLINK_MSG_ID_ATT_POS_MOCAP_MIN_LEN, MAVLINK_MSG_ID_ATT_POS_MOCAP_LEN, MAVLINK_MSG_ID_ATT_POS_MOCAP_CRC);
 #endif
 }
@@ -273,7 +273,7 @@ static inline void mavlink_msg_att_pos_mocap_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_ATT_POS_MOCAP_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -296,8 +296,8 @@ static inline void mavlink_msg_att_pos_mocap_send_buf(mavlink_message_t *msgbuf,
     packet->x = x;
     packet->y = y;
     packet->z = z;
-    mav_array_assign_float(packet->q, q, 4);
-    mav_array_assign_float(packet->covariance, covariance, 21);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
+    mav_array_memcpy(packet->covariance, covariance, sizeof(float)*21);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATT_POS_MOCAP, (const char *)packet, MAVLINK_MSG_ID_ATT_POS_MOCAP_MIN_LEN, MAVLINK_MSG_ID_ATT_POS_MOCAP_LEN, MAVLINK_MSG_ID_ATT_POS_MOCAP_CRC);
 #endif
 }

v2.0/common/mavlink_msg_attitude.h

@@ -295,7 +295,7 @@ static inline void mavlink_msg_attitude_send_struct(mavlink_channel_t chan, cons
 
 #if MAVLINK_MSG_ID_ATTITUDE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_attitude_quaternion.h

@@ -101,7 +101,7 @@ static inline uint16_t mavlink_msg_attitude_quaternion_pack(uint8_t system_id, u
     packet.rollspeed = rollspeed;
     packet.pitchspeed = pitchspeed;
     packet.yawspeed = yawspeed;
-    mav_array_assign_float(packet.repr_offset_q, repr_offset_q, 4);
+    mav_array_memcpy(packet.repr_offset_q, repr_offset_q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_LEN);
 #endif
 
@@ -207,7 +207,7 @@ static inline uint16_t mavlink_msg_attitude_quaternion_pack_chan(uint8_t system_
     packet.rollspeed = rollspeed;
     packet.pitchspeed = pitchspeed;
     packet.yawspeed = yawspeed;
-    mav_array_assign_float(packet.repr_offset_q, repr_offset_q, 4);
+    mav_array_memcpy(packet.repr_offset_q, repr_offset_q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_LEN);
 #endif
 
@@ -296,7 +296,7 @@ static inline void mavlink_msg_attitude_quaternion_send(mavlink_channel_t chan,
     packet.rollspeed = rollspeed;
     packet.pitchspeed = pitchspeed;
     packet.yawspeed = yawspeed;
-    mav_array_assign_float(packet.repr_offset_q, repr_offset_q, 4);
+    mav_array_memcpy(packet.repr_offset_q, repr_offset_q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE_QUATERNION, (const char *)&packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_MIN_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_CRC);
 #endif
 }
@@ -317,7 +317,7 @@ static inline void mavlink_msg_attitude_quaternion_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_ATTITUDE_QUATERNION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -347,7 +347,7 @@ static inline void mavlink_msg_attitude_quaternion_send_buf(mavlink_message_t *m
     packet->rollspeed = rollspeed;
     packet->pitchspeed = pitchspeed;
     packet->yawspeed = yawspeed;
-    mav_array_assign_float(packet->repr_offset_q, repr_offset_q, 4);
+    mav_array_memcpy(packet->repr_offset_q, repr_offset_q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE_QUATERNION, (const char *)packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_MIN_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_CRC);
 #endif
 }

v2.0/common/mavlink_msg_attitude_quaternion_cov.h

@@ -83,8 +83,8 @@ static inline uint16_t mavlink_msg_attitude_quaternion_cov_pack(uint8_t system_i
     packet.rollspeed = rollspeed;
     packet.pitchspeed = pitchspeed;
     packet.yawspeed = yawspeed;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_float(packet.covariance, covariance, 9);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*9);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_LEN);
 #endif
 
@@ -171,8 +171,8 @@ static inline uint16_t mavlink_msg_attitude_quaternion_cov_pack_chan(uint8_t sys
     packet.rollspeed = rollspeed;
     packet.pitchspeed = pitchspeed;
     packet.yawspeed = yawspeed;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_float(packet.covariance, covariance, 9);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*9);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_LEN);
 #endif
 
@@ -251,8 +251,8 @@ static inline void mavlink_msg_attitude_quaternion_cov_send(mavlink_channel_t ch
     packet.rollspeed = rollspeed;
     packet.pitchspeed = pitchspeed;
     packet.yawspeed = yawspeed;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_float(packet.covariance, covariance, 9);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*9);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV, (const char *)&packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_MIN_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_CRC);
 #endif
 }
@@ -273,7 +273,7 @@ static inline void mavlink_msg_attitude_quaternion_cov_send_struct(mavlink_chann
 
 #if MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -296,8 +296,8 @@ static inline void mavlink_msg_attitude_quaternion_cov_send_buf(mavlink_message_
     packet->rollspeed = rollspeed;
     packet->pitchspeed = pitchspeed;
     packet->yawspeed = yawspeed;
-    mav_array_assign_float(packet->q, q, 4);
-    mav_array_assign_float(packet->covariance, covariance, 9);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
+    mav_array_memcpy(packet->covariance, covariance, sizeof(float)*9);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV, (const char *)packet, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_MIN_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_LEN, MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_CRC);
 #endif
 }

v2.0/common/mavlink_msg_attitude_target.h

@@ -89,7 +89,7 @@ static inline uint16_t mavlink_msg_attitude_target_pack(uint8_t system_id, uint8
     packet.body_yaw_rate = body_yaw_rate;
     packet.thrust = thrust;
     packet.type_mask = type_mask;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATTITUDE_TARGET_LEN);
 #endif
 
@@ -183,7 +183,7 @@ static inline uint16_t mavlink_msg_attitude_target_pack_chan(uint8_t system_id,
     packet.body_yaw_rate = body_yaw_rate;
     packet.thrust = thrust;
     packet.type_mask = type_mask;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ATTITUDE_TARGET_LEN);
 #endif
 
@@ -266,7 +266,7 @@ static inline void mavlink_msg_attitude_target_send(mavlink_channel_t chan, uint
     packet.body_yaw_rate = body_yaw_rate;
     packet.thrust = thrust;
     packet.type_mask = type_mask;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE_TARGET, (const char *)&packet, MAVLINK_MSG_ID_ATTITUDE_TARGET_MIN_LEN, MAVLINK_MSG_ID_ATTITUDE_TARGET_LEN, MAVLINK_MSG_ID_ATTITUDE_TARGET_CRC);
 #endif
 }
@@ -287,7 +287,7 @@ static inline void mavlink_msg_attitude_target_send_struct(mavlink_channel_t cha
 
 #if MAVLINK_MSG_ID_ATTITUDE_TARGET_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -313,7 +313,7 @@ static inline void mavlink_msg_attitude_target_send_buf(mavlink_message_t *msgbu
     packet->body_yaw_rate = body_yaw_rate;
     packet->thrust = thrust;
     packet->type_mask = type_mask;
-    mav_array_assign_float(packet->q, q, 4);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ATTITUDE_TARGET, (const char *)packet, MAVLINK_MSG_ID_ATTITUDE_TARGET_MIN_LEN, MAVLINK_MSG_ID_ATTITUDE_TARGET_LEN, MAVLINK_MSG_ID_ATTITUDE_TARGET_CRC);
 #endif
 }

v2.0/common/mavlink_msg_auth_key.h

@@ -55,7 +55,7 @@ static inline uint16_t mavlink_msg_auth_key_pack(uint8_t system_id, uint8_t comp
 #else
     mavlink_auth_key_t packet;
 
-    mav_array_assign_char(packet.key, key, 32);
+    mav_array_memcpy(packet.key, key, sizeof(char)*32);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AUTH_KEY_LEN);
 #endif
 
@@ -117,7 +117,7 @@ static inline uint16_t mavlink_msg_auth_key_pack_chan(uint8_t system_id, uint8_t
 #else
     mavlink_auth_key_t packet;
 
-    mav_array_assign_char(packet.key, key, 32);
+    mav_array_memcpy(packet.key, key, sizeof(char)*32);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AUTH_KEY_LEN);
 #endif
 
@@ -184,7 +184,7 @@ static inline void mavlink_msg_auth_key_send(mavlink_channel_t chan, const char
 #else
     mavlink_auth_key_t packet;
 
-    mav_array_assign_char(packet.key, key, 32);
+    mav_array_memcpy(packet.key, key, sizeof(char)*32);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTH_KEY, (const char *)&packet, MAVLINK_MSG_ID_AUTH_KEY_MIN_LEN, MAVLINK_MSG_ID_AUTH_KEY_LEN, MAVLINK_MSG_ID_AUTH_KEY_CRC);
 #endif
 }
@@ -205,7 +205,7 @@ static inline void mavlink_msg_auth_key_send_struct(mavlink_channel_t chan, cons
 
 #if MAVLINK_MSG_ID_AUTH_KEY_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -221,7 +221,7 @@ static inline void mavlink_msg_auth_key_send_buf(mavlink_message_t *msgbuf, mavl
 #else
     mavlink_auth_key_t *packet = (mavlink_auth_key_t *)msgbuf;
 
-    mav_array_assign_char(packet->key, key, 32);
+    mav_array_memcpy(packet->key, key, sizeof(char)*32);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTH_KEY, (const char *)packet, MAVLINK_MSG_ID_AUTH_KEY_MIN_LEN, MAVLINK_MSG_ID_AUTH_KEY_LEN, MAVLINK_MSG_ID_AUTH_KEY_CRC);
 #endif
 }

v2.0/common/mavlink_msg_autopilot_state_for_gimbal_device.h

@@ -125,7 +125,7 @@ static inline uint16_t mavlink_msg_autopilot_state_for_gimbal_device_pack(uint8_
     packet.target_component = target_component;
     packet.landed_state = landed_state;
     packet.angular_velocity_z = angular_velocity_z;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_LEN);
 #endif
 
@@ -255,7 +255,7 @@ static inline uint16_t mavlink_msg_autopilot_state_for_gimbal_device_pack_chan(u
     packet.target_component = target_component;
     packet.landed_state = landed_state;
     packet.angular_velocity_z = angular_velocity_z;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_LEN);
 #endif
 
@@ -356,7 +356,7 @@ static inline void mavlink_msg_autopilot_state_for_gimbal_device_send(mavlink_ch
     packet.target_component = target_component;
     packet.landed_state = landed_state;
     packet.angular_velocity_z = angular_velocity_z;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE, (const char *)&packet, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_MIN_LEN, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_LEN, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_CRC);
 #endif
 }
@@ -377,7 +377,7 @@ static inline void mavlink_msg_autopilot_state_for_gimbal_device_send_struct(mav
 
 #if MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -415,7 +415,7 @@ static inline void mavlink_msg_autopilot_state_for_gimbal_device_send_buf(mavlin
     packet->target_component = target_component;
     packet->landed_state = landed_state;
     packet->angular_velocity_z = angular_velocity_z;
-    mav_array_assign_float(packet->q, q, 4);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE, (const char *)packet, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_MIN_LEN, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_LEN, MAVLINK_MSG_ID_AUTOPILOT_STATE_FOR_GIMBAL_DEVICE_CRC);
 #endif
 }

v2.0/common/mavlink_msg_autopilot_version.h

@@ -119,10 +119,10 @@ static inline uint16_t mavlink_msg_autopilot_version_pack(uint8_t system_id, uin
     packet.board_version = board_version;
     packet.vendor_id = vendor_id;
     packet.product_id = product_id;
-    mav_array_assign_uint8_t(packet.flight_custom_version, flight_custom_version, 8);
-    mav_array_assign_uint8_t(packet.middleware_custom_version, middleware_custom_version, 8);
-    mav_array_assign_uint8_t(packet.os_custom_version, os_custom_version, 8);
-    mav_array_assign_uint8_t(packet.uid2, uid2, 18);
+    mav_array_memcpy(packet.flight_custom_version, flight_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.middleware_custom_version, middleware_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.os_custom_version, os_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.uid2, uid2, sizeof(uint8_t)*18);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AUTOPILOT_VERSION_LEN);
 #endif
 
@@ -243,10 +243,10 @@ static inline uint16_t mavlink_msg_autopilot_version_pack_chan(uint8_t system_id
     packet.board_version = board_version;
     packet.vendor_id = vendor_id;
     packet.product_id = product_id;
-    mav_array_assign_uint8_t(packet.flight_custom_version, flight_custom_version, 8);
-    mav_array_assign_uint8_t(packet.middleware_custom_version, middleware_custom_version, 8);
-    mav_array_assign_uint8_t(packet.os_custom_version, os_custom_version, 8);
-    mav_array_assign_uint8_t(packet.uid2, uid2, 18);
+    mav_array_memcpy(packet.flight_custom_version, flight_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.middleware_custom_version, middleware_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.os_custom_version, os_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.uid2, uid2, sizeof(uint8_t)*18);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_AUTOPILOT_VERSION_LEN);
 #endif
 
@@ -341,10 +341,10 @@ static inline void mavlink_msg_autopilot_version_send(mavlink_channel_t chan, ui
     packet.board_version = board_version;
     packet.vendor_id = vendor_id;
     packet.product_id = product_id;
-    mav_array_assign_uint8_t(packet.flight_custom_version, flight_custom_version, 8);
-    mav_array_assign_uint8_t(packet.middleware_custom_version, middleware_custom_version, 8);
-    mav_array_assign_uint8_t(packet.os_custom_version, os_custom_version, 8);
-    mav_array_assign_uint8_t(packet.uid2, uid2, 18);
+    mav_array_memcpy(packet.flight_custom_version, flight_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.middleware_custom_version, middleware_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.os_custom_version, os_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet.uid2, uid2, sizeof(uint8_t)*18);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTOPILOT_VERSION, (const char *)&packet, MAVLINK_MSG_ID_AUTOPILOT_VERSION_MIN_LEN, MAVLINK_MSG_ID_AUTOPILOT_VERSION_LEN, MAVLINK_MSG_ID_AUTOPILOT_VERSION_CRC);
 #endif
 }
@@ -365,7 +365,7 @@ static inline void mavlink_msg_autopilot_version_send_struct(mavlink_channel_t c
 
 #if MAVLINK_MSG_ID_AUTOPILOT_VERSION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -398,10 +398,10 @@ static inline void mavlink_msg_autopilot_version_send_buf(mavlink_message_t *msg
     packet->board_version = board_version;
     packet->vendor_id = vendor_id;
     packet->product_id = product_id;
-    mav_array_assign_uint8_t(packet->flight_custom_version, flight_custom_version, 8);
-    mav_array_assign_uint8_t(packet->middleware_custom_version, middleware_custom_version, 8);
-    mav_array_assign_uint8_t(packet->os_custom_version, os_custom_version, 8);
-    mav_array_assign_uint8_t(packet->uid2, uid2, 18);
+    mav_array_memcpy(packet->flight_custom_version, flight_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet->middleware_custom_version, middleware_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet->os_custom_version, os_custom_version, sizeof(uint8_t)*8);
+    mav_array_memcpy(packet->uid2, uid2, sizeof(uint8_t)*18);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_AUTOPILOT_VERSION, (const char *)packet, MAVLINK_MSG_ID_AUTOPILOT_VERSION_MIN_LEN, MAVLINK_MSG_ID_AUTOPILOT_VERSION_LEN, MAVLINK_MSG_ID_AUTOPILOT_VERSION_CRC);
 #endif
 }

v2.0/common/mavlink_msg_battery_info.h

@@ -122,7 +122,6 @@ 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)
 {
@@ -168,9 +167,9 @@ static inline uint16_t mavlink_msg_battery_info_pack(uint8_t system_id, uint8_t
     packet.type = type;
     packet.state_of_health = state_of_health;
     packet.cells_in_series = cells_in_series;
-    mav_array_assign_char(packet.manufacture_date, manufacture_date, 9);
-    mav_array_assign_char(packet.serial_number, serial_number, 32);
-    mav_array_assign_char(packet.name, name, 50);
+    mav_array_memcpy(packet.manufacture_date, manufacture_date, sizeof(char)*9);
+    mav_array_memcpy(packet.serial_number, serial_number, sizeof(char)*32);
+    mav_array_memcpy(packet.name, name, sizeof(char)*50);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_BATTERY_INFO_LEN);
 #endif
 
@@ -294,7 +293,6 @@ 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)
@@ -341,9 +339,9 @@ static inline uint16_t mavlink_msg_battery_info_pack_chan(uint8_t system_id, uin
     packet.type = type;
     packet.state_of_health = state_of_health;
     packet.cells_in_series = cells_in_series;
-    mav_array_assign_char(packet.manufacture_date, manufacture_date, 9);
-    mav_array_assign_char(packet.serial_number, serial_number, 32);
-    mav_array_assign_char(packet.name, name, 50);
+    mav_array_memcpy(packet.manufacture_date, manufacture_date, sizeof(char)*9);
+    mav_array_memcpy(packet.serial_number, serial_number, sizeof(char)*32);
+    mav_array_memcpy(packet.name, name, sizeof(char)*50);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_BATTERY_INFO_LEN);
 #endif
 
@@ -359,7 +357,6 @@ 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);
@@ -374,7 +371,6 @@ 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);
@@ -421,7 +417,6 @@ 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
@@ -466,9 +461,9 @@ static inline void mavlink_msg_battery_info_send(mavlink_channel_t chan, uint8_t
     packet.type = type;
     packet.state_of_health = state_of_health;
     packet.cells_in_series = cells_in_series;
-    mav_array_assign_char(packet.manufacture_date, manufacture_date, 9);
-    mav_array_assign_char(packet.serial_number, serial_number, 32);
-    mav_array_assign_char(packet.name, name, 50);
+    mav_array_memcpy(packet.manufacture_date, manufacture_date, sizeof(char)*9);
+    mav_array_memcpy(packet.serial_number, serial_number, sizeof(char)*32);
+    mav_array_memcpy(packet.name, name, sizeof(char)*50);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_BATTERY_INFO, (const char *)&packet, MAVLINK_MSG_ID_BATTERY_INFO_MIN_LEN, MAVLINK_MSG_ID_BATTERY_INFO_LEN, MAVLINK_MSG_ID_BATTERY_INFO_CRC);
 #endif
 }
@@ -478,7 +473,6 @@ 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,13 +484,12 @@ static inline void mavlink_msg_battery_info_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_BATTERY_INFO_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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.
  */
-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
@@ -541,9 +534,9 @@ static inline void mavlink_msg_battery_info_send_buf(mavlink_message_t *msgbuf,
     packet->type = type;
     packet->state_of_health = state_of_health;
     packet->cells_in_series = cells_in_series;
-    mav_array_assign_char(packet->manufacture_date, manufacture_date, 9);
-    mav_array_assign_char(packet->serial_number, serial_number, 32);
-    mav_array_assign_char(packet->name, name, 50);
+    mav_array_memcpy(packet->manufacture_date, manufacture_date, sizeof(char)*9);
+    mav_array_memcpy(packet->serial_number, serial_number, sizeof(char)*32);
+    mav_array_memcpy(packet->name, name, sizeof(char)*50);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_BATTERY_INFO, (const char *)packet, MAVLINK_MSG_ID_BATTERY_INFO_MIN_LEN, MAVLINK_MSG_ID_BATTERY_INFO_LEN, MAVLINK_MSG_ID_BATTERY_INFO_CRC);
 #endif
 }
@@ -559,7 +552,6 @@ 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);
@@ -570,7 +562,6 @@ 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);
@@ -581,7 +572,6 @@ 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);
@@ -592,7 +582,6 @@ 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);
@@ -603,7 +592,6 @@ 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);
@@ -614,7 +602,6 @@ 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);
@@ -625,7 +612,6 @@ 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);
@@ -636,7 +622,6 @@ 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);
@@ -647,7 +632,6 @@ 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);
@@ -658,7 +642,6 @@ 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);
@@ -669,7 +652,6 @@ 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);
@@ -680,7 +662,6 @@ 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);
@@ -691,7 +672,6 @@ 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);
@@ -702,7 +682,6 @@ 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);
@@ -713,7 +692,6 @@ 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);
@@ -724,7 +702,6 @@ 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);
@@ -735,7 +712,6 @@ 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);
@@ -746,7 +722,6 @@ 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);
@@ -757,7 +732,6 @@ 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);
@@ -768,7 +742,6 @@ 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);
@@ -780,7 +753,6 @@ 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

v2.0/common/mavlink_msg_battery_status.h

@@ -131,8 +131,8 @@ static inline uint16_t mavlink_msg_battery_status_pack(uint8_t system_id, uint8_
     packet.charge_state = charge_state;
     packet.mode = mode;
     packet.fault_bitmask = fault_bitmask;
-    mav_array_assign_uint16_t(packet.voltages, voltages, 10);
-    mav_array_assign_uint16_t(packet.voltages_ext, voltages_ext, 4);
+    mav_array_memcpy(packet.voltages, voltages, sizeof(uint16_t)*10);
+    mav_array_memcpy(packet.voltages_ext, voltages_ext, sizeof(uint16_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_BATTERY_STATUS_LEN);
 #endif
 
@@ -267,8 +267,8 @@ static inline uint16_t mavlink_msg_battery_status_pack_chan(uint8_t system_id, u
     packet.charge_state = charge_state;
     packet.mode = mode;
     packet.fault_bitmask = fault_bitmask;
-    mav_array_assign_uint16_t(packet.voltages, voltages, 10);
-    mav_array_assign_uint16_t(packet.voltages_ext, voltages_ext, 4);
+    mav_array_memcpy(packet.voltages, voltages, sizeof(uint16_t)*10);
+    mav_array_memcpy(packet.voltages_ext, voltages_ext, sizeof(uint16_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_BATTERY_STATUS_LEN);
 #endif
 
@@ -371,8 +371,8 @@ static inline void mavlink_msg_battery_status_send(mavlink_channel_t chan, uint8
     packet.charge_state = charge_state;
     packet.mode = mode;
     packet.fault_bitmask = fault_bitmask;
-    mav_array_assign_uint16_t(packet.voltages, voltages, 10);
-    mav_array_assign_uint16_t(packet.voltages_ext, voltages_ext, 4);
+    mav_array_memcpy(packet.voltages, voltages, sizeof(uint16_t)*10);
+    mav_array_memcpy(packet.voltages_ext, voltages_ext, sizeof(uint16_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_BATTERY_STATUS, (const char *)&packet, MAVLINK_MSG_ID_BATTERY_STATUS_MIN_LEN, MAVLINK_MSG_ID_BATTERY_STATUS_LEN, MAVLINK_MSG_ID_BATTERY_STATUS_CRC);
 #endif
 }
@@ -393,7 +393,7 @@ static inline void mavlink_msg_battery_status_send_struct(mavlink_channel_t chan
 
 #if MAVLINK_MSG_ID_BATTERY_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -432,8 +432,8 @@ static inline void mavlink_msg_battery_status_send_buf(mavlink_message_t *msgbuf
     packet->charge_state = charge_state;
     packet->mode = mode;
     packet->fault_bitmask = fault_bitmask;
-    mav_array_assign_uint16_t(packet->voltages, voltages, 10);
-    mav_array_assign_uint16_t(packet->voltages_ext, voltages_ext, 4);
+    mav_array_memcpy(packet->voltages, voltages, sizeof(uint16_t)*10);
+    mav_array_memcpy(packet->voltages_ext, voltages_ext, sizeof(uint16_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_BATTERY_STATUS, (const char *)packet, MAVLINK_MSG_ID_BATTERY_STATUS_MIN_LEN, MAVLINK_MSG_ID_BATTERY_STATUS_LEN, MAVLINK_MSG_ID_BATTERY_STATUS_CRC);
 #endif
 }

v2.0/common/mavlink_msg_button_change.h

@@ -235,7 +235,7 @@ static inline void mavlink_msg_button_change_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_BUTTON_CHANGE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_camera_capture_status.h

@@ -295,7 +295,7 @@ static inline void mavlink_msg_camera_capture_status_send_struct(mavlink_channel
 
 #if MAVLINK_MSG_ID_CAMERA_CAPTURE_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_camera_fov_status.h

@@ -107,7 +107,7 @@ static inline uint16_t mavlink_msg_camera_fov_status_pack(uint8_t system_id, uin
     packet.alt_image = alt_image;
     packet.hfov = hfov;
     packet.vfov = vfov;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_LEN);
 #endif
 
@@ -219,7 +219,7 @@ static inline uint16_t mavlink_msg_camera_fov_status_pack_chan(uint8_t system_id
     packet.alt_image = alt_image;
     packet.hfov = hfov;
     packet.vfov = vfov;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_LEN);
 #endif
 
@@ -311,7 +311,7 @@ static inline void mavlink_msg_camera_fov_status_send(mavlink_channel_t chan, ui
     packet.alt_image = alt_image;
     packet.hfov = hfov;
     packet.vfov = vfov;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAMERA_FOV_STATUS, (const char *)&packet, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_MIN_LEN, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_LEN, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_CRC);
 #endif
 }
@@ -332,7 +332,7 @@ static inline void mavlink_msg_camera_fov_status_send_struct(mavlink_channel_t c
 
 #if MAVLINK_MSG_ID_CAMERA_FOV_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -364,7 +364,7 @@ static inline void mavlink_msg_camera_fov_status_send_buf(mavlink_message_t *msg
     packet->alt_image = alt_image;
     packet->hfov = hfov;
     packet->vfov = vfov;
-    mav_array_assign_float(packet->q, q, 4);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAMERA_FOV_STATUS, (const char *)packet, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_MIN_LEN, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_LEN, MAVLINK_MSG_ID_CAMERA_FOV_STATUS_CRC);
 #endif
 }

v2.0/common/mavlink_msg_camera_image_captured.h

@@ -113,8 +113,8 @@ static inline uint16_t mavlink_msg_camera_image_captured_pack(uint8_t system_id,
     packet.image_index = image_index;
     packet.camera_id = camera_id;
     packet.capture_result = capture_result;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_char(packet.file_url, file_url, 205);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.file_url, file_url, sizeof(char)*205);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_LEN);
 #endif
 
@@ -231,8 +231,8 @@ static inline uint16_t mavlink_msg_camera_image_captured_pack_chan(uint8_t syste
     packet.image_index = image_index;
     packet.camera_id = camera_id;
     packet.capture_result = capture_result;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_char(packet.file_url, file_url, 205);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.file_url, file_url, sizeof(char)*205);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_LEN);
 #endif
 
@@ -326,8 +326,8 @@ static inline void mavlink_msg_camera_image_captured_send(mavlink_channel_t chan
     packet.image_index = image_index;
     packet.camera_id = camera_id;
     packet.capture_result = capture_result;
-    mav_array_assign_float(packet.q, q, 4);
-    mav_array_assign_char(packet.file_url, file_url, 205);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
+    mav_array_memcpy(packet.file_url, file_url, sizeof(char)*205);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED, (const char *)&packet, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_MIN_LEN, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_LEN, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_CRC);
 #endif
 }
@@ -348,7 +348,7 @@ static inline void mavlink_msg_camera_image_captured_send_struct(mavlink_channel
 
 #if MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -381,8 +381,8 @@ static inline void mavlink_msg_camera_image_captured_send_buf(mavlink_message_t
     packet->image_index = image_index;
     packet->camera_id = camera_id;
     packet->capture_result = capture_result;
-    mav_array_assign_float(packet->q, q, 4);
-    mav_array_assign_char(packet->file_url, file_url, 205);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
+    mav_array_memcpy(packet->file_url, file_url, sizeof(char)*205);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED, (const char *)packet, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_MIN_LEN, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_LEN, MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_CRC);
 #endif
 }

v2.0/common/mavlink_msg_camera_information.h

@@ -131,9 +131,9 @@ static inline uint16_t mavlink_msg_camera_information_pack(uint8_t system_id, ui
     packet.cam_definition_version = cam_definition_version;
     packet.lens_id = lens_id;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_uint8_t(packet.vendor_name, vendor_name, 32);
-    mav_array_assign_uint8_t(packet.model_name, model_name, 32);
-    mav_array_assign_char(packet.cam_definition_uri, cam_definition_uri, 140);
+    mav_array_memcpy(packet.vendor_name, vendor_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet.model_name, model_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet.cam_definition_uri, cam_definition_uri, sizeof(char)*140);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAMERA_INFORMATION_LEN);
 #endif
 
@@ -267,9 +267,9 @@ static inline uint16_t mavlink_msg_camera_information_pack_chan(uint8_t system_i
     packet.cam_definition_version = cam_definition_version;
     packet.lens_id = lens_id;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_uint8_t(packet.vendor_name, vendor_name, 32);
-    mav_array_assign_uint8_t(packet.model_name, model_name, 32);
-    mav_array_assign_char(packet.cam_definition_uri, cam_definition_uri, 140);
+    mav_array_memcpy(packet.vendor_name, vendor_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet.model_name, model_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet.cam_definition_uri, cam_definition_uri, sizeof(char)*140);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAMERA_INFORMATION_LEN);
 #endif
 
@@ -371,9 +371,9 @@ static inline void mavlink_msg_camera_information_send(mavlink_channel_t chan, u
     packet.cam_definition_version = cam_definition_version;
     packet.lens_id = lens_id;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_uint8_t(packet.vendor_name, vendor_name, 32);
-    mav_array_assign_uint8_t(packet.model_name, model_name, 32);
-    mav_array_assign_char(packet.cam_definition_uri, cam_definition_uri, 140);
+    mav_array_memcpy(packet.vendor_name, vendor_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet.model_name, model_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet.cam_definition_uri, cam_definition_uri, sizeof(char)*140);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAMERA_INFORMATION, (const char *)&packet, MAVLINK_MSG_ID_CAMERA_INFORMATION_MIN_LEN, MAVLINK_MSG_ID_CAMERA_INFORMATION_LEN, MAVLINK_MSG_ID_CAMERA_INFORMATION_CRC);
 #endif
 }
@@ -394,7 +394,7 @@ static inline void mavlink_msg_camera_information_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_CAMERA_INFORMATION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -432,9 +432,9 @@ static inline void mavlink_msg_camera_information_send_buf(mavlink_message_t *ms
     packet->cam_definition_version = cam_definition_version;
     packet->lens_id = lens_id;
     packet->gimbal_device_id = gimbal_device_id;
-    mav_array_assign_uint8_t(packet->vendor_name, vendor_name, 32);
-    mav_array_assign_uint8_t(packet->model_name, model_name, 32);
-    mav_array_assign_char(packet->cam_definition_uri, cam_definition_uri, 140);
+    mav_array_memcpy(packet->vendor_name, vendor_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet->model_name, model_name, sizeof(uint8_t)*32);
+    mav_array_memcpy(packet->cam_definition_uri, cam_definition_uri, sizeof(char)*140);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAMERA_INFORMATION, (const char *)packet, MAVLINK_MSG_ID_CAMERA_INFORMATION_MIN_LEN, MAVLINK_MSG_ID_CAMERA_INFORMATION_LEN, MAVLINK_MSG_ID_CAMERA_INFORMATION_CRC);
 #endif
 }

v2.0/common/mavlink_msg_camera_settings.h

@@ -250,7 +250,7 @@ static inline void mavlink_msg_camera_settings_send_struct(mavlink_channel_t cha
 
 #if MAVLINK_MSG_ID_CAMERA_SETTINGS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_camera_tracking_geo_status.h

@@ -385,7 +385,7 @@ static inline void mavlink_msg_camera_tracking_geo_status_send_struct(mavlink_ch
 
 #if MAVLINK_MSG_ID_CAMERA_TRACKING_GEO_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_camera_tracking_image_status.h

@@ -340,7 +340,7 @@ static inline void mavlink_msg_camera_tracking_image_status_send_struct(mavlink_
 
 #if MAVLINK_MSG_ID_CAMERA_TRACKING_IMAGE_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_camera_trigger.h

@@ -220,7 +220,7 @@ static inline void mavlink_msg_camera_trigger_send_struct(mavlink_channel_t chan
 
 #if MAVLINK_MSG_ID_CAMERA_TRIGGER_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_can_filter_modify.h

@@ -83,7 +83,7 @@ static inline uint16_t mavlink_msg_can_filter_modify_pack(uint8_t system_id, uin
     packet.bus = bus;
     packet.operation = operation;
     packet.num_ids = num_ids;
-    mav_array_assign_uint16_t(packet.ids, ids, 16);
+    mav_array_memcpy(packet.ids, ids, sizeof(uint16_t)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_LEN);
 #endif
 
@@ -171,7 +171,7 @@ static inline uint16_t mavlink_msg_can_filter_modify_pack_chan(uint8_t system_id
     packet.bus = bus;
     packet.operation = operation;
     packet.num_ids = num_ids;
-    mav_array_assign_uint16_t(packet.ids, ids, 16);
+    mav_array_memcpy(packet.ids, ids, sizeof(uint16_t)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_LEN);
 #endif
 
@@ -251,7 +251,7 @@ static inline void mavlink_msg_can_filter_modify_send(mavlink_channel_t chan, ui
     packet.bus = bus;
     packet.operation = operation;
     packet.num_ids = num_ids;
-    mav_array_assign_uint16_t(packet.ids, ids, 16);
+    mav_array_memcpy(packet.ids, ids, sizeof(uint16_t)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAN_FILTER_MODIFY, (const char *)&packet, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_MIN_LEN, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_LEN, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_CRC);
 #endif
 }
@@ -272,7 +272,7 @@ static inline void mavlink_msg_can_filter_modify_send_struct(mavlink_channel_t c
 
 #if MAVLINK_MSG_ID_CAN_FILTER_MODIFY_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -296,7 +296,7 @@ static inline void mavlink_msg_can_filter_modify_send_buf(mavlink_message_t *msg
     packet->bus = bus;
     packet->operation = operation;
     packet->num_ids = num_ids;
-    mav_array_assign_uint16_t(packet->ids, ids, 16);
+    mav_array_memcpy(packet->ids, ids, sizeof(uint16_t)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAN_FILTER_MODIFY, (const char *)packet, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_MIN_LEN, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_LEN, MAVLINK_MSG_ID_CAN_FILTER_MODIFY_CRC);
 #endif
 }

v2.0/common/mavlink_msg_can_frame.h

@@ -83,7 +83,7 @@ static inline uint16_t mavlink_msg_can_frame_pack(uint8_t system_id, uint8_t com
     packet.target_component = target_component;
     packet.bus = bus;
     packet.len = len;
-    mav_array_assign_uint8_t(packet.data, data, 8);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*8);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAN_FRAME_LEN);
 #endif
 
@@ -171,7 +171,7 @@ static inline uint16_t mavlink_msg_can_frame_pack_chan(uint8_t system_id, uint8_
     packet.target_component = target_component;
     packet.bus = bus;
     packet.len = len;
-    mav_array_assign_uint8_t(packet.data, data, 8);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*8);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CAN_FRAME_LEN);
 #endif
 
@@ -251,7 +251,7 @@ static inline void mavlink_msg_can_frame_send(mavlink_channel_t chan, uint8_t ta
     packet.target_component = target_component;
     packet.bus = bus;
     packet.len = len;
-    mav_array_assign_uint8_t(packet.data, data, 8);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*8);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAN_FRAME, (const char *)&packet, MAVLINK_MSG_ID_CAN_FRAME_MIN_LEN, MAVLINK_MSG_ID_CAN_FRAME_LEN, MAVLINK_MSG_ID_CAN_FRAME_CRC);
 #endif
 }
@@ -272,7 +272,7 @@ static inline void mavlink_msg_can_frame_send_struct(mavlink_channel_t chan, con
 
 #if MAVLINK_MSG_ID_CAN_FRAME_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -296,7 +296,7 @@ static inline void mavlink_msg_can_frame_send_buf(mavlink_message_t *msgbuf, mav
     packet->target_component = target_component;
     packet->bus = bus;
     packet->len = len;
-    mav_array_assign_uint8_t(packet->data, data, 8);
+    mav_array_memcpy(packet->data, data, sizeof(uint8_t)*8);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CAN_FRAME, (const char *)packet, MAVLINK_MSG_ID_CAN_FRAME_MIN_LEN, MAVLINK_MSG_ID_CAN_FRAME_LEN, MAVLINK_MSG_ID_CAN_FRAME_CRC);
 #endif
 }

v2.0/common/mavlink_msg_canfd_frame.h

@@ -83,7 +83,7 @@ static inline uint16_t mavlink_msg_canfd_frame_pack(uint8_t system_id, uint8_t c
     packet.target_component = target_component;
     packet.bus = bus;
     packet.len = len;
-    mav_array_assign_uint8_t(packet.data, data, 64);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*64);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CANFD_FRAME_LEN);
 #endif
 
@@ -171,7 +171,7 @@ static inline uint16_t mavlink_msg_canfd_frame_pack_chan(uint8_t system_id, uint
     packet.target_component = target_component;
     packet.bus = bus;
     packet.len = len;
-    mav_array_assign_uint8_t(packet.data, data, 64);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*64);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CANFD_FRAME_LEN);
 #endif
 
@@ -251,7 +251,7 @@ static inline void mavlink_msg_canfd_frame_send(mavlink_channel_t chan, uint8_t
     packet.target_component = target_component;
     packet.bus = bus;
     packet.len = len;
-    mav_array_assign_uint8_t(packet.data, data, 64);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*64);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CANFD_FRAME, (const char *)&packet, MAVLINK_MSG_ID_CANFD_FRAME_MIN_LEN, MAVLINK_MSG_ID_CANFD_FRAME_LEN, MAVLINK_MSG_ID_CANFD_FRAME_CRC);
 #endif
 }
@@ -272,7 +272,7 @@ static inline void mavlink_msg_canfd_frame_send_struct(mavlink_channel_t chan, c
 
 #if MAVLINK_MSG_ID_CANFD_FRAME_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -296,7 +296,7 @@ static inline void mavlink_msg_canfd_frame_send_buf(mavlink_message_t *msgbuf, m
     packet->target_component = target_component;
     packet->bus = bus;
     packet->len = len;
-    mav_array_assign_uint8_t(packet->data, data, 64);
+    mav_array_memcpy(packet->data, data, sizeof(uint8_t)*64);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CANFD_FRAME, (const char *)packet, MAVLINK_MSG_ID_CANFD_FRAME_MIN_LEN, MAVLINK_MSG_ID_CANFD_FRAME_LEN, MAVLINK_MSG_ID_CANFD_FRAME_CRC);
 #endif
 }

v2.0/common/mavlink_msg_cellular_config.h

@@ -95,10 +95,10 @@ static inline uint16_t mavlink_msg_cellular_config_pack(uint8_t system_id, uint8
     packet.enable_pin = enable_pin;
     packet.roaming = roaming;
     packet.response = response;
-    mav_array_assign_char(packet.pin, pin, 16);
-    mav_array_assign_char(packet.new_pin, new_pin, 16);
-    mav_array_assign_char(packet.apn, apn, 32);
-    mav_array_assign_char(packet.puk, puk, 16);
+    mav_array_memcpy(packet.pin, pin, sizeof(char)*16);
+    mav_array_memcpy(packet.new_pin, new_pin, sizeof(char)*16);
+    mav_array_memcpy(packet.apn, apn, sizeof(char)*32);
+    mav_array_memcpy(packet.puk, puk, sizeof(char)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CELLULAR_CONFIG_LEN);
 #endif
 
@@ -195,10 +195,10 @@ static inline uint16_t mavlink_msg_cellular_config_pack_chan(uint8_t system_id,
     packet.enable_pin = enable_pin;
     packet.roaming = roaming;
     packet.response = response;
-    mav_array_assign_char(packet.pin, pin, 16);
-    mav_array_assign_char(packet.new_pin, new_pin, 16);
-    mav_array_assign_char(packet.apn, apn, 32);
-    mav_array_assign_char(packet.puk, puk, 16);
+    mav_array_memcpy(packet.pin, pin, sizeof(char)*16);
+    mav_array_memcpy(packet.new_pin, new_pin, sizeof(char)*16);
+    mav_array_memcpy(packet.apn, apn, sizeof(char)*32);
+    mav_array_memcpy(packet.puk, puk, sizeof(char)*16);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CELLULAR_CONFIG_LEN);
 #endif
 
@@ -281,10 +281,10 @@ static inline void mavlink_msg_cellular_config_send(mavlink_channel_t chan, uint
     packet.enable_pin = enable_pin;
     packet.roaming = roaming;
     packet.response = response;
-    mav_array_assign_char(packet.pin, pin, 16);
-    mav_array_assign_char(packet.new_pin, new_pin, 16);
-    mav_array_assign_char(packet.apn, apn, 32);
-    mav_array_assign_char(packet.puk, puk, 16);
+    mav_array_memcpy(packet.pin, pin, sizeof(char)*16);
+    mav_array_memcpy(packet.new_pin, new_pin, sizeof(char)*16);
+    mav_array_memcpy(packet.apn, apn, sizeof(char)*32);
+    mav_array_memcpy(packet.puk, puk, sizeof(char)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CELLULAR_CONFIG, (const char *)&packet, MAVLINK_MSG_ID_CELLULAR_CONFIG_MIN_LEN, MAVLINK_MSG_ID_CELLULAR_CONFIG_LEN, MAVLINK_MSG_ID_CELLULAR_CONFIG_CRC);
 #endif
 }
@@ -305,7 +305,7 @@ static inline void mavlink_msg_cellular_config_send_struct(mavlink_channel_t cha
 
 #if MAVLINK_MSG_ID_CELLULAR_CONFIG_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -330,10 +330,10 @@ static inline void mavlink_msg_cellular_config_send_buf(mavlink_message_t *msgbu
     packet->enable_pin = enable_pin;
     packet->roaming = roaming;
     packet->response = response;
-    mav_array_assign_char(packet->pin, pin, 16);
-    mav_array_assign_char(packet->new_pin, new_pin, 16);
-    mav_array_assign_char(packet->apn, apn, 32);
-    mav_array_assign_char(packet->puk, puk, 16);
+    mav_array_memcpy(packet->pin, pin, sizeof(char)*16);
+    mav_array_memcpy(packet->new_pin, new_pin, sizeof(char)*16);
+    mav_array_memcpy(packet->apn, apn, sizeof(char)*32);
+    mav_array_memcpy(packet->puk, puk, sizeof(char)*16);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CELLULAR_CONFIG, (const char *)packet, MAVLINK_MSG_ID_CELLULAR_CONFIG_MIN_LEN, MAVLINK_MSG_ID_CELLULAR_CONFIG_LEN, MAVLINK_MSG_ID_CELLULAR_CONFIG_CRC);
 #endif
 }

v2.0/common/mavlink_msg_cellular_status.h

@@ -295,7 +295,7 @@ static inline void mavlink_msg_cellular_status_send_struct(mavlink_channel_t cha
 
 #if MAVLINK_MSG_ID_CELLULAR_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_change_operator_control.h

@@ -71,7 +71,7 @@ static inline uint16_t mavlink_msg_change_operator_control_pack(uint8_t system_i
     packet.target_system = target_system;
     packet.control_request = control_request;
     packet.version = version;
-    mav_array_assign_char(packet.passkey, passkey, 25);
+    mav_array_memcpy(packet.passkey, passkey, sizeof(char)*25);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_LEN);
 #endif
 
@@ -147,7 +147,7 @@ static inline uint16_t mavlink_msg_change_operator_control_pack_chan(uint8_t sys
     packet.target_system = target_system;
     packet.control_request = control_request;
     packet.version = version;
-    mav_array_assign_char(packet.passkey, passkey, 25);
+    mav_array_memcpy(packet.passkey, passkey, sizeof(char)*25);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_LEN);
 #endif
 
@@ -221,7 +221,7 @@ static inline void mavlink_msg_change_operator_control_send(mavlink_channel_t ch
     packet.target_system = target_system;
     packet.control_request = control_request;
     packet.version = version;
-    mav_array_assign_char(packet.passkey, passkey, 25);
+    mav_array_memcpy(packet.passkey, passkey, sizeof(char)*25);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL, (const char *)&packet, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_MIN_LEN, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_LEN, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_CRC);
 #endif
 }
@@ -242,7 +242,7 @@ static inline void mavlink_msg_change_operator_control_send_struct(mavlink_chann
 
 #if MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -262,7 +262,7 @@ static inline void mavlink_msg_change_operator_control_send_buf(mavlink_message_
     packet->target_system = target_system;
     packet->control_request = control_request;
     packet->version = version;
-    mav_array_assign_char(packet->passkey, passkey, 25);
+    mav_array_memcpy(packet->passkey, passkey, sizeof(char)*25);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL, (const char *)packet, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_MIN_LEN, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_LEN, MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_CRC);
 #endif
 }

v2.0/common/mavlink_msg_change_operator_control_ack.h

@@ -235,7 +235,7 @@ static inline void mavlink_msg_change_operator_control_ack_send_struct(mavlink_c
 
 #if MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_collision.h

@@ -295,7 +295,7 @@ static inline void mavlink_msg_collision_send_struct(mavlink_channel_t chan, con
 
 #if MAVLINK_MSG_ID_COLLISION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_command_ack.h

@@ -280,7 +280,7 @@ static inline void mavlink_msg_command_ack_send_struct(mavlink_channel_t chan, c
 
 #if MAVLINK_MSG_ID_COMMAND_ACK_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_command_cancel.h

@@ -52,7 +52,6 @@ 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)
 {
@@ -126,7 +125,6 @@ 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)
@@ -159,7 +157,6 @@ 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);
@@ -174,7 +171,6 @@ 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);
@@ -204,7 +200,6 @@ 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
@@ -229,7 +224,6 @@ 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,13 +235,12 @@ static inline void mavlink_msg_command_cancel_send_struct(mavlink_channel_t chan
 
 #if MAVLINK_MSG_ID_COMMAND_CANCEL_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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.
  */
-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
@@ -278,7 +271,6 @@ 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);
@@ -289,7 +281,6 @@ 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);
@@ -300,7 +291,6 @@ 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);
@@ -312,7 +302,6 @@ 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

v2.0/common/mavlink_msg_command_int.h

@@ -385,7 +385,7 @@ static inline void mavlink_msg_command_int_send_struct(mavlink_channel_t chan, c
 
 #if MAVLINK_MSG_ID_COMMAND_INT_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_command_long.h

@@ -355,7 +355,7 @@ static inline void mavlink_msg_command_long_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_COMMAND_LONG_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_component_information.h

@@ -77,8 +77,8 @@ static inline uint16_t mavlink_msg_component_information_pack(uint8_t system_id,
     packet.time_boot_ms = time_boot_ms;
     packet.general_metadata_file_crc = general_metadata_file_crc;
     packet.peripherals_metadata_file_crc = peripherals_metadata_file_crc;
-    mav_array_assign_char(packet.general_metadata_uri, general_metadata_uri, 100);
-    mav_array_assign_char(packet.peripherals_metadata_uri, peripherals_metadata_uri, 100);
+    mav_array_memcpy(packet.general_metadata_uri, general_metadata_uri, sizeof(char)*100);
+    mav_array_memcpy(packet.peripherals_metadata_uri, peripherals_metadata_uri, sizeof(char)*100);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_COMPONENT_INFORMATION_LEN);
 #endif
 
@@ -159,8 +159,8 @@ static inline uint16_t mavlink_msg_component_information_pack_chan(uint8_t syste
     packet.time_boot_ms = time_boot_ms;
     packet.general_metadata_file_crc = general_metadata_file_crc;
     packet.peripherals_metadata_file_crc = peripherals_metadata_file_crc;
-    mav_array_assign_char(packet.general_metadata_uri, general_metadata_uri, 100);
-    mav_array_assign_char(packet.peripherals_metadata_uri, peripherals_metadata_uri, 100);
+    mav_array_memcpy(packet.general_metadata_uri, general_metadata_uri, sizeof(char)*100);
+    mav_array_memcpy(packet.peripherals_metadata_uri, peripherals_metadata_uri, sizeof(char)*100);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_COMPONENT_INFORMATION_LEN);
 #endif
 
@@ -236,8 +236,8 @@ static inline void mavlink_msg_component_information_send(mavlink_channel_t chan
     packet.time_boot_ms = time_boot_ms;
     packet.general_metadata_file_crc = general_metadata_file_crc;
     packet.peripherals_metadata_file_crc = peripherals_metadata_file_crc;
-    mav_array_assign_char(packet.general_metadata_uri, general_metadata_uri, 100);
-    mav_array_assign_char(packet.peripherals_metadata_uri, peripherals_metadata_uri, 100);
+    mav_array_memcpy(packet.general_metadata_uri, general_metadata_uri, sizeof(char)*100);
+    mav_array_memcpy(packet.peripherals_metadata_uri, peripherals_metadata_uri, sizeof(char)*100);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMPONENT_INFORMATION, (const char *)&packet, MAVLINK_MSG_ID_COMPONENT_INFORMATION_MIN_LEN, MAVLINK_MSG_ID_COMPONENT_INFORMATION_LEN, MAVLINK_MSG_ID_COMPONENT_INFORMATION_CRC);
 #endif
 }
@@ -258,7 +258,7 @@ static inline void mavlink_msg_component_information_send_struct(mavlink_channel
 
 #if MAVLINK_MSG_ID_COMPONENT_INFORMATION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -279,8 +279,8 @@ static inline void mavlink_msg_component_information_send_buf(mavlink_message_t
     packet->time_boot_ms = time_boot_ms;
     packet->general_metadata_file_crc = general_metadata_file_crc;
     packet->peripherals_metadata_file_crc = peripherals_metadata_file_crc;
-    mav_array_assign_char(packet->general_metadata_uri, general_metadata_uri, 100);
-    mav_array_assign_char(packet->peripherals_metadata_uri, peripherals_metadata_uri, 100);
+    mav_array_memcpy(packet->general_metadata_uri, general_metadata_uri, sizeof(char)*100);
+    mav_array_memcpy(packet->peripherals_metadata_uri, peripherals_metadata_uri, sizeof(char)*100);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMPONENT_INFORMATION, (const char *)packet, MAVLINK_MSG_ID_COMPONENT_INFORMATION_MIN_LEN, MAVLINK_MSG_ID_COMPONENT_INFORMATION_LEN, MAVLINK_MSG_ID_COMPONENT_INFORMATION_CRC);
 #endif
 }

v2.0/common/mavlink_msg_component_metadata.h

@@ -52,7 +52,6 @@ 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)
 {
@@ -66,7 +65,7 @@ static inline uint16_t mavlink_msg_component_metadata_pack(uint8_t system_id, ui
     mavlink_component_metadata_t packet;
     packet.time_boot_ms = time_boot_ms;
     packet.file_crc = file_crc;
-    mav_array_assign_char(packet.uri, uri, 100);
+    mav_array_memcpy(packet.uri, uri, sizeof(char)*100);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_COMPONENT_METADATA_LEN);
 #endif
 
@@ -122,7 +121,6 @@ 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)
@@ -137,7 +135,7 @@ static inline uint16_t mavlink_msg_component_metadata_pack_chan(uint8_t system_i
     mavlink_component_metadata_t packet;
     packet.time_boot_ms = time_boot_ms;
     packet.file_crc = file_crc;
-    mav_array_assign_char(packet.uri, uri, 100);
+    mav_array_memcpy(packet.uri, uri, sizeof(char)*100);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_COMPONENT_METADATA_LEN);
 #endif
 
@@ -153,7 +151,6 @@ 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);
@@ -168,7 +165,6 @@ 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);
@@ -198,7 +194,6 @@ 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
@@ -211,7 +206,7 @@ static inline void mavlink_msg_component_metadata_send(mavlink_channel_t chan, u
     mavlink_component_metadata_t packet;
     packet.time_boot_ms = time_boot_ms;
     packet.file_crc = file_crc;
-    mav_array_assign_char(packet.uri, uri, 100);
+    mav_array_memcpy(packet.uri, uri, sizeof(char)*100);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMPONENT_METADATA, (const char *)&packet, MAVLINK_MSG_ID_COMPONENT_METADATA_MIN_LEN, MAVLINK_MSG_ID_COMPONENT_METADATA_LEN, MAVLINK_MSG_ID_COMPONENT_METADATA_CRC);
 #endif
 }
@@ -221,7 +216,6 @@ 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,13 +227,12 @@ static inline void mavlink_msg_component_metadata_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_COMPONENT_METADATA_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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.
  */
-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
@@ -252,7 +245,7 @@ static inline void mavlink_msg_component_metadata_send_buf(mavlink_message_t *ms
     mavlink_component_metadata_t *packet = (mavlink_component_metadata_t *)msgbuf;
     packet->time_boot_ms = time_boot_ms;
     packet->file_crc = file_crc;
-    mav_array_assign_char(packet->uri, uri, 100);
+    mav_array_memcpy(packet->uri, uri, sizeof(char)*100);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMPONENT_METADATA, (const char *)packet, MAVLINK_MSG_ID_COMPONENT_METADATA_MIN_LEN, MAVLINK_MSG_ID_COMPONENT_METADATA_LEN, MAVLINK_MSG_ID_COMPONENT_METADATA_CRC);
 #endif
 }
@@ -268,7 +261,6 @@ 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);
@@ -279,7 +271,6 @@ 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);
@@ -290,7 +281,6 @@ 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);
@@ -302,7 +292,6 @@ 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

v2.0/common/mavlink_msg_control_system_state.h

@@ -149,9 +149,9 @@ static inline uint16_t mavlink_msg_control_system_state_pack(uint8_t system_id,
     packet.roll_rate = roll_rate;
     packet.pitch_rate = pitch_rate;
     packet.yaw_rate = yaw_rate;
-    mav_array_assign_float(packet.vel_variance, vel_variance, 3);
-    mav_array_assign_float(packet.pos_variance, pos_variance, 3);
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.vel_variance, vel_variance, sizeof(float)*3);
+    mav_array_memcpy(packet.pos_variance, pos_variance, sizeof(float)*3);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_LEN);
 #endif
 
@@ -303,9 +303,9 @@ static inline uint16_t mavlink_msg_control_system_state_pack_chan(uint8_t system
     packet.roll_rate = roll_rate;
     packet.pitch_rate = pitch_rate;
     packet.yaw_rate = yaw_rate;
-    mav_array_assign_float(packet.vel_variance, vel_variance, 3);
-    mav_array_assign_float(packet.pos_variance, pos_variance, 3);
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.vel_variance, vel_variance, sizeof(float)*3);
+    mav_array_memcpy(packet.pos_variance, pos_variance, sizeof(float)*3);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_LEN);
 #endif
 
@@ -416,9 +416,9 @@ static inline void mavlink_msg_control_system_state_send(mavlink_channel_t chan,
     packet.roll_rate = roll_rate;
     packet.pitch_rate = pitch_rate;
     packet.yaw_rate = yaw_rate;
-    mav_array_assign_float(packet.vel_variance, vel_variance, 3);
-    mav_array_assign_float(packet.pos_variance, pos_variance, 3);
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.vel_variance, vel_variance, sizeof(float)*3);
+    mav_array_memcpy(packet.pos_variance, pos_variance, sizeof(float)*3);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE, (const char *)&packet, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_MIN_LEN, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_LEN, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_CRC);
 #endif
 }
@@ -439,7 +439,7 @@ static inline void mavlink_msg_control_system_state_send_struct(mavlink_channel_
 
 #if MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -483,9 +483,9 @@ static inline void mavlink_msg_control_system_state_send_buf(mavlink_message_t *
     packet->roll_rate = roll_rate;
     packet->pitch_rate = pitch_rate;
     packet->yaw_rate = yaw_rate;
-    mav_array_assign_float(packet->vel_variance, vel_variance, 3);
-    mav_array_assign_float(packet->pos_variance, pos_variance, 3);
-    mav_array_assign_float(packet->q, q, 4);
+    mav_array_memcpy(packet->vel_variance, vel_variance, sizeof(float)*3);
+    mav_array_memcpy(packet->pos_variance, pos_variance, sizeof(float)*3);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE, (const char *)packet, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_MIN_LEN, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_LEN, MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_CRC);
 #endif
 }

v2.0/common/mavlink_msg_current_event_sequence.h

@@ -48,7 +48,6 @@ 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)
 {
@@ -116,7 +115,6 @@ 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)
@@ -147,7 +145,6 @@ 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);
@@ -162,7 +159,6 @@ 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);
@@ -191,7 +187,6 @@ 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
@@ -214,7 +209,6 @@ 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,13 +220,12 @@ static inline void mavlink_msg_current_event_sequence_send_struct(mavlink_channe
 
 #if MAVLINK_MSG_ID_CURRENT_EVENT_SEQUENCE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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.
  */
-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
@@ -261,7 +254,6 @@ 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);
@@ -272,7 +264,6 @@ 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);
@@ -284,7 +275,6 @@ 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

v2.0/common/mavlink_msg_data_stream.h

@@ -235,7 +235,7 @@ static inline void mavlink_msg_data_stream_send_struct(mavlink_channel_t chan, c
 
 #if MAVLINK_MSG_ID_DATA_STREAM_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_data_transmission_handshake.h

@@ -295,7 +295,7 @@ static inline void mavlink_msg_data_transmission_handshake_send_struct(mavlink_c
 
 #if MAVLINK_MSG_ID_DATA_TRANSMISSION_HANDSHAKE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_debug.h

@@ -235,7 +235,7 @@ static inline void mavlink_msg_debug_send_struct(mavlink_channel_t chan, const m
 
 #if MAVLINK_MSG_ID_DEBUG_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_debug_float_array.h

@@ -71,8 +71,8 @@ static inline uint16_t mavlink_msg_debug_float_array_pack(uint8_t system_id, uin
     mavlink_debug_float_array_t packet;
     packet.time_usec = time_usec;
     packet.array_id = array_id;
-    mav_array_assign_char(packet.name, name, 10);
-    mav_array_assign_float(packet.data, data, 58);
+    mav_array_memcpy(packet.name, name, sizeof(char)*10);
+    mav_array_memcpy(packet.data, data, sizeof(float)*58);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN);
 #endif
 
@@ -147,8 +147,8 @@ static inline uint16_t mavlink_msg_debug_float_array_pack_chan(uint8_t system_id
     mavlink_debug_float_array_t packet;
     packet.time_usec = time_usec;
     packet.array_id = array_id;
-    mav_array_assign_char(packet.name, name, 10);
-    mav_array_assign_float(packet.data, data, 58);
+    mav_array_memcpy(packet.name, name, sizeof(char)*10);
+    mav_array_memcpy(packet.data, data, sizeof(float)*58);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN);
 #endif
 
@@ -221,8 +221,8 @@ static inline void mavlink_msg_debug_float_array_send(mavlink_channel_t chan, ui
     mavlink_debug_float_array_t packet;
     packet.time_usec = time_usec;
     packet.array_id = array_id;
-    mav_array_assign_char(packet.name, name, 10);
-    mav_array_assign_float(packet.data, data, 58);
+    mav_array_memcpy(packet.name, name, sizeof(char)*10);
+    mav_array_memcpy(packet.data, data, sizeof(float)*58);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY, (const char *)&packet, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC);
 #endif
 }
@@ -243,7 +243,7 @@ static inline void mavlink_msg_debug_float_array_send_struct(mavlink_channel_t c
 
 #if MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -262,8 +262,8 @@ static inline void mavlink_msg_debug_float_array_send_buf(mavlink_message_t *msg
     mavlink_debug_float_array_t *packet = (mavlink_debug_float_array_t *)msgbuf;
     packet->time_usec = time_usec;
     packet->array_id = array_id;
-    mav_array_assign_char(packet->name, name, 10);
-    mav_array_assign_float(packet->data, data, 58);
+    mav_array_memcpy(packet->name, name, sizeof(char)*10);
+    mav_array_memcpy(packet->data, data, sizeof(float)*58);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY, (const char *)packet, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC);
 #endif
 }

v2.0/common/mavlink_msg_debug_vect.h

@@ -77,7 +77,7 @@ static inline uint16_t mavlink_msg_debug_vect_pack(uint8_t system_id, uint8_t co
     packet.x = x;
     packet.y = y;
     packet.z = z;
-    mav_array_assign_char(packet.name, name, 10);
+    mav_array_memcpy(packet.name, name, sizeof(char)*10);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DEBUG_VECT_LEN);
 #endif
 
@@ -159,7 +159,7 @@ static inline uint16_t mavlink_msg_debug_vect_pack_chan(uint8_t system_id, uint8
     packet.x = x;
     packet.y = y;
     packet.z = z;
-    mav_array_assign_char(packet.name, name, 10);
+    mav_array_memcpy(packet.name, name, sizeof(char)*10);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DEBUG_VECT_LEN);
 #endif
 
@@ -236,7 +236,7 @@ static inline void mavlink_msg_debug_vect_send(mavlink_channel_t chan, const cha
     packet.x = x;
     packet.y = y;
     packet.z = z;
-    mav_array_assign_char(packet.name, name, 10);
+    mav_array_memcpy(packet.name, name, sizeof(char)*10);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_VECT, (const char *)&packet, MAVLINK_MSG_ID_DEBUG_VECT_MIN_LEN, MAVLINK_MSG_ID_DEBUG_VECT_LEN, MAVLINK_MSG_ID_DEBUG_VECT_CRC);
 #endif
 }
@@ -257,7 +257,7 @@ static inline void mavlink_msg_debug_vect_send_struct(mavlink_channel_t chan, co
 
 #if MAVLINK_MSG_ID_DEBUG_VECT_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -279,7 +279,7 @@ static inline void mavlink_msg_debug_vect_send_buf(mavlink_message_t *msgbuf, ma
     packet->x = x;
     packet->y = y;
     packet->z = z;
-    mav_array_assign_char(packet->name, name, 10);
+    mav_array_memcpy(packet->name, name, sizeof(char)*10);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_VECT, (const char *)packet, MAVLINK_MSG_ID_DEBUG_VECT_MIN_LEN, MAVLINK_MSG_ID_DEBUG_VECT_LEN, MAVLINK_MSG_ID_DEBUG_VECT_CRC);
 #endif
 }

v2.0/common/mavlink_msg_distance_sensor.h

@@ -119,7 +119,7 @@ static inline uint16_t mavlink_msg_distance_sensor_pack(uint8_t system_id, uint8
     packet.horizontal_fov = horizontal_fov;
     packet.vertical_fov = vertical_fov;
     packet.signal_quality = signal_quality;
-    mav_array_assign_float(packet.quaternion, quaternion, 4);
+    mav_array_memcpy(packet.quaternion, quaternion, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DISTANCE_SENSOR_LEN);
 #endif
 
@@ -243,7 +243,7 @@ static inline uint16_t mavlink_msg_distance_sensor_pack_chan(uint8_t system_id,
     packet.horizontal_fov = horizontal_fov;
     packet.vertical_fov = vertical_fov;
     packet.signal_quality = signal_quality;
-    mav_array_assign_float(packet.quaternion, quaternion, 4);
+    mav_array_memcpy(packet.quaternion, quaternion, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DISTANCE_SENSOR_LEN);
 #endif
 
@@ -341,7 +341,7 @@ static inline void mavlink_msg_distance_sensor_send(mavlink_channel_t chan, uint
     packet.horizontal_fov = horizontal_fov;
     packet.vertical_fov = vertical_fov;
     packet.signal_quality = signal_quality;
-    mav_array_assign_float(packet.quaternion, quaternion, 4);
+    mav_array_memcpy(packet.quaternion, quaternion, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DISTANCE_SENSOR, (const char *)&packet, MAVLINK_MSG_ID_DISTANCE_SENSOR_MIN_LEN, MAVLINK_MSG_ID_DISTANCE_SENSOR_LEN, MAVLINK_MSG_ID_DISTANCE_SENSOR_CRC);
 #endif
 }
@@ -362,7 +362,7 @@ static inline void mavlink_msg_distance_sensor_send_struct(mavlink_channel_t cha
 
 #if MAVLINK_MSG_ID_DISTANCE_SENSOR_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -398,7 +398,7 @@ static inline void mavlink_msg_distance_sensor_send_buf(mavlink_message_t *msgbu
     packet->horizontal_fov = horizontal_fov;
     packet->vertical_fov = vertical_fov;
     packet->signal_quality = signal_quality;
-    mav_array_assign_float(packet->quaternion, quaternion, 4);
+    mav_array_memcpy(packet->quaternion, quaternion, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DISTANCE_SENSOR, (const char *)packet, MAVLINK_MSG_ID_DISTANCE_SENSOR_MIN_LEN, MAVLINK_MSG_ID_DISTANCE_SENSOR_LEN, MAVLINK_MSG_ID_DISTANCE_SENSOR_CRC);
 #endif
 }

v2.0/common/mavlink_msg_efi_status.h

@@ -475,7 +475,7 @@ static inline void mavlink_msg_efi_status_send_struct(mavlink_channel_t chan, co
 
 #if MAVLINK_MSG_ID_EFI_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_encapsulated_data.h

@@ -59,7 +59,7 @@ static inline uint16_t mavlink_msg_encapsulated_data_pack(uint8_t system_id, uin
 #else
     mavlink_encapsulated_data_t packet;
     packet.seqnr = seqnr;
-    mav_array_assign_uint8_t(packet.data, data, 253);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*253);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN);
 #endif
 
@@ -123,7 +123,7 @@ static inline uint16_t mavlink_msg_encapsulated_data_pack_chan(uint8_t system_id
 #else
     mavlink_encapsulated_data_t packet;
     packet.seqnr = seqnr;
-    mav_array_assign_uint8_t(packet.data, data, 253);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*253);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN);
 #endif
 
@@ -191,7 +191,7 @@ static inline void mavlink_msg_encapsulated_data_send(mavlink_channel_t chan, ui
 #else
     mavlink_encapsulated_data_t packet;
     packet.seqnr = seqnr;
-    mav_array_assign_uint8_t(packet.data, data, 253);
+    mav_array_memcpy(packet.data, data, sizeof(uint8_t)*253);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ENCAPSULATED_DATA, (const char *)&packet, MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC);
 #endif
 }
@@ -212,7 +212,7 @@ static inline void mavlink_msg_encapsulated_data_send_struct(mavlink_channel_t c
 
 #if MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -228,7 +228,7 @@ static inline void mavlink_msg_encapsulated_data_send_buf(mavlink_message_t *msg
 #else
     mavlink_encapsulated_data_t *packet = (mavlink_encapsulated_data_t *)msgbuf;
     packet->seqnr = seqnr;
-    mav_array_assign_uint8_t(packet->data, data, 253);
+    mav_array_memcpy(packet->data, data, sizeof(uint8_t)*253);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ENCAPSULATED_DATA, (const char *)packet, MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC);
 #endif
 }

v2.0/common/mavlink_msg_esc_info.h

@@ -78,7 +78,6 @@ 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)
 {
@@ -102,9 +101,9 @@ static inline uint16_t mavlink_msg_esc_info_pack(uint8_t system_id, uint8_t comp
     packet.count = count;
     packet.connection_type = connection_type;
     packet.info = info;
-    mav_array_assign_uint32_t(packet.error_count, error_count, 4);
-    mav_array_assign_uint16_t(packet.failure_flags, failure_flags, 4);
-    mav_array_assign_int16_t(packet.temperature, temperature, 4);
+    mav_array_memcpy(packet.error_count, error_count, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet.failure_flags, failure_flags, sizeof(uint16_t)*4);
+    mav_array_memcpy(packet.temperature, temperature, sizeof(int16_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ESC_INFO_LEN);
 #endif
 
@@ -184,7 +183,6 @@ 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)
@@ -209,9 +207,9 @@ static inline uint16_t mavlink_msg_esc_info_pack_chan(uint8_t system_id, uint8_t
     packet.count = count;
     packet.connection_type = connection_type;
     packet.info = info;
-    mav_array_assign_uint32_t(packet.error_count, error_count, 4);
-    mav_array_assign_uint16_t(packet.failure_flags, failure_flags, 4);
-    mav_array_assign_int16_t(packet.temperature, temperature, 4);
+    mav_array_memcpy(packet.error_count, error_count, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet.failure_flags, failure_flags, sizeof(uint16_t)*4);
+    mav_array_memcpy(packet.temperature, temperature, sizeof(int16_t)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ESC_INFO_LEN);
 #endif
 
@@ -227,7 +225,6 @@ 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);
@@ -242,7 +239,6 @@ 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);
@@ -278,7 +274,6 @@ 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
@@ -301,9 +296,9 @@ static inline void mavlink_msg_esc_info_send(mavlink_channel_t chan, uint8_t ind
     packet.count = count;
     packet.connection_type = connection_type;
     packet.info = info;
-    mav_array_assign_uint32_t(packet.error_count, error_count, 4);
-    mav_array_assign_uint16_t(packet.failure_flags, failure_flags, 4);
-    mav_array_assign_int16_t(packet.temperature, temperature, 4);
+    mav_array_memcpy(packet.error_count, error_count, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet.failure_flags, failure_flags, sizeof(uint16_t)*4);
+    mav_array_memcpy(packet.temperature, temperature, sizeof(int16_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ESC_INFO, (const char *)&packet, MAVLINK_MSG_ID_ESC_INFO_MIN_LEN, MAVLINK_MSG_ID_ESC_INFO_LEN, MAVLINK_MSG_ID_ESC_INFO_CRC);
 #endif
 }
@@ -313,7 +308,6 @@ 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,13 +319,12 @@ static inline void mavlink_msg_esc_info_send_struct(mavlink_channel_t chan, cons
 
 #if MAVLINK_MSG_ID_ESC_INFO_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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.
  */
-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
@@ -354,9 +347,9 @@ static inline void mavlink_msg_esc_info_send_buf(mavlink_message_t *msgbuf, mavl
     packet->count = count;
     packet->connection_type = connection_type;
     packet->info = info;
-    mav_array_assign_uint32_t(packet->error_count, error_count, 4);
-    mav_array_assign_uint16_t(packet->failure_flags, failure_flags, 4);
-    mav_array_assign_int16_t(packet->temperature, temperature, 4);
+    mav_array_memcpy(packet->error_count, error_count, sizeof(uint32_t)*4);
+    mav_array_memcpy(packet->failure_flags, failure_flags, sizeof(uint16_t)*4);
+    mav_array_memcpy(packet->temperature, temperature, sizeof(int16_t)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ESC_INFO, (const char *)packet, MAVLINK_MSG_ID_ESC_INFO_MIN_LEN, MAVLINK_MSG_ID_ESC_INFO_LEN, MAVLINK_MSG_ID_ESC_INFO_CRC);
 #endif
 }
@@ -372,7 +365,6 @@ 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);
@@ -383,7 +375,6 @@ 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);
@@ -394,7 +385,6 @@ 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);
@@ -405,7 +395,6 @@ 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);
@@ -416,7 +405,6 @@ 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);
@@ -427,7 +415,6 @@ 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);
@@ -438,7 +425,6 @@ 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);
@@ -449,7 +435,6 @@ 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);
@@ -460,7 +445,6 @@ 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);
@@ -472,7 +456,6 @@ 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

v2.0/common/mavlink_msg_esc_status.h

@@ -62,7 +62,6 @@ 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)
 {
@@ -78,9 +77,9 @@ static inline uint16_t mavlink_msg_esc_status_pack(uint8_t system_id, uint8_t co
     mavlink_esc_status_t packet;
     packet.time_usec = time_usec;
     packet.index = index;
-    mav_array_assign_int32_t(packet.rpm, rpm, 4);
-    mav_array_assign_float(packet.voltage, voltage, 4);
-    mav_array_assign_float(packet.current, current, 4);
+    mav_array_memcpy(packet.rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet.voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet.current, current, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ESC_STATUS_LEN);
 #endif
 
@@ -144,7 +143,6 @@ 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)
@@ -161,9 +159,9 @@ static inline uint16_t mavlink_msg_esc_status_pack_chan(uint8_t system_id, uint8
     mavlink_esc_status_t packet;
     packet.time_usec = time_usec;
     packet.index = index;
-    mav_array_assign_int32_t(packet.rpm, rpm, 4);
-    mav_array_assign_float(packet.voltage, voltage, 4);
-    mav_array_assign_float(packet.current, current, 4);
+    mav_array_memcpy(packet.rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet.voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet.current, current, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ESC_STATUS_LEN);
 #endif
 
@@ -179,7 +177,6 @@ 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);
@@ -194,7 +191,6 @@ 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);
@@ -226,7 +222,6 @@ 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
@@ -241,9 +236,9 @@ static inline void mavlink_msg_esc_status_send(mavlink_channel_t chan, uint8_t i
     mavlink_esc_status_t packet;
     packet.time_usec = time_usec;
     packet.index = index;
-    mav_array_assign_int32_t(packet.rpm, rpm, 4);
-    mav_array_assign_float(packet.voltage, voltage, 4);
-    mav_array_assign_float(packet.current, current, 4);
+    mav_array_memcpy(packet.rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet.voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet.current, current, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ESC_STATUS, (const char *)&packet, MAVLINK_MSG_ID_ESC_STATUS_MIN_LEN, MAVLINK_MSG_ID_ESC_STATUS_LEN, MAVLINK_MSG_ID_ESC_STATUS_CRC);
 #endif
 }
@@ -253,7 +248,6 @@ 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,13 +259,12 @@ static inline void mavlink_msg_esc_status_send_struct(mavlink_channel_t chan, co
 
 #if MAVLINK_MSG_ID_ESC_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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.
  */
-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
@@ -286,9 +279,9 @@ static inline void mavlink_msg_esc_status_send_buf(mavlink_message_t *msgbuf, ma
     mavlink_esc_status_t *packet = (mavlink_esc_status_t *)msgbuf;
     packet->time_usec = time_usec;
     packet->index = index;
-    mav_array_assign_int32_t(packet->rpm, rpm, 4);
-    mav_array_assign_float(packet->voltage, voltage, 4);
-    mav_array_assign_float(packet->current, current, 4);
+    mav_array_memcpy(packet->rpm, rpm, sizeof(int32_t)*4);
+    mav_array_memcpy(packet->voltage, voltage, sizeof(float)*4);
+    mav_array_memcpy(packet->current, current, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ESC_STATUS, (const char *)packet, MAVLINK_MSG_ID_ESC_STATUS_MIN_LEN, MAVLINK_MSG_ID_ESC_STATUS_LEN, MAVLINK_MSG_ID_ESC_STATUS_CRC);
 #endif
 }
@@ -304,7 +297,6 @@ 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);
@@ -315,7 +307,6 @@ 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);
@@ -326,7 +317,6 @@ 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);
@@ -337,7 +327,6 @@ 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);
@@ -348,7 +337,6 @@ 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);
@@ -360,7 +348,6 @@ 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

v2.0/common/mavlink_msg_estimator_status.h

@@ -340,7 +340,7 @@ static inline void mavlink_msg_estimator_status_send_struct(mavlink_channel_t ch
 
 #if MAVLINK_MSG_ID_ESTIMATOR_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_event.h

@@ -68,7 +68,6 @@ 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)
 {
@@ -90,7 +89,7 @@ static inline uint16_t mavlink_msg_event_pack(uint8_t system_id, uint8_t compone
     packet.destination_component = destination_component;
     packet.destination_system = destination_system;
     packet.log_levels = log_levels;
-    mav_array_assign_uint8_t(packet.arguments, arguments, 40);
+    mav_array_memcpy(packet.arguments, arguments, sizeof(uint8_t)*40);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_EVENT_LEN);
 #endif
 
@@ -162,7 +161,6 @@ 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)
@@ -185,7 +183,7 @@ static inline uint16_t mavlink_msg_event_pack_chan(uint8_t system_id, uint8_t co
     packet.destination_component = destination_component;
     packet.destination_system = destination_system;
     packet.log_levels = log_levels;
-    mav_array_assign_uint8_t(packet.arguments, arguments, 40);
+    mav_array_memcpy(packet.arguments, arguments, sizeof(uint8_t)*40);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_EVENT_LEN);
 #endif
 
@@ -201,7 +199,6 @@ 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);
@@ -216,7 +213,6 @@ 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);
@@ -250,7 +246,6 @@ 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
@@ -271,7 +266,7 @@ static inline void mavlink_msg_event_send(mavlink_channel_t chan, uint8_t destin
     packet.destination_component = destination_component;
     packet.destination_system = destination_system;
     packet.log_levels = log_levels;
-    mav_array_assign_uint8_t(packet.arguments, arguments, 40);
+    mav_array_memcpy(packet.arguments, arguments, sizeof(uint8_t)*40);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_EVENT, (const char *)&packet, MAVLINK_MSG_ID_EVENT_MIN_LEN, MAVLINK_MSG_ID_EVENT_LEN, MAVLINK_MSG_ID_EVENT_CRC);
 #endif
 }
@@ -281,7 +276,6 @@ 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,13 +287,12 @@ static inline void mavlink_msg_event_send_struct(mavlink_channel_t chan, const m
 
 #if MAVLINK_MSG_ID_EVENT_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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.
  */
-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
@@ -320,7 +313,7 @@ static inline void mavlink_msg_event_send_buf(mavlink_message_t *msgbuf, mavlink
     packet->destination_component = destination_component;
     packet->destination_system = destination_system;
     packet->log_levels = log_levels;
-    mav_array_assign_uint8_t(packet->arguments, arguments, 40);
+    mav_array_memcpy(packet->arguments, arguments, sizeof(uint8_t)*40);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_EVENT, (const char *)packet, MAVLINK_MSG_ID_EVENT_MIN_LEN, MAVLINK_MSG_ID_EVENT_LEN, MAVLINK_MSG_ID_EVENT_CRC);
 #endif
 }
@@ -336,7 +329,6 @@ 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);
@@ -347,7 +339,6 @@ 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);
@@ -358,7 +349,6 @@ 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);
@@ -369,7 +359,6 @@ 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);
@@ -380,7 +369,6 @@ 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);
@@ -391,7 +379,6 @@ 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);
@@ -402,7 +389,6 @@ 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);
@@ -414,7 +400,6 @@ 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

v2.0/common/mavlink_msg_extended_sys_state.h

@@ -220,7 +220,7 @@ static inline void mavlink_msg_extended_sys_state_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_EXTENDED_SYS_STATE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_fence_status.h

@@ -265,7 +265,7 @@ static inline void mavlink_msg_fence_status_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_FENCE_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_file_transfer_protocol.h

@@ -71,7 +71,7 @@ static inline uint16_t mavlink_msg_file_transfer_protocol_pack(uint8_t system_id
     packet.target_network = target_network;
     packet.target_system = target_system;
     packet.target_component = target_component;
-    mav_array_assign_uint8_t(packet.payload, payload, 251);
+    mav_array_memcpy(packet.payload, payload, sizeof(uint8_t)*251);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_LEN);
 #endif
 
@@ -147,7 +147,7 @@ static inline uint16_t mavlink_msg_file_transfer_protocol_pack_chan(uint8_t syst
     packet.target_network = target_network;
     packet.target_system = target_system;
     packet.target_component = target_component;
-    mav_array_assign_uint8_t(packet.payload, payload, 251);
+    mav_array_memcpy(packet.payload, payload, sizeof(uint8_t)*251);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_LEN);
 #endif
 
@@ -221,7 +221,7 @@ static inline void mavlink_msg_file_transfer_protocol_send(mavlink_channel_t cha
     packet.target_network = target_network;
     packet.target_system = target_system;
     packet.target_component = target_component;
-    mav_array_assign_uint8_t(packet.payload, payload, 251);
+    mav_array_memcpy(packet.payload, payload, sizeof(uint8_t)*251);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL, (const char *)&packet, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_MIN_LEN, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_LEN, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_CRC);
 #endif
 }
@@ -242,7 +242,7 @@ static inline void mavlink_msg_file_transfer_protocol_send_struct(mavlink_channe
 
 #if MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -262,7 +262,7 @@ static inline void mavlink_msg_file_transfer_protocol_send_buf(mavlink_message_t
     packet->target_network = target_network;
     packet->target_system = target_system;
     packet->target_component = target_component;
-    mav_array_assign_uint8_t(packet->payload, payload, 251);
+    mav_array_memcpy(packet->payload, payload, sizeof(uint8_t)*251);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL, (const char *)packet, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_MIN_LEN, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_LEN, MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_CRC);
 #endif
 }

v2.0/common/mavlink_msg_flight_information.h

@@ -265,7 +265,7 @@ static inline void mavlink_msg_flight_information_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_FLIGHT_INFORMATION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_follow_target.h

@@ -113,11 +113,11 @@ static inline uint16_t mavlink_msg_follow_target_pack(uint8_t system_id, uint8_t
     packet.lon = lon;
     packet.alt = alt;
     packet.est_capabilities = est_capabilities;
-    mav_array_assign_float(packet.vel, vel, 3);
-    mav_array_assign_float(packet.acc, acc, 3);
-    mav_array_assign_float(packet.attitude_q, attitude_q, 4);
-    mav_array_assign_float(packet.rates, rates, 3);
-    mav_array_assign_float(packet.position_cov, position_cov, 3);
+    mav_array_memcpy(packet.vel, vel, sizeof(float)*3);
+    mav_array_memcpy(packet.acc, acc, sizeof(float)*3);
+    mav_array_memcpy(packet.attitude_q, attitude_q, sizeof(float)*4);
+    mav_array_memcpy(packet.rates, rates, sizeof(float)*3);
+    mav_array_memcpy(packet.position_cov, position_cov, sizeof(float)*3);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_FOLLOW_TARGET_LEN);
 #endif
 
@@ -231,11 +231,11 @@ static inline uint16_t mavlink_msg_follow_target_pack_chan(uint8_t system_id, ui
     packet.lon = lon;
     packet.alt = alt;
     packet.est_capabilities = est_capabilities;
-    mav_array_assign_float(packet.vel, vel, 3);
-    mav_array_assign_float(packet.acc, acc, 3);
-    mav_array_assign_float(packet.attitude_q, attitude_q, 4);
-    mav_array_assign_float(packet.rates, rates, 3);
-    mav_array_assign_float(packet.position_cov, position_cov, 3);
+    mav_array_memcpy(packet.vel, vel, sizeof(float)*3);
+    mav_array_memcpy(packet.acc, acc, sizeof(float)*3);
+    mav_array_memcpy(packet.attitude_q, attitude_q, sizeof(float)*4);
+    mav_array_memcpy(packet.rates, rates, sizeof(float)*3);
+    mav_array_memcpy(packet.position_cov, position_cov, sizeof(float)*3);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_FOLLOW_TARGET_LEN);
 #endif
 
@@ -326,11 +326,11 @@ static inline void mavlink_msg_follow_target_send(mavlink_channel_t chan, uint64
     packet.lon = lon;
     packet.alt = alt;
     packet.est_capabilities = est_capabilities;
-    mav_array_assign_float(packet.vel, vel, 3);
-    mav_array_assign_float(packet.acc, acc, 3);
-    mav_array_assign_float(packet.attitude_q, attitude_q, 4);
-    mav_array_assign_float(packet.rates, rates, 3);
-    mav_array_assign_float(packet.position_cov, position_cov, 3);
+    mav_array_memcpy(packet.vel, vel, sizeof(float)*3);
+    mav_array_memcpy(packet.acc, acc, sizeof(float)*3);
+    mav_array_memcpy(packet.attitude_q, attitude_q, sizeof(float)*4);
+    mav_array_memcpy(packet.rates, rates, sizeof(float)*3);
+    mav_array_memcpy(packet.position_cov, position_cov, sizeof(float)*3);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FOLLOW_TARGET, (const char *)&packet, MAVLINK_MSG_ID_FOLLOW_TARGET_MIN_LEN, MAVLINK_MSG_ID_FOLLOW_TARGET_LEN, MAVLINK_MSG_ID_FOLLOW_TARGET_CRC);
 #endif
 }
@@ -351,7 +351,7 @@ static inline void mavlink_msg_follow_target_send_struct(mavlink_channel_t chan,
 
 #if MAVLINK_MSG_ID_FOLLOW_TARGET_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -381,11 +381,11 @@ static inline void mavlink_msg_follow_target_send_buf(mavlink_message_t *msgbuf,
     packet->lon = lon;
     packet->alt = alt;
     packet->est_capabilities = est_capabilities;
-    mav_array_assign_float(packet->vel, vel, 3);
-    mav_array_assign_float(packet->acc, acc, 3);
-    mav_array_assign_float(packet->attitude_q, attitude_q, 4);
-    mav_array_assign_float(packet->rates, rates, 3);
-    mav_array_assign_float(packet->position_cov, position_cov, 3);
+    mav_array_memcpy(packet->vel, vel, sizeof(float)*3);
+    mav_array_memcpy(packet->acc, acc, sizeof(float)*3);
+    mav_array_memcpy(packet->attitude_q, attitude_q, sizeof(float)*4);
+    mav_array_memcpy(packet->rates, rates, sizeof(float)*3);
+    mav_array_memcpy(packet->position_cov, position_cov, sizeof(float)*3);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_FOLLOW_TARGET, (const char *)packet, MAVLINK_MSG_ID_FOLLOW_TARGET_MIN_LEN, MAVLINK_MSG_ID_FOLLOW_TARGET_LEN, MAVLINK_MSG_ID_FOLLOW_TARGET_CRC);
 #endif
 }

v2.0/common/mavlink_msg_generator_status.h

@@ -355,7 +355,7 @@ static inline void mavlink_msg_generator_status_send_struct(mavlink_channel_t ch
 
 #if MAVLINK_MSG_ID_GENERATOR_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_gimbal_device_attitude_status.h

@@ -119,7 +119,7 @@ static inline uint16_t mavlink_msg_gimbal_device_attitude_status_pack(uint8_t sy
     packet.delta_yaw = delta_yaw;
     packet.delta_yaw_velocity = delta_yaw_velocity;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_LEN);
 #endif
 
@@ -243,7 +243,7 @@ static inline uint16_t mavlink_msg_gimbal_device_attitude_status_pack_chan(uint8
     packet.delta_yaw = delta_yaw;
     packet.delta_yaw_velocity = delta_yaw_velocity;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_LEN);
 #endif
 
@@ -341,7 +341,7 @@ static inline void mavlink_msg_gimbal_device_attitude_status_send(mavlink_channe
     packet.delta_yaw = delta_yaw;
     packet.delta_yaw_velocity = delta_yaw_velocity;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS, (const char *)&packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_CRC);
 #endif
 }
@@ -362,7 +362,7 @@ static inline void mavlink_msg_gimbal_device_attitude_status_send_struct(mavlink
 
 #if MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -398,7 +398,7 @@ static inline void mavlink_msg_gimbal_device_attitude_status_send_buf(mavlink_me
     packet->delta_yaw = delta_yaw;
     packet->delta_yaw_velocity = delta_yaw_velocity;
     packet->gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet->q, q, 4);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS, (const char *)packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_ATTITUDE_STATUS_CRC);
 #endif
 }

v2.0/common/mavlink_msg_gimbal_device_information.h

@@ -143,9 +143,9 @@ static inline uint16_t mavlink_msg_gimbal_device_information_pack(uint8_t system
     packet.cap_flags = cap_flags;
     packet.custom_cap_flags = custom_cap_flags;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_char(packet.vendor_name, vendor_name, 32);
-    mav_array_assign_char(packet.model_name, model_name, 32);
-    mav_array_assign_char(packet.custom_name, custom_name, 32);
+    mav_array_memcpy(packet.vendor_name, vendor_name, sizeof(char)*32);
+    mav_array_memcpy(packet.model_name, model_name, sizeof(char)*32);
+    mav_array_memcpy(packet.custom_name, custom_name, sizeof(char)*32);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_LEN);
 #endif
 
@@ -291,9 +291,9 @@ static inline uint16_t mavlink_msg_gimbal_device_information_pack_chan(uint8_t s
     packet.cap_flags = cap_flags;
     packet.custom_cap_flags = custom_cap_flags;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_char(packet.vendor_name, vendor_name, 32);
-    mav_array_assign_char(packet.model_name, model_name, 32);
-    mav_array_assign_char(packet.custom_name, custom_name, 32);
+    mav_array_memcpy(packet.vendor_name, vendor_name, sizeof(char)*32);
+    mav_array_memcpy(packet.model_name, model_name, sizeof(char)*32);
+    mav_array_memcpy(packet.custom_name, custom_name, sizeof(char)*32);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_LEN);
 #endif
 
@@ -401,9 +401,9 @@ static inline void mavlink_msg_gimbal_device_information_send(mavlink_channel_t
     packet.cap_flags = cap_flags;
     packet.custom_cap_flags = custom_cap_flags;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_char(packet.vendor_name, vendor_name, 32);
-    mav_array_assign_char(packet.model_name, model_name, 32);
-    mav_array_assign_char(packet.custom_name, custom_name, 32);
+    mav_array_memcpy(packet.vendor_name, vendor_name, sizeof(char)*32);
+    mav_array_memcpy(packet.model_name, model_name, sizeof(char)*32);
+    mav_array_memcpy(packet.custom_name, custom_name, sizeof(char)*32);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION, (const char *)&packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_CRC);
 #endif
 }
@@ -424,7 +424,7 @@ static inline void mavlink_msg_gimbal_device_information_send_struct(mavlink_cha
 
 #if MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -466,9 +466,9 @@ static inline void mavlink_msg_gimbal_device_information_send_buf(mavlink_messag
     packet->cap_flags = cap_flags;
     packet->custom_cap_flags = custom_cap_flags;
     packet->gimbal_device_id = gimbal_device_id;
-    mav_array_assign_char(packet->vendor_name, vendor_name, 32);
-    mav_array_assign_char(packet->model_name, model_name, 32);
-    mav_array_assign_char(packet->custom_name, custom_name, 32);
+    mav_array_memcpy(packet->vendor_name, vendor_name, sizeof(char)*32);
+    mav_array_memcpy(packet->model_name, model_name, sizeof(char)*32);
+    mav_array_memcpy(packet->custom_name, custom_name, sizeof(char)*32);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION, (const char *)packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_INFORMATION_CRC);
 #endif
 }

v2.0/common/mavlink_msg_gimbal_device_set_attitude.h

@@ -89,7 +89,7 @@ static inline uint16_t mavlink_msg_gimbal_device_set_attitude_pack(uint8_t syste
     packet.flags = flags;
     packet.target_system = target_system;
     packet.target_component = target_component;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_LEN);
 #endif
 
@@ -183,7 +183,7 @@ static inline uint16_t mavlink_msg_gimbal_device_set_attitude_pack_chan(uint8_t
     packet.flags = flags;
     packet.target_system = target_system;
     packet.target_component = target_component;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_LEN);
 #endif
 
@@ -266,7 +266,7 @@ static inline void mavlink_msg_gimbal_device_set_attitude_send(mavlink_channel_t
     packet.flags = flags;
     packet.target_system = target_system;
     packet.target_component = target_component;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE, (const char *)&packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_CRC);
 #endif
 }
@@ -287,7 +287,7 @@ static inline void mavlink_msg_gimbal_device_set_attitude_send_struct(mavlink_ch
 
 #if MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -313,7 +313,7 @@ static inline void mavlink_msg_gimbal_device_set_attitude_send_buf(mavlink_messa
     packet->flags = flags;
     packet->target_system = target_system;
     packet->target_component = target_component;
-    mav_array_assign_float(packet->q, q, 4);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE, (const char *)packet, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_LEN, MAVLINK_MSG_ID_GIMBAL_DEVICE_SET_ATTITUDE_CRC);
 #endif
 }

v2.0/common/mavlink_msg_gimbal_manager_information.h

@@ -325,7 +325,7 @@ static inline void mavlink_msg_gimbal_manager_information_send_struct(mavlink_ch
 
 #if MAVLINK_MSG_ID_GIMBAL_MANAGER_INFORMATION_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_gimbal_manager_set_attitude.h

@@ -95,7 +95,7 @@ static inline uint16_t mavlink_msg_gimbal_manager_set_attitude_pack(uint8_t syst
     packet.target_system = target_system;
     packet.target_component = target_component;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_LEN);
 #endif
 
@@ -195,7 +195,7 @@ static inline uint16_t mavlink_msg_gimbal_manager_set_attitude_pack_chan(uint8_t
     packet.target_system = target_system;
     packet.target_component = target_component;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_LEN);
 #endif
 
@@ -281,7 +281,7 @@ static inline void mavlink_msg_gimbal_manager_set_attitude_send(mavlink_channel_
     packet.target_system = target_system;
     packet.target_component = target_component;
     packet.gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet.q, q, 4);
+    mav_array_memcpy(packet.q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE, (const char *)&packet, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_LEN, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_CRC);
 #endif
 }
@@ -302,7 +302,7 @@ static inline void mavlink_msg_gimbal_manager_set_attitude_send_struct(mavlink_c
 
 #if MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -330,7 +330,7 @@ static inline void mavlink_msg_gimbal_manager_set_attitude_send_buf(mavlink_mess
     packet->target_system = target_system;
     packet->target_component = target_component;
     packet->gimbal_device_id = gimbal_device_id;
-    mav_array_assign_float(packet->q, q, 4);
+    mav_array_memcpy(packet->q, q, sizeof(float)*4);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE, (const char *)packet, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_MIN_LEN, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_LEN, MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_ATTITUDE_CRC);
 #endif
 }

v2.0/common/mavlink_msg_gimbal_manager_set_manual_control.h

@@ -310,7 +310,7 @@ static inline void mavlink_msg_gimbal_manager_set_manual_control_send_struct(mav
 
 #if MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_MANUAL_CONTROL_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_gimbal_manager_set_pitchyaw.h

@@ -310,7 +310,7 @@ static inline void mavlink_msg_gimbal_manager_set_pitchyaw_send_struct(mavlink_c
 
 #if MAVLINK_MSG_ID_GIMBAL_MANAGER_SET_PITCHYAW_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_gimbal_manager_status.h

@@ -295,7 +295,7 @@ static inline void mavlink_msg_gimbal_manager_status_send_struct(mavlink_channel
 
 #if MAVLINK_MSG_ID_GIMBAL_MANAGER_STATUS_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_global_position_int.h

@@ -325,7 +325,7 @@ static inline void mavlink_msg_global_position_int_send_struct(mavlink_channel_t
 
 #if MAVLINK_MSG_ID_GLOBAL_POSITION_INT_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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

v2.0/common/mavlink_msg_global_position_int_cov.h

@@ -107,7 +107,7 @@ static inline uint16_t mavlink_msg_global_position_int_cov_pack(uint8_t system_i
     packet.vy = vy;
     packet.vz = vz;
     packet.estimator_type = estimator_type;
-    mav_array_assign_float(packet.covariance, covariance, 36);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*36);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_LEN);
 #endif
 
@@ -219,7 +219,7 @@ static inline uint16_t mavlink_msg_global_position_int_cov_pack_chan(uint8_t sys
     packet.vy = vy;
     packet.vz = vz;
     packet.estimator_type = estimator_type;
-    mav_array_assign_float(packet.covariance, covariance, 36);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*36);
         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_LEN);
 #endif
 
@@ -311,7 +311,7 @@ static inline void mavlink_msg_global_position_int_cov_send(mavlink_channel_t ch
     packet.vy = vy;
     packet.vz = vz;
     packet.estimator_type = estimator_type;
-    mav_array_assign_float(packet.covariance, covariance, 36);
+    mav_array_memcpy(packet.covariance, covariance, sizeof(float)*36);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV, (const char *)&packet, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_MIN_LEN, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_LEN, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_CRC);
 #endif
 }
@@ -332,7 +332,7 @@ static inline void mavlink_msg_global_position_int_cov_send_struct(mavlink_chann
 
 #if MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 /*
-  This variant of _send() can be used to save stack space by reusing
+  This variant of _send() can be used to save stack space by re-using
   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
@@ -364,7 +364,7 @@ static inline void mavlink_msg_global_position_int_cov_send_buf(mavlink_message_
     packet->vy = vy;
     packet->vz = vz;
     packet->estimator_type = estimator_type;
-    mav_array_assign_float(packet->covariance, covariance, 36);
+    mav_array_memcpy(packet->covariance, covariance, sizeof(float)*36);
     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV, (const char *)packet, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_MIN_LEN, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_LEN, MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_CRC);
 #endif
 }