zhaohuwei
/
QG4
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Prepping merge

QGC4.4
lm 14 years ago
parent
b303e674b3
commit
ce112d3a92
13 changed files with 0 additions and 2299 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 196
      thirdParty/mavlink/include/common/mavlink_msg_attitude_controller_output.h
  2. 141
      thirdParty/mavlink/include/common/mavlink_msg_cmd_ack.h
  3. 196
      thirdParty/mavlink/include/common/mavlink_msg_position_controller_output.h
  4. 178
      thirdParty/mavlink/include/common/mavlink_msg_roll_pitch_yaw_setpoint.h
  5. 178
      thirdParty/mavlink/include/common/mavlink_msg_roll_pitch_yaw_speed_setpoint.h
  6. 196
      thirdParty/mavlink/include/common/mavlink_msg_set_roll_pitch_yaw.h
  7. 196
      thirdParty/mavlink/include/common/mavlink_msg_set_roll_pitch_yaw_speed.h
  8. 41
      thirdParty/mavlink/include/documentation.dox
  9. 183
      thirdParty/mavlink/include/mavlink_checksum.h
  10. 21
      thirdParty/mavlink/include/mavlink_data.h
  11. 135
      thirdParty/mavlink/include/mavlink_options.h
  12. 425
      thirdParty/mavlink/include/mavlink_protocol.h
  13. 213
      thirdParty/mavlink/include/pixhawk/mavlink_msg_aux_status.h

196
thirdParty/mavlink/include/common/mavlink_msg_attitude_controller_output.h vendored
Unescape View File

@ -1,196 +0,0 @@ @@ -1,196 +0,0 @@
// MESSAGE ATTITUDE_CONTROLLER_OUTPUT PACKING
#define MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT 60
#define MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT_LEN 5
#define MAVLINK_MSG_60_LEN 5
typedef struct __mavlink_attitude_controller_output_t
{
uint8_t enabled; ///< 1: enabled, 0: disabled
int8_t roll; ///< Attitude roll: -128: -100%, 127: +100%
int8_t pitch; ///< Attitude pitch: -128: -100%, 127: +100%
int8_t yaw; ///< Attitude yaw: -128: -100%, 127: +100%
int8_t thrust; ///< Attitude thrust: -128: -100%, 127: +100%
} mavlink_attitude_controller_output_t;
/**
* @brief Pack a attitude_controller_output message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param enabled 1: enabled, 0: disabled
* @param roll Attitude roll: -128: -100%, 127: +100%
* @param pitch Attitude pitch: -128: -100%, 127: +100%
* @param yaw Attitude yaw: -128: -100%, 127: +100%
* @param thrust Attitude thrust: -128: -100%, 127: +100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_attitude_controller_output_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint8_t enabled, int8_t roll, int8_t pitch, int8_t yaw, int8_t thrust)
{
mavlink_attitude_controller_output_t *p = (mavlink_attitude_controller_output_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT;
p->enabled = enabled; // uint8_t:1: enabled, 0: disabled
p->roll = roll; // int8_t:Attitude roll: -128: -100%, 127: +100%
p->pitch = pitch; // int8_t:Attitude pitch: -128: -100%, 127: +100%
p->yaw = yaw; // int8_t:Attitude yaw: -128: -100%, 127: +100%
p->thrust = thrust; // int8_t:Attitude thrust: -128: -100%, 127: +100%
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT_LEN);
}
/**
* @brief Pack a attitude_controller_output message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param enabled 1: enabled, 0: disabled
* @param roll Attitude roll: -128: -100%, 127: +100%
* @param pitch Attitude pitch: -128: -100%, 127: +100%
* @param yaw Attitude yaw: -128: -100%, 127: +100%
* @param thrust Attitude thrust: -128: -100%, 127: +100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_attitude_controller_output_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint8_t enabled, int8_t roll, int8_t pitch, int8_t yaw, int8_t thrust)
{
mavlink_attitude_controller_output_t *p = (mavlink_attitude_controller_output_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT;
p->enabled = enabled; // uint8_t:1: enabled, 0: disabled
p->roll = roll; // int8_t:Attitude roll: -128: -100%, 127: +100%
p->pitch = pitch; // int8_t:Attitude pitch: -128: -100%, 127: +100%
p->yaw = yaw; // int8_t:Attitude yaw: -128: -100%, 127: +100%
p->thrust = thrust; // int8_t:Attitude thrust: -128: -100%, 127: +100%
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT_LEN);
}
/**
* @brief Encode a attitude_controller_output struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param attitude_controller_output C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_attitude_controller_output_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_attitude_controller_output_t* attitude_controller_output)
{
return mavlink_msg_attitude_controller_output_pack(system_id, component_id, msg, attitude_controller_output->enabled, attitude_controller_output->roll, attitude_controller_output->pitch, attitude_controller_output->yaw, attitude_controller_output->thrust);
}
/**
* @brief Send a attitude_controller_output message
* @param chan MAVLink channel to send the message
*
* @param enabled 1: enabled, 0: disabled
* @param roll Attitude roll: -128: -100%, 127: +100%
* @param pitch Attitude pitch: -128: -100%, 127: +100%
* @param yaw Attitude yaw: -128: -100%, 127: +100%
* @param thrust Attitude thrust: -128: -100%, 127: +100%
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_attitude_controller_output_send(mavlink_channel_t chan, uint8_t enabled, int8_t roll, int8_t pitch, int8_t yaw, int8_t thrust)
{
mavlink_header_t hdr;
mavlink_attitude_controller_output_t payload;
uint16_t checksum;
mavlink_attitude_controller_output_t *p = &payload;
p->enabled = enabled; // uint8_t:1: enabled, 0: disabled
p->roll = roll; // int8_t:Attitude roll: -128: -100%, 127: +100%
p->pitch = pitch; // int8_t:Attitude pitch: -128: -100%, 127: +100%
p->yaw = yaw; // int8_t:Attitude yaw: -128: -100%, 127: +100%
p->thrust = thrust; // int8_t:Attitude thrust: -128: -100%, 127: +100%
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT_LEN;
hdr.msgid = MAVLINK_MSG_ID_ATTITUDE_CONTROLLER_OUTPUT;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
crc_init(&checksum);
checksum = crc_calculate_mem((uint8_t *)&hdr.len, &checksum, MAVLINK_CORE_HEADER_LEN);
checksum = crc_calculate_mem((uint8_t *)&payload, &checksum, hdr.len );
hdr.ck_a = (uint8_t)(checksum & 0xFF); ///< Low byte
hdr.ck_b = (uint8_t)(checksum >> 8); ///< High byte
mavlink_send_mem(chan, (uint8_t *)&payload, hdr.len);
mavlink_send_mem(chan, (uint8_t *)&hdr.ck_a, MAVLINK_NUM_CHECKSUM_BYTES);
}
#endif
// MESSAGE ATTITUDE_CONTROLLER_OUTPUT UNPACKING
/**
* @brief Get field enabled from attitude_controller_output message
*
* @return 1: enabled, 0: disabled
*/
static inline uint8_t mavlink_msg_attitude_controller_output_get_enabled(const mavlink_message_t* msg)
{
mavlink_attitude_controller_output_t *p = (mavlink_attitude_controller_output_t *)&msg->payload[0];
return (uint8_t)(p->enabled);
}
/**
* @brief Get field roll from attitude_controller_output message
*
* @return Attitude roll: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_attitude_controller_output_get_roll(const mavlink_message_t* msg)
{
mavlink_attitude_controller_output_t *p = (mavlink_attitude_controller_output_t *)&msg->payload[0];
return (int8_t)(p->roll);
}
/**
* @brief Get field pitch from attitude_controller_output message
*
* @return Attitude pitch: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_attitude_controller_output_get_pitch(const mavlink_message_t* msg)
{
mavlink_attitude_controller_output_t *p = (mavlink_attitude_controller_output_t *)&msg->payload[0];
return (int8_t)(p->pitch);
}
/**
* @brief Get field yaw from attitude_controller_output message
*
* @return Attitude yaw: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_attitude_controller_output_get_yaw(const mavlink_message_t* msg)
{
mavlink_attitude_controller_output_t *p = (mavlink_attitude_controller_output_t *)&msg->payload[0];
return (int8_t)(p->yaw);
}
/**
* @brief Get field thrust from attitude_controller_output message
*
* @return Attitude thrust: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_attitude_controller_output_get_thrust(const mavlink_message_t* msg)
{
mavlink_attitude_controller_output_t *p = (mavlink_attitude_controller_output_t *)&msg->payload[0];
return (int8_t)(p->thrust);
}
/**
* @brief Decode a attitude_controller_output message into a struct
*
* @param msg The message to decode
* @param attitude_controller_output C-struct to decode the message contents into
*/
static inline void mavlink_msg_attitude_controller_output_decode(const mavlink_message_t* msg, mavlink_attitude_controller_output_t* attitude_controller_output)
{
memcpy( attitude_controller_output, msg->payload, sizeof(mavlink_attitude_controller_output_t));
}

141
thirdParty/mavlink/include/common/mavlink_msg_cmd_ack.h vendored
Unescape View File

