flight/libraries/mavlink/v1.0/common/mavlink_msg_sys_status.h

   1 // MESSAGE SYS_STATUS PACKING
   2
   3 #define MAVLINK_MSG_ID_SYS_STATUS 1
   4
   5 typedef struct __mavlink_sys_status_t {
   6     uint32_t onboard_control_sensors_present; ///< Bitmask showing which onboard controllers and sensors are present. Value of 0: not present. Value of 1: present. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
   7     uint32_t onboard_control_sensors_enabled; ///< Bitmask showing which onboard controllers and sensors are enabled:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
   8     uint32_t onboard_control_sensors_health; ///< Bitmask showing which onboard controllers and sensors are operational or have an error:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
   9     uint16_t load; ///< Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
  10     uint16_t voltage_battery; ///< Battery voltage, in millivolts (1 = 1 millivolt)
  11     int16_t  current_battery; ///< Battery current, in 10*milliamperes (1 = 10 milliampere), -1: autopilot does not measure the current
  12     uint16_t drop_rate_comm; ///< Communication drops in percent, (0%: 0, 100%: 10'000), (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
  13     uint16_t errors_comm; ///< Communication errors (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
  14     uint16_t errors_count1; ///< Autopilot-specific errors
  15     uint16_t errors_count2; ///< Autopilot-specific errors
  16     uint16_t errors_count3; ///< Autopilot-specific errors
  17     uint16_t errors_count4; ///< Autopilot-specific errors
  18     int8_t   battery_remaining; ///< Remaining battery energy: (0%: 0, 100%: 100), -1: autopilot estimate the remaining battery
  19 } mavlink_sys_status_t;
  20
  21 #define MAVLINK_MSG_ID_SYS_STATUS_LEN 31
  22 #define MAVLINK_MSG_ID_1_LEN          31
  23
  24
  25 #define MAVLINK_MESSAGE_INFO_SYS_STATUS \
  26     { \
  27         "SYS_STATUS", \
  28         13, \
  29         { \
  30             { "onboard_control_sensors_present", "0x%04x", MAVLINK_TYPE_UINT32_T, 0, 0, offsetof(mavlink_sys_status_t, onboard_control_sensors_present) }, \
  31             { "onboard_control_sensors_enabled", "0x%04x", MAVLINK_TYPE_UINT32_T, 0, 4, offsetof(mavlink_sys_status_t, onboard_control_sensors_enabled) }, \
  32             { "onboard_control_sensors_health", "0x%04x", MAVLINK_TYPE_UINT32_T, 0, 8, offsetof(mavlink_sys_status_t, onboard_control_sensors_health) }, \
  33             { "load", NULL, MAVLINK_TYPE_UINT16_T, 0, 12, offsetof(mavlink_sys_status_t, load) }, \
  34             { "voltage_battery", NULL, MAVLINK_TYPE_UINT16_T, 0, 14, offsetof(mavlink_sys_status_t, voltage_battery) }, \
  35             { "current_battery", NULL, MAVLINK_TYPE_INT16_T, 0, 16, offsetof(mavlink_sys_status_t, current_battery) }, \
  36             { "drop_rate_comm", NULL, MAVLINK_TYPE_UINT16_T, 0, 18, offsetof(mavlink_sys_status_t, drop_rate_comm) }, \
  37             { "errors_comm", NULL, MAVLINK_TYPE_UINT16_T, 0, 20, offsetof(mavlink_sys_status_t, errors_comm) }, \
  38             { "errors_count1", NULL, MAVLINK_TYPE_UINT16_T, 0, 22, offsetof(mavlink_sys_status_t, errors_count1) }, \
  39             { "errors_count2", NULL, MAVLINK_TYPE_UINT16_T, 0, 24, offsetof(mavlink_sys_status_t, errors_count2) }, \
  40             { "errors_count3", NULL, MAVLINK_TYPE_UINT16_T, 0, 26, offsetof(mavlink_sys_status_t, errors_count3) }, \
  41             { "errors_count4", NULL, MAVLINK_TYPE_UINT16_T, 0, 28, offsetof(mavlink_sys_status_t, errors_count4) }, \
  42             { "battery_remaining", NULL, MAVLINK_TYPE_INT8_T, 0, 30, offsetof(mavlink_sys_status_t, battery_remaining) }, \
  43         } \
  44     }
  45
  46
  47 /**
  48  * @brief Pack a sys_status 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 onboard_control_sensors_present Bitmask showing which onboard controllers and sensors are present. Value of 0: not present. Value of 1: present. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
  54  * @param onboard_control_sensors_enabled Bitmask showing which onboard controllers and sensors are enabled:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
  55  * @param onboard_control_sensors_health Bitmask showing which onboard controllers and sensors are operational or have an error:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
  56  * @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
  57  * @param voltage_battery Battery voltage, in millivolts (1 = 1 millivolt)
  58  * @param current_battery Battery current, in 10*milliamperes (1 = 10 milliampere), -1: autopilot does not measure the current
  59  * @param battery_remaining Remaining battery energy: (0%: 0, 100%: 100), -1: autopilot estimate the remaining battery
  60  * @param drop_rate_comm Communication drops in percent, (0%: 0, 100%: 10'000), (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
  61  * @param errors_comm Communication errors (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
  62  * @param errors_count1 Autopilot-specific errors
  63  * @param errors_count2 Autopilot-specific errors
  64  * @param errors_count3 Autopilot-specific errors
  65  * @param errors_count4 Autopilot-specific errors
  66  * @return length of the message in bytes (excluding serial stream start sign)
  67  */
  68 static inline uint16_t mavlink_msg_sys_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t *msg,
  69                                                    uint32_t onboard_control_sensors_present, uint32_t onboard_control_sensors_enabled, uint32_t onboard_control_sensors_health, uint16_t load, uint16_t voltage_battery, int16_t current_battery, int8_t battery_remaining, uint16_t drop_rate_comm, uint16_t errors_comm, uint16_t errors_count1, uint16_t errors_count2, uint16_t errors_count3, uint16_t errors_count4)
  70 {
  71 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
  72     char buf[31];
  73     _mav_put_uint32_t(buf, 0, onboard_control_sensors_present);
  74     _mav_put_uint32_t(buf, 4, onboard_control_sensors_enabled);
  75     _mav_put_uint32_t(buf, 8, onboard_control_sensors_health);
  76     _mav_put_uint16_t(buf, 12, load);
  77     _mav_put_uint16_t(buf, 14, voltage_battery);
  78     _mav_put_int16_t(buf, 16, current_battery);
  79     _mav_put_uint16_t(buf, 18, drop_rate_comm);
  80     _mav_put_uint16_t(buf, 20, errors_comm);
  81     _mav_put_uint16_t(buf, 22, errors_count1);
  82     _mav_put_uint16_t(buf, 24, errors_count2);
  83     _mav_put_uint16_t(buf, 26, errors_count3);
  84     _mav_put_uint16_t(buf, 28, errors_count4);
  85     _mav_put_int8_t(buf, 30, battery_remaining);
  86
  87     memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, 31);
  88 #else
  89     mavlink_sys_status_t packet;
  90     packet.onboard_control_sensors_present = onboard_control_sensors_present;
  91     packet.onboard_control_sensors_enabled = onboard_control_sensors_enabled;
  92     packet.onboard_control_sensors_health  = onboard_control_sensors_health;
  93     packet.load = load;
  94     packet.voltage_battery   = voltage_battery;
  95     packet.current_battery   = current_battery;
  96     packet.drop_rate_comm    = drop_rate_comm;
  97     packet.errors_comm       = errors_comm;
  98     packet.errors_count1     = errors_count1;
  99     packet.errors_count2     = errors_count2;
 100     packet.errors_count3     = errors_count3;
 101     packet.errors_count4     = errors_count4;
 102     packet.battery_remaining = battery_remaining;
 103
 104     memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, 31);
 105 #endif // if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 106
 107     msg->msgid = MAVLINK_MSG_ID_SYS_STATUS;
 108     return mavlink_finalize_message(msg, system_id, component_id, 31, 124);
 109 }
 110
 111 /**
 112  * @brief Pack a sys_status message on a channel
 113  * @param system_id ID of this system
 114  * @param component_id ID of this component (e.g. 200 for IMU)
 115  * @param chan The MAVLink channel this message was sent over
 116  * @param msg The MAVLink message to compress the data into
 117  * @param onboard_control_sensors_present Bitmask showing which onboard controllers and sensors are present. Value of 0: not present. Value of 1: present. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 118  * @param onboard_control_sensors_enabled Bitmask showing which onboard controllers and sensors are enabled:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 119  * @param onboard_control_sensors_health Bitmask showing which onboard controllers and sensors are operational or have an error:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 120  * @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
 121  * @param voltage_battery Battery voltage, in millivolts (1 = 1 millivolt)
 122  * @param current_battery Battery current, in 10*milliamperes (1 = 10 milliampere), -1: autopilot does not measure the current
 123  * @param battery_remaining Remaining battery energy: (0%: 0, 100%: 100), -1: autopilot estimate the remaining battery
 124  * @param drop_rate_comm Communication drops in percent, (0%: 0, 100%: 10'000), (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
 125  * @param errors_comm Communication errors (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
 126  * @param errors_count1 Autopilot-specific errors
 127  * @param errors_count2 Autopilot-specific errors
 128  * @param errors_count3 Autopilot-specific errors
 129  * @param errors_count4 Autopilot-specific errors
 130  * @return length of the message in bytes (excluding serial stream start sign)
 131  */
 132 static inline uint16_t mavlink_msg_sys_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan,
 133                                                         mavlink_message_t *msg,
 134                                                         uint32_t onboard_control_sensors_present, uint32_t onboard_control_sensors_enabled, uint32_t onboard_control_sensors_health, uint16_t load, uint16_t voltage_battery, int16_t current_battery, int8_t battery_remaining, uint16_t drop_rate_comm, uint16_t errors_comm, uint16_t errors_count1, uint16_t errors_count2, uint16_t errors_count3, uint16_t errors_count4)
 135 {
 136 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 137     char buf[31];
 138     _mav_put_uint32_t(buf, 0, onboard_control_sensors_present);
 139     _mav_put_uint32_t(buf, 4, onboard_control_sensors_enabled);
 140     _mav_put_uint32_t(buf, 8, onboard_control_sensors_health);
 141     _mav_put_uint16_t(buf, 12, load);
 142     _mav_put_uint16_t(buf, 14, voltage_battery);
 143     _mav_put_int16_t(buf, 16, current_battery);
 144     _mav_put_uint16_t(buf, 18, drop_rate_comm);
 145     _mav_put_uint16_t(buf, 20, errors_comm);
 146     _mav_put_uint16_t(buf, 22, errors_count1);
 147     _mav_put_uint16_t(buf, 24, errors_count2);
 148     _mav_put_uint16_t(buf, 26, errors_count3);
 149     _mav_put_uint16_t(buf, 28, errors_count4);
 150     _mav_put_int8_t(buf, 30, battery_remaining);
 151
 152     memcpy(_MAV_PAYLOAD_NON_CONST(msg), buf, 31);
 153 #else
 154     mavlink_sys_status_t packet;
 155     packet.onboard_control_sensors_present = onboard_control_sensors_present;
 156     packet.onboard_control_sensors_enabled = onboard_control_sensors_enabled;
 157     packet.onboard_control_sensors_health  = onboard_control_sensors_health;
 158     packet.load = load;
 159     packet.voltage_battery   = voltage_battery;
 160     packet.current_battery   = current_battery;
 161     packet.drop_rate_comm    = drop_rate_comm;
 162     packet.errors_comm       = errors_comm;
 163     packet.errors_count1     = errors_count1;
 164     packet.errors_count2     = errors_count2;
 165     packet.errors_count3     = errors_count3;
 166     packet.errors_count4     = errors_count4;
 167     packet.battery_remaining = battery_remaining;
 168
 169     memcpy(_MAV_PAYLOAD_NON_CONST(msg), &packet, 31);
 170 #endif // if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 171
 172     msg->msgid = MAVLINK_MSG_ID_SYS_STATUS;
 173     return mavlink_finalize_message_chan(msg, system_id, component_id, chan, 31, 124);
 174 }
 175
 176 /**
 177  * @brief Encode a sys_status struct into a message
 178  *
 179  * @param system_id ID of this system
 180  * @param component_id ID of this component (e.g. 200 for IMU)
 181  * @param msg The MAVLink message to compress the data into
 182  * @param sys_status C-struct to read the message contents from
 183  */
 184 static inline uint16_t mavlink_msg_sys_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t *msg, const mavlink_sys_status_t *sys_status)
 185 {
 186     return mavlink_msg_sys_status_pack(system_id, component_id, msg, sys_status->onboard_control_sensors_present, sys_status->onboard_control_sensors_enabled, sys_status->onboard_control_sensors_health, sys_status->load, sys_status->voltage_battery, sys_status->current_battery, sys_status->battery_remaining, sys_status->drop_rate_comm, sys_status->errors_comm, sys_status->errors_count1, sys_status->errors_count2, sys_status->errors_count3, sys_status->errors_count4);
 187 }
 188
 189 /**
 190  * @brief Send a sys_status message
 191  * @param chan MAVLink channel to send the message
 192  *
 193  * @param onboard_control_sensors_present Bitmask showing which onboard controllers and sensors are present. Value of 0: not present. Value of 1: present. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 194  * @param onboard_control_sensors_enabled Bitmask showing which onboard controllers and sensors are enabled:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 195  * @param onboard_control_sensors_health Bitmask showing which onboard controllers and sensors are operational or have an error:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 196  * @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
 197  * @param voltage_battery Battery voltage, in millivolts (1 = 1 millivolt)
 198  * @param current_battery Battery current, in 10*milliamperes (1 = 10 milliampere), -1: autopilot does not measure the current
 199  * @param battery_remaining Remaining battery energy: (0%: 0, 100%: 100), -1: autopilot estimate the remaining battery
 200  * @param drop_rate_comm Communication drops in percent, (0%: 0, 100%: 10'000), (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
 201  * @param errors_comm Communication errors (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
 202  * @param errors_count1 Autopilot-specific errors
 203  * @param errors_count2 Autopilot-specific errors
 204  * @param errors_count3 Autopilot-specific errors
 205  * @param errors_count4 Autopilot-specific errors
 206  */
 207 #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 208
 209 static inline void mavlink_msg_sys_status_send(mavlink_channel_t chan, uint32_t onboard_control_sensors_present, uint32_t onboard_control_sensors_enabled, uint32_t onboard_control_sensors_health, uint16_t load, uint16_t voltage_battery, int16_t current_battery, int8_t battery_remaining, uint16_t drop_rate_comm, uint16_t errors_comm, uint16_t errors_count1, uint16_t errors_count2, uint16_t errors_count3, uint16_t errors_count4)
 210 {
 211 #if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 212     char buf[31];
 213     _mav_put_uint32_t(buf, 0, onboard_control_sensors_present);
 214     _mav_put_uint32_t(buf, 4, onboard_control_sensors_enabled);
 215     _mav_put_uint32_t(buf, 8, onboard_control_sensors_health);
 216     _mav_put_uint16_t(buf, 12, load);
 217     _mav_put_uint16_t(buf, 14, voltage_battery);
 218     _mav_put_int16_t(buf, 16, current_battery);
 219     _mav_put_uint16_t(buf, 18, drop_rate_comm);
 220     _mav_put_uint16_t(buf, 20, errors_comm);
 221     _mav_put_uint16_t(buf, 22, errors_count1);
 222     _mav_put_uint16_t(buf, 24, errors_count2);
 223     _mav_put_uint16_t(buf, 26, errors_count3);
 224     _mav_put_uint16_t(buf, 28, errors_count4);
 225     _mav_put_int8_t(buf, 30, battery_remaining);
 226
 227     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYS_STATUS, buf, 31, 124);
 228 #else
 229     mavlink_sys_status_t packet;
 230     packet.onboard_control_sensors_present = onboard_control_sensors_present;
 231     packet.onboard_control_sensors_enabled = onboard_control_sensors_enabled;
 232     packet.onboard_control_sensors_health  = onboard_control_sensors_health;
 233     packet.load = load;
 234     packet.voltage_battery   = voltage_battery;
 235     packet.current_battery   = current_battery;
 236     packet.drop_rate_comm    = drop_rate_comm;
 237     packet.errors_comm       = errors_comm;
 238     packet.errors_count1     = errors_count1;
 239     packet.errors_count2     = errors_count2;
 240     packet.errors_count3     = errors_count3;
 241     packet.errors_count4     = errors_count4;
 242     packet.battery_remaining = battery_remaining;
 243
 244     _mav_finalize_message_chan_send(chan, MAVLINK_MSG_ID_SYS_STATUS, (const char *)&packet, 31, 124);
 245 #endif // if MAVLINK_NEED_BYTE_SWAP || !MAVLINK_ALIGNED_FIELDS
 246 }
 247
 248 #endif // ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
 249
 250 // MESSAGE SYS_STATUS UNPACKING
 251
 252
 253 /**
 254  * @brief Get field onboard_control_sensors_present from sys_status message
 255  *
 256  * @return Bitmask showing which onboard controllers and sensors are present. Value of 0: not present. Value of 1: present. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 257  */
 258 static inline uint32_t mavlink_msg_sys_status_get_onboard_control_sensors_present(const mavlink_message_t *msg)
 259 {
 260     return _MAV_RETURN_uint32_t(msg, 0);
 261 }
 262
 263 /**
 264  * @brief Get field onboard_control_sensors_enabled from sys_status message
 265  *
 266  * @return Bitmask showing which onboard controllers and sensors are enabled:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 267  */
 268 static inline uint32_t mavlink_msg_sys_status_get_onboard_control_sensors_enabled(const mavlink_message_t *msg)
 269 {
 270     return _MAV_RETURN_uint32_t(msg, 4);
 271 }
 272
 273 /**
 274  * @brief Get field onboard_control_sensors_health from sys_status message
 275  *
 276  * @return Bitmask showing which onboard controllers and sensors are operational or have an error:  Value of 0: not enabled. Value of 1: enabled. Indices: 0: 3D gyro, 1: 3D acc, 2: 3D mag, 3: absolute pressure, 4: differential pressure, 5: GPS, 6: optical flow, 7: computer vision position, 8: laser based position, 9: external ground-truth (Vicon or Leica). Controllers: 10: 3D angular rate control 11: attitude stabilization, 12: yaw position, 13: z/altitude control, 14: x/y position control, 15: motor outputs / control
 277  */
 278 static inline uint32_t mavlink_msg_sys_status_get_onboard_control_sensors_health(const mavlink_message_t *msg)
 279 {
 280     return _MAV_RETURN_uint32_t(msg, 8);
 281 }
 282
 283 /**
 284  * @brief Get field load from sys_status message
 285  *
 286  * @return Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
 287  */
 288 static inline uint16_t mavlink_msg_sys_status_get_load(const mavlink_message_t *msg)
 289 {
 290     return _MAV_RETURN_uint16_t(msg, 12);
 291 }
 292
 293 /**
 294  * @brief Get field voltage_battery from sys_status message
 295  *
 296  * @return Battery voltage, in millivolts (1 = 1 millivolt)
 297  */
 298 static inline uint16_t mavlink_msg_sys_status_get_voltage_battery(const mavlink_message_t *msg)
 299 {
 300     return _MAV_RETURN_uint16_t(msg, 14);
 301 }
 302
 303 /**
 304  * @brief Get field current_battery from sys_status message
 305  *
 306  * @return Battery current, in 10*milliamperes (1 = 10 milliampere), -1: autopilot does not measure the current
 307  */
 308 static inline int16_t mavlink_msg_sys_status_get_current_battery(const mavlink_message_t *msg)
 309 {
 310     return _MAV_RETURN_int16_t(msg, 16);
 311 }
 312
 313 /**
 314  * @brief Get field battery_remaining from sys_status message
 315  *
 316  * @return Remaining battery energy: (0%: 0, 100%: 100), -1: autopilot estimate the remaining battery
 317  */
 318 static inline int8_t mavlink_msg_sys_status_get_battery_remaining(const mavlink_message_t *msg)
 319 {
 320     return _MAV_RETURN_int8_t(msg, 30);
 321 }
 322
 323 /**
 324  * @brief Get field drop_rate_comm from sys_status message
 325  *
 326  * @return Communication drops in percent, (0%: 0, 100%: 10'000), (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
 327  */
 328 static inline uint16_t mavlink_msg_sys_status_get_drop_rate_comm(const mavlink_message_t *msg)
 329 {
 330     return _MAV_RETURN_uint16_t(msg, 18);
 331 }
 332
 333 /**
 334  * @brief Get field errors_comm from sys_status message
 335  *
 336  * @return Communication errors (UART, I2C, SPI, CAN), dropped packets on all links (packets that were corrupted on reception on the MAV)
 337  */
 338 static inline uint16_t mavlink_msg_sys_status_get_errors_comm(const mavlink_message_t *msg)
 339 {
 340     return _MAV_RETURN_uint16_t(msg, 20);
 341 }
 342
 343 /**
 344  * @brief Get field errors_count1 from sys_status message
 345  *
 346  * @return Autopilot-specific errors
 347  */
 348 static inline uint16_t mavlink_msg_sys_status_get_errors_count1(const mavlink_message_t *msg)
 349 {
 350     return _MAV_RETURN_uint16_t(msg, 22);
 351 }
 352
 353 /**
 354  * @brief Get field errors_count2 from sys_status message
 355  *
 356  * @return Autopilot-specific errors
 357  */
 358 static inline uint16_t mavlink_msg_sys_status_get_errors_count2(const mavlink_message_t *msg)
 359 {
 360     return _MAV_RETURN_uint16_t(msg, 24);
 361 }
 362
 363 /**
 364  * @brief Get field errors_count3 from sys_status message
 365  *
 366  * @return Autopilot-specific errors
 367  */
 368 static inline uint16_t mavlink_msg_sys_status_get_errors_count3(const mavlink_message_t *msg)
 369 {
 370     return _MAV_RETURN_uint16_t(msg, 26);
 371 }
 372
 373 /**
 374  * @brief Get field errors_count4 from sys_status message
 375  *
 376  * @return Autopilot-specific errors
 377  */
 378 static inline uint16_t mavlink_msg_sys_status_get_errors_count4(const mavlink_message_t *msg)
 379 {
 380     return _MAV_RETURN_uint16_t(msg, 28);
 381 }
 382
 383 /**
 384  * @brief Decode a sys_status message into a struct
 385  *
 386  * @param msg The message to decode
 387  * @param sys_status C-struct to decode the message contents into
 388  */
 389 static inline void mavlink_msg_sys_status_decode(const mavlink_message_t *msg, mavlink_sys_status_t *sys_status)
 390 {
 391 #if MAVLINK_NEED_BYTE_SWAP
 392     sys_status->onboard_control_sensors_present = mavlink_msg_sys_status_get_onboard_control_sensors_present(msg);
 393     sys_status->onboard_control_sensors_enabled = mavlink_msg_sys_status_get_onboard_control_sensors_enabled(msg);
 394     sys_status->onboard_control_sensors_health  = mavlink_msg_sys_status_get_onboard_control_sensors_health(msg);
 395     sys_status->load = mavlink_msg_sys_status_get_load(msg);
 396     sys_status->voltage_battery   = mavlink_msg_sys_status_get_voltage_battery(msg);
 397     sys_status->current_battery   = mavlink_msg_sys_status_get_current_battery(msg);
 398     sys_status->drop_rate_comm    = mavlink_msg_sys_status_get_drop_rate_comm(msg);
 399     sys_status->errors_comm       = mavlink_msg_sys_status_get_errors_comm(msg);
 400     sys_status->errors_count1     = mavlink_msg_sys_status_get_errors_count1(msg);
 401     sys_status->errors_count2     = mavlink_msg_sys_status_get_errors_count2(msg);
 402     sys_status->errors_count3     = mavlink_msg_sys_status_get_errors_count3(msg);
 403     sys_status->errors_count4     = mavlink_msg_sys_status_get_errors_count4(msg);
 404     sys_status->battery_remaining = mavlink_msg_sys_status_get_battery_remaining(msg);
 405 #else
 406     memcpy(sys_status, _MAV_PAYLOAD(msg), 31);
 407 #endif
 408 }