lib/main/MAVLink/common/mavlink_msg_open_drone_id_basic_id.h

   1 #pragma once
   2 // MESSAGE OPEN_DRONE_ID_BASIC_ID PACKING
   3
   4 #define MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID 12900
   5
   6
   7 typedef struct __mavlink_open_drone_id_basic_id_t {
   8  uint8_t target_system; /*<  System ID (0 for broadcast).*/
   9  uint8_t target_component; /*<  Component ID (0 for broadcast).*/
  10  uint8_t id_or_mac[20]; /*<  Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html. */
  11  uint8_t id_type; /*<  Indicates the format for the uas_id field of this message.*/
  12  uint8_t ua_type; /*<  Indicates the type of UA (Unmanned Aircraft).*/
  13  uint8_t uas_id[20]; /*<  UAS (Unmanned Aircraft System) ID following the format specified by id_type. Shall be filled with nulls in the unused portion of the field.*/
  14 } mavlink_open_drone_id_basic_id_t;
  15
  16 #define MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN 44
  17 #define MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN 44
  18 #define MAVLINK_MSG_ID_12900_LEN 44
  19 #define MAVLINK_MSG_ID_12900_MIN_LEN 44
  20
  21 #define MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC 114
  22 #define MAVLINK_MSG_ID_12900_CRC 114
  23
  24 #define MAVLINK_MSG_OPEN_DRONE_ID_BASIC_ID_FIELD_ID_OR_MAC_LEN 20
  25 #define MAVLINK_MSG_OPEN_DRONE_ID_BASIC_ID_FIELD_UAS_ID_LEN 20
  26
  27 #if MAVLINK_COMMAND_24BIT
  28 #define MAVLINK_MESSAGE_INFO_OPEN_DRONE_ID_BASIC_ID { \
  29     12900, \
  30     "OPEN_DRONE_ID_BASIC_ID", \
  31     6, \
  32     {  { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_open_drone_id_basic_id_t, target_system) }, \
  33          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_open_drone_id_basic_id_t, target_component) }, \
  34          { "id_or_mac", NULL, MAVLINK_TYPE_UINT8_T, 20, 2, offsetof(mavlink_open_drone_id_basic_id_t, id_or_mac) }, \
  35          { "id_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 22, offsetof(mavlink_open_drone_id_basic_id_t, id_type) }, \
  36          { "ua_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 23, offsetof(mavlink_open_drone_id_basic_id_t, ua_type) }, \
  37          { "uas_id", NULL, MAVLINK_TYPE_UINT8_T, 20, 24, offsetof(mavlink_open_drone_id_basic_id_t, uas_id) }, \
  38          } \
  39 }
  40 #else
  41 #define MAVLINK_MESSAGE_INFO_OPEN_DRONE_ID_BASIC_ID { \
  42     "OPEN_DRONE_ID_BASIC_ID", \
  43     6, \
  44     {  { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 0, offsetof(mavlink_open_drone_id_basic_id_t, target_system) }, \
  45          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 1, offsetof(mavlink_open_drone_id_basic_id_t, target_component) }, \
  46          { "id_or_mac", NULL, MAVLINK_TYPE_UINT8_T, 20, 2, offsetof(mavlink_open_drone_id_basic_id_t, id_or_mac) }, \
  47          { "id_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 22, offsetof(mavlink_open_drone_id_basic_id_t, id_type) }, \
  48          { "ua_type", NULL, MAVLINK_TYPE_UINT8_T, 0, 23, offsetof(mavlink_open_drone_id_basic_id_t, ua_type) }, \
  49          { "uas_id", NULL, MAVLINK_TYPE_UINT8_T, 20, 24, offsetof(mavlink_open_drone_id_basic_id_t, uas_id) }, \
  50          } \
  51 }
  52 #endif
  53
  54 /**
  55  * @brief Pack a open_drone_id_basic_id message
  56  * @param system_id ID of this system
  57  * @param component_id ID of this component (e.g. 200 for IMU)
  58  * @param msg The MAVLink message to compress the data into
  59  *
  60  * @param target_system  System ID (0 for broadcast).
  61  * @param target_component  Component ID (0 for broadcast).
  62  * @param id_or_mac  Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html.
  63  * @param id_type  Indicates the format for the uas_id field of this message.
  64  * @param ua_type  Indicates the type of UA (Unmanned Aircraft).
  65  * @param uas_id  UAS (Unmanned Aircraft System) ID following the format specified by id_type. Shall be filled with nulls in the unused portion of the field.
  66  * @return length of the message in bytes (excluding serial stream start sign)
  67  */
  68 static inline uint16_t mavlink_msg_open_drone_id_basic_id_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
  69                                uint8_t target_system, uint8_t target_component, const uint8_t *id_or_mac, uint8_t id_type, uint8_t ua_type, const uint8_t *uas_id)
  70 {
  71 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  72     char buf[MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN];
  73     _mav_put_uint8_t(buf, 0, target_system);
  74     _mav_put_uint8_t(buf, 1, target_component);
  75     _mav_put_uint8_t(buf, 22, id_type);
  76     _mav_put_uint8_t(buf, 23, ua_type);
  77     _mav_put_uint8_t_array(buf, 2, id_or_mac, 20);
  78     _mav_put_uint8_t_array(buf, 24, uas_id, 20);
  79         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN);
  80 #else
  81     mavlink_open_drone_id_basic_id_t packet;
  82     packet.target_system = target_system;
  83     packet.target_component = target_component;
  84     packet.id_type = id_type;
  85     packet.ua_type = ua_type;
  86     mav_array_memcpy(packet.id_or_mac, id_or_mac, sizeof(uint8_t)*20);
  87     mav_array_memcpy(packet.uas_id, uas_id, sizeof(uint8_t)*20);
  88         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN);
  89 #endif
  90
  91     msg->msgid = MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID;
  92     return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC);
  93 }
  94
  95 /**
  96  * @brief Pack a open_drone_id_basic_id message on a channel
  97  * @param system_id ID of this system
  98  * @param component_id ID of this component (e.g. 200 for IMU)
  99  * @param chan The MAVLink channel this message will be sent over
 100  * @param msg The MAVLink message to compress the data into
 101  * @param target_system  System ID (0 for broadcast).
 102  * @param target_component  Component ID (0 for broadcast).
 103  * @param id_or_mac  Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html.
 104  * @param id_type  Indicates the format for the uas_id field of this message.
 105  * @param ua_type  Indicates the type of UA (Unmanned Aircraft).
 106  * @param uas_id  UAS (Unmanned Aircraft System) ID following the format specified by id_type. Shall be filled with nulls in the unused portion of the field.
 107  * @return length of the message in bytes (excluding serial stream start sign)
 108  */
 109 static inline uint16_t mavlink_msg_open_drone_id_basic_id_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
 110                                mavlink_message_t* msg,
 111                                    uint8_t target_system,uint8_t target_component,const uint8_t *id_or_mac,uint8_t id_type,uint8_t ua_type,const uint8_t *uas_id)
 112 {
 113 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 114     char buf[MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN];
 115     _mav_put_uint8_t(buf, 0, target_system);
 116     _mav_put_uint8_t(buf, 1, target_component);
 117     _mav_put_uint8_t(buf, 22, id_type);
 118     _mav_put_uint8_t(buf, 23, ua_type);
 119     _mav_put_uint8_t_array(buf, 2, id_or_mac, 20);
 120     _mav_put_uint8_t_array(buf, 24, uas_id, 20);
 121         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN);
 122 #else
 123     mavlink_open_drone_id_basic_id_t packet;
 124     packet.target_system = target_system;
 125     packet.target_component = target_component;
 126     packet.id_type = id_type;
 127     packet.ua_type = ua_type;
 128     mav_array_memcpy(packet.id_or_mac, id_or_mac, sizeof(uint8_t)*20);
 129     mav_array_memcpy(packet.uas_id, uas_id, sizeof(uint8_t)*20);
 130         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN);
 131 #endif
 132
 133     msg->msgid = MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID;
 134     return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC);
 135 }
 136
 137 /**
 138  * @brief Encode a open_drone_id_basic_id struct
 139  *
 140  * @param system_id ID of this system
 141  * @param component_id ID of this component (e.g. 200 for IMU)
 142  * @param msg The MAVLink message to compress the data into
 143  * @param open_drone_id_basic_id C-struct to read the message contents from
 144  */
 145 static inline uint16_t mavlink_msg_open_drone_id_basic_id_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_open_drone_id_basic_id_t* open_drone_id_basic_id)
 146 {
 147     return mavlink_msg_open_drone_id_basic_id_pack(system_id, component_id, msg, open_drone_id_basic_id->target_system, open_drone_id_basic_id->target_component, open_drone_id_basic_id->id_or_mac, open_drone_id_basic_id->id_type, open_drone_id_basic_id->ua_type, open_drone_id_basic_id->uas_id);
 148 }
 149
 150 /**
 151  * @brief Encode a open_drone_id_basic_id struct on a channel
 152  *
 153  * @param system_id ID of this system
 154  * @param component_id ID of this component (e.g. 200 for IMU)
 155  * @param chan The MAVLink channel this message will be sent over
 156  * @param msg The MAVLink message to compress the data into
 157  * @param open_drone_id_basic_id C-struct to read the message contents from
 158  */
 159 static inline uint16_t mavlink_msg_open_drone_id_basic_id_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_open_drone_id_basic_id_t* open_drone_id_basic_id)
 160 {
 161     return mavlink_msg_open_drone_id_basic_id_pack_chan(system_id, component_id, chan, msg, open_drone_id_basic_id->target_system, open_drone_id_basic_id->target_component, open_drone_id_basic_id->id_or_mac, open_drone_id_basic_id->id_type, open_drone_id_basic_id->ua_type, open_drone_id_basic_id->uas_id);
 162 }
 163
 164 /**
 165  * @brief Send a open_drone_id_basic_id message
 166  * @param chan MAVLink channel to send the message
 167  *
 168  * @param target_system  System ID (0 for broadcast).
 169  * @param target_component  Component ID (0 for broadcast).
 170  * @param id_or_mac  Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html.
 171  * @param id_type  Indicates the format for the uas_id field of this message.
 172  * @param ua_type  Indicates the type of UA (Unmanned Aircraft).
 173  * @param uas_id  UAS (Unmanned Aircraft System) ID following the format specified by id_type. Shall be filled with nulls in the unused portion of the field.
 174  */
 175 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 176
 177 static inline void mavlink_msg_open_drone_id_basic_id_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, const uint8_t *id_or_mac, uint8_t id_type, uint8_t ua_type, const uint8_t *uas_id)
 178 {
 179 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 180     char buf[MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN];
 181     _mav_put_uint8_t(buf, 0, target_system);
 182     _mav_put_uint8_t(buf, 1, target_component);
 183     _mav_put_uint8_t(buf, 22, id_type);
 184     _mav_put_uint8_t(buf, 23, ua_type);
 185     _mav_put_uint8_t_array(buf, 2, id_or_mac, 20);
 186     _mav_put_uint8_t_array(buf, 24, uas_id, 20);
 187     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID, buf, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC);
 188 #else
 189     mavlink_open_drone_id_basic_id_t packet;
 190     packet.target_system = target_system;
 191     packet.target_component = target_component;
 192     packet.id_type = id_type;
 193     packet.ua_type = ua_type;
 194     mav_array_memcpy(packet.id_or_mac, id_or_mac, sizeof(uint8_t)*20);
 195     mav_array_memcpy(packet.uas_id, uas_id, sizeof(uint8_t)*20);
 196     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID, (const char *)&packet, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC);
 197 #endif
 198 }
 199
 200 /**
 201  * @brief Send a open_drone_id_basic_id message
 202  * @param chan MAVLink channel to send the message
 203  * @param struct The MAVLink struct to serialize
 204  */
 205 static inline void mavlink_msg_open_drone_id_basic_id_send_struct(mavlink_channel_t chan, const mavlink_open_drone_id_basic_id_t* open_drone_id_basic_id)
 206 {
 207 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 208     mavlink_msg_open_drone_id_basic_id_send(chan, open_drone_id_basic_id->target_system, open_drone_id_basic_id->target_component, open_drone_id_basic_id->id_or_mac, open_drone_id_basic_id->id_type, open_drone_id_basic_id->ua_type, open_drone_id_basic_id->uas_id);
 209 #else
 210     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID, (const char *)open_drone_id_basic_id, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC);
 211 #endif
 212 }
 213
 214 #if MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 215 /*
 216   This varient of _send() can be used to save stack space by re-using
 217   memory from the receive buffer.  The caller provides a
 218   mavlink_message_t which is the size of a full mavlink message. This
 219   is usually the receive buffer for the channel, and allows a reply to an
 220   incoming message with minimum stack space usage.
 221  */
 222 static inline void mavlink_msg_open_drone_id_basic_id_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint8_t target_system, uint8_t target_component, const uint8_t *id_or_mac, uint8_t id_type, uint8_t ua_type, const uint8_t *uas_id)
 223 {
 224 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 225     char *buf = (char *)msgbuf;
 226     _mav_put_uint8_t(buf, 0, target_system);
 227     _mav_put_uint8_t(buf, 1, target_component);
 228     _mav_put_uint8_t(buf, 22, id_type);
 229     _mav_put_uint8_t(buf, 23, ua_type);
 230     _mav_put_uint8_t_array(buf, 2, id_or_mac, 20);
 231     _mav_put_uint8_t_array(buf, 24, uas_id, 20);
 232     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID, buf, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC);
 233 #else
 234     mavlink_open_drone_id_basic_id_t *packet = (mavlink_open_drone_id_basic_id_t *)msgbuf;
 235     packet->target_system = target_system;
 236     packet->target_component = target_component;
 237     packet->id_type = id_type;
 238     packet->ua_type = ua_type;
 239     mav_array_memcpy(packet->id_or_mac, id_or_mac, sizeof(uint8_t)*20);
 240     mav_array_memcpy(packet->uas_id, uas_id, sizeof(uint8_t)*20);
 241     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID, (const char *)packet, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_MIN_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_CRC);
 242 #endif
 243 }
 244 #endif
 245
 246 #endif
 247
 248 // MESSAGE OPEN_DRONE_ID_BASIC_ID UNPACKING
 249
 250
 251 /**
 252  * @brief Get field target_system from open_drone_id_basic_id message
 253  *
 254  * @return  System ID (0 for broadcast).
 255  */
 256 static inline uint8_t mavlink_msg_open_drone_id_basic_id_get_target_system(const mavlink_message_t* msg)
 257 {
 258     return _MAV_RETURN_uint8_t(msg,  0);
 259 }
 260
 261 /**
 262  * @brief Get field target_component from open_drone_id_basic_id message
 263  *
 264  * @return  Component ID (0 for broadcast).
 265  */
 266 static inline uint8_t mavlink_msg_open_drone_id_basic_id_get_target_component(const mavlink_message_t* msg)
 267 {
 268     return _MAV_RETURN_uint8_t(msg,  1);
 269 }
 270
 271 /**
 272  * @brief Get field id_or_mac from open_drone_id_basic_id message
 273  *
 274  * @return  Only used for drone ID data received from other UAs. See detailed description at https://mavlink.io/en/services/opendroneid.html.
 275  */
 276 static inline uint16_t mavlink_msg_open_drone_id_basic_id_get_id_or_mac(const mavlink_message_t* msg, uint8_t *id_or_mac)
 277 {
 278     return _MAV_RETURN_uint8_t_array(msg, id_or_mac, 20,  2);
 279 }
 280
 281 /**
 282  * @brief Get field id_type from open_drone_id_basic_id message
 283  *
 284  * @return  Indicates the format for the uas_id field of this message.
 285  */
 286 static inline uint8_t mavlink_msg_open_drone_id_basic_id_get_id_type(const mavlink_message_t* msg)
 287 {
 288     return _MAV_RETURN_uint8_t(msg,  22);
 289 }
 290
 291 /**
 292  * @brief Get field ua_type from open_drone_id_basic_id message
 293  *
 294  * @return  Indicates the type of UA (Unmanned Aircraft).
 295  */
 296 static inline uint8_t mavlink_msg_open_drone_id_basic_id_get_ua_type(const mavlink_message_t* msg)
 297 {
 298     return _MAV_RETURN_uint8_t(msg,  23);
 299 }
 300
 301 /**
 302  * @brief Get field uas_id from open_drone_id_basic_id message
 303  *
 304  * @return  UAS (Unmanned Aircraft System) ID following the format specified by id_type. Shall be filled with nulls in the unused portion of the field.
 305  */
 306 static inline uint16_t mavlink_msg_open_drone_id_basic_id_get_uas_id(const mavlink_message_t* msg, uint8_t *uas_id)
 307 {
 308     return _MAV_RETURN_uint8_t_array(msg, uas_id, 20,  24);
 309 }
 310
 311 /**
 312  * @brief Decode a open_drone_id_basic_id message into a struct
 313  *
 314  * @param msg The message to decode
 315  * @param open_drone_id_basic_id C-struct to decode the message contents into
 316  */
 317 static inline void mavlink_msg_open_drone_id_basic_id_decode(const mavlink_message_t* msg, mavlink_open_drone_id_basic_id_t* open_drone_id_basic_id)
 318 {
 319 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 320     open_drone_id_basic_id->target_system = mavlink_msg_open_drone_id_basic_id_get_target_system(msg);
 321     open_drone_id_basic_id->target_component = mavlink_msg_open_drone_id_basic_id_get_target_component(msg);
 322     mavlink_msg_open_drone_id_basic_id_get_id_or_mac(msg, open_drone_id_basic_id->id_or_mac);
 323     open_drone_id_basic_id->id_type = mavlink_msg_open_drone_id_basic_id_get_id_type(msg);
 324     open_drone_id_basic_id->ua_type = mavlink_msg_open_drone_id_basic_id_get_ua_type(msg);
 325     mavlink_msg_open_drone_id_basic_id_get_uas_id(msg, open_drone_id_basic_id->uas_id);
 326 #else
 327         uint8_t len = msg->len < MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN? msg->len : MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN;
 328         memset(open_drone_id_basic_id, 0, MAVLINK_MSG_ID_OPEN_DRONE_ID_BASIC_ID_LEN);
 329     memcpy(open_drone_id_basic_id, _MAV_PAYLOAD(msg), len);
 330 #endif
 331 }