@ -1,141 +0,0 @@ @@ -1,141 +0,0 @@
// MESSAGE CMD_ACK PACKING
#define MAVLINK_MSG_ID_CMD_ACK 9
#define MAVLINK_MSG_ID_CMD_ACK_LEN 2
#define MAVLINK_MSG_9_LEN 2
#define MAVLINK_MSG_ID_CMD_ACK_KEY 0x90
#define MAVLINK_MSG_9_KEY 0x90
typedef struct __mavlink_cmd_ack_t
{
uint8_t cmd; ///< The MAV_CMD ID
uint8_t result; ///< 0: Action DENIED, 1: Action executed
} mavlink_cmd_ack_t;
/**
* @brief Pack a cmd_ack message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param cmd The MAV_CMD ID
* @param result 0: Action DENIED, 1: Action executed
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_cmd_ack_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint8_t cmd, uint8_t result)
{
mavlink_cmd_ack_t *p = (mavlink_cmd_ack_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_CMD_ACK;
p->cmd = cmd; // uint8_t:The MAV_CMD ID
p->result = result; // uint8_t:0: Action DENIED, 1: Action executed
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_CMD_ACK_LEN);
}
/**
* @brief Pack a cmd_ack message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param cmd The MAV_CMD ID
* @param result 0: Action DENIED, 1: Action executed
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_cmd_ack_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint8_t cmd, uint8_t result)
{
mavlink_cmd_ack_t *p = (mavlink_cmd_ack_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_CMD_ACK;
p->cmd = cmd; // uint8_t:The MAV_CMD ID
p->result = result; // uint8_t:0: Action DENIED, 1: Action executed
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_CMD_ACK_LEN);
}
/**
* @brief Encode a cmd_ack struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param cmd_ack C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_cmd_ack_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_cmd_ack_t* cmd_ack)
{
return mavlink_msg_cmd_ack_pack(system_id, component_id, msg, cmd_ack->cmd, cmd_ack->result);
}
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
/**
* @brief Send a cmd_ack message
* @param chan MAVLink channel to send the message
*
* @param cmd The MAV_CMD ID
* @param result 0: Action DENIED, 1: Action executed
*/
static inline void mavlink_msg_cmd_ack_send(mavlink_channel_t chan, uint8_t cmd, uint8_t result)
{
mavlink_header_t hdr;
mavlink_cmd_ack_t payload;
MAVLINK_BUFFER_CHECK_START( chan, MAVLINK_MSG_ID_CMD_ACK_LEN )
payload.cmd = cmd; // uint8_t:The MAV_CMD ID
payload.result = result; // uint8_t:0: Action DENIED, 1: Action executed
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_CMD_ACK_LEN;
hdr.msgid = MAVLINK_MSG_ID_CMD_ACK;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
mavlink_send_mem(chan, (uint8_t *)&payload, sizeof(payload) );
crc_init(&hdr.ck);
crc_calculate_mem((uint8_t *)&hdr.len, &hdr.ck, MAVLINK_CORE_HEADER_LEN);
crc_calculate_mem((uint8_t *)&payload, &hdr.ck, hdr.len );
crc_accumulate( 0x90, &hdr.ck); /// include key in X25 checksum
mavlink_send_mem(chan, (uint8_t *)&hdr.ck, MAVLINK_NUM_CHECKSUM_BYTES);
MAVLINK_BUFFER_CHECK_END
}
#endif
// MESSAGE CMD_ACK UNPACKING
/**
* @brief Get field cmd from cmd_ack message
*
* @return The MAV_CMD ID
*/
static inline uint8_t mavlink_msg_cmd_ack_get_cmd(const mavlink_message_t* msg)
{
mavlink_cmd_ack_t *p = (mavlink_cmd_ack_t *)&msg->payload[0];
return (uint8_t)(p->cmd);
}
/**
* @brief Get field result from cmd_ack message
*
* @return 0: Action DENIED, 1: Action executed
*/
static inline uint8_t mavlink_msg_cmd_ack_get_result(const mavlink_message_t* msg)
{
mavlink_cmd_ack_t *p = (mavlink_cmd_ack_t *)&msg->payload[0];
return (uint8_t)(p->result);
}
/**
* @brief Decode a cmd_ack message into a struct
*
* @param msg The message to decode
* @param cmd_ack C-struct to decode the message contents into
*/
static inline void mavlink_msg_cmd_ack_decode(const mavlink_message_t* msg, mavlink_cmd_ack_t* cmd_ack)
{
memcpy( cmd_ack, msg->payload, sizeof(mavlink_cmd_ack_t));
}

196
thirdParty/mavlink/include/common/mavlink_msg_position_controller_output.h vendored
Unescape View File

@ -1,196 +0,0 @@ @@ -1,196 +0,0 @@
// MESSAGE POSITION_CONTROLLER_OUTPUT PACKING
#define MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT 61
#define MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT_LEN 5
#define MAVLINK_MSG_61_LEN 5
typedef struct __mavlink_position_controller_output_t
{
uint8_t enabled; ///< 1: enabled, 0: disabled
int8_t x; ///< Position x: -128: -100%, 127: +100%
int8_t y; ///< Position y: -128: -100%, 127: +100%
int8_t z; ///< Position z: -128: -100%, 127: +100%
int8_t yaw; ///< Position yaw: -128: -100%, 127: +100%
} mavlink_position_controller_output_t;
/**
* @brief Pack a position_controller_output message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param enabled 1: enabled, 0: disabled
* @param x Position x: -128: -100%, 127: +100%
* @param y Position y: -128: -100%, 127: +100%
* @param z Position z: -128: -100%, 127: +100%
* @param yaw Position yaw: -128: -100%, 127: +100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_position_controller_output_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint8_t enabled, int8_t x, int8_t y, int8_t z, int8_t yaw)
{
mavlink_position_controller_output_t *p = (mavlink_position_controller_output_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT;
p->enabled = enabled; // uint8_t:1: enabled, 0: disabled
p->x = x; // int8_t:Position x: -128: -100%, 127: +100%
p->y = y; // int8_t:Position y: -128: -100%, 127: +100%
p->z = z; // int8_t:Position z: -128: -100%, 127: +100%
p->yaw = yaw; // int8_t:Position yaw: -128: -100%, 127: +100%
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT_LEN);
}
/**
* @brief Pack a position_controller_output message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param enabled 1: enabled, 0: disabled
* @param x Position x: -128: -100%, 127: +100%
* @param y Position y: -128: -100%, 127: +100%
* @param z Position z: -128: -100%, 127: +100%
* @param yaw Position yaw: -128: -100%, 127: +100%
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_position_controller_output_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint8_t enabled, int8_t x, int8_t y, int8_t z, int8_t yaw)
{
mavlink_position_controller_output_t *p = (mavlink_position_controller_output_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT;
p->enabled = enabled; // uint8_t:1: enabled, 0: disabled
p->x = x; // int8_t:Position x: -128: -100%, 127: +100%
p->y = y; // int8_t:Position y: -128: -100%, 127: +100%
p->z = z; // int8_t:Position z: -128: -100%, 127: +100%
p->yaw = yaw; // int8_t:Position yaw: -128: -100%, 127: +100%
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT_LEN);
}
/**
* @brief Encode a position_controller_output struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param position_controller_output C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_position_controller_output_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_position_controller_output_t* position_controller_output)
{
return mavlink_msg_position_controller_output_pack(system_id, component_id, msg, position_controller_output->enabled, position_controller_output->x, position_controller_output->y, position_controller_output->z, position_controller_output->yaw);
}
/**
* @brief Send a position_controller_output message
* @param chan MAVLink channel to send the message
*
* @param enabled 1: enabled, 0: disabled
* @param x Position x: -128: -100%, 127: +100%
* @param y Position y: -128: -100%, 127: +100%
* @param z Position z: -128: -100%, 127: +100%
* @param yaw Position yaw: -128: -100%, 127: +100%
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_position_controller_output_send(mavlink_channel_t chan, uint8_t enabled, int8_t x, int8_t y, int8_t z, int8_t yaw)
{
mavlink_header_t hdr;
mavlink_position_controller_output_t payload;
uint16_t checksum;
mavlink_position_controller_output_t *p = &payload;
p->enabled = enabled; // uint8_t:1: enabled, 0: disabled
p->x = x; // int8_t:Position x: -128: -100%, 127: +100%
p->y = y; // int8_t:Position y: -128: -100%, 127: +100%
p->z = z; // int8_t:Position z: -128: -100%, 127: +100%
p->yaw = yaw; // int8_t:Position yaw: -128: -100%, 127: +100%
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT_LEN;
hdr.msgid = MAVLINK_MSG_ID_POSITION_CONTROLLER_OUTPUT;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
crc_init(&checksum);
checksum = crc_calculate_mem((uint8_t *)&hdr.len, &checksum, MAVLINK_CORE_HEADER_LEN);
checksum = crc_calculate_mem((uint8_t *)&payload, &checksum, hdr.len );
hdr.ck_a = (uint8_t)(checksum & 0xFF); ///< Low byte
hdr.ck_b = (uint8_t)(checksum >> 8); ///< High byte
mavlink_send_mem(chan, (uint8_t *)&payload, hdr.len);
mavlink_send_mem(chan, (uint8_t *)&hdr.ck_a, MAVLINK_NUM_CHECKSUM_BYTES);
}
#endif
// MESSAGE POSITION_CONTROLLER_OUTPUT UNPACKING
/**
* @brief Get field enabled from position_controller_output message
*
* @return 1: enabled, 0: disabled
*/
static inline uint8_t mavlink_msg_position_controller_output_get_enabled(const mavlink_message_t* msg)
{
mavlink_position_controller_output_t *p = (mavlink_position_controller_output_t *)&msg->payload[0];
return (uint8_t)(p->enabled);
}
/**
* @brief Get field x from position_controller_output message
*
* @return Position x: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_position_controller_output_get_x(const mavlink_message_t* msg)
{
mavlink_position_controller_output_t *p = (mavlink_position_controller_output_t *)&msg->payload[0];
return (int8_t)(p->x);
}
/**
* @brief Get field y from position_controller_output message
*
* @return Position y: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_position_controller_output_get_y(const mavlink_message_t* msg)
{
mavlink_position_controller_output_t *p = (mavlink_position_controller_output_t *)&msg->payload[0];
return (int8_t)(p->y);
}
/**
* @brief Get field z from position_controller_output message
*
* @return Position z: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_position_controller_output_get_z(const mavlink_message_t* msg)
{
mavlink_position_controller_output_t *p = (mavlink_position_controller_output_t *)&msg->payload[0];
return (int8_t)(p->z);
}
/**
* @brief Get field yaw from position_controller_output message
*
* @return Position yaw: -128: -100%, 127: +100%
*/
static inline int8_t mavlink_msg_position_controller_output_get_yaw(const mavlink_message_t* msg)
{
mavlink_position_controller_output_t *p = (mavlink_position_controller_output_t *)&msg->payload[0];
return (int8_t)(p->yaw);
}
/**
* @brief Decode a position_controller_output message into a struct
*
* @param msg The message to decode
* @param position_controller_output C-struct to decode the message contents into
*/
static inline void mavlink_msg_position_controller_output_decode(const mavlink_message_t* msg, mavlink_position_controller_output_t* position_controller_output)
{
memcpy( position_controller_output, msg->payload, sizeof(mavlink_position_controller_output_t));
}

178
thirdParty/mavlink/include/common/mavlink_msg_roll_pitch_yaw_setpoint.h vendored
Unescape View File

