mavlink_msg_debug_float_array.h 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281
  1. #pragma once
  2. // MESSAGE DEBUG_FLOAT_ARRAY PACKING
  3. #define MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY 350
  4. typedef struct __mavlink_debug_float_array_t {
  5. 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.*/
  6. uint16_t array_id; /*< Unique ID used to discriminate between arrays*/
  7. char name[10]; /*< Name, for human-friendly display in a Ground Control Station*/
  8. float data[58]; /*< data*/
  9. } mavlink_debug_float_array_t;
  10. #define MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN 252
  11. #define MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN 20
  12. #define MAVLINK_MSG_ID_350_LEN 252
  13. #define MAVLINK_MSG_ID_350_MIN_LEN 20
  14. #define MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC 232
  15. #define MAVLINK_MSG_ID_350_CRC 232
  16. #define MAVLINK_MSG_DEBUG_FLOAT_ARRAY_FIELD_NAME_LEN 10
  17. #define MAVLINK_MSG_DEBUG_FLOAT_ARRAY_FIELD_DATA_LEN 58
  18. #if MAVLINK_COMMAND_24BIT
  19. #define MAVLINK_MESSAGE_INFO_DEBUG_FLOAT_ARRAY { \
  20. 350, \
  21. "DEBUG_FLOAT_ARRAY", \
  22. 4, \
  23. { { "time_usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_debug_float_array_t, time_usec) }, \
  24. { "name", NULL, MAVLINK_TYPE_CHAR, 10, 10, offsetof(mavlink_debug_float_array_t, name) }, \
  25. { "array_id", NULL, MAVLINK_TYPE_UINT16_T, 0, 8, offsetof(mavlink_debug_float_array_t, array_id) }, \
  26. { "data", NULL, MAVLINK_TYPE_FLOAT, 58, 20, offsetof(mavlink_debug_float_array_t, data) }, \
  27. } \
  28. }
  29. #else
  30. #define MAVLINK_MESSAGE_INFO_DEBUG_FLOAT_ARRAY { \
  31. "DEBUG_FLOAT_ARRAY", \
  32. 4, \
  33. { { "time_usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_debug_float_array_t, time_usec) }, \
  34. { "name", NULL, MAVLINK_TYPE_CHAR, 10, 10, offsetof(mavlink_debug_float_array_t, name) }, \
  35. { "array_id", NULL, MAVLINK_TYPE_UINT16_T, 0, 8, offsetof(mavlink_debug_float_array_t, array_id) }, \
  36. { "data", NULL, MAVLINK_TYPE_FLOAT, 58, 20, offsetof(mavlink_debug_float_array_t, data) }, \
  37. } \
  38. }
  39. #endif
  40. /**
  41. * @brief Pack a debug_float_array message
  42. * @param system_id ID of this system
  43. * @param component_id ID of this component (e.g. 200 for IMU)
  44. * @param msg The MAVLink message to compress the data into
  45. *
  46. * @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.
  47. * @param name Name, for human-friendly display in a Ground Control Station
  48. * @param array_id Unique ID used to discriminate between arrays
  49. * @param data data
  50. * @return length of the message in bytes (excluding serial stream start sign)
  51. */
  52. static inline uint16_t mavlink_msg_debug_float_array_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
  53. uint64_t time_usec, const char *name, uint16_t array_id, const float *data)
  54. {
  55. #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  56. char buf[MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN];
  57. _mav_put_uint64_t(buf, 0, time_usec);
  58. _mav_put_uint16_t(buf, 8, array_id);
  59. _mav_put_char_array(buf, 10, name, 10);
  60. _mav_put_float_array(buf, 20, data, 58);
  61. memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN);
  62. #else
  63. mavlink_debug_float_array_t packet;
  64. packet.time_usec = time_usec;
  65. packet.array_id = array_id;
  66. mav_array_memcpy(packet.name, name, sizeof(char)*10);
  67. mav_array_memcpy(packet.data, data, sizeof(float)*58);
  68. memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN);
  69. #endif
  70. msg->msgid = MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY;
  71. return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC);
  72. }
  73. /**
  74. * @brief Pack a debug_float_array message on a channel
  75. * @param system_id ID of this system
  76. * @param component_id ID of this component (e.g. 200 for IMU)
  77. * @param chan The MAVLink channel this message will be sent over
  78. * @param msg The MAVLink message to compress the data into
  79. * @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.
  80. * @param name Name, for human-friendly display in a Ground Control Station
  81. * @param array_id Unique ID used to discriminate between arrays
  82. * @param data data
  83. * @return length of the message in bytes (excluding serial stream start sign)
  84. */
  85. static inline uint16_t mavlink_msg_debug_float_array_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
  86. mavlink_message_t* msg,
  87. uint64_t time_usec,const char *name,uint16_t array_id,const float *data)
  88. {
  89. #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  90. char buf[MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN];
  91. _mav_put_uint64_t(buf, 0, time_usec);
  92. _mav_put_uint16_t(buf, 8, array_id);
  93. _mav_put_char_array(buf, 10, name, 10);
  94. _mav_put_float_array(buf, 20, data, 58);
  95. memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN);
  96. #else
  97. mavlink_debug_float_array_t packet;
  98. packet.time_usec = time_usec;
  99. packet.array_id = array_id;
  100. mav_array_memcpy(packet.name, name, sizeof(char)*10);
  101. mav_array_memcpy(packet.data, data, sizeof(float)*58);
  102. memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN);
  103. #endif
  104. msg->msgid = MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY;
  105. return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC);
  106. }
  107. /**
  108. * @brief Encode a debug_float_array struct
  109. *
  110. * @param system_id ID of this system
  111. * @param component_id ID of this component (e.g. 200 for IMU)
  112. * @param msg The MAVLink message to compress the data into
  113. * @param debug_float_array C-struct to read the message contents from
  114. */
  115. static inline uint16_t mavlink_msg_debug_float_array_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_debug_float_array_t* debug_float_array)
  116. {
  117. return mavlink_msg_debug_float_array_pack(system_id, component_id, msg, debug_float_array->time_usec, debug_float_array->name, debug_float_array->array_id, debug_float_array->data);
  118. }
  119. /**
  120. * @brief Encode a debug_float_array struct on a channel
  121. *
  122. * @param system_id ID of this system
  123. * @param component_id ID of this component (e.g. 200 for IMU)
  124. * @param chan The MAVLink channel this message will be sent over
  125. * @param msg The MAVLink message to compress the data into
  126. * @param debug_float_array C-struct to read the message contents from
  127. */
  128. static inline uint16_t mavlink_msg_debug_float_array_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_debug_float_array_t* debug_float_array)
  129. {
  130. return mavlink_msg_debug_float_array_pack_chan(system_id, component_id, chan, msg, debug_float_array->time_usec, debug_float_array->name, debug_float_array->array_id, debug_float_array->data);
  131. }
  132. /**
  133. * @brief Send a debug_float_array message
  134. * @param chan MAVLink channel to send the message
  135. *
  136. * @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.
  137. * @param name Name, for human-friendly display in a Ground Control Station
  138. * @param array_id Unique ID used to discriminate between arrays
  139. * @param data data
  140. */
  141. #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
  142. static inline void mavlink_msg_debug_float_array_send(mavlink_channel_t chan, uint64_t time_usec, const char *name, uint16_t array_id, const float *data)
  143. {
  144. #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  145. char buf[MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN];
  146. _mav_put_uint64_t(buf, 0, time_usec);
  147. _mav_put_uint16_t(buf, 8, array_id);
  148. _mav_put_char_array(buf, 10, name, 10);
  149. _mav_put_float_array(buf, 20, data, 58);
  150. _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY, buf, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC);
  151. #else
  152. mavlink_debug_float_array_t packet;
  153. packet.time_usec = time_usec;
  154. packet.array_id = array_id;
  155. mav_array_memcpy(packet.name, name, sizeof(char)*10);
  156. mav_array_memcpy(packet.data, data, sizeof(float)*58);
  157. _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);
  158. #endif
  159. }
  160. /**
  161. * @brief Send a debug_float_array message
  162. * @param chan MAVLink channel to send the message
  163. * @param struct The MAVLink struct to serialize
  164. */
  165. static inline void mavlink_msg_debug_float_array_send_struct(mavlink_channel_t chan, const mavlink_debug_float_array_t* debug_float_array)
  166. {
  167. #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  168. mavlink_msg_debug_float_array_send(chan, debug_float_array->time_usec, debug_float_array->name, debug_float_array->array_id, debug_float_array->data);
  169. #else
  170. _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY, (const char *)debug_float_array, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC);
  171. #endif
  172. }
  173. #if MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN <= MAVLINK_MAX_PAYLOAD_LEN
  174. /*
  175. This variant of _send() can be used to save stack space by re-using
  176. memory from the receive buffer. The caller provides a
  177. mavlink_message_t which is the size of a full mavlink message. This
  178. is usually the receive buffer for the channel, and allows a reply to an
  179. incoming message with minimum stack space usage.
  180. */
  181. static inline void mavlink_msg_debug_float_array_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan, uint64_t time_usec, const char *name, uint16_t array_id, const float *data)
  182. {
  183. #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  184. char *buf = (char *)msgbuf;
  185. _mav_put_uint64_t(buf, 0, time_usec);
  186. _mav_put_uint16_t(buf, 8, array_id);
  187. _mav_put_char_array(buf, 10, name, 10);
  188. _mav_put_float_array(buf, 20, data, 58);
  189. _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY, buf, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_MIN_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_CRC);
  190. #else
  191. mavlink_debug_float_array_t *packet = (mavlink_debug_float_array_t *)msgbuf;
  192. packet->time_usec = time_usec;
  193. packet->array_id = array_id;
  194. mav_array_memcpy(packet->name, name, sizeof(char)*10);
  195. mav_array_memcpy(packet->data, data, sizeof(float)*58);
  196. _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);
  197. #endif
  198. }
  199. #endif
  200. #endif
  201. // MESSAGE DEBUG_FLOAT_ARRAY UNPACKING
  202. /**
  203. * @brief Get field time_usec from debug_float_array message
  204. *
  205. * @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.
  206. */
  207. static inline uint64_t mavlink_msg_debug_float_array_get_time_usec(const mavlink_message_t* msg)
  208. {
  209. return _MAV_RETURN_uint64_t(msg, 0);
  210. }
  211. /**
  212. * @brief Get field name from debug_float_array message
  213. *
  214. * @return Name, for human-friendly display in a Ground Control Station
  215. */
  216. static inline uint16_t mavlink_msg_debug_float_array_get_name(const mavlink_message_t* msg, char *name)
  217. {
  218. return _MAV_RETURN_char_array(msg, name, 10, 10);
  219. }
  220. /**
  221. * @brief Get field array_id from debug_float_array message
  222. *
  223. * @return Unique ID used to discriminate between arrays
  224. */
  225. static inline uint16_t mavlink_msg_debug_float_array_get_array_id(const mavlink_message_t* msg)
  226. {
  227. return _MAV_RETURN_uint16_t(msg, 8);
  228. }
  229. /**
  230. * @brief Get field data from debug_float_array message
  231. *
  232. * @return data
  233. */
  234. static inline uint16_t mavlink_msg_debug_float_array_get_data(const mavlink_message_t* msg, float *data)
  235. {
  236. return _MAV_RETURN_float_array(msg, data, 58, 20);
  237. }
  238. /**
  239. * @brief Decode a debug_float_array message into a struct
  240. *
  241. * @param msg The message to decode
  242. * @param debug_float_array C-struct to decode the message contents into
  243. */
  244. static inline void mavlink_msg_debug_float_array_decode(const mavlink_message_t* msg, mavlink_debug_float_array_t* debug_float_array)
  245. {
  246. #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  247. debug_float_array->time_usec = mavlink_msg_debug_float_array_get_time_usec(msg);
  248. debug_float_array->array_id = mavlink_msg_debug_float_array_get_array_id(msg);
  249. mavlink_msg_debug_float_array_get_name(msg, debug_float_array->name);
  250. mavlink_msg_debug_float_array_get_data(msg, debug_float_array->data);
  251. #else
  252. uint8_t len = msg->len < MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN? msg->len : MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN;
  253. memset(debug_float_array, 0, MAVLINK_MSG_ID_DEBUG_FLOAT_ARRAY_LEN);
  254. memcpy(debug_float_array, _MAV_PAYLOAD(msg), len);
  255. #endif
  256. }