mirror of
https://github.com/ArduPilot/ardupilot.git
synced 2026-10-06 19:00:27 +08:00
Leonard Hall
195c024c56
RGPK carries the moving baseline yaw antenna offset, which Replay needs only to reproduce the EKF3 attitude correction of that yaw. Add AP_DAL_RGPK_LOGGING_ENABLED and gate the message ID, the structure, the per-instance state and the write on it. This also removes the runtime flag start_frame() took to decide whether to fetch the offset. The flag kept AP_GPS::get_mb_yaw_offset() referenced, so the accessor and the RGPK write were linked into every build whether or not any consumer applied the correction.
713 lines
23 KiB
C
713 lines
23 KiB
C
#pragma once
|
|
|
|
#include <AP_GPS/AP_GPS_config.h>
|
|
#include <AP_Logger/LogStructure.h>
|
|
#include <AP_Math/vector3.h>
|
|
#include <AP_Math/vector2.h>
|
|
#include <AP_Math/matrix3.h>
|
|
#include <AP_Math/quaternion.h>
|
|
|
|
// RGPK carries the antenna offset a moving baseline GPS yaw was calculated
|
|
// from, which Replay needs only to reproduce the EKF3 correction of that yaw
|
|
#ifndef AP_DAL_RGPK_LOGGING_ENABLED
|
|
#define AP_DAL_RGPK_LOGGING_ENABLED AP_GPS_MB_YAW_OFFSET_ENABLED
|
|
#endif
|
|
|
|
#if AP_DAL_RGPK_LOGGING_ENABLED
|
|
#define LOG_ID_FROM_DAL_RGPK LOG_RGPK_MSG,
|
|
#else
|
|
#define LOG_ID_FROM_DAL_RGPK
|
|
#endif
|
|
|
|
#define LOG_IDS_FROM_DAL \
|
|
LOG_RFRH_MSG, \
|
|
LOG_RFRF_MSG, \
|
|
LOG_REV2_MSG, \
|
|
LOG_RSO2_MSG, \
|
|
LOG_RWA2_MSG, \
|
|
LOG_REV3_MSG, \
|
|
LOG_RSO3_MSG, \
|
|
LOG_RWA3_MSG, \
|
|
LOG_REY3_MSG, \
|
|
LOG_RFRN_MSG, \
|
|
LOG_RISH_MSG, \
|
|
LOG_RISI_MSG, \
|
|
LOG_RISJ_MSG, \
|
|
LOG_RBRH_MSG, \
|
|
LOG_RBRI_MSG, \
|
|
LOG_RRNH_MSG, \
|
|
LOG_RRNI_MSG, \
|
|
LOG_RGPH_MSG, \
|
|
LOG_RGPI_MSG, \
|
|
LOG_RGPJ_MSG, \
|
|
LOG_ID_FROM_DAL_RGPK \
|
|
LOG_RASH_MSG, \
|
|
LOG_RASI_MSG, \
|
|
LOG_RBCH_MSG, \
|
|
LOG_RBCI_MSG, \
|
|
LOG_RVOH_MSG, \
|
|
LOG_RMGH_MSG, \
|
|
LOG_RMGI_MSG, \
|
|
LOG_ROFH_MSG, \
|
|
LOG_REPH_MSG, \
|
|
LOG_RSLL_MSG, \
|
|
LOG_REVH_MSG, \
|
|
LOG_RWOH_MSG, \
|
|
LOG_RBOH_MSG, \
|
|
LOG_RTER_MSG
|
|
|
|
// @LoggerMessage: RFRH
|
|
// @Description: Replay FRame Header
|
|
// @Field: TimeUS: Time since system startup
|
|
// @Field: TF: Time flying
|
|
struct log_RFRH {
|
|
uint64_t time_us;
|
|
uint32_t time_flying_ms;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RFRF
|
|
// @Description: Replay FRame data - Finished frame
|
|
// @Field: FTypes: accumulated method calls made during frame
|
|
// @FieldBitmaskEnum: FTypes: AP_DAL::FrameType
|
|
// @Field: Slow: true if we are not keeping up with IMU loop rate
|
|
struct log_RFRF {
|
|
uint8_t frame_types;
|
|
uint8_t core_slow;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RFRN
|
|
// @Description: Replay FRame - aNother frame header
|
|
// @Field: HLat: home latitude
|
|
// @Field: HLon: home latitude
|
|
// @Field: HAlt: home altitude AMSL
|
|
// @Field: E2T: EAS to TAS factor
|
|
// @Field: AM: available memory
|
|
// @Field: TX: AHRS trim X
|
|
// @Field: TY: AHRS trim Y
|
|
// @Field: TZ: AHRS trim Z
|
|
// @Field: VC: AHRS Vehicle Class
|
|
// @Field: EKT: configured EKF type
|
|
// @FieldValueEnum: EKT: AP_DAL::EKFType
|
|
// @Field: Flags: bitmask of boolean state
|
|
// @FieldBitmaskEnum: Flags: AP_DAL::RFRNFlags
|
|
struct log_RFRN {
|
|
int32_t lat;
|
|
int32_t lng;
|
|
int32_t alt;
|
|
float EAS2TAS;
|
|
uint32_t available_memory;
|
|
Vector3f ahrs_trim;
|
|
uint8_t vehicle_class;
|
|
uint8_t ekf_type;
|
|
uint8_t armed:1;
|
|
uint8_t unused:1; // was get_compass_is_null
|
|
uint8_t fly_forward:1;
|
|
uint8_t ahrs_airspeed_sensor_enabled:1;
|
|
uint8_t opticalflow_enabled:1;
|
|
uint8_t wheelencoder_enabled:1;
|
|
uint8_t takeoff_expected:1;
|
|
uint8_t touchdown_expected:1;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RISH
|
|
// @Description: Replay Inertial Sensor header
|
|
// @Field: LR: INS loop rate
|
|
// @Field: PG: primary gyro index
|
|
// @Field: PA: primary accel index
|
|
// @Field: LD: INS loop-delta-t
|
|
// @Field: AC: accel count
|
|
// @Field: GC: gyro count
|
|
struct log_RISH {
|
|
uint16_t loop_rate_hz;
|
|
uint8_t first_usable_gyro;
|
|
uint8_t first_usable_accel;
|
|
float loop_delta_t;
|
|
uint8_t accel_count;
|
|
uint8_t gyro_count;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RISI
|
|
// @Description: Replay Inertial Sensor instance data
|
|
// @Field: DVX: x-axis delta-velocity
|
|
// @Field: DVY: y-axis delta-velocity
|
|
// @Field: DVZ: z-axis delta-velocity
|
|
// @Field: DAX: x-axis delta-angle
|
|
// @Field: DAY: y-axis delta-angle
|
|
// @Field: DAZ: z-axis delta-angle
|
|
// @Field: DVDT: delta-velocity-delta-time
|
|
// @Field: DADT: delta-angle-delta-time
|
|
// @Field: Flags: use-accel, use-gyro, delta-vel-valid, delta-accel-valid
|
|
// @Field: I: IMU instance
|
|
struct log_RISI {
|
|
Vector3f delta_velocity;
|
|
Vector3f delta_angle;
|
|
float delta_velocity_dt;
|
|
float delta_angle_dt;
|
|
uint8_t use_accel:1;
|
|
uint8_t use_gyro:1;
|
|
uint8_t get_delta_velocity_ret:1;
|
|
uint8_t get_delta_angle_ret:1;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RISJ
|
|
// @Description: Replay Inertial Sensor instance metadata (low-rate, only logged when changed)
|
|
// @Field: GBL: gyro bias limit (rad/s) for the EKF gyro bias state clamp
|
|
// @Field: GBI: initial gyro bias 1-sigma uncertainty (deg/s)
|
|
// @Field: I: IMU instance
|
|
struct log_RISJ {
|
|
float gyro_bias_limit;
|
|
float gyro_bias_init_dps;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: REV2
|
|
// @Description: Replay Event (EKF2)
|
|
// @Field: Event: external event injected into EKF
|
|
// @FieldValueEnum: Event: AP_DAL::Event
|
|
struct log_REV2 {
|
|
uint8_t event;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RSO2
|
|
// @Description: Replay Set Origin event (EKF2)
|
|
// @Field: Lat: origin latitude
|
|
// @Field: Lon: origin longitude
|
|
// @Field: Alt: origin altitude
|
|
struct log_RSO2 {
|
|
int32_t lat;
|
|
int32_t lng;
|
|
int32_t alt;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RWA2
|
|
// @Description: Replay set-default-airspeed event (EKF2)
|
|
// @Field: Airspeed: default airspeed
|
|
// @Field: uncertainty: uncertainty in default airspeed
|
|
struct log_RWA2 {
|
|
float airspeed;
|
|
float uncertainty;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// same structures for EKF3
|
|
// @LoggerMessage: REV3
|
|
// @Description: Replay Event (EKF3)
|
|
// @Field: Event: external event injected into EKF
|
|
// @FieldValueEnum: Event: AP_DAL::Event
|
|
#define log_REV3 log_REV2
|
|
|
|
// @LoggerMessage: RSO3
|
|
// @Description: Replay Set Origin event (EKF3)
|
|
// @Field: Lat: origin latitude
|
|
// @Field: Lon: origin longitude
|
|
// @Field: Alt: origin altitude
|
|
#define log_RSO3 log_RSO2
|
|
|
|
// @LoggerMessage: RWA3
|
|
// @Description: Replay set-default-airspeed event (EKF3)
|
|
// @Field: Airspeed: default airspeed
|
|
// @Field: Uncertainty: uncertainty in default airspeed
|
|
#define log_RWA3 log_RWA2
|
|
|
|
// @LoggerMessage: REY3
|
|
// @Description: Replay Euler Yaw event
|
|
// @Field: yawangle: externally supplied yaw angle
|
|
// @Field: yawangleerr: error in externally supplied yaw angle
|
|
// @Field: timestamp_ms: timestamp associated with yaw angle and yaw angle error
|
|
// @Field: type: number that needs documenting
|
|
struct log_REY3 {
|
|
float yawangle;
|
|
float yawangleerr;
|
|
uint32_t timestamp_ms;
|
|
uint8_t type;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RBRH
|
|
// @Description: Replay Data Barometer Header
|
|
// @Field: Primary: primary barometer instance number
|
|
// @Field: NumInst: number of barometer sensors
|
|
struct log_RBRH {
|
|
uint8_t primary;
|
|
uint8_t num_instances;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RBRI
|
|
// @Description: Replay Data Barometer Instance
|
|
// @Field: LastUpdate: timestamp of barometer data
|
|
// @Field: Alt: barometer altitude estimate
|
|
// @Field: H: barometer sensor health indication
|
|
// @Field: I: barometer instance number
|
|
struct log_RBRI {
|
|
uint32_t last_update_ms;
|
|
float altitude; // from get_altitude
|
|
bool healthy;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RRNH
|
|
// @Description: Replay Data Rangefinder Header
|
|
// @Field: GCl: rangefinder ground clearance for downward-facing rangefinders
|
|
// @Field: MaxD: rangefinder maximum distance for downward-facing rangefinders
|
|
// @Field: NumSensors: number of rangefinder instances
|
|
struct log_RRNH {
|
|
// this is rotation-pitch-270!
|
|
float ground_clearance;
|
|
float max_distance;
|
|
uint8_t num_sensors;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RRNI
|
|
// @Description: Replay Data Rangefinder Instance
|
|
// @Field: PX: rangefinder body-frame offset, X-axis
|
|
// @Field: PY: rangefinder body-frame offset, Y-axis
|
|
// @Field: PZ: rangefinder body-frame offset, Z-axis
|
|
// @Field: Dist: Measured rangefinder distance
|
|
// @Field: Orient: orientation
|
|
// @Field: Status: status
|
|
// @Field: I: rangefinder instance number
|
|
struct log_RRNI {
|
|
Vector3f pos_offset;
|
|
float distance;
|
|
uint8_t orientation;
|
|
uint8_t status;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RGPH
|
|
// @Description: Replay Data GPS Header
|
|
// @Field: NumInst: number of GPS sensors
|
|
// @Field: Primary: instance number of primary sensor
|
|
struct log_RGPH {
|
|
uint8_t num_sensors;
|
|
uint8_t primary_sensor;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RGPI
|
|
// @Description: Replay Data GPS Instance, infrequently changing data
|
|
// @Field: OX: antenna body-frame offset, X-axis
|
|
// @Field: OY: antenna body-frame offset, Y-axis
|
|
// @Field: OZ: antenna body-frame offset, Z-axis
|
|
// @Field: Lg: GPS time lag
|
|
// @Field: Flags: various GPS flags
|
|
// @FieldBits: Flags: have_vertical_velocity,horizontal_accuracy_returncode,vertical_accuracy_returncode,get_lag_returncode,speed_accuracy_returncode,gps_yaw_deg_returncode
|
|
// @Field: Stat: GPS fix status
|
|
// @Field: NSats: number of satellites GPS is using
|
|
// @Field: I: GPS sensor instance number
|
|
struct log_RGPI {
|
|
Vector3f antenna_offset;
|
|
float lag_sec;
|
|
uint8_t have_vertical_velocity:1;
|
|
uint8_t horizontal_accuracy_returncode:1;
|
|
uint8_t vertical_accuracy_returncode:1;
|
|
uint8_t get_lag_returncode:1;
|
|
uint8_t speed_accuracy_returncode:1;
|
|
uint8_t gps_yaw_deg_returncode:1;
|
|
uint8_t status;
|
|
uint8_t num_sats;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RGPJ
|
|
// @Description: Replay Data GPS Instance - rapidly changing data
|
|
// @Field: TS: GPS data timestamp
|
|
// @Field: VX: GPS velocity, North
|
|
// @Field: VY: GPS velocity, East
|
|
// @Field: VZ: GPS velocity, Down
|
|
// @Field: SA: speed accuracy
|
|
// @Field: Y: GPS yaw
|
|
// @Field: YA: GPS yaw accuracy
|
|
// @Field: YT: timestamp of GPS yaw estimate
|
|
// @Field: Lat: latitude
|
|
// @Field: Lon: longitude
|
|
// @Field: Alt: altitude
|
|
// @Field: HA: horizontal accuracy
|
|
// @Field: VA: vertical accuracy
|
|
// @Field: HD: HDOP
|
|
// @Field: I: GPS sensor instance number
|
|
struct log_RGPJ {
|
|
uint32_t last_message_time_ms;
|
|
Vector3f velocity;
|
|
float sacc;
|
|
float yaw_deg;
|
|
float yaw_accuracy_deg;
|
|
uint32_t yaw_deg_time_ms;
|
|
int32_t lat;
|
|
int32_t lng;
|
|
int32_t alt;
|
|
float hacc;
|
|
float vacc;
|
|
uint16_t hdop;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
#if AP_DAL_RGPK_LOGGING_ENABLED
|
|
// @LoggerMessage: RGPK
|
|
// @Description: Replay Data GPS Instance - moving baseline yaw antenna offset (low-rate, only logged when changed)
|
|
// @Field: OX: moving baseline antenna offset used to calculate GPS yaw, X-axis
|
|
// @Field: OY: moving baseline antenna offset used to calculate GPS yaw, Y-axis
|
|
// @Field: OZ: moving baseline antenna offset used to calculate GPS yaw, Z-axis
|
|
// @Field: I: GPS sensor instance number
|
|
struct log_RGPK {
|
|
Vector3f mb_yaw_offset;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
#endif // AP_DAL_RGPK_LOGGING_ENABLED
|
|
|
|
// @LoggerMessage: RASH
|
|
// @Description: Replay Airspeed Sensor Header
|
|
// @Field: Primary: airspeed instance number
|
|
// @Field: NumInst: number of airspeed instances
|
|
struct log_RASH {
|
|
uint8_t num_sensors;
|
|
uint8_t primary;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RASI
|
|
// @Description: Replay Airspeed Sensor Instance data
|
|
// @Field: pd: measured airspeed
|
|
// @Field: UpdateMS: timestamp of measured airspeed
|
|
// @Field: H: indicator of airspeed sensor health
|
|
// @Field: Use: true if airspeed is configured to be used
|
|
// @Field: I: airspeed instance number
|
|
struct log_RASI {
|
|
float airspeed;
|
|
uint32_t last_update_ms;
|
|
bool healthy;
|
|
bool use;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RMGH
|
|
// @Description: Replay Data Magnetometer Header
|
|
// @Field: Dec: vehicle declination
|
|
// @Field: Avail: true if the compass library is marking itself as available
|
|
// @Field: NumInst: number of compass instances
|
|
// @Field: AutoDec: true if compass autodeclination is enabled
|
|
// @Field: NumEna: number of enabled compass instances
|
|
// @Field: LOE: true if compass learning of offsets is enabled
|
|
// @Field: C: true if compasses are consistent
|
|
// @Field: FUsable: index of first usable compass
|
|
struct log_RMGH {
|
|
float declination;
|
|
bool available;
|
|
uint8_t count;
|
|
bool auto_declination_enabled;
|
|
uint8_t num_enabled;
|
|
bool learn_offsets_enabled;
|
|
bool consistent;
|
|
uint8_t first_usable;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RMGI
|
|
// @Description: Replay Data Magnetometer Instance
|
|
// @Field: LU: last update time for magnetometer data
|
|
// @Field: OX: mag sensor offset, X-axis
|
|
// @Field: OY: mag sensor offset, Y-axis
|
|
// @Field: OZ: mag sensor offset, Z-axis
|
|
// @Field: FX: field strength, X-axis
|
|
// @Field: FY: field strength, Y-axis
|
|
// @Field: FZ: field strength, Z-axis
|
|
// @Field: UFY: true if compass is being used for yaw
|
|
// @Field: H: sensor health
|
|
// @Field: HSF: compass has scale factor
|
|
// @Field: I: magnetometer instance number
|
|
struct log_RMGI {
|
|
uint32_t last_update_usec;
|
|
Vector3f offsets;
|
|
Vector3f field;
|
|
bool use_for_yaw;
|
|
bool healthy;
|
|
bool have_scale_factor;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RBCH
|
|
// @Description: Replay Data Beacon Header
|
|
// @Field: PX: beacon system estimated vehicle position, North
|
|
// @Field: PY: beacon system estimated vehicle position, East
|
|
// @Field: PZ: beacon system estimated vehicle position, Down
|
|
// @Field: AE: beacon system estimated vehicle position accuracy
|
|
// @Field: OLat: origin latitude
|
|
// @Field: OLng: origin longitude
|
|
// @Field: OAlt: origin altitude
|
|
// @Field: Flags: vehicle_position_ned_returncode,get_origin_returncode,enabled
|
|
// @Field: NumInst: number of beacons
|
|
struct log_RBCH {
|
|
Vector3f vehicle_position_ned;
|
|
float accuracy_estimate;
|
|
int32_t origin_lat;
|
|
int32_t origin_lng;
|
|
int32_t origin_alt;
|
|
uint8_t get_vehicle_position_ned_returncode:1;
|
|
uint8_t get_origin_returncode:1;
|
|
uint8_t enabled:1;
|
|
uint8_t count;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RBCI
|
|
// @Description: Replay Data Beacon Instance
|
|
// @Field: LU: last update from this beacon instance
|
|
// @Field: PX: beacon distance from origin, X-axis
|
|
// @Field: PY: beacon distance from origin, Y-axis
|
|
// @Field: PZ: beacon distance from origin, Z-axis
|
|
// @Field: Dist: distance to beacon
|
|
// @Field: H: beacon data health
|
|
// @Field: I: beacon instance number
|
|
struct log_RBCI {
|
|
uint32_t last_update_ms;
|
|
Vector3f position;
|
|
float distance;
|
|
uint8_t healthy;
|
|
uint8_t instance;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RVOH
|
|
// @Description: Replay Data Visual Odometry data
|
|
// @Field: OX: offset, x-axis
|
|
// @Field: OY: offset, y-axis
|
|
// @Field: OZ: offset, z-axis
|
|
// @Field: Del: data delay
|
|
// @Field: H: sensor health
|
|
// @Field: Ena: sensor enabled
|
|
struct log_RVOH {
|
|
Vector3f pos_offset;
|
|
uint32_t delay_ms;
|
|
uint8_t healthy;
|
|
bool enabled;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: ROFH
|
|
// @Description: Replay optical flow data
|
|
// @Field: FX: raw flow rate, X-axis
|
|
// @Field: FY: raw flow rate, Y-axis
|
|
// @Field: GX: gyro rate, X-axis
|
|
// @Field: GY: gyro rate, Y-axis
|
|
// @Field: Tms: measurement timestamp
|
|
// @Field: PX:gyro rate, X-axis
|
|
// @Field: PY: body-frame offset, Y-axis
|
|
// @Field: PZ: body-frame offset, Z-axis
|
|
// @Field: HgtOvr: sensor height override
|
|
// @Field: Qual: flow quality measurement
|
|
struct log_ROFH {
|
|
Vector2f rawFlowRates;
|
|
Vector2f rawGyroRates;
|
|
uint32_t msecFlowMeas;
|
|
Vector3f posOffset;
|
|
float heightOverride;
|
|
uint8_t rawFlowQuality;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: REPH
|
|
// @Description: Replay external position data
|
|
// @Field: PX: external position estimate, X-axis
|
|
// @Field: PY: external position estimate, Y-axis
|
|
// @Field: PZ: external position estimate, Z-axis
|
|
// @Field: Q1: external attitude quaternion
|
|
// @Field: Q2: external attitude quaternion
|
|
// @Field: Q3: external attitude quaternion
|
|
// @Field: Q4: external attitude quaternion
|
|
// @Field: PEr: external position error estimate
|
|
// @Field: AEr: external attitude error estimate
|
|
// @Field: TS: timestamp on external error estimate
|
|
// @Field: RT: timestamp of last external reset
|
|
// @Field: D: delay on external data
|
|
struct log_REPH {
|
|
Vector3f pos;
|
|
Quaternion quat;
|
|
float posErr;
|
|
float angErr;
|
|
uint32_t timeStamp_ms;
|
|
uint32_t resetTime_ms;
|
|
uint16_t delay_ms;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RSLL
|
|
// @Description: Replay Set Lat Lng event
|
|
// @Field: Lat: latitude
|
|
// @Field: Lng: longitude
|
|
// @Field: PosAccSD: position accuracy, 1-StD
|
|
// @Field: TS: timestamp of latitude/longitude
|
|
struct log_RSLL {
|
|
int32_t lat; // WGS-84 latitude in 1E-7 degrees
|
|
int32_t lng; // WGS-84 longitude in 1E7 degrees
|
|
float posAccSD; // horizontal position 1 STD uncertainty (m)
|
|
uint32_t timestamp_ms;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: REVH
|
|
// @Description: Replay external velocity data
|
|
// @Field: VX: external velocity estimate, X-axis
|
|
// @Field: VY: external velocity estimate, Y-axis
|
|
// @Field: VZ: external velocity estimate, Z-axis
|
|
// @Field: Er: error in velocity estimate
|
|
// @Field: TS: timestamp of velocity estimate
|
|
// @Field: D: delay in external velocity data
|
|
struct log_REVH {
|
|
Vector3f vel;
|
|
float err;
|
|
uint32_t timeStamp_ms;
|
|
uint16_t delay_ms;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RWOH
|
|
// @Description: Replay wheel odometry data
|
|
// @Field: DA: delta-angle
|
|
// @Field: DT: delta-time
|
|
// @Field: TS: data timestamp
|
|
// @Field: PX: sensor body-frame offset, x-axis
|
|
// @Field: PY: sensor body-frame offset, y-axis
|
|
// @Field: PZ: sensor body-frame offset, z-axis
|
|
// @Field: R: wheel radius
|
|
struct log_RWOH {
|
|
float delAng;
|
|
float delTime;
|
|
uint32_t timeStamp_ms;
|
|
Vector3f posOffset;
|
|
float radius;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RBOH
|
|
// @Description: Replay body odometry data
|
|
// @Field: Q: data quality measure
|
|
// @Field: DPX: delta-position-X
|
|
// @Field: DPY: delta-position-Y
|
|
// @Field: DPZ: delta-position-Z
|
|
// @Field: DAX: delta-angle-X
|
|
// @Field: DAY: delta-angle-Y
|
|
// @Field: DAZ: delta-angle-Z
|
|
// @Field: DT: delta-time
|
|
// @Field: TS: data timestamp
|
|
// @Field: OX: pos-offset-X
|
|
// @Field: OY: pos-offset-Y
|
|
// @Field: OZ: pos-offset-Z
|
|
// @Field: D: delay in body odometry data
|
|
struct log_RBOH {
|
|
float quality;
|
|
Vector3f delPos;
|
|
Vector3f delAng;
|
|
float delTime;
|
|
uint32_t timeStamp_ms;
|
|
Vector3f posOffset;
|
|
uint16_t delay_ms;
|
|
uint8_t _end;
|
|
};
|
|
|
|
// @LoggerMessage: RTER
|
|
// @Description: Replay Terrain SRTM Altitude
|
|
// @Field: Alt: altitude above origin in meters
|
|
struct log_RTER {
|
|
float alt_m;
|
|
uint8_t _end;
|
|
};
|
|
|
|
#define RLOG_SIZE(sname) 3+offsetof(struct log_ ##sname,_end)
|
|
|
|
#if AP_DAL_RGPK_LOGGING_ENABLED
|
|
#define LOG_STRUCTURE_FROM_DAL_RGPK \
|
|
{ LOG_RGPK_MSG, RLOG_SIZE(RGPK), \
|
|
"RGPK", "fffB", "OX,OY,OZ,I", "---#", "----" },
|
|
#else
|
|
#define LOG_STRUCTURE_FROM_DAL_RGPK
|
|
#endif
|
|
|
|
#define LOG_STRUCTURE_FROM_DAL \
|
|
{ LOG_RFRH_MSG, RLOG_SIZE(RFRH), \
|
|
"RFRH", "QI", "TimeUS,TF", "s-", "F-" }, \
|
|
{ LOG_RFRF_MSG, RLOG_SIZE(RFRF), \
|
|
"RFRF", "BB", "FTypes,Slow", "--", "--" }, \
|
|
{ LOG_RFRN_MSG, RLOG_SIZE(RFRN), \
|
|
"RFRN", "IIIfIfffBBB", "HLat,HLon,HAlt,E2T,AM,TX,TY,TZ,VC,EKT,Flags", "DUm-bddd---", "GGB--------" }, \
|
|
{ LOG_REV2_MSG, RLOG_SIZE(REV2), \
|
|
"REV2", "B", "Event", "-", "-" }, \
|
|
{ LOG_RSO2_MSG, RLOG_SIZE(RSO2), \
|
|
"RSO2", "III", "Lat,Lon,Alt", "DUm", "GGB" }, \
|
|
{ LOG_RWA2_MSG, RLOG_SIZE(RWA2), \
|
|
"RWA2", "ff", "Airspeed,uncertainty", "nn", "00" }, \
|
|
{ LOG_REV3_MSG, RLOG_SIZE(REV3), \
|
|
"REV3", "B", "Event", "-", "-" }, \
|
|
{ LOG_RSO3_MSG, RLOG_SIZE(RSO3), \
|
|
"RSO3", "III", "Lat,Lon,Alt", "DUm", "GGB" }, \
|
|
{ LOG_RWA3_MSG, RLOG_SIZE(RWA3), \
|
|
"RWA3", "ff", "Airspeed,Uncertainty", "nn", "00" }, \
|
|
{ LOG_REY3_MSG, RLOG_SIZE(REY3), \
|
|
"REY3", "ffIB", "yawangle,yawangleerr,timestamp_ms,type", "???-", "???-" }, \
|
|
{ LOG_RISH_MSG, RLOG_SIZE(RISH), \
|
|
"RISH", "HBBfBB", "LR,PG,PA,LD,AC,GC", "------", "------" }, \
|
|
{ LOG_RISI_MSG, RLOG_SIZE(RISI), \
|
|
"RISI", "ffffffffBB", "DVX,DVY,DVZ,DAX,DAY,DAZ,DVDT,DADT,Flags,I", "---------#", "----------" }, \
|
|
{ LOG_RISJ_MSG, RLOG_SIZE(RISJ), \
|
|
"RISJ", "ffB", "GBL,GBI,I", "--#", "---" }, \
|
|
{ LOG_RASH_MSG, RLOG_SIZE(RASH), \
|
|
"RASH", "BB", "Primary,NumInst", "--", "--" }, \
|
|
{ LOG_RASI_MSG, RLOG_SIZE(RASI), \
|
|
"RASI", "fIBBB", "pd,UpdateMS,H,Use,I", "----#", "-----" }, \
|
|
{ LOG_RBRH_MSG, RLOG_SIZE(RBRH), \
|
|
"RBRH", "BB", "Primary,NumInst", "--", "--" }, \
|
|
{ LOG_RBRI_MSG, RLOG_SIZE(RBRI), \
|
|
"RBRI", "IfBB", "LastUpdate,Alt,H,I", "---#", "----" }, \
|
|
{ LOG_RRNH_MSG, RLOG_SIZE(RRNH), \
|
|
"RRNH", "ffB", "GCl,MaxD,NumSensors", "mm-", "00-" }, \
|
|
{ LOG_RRNI_MSG, RLOG_SIZE(RRNI), \
|
|
"RRNI", "ffffBBB", "PX,PY,PZ,Dist,Orient,Status,I", "---m--#", "---0---" }, \
|
|
{ LOG_RGPH_MSG, RLOG_SIZE(RGPH), \
|
|
"RGPH", "BB", "NumInst,Primary", "--", "--" }, \
|
|
{ LOG_RGPI_MSG, RLOG_SIZE(RGPI), \
|
|
"RGPI", "ffffBBBB", "OX,OY,OZ,Lg,Flags,Stat,NSats,I", "-------#", "--------" }, \
|
|
{ LOG_RGPJ_MSG, RLOG_SIZE(RGPJ), \
|
|
"RGPJ", "IffffffIiiiffHB", "TS,VX,VY,VZ,SA,Y,YA,YT,Lat,Lon,Alt,HA,VA,HD,I", "--------------#", "---------------" }, \
|
|
LOG_STRUCTURE_FROM_DAL_RGPK \
|
|
{ LOG_RMGH_MSG, RLOG_SIZE(RMGH), \
|
|
"RMGH", "fBBBBBBB", "Dec,Avail,NumInst,AutoDec,NumEna,LOE,C,FUsable", "--------", "--------" }, \
|
|
{ LOG_RMGI_MSG, RLOG_SIZE(RMGI), \
|
|
"RMGI", "IffffffBBBB", "LU,OX,OY,OZ,FX,FY,FZ,UFY,H,HSF,I", "----------#", "-----------" }, \
|
|
{ LOG_RBCH_MSG, RLOG_SIZE(RBCH), \
|
|
"RBCH", "ffffiiiBB", "PX,PY,PZ,AE,OLat,OLng,OAlt,Flags,NumInst", "---------", "---------" }, \
|
|
{ LOG_RBCI_MSG, RLOG_SIZE(RBCI), \
|
|
"RBCI", "IffffBB", "LU,PX,PY,PZ,Dist,H,I", "smmmm-#", "?0000--" }, \
|
|
{ LOG_RVOH_MSG, RLOG_SIZE(RVOH), \
|
|
"RVOH", "fffIBB", "OX,OY,OZ,Del,H,Ena", "------", "------" }, \
|
|
{ LOG_ROFH_MSG, RLOG_SIZE(ROFH), \
|
|
"ROFH", "ffffIffffB", "FX,FY,GX,GY,Tms,PX,PY,PZ,HgtOvr,Qual", "----------", "----------" }, \
|
|
{ LOG_REPH_MSG, RLOG_SIZE(REPH), \
|
|
"REPH", "fffffffffIIH", "PX,PY,PZ,Q1,Q2,Q3,Q4,PEr,AEr,TS,RT,D", "------------", "------------" }, \
|
|
{ LOG_RSLL_MSG, RLOG_SIZE(RSLL), \
|
|
"RSLL", "IIfI", "Lat,Lng,PosAccSD,TS", "DU--", "GG--" }, \
|
|
{ LOG_REVH_MSG, RLOG_SIZE(REVH), \
|
|
"REVH", "ffffIH", "VX,VY,VZ,Er,TS,D", "------", "------" }, \
|
|
{ LOG_RWOH_MSG, RLOG_SIZE(RWOH), \
|
|
"RWOH", "ffIffff", "DA,DT,TS,PX,PY,PZ,R", "-------", "-------" }, \
|
|
{ LOG_RBOH_MSG, RLOG_SIZE(RBOH), \
|
|
"RBOH", "ffffffffIfffH", "Q,DPX,DPY,DPZ,DAX,DAY,DAZ,DT,TS,OX,OY,OZ,D", "-------------", "-------------" }, \
|
|
{ LOG_RTER_MSG, RLOG_SIZE(RTER), \
|
|
"RTER", "f", "Alt", "m", "0" },
|