@ -1,178 +0,0 @@ @@ -1,178 +0,0 @@
// MESSAGE ROLL_PITCH_YAW_SETPOINT PACKING
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT 57
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT_LEN 16
#define MAVLINK_MSG_57_LEN 16
typedef struct __mavlink_roll_pitch_yaw_setpoint_t
{
uint32_t time_ms; ///< Timestamp in milliseconds since system boot
float roll; ///< Desired roll angle in radians
float pitch; ///< Desired pitch angle in radians
float yaw; ///< Desired yaw angle in radians
} mavlink_roll_pitch_yaw_setpoint_t;
/**
* @brief Pack a roll_pitch_yaw_setpoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time_ms Timestamp in milliseconds since system boot
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_setpoint_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint32_t time_ms, float roll, float pitch, float yaw)
{
mavlink_roll_pitch_yaw_setpoint_t *p = (mavlink_roll_pitch_yaw_setpoint_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT;
p->time_ms = time_ms; // uint32_t:Timestamp in milliseconds since system boot
p->roll = roll; // float:Desired roll angle in radians
p->pitch = pitch; // float:Desired pitch angle in radians
p->yaw = yaw; // float:Desired yaw angle in radians
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT_LEN);
}
/**
* @brief Pack a roll_pitch_yaw_setpoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time_ms Timestamp in milliseconds since system boot
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_setpoint_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint32_t time_ms, float roll, float pitch, float yaw)
{
mavlink_roll_pitch_yaw_setpoint_t *p = (mavlink_roll_pitch_yaw_setpoint_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT;
p->time_ms = time_ms; // uint32_t:Timestamp in milliseconds since system boot
p->roll = roll; // float:Desired roll angle in radians
p->pitch = pitch; // float:Desired pitch angle in radians
p->yaw = yaw; // float:Desired yaw angle in radians
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT_LEN);
}
/**
* @brief Encode a roll_pitch_yaw_setpoint struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param roll_pitch_yaw_setpoint C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_setpoint_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_roll_pitch_yaw_setpoint_t* roll_pitch_yaw_setpoint)
{
return mavlink_msg_roll_pitch_yaw_setpoint_pack(system_id, component_id, msg, roll_pitch_yaw_setpoint->time_ms, roll_pitch_yaw_setpoint->roll, roll_pitch_yaw_setpoint->pitch, roll_pitch_yaw_setpoint->yaw);
}
/**
* @brief Send a roll_pitch_yaw_setpoint message
* @param chan MAVLink channel to send the message
*
* @param time_ms Timestamp in milliseconds since system boot
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_roll_pitch_yaw_setpoint_send(mavlink_channel_t chan, uint32_t time_ms, float roll, float pitch, float yaw)
{
mavlink_header_t hdr;
mavlink_roll_pitch_yaw_setpoint_t payload;
uint16_t checksum;
mavlink_roll_pitch_yaw_setpoint_t *p = &payload;
p->time_ms = time_ms; // uint32_t:Timestamp in milliseconds since system boot
p->roll = roll; // float:Desired roll angle in radians
p->pitch = pitch; // float:Desired pitch angle in radians
p->yaw = yaw; // float:Desired yaw angle in radians
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT_LEN;
hdr.msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SETPOINT;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
crc_init(&checksum);
checksum = crc_calculate_mem((uint8_t *)&hdr.len, &checksum, MAVLINK_CORE_HEADER_LEN);
checksum = crc_calculate_mem((uint8_t *)&payload, &checksum, hdr.len );
hdr.ck_a = (uint8_t)(checksum & 0xFF); ///< Low byte
hdr.ck_b = (uint8_t)(checksum >> 8); ///< High byte
mavlink_send_mem(chan, (uint8_t *)&payload, hdr.len);
mavlink_send_mem(chan, (uint8_t *)&hdr.ck_a, MAVLINK_NUM_CHECKSUM_BYTES);
}
#endif
// MESSAGE ROLL_PITCH_YAW_SETPOINT UNPACKING
/**
* @brief Get field time_ms from roll_pitch_yaw_setpoint message
*
* @return Timestamp in milliseconds since system boot
*/
static inline uint32_t mavlink_msg_roll_pitch_yaw_setpoint_get_time_ms(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_setpoint_t *p = (mavlink_roll_pitch_yaw_setpoint_t *)&msg->payload[0];
return (uint32_t)(p->time_ms);
}
/**
* @brief Get field roll from roll_pitch_yaw_setpoint message
*
* @return Desired roll angle in radians
*/
static inline float mavlink_msg_roll_pitch_yaw_setpoint_get_roll(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_setpoint_t *p = (mavlink_roll_pitch_yaw_setpoint_t *)&msg->payload[0];
return (float)(p->roll);
}
/**
* @brief Get field pitch from roll_pitch_yaw_setpoint message
*
* @return Desired pitch angle in radians
*/
static inline float mavlink_msg_roll_pitch_yaw_setpoint_get_pitch(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_setpoint_t *p = (mavlink_roll_pitch_yaw_setpoint_t *)&msg->payload[0];
return (float)(p->pitch);
}
/**
* @brief Get field yaw from roll_pitch_yaw_setpoint message
*
* @return Desired yaw angle in radians
*/
static inline float mavlink_msg_roll_pitch_yaw_setpoint_get_yaw(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_setpoint_t *p = (mavlink_roll_pitch_yaw_setpoint_t *)&msg->payload[0];
return (float)(p->yaw);
}
/**
* @brief Decode a roll_pitch_yaw_setpoint message into a struct
*
* @param msg The message to decode
* @param roll_pitch_yaw_setpoint C-struct to decode the message contents into
*/
static inline void mavlink_msg_roll_pitch_yaw_setpoint_decode(const mavlink_message_t* msg, mavlink_roll_pitch_yaw_setpoint_t* roll_pitch_yaw_setpoint)
{
memcpy( roll_pitch_yaw_setpoint, msg->payload, sizeof(mavlink_roll_pitch_yaw_setpoint_t));
}

178
thirdParty/mavlink/include/common/mavlink_msg_roll_pitch_yaw_speed_setpoint.h vendored
Unescape View File

@ -1,178 +0,0 @@ @@ -1,178 +0,0 @@
// MESSAGE ROLL_PITCH_YAW_SPEED_SETPOINT PACKING
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT 58
#define MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT_LEN 16
#define MAVLINK_MSG_58_LEN 16
typedef struct __mavlink_roll_pitch_yaw_speed_setpoint_t
{
uint32_t time_ms; ///< Timestamp in milliseconds since system boot
float roll_speed; ///< Desired roll angular speed in rad/s
float pitch_speed; ///< Desired pitch angular speed in rad/s
float yaw_speed; ///< Desired yaw angular speed in rad/s
} mavlink_roll_pitch_yaw_speed_setpoint_t;
/**
* @brief Pack a roll_pitch_yaw_speed_setpoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param time_ms Timestamp in milliseconds since system boot
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_speed_setpoint_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint32_t time_ms, float roll_speed, float pitch_speed, float yaw_speed)
{
mavlink_roll_pitch_yaw_speed_setpoint_t *p = (mavlink_roll_pitch_yaw_speed_setpoint_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT;
p->time_ms = time_ms; // uint32_t:Timestamp in milliseconds since system boot
p->roll_speed = roll_speed; // float:Desired roll angular speed in rad/s
p->pitch_speed = pitch_speed; // float:Desired pitch angular speed in rad/s
p->yaw_speed = yaw_speed; // float:Desired yaw angular speed in rad/s
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT_LEN);
}
/**
* @brief Pack a roll_pitch_yaw_speed_setpoint message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param time_ms Timestamp in milliseconds since system boot
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_speed_setpoint_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint32_t time_ms, float roll_speed, float pitch_speed, float yaw_speed)
{
mavlink_roll_pitch_yaw_speed_setpoint_t *p = (mavlink_roll_pitch_yaw_speed_setpoint_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT;
p->time_ms = time_ms; // uint32_t:Timestamp in milliseconds since system boot
p->roll_speed = roll_speed; // float:Desired roll angular speed in rad/s
p->pitch_speed = pitch_speed; // float:Desired pitch angular speed in rad/s
p->yaw_speed = yaw_speed; // float:Desired yaw angular speed in rad/s
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT_LEN);
}
/**
* @brief Encode a roll_pitch_yaw_speed_setpoint struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param roll_pitch_yaw_speed_setpoint C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_roll_pitch_yaw_speed_setpoint_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_roll_pitch_yaw_speed_setpoint_t* roll_pitch_yaw_speed_setpoint)
{
return mavlink_msg_roll_pitch_yaw_speed_setpoint_pack(system_id, component_id, msg, roll_pitch_yaw_speed_setpoint->time_ms, roll_pitch_yaw_speed_setpoint->roll_speed, roll_pitch_yaw_speed_setpoint->pitch_speed, roll_pitch_yaw_speed_setpoint->yaw_speed);
}
/**
* @brief Send a roll_pitch_yaw_speed_setpoint message
* @param chan MAVLink channel to send the message
*
* @param time_ms Timestamp in milliseconds since system boot
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_roll_pitch_yaw_speed_setpoint_send(mavlink_channel_t chan, uint32_t time_ms, float roll_speed, float pitch_speed, float yaw_speed)
{
mavlink_header_t hdr;
mavlink_roll_pitch_yaw_speed_setpoint_t payload;
uint16_t checksum;
mavlink_roll_pitch_yaw_speed_setpoint_t *p = &payload;
p->time_ms = time_ms; // uint32_t:Timestamp in milliseconds since system boot
p->roll_speed = roll_speed; // float:Desired roll angular speed in rad/s
p->pitch_speed = pitch_speed; // float:Desired pitch angular speed in rad/s
p->yaw_speed = yaw_speed; // float:Desired yaw angular speed in rad/s
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT_LEN;
hdr.msgid = MAVLINK_MSG_ID_ROLL_PITCH_YAW_SPEED_SETPOINT;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
crc_init(&checksum);
checksum = crc_calculate_mem((uint8_t *)&hdr.len, &checksum, MAVLINK_CORE_HEADER_LEN);
checksum = crc_calculate_mem((uint8_t *)&payload, &checksum, hdr.len );
hdr.ck_a = (uint8_t)(checksum & 0xFF); ///< Low byte
hdr.ck_b = (uint8_t)(checksum >> 8); ///< High byte
mavlink_send_mem(chan, (uint8_t *)&payload, hdr.len);
mavlink_send_mem(chan, (uint8_t *)&hdr.ck_a, MAVLINK_NUM_CHECKSUM_BYTES);
}
#endif
// MESSAGE ROLL_PITCH_YAW_SPEED_SETPOINT UNPACKING
/**
* @brief Get field time_ms from roll_pitch_yaw_speed_setpoint message
*
* @return Timestamp in milliseconds since system boot
*/
static inline uint32_t mavlink_msg_roll_pitch_yaw_speed_setpoint_get_time_ms(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_speed_setpoint_t *p = (mavlink_roll_pitch_yaw_speed_setpoint_t *)&msg->payload[0];
return (uint32_t)(p->time_ms);
}
/**
* @brief Get field roll_speed from roll_pitch_yaw_speed_setpoint message
*
* @return Desired roll angular speed in rad/s
*/
static inline float mavlink_msg_roll_pitch_yaw_speed_setpoint_get_roll_speed(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_speed_setpoint_t *p = (mavlink_roll_pitch_yaw_speed_setpoint_t *)&msg->payload[0];
return (float)(p->roll_speed);
}
/**
* @brief Get field pitch_speed from roll_pitch_yaw_speed_setpoint message
*
* @return Desired pitch angular speed in rad/s
*/
static inline float mavlink_msg_roll_pitch_yaw_speed_setpoint_get_pitch_speed(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_speed_setpoint_t *p = (mavlink_roll_pitch_yaw_speed_setpoint_t *)&msg->payload[0];
return (float)(p->pitch_speed);
}
/**
* @brief Get field yaw_speed from roll_pitch_yaw_speed_setpoint message
*
* @return Desired yaw angular speed in rad/s
*/
static inline float mavlink_msg_roll_pitch_yaw_speed_setpoint_get_yaw_speed(const mavlink_message_t* msg)
{
mavlink_roll_pitch_yaw_speed_setpoint_t *p = (mavlink_roll_pitch_yaw_speed_setpoint_t *)&msg->payload[0];
return (float)(p->yaw_speed);
}
/**
* @brief Decode a roll_pitch_yaw_speed_setpoint message into a struct
*
* @param msg The message to decode
* @param roll_pitch_yaw_speed_setpoint C-struct to decode the message contents into
*/
static inline void mavlink_msg_roll_pitch_yaw_speed_setpoint_decode(const mavlink_message_t* msg, mavlink_roll_pitch_yaw_speed_setpoint_t* roll_pitch_yaw_speed_setpoint)
{
memcpy( roll_pitch_yaw_speed_setpoint, msg->payload, sizeof(mavlink_roll_pitch_yaw_speed_setpoint_t));
}

