#pragma once
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "ekf2_allocator.h"
typedef struct {
uint64_t timestamp;
uint64_t timestamp_sample;
uint8_t estimator_instance;
uint8_t _pad0[3];
uint32_t device_id;
uint64_t time_last_fuse;
float observation;
float observation_variance;
float innovation;
float innovation_filtered;
float innovation_variance;
float test_ratio;
float test_ratio_filtered;
uint8_t innovation_rejected;
uint8_t fused;
uint8_t _pad1[2];
} EkfAidSource1d;
typedef struct {
uint64_t timestamp;
uint64_t timestamp_sample;
uint8_t estimator_instance;
uint8_t _pad0[7];
uint32_t device_id;
uint8_t _pad1[4];
uint64_t time_last_fuse;
double observation[2];
float observation_variance[2];
float innovation[2];
float innovation_filtered[2];
float innovation_variance[2];
float test_ratio[2];
float test_ratio_filtered[2];
uint8_t innovation_rejected;
uint8_t fused;
uint8_t _pad2[6];
} EkfAidSource2d;
typedef struct {
uint64_t timestamp;
uint64_t timestamp_sample;
uint8_t estimator_instance;
uint8_t _pad0[3];
uint32_t device_id;
uint64_t time_last_fuse;
float observation[3];
float observation_variance[3];
float innovation[3];
float innovation_filtered[3];
float innovation_variance[3];
float test_ratio[3];
float test_ratio_filtered[3];
uint8_t innovation_rejected;
uint8_t fused;
uint8_t _pad1[2];
} EkfAidSource3d;
typedef struct {
float bias;
float bias_var;
float innov;
float innov_var;
float innov_test_ratio;
} EkfBiasEstimatorStatus;
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
uint64_t time_us;
float delta_ang[3];
float delta_vel[3];
float delta_ang_dt;
float delta_vel_dt;
uint8_t delta_vel_clipping[3];
uint8_t _pad[5];
} EkfImuSample;
#ifdef CONFIG_EKF2_GNSS
typedef struct {
uint64_t time_us;
double lat;
double lon;
float alt;
float yaw;
float yaw_acc;
float yaw_offset;
float vel[3];
float hacc;
float vacc;
float sacc;
float pdop;
uint8_t fix_type;
uint8_t nsats;
uint8_t spoofed;
uint8_t jammed;
uint8_t _pad[8];
} EkfGnssSample;
#endif
#ifdef CONFIG_EKF2_MAGNETOMETER
typedef struct {
uint64_t time_us;
float mag[3];
uint8_t reset;
uint8_t _pad[3];
} EkfMagSample;
#endif
#ifdef CONFIG_EKF2_BAROMETER
typedef struct {
uint64_t time_us;
float hgt;
uint8_t reset;
uint8_t _pad[3];
} EkfBaroSample;
#endif
#ifdef CONFIG_EKF2_AIRSPEED
typedef struct {
uint64_t time_us;
float true_airspeed;
float eas2tas;
} EkfAirspeedSample;
#endif
#ifdef CONFIG_EKF2_RANGE_FINDER
typedef struct {
uint64_t time_us;
float rng;
int8_t quality;
uint8_t _pad[3];
} EkfRangeSample;
#endif
#ifdef CONFIG_EKF2_OPTICAL_FLOW
typedef struct {
uint64_t time_us;
float flow_rate_xy[2];
float gyro_rate_xyz[3];
uint8_t quality;
uint8_t _pad[3];
} EkfFlowSample;
#endif
#ifdef CONFIG_EKF2_EXTERNAL_VISION
typedef struct {
uint64_t time_us;
float pos[3];
float quat[4];
float vel[3];
float pos_var[3];
float ang_var[3];
float vel_var[3];
uint8_t pos_frame;
uint8_t vel_frame;
uint8_t reset_counter;
int8_t quality;
} EkfExtVisionSample;
#endif
#ifdef CONFIG_EKF2_AUXVEL
typedef struct {
uint64_t time_us;
float vel[2];
float vel_var[2];
} EkfAuxVelSample;
#endif
typedef struct {
uint64_t time_us;
bool at_rest;
bool in_air;
bool is_fixed_wing;
bool gnd_effect;
bool constant_pos;
bool in_transition_to_fw;
uint8_t _pad;
} EkfSystemFlagUpdate;
size_t ekf2_sizeof(void);
size_t ekf2_alignof(void);
void* ekf2_create_heap(void);
void* ekf2_create_heap_with_allocator(EkfAllocator allocator);
void ekf2_destroy_heap(void* self);
void* ekf2_create(void* ekf_buf, size_t ekf_buf_size);
void* ekf2_create_with_allocator(void* ekf_buf, size_t ekf_buf_size,
EkfAllocator allocator);
bool ekf2_init(void* self, uint64_t timestamp_us);
bool ekf2_update(void* self);
void ekf2_destroy(void* self);
void ekf2_set_imu_data(void* self, const EkfImuSample* sample);
#ifdef CONFIG_EKF2_GNSS
void ekf2_set_gps_data(void* self, const EkfGnssSample* sample);
#endif
#ifdef CONFIG_EKF2_MAGNETOMETER
void ekf2_set_mag_data(void* self, const EkfMagSample* sample);
#endif
#ifdef CONFIG_EKF2_BAROMETER
void ekf2_set_baro_data(void* self, const EkfBaroSample* sample);
#endif
#ifdef CONFIG_EKF2_AIRSPEED
void ekf2_set_airspeed_data(void* self, const EkfAirspeedSample* sample);
#endif
#ifdef CONFIG_EKF2_RANGE_FINDER
void ekf2_set_range_data(void* self, const EkfRangeSample* sample);
#endif
#ifdef CONFIG_EKF2_OPTICAL_FLOW
void ekf2_set_optical_flow_data(void* self, const EkfFlowSample* sample);
#endif
#ifdef CONFIG_EKF2_EXTERNAL_VISION
void ekf2_set_ev_data(void* self, const EkfExtVisionSample* sample);
#endif
#ifdef CONFIG_EKF2_AUXVEL
void ekf2_set_aux_vel_data(void* self, const EkfAuxVelSample* sample);
#endif
void ekf2_set_system_flag_data(void* self, const EkfSystemFlagUpdate* sample);
void ekf2_set_in_air_status(void* self, bool in_air);
void ekf2_set_vehicle_at_rest(void* self, bool at_rest);
void ekf2_set_constant_pos(void* self, bool constant_pos);
void ekf2_set_is_fixed_wing(void* self, bool is_fixed_wing);
void ekf2_set_in_transition_to_fw(void* self, bool in_transition_to_fw);
void ekf2_set_gnd_effect(void* self);
void ekf2_set_air_density(void* self, float air_density);
#ifdef CONFIG_EKF2_GNSS
void ekf2_set_gps_data_with_pps(void* self, const EkfGnssSample* sample, bool pps_compensation);
#endif
#ifdef CONFIG_EKF2_AIRSPEED
void ekf2_set_synthetic_airspeed(void* self, bool synthetic_airspeed);
#endif
#ifdef CONFIG_EKF2_RANGE_FINDER
void ekf2_set_rangefinder_limits(void* self, float min_distance, float max_distance);
#endif
#ifdef CONFIG_EKF2_OPTICAL_FLOW
void ekf2_set_optical_flow_limits(void* self, float max_flow_rate, float min_distance, float max_distance);
#endif
void ekf2_get_quaternion(const void* self, float q[4]);
void ekf2_get_velocity(const void* self, float v[3]);
void ekf2_get_position(const void* self, float p[3]);
void ekf2_get_gyro_bias(const void* self, float b[3]);
void ekf2_get_accel_bias(const void* self, float b[3]);
#ifdef CONFIG_EKF2_MAGNETOMETER
void ekf2_get_mag_earth_field(const void* self, float mag[3]);
void ekf2_get_mag_bias(const void* self, float bias[3]);
void ekf2_get_mag_bias_variance(const void* self, float var[3]);
#endif
void ekf2_get_angular_velocity_reset_accumulator(void* self, float w[3]);
float ekf2_get_unaided_yaw(const void* self);
bool ekf2_attitude_valid(const void* self);
bool ekf2_local_position_valid(const void* self);
bool ekf2_local_velocity_valid(const void* self);
bool ekf2_global_position_valid(const void* self);
bool ekf2_yaw_align_complete(const void* self);
void ekf2_get_pos_variance(const void* self, float var[3]);
void ekf2_get_vel_variance(const void* self, float var[3]);
void ekf2_get_gyro_bias_variance(const void* self, float var[3]);
void ekf2_get_accel_bias_variance(const void* self, float var[3]);
void ekf2_get_rot_var_body(const void* self, float var[3]);
void ekf2_get_rot_var_ned(const void* self, float var[3]);
float ekf2_get_yaw_variance(const void* self);
float ekf2_get_tilt_variance(const void* self);
size_t ekf2_get_state_size(void);
size_t ekf2_get_covariances_diagonal(const void* self, float* out, size_t capacity);
float ekf2_get_state_covariance(const void* self, uint32_t row, uint32_t col);
void ekf2_get_velocity_derivative(const void* self, float vdot[3]);
void ekf2_reset_velocity_derivative_accumulation(void* self);
float ekf2_get_vertical_position_derivative(const void* self);
void ekf2_get_lat_lon_alt(const void* self, double* lat, double* lon, float* alt);
void ekf2_get_output_tracking_error(const void* self, float err[3]);
uint64_t ekf2_get_control_status(const void* self);
uint32_t ekf2_get_fault_status(const void* self);
uint32_t ekf2_get_information_event_status(const void* self);
void ekf2_clear_information_events(void* self);
float ekf2_get_heading_innov_test_ratio(const void* self);
float ekf2_get_horiz_vel_innov_test_ratio(const void* self);
float ekf2_get_vert_vel_innov_test_ratio(const void* self);
float ekf2_get_horiz_pos_innov_test_ratio(const void* self);
float ekf2_get_vert_pos_innov_test_ratio(const void* self);
#ifdef CONFIG_EKF2_AIRSPEED
float ekf2_get_airspeed_innov_test_ratio(const void* self);
#endif
#ifdef CONFIG_EKF2_SIDESLIP
float ekf2_get_sideslip_innov_test_ratio(const void* self);
#endif
#ifdef CONFIG_EKF2_RANGE_FINDER
float ekf2_get_hagl_rate_innov(const void* self);
float ekf2_get_hagl_rate_innov_var(const void* self);
float ekf2_get_hagl_rate_innov_ratio(const void* self);
#endif
#if defined(CONFIG_EKF2_TERRAIN) || defined(CONFIG_EKF2_RANGE_FINDER) || defined(CONFIG_EKF2_OPTICAL_FLOW)
float ekf2_get_hagl_innov_test_ratio(const void* self);
#endif
uint16_t ekf2_get_soln_status(const void* self);
uint8_t ekf2_get_height_sensor_ref(const void* self);
void ekf2_get_lpos_accuracy(const void* self, float* eph, float* epv);
void ekf2_get_gpos_accuracy(const void* self, float* eph, float* epv);
void ekf2_get_vel_accuracy(const void* self, float* evh, float* evv);
void ekf2_get_ctrl_limits(const void* self, float* vxy_max, float* vz_max,
float* hagl_min, float* hagl_max_z, float* hagl_max_xy);
void ekf2_get_global_origin(const void* self, uint64_t* time_us,
double* lat, double* lon, float* alt);
bool ekf2_global_origin_valid(const void* self);
bool ekf2_set_global_origin(void* self, double lat, double lon, float alt,
float hpos_var, float vpos_var);
bool ekf2_reset_global_position(void* self, double lat, double lon, float alt,
float hpos_var, float vpos_var);
bool ekf2_reset_global_position_to_external_observation(
void* self,
double lat,
double lon,
float alt,
float eph,
float epv,
uint64_t timestamp_observation);
uint8_t ekf2_get_quat_reset_count(const void* self);
uint8_t ekf2_get_pos_ne_reset_count(const void* self);
uint8_t ekf2_get_vel_ne_reset_count(const void* self);
uint8_t ekf2_get_pos_d_reset_count(const void* self);
uint8_t ekf2_get_vel_d_reset_count(const void* self);
uint8_t ekf2_get_hagl_reset_count(const void* self);
void ekf2_get_quat_reset(const void* self, float delta_quat[4], uint8_t* count);
void ekf2_get_pos_ne_reset(const void* self, float delta_ne[2], uint8_t* count);
void ekf2_get_vel_ne_reset(const void* self, float delta_ne[2], uint8_t* count);
void ekf2_get_pos_d_reset(const void* self, float* delta, uint8_t* count);
void ekf2_get_vel_d_reset(const void* self, float* delta, uint8_t* count);
void ekf2_get_hagl_reset(const void* self, float* delta, uint8_t* count);
void ekf2_reset_gyro_bias(void* self);
void ekf2_reset_accel_bias(void* self);
void ekf2_reset_gyro_bias_cov(void* self);
void ekf2_reset_accel_bias_cov(void* self);
void ekf2_reset_heading_to_external_observation(void* self, float heading, float heading_accuracy);
void ekf2_update_parameters(void* self);
bool ekf2_check_lat_lon_validity(void* self, double lat, double lon);
bool ekf2_check_altitude_validity(void* self, float altitude);
#ifdef CONFIG_EKF2_WIND
void ekf2_reset_wind_to_external_observation(
void* self,
float wind_speed,
float wind_direction,
float wind_speed_accuracy,
float wind_direction_accuracy);
#endif
#ifdef CONFIG_EKF2_MAGNETOMETER
bool ekf2_update_world_magnetic_model(void* self, double latitude_deg, double longitude_deg);
#endif
#ifdef CONFIG_EKF2_GNSS
float ekf2_get_gps_horizontal_position_drift_rate(const void* self);
float ekf2_get_gps_vertical_position_drift_rate(const void* self);
float ekf2_get_gps_filtered_horizontal_velocity(const void* self);
bool ekf2_gps_checks_passed(const void* self);
uint16_t ekf2_get_gps_check_fail_status(const void* self);
void ekf2_set_min_required_gps_health_time(void* self, uint32_t time_us);
void ekf2_get_gps_hgt_bias_estimator_status(const void* self, EkfBiasEstimatorStatus* out);
bool ekf2_yaw_emergency_estimate_available(const void* self);
bool ekf2_get_ekfgsf_data(
const void* self,
float* yaw_composite,
float* yaw_variance,
float* yaw,
float* innov_vn,
float* innov_ve,
float* weight,
size_t capacity,
size_t* count_out);
#endif
#if defined(CONFIG_EKF2_TERRAIN) || defined(CONFIG_EKF2_RANGE_FINDER) || defined(CONFIG_EKF2_OPTICAL_FLOW)
bool ekf2_terrain_valid(const void* self);
float ekf2_get_terrain_vert_pos(const void* self);
float ekf2_get_terrain_variance(const void* self);
float ekf2_get_hagl(const void* self);
#endif
#ifdef CONFIG_EKF2_OPTICAL_FLOW
void ekf2_get_flow_vel_body(const void* self, float v[2]);
void ekf2_get_flow_vel_ne(const void* self, float v[2]);
void ekf2_get_filtered_flow_vel_body(const void* self, float v[2]);
void ekf2_get_filtered_flow_vel_ne(const void* self, float v[2]);
void ekf2_get_flow_compensated(const void* self, float flow_rate[2]);
void ekf2_get_flow_uncompensated(const void* self, float flow_rate[2]);
void ekf2_get_flow_gyro(const void* self, float gyro_rate[3]);
void ekf2_get_flow_gyro_bias(const void* self, float gyro_bias[3]);
void ekf2_get_flow_ref_body_rate(const void* self, float body_rate[3]);
#endif
void ekf2_get_aid_src_fake_hgt(const void* self, EkfAidSource1d* out);
void ekf2_get_aid_src_fake_pos(const void* self, EkfAidSource2d* out);
#ifdef CONFIG_EKF2_BAROMETER
void ekf2_get_aid_src_baro_hgt(const void* self, EkfAidSource1d* out);
#endif
#ifdef CONFIG_EKF2_GNSS
void ekf2_get_aid_src_gnss_hgt(const void* self, EkfAidSource1d* out);
void ekf2_get_aid_src_gnss_pos(const void* self, EkfAidSource2d* out);
void ekf2_get_aid_src_gnss_vel(const void* self, EkfAidSource3d* out);
# ifdef CONFIG_EKF2_GNSS_YAW
void ekf2_get_aid_src_gnss_yaw(const void* self, EkfAidSource1d* out);
# endif
#endif
#ifdef CONFIG_EKF2_MAGNETOMETER
void ekf2_get_aid_src_mag(const void* self, EkfAidSource3d* out);
#endif
#ifdef CONFIG_EKF2_AIRSPEED
void ekf2_get_aid_src_airspeed(const void* self, EkfAidSource1d* out);
#endif
#ifdef CONFIG_EKF2_SIDESLIP
void ekf2_get_aid_src_sideslip(const void* self, EkfAidSource1d* out);
#endif
#ifdef CONFIG_EKF2_RANGE_FINDER
void ekf2_get_aid_src_rng_hgt(const void* self, EkfAidSource1d* out);
#endif
#ifdef CONFIG_EKF2_OPTICAL_FLOW
void ekf2_get_aid_src_optical_flow(const void* self, EkfAidSource2d* out);
#endif
#ifdef CONFIG_EKF2_EXTERNAL_VISION
void ekf2_get_aid_src_ev_hgt(const void* self, EkfAidSource1d* out);
void ekf2_get_aid_src_ev_pos(const void* self, EkfAidSource2d* out);
void ekf2_get_aid_src_ev_vel(const void* self, EkfAidSource3d* out);
void ekf2_get_aid_src_ev_yaw(const void* self, EkfAidSource1d* out);
#endif
#ifdef CONFIG_EKF2_DRAG_FUSION
void ekf2_get_aid_src_drag(const void* self, EkfAidSource2d* out);
#endif
#ifdef CONFIG_EKF2_GRAVITY_FUSION
void ekf2_get_aid_src_gravity(const void* self, EkfAidSource3d* out);
#endif
#ifdef CONFIG_EKF2_AUXVEL
void ekf2_get_aid_src_aux_vel(const void* self, EkfAidSource2d* out);
#endif
#ifdef CONFIG_EKF2_WIND
void ekf2_get_wind_velocity(const void* self, float w[2]);
void ekf2_get_wind_variance(const void* self, float var[2]);
bool ekf2_wind_estimate_active(const void* self);
#endif
bool ekf2_horizontal_aiding_active(const void* self);
bool ekf2_horizontal_position_aiding_active(const void* self);
bool ekf2_vertical_aiding_active(const void* self);
bool ekf2_north_east_aiding_active(const void* self);
int32_t ekf2_num_active_horizontal_aiding_sources(const void* self);
int32_t ekf2_num_active_horizontal_position_aiding_sources(const void* self);
int32_t ekf2_num_active_horizontal_velocity_aiding_sources(const void* self);
bool ekf2_vertical_position_aiding_active(const void* self);
int32_t ekf2_num_active_vertical_position_aiding_sources(const void* self);
bool ekf2_vertical_velocity_aiding_active(const void* self);
int32_t ekf2_num_active_vertical_velocity_aiding_sources(const void* self);
float ekf2_get_dt_ekf_avg(const void* self);
#ifdef CONFIG_EKF2_BAROMETER
void ekf2_get_baro_bias_estimator_status(const void* self, EkfBiasEstimatorStatus* out);
#endif
#ifdef CONFIG_EKF2_EXTERNAL_VISION
void ekf2_get_ev_hgt_bias_estimator_status(const void* self, EkfBiasEstimatorStatus* out);
void ekf2_get_ev_pos_bias_estimator_status(const void* self, uint8_t axis, EkfBiasEstimatorStatus* out);
#endif
float ekf2_param_get_gyro_noise(const void* self);
void ekf2_param_set_gyro_noise(void* self, float v);
float ekf2_param_get_accel_noise(const void* self);
void ekf2_param_set_accel_noise(void* self, float v);
float ekf2_param_get_gyro_bias_noise(const void* self);
void ekf2_param_set_gyro_bias_noise(void* self, float v);
float ekf2_param_get_accel_bias_noise(const void* self);
void ekf2_param_set_accel_bias_noise(void* self, float v);
float ekf2_param_get_gyro_bias_init(const void* self);
void ekf2_param_set_gyro_bias_init(void* self, float v);
float ekf2_param_get_accel_bias_init(const void* self);
void ekf2_param_set_accel_bias_init(void* self, float v);
float ekf2_param_get_angerr_init(const void* self);
void ekf2_param_set_angerr_init(void* self, float v);
float ekf2_param_get_delay_max(const void* self);
void ekf2_param_set_delay_max(void* self, float v);
int32_t ekf2_param_get_predict_us(const void* self);
void ekf2_param_set_predict_us(void* self, int32_t v);
int32_t ekf2_param_get_imu_ctrl(const void* self);
void ekf2_param_set_imu_ctrl(void* self, int32_t v);
float ekf2_param_get_vel_lim(const void* self);
void ekf2_param_set_vel_lim(void* self, float v);
int32_t ekf2_param_get_position_sensor_ref(const void* self);
void ekf2_param_set_position_sensor_ref(void* self, int32_t v);
int32_t ekf2_param_get_noaid_tout(const void* self);
void ekf2_param_set_noaid_tout(void* self, int32_t v);
float ekf2_param_get_noaid_noise(const void* self);
void ekf2_param_set_noaid_noise(void* self, float v);
float ekf2_param_get_hdg_gate(const void* self);
void ekf2_param_set_hdg_gate(void* self, float v);
float ekf2_param_get_head_noise(const void* self);
void ekf2_param_set_head_noise(void* self, float v);
float ekf2_param_get_abl_lim(const void* self);
void ekf2_param_set_abl_lim(void* self, float v);
float ekf2_param_get_abl_acclim(const void* self);
void ekf2_param_set_abl_acclim(void* self, float v);
float ekf2_param_get_abl_gyrlim(const void* self);
void ekf2_param_set_abl_gyrlim(void* self, float v);
float ekf2_param_get_abl_tau(const void* self);
void ekf2_param_set_abl_tau(void* self, float v);
float ekf2_param_get_gyr_b_lim(const void* self);
void ekf2_param_set_gyr_b_lim(void* self, float v);
#ifdef CONFIG_EKF2_BAROMETER
int32_t ekf2_param_get_baro_ctrl(const void* self);
void ekf2_param_set_baro_ctrl(void* self, int32_t v);
float ekf2_param_get_baro_delay(const void* self);
void ekf2_param_set_baro_delay(void* self, float v);
float ekf2_param_get_baro_noise(const void* self);
void ekf2_param_set_baro_noise(void* self, float v);
float ekf2_param_get_baro_gate(const void* self);
void ekf2_param_set_baro_gate(void* self, float v);
float ekf2_param_get_baro_bias_nsd(const void* self);
void ekf2_param_set_baro_bias_nsd(void* self, float v);
float ekf2_param_get_gnd_eff_dz(const void* self);
void ekf2_param_set_gnd_eff_dz(void* self, float v);
float ekf2_param_get_gnd_max_hgt(const void* self);
void ekf2_param_set_gnd_max_hgt(void* self, float v);
# ifdef CONFIG_EKF2_BARO_COMPENSATION
float ekf2_param_get_pcoef_xp(const void* self);
void ekf2_param_set_pcoef_xp(void* self, float v);
float ekf2_param_get_pcoef_xn(const void* self);
void ekf2_param_set_pcoef_xn(void* self, float v);
float ekf2_param_get_pcoef_yp(const void* self);
void ekf2_param_set_pcoef_yp(void* self, float v);
float ekf2_param_get_pcoef_yn(const void* self);
void ekf2_param_set_pcoef_yn(void* self, float v);
float ekf2_param_get_pcoef_z(const void* self);
void ekf2_param_set_pcoef_z(void* self, float v);
float ekf2_param_get_aspd_max(const void* self);
void ekf2_param_set_aspd_max(void* self, float v);
# endif
#endif
#ifdef CONFIG_EKF2_GNSS
int32_t ekf2_param_get_gps_mode(const void* self);
void ekf2_param_set_gps_mode(void* self, int32_t v);
float ekf2_param_get_gps_delay(const void* self);
void ekf2_param_set_gps_delay(void* self, float v);
float ekf2_param_get_gps_pos_body_x(const void* self);
void ekf2_param_set_gps_pos_body_x(void* self, float v);
float ekf2_param_get_gps_pos_body_y(const void* self);
void ekf2_param_set_gps_pos_body_y(void* self, float v);
float ekf2_param_get_gps_pos_body_z(const void* self);
void ekf2_param_set_gps_pos_body_z(void* self, float v);
float ekf2_param_get_gps_pos_noise(const void* self);
void ekf2_param_set_gps_pos_noise(void* self, float v);
float ekf2_param_get_gps_vel_noise(const void* self);
void ekf2_param_set_gps_vel_noise(void* self, float v);
float ekf2_param_get_gps_hgt_bias_nsd(const void* self);
void ekf2_param_set_gps_hgt_bias_nsd(void* self, float v);
float ekf2_param_get_gps_pos_gate(const void* self);
void ekf2_param_set_gps_pos_gate(void* self, float v);
float ekf2_param_get_gps_vel_gate(const void* self);
void ekf2_param_set_gps_vel_gate(void* self, float v);
int32_t ekf2_param_get_gps_ctrl(const void* self);
void ekf2_param_set_gps_ctrl(void* self, int32_t v);
int32_t ekf2_param_get_gps_check(const void* self);
void ekf2_param_set_gps_check(void* self, int32_t v);
float ekf2_param_get_req_eph(const void* self);
void ekf2_param_set_req_eph(void* self, float v);
float ekf2_param_get_req_epv(const void* self);
void ekf2_param_set_req_epv(void* self, float v);
float ekf2_param_get_req_sacc(const void* self);
void ekf2_param_set_req_sacc(void* self, float v);
int32_t ekf2_param_get_req_nsats(const void* self);
void ekf2_param_set_req_nsats(void* self, int32_t v);
float ekf2_param_get_req_pdop(const void* self);
void ekf2_param_set_req_pdop(void* self, float v);
float ekf2_param_get_req_hdrift(const void* self);
void ekf2_param_set_req_hdrift(void* self, float v);
float ekf2_param_get_req_vdrift(const void* self);
void ekf2_param_set_req_vdrift(void* self, float v);
int32_t ekf2_param_get_req_fix(const void* self);
void ekf2_param_set_req_fix(void* self, int32_t v);
float ekf2_param_get_gsf_tas(const void* self);
void ekf2_param_set_gsf_tas(void* self, float v);
# ifdef CONFIG_EKF2_GNSS_YAW
float ekf2_param_get_gnss_heading_noise(const void* self);
void ekf2_param_set_gnss_heading_noise(void* self, float v);
# endif
#endif
#ifdef CONFIG_EKF2_MAGNETOMETER
float ekf2_param_get_mag_delay(const void* self);
void ekf2_param_set_mag_delay(void* self, float v);
float ekf2_param_get_mag_noise(const void* self);
void ekf2_param_set_mag_noise(void* self, float v);
float ekf2_param_get_mag_decl(const void* self);
void ekf2_param_set_mag_decl(void* self, float v);
float ekf2_param_get_mag_gate(const void* self);
void ekf2_param_set_mag_gate(void* self, float v);
int32_t ekf2_param_get_decl_type(const void* self);
void ekf2_param_set_decl_type(void* self, int32_t v);
int32_t ekf2_param_get_mag_type(const void* self);
void ekf2_param_set_mag_type(void* self, int32_t v);
int32_t ekf2_param_get_mag_check(const void* self);
void ekf2_param_set_mag_check(void* self, int32_t v);
float ekf2_param_get_mag_chk_str(const void* self);
void ekf2_param_set_mag_chk_str(void* self, float v);
float ekf2_param_get_mag_chk_inc(const void* self);
void ekf2_param_set_mag_chk_inc(void* self, float v);
float ekf2_param_get_mag_e_noise(const void* self);
void ekf2_param_set_mag_e_noise(void* self, float v);
float ekf2_param_get_mag_b_noise(const void* self);
void ekf2_param_set_mag_b_noise(void* self, float v);
float ekf2_param_get_mag_acclim(const void* self);
void ekf2_param_set_mag_acclim(void* self, float v);
int32_t ekf2_param_get_synt_mag_z(const void* self);
void ekf2_param_set_synt_mag_z(void* self, int32_t v);
#endif
int32_t ekf2_param_get_hgt_ref(const void* self);
void ekf2_param_set_hgt_ref(void* self, int32_t v);
#ifdef CONFIG_EKF2_AIRSPEED
float ekf2_param_get_asp_delay(const void* self);
void ekf2_param_set_asp_delay(void* self, float v);
float ekf2_param_get_eas_noise(const void* self);
void ekf2_param_set_eas_noise(void* self, float v);
float ekf2_param_get_tas_gate(const void* self);
void ekf2_param_set_tas_gate(void* self, float v);
float ekf2_param_get_arsp_thr(const void* self);
void ekf2_param_set_arsp_thr(void* self, float v);
#endif
#ifdef CONFIG_EKF2_RANGE_FINDER
int32_t ekf2_param_get_rng_ctrl(const void* self);
void ekf2_param_set_rng_ctrl(void* self, int32_t v);
float ekf2_param_get_rng_delay(const void* self);
void ekf2_param_set_rng_delay(void* self, float v);
float ekf2_param_get_rng_noise(const void* self);
void ekf2_param_set_rng_noise(void* self, float v);
float ekf2_param_get_rng_gate(const void* self);
void ekf2_param_set_rng_gate(void* self, float v);
float ekf2_param_get_rng_pitch(const void* self);
void ekf2_param_set_rng_pitch(void* self, float v);
float ekf2_param_get_rng_sfe(const void* self);
void ekf2_param_set_rng_sfe(void* self, float v);
float ekf2_param_get_rng_a_hmax(const void* self);
void ekf2_param_set_rng_a_hmax(void* self, float v);
float ekf2_param_get_rng_a_vmax(const void* self);
void ekf2_param_set_rng_a_vmax(void* self, float v);
float ekf2_param_get_rng_qlty_t(const void* self);
void ekf2_param_set_rng_qlty_t(void* self, float v);
float ekf2_param_get_rng_k_gate(const void* self);
void ekf2_param_set_rng_k_gate(void* self, float v);
float ekf2_param_get_rng_fog(const void* self);
void ekf2_param_set_rng_fog(void* self, float v);
float ekf2_param_get_rng_pos_body_x(const void* self);
void ekf2_param_set_rng_pos_body_x(void* self, float v);
float ekf2_param_get_rng_pos_body_y(const void* self);
void ekf2_param_set_rng_pos_body_y(void* self, float v);
float ekf2_param_get_rng_pos_body_z(const void* self);
void ekf2_param_set_rng_pos_body_z(void* self, float v);
#endif
#ifdef CONFIG_EKF2_EXTERNAL_VISION
int32_t ekf2_param_get_ev_ctrl(const void* self);
void ekf2_param_set_ev_ctrl(void* self, int32_t v);
float ekf2_param_get_ev_delay(const void* self);
void ekf2_param_set_ev_delay(void* self, float v);
float ekf2_param_get_evv_noise(const void* self);
void ekf2_param_set_evv_noise(void* self, float v);
float ekf2_param_get_evp_noise(const void* self);
void ekf2_param_set_evp_noise(void* self, float v);
float ekf2_param_get_eva_noise(const void* self);
void ekf2_param_set_eva_noise(void* self, float v);
int32_t ekf2_param_get_ev_qmin(const void* self);
void ekf2_param_set_ev_qmin(void* self, int32_t v);
float ekf2_param_get_evv_gate(const void* self);
void ekf2_param_set_evv_gate(void* self, float v);
float ekf2_param_get_evp_gate(const void* self);
void ekf2_param_set_evp_gate(void* self, float v);
float ekf2_param_get_ev_hgt_bias_nsd(const void* self);
void ekf2_param_set_ev_hgt_bias_nsd(void* self, float v);
float ekf2_param_get_ev_pos_body_x(const void* self);
void ekf2_param_set_ev_pos_body_x(void* self, float v);
float ekf2_param_get_ev_pos_body_y(const void* self);
void ekf2_param_set_ev_pos_body_y(void* self, float v);
float ekf2_param_get_ev_pos_body_z(const void* self);
void ekf2_param_set_ev_pos_body_z(void* self, float v);
#endif
#ifdef CONFIG_EKF2_OPTICAL_FLOW
int32_t ekf2_param_get_of_ctrl(const void* self);
void ekf2_param_set_of_ctrl(void* self, int32_t v);
int32_t ekf2_param_get_of_gyr_src(const void* self);
void ekf2_param_set_of_gyr_src(void* self, int32_t v);
float ekf2_param_get_of_delay(const void* self);
void ekf2_param_set_of_delay(void* self, float v);
float ekf2_param_get_of_n_min(const void* self);
void ekf2_param_set_of_n_min(void* self, float v);
float ekf2_param_get_of_n_max(const void* self);
void ekf2_param_set_of_n_max(void* self, float v);
int32_t ekf2_param_get_of_qmin(const void* self);
void ekf2_param_set_of_qmin(void* self, int32_t v);
int32_t ekf2_param_get_of_qmin_gnd(const void* self);
void ekf2_param_set_of_qmin_gnd(void* self, int32_t v);
float ekf2_param_get_of_gate(const void* self);
void ekf2_param_set_of_gate(void* self, float v);
float ekf2_param_get_flow_pos_body_x(const void* self);
void ekf2_param_set_flow_pos_body_x(void* self, float v);
float ekf2_param_get_flow_pos_body_y(const void* self);
void ekf2_param_set_flow_pos_body_y(void* self, float v);
float ekf2_param_get_flow_pos_body_z(const void* self);
void ekf2_param_set_flow_pos_body_z(void* self, float v);
#endif
float ekf2_param_get_imu_pos_body_x(const void* self);
void ekf2_param_set_imu_pos_body_x(void* self, float v);
float ekf2_param_get_imu_pos_body_y(const void* self);
void ekf2_param_set_imu_pos_body_y(void* self, float v);
float ekf2_param_get_imu_pos_body_z(const void* self);
void ekf2_param_set_imu_pos_body_z(void* self, float v);
#ifdef CONFIG_EKF2_WIND
float ekf2_param_get_wind_nsd(const void* self);
void ekf2_param_set_wind_nsd(void* self, float v);
#endif
#ifdef CONFIG_EKF2_SIDESLIP
int32_t ekf2_param_get_fuse_beta(const void* self);
void ekf2_param_set_fuse_beta(void* self, int32_t v);
float ekf2_param_get_beta_gate(const void* self);
void ekf2_param_set_beta_gate(void* self, float v);
float ekf2_param_get_beta_noise(const void* self);
void ekf2_param_set_beta_noise(void* self, float v);
#endif
#ifdef CONFIG_EKF2_TERRAIN
float ekf2_param_get_terr_noise(const void* self);
void ekf2_param_set_terr_noise(void* self, float v);
float ekf2_param_get_terr_grad(const void* self);
void ekf2_param_set_terr_grad(void* self, float v);
#endif
#if defined(CONFIG_EKF2_TERRAIN) || defined(CONFIG_EKF2_OPTICAL_FLOW) || defined(CONFIG_EKF2_RANGE_FINDER)
float ekf2_param_get_min_rng(const void* self);
void ekf2_param_set_min_rng(void* self, float v);
#endif
#ifdef CONFIG_EKF2_GRAVITY_FUSION
float ekf2_param_get_grav_noise(const void* self);
void ekf2_param_set_grav_noise(void* self, float v);
#endif
#ifdef CONFIG_EKF2_DRAG_FUSION
int32_t ekf2_param_get_drag_ctrl(const void* self);
void ekf2_param_set_drag_ctrl(void* self, int32_t v);
float ekf2_param_get_drag_noise(const void* self);
void ekf2_param_set_drag_noise(void* self, float v);
float ekf2_param_get_bcoef_x(const void* self);
void ekf2_param_set_bcoef_x(void* self, float v);
float ekf2_param_get_bcoef_y(const void* self);
void ekf2_param_set_bcoef_y(void* self, float v);
float ekf2_param_get_mcoef(const void* self);
void ekf2_param_set_mcoef(void* self, float v);
#endif
#ifdef CONFIG_EKF2_AUXVEL
float ekf2_param_get_avel_delay(const void* self);
void ekf2_param_set_avel_delay(void* self, float v);
#endif
#ifdef __cplusplus
}
#endif