lib/main/MAVLink/common/mavlink_msg_command_ack.h

   1 #pragma once
   2 // MESSAGE COMMAND_ACK PACKING
   3
   4 #define MAVLINK_MSG_ID_COMMAND_ACK 77
   5
   6
   7 typedef struct __mavlink_command_ack_t {
   8  uint16_t command; /*<  Command ID (of acknowledged command).*/
   9  uint8_t result; /*<  Result of command.*/
  10  uint8_t progress; /*<  WIP: Also used as result_param1, it can be set with an enum containing the errors reasons of why the command was denied, or the progress percentage when result is MAV_RESULT_IN_PROGRESS (255 if the progress is unknown).*/
  11  int32_t result_param2; /*<  WIP: Additional parameter of the result, example: which parameter of MAV_CMD_NAV_WAYPOINT caused it to be denied.*/
  12  uint8_t target_system; /*<  WIP: System ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.*/
  13  uint8_t target_component; /*<  WIP: Component ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.*/
  14 } mavlink_command_ack_t;
  15
  16 #define MAVLINK_MSG_ID_COMMAND_ACK_LEN 10
  17 #define MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN 3
  18 #define MAVLINK_MSG_ID_77_LEN 10
  19 #define MAVLINK_MSG_ID_77_MIN_LEN 3
  20
  21 #define MAVLINK_MSG_ID_COMMAND_ACK_CRC 143
  22 #define MAVLINK_MSG_ID_77_CRC 143
  23
  24
  25
  26 #if MAVLINK_COMMAND_24BIT
  27 #define MAVLINK_MESSAGE_INFO_COMMAND_ACK { \
  28     77, \
  29     "COMMAND_ACK", \
  30     6, \
  31     {  { "command", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_command_ack_t, command) }, \
  32          { "result", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_command_ack_t, result) }, \
  33          { "progress", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_command_ack_t, progress) }, \
  34          { "result_param2", NULL, MAVLINK_TYPE_INT32_T, 0, 4, offsetof(mavlink_command_ack_t, result_param2) }, \
  35          { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 8, offsetof(mavlink_command_ack_t, target_system) }, \
  36          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 9, offsetof(mavlink_command_ack_t, target_component) }, \
  37          } \
  38 }
  39 #else
  40 #define MAVLINK_MESSAGE_INFO_COMMAND_ACK { \
  41     "COMMAND_ACK", \
  42     6, \
  43     {  { "command", NULL, MAVLINK_TYPE_UINT16_T, 0, 0, offsetof(mavlink_command_ack_t, command) }, \
  44          { "result", NULL, MAVLINK_TYPE_UINT8_T, 0, 2, offsetof(mavlink_command_ack_t, result) }, \
  45          { "progress", NULL, MAVLINK_TYPE_UINT8_T, 0, 3, offsetof(mavlink_command_ack_t, progress) }, \
  46          { "result_param2", NULL, MAVLINK_TYPE_INT32_T, 0, 4, offsetof(mavlink_command_ack_t, result_param2) }, \
  47          { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 8, offsetof(mavlink_command_ack_t, target_system) }, \
  48          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 9, offsetof(mavlink_command_ack_t, target_component) }, \
  49          } \
  50 }
  51 #endif
  52
  53 /**
  54  * @brief Pack a command_ack message
  55  * @param system_id ID of this system
  56  * @param component_id ID of this component (e.g. 200 for IMU)
  57  * @param msg The MAVLink message to compress the data into
  58  *
  59  * @param command  Command ID (of acknowledged command).
  60  * @param result  Result of command.
  61  * @param progress  WIP: Also used as result_param1, it can be set with an enum containing the errors reasons of why the command was denied, or the progress percentage when result is MAV_RESULT_IN_PROGRESS (255 if the progress is unknown).
  62  * @param result_param2  WIP: Additional parameter of the result, example: which parameter of MAV_CMD_NAV_WAYPOINT caused it to be denied.
  63  * @param target_system  WIP: System ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
  64  * @param target_component  WIP: Component ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
  65  * @return length of the message in bytes (excluding serial stream start sign)
  66  */
  67 static inline uint16_t mavlink_msg_command_ack_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
  68                                uint16_t command, uint8_t result, uint8_t progress, int32_t result_param2, uint8_t target_system, uint8_t target_component)
  69 {
  70 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  71     char buf[MAVLINK_MSG_ID_COMMAND_ACK_LEN];
  72     _mav_put_uint16_t(buf, 0, command);
  73     _mav_put_uint8_t(buf, 2, result);
  74     _mav_put_uint8_t(buf, 3, progress);
  75     _mav_put_int32_t(buf, 4, result_param2);
  76     _mav_put_uint8_t(buf, 8, target_system);
  77     _mav_put_uint8_t(buf, 9, target_component);
  78
  79         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_COMMAND_ACK_LEN);
  80 #else
  81     mavlink_command_ack_t packet;
  82     packet.command = command;
  83     packet.result = result;
  84     packet.progress = progress;
  85     packet.result_param2 = result_param2;
  86     packet.target_system = target_system;
  87     packet.target_component = target_component;
  88
  89         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_COMMAND_ACK_LEN);
  90 #endif
  91
  92     msg->msgid = MAVLINK_MSG_ID_COMMAND_ACK;
  93     return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN, MAVLINK_MSG_ID_COMMAND_ACK_LEN, MAVLINK_MSG_ID_COMMAND_ACK_CRC);
  94 }
  95
  96 /**
  97  * @brief Pack a command_ack message on a channel
  98  * @param system_id ID of this system
  99  * @param component_id ID of this component (e.g. 200 for IMU)
 100  * @param chan The MAVLink channel this message will be sent over
 101  * @param msg The MAVLink message to compress the data into
 102  * @param command  Command ID (of acknowledged command).
 103  * @param result  Result of command.
 104  * @param progress  WIP: Also used as result_param1, it can be set with an enum containing the errors reasons of why the command was denied, or the progress percentage when result is MAV_RESULT_IN_PROGRESS (255 if the progress is unknown).
 105  * @param result_param2  WIP: Additional parameter of the result, example: which parameter of MAV_CMD_NAV_WAYPOINT caused it to be denied.
 106  * @param target_system  WIP: System ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
 107  * @param target_component  WIP: Component ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
 108  * @return length of the message in bytes (excluding serial stream start sign)
 109  */
 110 static inline uint16_t mavlink_msg_command_ack_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
 111                                mavlink_message_t* msg,
 112                                    uint16_t command,uint8_t result,uint8_t progress,int32_t result_param2,uint8_t target_system,uint8_t target_component)
 113 {
 114 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 115     char buf[MAVLINK_MSG_ID_COMMAND_ACK_LEN];
 116     _mav_put_uint16_t(buf, 0, command);
 117     _mav_put_uint8_t(buf, 2, result);
 118     _mav_put_uint8_t(buf, 3, progress);
 119     _mav_put_int32_t(buf, 4, result_param2);
 120     _mav_put_uint8_t(buf, 8, target_system);
 121     _mav_put_uint8_t(buf, 9, target_component);
 122
 123         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_COMMAND_ACK_LEN);
 124 #else
 125     mavlink_command_ack_t packet;
 126     packet.command = command;
 127     packet.result = result;
 128     packet.progress = progress;
 129     packet.result_param2 = result_param2;
 130     packet.target_system = target_system;
 131     packet.target_component = target_component;
 132
 133         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_COMMAND_ACK_LEN);
 134 #endif
 135
 136     msg->msgid = MAVLINK_MSG_ID_COMMAND_ACK;
 137     return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN, MAVLINK_MSG_ID_COMMAND_ACK_LEN, MAVLINK_MSG_ID_COMMAND_ACK_CRC);
 138 }
 139
 140 /**
 141  * @brief Encode a command_ack struct
 142  *
 143  * @param system_id ID of this system
 144  * @param component_id ID of this component (e.g. 200 for IMU)
 145  * @param msg The MAVLink message to compress the data into
 146  * @param command_ack C-struct to read the message contents from
 147  */
 148 static inline uint16_t mavlink_msg_command_ack_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_command_ack_t* command_ack)
 149 {
 150     return mavlink_msg_command_ack_pack(system_id, component_id, msg, command_ack->command, command_ack->result, command_ack->progress, command_ack->result_param2, command_ack->target_system, command_ack->target_component);
 151 }
 152
 153 /**
 154  * @brief Encode a command_ack struct on a channel
 155  *
 156  * @param system_id ID of this system
 157  * @param component_id ID of this component (e.g. 200 for IMU)
 158  * @param chan The MAVLink channel this message will be sent over
 159  * @param msg The MAVLink message to compress the data into
 160  * @param command_ack C-struct to read the message contents from
 161  */
 162 static inline uint16_t mavlink_msg_command_ack_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_command_ack_t* command_ack)
 163 {
 164     return mavlink_msg_command_ack_pack_chan(system_id, component_id, chan, msg, command_ack->command, command_ack->result, command_ack->progress, command_ack->result_param2, command_ack->target_system, command_ack->target_component);
 165 }
 166
 167 /**
 168  * @brief Send a command_ack message
 169  * @param chan MAVLink channel to send the message
 170  *
 171  * @param command  Command ID (of acknowledged command).
 172  * @param result  Result of command.
 173  * @param progress  WIP: Also used as result_param1, it can be set with an enum containing the errors reasons of why the command was denied, or the progress percentage when result is MAV_RESULT_IN_PROGRESS (255 if the progress is unknown).
 174  * @param result_param2  WIP: Additional parameter of the result, example: which parameter of MAV_CMD_NAV_WAYPOINT caused it to be denied.
 175  * @param target_system  WIP: System ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
 176  * @param target_component  WIP: Component ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
 177  */
 178 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 179
 180 static inline void mavlink_msg_command_ack_send(mavlink_channel_t chan, uint16_t command, uint8_t result, uint8_t progress, int32_t result_param2, uint8_t target_system, uint8_t target_component)
 181 {
 182 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 183     char buf[MAVLINK_MSG_ID_COMMAND_ACK_LEN];
 184     _mav_put_uint16_t(buf, 0, command);
 185     _mav_put_uint8_t(buf, 2, result);
 186     _mav_put_uint8_t(buf, 3, progress);
 187     _mav_put_int32_t(buf, 4, result_param2);
 188     _mav_put_uint8_t(buf, 8, target_system);
 189     _mav_put_uint8_t(buf, 9, target_component);
 190
 191     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND_ACK, buf, MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN, MAVLINK_MSG_ID_COMMAND_ACK_LEN, MAVLINK_MSG_ID_COMMAND_ACK_CRC);
 192 #else
 193     mavlink_command_ack_t packet;
 194     packet.command = command;
 195     packet.result = result;
 196     packet.progress = progress;
 197     packet.result_param2 = result_param2;
 198     packet.target_system = target_system;
 199     packet.target_component = target_component;
 200
 201     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND_ACK, (const char *)&packet, MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN, MAVLINK_MSG_ID_COMMAND_ACK_LEN, MAVLINK_MSG_ID_COMMAND_ACK_CRC);
 202 #endif
 203 }
 204
 205 /**
 206  * @brief Send a command_ack message
 207  * @param chan MAVLink channel to send the message
 208  * @param struct The MAVLink struct to serialize
 209  */
 210 static inline void mavlink_msg_command_ack_send_struct(mavlink_channel_t chan, const mavlink_command_ack_t* command_ack)
 211 {
 212 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 213     mavlink_msg_command_ack_send(chan, command_ack->command, command_ack->result, command_ack->progress, command_ack->result_param2, command_ack->target_system, command_ack->target_component);
 214 #else
 215     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND_ACK, (const char *)command_ack, MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN, MAVLINK_MSG_ID_COMMAND_ACK_LEN, MAVLINK_MSG_ID_COMMAND_ACK_CRC);
 216 #endif
 217 }
 218
 219 #if MAVLINK_MSG_ID_COMMAND_ACK_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 220 /*
 221   This varient of _send() can be used to save stack space by re-using
 222   memory from the receive buffer.  The caller provides a
 223   mavlink_message_t which is the size of a full mavlink message. This
 224   is usually the receive buffer for the channel, and allows a reply to an
 225   incoming message with minimum stack space usage.
 226  */
 227 static inline void mavlink_msg_command_ack_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint16_t command, uint8_t result, uint8_t progress, int32_t result_param2, uint8_t target_system, uint8_t target_component)
 228 {
 229 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 230     char *buf = (char *)msgbuf;
 231     _mav_put_uint16_t(buf, 0, command);
 232     _mav_put_uint8_t(buf, 2, result);
 233     _mav_put_uint8_t(buf, 3, progress);
 234     _mav_put_int32_t(buf, 4, result_param2);
 235     _mav_put_uint8_t(buf, 8, target_system);
 236     _mav_put_uint8_t(buf, 9, target_component);
 237
 238     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND_ACK, buf, MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN, MAVLINK_MSG_ID_COMMAND_ACK_LEN, MAVLINK_MSG_ID_COMMAND_ACK_CRC);
 239 #else
 240     mavlink_command_ack_t *packet = (mavlink_command_ack_t *)msgbuf;
 241     packet->command = command;
 242     packet->result = result;
 243     packet->progress = progress;
 244     packet->result_param2 = result_param2;
 245     packet->target_system = target_system;
 246     packet->target_component = target_component;
 247
 248     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_COMMAND_ACK, (const char *)packet, MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN, MAVLINK_MSG_ID_COMMAND_ACK_LEN, MAVLINK_MSG_ID_COMMAND_ACK_CRC);
 249 #endif
 250 }
 251 #endif
 252
 253 #endif
 254
 255 // MESSAGE COMMAND_ACK UNPACKING
 256
 257
 258 /**
 259  * @brief Get field command from command_ack message
 260  *
 261  * @return  Command ID (of acknowledged command).
 262  */
 263 static inline uint16_t mavlink_msg_command_ack_get_command(const mavlink_message_t* msg)
 264 {
 265     return _MAV_RETURN_uint16_t(msg,  0);
 266 }
 267
 268 /**
 269  * @brief Get field result from command_ack message
 270  *
 271  * @return  Result of command.
 272  */
 273 static inline uint8_t mavlink_msg_command_ack_get_result(const mavlink_message_t* msg)
 274 {
 275     return _MAV_RETURN_uint8_t(msg,  2);
 276 }
 277
 278 /**
 279  * @brief Get field progress from command_ack message
 280  *
 281  * @return  WIP: Also used as result_param1, it can be set with an enum containing the errors reasons of why the command was denied, or the progress percentage when result is MAV_RESULT_IN_PROGRESS (255 if the progress is unknown).
 282  */
 283 static inline uint8_t mavlink_msg_command_ack_get_progress(const mavlink_message_t* msg)
 284 {
 285     return _MAV_RETURN_uint8_t(msg,  3);
 286 }
 287
 288 /**
 289  * @brief Get field result_param2 from command_ack message
 290  *
 291  * @return  WIP: Additional parameter of the result, example: which parameter of MAV_CMD_NAV_WAYPOINT caused it to be denied.
 292  */
 293 static inline int32_t mavlink_msg_command_ack_get_result_param2(const mavlink_message_t* msg)
 294 {
 295     return _MAV_RETURN_int32_t(msg,  4);
 296 }
 297
 298 /**
 299  * @brief Get field target_system from command_ack message
 300  *
 301  * @return  WIP: System ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
 302  */
 303 static inline uint8_t mavlink_msg_command_ack_get_target_system(const mavlink_message_t* msg)
 304 {
 305     return _MAV_RETURN_uint8_t(msg,  8);
 306 }
 307
 308 /**
 309  * @brief Get field target_component from command_ack message
 310  *
 311  * @return  WIP: Component ID of the target recipient. This is the ID of the system that sent the command for which this COMMAND_ACK is an acknowledgement.
 312  */
 313 static inline uint8_t mavlink_msg_command_ack_get_target_component(const mavlink_message_t* msg)
 314 {
 315     return _MAV_RETURN_uint8_t(msg,  9);
 316 }
 317
 318 /**
 319  * @brief Decode a command_ack message into a struct
 320  *
 321  * @param msg The message to decode
 322  * @param command_ack C-struct to decode the message contents into
 323  */
 324 static inline void mavlink_msg_command_ack_decode(const mavlink_message_t* msg, mavlink_command_ack_t* command_ack)
 325 {
 326 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 327     command_ack->command = mavlink_msg_command_ack_get_command(msg);
 328     command_ack->result = mavlink_msg_command_ack_get_result(msg);
 329     command_ack->progress = mavlink_msg_command_ack_get_progress(msg);
 330     command_ack->result_param2 = mavlink_msg_command_ack_get_result_param2(msg);
 331     command_ack->target_system = mavlink_msg_command_ack_get_target_system(msg);
 332     command_ack->target_component = mavlink_msg_command_ack_get_target_component(msg);
 333 #else
 334         uint8_t len = msg->len < MAVLINK_MSG_ID_COMMAND_ACK_LEN? msg->len : MAVLINK_MSG_ID_COMMAND_ACK_LEN;
 335         memset(command_ack, 0, MAVLINK_MSG_ID_COMMAND_ACK_LEN);
 336     memcpy(command_ack, _MAV_PAYLOAD(msg), len);
 337 #endif
 338 }