lib/main/MAVLink/common/mavlink_msg_encapsulated_data.h

   1 #pragma once
   2 // MESSAGE ENCAPSULATED_DATA PACKING
   3
   4 #define MAVLINK_MSG_ID_ENCAPSULATED_DATA 131
   5
   6
   7 typedef struct __mavlink_encapsulated_data_t {
   8  uint16_t seqnr; /*<  sequence number (starting with 0 on every transmission)*/
   9  uint8_t data[253]; /*<  image data bytes*/
  10 } mavlink_encapsulated_data_t;
  11
  12 #define MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN 255
  13 #define MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN 255
  14 #define MAVLINK_MSG_ID_131_LEN 255
  15 #define MAVLINK_MSG_ID_131_MIN_LEN 255
  16
  17 #define MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC 223
  18 #define MAVLINK_MSG_ID_131_CRC 223
  19
  20 #define MAVLINK_MSG_ENCAPSULATED_DATA_FIELD_DATA_LEN 253
  21
  22 #if MAVLINK_COMMAND_24BIT
  23 #define MAVLINK_MESSAGE_INFO_ENCAPSULATED_DATA { \
  24     131, \
  25     "ENCAPSULATED_DATA", \
  26     2, \
  27     {  { "seqnr", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_encapsulated_data_t, seqnr) }, \
  28          { "data", NULL, MAVLINK_TYPE_UINT8_T, 253, 2, offsetof(mavlink_encapsulated_data_t, data) }, \
  29          } \
  30 }
  31 #else
  32 #define MAVLINK_MESSAGE_INFO_ENCAPSULATED_DATA { \
  33     "ENCAPSULATED_DATA", \
  34     2, \
  35     {  { "seqnr", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_encapsulated_data_t, seqnr) }, \
  36          { "data", NULL, MAVLINK_TYPE_UINT8_T, 253, 2, offsetof(mavlink_encapsulated_data_t, data) }, \
  37          } \
  38 }
  39 #endif
  40
  41 /**
  42  * @brief Pack a encapsulated_data message
  43  * @param system_id ID of this system
  44  * @param component_id ID of this component (e.g. 200 for IMU)
  45  * @param msg The MAVLink message to compress the data into
  46  *
  47  * @param seqnr  sequence number (starting with 0 on every transmission)
  48  * @param data  image data bytes
  49  * @return length of the message in bytes (excluding serial stream start sign)
  50  */
  51 static inline uint16_t mavlink_msg_encapsulated_data_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
  52                                uint16_t seqnr, const uint8_t *data)
  53 {
  54 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  55     char buf[MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN];
  56     _mav_put_uint16_t(buf, 0, seqnr);
  57     _mav_put_uint8_t_array(buf, 2, data, 253);
  58         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN);
  59 #else
  60     mavlink_encapsulated_data_t packet;
  61     packet.seqnr = seqnr;
  62     mav_array_memcpy(packet.data, data, sizeof(uint8_t)*253);
  63         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN);
  64 #endif
  65
  66     msg->msgid = MAVLINK_MSG_ID_ENCAPSULATED_DATA;
  67     return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC);
  68 }
  69
  70 /**
  71  * @brief Pack a encapsulated_data message on a channel
  72  * @param system_id ID of this system
  73  * @param component_id ID of this component (e.g. 200 for IMU)
  74  * @param chan The MAVLink channel this message will be sent over
  75  * @param msg The MAVLink message to compress the data into
  76  * @param seqnr  sequence number (starting with 0 on every transmission)
  77  * @param data  image data bytes
  78  * @return length of the message in bytes (excluding serial stream start sign)
  79  */
  80 static inline uint16_t mavlink_msg_encapsulated_data_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
  81                                mavlink_message_t* msg,
  82                                    uint16_t seqnr,const uint8_t *data)
  83 {
  84 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  85     char buf[MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN];
  86     _mav_put_uint16_t(buf, 0, seqnr);
  87     _mav_put_uint8_t_array(buf, 2, data, 253);
  88         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN);
  89 #else
  90     mavlink_encapsulated_data_t packet;
  91     packet.seqnr = seqnr;
  92     mav_array_memcpy(packet.data, data, sizeof(uint8_t)*253);
  93         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN);
  94 #endif
  95
  96     msg->msgid = MAVLINK_MSG_ID_ENCAPSULATED_DATA;
  97     return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC);
  98 }
  99
 100 /**
 101  * @brief Encode a encapsulated_data struct
 102  *
 103  * @param system_id ID of this system
 104  * @param component_id ID of this component (e.g. 200 for IMU)
 105  * @param msg The MAVLink message to compress the data into
 106  * @param encapsulated_data C-struct to read the message contents from
 107  */
 108 static inline uint16_t mavlink_msg_encapsulated_data_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_encapsulated_data_t* encapsulated_data)
 109 {
 110     return mavlink_msg_encapsulated_data_pack(system_id, component_id, msg, encapsulated_data->seqnr, encapsulated_data->data);
 111 }
 112
 113 /**
 114  * @brief Encode a encapsulated_data struct on a channel
 115  *
 116  * @param system_id ID of this system
 117  * @param component_id ID of this component (e.g. 200 for IMU)
 118  * @param chan The MAVLink channel this message will be sent over
 119  * @param msg The MAVLink message to compress the data into
 120  * @param encapsulated_data C-struct to read the message contents from
 121  */
 122 static inline uint16_t mavlink_msg_encapsulated_data_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_encapsulated_data_t* encapsulated_data)
 123 {
 124     return mavlink_msg_encapsulated_data_pack_chan(system_id, component_id, chan, msg, encapsulated_data->seqnr, encapsulated_data->data);
 125 }
 126
 127 /**
 128  * @brief Send a encapsulated_data message
 129  * @param chan MAVLink channel to send the message
 130  *
 131  * @param seqnr  sequence number (starting with 0 on every transmission)
 132  * @param data  image data bytes
 133  */
 134 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 135
 136 static inline void mavlink_msg_encapsulated_data_send(mavlink_channel_t chan, uint16_t seqnr, const uint8_t *data)
 137 {
 138 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 139     char buf[MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN];
 140     _mav_put_uint16_t(buf, 0, seqnr);
 141     _mav_put_uint8_t_array(buf, 2, data, 253);
 142     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ENCAPSULATED_DATA, buf, MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC);
 143 #else
 144     mavlink_encapsulated_data_t packet;
 145     packet.seqnr = seqnr;
 146     mav_array_memcpy(packet.data, data, sizeof(uint8_t)*253);
 147     _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);
 148 #endif
 149 }
 150
 151 /**
 152  * @brief Send a encapsulated_data message
 153  * @param chan MAVLink channel to send the message
 154  * @param struct The MAVLink struct to serialize
 155  */
 156 static inline void mavlink_msg_encapsulated_data_send_struct(mavlink_channel_t chan, const mavlink_encapsulated_data_t* encapsulated_data)
 157 {
 158 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 159     mavlink_msg_encapsulated_data_send(chan, encapsulated_data->seqnr, encapsulated_data->data);
 160 #else
 161     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ENCAPSULATED_DATA, (const char *)encapsulated_data, MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC);
 162 #endif
 163 }
 164
 165 #if MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 166 /*
 167   This varient of _send() can be used to save stack space by re-using
 168   memory from the receive buffer.  The caller provides a
 169   mavlink_message_t which is the size of a full mavlink message. This
 170   is usually the receive buffer for the channel, and allows a reply to an
 171   incoming message with minimum stack space usage.
 172  */
 173 static inline void mavlink_msg_encapsulated_data_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint16_t seqnr, const uint8_t *data)
 174 {
 175 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 176     char *buf = (char *)msgbuf;
 177     _mav_put_uint16_t(buf, 0, seqnr);
 178     _mav_put_uint8_t_array(buf, 2, data, 253);
 179     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_ENCAPSULATED_DATA, buf, MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN, MAVLINK_MSG_ID_ENCAPSULATED_DATA_CRC);
 180 #else
 181     mavlink_encapsulated_data_t *packet = (mavlink_encapsulated_data_t *)msgbuf;
 182     packet->seqnr = seqnr;
 183     mav_array_memcpy(packet->data, data, sizeof(uint8_t)*253);
 184     _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);
 185 #endif
 186 }
 187 #endif
 188
 189 #endif
 190
 191 // MESSAGE ENCAPSULATED_DATA UNPACKING
 192
 193
 194 /**
 195  * @brief Get field seqnr from encapsulated_data message
 196  *
 197  * @return  sequence number (starting with 0 on every transmission)
 198  */
 199 static inline uint16_t mavlink_msg_encapsulated_data_get_seqnr(const mavlink_message_t* msg)
 200 {
 201     return _MAV_RETURN_uint16_t(msg,  0);
 202 }
 203
 204 /**
 205  * @brief Get field data from encapsulated_data message
 206  *
 207  * @return  image data bytes
 208  */
 209 static inline uint16_t mavlink_msg_encapsulated_data_get_data(const mavlink_message_t* msg, uint8_t *data)
 210 {
 211     return _MAV_RETURN_uint8_t_array(msg, data, 253,  2);
 212 }
 213
 214 /**
 215  * @brief Decode a encapsulated_data message into a struct
 216  *
 217  * @param msg The message to decode
 218  * @param encapsulated_data C-struct to decode the message contents into
 219  */
 220 static inline void mavlink_msg_encapsulated_data_decode(const mavlink_message_t* msg, mavlink_encapsulated_data_t* encapsulated_data)
 221 {
 222 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 223     encapsulated_data->seqnr = mavlink_msg_encapsulated_data_get_seqnr(msg);
 224     mavlink_msg_encapsulated_data_get_data(msg, encapsulated_data->data);
 225 #else
 226         uint8_t len = msg->len < MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN? msg->len : MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN;
 227         memset(encapsulated_data, 0, MAVLINK_MSG_ID_ENCAPSULATED_DATA_LEN);
 228     memcpy(encapsulated_data, _MAV_PAYLOAD(msg), len);
 229 #endif
 230 }