196
thirdParty/mavlink/include/common/mavlink_msg_set_roll_pitch_yaw.h vendored
Unescape View File

@ -1,196 +0,0 @@ @@ -1,196 +0,0 @@
// MESSAGE SET_ROLL_PITCH_YAW PACKING
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW 55
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_LEN 14
#define MAVLINK_MSG_55_LEN 14
typedef struct __mavlink_set_roll_pitch_yaw_t
{
float roll; ///< Desired roll angle in radians
float pitch; ///< Desired pitch angle in radians
float yaw; ///< Desired yaw angle in radians
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
} mavlink_set_roll_pitch_yaw_t;
/**
* @brief Pack a set_roll_pitch_yaw message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint8_t target_system, uint8_t target_component, float roll, float pitch, float yaw)
{
mavlink_set_roll_pitch_yaw_t *p = (mavlink_set_roll_pitch_yaw_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW;
p->target_system = target_system; // uint8_t:System ID
p->target_component = target_component; // uint8_t:Component ID
p->roll = roll; // float:Desired roll angle in radians
p->pitch = pitch; // float:Desired pitch angle in radians
p->yaw = yaw; // float:Desired yaw angle in radians
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_LEN);
}
/**
* @brief Pack a set_roll_pitch_yaw message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint8_t target_system, uint8_t target_component, float roll, float pitch, float yaw)
{
mavlink_set_roll_pitch_yaw_t *p = (mavlink_set_roll_pitch_yaw_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW;
p->target_system = target_system; // uint8_t:System ID
p->target_component = target_component; // uint8_t:Component ID
p->roll = roll; // float:Desired roll angle in radians
p->pitch = pitch; // float:Desired pitch angle in radians
p->yaw = yaw; // float:Desired yaw angle in radians
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_LEN);
}
/**
* @brief Encode a set_roll_pitch_yaw struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_roll_pitch_yaw C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_roll_pitch_yaw_t* set_roll_pitch_yaw)
{
return mavlink_msg_set_roll_pitch_yaw_pack(system_id, component_id, msg, set_roll_pitch_yaw->target_system, set_roll_pitch_yaw->target_component, set_roll_pitch_yaw->roll, set_roll_pitch_yaw->pitch, set_roll_pitch_yaw->yaw);
}
/**
* @brief Send a set_roll_pitch_yaw message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param roll Desired roll angle in radians
* @param pitch Desired pitch angle in radians
* @param yaw Desired yaw angle in radians
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_roll_pitch_yaw_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, float roll, float pitch, float yaw)
{
mavlink_header_t hdr;
mavlink_set_roll_pitch_yaw_t payload;
uint16_t checksum;
mavlink_set_roll_pitch_yaw_t *p = &payload;
p->target_system = target_system; // uint8_t:System ID
p->target_component = target_component; // uint8_t:Component ID
p->roll = roll; // float:Desired roll angle in radians
p->pitch = pitch; // float:Desired pitch angle in radians
p->yaw = yaw; // float:Desired yaw angle in radians
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_LEN;
hdr.msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
crc_init(&checksum);
checksum = crc_calculate_mem((uint8_t *)&hdr.len, &checksum, MAVLINK_CORE_HEADER_LEN);
checksum = crc_calculate_mem((uint8_t *)&payload, &checksum, hdr.len );
hdr.ck_a = (uint8_t)(checksum & 0xFF); ///< Low byte
hdr.ck_b = (uint8_t)(checksum >> 8); ///< High byte
mavlink_send_mem(chan, (uint8_t *)&payload, hdr.len);
mavlink_send_mem(chan, (uint8_t *)&hdr.ck_a, MAVLINK_NUM_CHECKSUM_BYTES);
}
#endif
// MESSAGE SET_ROLL_PITCH_YAW UNPACKING
/**
* @brief Get field target_system from set_roll_pitch_yaw message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_get_target_system(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_t *p = (mavlink_set_roll_pitch_yaw_t *)&msg->payload[0];
return (uint8_t)(p->target_system);
}
/**
* @brief Get field target_component from set_roll_pitch_yaw message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_get_target_component(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_t *p = (mavlink_set_roll_pitch_yaw_t *)&msg->payload[0];
return (uint8_t)(p->target_component);
}
/**
* @brief Get field roll from set_roll_pitch_yaw message
*
* @return Desired roll angle in radians
*/
static inline float mavlink_msg_set_roll_pitch_yaw_get_roll(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_t *p = (mavlink_set_roll_pitch_yaw_t *)&msg->payload[0];
return (float)(p->roll);
}
/**
* @brief Get field pitch from set_roll_pitch_yaw message
*
* @return Desired pitch angle in radians
*/
static inline float mavlink_msg_set_roll_pitch_yaw_get_pitch(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_t *p = (mavlink_set_roll_pitch_yaw_t *)&msg->payload[0];
return (float)(p->pitch);
}
/**
* @brief Get field yaw from set_roll_pitch_yaw message
*
* @return Desired yaw angle in radians
*/
static inline float mavlink_msg_set_roll_pitch_yaw_get_yaw(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_t *p = (mavlink_set_roll_pitch_yaw_t *)&msg->payload[0];
return (float)(p->yaw);
}
/**
* @brief Decode a set_roll_pitch_yaw message into a struct
*
* @param msg The message to decode
* @param set_roll_pitch_yaw C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_roll_pitch_yaw_decode(const mavlink_message_t* msg, mavlink_set_roll_pitch_yaw_t* set_roll_pitch_yaw)
{
memcpy( set_roll_pitch_yaw, msg->payload, sizeof(mavlink_set_roll_pitch_yaw_t));
}

196
thirdParty/mavlink/include/common/mavlink_msg_set_roll_pitch_yaw_speed.h vendored
Unescape View File

@ -1,196 +0,0 @@ @@ -1,196 +0,0 @@
// MESSAGE SET_ROLL_PITCH_YAW_SPEED PACKING
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED 56
#define MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_LEN 14
#define MAVLINK_MSG_56_LEN 14
typedef struct __mavlink_set_roll_pitch_yaw_speed_t
{
float roll_speed; ///< Desired roll angular speed in rad/s
float pitch_speed; ///< Desired pitch angular speed in rad/s
float yaw_speed; ///< Desired yaw angular speed in rad/s
uint8_t target_system; ///< System ID
uint8_t target_component; ///< Component ID
} mavlink_set_roll_pitch_yaw_speed_t;
/**
* @brief Pack a set_roll_pitch_yaw_speed message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param target_system System ID
* @param target_component Component ID
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_speed_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint8_t target_system, uint8_t target_component, float roll_speed, float pitch_speed, float yaw_speed)
{
mavlink_set_roll_pitch_yaw_speed_t *p = (mavlink_set_roll_pitch_yaw_speed_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED;
p->target_system = target_system; // uint8_t:System ID
p->target_component = target_component; // uint8_t:Component ID
p->roll_speed = roll_speed; // float:Desired roll angular speed in rad/s
p->pitch_speed = pitch_speed; // float:Desired pitch angular speed in rad/s
p->yaw_speed = yaw_speed; // float:Desired yaw angular speed in rad/s
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_LEN);
}
/**
* @brief Pack a set_roll_pitch_yaw_speed message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param target_system System ID
* @param target_component Component ID
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_speed_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint8_t target_system, uint8_t target_component, float roll_speed, float pitch_speed, float yaw_speed)
{
mavlink_set_roll_pitch_yaw_speed_t *p = (mavlink_set_roll_pitch_yaw_speed_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED;
p->target_system = target_system; // uint8_t:System ID
p->target_component = target_component; // uint8_t:Component ID
p->roll_speed = roll_speed; // float:Desired roll angular speed in rad/s
p->pitch_speed = pitch_speed; // float:Desired pitch angular speed in rad/s
p->yaw_speed = yaw_speed; // float:Desired yaw angular speed in rad/s
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_LEN);
}
/**
* @brief Encode a set_roll_pitch_yaw_speed struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param set_roll_pitch_yaw_speed C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_set_roll_pitch_yaw_speed_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_set_roll_pitch_yaw_speed_t* set_roll_pitch_yaw_speed)
{
return mavlink_msg_set_roll_pitch_yaw_speed_pack(system_id, component_id, msg, set_roll_pitch_yaw_speed->target_system, set_roll_pitch_yaw_speed->target_component, set_roll_pitch_yaw_speed->roll_speed, set_roll_pitch_yaw_speed->pitch_speed, set_roll_pitch_yaw_speed->yaw_speed);
}
/**
* @brief Send a set_roll_pitch_yaw_speed message
* @param chan MAVLink channel to send the message
*
* @param target_system System ID
* @param target_component Component ID
* @param roll_speed Desired roll angular speed in rad/s
* @param pitch_speed Desired pitch angular speed in rad/s
* @param yaw_speed Desired yaw angular speed in rad/s
*/
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
static inline void mavlink_msg_set_roll_pitch_yaw_speed_send(mavlink_channel_t chan, uint8_t target_system, uint8_t target_component, float roll_speed, float pitch_speed, float yaw_speed)
{
mavlink_header_t hdr;
mavlink_set_roll_pitch_yaw_speed_t payload;
uint16_t checksum;
mavlink_set_roll_pitch_yaw_speed_t *p = &payload;
p->target_system = target_system; // uint8_t:System ID
p->target_component = target_component; // uint8_t:Component ID
p->roll_speed = roll_speed; // float:Desired roll angular speed in rad/s
p->pitch_speed = pitch_speed; // float:Desired pitch angular speed in rad/s
p->yaw_speed = yaw_speed; // float:Desired yaw angular speed in rad/s
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED_LEN;
hdr.msgid = MAVLINK_MSG_ID_SET_ROLL_PITCH_YAW_SPEED;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
crc_init(&checksum);
checksum = crc_calculate_mem((uint8_t *)&hdr.len, &checksum, MAVLINK_CORE_HEADER_LEN);
checksum = crc_calculate_mem((uint8_t *)&payload, &checksum, hdr.len );
hdr.ck_a = (uint8_t)(checksum & 0xFF); ///< Low byte
hdr.ck_b = (uint8_t)(checksum >> 8); ///< High byte
mavlink_send_mem(chan, (uint8_t *)&payload, hdr.len);
mavlink_send_mem(chan, (uint8_t *)&hdr.ck_a, MAVLINK_NUM_CHECKSUM_BYTES);
}
#endif
// MESSAGE SET_ROLL_PITCH_YAW_SPEED UNPACKING
/**
* @brief Get field target_system from set_roll_pitch_yaw_speed message
*
* @return System ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_speed_get_target_system(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_speed_t *p = (mavlink_set_roll_pitch_yaw_speed_t *)&msg->payload[0];
return (uint8_t)(p->target_system);
}
/**
* @brief Get field target_component from set_roll_pitch_yaw_speed message
*
* @return Component ID
*/
static inline uint8_t mavlink_msg_set_roll_pitch_yaw_speed_get_target_component(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_speed_t *p = (mavlink_set_roll_pitch_yaw_speed_t *)&msg->payload[0];
return (uint8_t)(p->target_component);
}
/**
* @brief Get field roll_speed from set_roll_pitch_yaw_speed message
*
* @return Desired roll angular speed in rad/s
*/
static inline float mavlink_msg_set_roll_pitch_yaw_speed_get_roll_speed(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_speed_t *p = (mavlink_set_roll_pitch_yaw_speed_t *)&msg->payload[0];
return (float)(p->roll_speed);
}
/**
* @brief Get field pitch_speed from set_roll_pitch_yaw_speed message
*
* @return Desired pitch angular speed in rad/s
*/
static inline float mavlink_msg_set_roll_pitch_yaw_speed_get_pitch_speed(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_speed_t *p = (mavlink_set_roll_pitch_yaw_speed_t *)&msg->payload[0];
return (float)(p->pitch_speed);
}
/**
* @brief Get field yaw_speed from set_roll_pitch_yaw_speed message
*
* @return Desired yaw angular speed in rad/s
*/
static inline float mavlink_msg_set_roll_pitch_yaw_speed_get_yaw_speed(const mavlink_message_t* msg)
{
mavlink_set_roll_pitch_yaw_speed_t *p = (mavlink_set_roll_pitch_yaw_speed_t *)&msg->payload[0];
return (float)(p->yaw_speed);
}
/**
* @brief Decode a set_roll_pitch_yaw_speed message into a struct
*
* @param msg The message to decode
* @param set_roll_pitch_yaw_speed C-struct to decode the message contents into
*/
static inline void mavlink_msg_set_roll_pitch_yaw_speed_decode(const mavlink_message_t* msg, mavlink_set_roll_pitch_yaw_speed_t* set_roll_pitch_yaw_speed)
{
memcpy( set_roll_pitch_yaw_speed, msg->payload, sizeof(mavlink_set_roll_pitch_yaw_speed_t));
}

