You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1501 lines
30 KiB
1501 lines
30 KiB
// |
|
// THIS FILE WAS AUTOMATICALLY GENERATED - DO NOT EDIT |
|
// |
|
/// @file protocol.h |
|
#pragma pack(push) |
|
#pragma pack(1) |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_ACKNOWLEDGE |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_ACKNOWLEDGE message |
|
struct msg_acknowledge { |
|
uint8_t msgID; |
|
uint8_t sum1; |
|
uint8_t sum2; |
|
}; |
|
|
|
/// Send a MSG_ACKNOWLEDGE message |
|
inline void |
|
send_msg_acknowledge( |
|
const uint8_t msgID, |
|
const uint8_t sum1, |
|
const uint8_t sum2) |
|
{ |
|
_startMessage(MSG_ACKNOWLEDGE, |
|
sizeof(msgID) + |
|
sizeof(sum1) + |
|
sizeof(sum2) + 0); |
|
_emit(msgID); |
|
_emit(sum1); |
|
_emit(sum2); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_ACKNOWLEDGE message |
|
inline void |
|
unpack_msg_acknowledge( |
|
uint8_t &msgID, |
|
uint8_t &sum1, |
|
uint8_t &sum2) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, msgID); |
|
_unpack(__p, sum1); |
|
_unpack(__p, sum2); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_STATUS_TEXT |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_STATUS_TEXT message |
|
struct msg_status_text { |
|
uint8_t severity; |
|
char text[50]; |
|
}; |
|
|
|
/// Send a MSG_STATUS_TEXT message |
|
inline void |
|
send_msg_status_text( |
|
const uint8_t severity, |
|
const char (&text)[50]) |
|
{ |
|
_startMessage(MSG_STATUS_TEXT, |
|
sizeof(severity) + |
|
(sizeof(text[0]) * 50) + 0); |
|
_emit(severity); |
|
_emit(text, 50); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_STATUS_TEXT message |
|
inline void |
|
unpack_msg_status_text( |
|
uint8_t &severity, |
|
char (&text)[50]) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, severity); |
|
_unpack(__p, text, 50); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_HEARTBEAT |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_HEARTBEAT message |
|
struct msg_heartbeat { |
|
uint8_t flightMode; |
|
uint16_t timeStamp; |
|
uint16_t batteryVoltage; |
|
uint16_t commandIndex; |
|
}; |
|
|
|
/// Send a MSG_HEARTBEAT message |
|
inline void |
|
send_msg_heartbeat( |
|
const uint8_t flightMode, |
|
const uint16_t timeStamp, |
|
const uint16_t batteryVoltage, |
|
const uint16_t commandIndex) |
|
{ |
|
_startMessage(MSG_HEARTBEAT, |
|
sizeof(flightMode) + |
|
sizeof(timeStamp) + |
|
sizeof(batteryVoltage) + |
|
sizeof(commandIndex) + 0); |
|
_emit(flightMode); |
|
_emit(timeStamp); |
|
_emit(batteryVoltage); |
|
_emit(commandIndex); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_HEARTBEAT message |
|
inline void |
|
unpack_msg_heartbeat( |
|
uint8_t &flightMode, |
|
uint16_t &timeStamp, |
|
uint16_t &batteryVoltage, |
|
uint16_t &commandIndex) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, flightMode); |
|
_unpack(__p, timeStamp); |
|
_unpack(__p, batteryVoltage); |
|
_unpack(__p, commandIndex); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_ATTITUDE |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_ATTITUDE message |
|
struct msg_attitude { |
|
int16_t roll; |
|
int16_t pitch; |
|
uint16_t yaw; |
|
}; |
|
|
|
/// Send a MSG_ATTITUDE message |
|
inline void |
|
send_msg_attitude( |
|
const int16_t roll, |
|
const int16_t pitch, |
|
const uint16_t yaw) |
|
{ |
|
_startMessage(MSG_ATTITUDE, |
|
sizeof(roll) + |
|
sizeof(pitch) + |
|
sizeof(yaw) + 0); |
|
_emit(roll); |
|
_emit(pitch); |
|
_emit(yaw); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_ATTITUDE message |
|
inline void |
|
unpack_msg_attitude( |
|
int16_t &roll, |
|
int16_t &pitch, |
|
uint16_t &yaw) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, roll); |
|
_unpack(__p, pitch); |
|
_unpack(__p, yaw); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_LOCATION |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_LOCATION message |
|
struct msg_location { |
|
int32_t latitude; |
|
int32_t longitude; |
|
int32_t altitude; |
|
uint16_t groundSpeed; |
|
uint16_t groundCourse; |
|
uint32_t timeOfWeek; |
|
}; |
|
|
|
/// Send a MSG_LOCATION message |
|
inline void |
|
send_msg_location( |
|
const int32_t latitude, |
|
const int32_t longitude, |
|
const int32_t altitude, |
|
const uint16_t groundSpeed, |
|
const uint16_t groundCourse, |
|
const uint32_t timeOfWeek) |
|
{ |
|
_startMessage(MSG_LOCATION, |
|
sizeof(latitude) + |
|
sizeof(longitude) + |
|
sizeof(altitude) + |
|
sizeof(groundSpeed) + |
|
sizeof(groundCourse) + |
|
sizeof(timeOfWeek) + 0); |
|
_emit(latitude); |
|
_emit(longitude); |
|
_emit(altitude); |
|
_emit(groundSpeed); |
|
_emit(groundCourse); |
|
_emit(timeOfWeek); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_LOCATION message |
|
inline void |
|
unpack_msg_location( |
|
int32_t &latitude, |
|
int32_t &longitude, |
|
int32_t &altitude, |
|
uint16_t &groundSpeed, |
|
uint16_t &groundCourse, |
|
uint32_t &timeOfWeek) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, latitude); |
|
_unpack(__p, longitude); |
|
_unpack(__p, altitude); |
|
_unpack(__p, groundSpeed); |
|
_unpack(__p, groundCourse); |
|
_unpack(__p, timeOfWeek); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_PRESSURE |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_PRESSURE message |
|
struct msg_pressure { |
|
int32_t pressureAltitude; |
|
int16_t airSpeed; |
|
}; |
|
|
|
/// Send a MSG_PRESSURE message |
|
inline void |
|
send_msg_pressure( |
|
const int32_t pressureAltitude, |
|
const int16_t airSpeed) |
|
{ |
|
_startMessage(MSG_PRESSURE, |
|
sizeof(pressureAltitude) + |
|
sizeof(airSpeed) + 0); |
|
_emit(pressureAltitude); |
|
_emit(airSpeed); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_PRESSURE message |
|
inline void |
|
unpack_msg_pressure( |
|
int32_t &pressureAltitude, |
|
int16_t &airSpeed) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, pressureAltitude); |
|
_unpack(__p, airSpeed); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_PERF_REPORT |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_PERF_REPORT message |
|
struct msg_perf_report { |
|
uint32_t interval; |
|
uint16_t mainLoopCycles; |
|
uint8_t mainLoopCycleTime; |
|
uint8_t gyroSaturationCount; |
|
uint8_t adcConstraintCount; |
|
uint8_t renormSqrtCount; |
|
uint8_t renormBlowupCount; |
|
uint8_t gpsFixCount; |
|
uint16_t imuHealth; |
|
uint16_t gcsMessageCount; |
|
}; |
|
|
|
/// Send a MSG_PERF_REPORT message |
|
inline void |
|
send_msg_perf_report( |
|
const uint32_t interval, |
|
const uint16_t mainLoopCycles, |
|
const uint8_t mainLoopCycleTime, |
|
const uint8_t gyroSaturationCount, |
|
const uint8_t adcConstraintCount, |
|
const uint8_t renormSqrtCount, |
|
const uint8_t renormBlowupCount, |
|
const uint8_t gpsFixCount, |
|
const uint16_t imuHealth, |
|
const uint16_t gcsMessageCount) |
|
{ |
|
_startMessage(MSG_PERF_REPORT, |
|
sizeof(interval) + |
|
sizeof(mainLoopCycles) + |
|
sizeof(mainLoopCycleTime) + |
|
sizeof(gyroSaturationCount) + |
|
sizeof(adcConstraintCount) + |
|
sizeof(renormSqrtCount) + |
|
sizeof(renormBlowupCount) + |
|
sizeof(gpsFixCount) + |
|
sizeof(imuHealth) + |
|
sizeof(gcsMessageCount) + 0); |
|
_emit(interval); |
|
_emit(mainLoopCycles); |
|
_emit(mainLoopCycleTime); |
|
_emit(gyroSaturationCount); |
|
_emit(adcConstraintCount); |
|
_emit(renormSqrtCount); |
|
_emit(renormBlowupCount); |
|
_emit(gpsFixCount); |
|
_emit(imuHealth); |
|
_emit(gcsMessageCount); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_PERF_REPORT message |
|
inline void |
|
unpack_msg_perf_report( |
|
uint32_t &interval, |
|
uint16_t &mainLoopCycles, |
|
uint8_t &mainLoopCycleTime, |
|
uint8_t &gyroSaturationCount, |
|
uint8_t &adcConstraintCount, |
|
uint8_t &renormSqrtCount, |
|
uint8_t &renormBlowupCount, |
|
uint8_t &gpsFixCount, |
|
uint16_t &imuHealth, |
|
uint16_t &gcsMessageCount) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, interval); |
|
_unpack(__p, mainLoopCycles); |
|
_unpack(__p, mainLoopCycleTime); |
|
_unpack(__p, gyroSaturationCount); |
|
_unpack(__p, adcConstraintCount); |
|
_unpack(__p, renormSqrtCount); |
|
_unpack(__p, renormBlowupCount); |
|
_unpack(__p, gpsFixCount); |
|
_unpack(__p, imuHealth); |
|
_unpack(__p, gcsMessageCount); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_VERSION_REQUEST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_VERSION_REQUEST message |
|
struct msg_version_request { |
|
uint8_t systemType; |
|
uint8_t systemID; |
|
}; |
|
|
|
/// Send a MSG_VERSION_REQUEST message |
|
inline void |
|
send_msg_version_request( |
|
const uint8_t systemType, |
|
const uint8_t systemID) |
|
{ |
|
_startMessage(MSG_VERSION_REQUEST, |
|
sizeof(systemType) + |
|
sizeof(systemID) + 0); |
|
_emit(systemType); |
|
_emit(systemID); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_VERSION_REQUEST message |
|
inline void |
|
unpack_msg_version_request( |
|
uint8_t &systemType, |
|
uint8_t &systemID) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, systemType); |
|
_unpack(__p, systemID); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_VERSION |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_VERSION message |
|
struct msg_version { |
|
uint8_t systemType; |
|
uint8_t systemID; |
|
uint8_t firmwareVersion[3]; |
|
}; |
|
|
|
/// Send a MSG_VERSION message |
|
inline void |
|
send_msg_version( |
|
const uint8_t systemType, |
|
const uint8_t systemID, |
|
const uint8_t (&firmwareVersion)[3]) |
|
{ |
|
_startMessage(MSG_VERSION, |
|
sizeof(systemType) + |
|
sizeof(systemID) + |
|
(sizeof(firmwareVersion[0]) * 3) + 0); |
|
_emit(systemType); |
|
_emit(systemID); |
|
_emit(firmwareVersion, 3); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_VERSION message |
|
inline void |
|
unpack_msg_version( |
|
uint8_t &systemType, |
|
uint8_t &systemID, |
|
uint8_t (&firmwareVersion)[3]) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, systemType); |
|
_unpack(__p, systemID); |
|
_unpack(__p, firmwareVersion, 3); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_COMMAND_REQUEST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_COMMAND_REQUEST message |
|
struct msg_command_request { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_COMMAND_REQUEST message |
|
inline void |
|
send_msg_command_request( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_COMMAND_REQUEST, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_COMMAND_REQUEST message |
|
inline void |
|
unpack_msg_command_request( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_COMMAND_UPLOAD |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_COMMAND_UPLOAD message |
|
struct msg_command_upload { |
|
uint8_t action; |
|
uint16_t itemNumber; |
|
uint16_t listLength; |
|
uint8_t commandID; |
|
uint8_t p1; |
|
int32_t p2; |
|
int32_t p3; |
|
int32_t p4; |
|
}; |
|
|
|
/// Send a MSG_COMMAND_UPLOAD message |
|
inline void |
|
send_msg_command_upload( |
|
const uint8_t action, |
|
const uint16_t itemNumber, |
|
const uint16_t listLength, |
|
const uint8_t commandID, |
|
const uint8_t p1, |
|
const int32_t p2, |
|
const int32_t p3, |
|
const int32_t p4) |
|
{ |
|
_startMessage(MSG_COMMAND_UPLOAD, |
|
sizeof(action) + |
|
sizeof(itemNumber) + |
|
sizeof(listLength) + |
|
sizeof(commandID) + |
|
sizeof(p1) + |
|
sizeof(p2) + |
|
sizeof(p3) + |
|
sizeof(p4) + 0); |
|
_emit(action); |
|
_emit(itemNumber); |
|
_emit(listLength); |
|
_emit(commandID); |
|
_emit(p1); |
|
_emit(p2); |
|
_emit(p3); |
|
_emit(p4); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_COMMAND_UPLOAD message |
|
inline void |
|
unpack_msg_command_upload( |
|
uint8_t &action, |
|
uint16_t &itemNumber, |
|
uint16_t &listLength, |
|
uint8_t &commandID, |
|
uint8_t &p1, |
|
int32_t &p2, |
|
int32_t &p3, |
|
int32_t &p4) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, action); |
|
_unpack(__p, itemNumber); |
|
_unpack(__p, listLength); |
|
_unpack(__p, commandID); |
|
_unpack(__p, p1); |
|
_unpack(__p, p2); |
|
_unpack(__p, p3); |
|
_unpack(__p, p4); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_COMMAND_LIST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_COMMAND_LIST message |
|
struct msg_command_list { |
|
uint16_t itemNumber; |
|
uint16_t listLength; |
|
uint8_t commandID; |
|
uint8_t p1; |
|
int32_t p2; |
|
int32_t p3; |
|
int32_t p4; |
|
}; |
|
|
|
/// Send a MSG_COMMAND_LIST message |
|
inline void |
|
send_msg_command_list( |
|
const uint16_t itemNumber, |
|
const uint16_t listLength, |
|
const uint8_t commandID, |
|
const uint8_t p1, |
|
const int32_t p2, |
|
const int32_t p3, |
|
const int32_t p4) |
|
{ |
|
_startMessage(MSG_COMMAND_LIST, |
|
sizeof(itemNumber) + |
|
sizeof(listLength) + |
|
sizeof(commandID) + |
|
sizeof(p1) + |
|
sizeof(p2) + |
|
sizeof(p3) + |
|
sizeof(p4) + 0); |
|
_emit(itemNumber); |
|
_emit(listLength); |
|
_emit(commandID); |
|
_emit(p1); |
|
_emit(p2); |
|
_emit(p3); |
|
_emit(p4); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_COMMAND_LIST message |
|
inline void |
|
unpack_msg_command_list( |
|
uint16_t &itemNumber, |
|
uint16_t &listLength, |
|
uint8_t &commandID, |
|
uint8_t &p1, |
|
int32_t &p2, |
|
int32_t &p3, |
|
int32_t &p4) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, itemNumber); |
|
_unpack(__p, listLength); |
|
_unpack(__p, commandID); |
|
_unpack(__p, p1); |
|
_unpack(__p, p2); |
|
_unpack(__p, p3); |
|
_unpack(__p, p4); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_COMMAND_MODE_CHANGE |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_COMMAND_MODE_CHANGE message |
|
struct msg_command_mode_change { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_COMMAND_MODE_CHANGE message |
|
inline void |
|
send_msg_command_mode_change( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_COMMAND_MODE_CHANGE, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_COMMAND_MODE_CHANGE message |
|
inline void |
|
unpack_msg_command_mode_change( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_VALUE_REQUEST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_VALUE_REQUEST message |
|
struct msg_value_request { |
|
uint8_t valueID; |
|
uint8_t broadcast; |
|
}; |
|
|
|
/// Send a MSG_VALUE_REQUEST message |
|
inline void |
|
send_msg_value_request( |
|
const uint8_t valueID, |
|
const uint8_t broadcast) |
|
{ |
|
_startMessage(MSG_VALUE_REQUEST, |
|
sizeof(valueID) + |
|
sizeof(broadcast) + 0); |
|
_emit(valueID); |
|
_emit(broadcast); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_VALUE_REQUEST message |
|
inline void |
|
unpack_msg_value_request( |
|
uint8_t &valueID, |
|
uint8_t &broadcast) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, valueID); |
|
_unpack(__p, broadcast); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_VALUE_SET |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_VALUE_SET message |
|
struct msg_value_set { |
|
uint8_t valueID; |
|
uint32_t value; |
|
}; |
|
|
|
/// Send a MSG_VALUE_SET message |
|
inline void |
|
send_msg_value_set( |
|
const uint8_t valueID, |
|
const uint32_t value) |
|
{ |
|
_startMessage(MSG_VALUE_SET, |
|
sizeof(valueID) + |
|
sizeof(value) + 0); |
|
_emit(valueID); |
|
_emit(value); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_VALUE_SET message |
|
inline void |
|
unpack_msg_value_set( |
|
uint8_t &valueID, |
|
uint32_t &value) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, valueID); |
|
_unpack(__p, value); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_VALUE |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_VALUE message |
|
struct msg_value { |
|
uint8_t valueID; |
|
uint32_t value; |
|
}; |
|
|
|
/// Send a MSG_VALUE message |
|
inline void |
|
send_msg_value( |
|
const uint8_t valueID, |
|
const uint32_t value) |
|
{ |
|
_startMessage(MSG_VALUE, |
|
sizeof(valueID) + |
|
sizeof(value) + 0); |
|
_emit(valueID); |
|
_emit(value); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_VALUE message |
|
inline void |
|
unpack_msg_value( |
|
uint8_t &valueID, |
|
uint32_t &value) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, valueID); |
|
_unpack(__p, value); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_PID_REQUEST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_PID_REQUEST message |
|
struct msg_pid_request { |
|
uint8_t pidSet; |
|
}; |
|
|
|
/// Send a MSG_PID_REQUEST message |
|
inline void |
|
send_msg_pid_request( |
|
const uint8_t pidSet) |
|
{ |
|
_startMessage(MSG_PID_REQUEST, |
|
sizeof(pidSet) + 0); |
|
_emit(pidSet); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_PID_REQUEST message |
|
inline void |
|
unpack_msg_pid_request( |
|
uint8_t &pidSet) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, pidSet); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_PID_SET |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_PID_SET message |
|
struct msg_pid_set { |
|
uint8_t pidSet; |
|
int32_t p; |
|
int32_t i; |
|
int32_t d; |
|
int16_t integratorMax; |
|
}; |
|
|
|
/// Send a MSG_PID_SET message |
|
inline void |
|
send_msg_pid_set( |
|
const uint8_t pidSet, |
|
const int32_t p, |
|
const int32_t i, |
|
const int32_t d, |
|
const int16_t integratorMax) |
|
{ |
|
_startMessage(MSG_PID_SET, |
|
sizeof(pidSet) + |
|
sizeof(p) + |
|
sizeof(i) + |
|
sizeof(d) + |
|
sizeof(integratorMax) + 0); |
|
_emit(pidSet); |
|
_emit(p); |
|
_emit(i); |
|
_emit(d); |
|
_emit(integratorMax); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_PID_SET message |
|
inline void |
|
unpack_msg_pid_set( |
|
uint8_t &pidSet, |
|
int32_t &p, |
|
int32_t &i, |
|
int32_t &d, |
|
int16_t &integratorMax) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, pidSet); |
|
_unpack(__p, p); |
|
_unpack(__p, i); |
|
_unpack(__p, d); |
|
_unpack(__p, integratorMax); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_PID |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_PID message |
|
struct msg_pid { |
|
uint8_t pidSet; |
|
int32_t p; |
|
int32_t i; |
|
int32_t d; |
|
int16_t integratorMax; |
|
}; |
|
|
|
/// Send a MSG_PID message |
|
inline void |
|
send_msg_pid( |
|
const uint8_t pidSet, |
|
const int32_t p, |
|
const int32_t i, |
|
const int32_t d, |
|
const int16_t integratorMax) |
|
{ |
|
_startMessage(MSG_PID, |
|
sizeof(pidSet) + |
|
sizeof(p) + |
|
sizeof(i) + |
|
sizeof(d) + |
|
sizeof(integratorMax) + 0); |
|
_emit(pidSet); |
|
_emit(p); |
|
_emit(i); |
|
_emit(d); |
|
_emit(integratorMax); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_PID message |
|
inline void |
|
unpack_msg_pid( |
|
uint8_t &pidSet, |
|
int32_t &p, |
|
int32_t &i, |
|
int32_t &d, |
|
int16_t &integratorMax) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, pidSet); |
|
_unpack(__p, p); |
|
_unpack(__p, i); |
|
_unpack(__p, d); |
|
_unpack(__p, integratorMax); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_TRIM_STARTUP |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_TRIM_STARTUP message |
|
struct msg_trim_startup { |
|
uint16_t value[8]; |
|
}; |
|
|
|
/// Send a MSG_TRIM_STARTUP message |
|
inline void |
|
send_msg_trim_startup( |
|
const uint16_t (&value)[8]) |
|
{ |
|
_startMessage(MSG_TRIM_STARTUP, |
|
(sizeof(value[0]) * 8) + 0); |
|
_emit(value, 8); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_TRIM_STARTUP message |
|
inline void |
|
unpack_msg_trim_startup( |
|
uint16_t (&value)[8]) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, value, 8); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_TRIM_MIN |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_TRIM_MIN message |
|
struct msg_trim_min { |
|
uint16_t value[8]; |
|
}; |
|
|
|
/// Send a MSG_TRIM_MIN message |
|
inline void |
|
send_msg_trim_min( |
|
const uint16_t (&value)[8]) |
|
{ |
|
_startMessage(MSG_TRIM_MIN, |
|
(sizeof(value[0]) * 8) + 0); |
|
_emit(value, 8); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_TRIM_MIN message |
|
inline void |
|
unpack_msg_trim_min( |
|
uint16_t (&value)[8]) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, value, 8); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_TRIM_MAX |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_TRIM_MAX message |
|
struct msg_trim_max { |
|
uint16_t value[8]; |
|
}; |
|
|
|
/// Send a MSG_TRIM_MAX message |
|
inline void |
|
send_msg_trim_max( |
|
const uint16_t (&value)[8]) |
|
{ |
|
_startMessage(MSG_TRIM_MAX, |
|
(sizeof(value[0]) * 8) + 0); |
|
_emit(value, 8); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_TRIM_MAX message |
|
inline void |
|
unpack_msg_trim_max( |
|
uint16_t (&value)[8]) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, value, 8); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_RADIO_OUT |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_RADIO_OUT message |
|
struct msg_radio_out { |
|
uint16_t value[8]; |
|
}; |
|
|
|
/// Send a MSG_RADIO_OUT message |
|
inline void |
|
send_msg_radio_out( |
|
const uint16_t (&value)[8]) |
|
{ |
|
_startMessage(MSG_RADIO_OUT, |
|
(sizeof(value[0]) * 8) + 0); |
|
_emit(value, 8); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_RADIO_OUT message |
|
inline void |
|
unpack_msg_radio_out( |
|
uint16_t (&value)[8]) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, value, 8); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_SENSOR |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_SENSOR message |
|
struct msg_sensor { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_SENSOR message |
|
inline void |
|
send_msg_sensor( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_SENSOR, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_SENSOR message |
|
inline void |
|
unpack_msg_sensor( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_SERVO_OUT |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_SERVO_OUT message |
|
struct msg_servo_out { |
|
int16_t value[8]; |
|
}; |
|
|
|
/// Send a MSG_SERVO_OUT message |
|
inline void |
|
send_msg_servo_out( |
|
const int16_t (&value)[8]) |
|
{ |
|
_startMessage(MSG_SERVO_OUT, |
|
(sizeof(value[0]) * 8) + 0); |
|
_emit(value, 8); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_SERVO_OUT message |
|
inline void |
|
unpack_msg_servo_out( |
|
int16_t (&value)[8]) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, value, 8); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_PIN_REQUEST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_PIN_REQUEST message |
|
struct msg_pin_request { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_PIN_REQUEST message |
|
inline void |
|
send_msg_pin_request( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_PIN_REQUEST, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_PIN_REQUEST message |
|
inline void |
|
unpack_msg_pin_request( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_PIN_SET |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_PIN_SET message |
|
struct msg_pin_set { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_PIN_SET message |
|
inline void |
|
send_msg_pin_set( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_PIN_SET, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_PIN_SET message |
|
inline void |
|
unpack_msg_pin_set( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_DATAFLASH_REQUEST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_DATAFLASH_REQUEST message |
|
struct msg_dataflash_request { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_DATAFLASH_REQUEST message |
|
inline void |
|
send_msg_dataflash_request( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_DATAFLASH_REQUEST, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_DATAFLASH_REQUEST message |
|
inline void |
|
unpack_msg_dataflash_request( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_DATAFLASH_SET |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_DATAFLASH_SET message |
|
struct msg_dataflash_set { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_DATAFLASH_SET message |
|
inline void |
|
send_msg_dataflash_set( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_DATAFLASH_SET, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_DATAFLASH_SET message |
|
inline void |
|
unpack_msg_dataflash_set( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_EEPROM_REQUEST |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_EEPROM_REQUEST message |
|
struct msg_eeprom_request { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_EEPROM_REQUEST message |
|
inline void |
|
send_msg_eeprom_request( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_EEPROM_REQUEST, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_EEPROM_REQUEST message |
|
inline void |
|
unpack_msg_eeprom_request( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_EEPROM_SET |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_EEPROM_SET message |
|
struct msg_eeprom_set { |
|
uint16_t UNSPECIFIED; |
|
}; |
|
|
|
/// Send a MSG_EEPROM_SET message |
|
inline void |
|
send_msg_eeprom_set( |
|
const uint16_t UNSPECIFIED) |
|
{ |
|
_startMessage(MSG_EEPROM_SET, |
|
sizeof(UNSPECIFIED) + 0); |
|
_emit(UNSPECIFIED); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_EEPROM_SET message |
|
inline void |
|
unpack_msg_eeprom_set( |
|
uint16_t &UNSPECIFIED) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, UNSPECIFIED); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_POSITION_CORRECT |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_POSITION_CORRECT message |
|
struct msg_position_correct { |
|
int16_t latError; |
|
int16_t lonError; |
|
int16_t altError; |
|
int16_t groundSpeedError; |
|
}; |
|
|
|
/// Send a MSG_POSITION_CORRECT message |
|
inline void |
|
send_msg_position_correct( |
|
const int16_t latError, |
|
const int16_t lonError, |
|
const int16_t altError, |
|
const int16_t groundSpeedError) |
|
{ |
|
_startMessage(MSG_POSITION_CORRECT, |
|
sizeof(latError) + |
|
sizeof(lonError) + |
|
sizeof(altError) + |
|
sizeof(groundSpeedError) + 0); |
|
_emit(latError); |
|
_emit(lonError); |
|
_emit(altError); |
|
_emit(groundSpeedError); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_POSITION_CORRECT message |
|
inline void |
|
unpack_msg_position_correct( |
|
int16_t &latError, |
|
int16_t &lonError, |
|
int16_t &altError, |
|
int16_t &groundSpeedError) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, latError); |
|
_unpack(__p, lonError); |
|
_unpack(__p, altError); |
|
_unpack(__p, groundSpeedError); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_ATTITUDE_CORRECT |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_ATTITUDE_CORRECT message |
|
struct msg_attitude_correct { |
|
int16_t rollError; |
|
int16_t pitchError; |
|
int16_t yawError; |
|
}; |
|
|
|
/// Send a MSG_ATTITUDE_CORRECT message |
|
inline void |
|
send_msg_attitude_correct( |
|
const int16_t rollError, |
|
const int16_t pitchError, |
|
const int16_t yawError) |
|
{ |
|
_startMessage(MSG_ATTITUDE_CORRECT, |
|
sizeof(rollError) + |
|
sizeof(pitchError) + |
|
sizeof(yawError) + 0); |
|
_emit(rollError); |
|
_emit(pitchError); |
|
_emit(yawError); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_ATTITUDE_CORRECT message |
|
inline void |
|
unpack_msg_attitude_correct( |
|
int16_t &rollError, |
|
int16_t &pitchError, |
|
int16_t &yawError) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, rollError); |
|
_unpack(__p, pitchError); |
|
_unpack(__p, yawError); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_POSITION_SET |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_POSITION_SET message |
|
struct msg_position_set { |
|
int32_t latitude; |
|
int32_t longitude; |
|
int32_t altitude; |
|
uint16_t heading; |
|
}; |
|
|
|
/// Send a MSG_POSITION_SET message |
|
inline void |
|
send_msg_position_set( |
|
const int32_t latitude, |
|
const int32_t longitude, |
|
const int32_t altitude, |
|
const uint16_t heading) |
|
{ |
|
_startMessage(MSG_POSITION_SET, |
|
sizeof(latitude) + |
|
sizeof(longitude) + |
|
sizeof(altitude) + |
|
sizeof(heading) + 0); |
|
_emit(latitude); |
|
_emit(longitude); |
|
_emit(altitude); |
|
_emit(heading); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_POSITION_SET message |
|
inline void |
|
unpack_msg_position_set( |
|
int32_t &latitude, |
|
int32_t &longitude, |
|
int32_t &altitude, |
|
uint16_t &heading) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, latitude); |
|
_unpack(__p, longitude); |
|
_unpack(__p, altitude); |
|
_unpack(__p, heading); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// @name MSG_ATTITUDE_SET |
|
//@{ |
|
|
|
/// Structure describing the payload section of the MSG_ATTITUDE_SET message |
|
struct msg_attitude_set { |
|
int16_t roll; |
|
int16_t pitch; |
|
uint16_t yaw; |
|
}; |
|
|
|
/// Send a MSG_ATTITUDE_SET message |
|
inline void |
|
send_msg_attitude_set( |
|
const int16_t roll, |
|
const int16_t pitch, |
|
const uint16_t yaw) |
|
{ |
|
_startMessage(MSG_ATTITUDE_SET, |
|
sizeof(roll) + |
|
sizeof(pitch) + |
|
sizeof(yaw) + 0); |
|
_emit(roll); |
|
_emit(pitch); |
|
_emit(yaw); |
|
_endMessage(); |
|
}; |
|
|
|
/// Unpack a MSG_ATTITUDE_SET message |
|
inline void |
|
unpack_msg_attitude_set( |
|
int16_t &roll, |
|
int16_t &pitch, |
|
uint16_t &yaw) |
|
{ |
|
uint8_t *__p = &_decodeBuf.payload[0]; |
|
_unpack(__p, roll); |
|
_unpack(__p, pitch); |
|
_unpack(__p, yaw); |
|
}; |
|
//@} |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// Message ID values |
|
enum MessageID { |
|
MSG_PID = 0x42, |
|
MSG_DATAFLASH_REQUEST = 0x90, |
|
MSG_DATAFLASH_SET = 0x91, |
|
MSG_SENSOR = 0x60, |
|
MSG_VALUE_REQUEST = 0x30, |
|
MSG_VALUE_SET = 0x31, |
|
MSG_VALUE = 0x32, |
|
MSG_PIN_REQUEST = 0x80, |
|
MSG_PIN_SET = 0x81, |
|
MSG_POSITION_CORRECT = 0xb0, |
|
MSG_ACKNOWLEDGE = 0x0, |
|
MSG_ATTITUDE_CORRECT = 0xb1, |
|
MSG_HEARTBEAT = 0x1, |
|
MSG_POSITION_SET = 0xb2, |
|
MSG_ATTITUDE = 0x2, |
|
MSG_ATTITUDE_SET = 0xb3, |
|
MSG_LOCATION = 0x3, |
|
MSG_PRESSURE = 0x4, |
|
MSG_TRIM_STARTUP = 0x50, |
|
MSG_STATUS_TEXT = 0x5, |
|
MSG_TRIM_MIN = 0x51, |
|
MSG_PERF_REPORT = 0x6, |
|
MSG_TRIM_MAX = 0x52, |
|
MSG_VERSION_REQUEST = 0x7, |
|
MSG_RADIO_OUT = 0x53, |
|
MSG_VERSION = 0x8, |
|
MSG_COMMAND_REQUEST = 0x20, |
|
MSG_COMMAND_UPLOAD = 0x21, |
|
MSG_COMMAND_LIST = 0x22, |
|
MSG_COMMAND_MODE_CHANGE = 0x23, |
|
MSG_SERVO_OUT = 0x70, |
|
MSG_EEPROM_REQUEST = 0xa0, |
|
MSG_EEPROM_SET = 0xa1, |
|
MSG_PID_REQUEST = 0x40, |
|
MSG_PID_SET = 0x41, |
|
MSG_ANY = 0xfe, |
|
MSG_NULL = 0xff |
|
}; |
|
|
|
////////////////////////////////////////////////////////////////////// |
|
/// Message buffer sizing |
|
union _binCommBufferSizer { |
|
struct msg_acknowledge msg_acknowledge; |
|
struct msg_status_text msg_status_text; |
|
struct msg_heartbeat msg_heartbeat; |
|
struct msg_attitude msg_attitude; |
|
struct msg_location msg_location; |
|
struct msg_pressure msg_pressure; |
|
struct msg_perf_report msg_perf_report; |
|
struct msg_version_request msg_version_request; |
|
struct msg_version msg_version; |
|
struct msg_command_request msg_command_request; |
|
struct msg_command_upload msg_command_upload; |
|
struct msg_command_list msg_command_list; |
|
struct msg_command_mode_change msg_command_mode_change; |
|
struct msg_value_request msg_value_request; |
|
struct msg_value_set msg_value_set; |
|
struct msg_value msg_value; |
|
struct msg_pid_request msg_pid_request; |
|
struct msg_pid_set msg_pid_set; |
|
struct msg_pid msg_pid; |
|
struct msg_trim_startup msg_trim_startup; |
|
struct msg_trim_min msg_trim_min; |
|
struct msg_trim_max msg_trim_max; |
|
struct msg_radio_out msg_radio_out; |
|
struct msg_sensor msg_sensor; |
|
struct msg_servo_out msg_servo_out; |
|
struct msg_pin_request msg_pin_request; |
|
struct msg_pin_set msg_pin_set; |
|
struct msg_dataflash_request msg_dataflash_request; |
|
struct msg_dataflash_set msg_dataflash_set; |
|
struct msg_eeprom_request msg_eeprom_request; |
|
struct msg_eeprom_set msg_eeprom_set; |
|
struct msg_position_correct msg_position_correct; |
|
struct msg_attitude_correct msg_attitude_correct; |
|
struct msg_position_set msg_position_set; |
|
struct msg_attitude_set msg_attitude_set; |
|
}; |
|
#define BINCOMM_MAX_MESSAGE_SIZE sizeof(union _binCommBufferSizer) |
|
|
|
#pragma pack(pop)
|
|
|