lib/main/MAVLink/common/mavlink_msg_set_actuator_control_target.h

   1 #pragma once
   2 // MESSAGE SET_ACTUATOR_CONTROL_TARGET PACKING
   3
   4 #define MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET 139
   5
   6
   7 typedef struct __mavlink_set_actuator_control_target_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  float controls[8]; /*<  Actuator controls. Normed to -1..+1 where 0 is neutral position. Throttle for single rotation direction motors is 0..1, negative range for reverse direction. Standard mapping for attitude controls (group 0): (index 0-7): roll, pitch, yaw, throttle, flaps, spoilers, airbrakes, landing gear. Load a pass-through mixer to repurpose them as generic outputs.*/
  10  uint8_t group_mlx; /*<  Actuator group. The "_mlx" indicates this is a multi-instance message and a MAVLink parser should use this field to difference between instances.*/
  11  uint8_t target_system; /*<  System ID*/
  12  uint8_t target_component; /*<  Component ID*/
  13 } mavlink_set_actuator_control_target_t;
  14
  15 #define MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN 43
  16 #define MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN 43
  17 #define MAVLINK_MSG_ID_139_LEN 43
  18 #define MAVLINK_MSG_ID_139_MIN_LEN 43
  19
  20 #define MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC 168
  21 #define MAVLINK_MSG_ID_139_CRC 168
  22
  23 #define MAVLINK_MSG_SET_ACTUATOR_CONTROL_TARGET_FIELD_CONTROLS_LEN 8
  24
  25 #if MAVLINK_COMMAND_24BIT
  26 #define MAVLINK_MESSAGE_INFO_SET_ACTUATOR_CONTROL_TARGET { \
  27     139, \
  28     "SET_ACTUATOR_CONTROL_TARGET", \
  29     5, \
  30     {  { "time_usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_set_actuator_control_target_t, time_usec) }, \
  31          { "group_mlx", NULL, MAVLINK_TYPE_UINT8_T, 0, 40, offsetof(mavlink_set_actuator_control_target_t, group_mlx) }, \
  32          { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 41, offsetof(mavlink_set_actuator_control_target_t, target_system) }, \
  33          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 42, offsetof(mavlink_set_actuator_control_target_t, target_component) }, \
  34          { "controls", NULL, MAVLINK_TYPE_FLOAT, 8, 8, offsetof(mavlink_set_actuator_control_target_t, controls) }, \
  35          } \
  36 }
  37 #else
  38 #define MAVLINK_MESSAGE_INFO_SET_ACTUATOR_CONTROL_TARGET { \
  39     "SET_ACTUATOR_CONTROL_TARGET", \
  40     5, \
  41     {  { "time_usec", NULL, MAVLINK_TYPE_UINT64_T, 0, 0, offsetof(mavlink_set_actuator_control_target_t, time_usec) }, \
  42          { "group_mlx", NULL, MAVLINK_TYPE_UINT8_T, 0, 40, offsetof(mavlink_set_actuator_control_target_t, group_mlx) }, \
  43          { "target_system", NULL, MAVLINK_TYPE_UINT8_T, 0, 41, offsetof(mavlink_set_actuator_control_target_t, target_system) }, \
  44          { "target_component", NULL, MAVLINK_TYPE_UINT8_T, 0, 42, offsetof(mavlink_set_actuator_control_target_t, target_component) }, \
  45          { "controls", NULL, MAVLINK_TYPE_FLOAT, 8, 8, offsetof(mavlink_set_actuator_control_target_t, controls) }, \
  46          } \
  47 }
  48 #endif
  49
  50 /**
  51  * @brief Pack a set_actuator_control_target message
  52  * @param system_id ID of this system
  53  * @param component_id ID of this component (e.g. 200 for IMU)
  54  * @param msg The MAVLink message to compress the data into
  55  *
  56  * @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.
  57  * @param group_mlx  Actuator group. The "_mlx" indicates this is a multi-instance message and a MAVLink parser should use this field to difference between instances.
  58  * @param target_system  System ID
  59  * @param target_component  Component ID
  60  * @param controls  Actuator controls. Normed to -1..+1 where 0 is neutral position. Throttle for single rotation direction motors is 0..1, negative range for reverse direction. Standard mapping for attitude controls (group 0): (index 0-7): roll, pitch, yaw, throttle, flaps, spoilers, airbrakes, landing gear. Load a pass-through mixer to repurpose them as generic outputs.
  61  * @return length of the message in bytes (excluding serial stream start sign)
  62  */
  63 static inline uint16_t mavlink_msg_set_actuator_control_target_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg,
  64                                uint64_t time_usec, uint8_t group_mlx, uint8_t target_system, uint8_t target_component, const float *controls)
  65 {
  66 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  67     char buf[MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN];
  68     _mav_put_uint64_t(buf, 0, time_usec);
  69     _mav_put_uint8_t(buf, 40, group_mlx);
  70     _mav_put_uint8_t(buf, 41, target_system);
  71     _mav_put_uint8_t(buf, 42, target_component);
  72     _mav_put_float_array(buf, 8, controls, 8);
  73         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN);
  74 #else
  75     mavlink_set_actuator_control_target_t packet;
  76     packet.time_usec = time_usec;
  77     packet.group_mlx = group_mlx;
  78     packet.target_system = target_system;
  79     packet.target_component = target_component;
  80     mav_array_memcpy(packet.controls, controls, sizeof(float)*8);
  81         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN);
  82 #endif
  83
  84     msg->msgid = MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET;
  85     return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC);
  86 }
  87
  88 /**
  89  * @brief Pack a set_actuator_control_target message on a channel
  90  * @param system_id ID of this system
  91  * @param component_id ID of this component (e.g. 200 for IMU)
  92  * @param chan The MAVLink channel this message will be sent over
  93  * @param msg The MAVLink message to compress the data into
  94  * @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.
  95  * @param group_mlx  Actuator group. The "_mlx" indicates this is a multi-instance message and a MAVLink parser should use this field to difference between instances.
  96  * @param target_system  System ID
  97  * @param target_component  Component ID
  98  * @param controls  Actuator controls. Normed to -1..+1 where 0 is neutral position. Throttle for single rotation direction motors is 0..1, negative range for reverse direction. Standard mapping for attitude controls (group 0): (index 0-7): roll, pitch, yaw, throttle, flaps, spoilers, airbrakes, landing gear. Load a pass-through mixer to repurpose them as generic outputs.
  99  * @return length of the message in bytes (excluding serial stream start sign)
 100  */
 101 static inline uint16_t mavlink_msg_set_actuator_control_target_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
 102                                mavlink_message_t* msg,
 103                                    uint64_t time_usec,uint8_t group_mlx,uint8_t target_system,uint8_t target_component,const float *controls)
 104 {
 105 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 106     char buf[MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN];
 107     _mav_put_uint64_t(buf, 0, time_usec);
 108     _mav_put_uint8_t(buf, 40, group_mlx);
 109     _mav_put_uint8_t(buf, 41, target_system);
 110     _mav_put_uint8_t(buf, 42, target_component);
 111     _mav_put_float_array(buf, 8, controls, 8);
 112         memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN);
 113 #else
 114     mavlink_set_actuator_control_target_t packet;
 115     packet.time_usec = time_usec;
 116     packet.group_mlx = group_mlx;
 117     packet.target_system = target_system;
 118     packet.target_component = target_component;
 119     mav_array_memcpy(packet.controls, controls, sizeof(float)*8);
 120         memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN);
 121 #endif
 122
 123     msg->msgid = MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET;
 124     return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC);
 125 }
 126
 127 /**
 128  * @brief Encode a set_actuator_control_target struct
 129  *
 130  * @param system_id ID of this system
 131  * @param component_id ID of this component (e.g. 200 for IMU)
 132  * @param msg The MAVLink message to compress the data into
 133  * @param set_actuator_control_target C-struct to read the message contents from
 134  */
 135 static inline uint16_t mavlink_msg_set_actuator_control_target_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_actuator_control_target_t* set_actuator_control_target)
 136 {
 137     return mavlink_msg_set_actuator_control_target_pack(system_id, component_id, msg, set_actuator_control_target->time_usec, set_actuator_control_target->group_mlx, set_actuator_control_target->target_system, set_actuator_control_target->target_component, set_actuator_control_target->controls);
 138 }
 139
 140 /**
 141  * @brief Encode a set_actuator_control_target struct on a channel
 142  *
 143  * @param system_id ID of this system
 144  * @param component_id ID of this component (e.g. 200 for IMU)
 145  * @param chan The MAVLink channel this message will be sent over
 146  * @param msg The MAVLink message to compress the data into
 147  * @param set_actuator_control_target C-struct to read the message contents from
 148  */
 149 static inline uint16_t mavlink_msg_set_actuator_control_target_encode_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, const mavlink_set_actuator_control_target_t* set_actuator_control_target)
 150 {
 151     return mavlink_msg_set_actuator_control_target_pack_chan(system_id, component_id, chan, msg, set_actuator_control_target->time_usec, set_actuator_control_target->group_mlx, set_actuator_control_target->target_system, set_actuator_control_target->target_component, set_actuator_control_target->controls);
 152 }
 153
 154 /**
 155  * @brief Send a set_actuator_control_target message
 156  * @param chan MAVLink channel to send the message
 157  *
 158  * @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.
 159  * @param group_mlx  Actuator group. The "_mlx" indicates this is a multi-instance message and a MAVLink parser should use this field to difference between instances.
 160  * @param target_system  System ID
 161  * @param target_component  Component ID
 162  * @param controls  Actuator controls. Normed to -1..+1 where 0 is neutral position. Throttle for single rotation direction motors is 0..1, negative range for reverse direction. Standard mapping for attitude controls (group 0): (index 0-7): roll, pitch, yaw, throttle, flaps, spoilers, airbrakes, landing gear. Load a pass-through mixer to repurpose them as generic outputs.
 163  */
 164 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 165
 166 static inline void mavlink_msg_set_actuator_control_target_send(mavlink_channel_t chan, uint64_t time_usec, uint8_t group_mlx, uint8_t target_system, uint8_t target_component, const float *controls)
 167 {
 168 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 169     char buf[MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN];
 170     _mav_put_uint64_t(buf, 0, time_usec);
 171     _mav_put_uint8_t(buf, 40, group_mlx);
 172     _mav_put_uint8_t(buf, 41, target_system);
 173     _mav_put_uint8_t(buf, 42, target_component);
 174     _mav_put_float_array(buf, 8, controls, 8);
 175     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET, buf, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC);
 176 #else
 177     mavlink_set_actuator_control_target_t packet;
 178     packet.time_usec = time_usec;
 179     packet.group_mlx = group_mlx;
 180     packet.target_system = target_system;
 181     packet.target_component = target_component;
 182     mav_array_memcpy(packet.controls, controls, sizeof(float)*8);
 183     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET, (const char *)&packet, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC);
 184 #endif
 185 }
 186
 187 /**
 188  * @brief Send a set_actuator_control_target message
 189  * @param chan MAVLink channel to send the message
 190  * @param struct The MAVLink struct to serialize
 191  */
 192 static inline void mavlink_msg_set_actuator_control_target_send_struct(mavlink_channel_t chan, const mavlink_set_actuator_control_target_t* set_actuator_control_target)
 193 {
 194 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 195     mavlink_msg_set_actuator_control_target_send(chan, set_actuator_control_target->time_usec, set_actuator_control_target->group_mlx, set_actuator_control_target->target_system, set_actuator_control_target->target_component, set_actuator_control_target->controls);
 196 #else
 197     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET, (const char *)set_actuator_control_target, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC);
 198 #endif
 199 }
 200
 201 #if MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN <= MAVLINK_MAX_PAYLOAD_LEN
 202 /*
 203   This varient of _send() can be used to save stack space by re-using
 204   memory from the receive buffer.  The caller provides a
 205   mavlink_message_t which is the size of a full mavlink message. This
 206   is usually the receive buffer for the channel, and allows a reply to an
 207   incoming message with minimum stack space usage.
 208  */
 209 static inline void mavlink_msg_set_actuator_control_target_send_buf(mavlink_message_t *msgbuf, mavlink_channel_t chan,  uint64_t time_usec, uint8_t group_mlx, uint8_t target_system, uint8_t target_component, const float *controls)
 210 {
 211 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 212     char *buf = (char *)msgbuf;
 213     _mav_put_uint64_t(buf, 0, time_usec);
 214     _mav_put_uint8_t(buf, 40, group_mlx);
 215     _mav_put_uint8_t(buf, 41, target_system);
 216     _mav_put_uint8_t(buf, 42, target_component);
 217     _mav_put_float_array(buf, 8, controls, 8);
 218     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET, buf, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC);
 219 #else
 220     mavlink_set_actuator_control_target_t *packet = (mavlink_set_actuator_control_target_t *)msgbuf;
 221     packet->time_usec = time_usec;
 222     packet->group_mlx = group_mlx;
 223     packet->target_system = target_system;
 224     packet->target_component = target_component;
 225     mav_array_memcpy(packet->controls, controls, sizeof(float)*8);
 226     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET, (const char *)packet, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_CRC);
 227 #endif
 228 }
 229 #endif
 230
 231 #endif
 232
 233 // MESSAGE SET_ACTUATOR_CONTROL_TARGET UNPACKING
 234
 235
 236 /**
 237  * @brief Get field time_usec from set_actuator_control_target message
 238  *
 239  * @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.
 240  */
 241 static inline uint64_t mavlink_msg_set_actuator_control_target_get_time_usec(const mavlink_message_t* msg)
 242 {
 243     return _MAV_RETURN_uint64_t(msg,  0);
 244 }
 245
 246 /**
 247  * @brief Get field group_mlx from set_actuator_control_target message
 248  *
 249  * @return  Actuator group. The "_mlx" indicates this is a multi-instance message and a MAVLink parser should use this field to difference between instances.
 250  */
 251 static inline uint8_t mavlink_msg_set_actuator_control_target_get_group_mlx(const mavlink_message_t* msg)
 252 {
 253     return _MAV_RETURN_uint8_t(msg,  40);
 254 }
 255
 256 /**
 257  * @brief Get field target_system from set_actuator_control_target message
 258  *
 259  * @return  System ID
 260  */
 261 static inline uint8_t mavlink_msg_set_actuator_control_target_get_target_system(const mavlink_message_t* msg)
 262 {
 263     return _MAV_RETURN_uint8_t(msg,  41);
 264 }
 265
 266 /**
 267  * @brief Get field target_component from set_actuator_control_target message
 268  *
 269  * @return  Component ID
 270  */
 271 static inline uint8_t mavlink_msg_set_actuator_control_target_get_target_component(const mavlink_message_t* msg)
 272 {
 273     return _MAV_RETURN_uint8_t(msg,  42);
 274 }
 275
 276 /**
 277  * @brief Get field controls from set_actuator_control_target message
 278  *
 279  * @return  Actuator controls. Normed to -1..+1 where 0 is neutral position. Throttle for single rotation direction motors is 0..1, negative range for reverse direction. Standard mapping for attitude controls (group 0): (index 0-7): roll, pitch, yaw, throttle, flaps, spoilers, airbrakes, landing gear. Load a pass-through mixer to repurpose them as generic outputs.
 280  */
 281 static inline uint16_t mavlink_msg_set_actuator_control_target_get_controls(const mavlink_message_t* msg, float *controls)
 282 {
 283     return _MAV_RETURN_float_array(msg, controls, 8,  8);
 284 }
 285
 286 /**
 287  * @brief Decode a set_actuator_control_target message into a struct
 288  *
 289  * @param msg The message to decode
 290  * @param set_actuator_control_target C-struct to decode the message contents into
 291  */
 292 static inline void mavlink_msg_set_actuator_control_target_decode(const mavlink_message_t* msg, mavlink_set_actuator_control_target_t* set_actuator_control_target)
 293 {
 294 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 295     set_actuator_control_target->time_usec = mavlink_msg_set_actuator_control_target_get_time_usec(msg);
 296     mavlink_msg_set_actuator_control_target_get_controls(msg, set_actuator_control_target->controls);
 297     set_actuator_control_target->group_mlx = mavlink_msg_set_actuator_control_target_get_group_mlx(msg);
 298     set_actuator_control_target->target_system = mavlink_msg_set_actuator_control_target_get_target_system(msg);
 299     set_actuator_control_target->target_component = mavlink_msg_set_actuator_control_target_get_target_component(msg);
 300 #else
 301         uint8_t len = msg->len < MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN? msg->len : MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN;
 302         memset(set_actuator_control_target, 0, MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_LEN);
 303     memcpy(set_actuator_control_target, _MAV_PAYLOAD(msg), len);
 304 #endif
 305 }