41
thirdParty/mavlink/include/documentation.dox vendored
Unescape View File

@ -1,41 +0,0 @@ @@ -1,41 +0,0 @@
/**
* @file
* @brief MAVLink communication protocol
*
* @author Lorenz Meier <mavteam@student.ethz.ch>
*
*/
/**
* @mainpage MAVLink API Documentation
*
* @section intro_sec Introduction
*
* This <a href="http://en.wikipedia.org/wiki/API" target="_blank">API</a> documentation covers the MAVLink
* protocol developed <a href="http://pixhawk.ethz.ch" target="_blank">PIXHAWK</a> project.
* In case you have generated this documentation locally, the most recent version (generated on every commit)
* is also publicly available on the internet.
*
* @sa http://pixhawk.ethz.ch/api/qgroundcontrol/ - Groundstation code base
* @sa http://pixhawk.ethz.ch/api/mavlink - (this) MAVLink communication protocol
* @sa http://pixhawk.ethz.ch/api/imu_autopilot/ - Flight board (ARM MCU) code base
* @sa http://pixhawk.ethz.ch/api/ai_vision - Computer Vision / AI API docs
*
* @section further_sec Further Information
*
* How to run our software and a general overview of the software architecture is documented in the project
* wiki pages.
*
* @sa http://pixhawk.ethz.ch/software/mavlink/ - MAVLink main documentation
*
* See the <a href="http://pixhawk.ethz.ch" target="_blank">PIXHAWK website</a> for more information.
*
* @section usage_sec Doxygen Usage
*
* You can exclude files from being parsed into this Doxygen documentation
* by adding them to the EXCLUDE list in the file in embedded/cmake/doc/api/doxy.config.in.
*
*
*
**/

183
thirdParty/mavlink/include/mavlink_checksum.h vendored
Unescape View File

@ -1,183 +0,0 @@ @@ -1,183 +0,0 @@
/** @file
* @brief MAVLink comm protocol checksum routines.
* @see http://qgroundcontrol.org/mavlink/
* Edited on Monday, August 8 2011
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _CHECKSUM_H_
#define _CHECKSUM_H_
#include "inttypes.h"
/**
*
* CALCULATE THE CHECKSUM
*
*/
#define X25_INIT_CRC 0xffff
#define X25_VALIDATE_CRC 0xf0b8
/**
* @brief Accumulate the X.25 CRC by adding one char at a time.
*
* The checksum function adds the hash of one char at a time to the
* 16 bit checksum (uint16_t).
*
* @param data new char to hash
* @param crcAccum the already accumulated checksum
**/
static inline void crc_accumulate(uint8_t data, uint16_t *crcAccum)
{
/*Accumulate one byte of data into the CRC*/
uint8_t tmp;
tmp=data ^ (uint8_t)(*crcAccum &0xff);
tmp^= (tmp<<4);
*crcAccum = (*crcAccum>>8) ^ (tmp<<8) ^ (tmp <<3) ^ (tmp>>4);
// *crcAccum += data; // super simple to test
}
/**
* @brief Initiliaze the buffer for the X.25 CRC
*
* @param crcAccum the 16 bit X.25 CRC
*/
static inline void crc_init(uint16_t* crcAccum)
{
*crcAccum = X25_INIT_CRC;
}
/**
* @brief Initiliaze the buffer for the X.25 CRC to a specified value
*
* @param crcAccum the 16 bit X.25 CRC
*/
static inline void crc_init2(uint16_t* crcAccum, uint16_t crcValue)
{
*crcAccum = crcValue;
}
/**
* @brief Calculates the X.25 checksum on a byte buffer
*
* @param pBuffer buffer containing the byte array to hash
* @param length length of the byte array
* @return the checksum over the buffer bytes
**/
static inline uint16_t crc_calculate(uint8_t* pBuffer, int length)
{
// For a "message" of length bytes contained in the unsigned char array
// pointed to by pBuffer, calculate the CRC
// crcCalculate(unsigned char* pBuffer, int length, unsigned short* checkConst) < not needed
uint16_t crcTmp;
//uint16_t tmp;
uint8_t* pTmp;
int i;
pTmp=pBuffer;
/* init crcTmp */
crc_init(&crcTmp);
for (i = 0; i < length; i++){
crc_accumulate(*pTmp++, &crcTmp);
}
/* This is currently not needed, as only the checksum over payload should be computed
tmp = crcTmp;
crcAccumulate((unsigned char)(~crcTmp & 0xff),&tmp);
crcAccumulate((unsigned char)((~crcTmp>>8)&0xff),&tmp);
*checkConst = tmp;
*/
return(crcTmp);
}
/**
* @brief Calculates the X.25 checksum on a byte buffer
*
* @param pBuffer buffer containing the byte array to hash
* @param length length of the byte array
* @return the checksum over the buffer bytes
**/
static inline uint16_t crc_calculate_mem(uint8_t *pBuffer, uint16_t *crcTmp, int length)
{
// For a "message" of length bytes contained in the unsigned char array
// pointed to by pBuffer, calculate the CRC
// crcCalculate(unsigned char* pBuffer, int length, unsigned short* checkConst) < not needed
//uint16_t tmp;
//uint8_t* pTmp;
int i;
// pTmp=pBuffer;
for (i = 0; i < length; i++){
crc_accumulate(*pBuffer++, crcTmp);
}
return(*crcTmp);
}
/**
* @brief Calculates the X.25 checksum on a msg buffer
*
* @param pMSG buffer containing the msg to hash
* @param length number of bytes to hash
* @return the checksum over the buffer bytes
**/
static inline uint16_t crc_calculate_msg(mavlink_message_t* pMSG, int length)
{
// For a "message" of length bytes contained in the unsigned char array
// pointed to by pBuffer, calculate the CRC
// crcCalculate(unsigned char* pBuffer, int length, unsigned short* checkConst) < not needed
uint16_t crcTmp;
//uint16_t tmp;
uint8_t* pTmp;
int i;
pTmp=&pMSG->len;
/* init crcTmp */
crc_init(&crcTmp);
for (i = 0; i < 5; i++){
crc_accumulate(*pTmp++, &crcTmp);
}
pTmp=&pMSG->payload[0];
for (; i < length; i++){
crc_accumulate(*pTmp++, &crcTmp);
}
/* This is currently not needed, as only the checksum over payload should be computed
tmp = crcTmp;
crcAccumulate((unsigned char)(~crcTmp & 0xff),&tmp);
crcAccumulate((unsigned char)((~crcTmp>>8)&0xff),&tmp);
*checkConst = tmp;
*/
return(crcTmp);
}
#endif /* _CHECKSUM_H_ */
#ifdef __cplusplus
}
#endif

