Skip to content

Q
qgroundcontrol
Commit ce112d3a authored by lm's avatar lm
Browse files
Options

Prepping merge

parent b303e674
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 2299 deletions
thirdParty/mavlink/include/common/mavlink_msg_attitude_controller_output.h deleted 100644 → 0
View file @ b303e674
// 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));
}
thirdParty/mavlink/include/common/mavlink_msg_cmd_ack.h deleted 100644 → 0
View file @ b303e674
// 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));
}
thirdParty/mavlink/include/common/mavlink_msg_position_controller_output.h deleted 100644 → 0
View file @ b303e674
// 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));
}
thirdParty/mavlink/include/common/mavlink_msg_roll_pitch_yaw_setpoint.h deleted 100644 → 0
View file @ b303e674
// 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));
}
thirdParty/mavlink/include/common/mavlink_msg_roll_pitch_yaw_speed_setpoint.h deleted 100644 → 0
View file @ b303e674
// 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));
}
thirdParty/mavlink/include/common/mavlink_msg_set_roll_pitch_yaw.h deleted 100644 → 0
View file @ b303e674
// 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));
}
thirdParty/mavlink/include/common/mavlink_msg_set_roll_pitch_yaw_speed.h deleted 100644 → 0
View file @ b303e674
// 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));
}
thirdParty/mavlink/include/documentation.dox deleted 100644 → 0
View file @ b303e674
/**
* @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.
*
*
*
**/
thirdParty/mavlink/include/mavlink_checksum.h deleted 100644 → 0
View file @ b303e674
/** @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
thirdParty/mavlink/include/mavlink_data.h deleted 100644 → 0
View file @ b303e674
/** @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
thirdParty/mavlink/include/mavlink_options.h deleted 100644 → 0
View file @ b303e674
/** @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
thirdParty/mavlink/include/mavlink_protocol.h deleted 100644 → 0
View file @ b303e674
/** @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_ */
thirdParty/mavlink/include/pixhawk/mavlink_msg_aux_status.h deleted 100644 → 0
View file @ b303e674
// 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));
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment