lib/main/MAVLink/common/mavlink_msg_ping.h

   1 #pragma once
   2 // MESSAGE PING PACKING
   3
   4 #define MAVLINK_MSG_ID_PING 4
   5
   6
   7 typedef struct __mavlink_ping_t {
   8  uint64_t time_usec; /*< [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number.*/
   9  uint32_t seq; /*<  PING sequence*/
  10  uint8_t target_system; /*<  0: request ping from all receiving systems. If greater than 0: message is a ping response and number is the system id of the requesting system*/
  11  uint8_t target_component; /*<  0: request ping from all receiving components. If greater than 0: message is a ping response and number is the component id of the requesting component.*/
  12 } mavlink_ping_t;
  13
  14 #define MAVLINK_MSG_ID_PING_LEN 14
  15 #define MAVLINK_MSG_ID_PING_MIN_LEN 14
  16 #define MAVLINK_MSG_ID_4_LEN 14
  17 #define MAVLINK_MSG_ID_4_MIN_LEN 14
  18
  19 #define MAVLINK_MSG_ID_PING_CRC 237
  20 #define MAVLINK_MSG_ID_4_CRC 237
  21
  22
  23
  24 #if MAVLINK_COMMAND_24BIT
  25 #define MAVLINK_MESSAGE_INFO_PING { \
  26     4, \
  27     "PING", \
  28     4, \
  29     {  { "time_usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_ping_t, time_usec) }, \
  30          { "seq", NULL, MAVLINK_TYPE_UINT32_T, 0, 8, offsetof(mavlink_ping_t, seq) }, \
  31          { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 12, offsetof(mavlink_ping_t, target_system) }, \
  32          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 13, offsetof(mavlink_ping_t, target_component) }, \
  33          } \
  34 }
  35 #else
  36 #define MAVLINK_MESSAGE_INFO_PING { \
  37     "PING", \
  38     4, \
  39     {  { "time_usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_ping_t, time_usec) }, \
  40          { "seq", NULL, MAVLINK_TYPE_UINT32_T, 0, 8, offsetof(mavlink_ping_t, seq) }, \
  41          { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 12, offsetof(mavlink_ping_t, target_system) }, \
  42          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 13, offsetof(mavlink_ping_t, target_component) }, \
  43          } \
  44 }
  45 #endif
  46
  47 /**
  48  * @brief Pack a ping message
  49  * @param system_id ID of this system
  50  * @param component_id ID of this component (e.g. 200 for IMU)
  51  * @param msg The MAVLink message to compress the data into
  52  *
  53  * @param time_usec [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
  54  * @param seq  PING sequence
  55  * @param target_system  0: request ping from all receiving systems. If greater than 0: message is a ping response and number is the system id of the requesting system
  56  * @param target_component  0: request ping from all receiving components. If greater than 0: message is a ping response and number is the component id of the requesting component.
  57  * @return length of the message in bytes (excluding serial stream start sign)
  58  */
  59 static inline uint16_t mavlink_msg_ping_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
  60                                uint64_t time_usec, uint32_t seq, uint8_t target_system, uint8_t target_component)
  61 {
  62 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  63     char buf[MAVLINK_MSG_ID_PING_LEN];
  64     _mav_put_uint64_t(buf, 0, time_usec);
  65     _mav_put_uint32_t(buf, 8, seq);
  66     _mav_put_uint8_t(buf, 12, target_system);
  67     _mav_put_uint8_t(buf, 13, target_component);
  68
  69         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_PING_LEN);
  70 #else
  71     mavlink_ping_t packet;
  72     packet.time_usec = time_usec;
  73     packet.seq = seq;
  74     packet.target_system = target_system;
  75     packet.target_component = target_component;
  76
  77         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_PING_LEN);
  78 #endif
  79
  80     msg->msgid = MAVLINK_MSG_ID_PING;
  81     return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_PING_MIN_LEN, MAVLINK_MSG_ID_PING_LEN, MAVLINK_MSG_ID_PING_CRC);
  82 }
  83
  84 /**
  85  * @brief Pack a ping message on a channel
  86  * @param system_id ID of this system
  87  * @param component_id ID of this component (e.g. 200 for IMU)
  88  * @param chan The MAVLink channel this message will be sent over
  89  * @param msg The MAVLink message to compress the data into
  90  * @param time_usec [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
  91  * @param seq  PING sequence
  92  * @param target_system  0: request ping from all receiving systems. If greater than 0: message is a ping response and number is the system id of the requesting system
  93  * @param target_component  0: request ping from all receiving components. If greater than 0: message is a ping response and number is the component id of the requesting component.
  94  * @return length of the message in bytes (excluding serial stream start sign)
  95  */
  96 static inline uint16_t mavlink_msg_ping_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
  97                                mavlink_message_t* msg,
  98                                    uint64_t time_usec,uint32_t seq,uint8_t target_system,uint8_t target_component)
  99 {
 100 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 101     char buf[MAVLINK_MSG_ID_PING_LEN];
 102     _mav_put_uint64_t(buf, 0, time_usec);
 103     _mav_put_uint32_t(buf, 8, seq);
 104     _mav_put_uint8_t(buf, 12, target_system);
 105     _mav_put_uint8_t(buf, 13, target_component);
 106
 107         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_PING_LEN);
 108 #else
 109     mavlink_ping_t packet;
 110     packet.time_usec = time_usec;
 111     packet.seq = seq;
 112     packet.target_system = target_system;
 113     packet.target_component = target_component;
 114
 115         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_PING_LEN);
 116 #endif
 117
 118     msg->msgid = MAVLINK_MSG_ID_PING;
 119     return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_PING_MIN_LEN, MAVLINK_MSG_ID_PING_LEN, MAVLINK_MSG_ID_PING_CRC);
 120 }
 121
 122 /**
 123  * @brief Encode a ping struct
 124  *
 125  * @param system_id ID of this system
 126  * @param component_id ID of this component (e.g. 200 for IMU)
 127  * @param msg The MAVLink message to compress the data into
 128  * @param ping C-struct to read the message contents from
 129  */
 130 static inline uint16_t mavlink_msg_ping_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_ping_t* ping)
 131 {
 132     return mavlink_msg_ping_pack(system_id, component_id, msg, ping->time_usec, ping->seq, ping->target_system, ping->target_component);
 133 }
 134
 135 /**
 136  * @brief Encode a ping struct on a channel
 137  *
 138  * @param system_id ID of this system
 139  * @param component_id ID of this component (e.g. 200 for IMU)
 140  * @param chan The MAVLink channel this message will be sent over
 141  * @param msg The MAVLink message to compress the data into
 142  * @param ping C-struct to read the message contents from
 143  */
 144 static inline uint16_t mavlink_msg_ping_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_ping_t* ping)
 145 {
 146     return mavlink_msg_ping_pack_chan(system_id, component_id, chan, msg, ping->time_usec, ping->seq, ping->target_system, ping->target_component);
 147 }
 148
 149 /**
 150  * @brief Send a ping message
 151  * @param chan MAVLink channel to send the message
 152  *
 153  * @param time_usec [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
 154  * @param seq  PING sequence
 155  * @param target_system  0: request ping from all receiving systems. If greater than 0: message is a ping response and number is the system id of the requesting system
 156  * @param target_component  0: request ping from all receiving components. If greater than 0: message is a ping response and number is the component id of the requesting component.
 157  */
 158 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 159
 160 static inline void mavlink_msg_ping_send(mavlink_channel_t chan, uint64_t time_usec, uint32_t seq, uint8_t target_system, uint8_t target_component)
 161 {
 162 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 163     char buf[MAVLINK_MSG_ID_PING_LEN];
 164     _mav_put_uint64_t(buf, 0, time_usec);
 165     _mav_put_uint32_t(buf, 8, seq);
 166     _mav_put_uint8_t(buf, 12, target_system);
 167     _mav_put_uint8_t(buf, 13, target_component);
 168
 169     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PING, buf, MAVLINK_MSG_ID_PING_MIN_LEN, MAVLINK_MSG_ID_PING_LEN, MAVLINK_MSG_ID_PING_CRC);
 170 #else
 171     mavlink_ping_t packet;
 172     packet.time_usec = time_usec;
 173     packet.seq = seq;
 174     packet.target_system = target_system;
 175     packet.target_component = target_component;
 176
 177     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PING, (const char *)&packet, MAVLINK_MSG_ID_PING_MIN_LEN, MAVLINK_MSG_ID_PING_LEN, MAVLINK_MSG_ID_PING_CRC);
 178 #endif
 179 }
 180
 181 /**
 182  * @brief Send a ping message
 183  * @param chan MAVLink channel to send the message
 184  * @param struct The MAVLink struct to serialize
 185  */
 186 static inline void mavlink_msg_ping_send_struct(mavlink_channel_t chan, const mavlink_ping_t* ping)
 187 {
 188 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 189     mavlink_msg_ping_send(chan, ping->time_usec, ping->seq, ping->target_system, ping->target_component);
 190 #else
 191     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PING, (const char *)ping, MAVLINK_MSG_ID_PING_MIN_LEN, MAVLINK_MSG_ID_PING_LEN, MAVLINK_MSG_ID_PING_CRC);
 192 #endif
 193 }
 194
 195 #if MAVLINK_MSG_ID_PING_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 196 /*
 197   This varient of _send() can be used to save stack space by re-using
 198   memory from the receive buffer.  The caller provides a
 199   mavlink_message_t which is the size of a full mavlink message. This
 200   is usually the receive buffer for the channel, and allows a reply to an
 201   incoming message with minimum stack space usage.
 202  */
 203 static inline void mavlink_msg_ping_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint64_t time_usec, uint32_t seq, uint8_t target_system, uint8_t target_component)
 204 {
 205 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 206     char *buf = (char *)msgbuf;
 207     _mav_put_uint64_t(buf, 0, time_usec);
 208     _mav_put_uint32_t(buf, 8, seq);
 209     _mav_put_uint8_t(buf, 12, target_system);
 210     _mav_put_uint8_t(buf, 13, target_component);
 211
 212     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PING, buf, MAVLINK_MSG_ID_PING_MIN_LEN, MAVLINK_MSG_ID_PING_LEN, MAVLINK_MSG_ID_PING_CRC);
 213 #else
 214     mavlink_ping_t *packet = (mavlink_ping_t *)msgbuf;
 215     packet->time_usec = time_usec;
 216     packet->seq = seq;
 217     packet->target_system = target_system;
 218     packet->target_component = target_component;
 219
 220     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_PING, (const char *)packet, MAVLINK_MSG_ID_PING_MIN_LEN, MAVLINK_MSG_ID_PING_LEN, MAVLINK_MSG_ID_PING_CRC);
 221 #endif
 222 }
 223 #endif
 224
 225 #endif
 226
 227 // MESSAGE PING UNPACKING
 228
 229
 230 /**
 231  * @brief Get field time_usec from ping message
 232  *
 233  * @return [us] Timestamp (UNIX Epoch time or time since system boot). The receiving end can infer timestamp format (since 1.1.1970 or since system boot) by checking for the magnitude of the number.
 234  */
 235 static inline uint64_t mavlink_msg_ping_get_time_usec(const mavlink_message_t* msg)
 236 {
 237     return _MAV_RETURN_uint64_t(msg,  0);
 238 }
 239
 240 /**
 241  * @brief Get field seq from ping message
 242  *
 243  * @return  PING sequence
 244  */
 245 static inline uint32_t mavlink_msg_ping_get_seq(const mavlink_message_t* msg)
 246 {
 247     return _MAV_RETURN_uint32_t(msg,  8);
 248 }
 249
 250 /**
 251  * @brief Get field target_system from ping message
 252  *
 253  * @return  0: request ping from all receiving systems. If greater than 0: message is a ping response and number is the system id of the requesting system
 254  */
 255 static inline uint8_t mavlink_msg_ping_get_target_system(const mavlink_message_t* msg)
 256 {
 257     return _MAV_RETURN_uint8_t(msg,  12);
 258 }
 259
 260 /**
 261  * @brief Get field target_component from ping message
 262  *
 263  * @return  0: request ping from all receiving components. If greater than 0: message is a ping response and number is the component id of the requesting component.
 264  */
 265 static inline uint8_t mavlink_msg_ping_get_target_component(const mavlink_message_t* msg)
 266 {
 267     return _MAV_RETURN_uint8_t(msg,  13);
 268 }
 269
 270 /**
 271  * @brief Decode a ping message into a struct
 272  *
 273  * @param msg The message to decode
 274  * @param ping C-struct to decode the message contents into
 275  */
 276 static inline void mavlink_msg_ping_decode(const mavlink_message_t* msg, mavlink_ping_t* ping)
 277 {
 278 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 279     ping->time_usec = mavlink_msg_ping_get_time_usec(msg);
 280     ping->seq = mavlink_msg_ping_get_seq(msg);
 281     ping->target_system = mavlink_msg_ping_get_target_system(msg);
 282     ping->target_component = mavlink_msg_ping_get_target_component(msg);
 283 #else
 284         uint8_t len = msg->len < MAVLINK_MSG_ID_PING_LEN? msg->len : MAVLINK_MSG_ID_PING_LEN;
 285         memset(ping, 0, MAVLINK_MSG_ID_PING_LEN);
 286     memcpy(ping, _MAV_PAYLOAD(msg), len);
 287 #endif
 288 }