21
thirdParty/mavlink/include/mavlink_data.h vendored
Unescape View File

@ -1,21 +0,0 @@ @@ -1,21 +0,0 @@
/** @file
* @brief Main MAVLink comm protocol data.
* @see http://qgroundcontrol.org/mavlink/
* Edited on Monday, August 8 2011
*/
#ifndef _ML_DATA_H_
#define _ML_DATA_H_
#include "mavlink_types.h"
#ifdef MAVLINK_CHECK_LENGTH
const uint8_t MAVLINK_CONST mavlink_msg_lengths[256] = MAVLINK_MESSAGE_LENGTHS;
#endif
const uint8_t MAVLINK_CONST mavlink_msg_keys[256] = MAVLINK_MESSAGE_KEYS;
mavlink_status_t m_mavlink_status[MAVLINK_COMM_NUM_BUFFERS];
mavlink_message_t m_mavlink_message[MAVLINK_COMM_NUM_BUFFERS];
mavlink_system_t mavlink_system;
#endif

135
thirdParty/mavlink/include/mavlink_options.h vendored
Unescape View File

@ -1,135 +0,0 @@ @@ -1,135 +0,0 @@
/** @file
* @brief MAVLink comm protocol option constants.
* @see http://qgroundcontrol.org/mavlink/
* Edited on Monday, August 8 2011
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _ML_OPTIONS_H_
#define _ML_OPTIONS_H_
/**
*
* Receive message length check option. On receive verify the length field
* as soon as the message ID field is received. Requires a 256 byte const
* table. Comment out the define to leave out the table and code to check it.
*
*/
//#define MAVLINK_CHECK_LENGTH
/**
*
* Receive message buffer option. This option should be used only when the
* side effects are understood but allows the underlying program access to
* the internal recieve buffer - eliminating the usual double buffering. It
* also REQUIRES changes in the return type of mavlink_parse_char so only
* enable if you make the changes required. Default DISABLED.
*
*/
//#define MAVLINK_STATIC_BUFFER
/**
*
* Receive message buffers option. This option defines how many msg buffers
* mavlink will define, and thereby how many links it can support. A default
* will be supplied if the symbol is not pre-defined, dependant on the make
* envionment. The default is 16 for a recognised OS envionment and 1
* otherwise.
*
*/
#if !(defined MAVLINK_COMM_NUM_BUFFERS) || (MAVLINK_COMM_NUM_BUFFERS < 1)
#undef MAVLINK_COMM_NUM_BUFFERS
#if (defined linux) || (defined __linux) || (defined __MACH__) || (defined _WIN32) || (defined __APPLE__)
#define MAVLINK_COMM_NUM_BUFFERS 16
#else
#define MAVLINK_COMM_NUM_BUFFERS 1
#endif
#endif
/**
*
* Data relization option. This option controls inclusion of the file
* mavlink_data.h in the current compile unit - thus defining mavlink's
* variables. Default is ON (not defined) because typically mavlink.h is only
* included once in a system but if it was used in two files there would
* be duplicate variables at link time. Normal practice would be to define
* this symbol outside of this file as defining it here will cause missing
* symbols at link time. In other words in the first file to include mavlink.h
* do not define this sybol, then define this symbol in all other files before
* including mavlink.h
*
*/
//#define MAVLINK_NO_DATA
#ifdef MAVLINK_NO_DATA
#undef MAVLINK_DATA
#else
#define MAVLINK_DATA
#endif
/**
*
* Custom data const data relization and access options.
* This define is placed in the form
* const uint8_t MAVLINK_CONST name[] = { ... };
* for the keys table and (if applicable) lengths table to tell the compiler
* were to put the data. The access option is placed in the form
* variable = MAVLINK_CONST_READ( name[i] );
* in order to allow custom read function's or accessors.
* By default MAVLINK_CONST is defined as nothing and MAVLINK_CONST_READ as
* MAVLINK_CONST_READ( a ) a
* These symbols are only defined if not already defined allowing this file
* to remain unchanged while the actual definitions are maintained in external
* files.
*
*/
#ifndef MAVLINK_CONST
#define MAVLINK_CONST
#endif
#ifndef MAVLINK_CONST_READ
#define MAVLINK_CONST_READ( a ) a
#endif
/**
*
* Convience functions. These are all in one send functions that are very
* easy to use. Just define the symbol MAVLINK_USE_CONVENIENCE_FUNCTIONS.
* These functions also support a buffer check, to ensure there is enough
* space in your comm buffer that the function would not block - it could
* also be used as the basis of a MUTEX. This is implemented in the send
* function as a macro with two arguments, first the comm chan number and
* the message length in the form
* MAVLINK_BUFFER_CHECK_START( chan, MAVLINK_MSG_ID_LEN )
* followed by the function code and then
* MAVLINK_BUFFER_CHECK_START
* Note that there are no terminators on these statements to allow for
* code nesting or other constructs. Default value for both is empty.
* A sugested implementation is shown below and the symbols will be defined
* only if they are not allready.
*
* if ( serial_space( chan ) > len ) { // serial_space returns available space
* ..... code that creates message
* }
*
* #define MAVLINK_BUFFER_CHECK_START( c, l ) if ( serial_space( c ) > l ) {
* #define MAVLINK_BUFFER_CHECK_END }
*
*/
//#define MAVLINK_USE_CONVENIENCE_FUNCTIONS
#ifndef MAVLINK_BUFFER_CHECK_START
#define MAVLINK_BUFFER_CHECK_START( c, l ) ;
#endif
#ifndef MAVLINK_BUFFER_CHECK_END
#define MAVLINK_BUFFER_CHECK_END ;
#endif
#endif /* _ML_OPTIONS_H_ */
#ifdef __cplusplus
}
#endif

425
thirdParty/mavlink/include/mavlink_protocol.h vendored
Unescape View File

@ -1,425 +0,0 @@ @@ -1,425 +0,0 @@
/** @file
* @brief Main MAVLink comm protocol routines.
* @see http://qgroundcontrol.org/mavlink/
* Edited on Monday, August 8 2011
*/
#ifndef _MAVLINK_PROTOCOL_H_
#define _MAVLINK_PROTOCOL_H_
#include "string.h" /* memcpy */
#include "mavlink_types.h"
#include "mavlink_checksum.h"
#ifdef MAVLINK_CHECK_LENGTH
extern const uint8_t MAVLINK_CONST mavlink_msg_lengths[256];
#endif
extern const uint8_t MAVLINK_CONST mavlink_msg_keys[256];
extern mavlink_status_t m_mavlink_status[MAVLINK_COMM_NUM_BUFFERS];
extern mavlink_message_t m_mavlink_message[MAVLINK_COMM_NUM_BUFFERS];
extern mavlink_system_t mavlink_system;
/**
* @brief Initialize the communication stack
*
* This function has to be called before using commParseBuffer() to initialize the different status registers.
*
* @return Will initialize the different buffers and status registers.
*/
static void mavlink_parse_state_initialize(mavlink_status_t* initStatus)
{
if ((initStatus->parse_state <= MAVLINK_PARSE_STATE_UNINIT) || (initStatus->parse_state > MAVLINK_PARSE_STATE_GOT_CRC1))
{
initStatus->ck_a = 0;
initStatus->ck_b = 0;
initStatus->msg_received = 0;
initStatus->buffer_overrun = 0;
initStatus->parse_error = 0;
initStatus->parse_state = MAVLINK_PARSE_STATE_UNINIT;
initStatus->packet_idx = 0;
initStatus->packet_rx_drop_count = 0;
initStatus->packet_rx_success_count = 0;
initStatus->current_rx_seq = 0;
initStatus->current_tx_seq = 0;
}
}
static inline mavlink_status_t* mavlink_get_channel_status(uint8_t chan)
{
return &m_mavlink_status[chan];
}
/**
* @brief Finalize a MAVLink message with MAVLINK_COMM_0 as default channel
*
* This function calculates the checksum and sets length and aircraft id correctly.
* It assumes that the message id and the payload are already correctly set.
*
* @warning This function implicitely assumes the message is sent over channel zero.
* if the message is sent over a different channel it will reach the receiver
* without error, BUT the sequence number might be wrong due to the wrong
* channel sequence counter. This will result is wrongly reported excessive
* packet loss. Please use @see mavlink_{pack|encode}_headerless and then
* @see mavlink_finalize_message_chan before sending for a correct channel
* assignment. Please note that the mavlink_msg_xxx_pack and encode functions
* assign channel zero as default and thus induce possible loss counter errors.\
* They have been left to ensure code compatibility.
*
* @see mavlink_finalize_message_chan
* @param msg Message to finalize
* @param system_id Id of the sending (this) system, 1-127
* @param length Message length, usually just the counter incremented while packing the message
*/
static inline uint16_t mavlink_finalize_message(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, uint16_t length)
{
// This code part is the same for all messages;
uint8_t key;
msg->len = length;
msg->sysid = system_id;
msg->compid = component_id;
// One sequence number per component
msg->seq = mavlink_get_channel_status(MAVLINK_COMM_0)->current_tx_seq;
mavlink_get_channel_status(MAVLINK_COMM_0)->current_tx_seq = mavlink_get_channel_status(MAVLINK_COMM_0)->current_tx_seq+1;
msg->ck = crc_calculate_msg(msg, length + MAVLINK_CORE_HEADER_LEN);
key = MAVLINK_CONST_READ( mavlink_msg_keys[msg->msgid] );
crc_accumulate( key, &msg->ck ); /// include key in X25 checksum
return length + MAVLINK_NUM_NON_STX_PAYLOAD_BYTES;
}
/**
* @brief Finalize a MAVLink message with channel assignment
*
* This function calculates the checksum and sets length and aircraft id correctly.
* It assumes that the message id and the payload are already correctly set. This function
* can also be used if the message header has already been written before (as in mavlink_msg_xxx_pack
* instead of mavlink_msg_xxx_pack_headerless), it just introduces little extra overhead.
*
* @param msg Message to finalize
* @param system_id Id of the sending (this) system, 1-127
* @param length Message length, usually just the counter incremented while packing the message
*/
static inline uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, uint8_t system_id, uint8_t component_id, uint8_t chan, uint16_t length)
{
// This code part is the same for all messages;
uint8_t key;
msg->len = length;
msg->sysid = system_id;
msg->compid = component_id;
// One sequence number per component
msg->seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = mavlink_get_channel_status(chan)->current_tx_seq+1;
msg->ck = crc_calculate_msg(msg, length + MAVLINK_CORE_HEADER_LEN);
key = MAVLINK_CONST_READ( mavlink_msg_keys[msg->msgid] );
crc_accumulate( key, &msg->ck ); /// include key in X25 checksum
return length + MAVLINK_NUM_NON_STX_PAYLOAD_BYTES;
}
/**
* @brief Pack a message to send it over a serial byte stream
*/
static inline uint16_t mavlink_msg_to_send_buffer(uint8_t* buffer, const mavlink_message_t* msg)
{
*(buffer+0) = MAVLINK_STX; ///< Start transmit
// memcpy((buffer+1), msg, msg->len + MAVLINK_CORE_HEADER_LEN); ///< Core header plus payload
memcpy((buffer+1), &msg->len, MAVLINK_CORE_HEADER_LEN); ///< Core header
memcpy((buffer+1+MAVLINK_CORE_HEADER_LEN), &msg->payload[0], msg->len); ///< payload
*(buffer + msg->len + MAVLINK_CORE_HEADER_LEN + 1) = msg->ck_a;
*(buffer + msg->len + MAVLINK_CORE_HEADER_LEN + 2) = msg->ck_b;
return msg->len + MAVLINK_NUM_NON_PAYLOAD_BYTES;
// return 0;
}
/**
* @brief Get the required buffer size for this message
*/
static inline uint16_t mavlink_msg_get_send_buffer_length(const mavlink_message_t* msg)
{
return msg->len + MAVLINK_NUM_NON_PAYLOAD_BYTES;
}
union checksum_ {
uint16_t s;
uint8_t c[2];
};
static inline void mavlink_start_checksum(mavlink_message_t* msg)
{
crc_init(&msg->ck);
}
static inline void mavlink_update_checksum(mavlink_message_t* msg, uint8_t c)
{
crc_accumulate(c, &msg->ck);
}
/**
* This is a convenience function which handles the complete MAVLink parsing.
* the function will parse one byte at a time and return the complete packet once
* it could be successfully decoded. Checksum and other failures will be silently
* ignored.
*
* @param chan ID of the current channel. This allows to parse different channels with this function.
* a channel is not a physical message channel like a serial port, but a logic partition of
* the communication streams in this case. COMM_NB is the limit for the number of channels
* on MCU (e.g. ARM7), while COMM_NB_HIGH is the limit for the number of channels in Linux/Windows
* @param c The char to barse
*
* @param returnMsg NULL if no message could be decoded, the message data else
* @return 0 if no message could be decoded, 1 else
*
* A typical use scenario of this function call is:
*
* @code
* #include <inttypes.h> // For fixed-width uint8_t type
*
* mavlink_message_t msg;
* int chan = 0;
*
*
* while(serial.bytesAvailable > 0)
* {
* uint8_t byte = serial.getNextByte();
* if (mavlink_parse_char(chan, byte, &msg))
* {
* printf("Received message with ID %d, sequence: %d from component %d of system %d", msg.msgid, msg.seq, msg.compid, msg.sysid);
* }
* }
*
*
* @endcode
*/
#ifdef MAVLINK_STATIC_BUFFER
static inline mavlink_message_t* mavlink_parse_char(uint8_t chan, uint8_t c, mavlink_message_t* r_message, mavlink_status_t* r_mavlink_status)
#else
static inline int16_t mavlink_parse_char(uint8_t chan, uint8_t c, mavlink_message_t* r_message, mavlink_status_t* r_mavlink_status)
#endif
{
// Initializes only once, values keep unchanged after first initialization
mavlink_parse_state_initialize(mavlink_get_channel_status(chan));
mavlink_message_t* rxmsg = &m_mavlink_message[chan]; ///< The currently decoded message
mavlink_status_t* status = mavlink_get_channel_status(chan); ///< The current decode status
int bufferIndex = 0;
status->msg_received = 0;
switch (status->parse_state)
{
case MAVLINK_PARSE_STATE_UNINIT:
case MAVLINK_PARSE_STATE_IDLE:
if (c == MAVLINK_STX)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
mavlink_start_checksum(rxmsg);
}
break;
case MAVLINK_PARSE_STATE_GOT_STX:
if (status->msg_received)
{
status->buffer_overrun++;
status->parse_error++;
status->msg_received = 0;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
}
else
{
// NOT counting STX, LENGTH, SEQ, SYSID, COMPID, MSGID, CRC1 and CRC2
rxmsg->len = c;
status->packet_idx = 0;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_LENGTH;
}
break;
case MAVLINK_PARSE_STATE_GOT_LENGTH:
rxmsg->seq = c;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_SEQ;
break;
case MAVLINK_PARSE_STATE_GOT_SEQ:
rxmsg->sysid = c;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_SYSID;
break;
case MAVLINK_PARSE_STATE_GOT_SYSID:
rxmsg->compid = c;
mavlink_update_checksum(rxmsg, c);
status->parse_state = MAVLINK_PARSE_STATE_GOT_COMPID;
break;
case MAVLINK_PARSE_STATE_GOT_COMPID:
rxmsg->msgid = c;
mavlink_update_checksum(rxmsg, c);
#ifdef MAVLINK_CHECK_LENGTH
if (rxmsg->len != MAVLINK_CONST_READ( mavlink_msg_lengths[c] ) )
{
status->parse_state = MAVLINK_PARSE_STATE_IDLE; // abort, not going to understand it anyway
break;
} else ;
#endif
if (rxmsg->len == 0)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
}
else
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_MSGID;
}
break;
case MAVLINK_PARSE_STATE_GOT_MSGID:
rxmsg->payload[status->packet_idx++] = c;
mavlink_update_checksum(rxmsg, c);
if (status->packet_idx == rxmsg->len)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
mavlink_update_checksum(rxmsg,
MAVLINK_CONST_READ( mavlink_msg_keys[rxmsg->msgid] ));
}
break;
case MAVLINK_PARSE_STATE_GOT_PAYLOAD:
if (c != rxmsg->ck_a)
{
// Check first checksum byte
status->parse_error++;
status->msg_received = 0;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
if (c == MAVLINK_STX)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
mavlink_start_checksum(rxmsg);
}
}
else
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_CRC1;
}
break;
case MAVLINK_PARSE_STATE_GOT_CRC1:
if (c != rxmsg->ck_b)
{// Check second checksum byte
status->parse_error++;
status->msg_received = 0;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
if (c == MAVLINK_STX)
{
status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
mavlink_start_checksum(rxmsg);
}
}
else
{
// Successfully got message
status->msg_received = 1;
status->parse_state = MAVLINK_PARSE_STATE_IDLE;
if ( r_message != 0 )
{
memcpy(r_message, rxmsg, sizeof(mavlink_message_t));
}
}
break;
}
bufferIndex++;
// If a message has been sucessfully decoded, check index
if (status->msg_received == 1)
{
//while(status->current_seq != rxmsg->seq)
//{
// status->packet_rx_drop_count++;
// status->current_seq++;
//}
status->current_rx_seq = rxmsg->seq;
// Initial condition: If no packet has been received so far, drop count is undefined
if (status->packet_rx_success_count == 0) status->packet_rx_drop_count = 0;
// Count this packet as received
status->packet_rx_success_count++;
}
r_mavlink_status->current_rx_seq = status->current_rx_seq+1;
r_mavlink_status->packet_rx_success_count = status->packet_rx_success_count;
r_mavlink_status->packet_rx_drop_count = status->parse_error;
status->parse_error = 0;
#ifdef MAVLINK_STATIC_BUFFER
if (status->msg_received == 1)
{
if ( r_message != NULL )
return r_message;
else return rxmsg;
} else return NULL;
#else
if (status->msg_received == 1)
return 1;
else return 0;
#endif
}
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
// To make MAVLink work on your MCU, define a similar function
/*
#include "mavlink_types.h"
void comm_send_ch(mavlink_channel_t chan, uint8_t ch)
{
if (chan == MAVLINK_COMM_0)
{
uart0_transmit(ch);
}
if (chan == MAVLINK_COMM_1)
{
uart1_transmit(ch);
}
}
static inline void mavlink_send_msg(mavlink_channel_t chan, mavlink_message_t* msg)
{
// ARM7 MCU board implementation
// Create pointer on message struct
// Send STX
comm_send_ch(chan, MAVLINK_STX);
comm_send_ch(chan, msg->len);
comm_send_ch(chan, msg->seq);
comm_send_ch(chan, msg->sysid);
comm_send_ch(chan, msg->compid);
comm_send_ch(chan, msg->msgid);
for(uint16_t i = 0; i < msg->len; i++)
{
comm_send_ch(chan, msg->payload[i]);
}
comm_send_ch(chan, msg->ck_a);
comm_send_ch(chan, msg->ck_b);
}
static inline void mavlink_send_mem(mavlink_channel_t chan, (uint8_t *)mem, uint8_t num)
{
// ARM7 MCU board implementation
// Create pointer on message struct
// Send STX
for(uint16_t i = 0; i < num; i++)
{
comm_send_ch( chan, mem[i] );
}
}
*/
static inline void mavlink_send_uart(mavlink_channel_t chan, mavlink_message_t* msg);
static inline void mavlink_send_mem(mavlink_channel_t chan, uint8_t *mem, uint16_t num);
#define mavlink_send_msg( a, b ) mavlink_send_uart( a, b )
#endif
#endif /* _MAVLINK_PROTOCOL_H_ */

213
thirdParty/mavlink/include/pixhawk/mavlink_msg_aux_status.h vendored
Unescape View File

@ -1,213 +0,0 @@ @@ -1,213 +0,0 @@
// MESSAGE AUX_STATUS PACKING
#define MAVLINK_MSG_ID_AUX_STATUS 142
#define MAVLINK_MSG_ID_AUX_STATUS_LEN 12
#define MAVLINK_MSG_142_LEN 12
#define MAVLINK_MSG_ID_AUX_STATUS_KEY 0x7A
#define MAVLINK_MSG_142_KEY 0x7A
typedef struct __mavlink_aux_status_t
{
uint16_t load; ///< Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
uint16_t i2c0_err_count; ///< Number of I2C errors since startup
uint16_t i2c1_err_count; ///< Number of I2C errors since startup
uint16_t spi0_err_count; ///< Number of I2C errors since startup
uint16_t spi1_err_count; ///< Number of I2C errors since startup
uint16_t uart_total_err_count; ///< Number of I2C errors since startup
} mavlink_aux_status_t;
/**
* @brief Pack a aux_status message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
*
* @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
* @param i2c0_err_count Number of I2C errors since startup
* @param i2c1_err_count Number of I2C errors since startup
* @param spi0_err_count Number of I2C errors since startup
* @param spi1_err_count Number of I2C errors since startup
* @param uart_total_err_count Number of I2C errors since startup
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_aux_status_pack(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, uint16_t load, uint16_t i2c0_err_count, uint16_t i2c1_err_count, uint16_t spi0_err_count, uint16_t spi1_err_count, uint16_t uart_total_err_count)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_AUX_STATUS;
p->load = load; // uint16_t:Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
p->i2c0_err_count = i2c0_err_count; // uint16_t:Number of I2C errors since startup
p->i2c1_err_count = i2c1_err_count; // uint16_t:Number of I2C errors since startup
p->spi0_err_count = spi0_err_count; // uint16_t:Number of I2C errors since startup
p->spi1_err_count = spi1_err_count; // uint16_t:Number of I2C errors since startup
p->uart_total_err_count = uart_total_err_count; // uint16_t:Number of I2C errors since startup
return mavlink_finalize_message(msg, system_id, component_id, MAVLINK_MSG_ID_AUX_STATUS_LEN);
}
/**
* @brief Pack a aux_status message
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param chan The MAVLink channel this message was sent over
* @param msg The MAVLink message to compress the data into
* @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
* @param i2c0_err_count Number of I2C errors since startup
* @param i2c1_err_count Number of I2C errors since startup
* @param spi0_err_count Number of I2C errors since startup
* @param spi1_err_count Number of I2C errors since startup
* @param uart_total_err_count Number of I2C errors since startup
* @return length of the message in bytes (excluding serial stream start sign)
*/
static inline uint16_t mavlink_msg_aux_status_pack_chan(uint8_t system_id, uint8_t component_id, uint8_t chan, mavlink_message_t* msg, uint16_t load, uint16_t i2c0_err_count, uint16_t i2c1_err_count, uint16_t spi0_err_count, uint16_t spi1_err_count, uint16_t uart_total_err_count)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
msg->msgid = MAVLINK_MSG_ID_AUX_STATUS;
p->load = load; // uint16_t:Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
p->i2c0_err_count = i2c0_err_count; // uint16_t:Number of I2C errors since startup
p->i2c1_err_count = i2c1_err_count; // uint16_t:Number of I2C errors since startup
p->spi0_err_count = spi0_err_count; // uint16_t:Number of I2C errors since startup
p->spi1_err_count = spi1_err_count; // uint16_t:Number of I2C errors since startup
p->uart_total_err_count = uart_total_err_count; // uint16_t:Number of I2C errors since startup
return mavlink_finalize_message_chan(msg, system_id, component_id, chan, MAVLINK_MSG_ID_AUX_STATUS_LEN);
}
/**
* @brief Encode a aux_status struct into a message
*
* @param system_id ID of this system
* @param component_id ID of this component (e.g. 200 for IMU)
* @param msg The MAVLink message to compress the data into
* @param aux_status C-struct to read the message contents from
*/
static inline uint16_t mavlink_msg_aux_status_encode(uint8_t system_id, uint8_t component_id, mavlink_message_t* msg, const mavlink_aux_status_t* aux_status)
{
return mavlink_msg_aux_status_pack(system_id, component_id, msg, aux_status->load, aux_status->i2c0_err_count, aux_status->i2c1_err_count, aux_status->spi0_err_count, aux_status->spi1_err_count, aux_status->uart_total_err_count);
}
#ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
/**
* @brief Send a aux_status message
* @param chan MAVLink channel to send the message
*
* @param load Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
* @param i2c0_err_count Number of I2C errors since startup
* @param i2c1_err_count Number of I2C errors since startup
* @param spi0_err_count Number of I2C errors since startup
* @param spi1_err_count Number of I2C errors since startup
* @param uart_total_err_count Number of I2C errors since startup
*/
static inline void mavlink_msg_aux_status_send(mavlink_channel_t chan, uint16_t load, uint16_t i2c0_err_count, uint16_t i2c1_err_count, uint16_t spi0_err_count, uint16_t spi1_err_count, uint16_t uart_total_err_count)
{
mavlink_header_t hdr;
mavlink_aux_status_t payload;
MAVLINK_BUFFER_CHECK_START( chan, MAVLINK_MSG_ID_AUX_STATUS_LEN )
payload.load = load; // uint16_t:Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
payload.i2c0_err_count = i2c0_err_count; // uint16_t:Number of I2C errors since startup
payload.i2c1_err_count = i2c1_err_count; // uint16_t:Number of I2C errors since startup
payload.spi0_err_count = spi0_err_count; // uint16_t:Number of I2C errors since startup
payload.spi1_err_count = spi1_err_count; // uint16_t:Number of I2C errors since startup
payload.uart_total_err_count = uart_total_err_count; // uint16_t:Number of I2C errors since startup
hdr.STX = MAVLINK_STX;
hdr.len = MAVLINK_MSG_ID_AUX_STATUS_LEN;
hdr.msgid = MAVLINK_MSG_ID_AUX_STATUS;
hdr.sysid = mavlink_system.sysid;
hdr.compid = mavlink_system.compid;
hdr.seq = mavlink_get_channel_status(chan)->current_tx_seq;
mavlink_get_channel_status(chan)->current_tx_seq = hdr.seq + 1;
mavlink_send_mem(chan, (uint8_t *)&hdr.STX, MAVLINK_NUM_HEADER_BYTES );
mavlink_send_mem(chan, (uint8_t *)&payload, sizeof(payload) );
crc_init(&hdr.ck);
crc_calculate_mem((uint8_t *)&hdr.len, &hdr.ck, MAVLINK_CORE_HEADER_LEN);
crc_calculate_mem((uint8_t *)&payload, &hdr.ck, hdr.len );
crc_accumulate( 0x7A, &hdr.ck); /// include key in X25 checksum
mavlink_send_mem(chan, (uint8_t *)&hdr.ck, MAVLINK_NUM_CHECKSUM_BYTES);
MAVLINK_BUFFER_CHECK_END
}
#endif
// MESSAGE AUX_STATUS UNPACKING
/**
* @brief Get field load from aux_status message
*
* @return Maximum usage in percent of the mainloop time, (0%: 0, 100%: 1000) should be always below 1000
*/
static inline uint16_t mavlink_msg_aux_status_get_load(const mavlink_message_t* msg)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
return (uint16_t)(p->load);
}
/**
* @brief Get field i2c0_err_count from aux_status message
*
* @return Number of I2C errors since startup
*/
static inline uint16_t mavlink_msg_aux_status_get_i2c0_err_count(const mavlink_message_t* msg)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
return (uint16_t)(p->i2c0_err_count);
}
/**
* @brief Get field i2c1_err_count from aux_status message
*
* @return Number of I2C errors since startup
*/
static inline uint16_t mavlink_msg_aux_status_get_i2c1_err_count(const mavlink_message_t* msg)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
return (uint16_t)(p->i2c1_err_count);
}
/**
* @brief Get field spi0_err_count from aux_status message
*
* @return Number of I2C errors since startup
*/
static inline uint16_t mavlink_msg_aux_status_get_spi0_err_count(const mavlink_message_t* msg)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
return (uint16_t)(p->spi0_err_count);
}
/**
* @brief Get field spi1_err_count from aux_status message
*
* @return Number of I2C errors since startup
*/
static inline uint16_t mavlink_msg_aux_status_get_spi1_err_count(const mavlink_message_t* msg)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
return (uint16_t)(p->spi1_err_count);
}
/**
* @brief Get field uart_total_err_count from aux_status message
*
* @return Number of I2C errors since startup
*/
static inline uint16_t mavlink_msg_aux_status_get_uart_total_err_count(const mavlink_message_t* msg)
{
mavlink_aux_status_t *p = (mavlink_aux_status_t *)&msg->payload[0];
return (uint16_t)(p->uart_total_err_count);
}
/**
* @brief Decode a aux_status message into a struct
*
* @param msg The message to decode
* @param aux_status C-struct to decode the message contents into
*/
static inline void mavlink_msg_aux_status_decode(const mavlink_message_t* msg, mavlink_aux_status_t* aux_status)
{
memcpy( aux_status, msg->payload, sizeof(mavlink_aux_status_t));
}
Write Preview
Loading…
Cancel
Save