px4-firmware/EKF/ekf.h

/****************************************************************************
 *
 *   Copyright (c) 2015 Estimation and Control Library (ECL). All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name ECL nor the names of its contributors may be
 *    used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/

/**
 * @file ekf.h
 * Class for core functions for ekf attitude and position estimator.
 *
 * @author Roman Bast <bapstroman@gmail.com>
 * @author Paul Riseborough <p_riseborough@live.com.au>
 *
 */

#include "estimator_interface.h"
#include "geo.h"

class Ekf : public EstimatorInterface
{
public:

	Ekf();
	~Ekf();

	// initialise variables to sane values (also interface class)
	bool init(uint64_t timestamp);

	// should be called every time new data is pushed into the filter
	bool update();

	// gets the innovations of velocity and position measurements
	// 0-2 vel, 3-5 pos
	void get_vel_pos_innov(float vel_pos_innov[6]);

	// gets the innovations of the earth magnetic field measurements
	void get_mag_innov(float mag_innov[3]);

	// gets the innovations of the heading measurement
	void get_heading_innov(float *heading_innov);

	// gets the innovation variances of velocity and position measurements
	// 0-2 vel, 3-5 pos
	void get_vel_pos_innov_var(float vel_pos_innov_var[6]);

	// gets the innovation variances of the earth magnetic field measurements
	void get_mag_innov_var(float mag_innov_var[3]);

	// gets the innovations of airspeed measurement
	void get_airspeed_innov(float *airspeed_innov);

	// gets the innovation variance of the airspeed measurement
	void get_airspeed_innov_var(float *airspeed_innov_var);

	// gets the innovations of synthetic sideslip measurement
 	void get_beta_innov(float *beta_innov);

 	// gets the innovation variance of the synthetic sideslip measurement
 	void get_beta_innov_var(float *beta_innov_var);

	// gets the innovation variance of the heading measurement
	void get_heading_innov_var(float *heading_innov_var);

	// gets the innovation variance of the flow measurement
	void get_flow_innov_var(float flow_innov_var[2]);

	// gets the innovation of the flow measurement
	void get_flow_innov(float flow_innov[2]);

	// gets the innovation variance of the HAGL measurement
	void get_hagl_innov_var(float *hagl_innov_var);

	// gets the innovation of the HAGL measurement
	void get_hagl_innov(float *hagl_innov);

	// get the state vector at the delayed time horizon
	void get_state_delayed(float *state);

	// get the wind velocity in m/s
	void get_wind_velocity(float *wind);

	// get the diagonal elements of the covariance matrix
	void get_covariances(float *covariances);

	// ask estimator for sensor data collection decision and do any preprocessing if required, returns true if not defined
	bool collect_gps(uint64_t time_usec, struct gps_message *gps);
	bool collect_imu(imuSample &imu);

	// get the ekf WGS-84 origin position and height and the system time it was last set
	// return true if the origin is valid
	bool get_ekf_origin(uint64_t *origin_time, map_projection_reference_s *origin_pos, float *origin_alt);

	// get the 1-sigma horizontal and vertical position uncertainty of the ekf WGS-84 position
	void get_ekf_accuracy(float *ekf_eph, float *ekf_epv, bool *dead_reckoning);

	void get_vel_var(Vector3f &vel_var);

	void get_pos_var(Vector3f &pos_var);

	// return an array containing the output predictor angular, velocity and position tracking
	// error magnitudes (rad), (m/s), (m)
	void get_output_tracking_error(float error[3]);

	/*
	Returns  following IMU vibration metrics in the following array locations
	0 : Gyro delta angle coning metric = filtered length of (delta_angle x prev_delta_angle)
	1 : Gyro high frequency vibe = filtered length of (delta_angle - prev_delta_angle)
	2 : Accel high frequency vibe = filtered length of (delta_velocity - prev_delta_velocity)
	*/
	void get_imu_vibe_metrics(float vibe[3]);

	// return true if the global position estimate is valid
	bool global_position_is_valid();

	// return true if the etimate is valid
	// return the estimated terrain vertical position relative to the NED origin
	bool get_terrain_vert_pos(float *ret);

	// get the accerometer bias in m/s/s
	void get_accel_bias(float bias[3]);

	// get the gyroscope bias in rad/s
	void get_gyro_bias(float bias[3]);

	// get GPS check status
	void get_gps_check_status(uint16_t *_gps_check_fail_status);

	// return the amount the local vertical position changed in the last reset and the number of reset events
	void get_posD_reset(float *delta, uint8_t *counter) {*delta = _state_reset_status.posD_change; *counter = _state_reset_status.posD_counter;}

	// return the amount the local vertical velocity changed in the last reset and the number of reset events
	void get_velD_reset(float *delta, uint8_t *counter) {*delta = _state_reset_status.velD_change; *counter = _state_reset_status.velD_counter;}

	// return the amount the local horizontal position changed in the last reset and the number of reset events
	void get_posNE_reset(float delta[2], uint8_t *counter){
		memcpy(delta, &_state_reset_status.posNE_change._data[0], sizeof(_state_reset_status.posNE_change._data));
		*counter = _state_reset_status.posNE_counter;
	}

	// return the amount the local horizontal velocity changed in the last reset and the number of reset events
	void get_velNE_reset(float delta[2], uint8_t *counter) {
		memcpy(delta, &_state_reset_status.velNE_change._data[0], sizeof(_state_reset_status.velNE_change._data));
		*counter = _state_reset_status.velNE_counter;
	}

	// return the amount the quaternion has changed in the last reset and the number of reset events
	void get_quat_reset(float delta_quat[4], uint8_t *counter)
	{
		memcpy(delta_quat, &_state_reset_status.quat_change._data[0], sizeof(_state_reset_status.quat_change._data));
		*counter = _state_reset_status.quat_counter;
	}

	// get EKF innovation consistency check status information comprising of:
	// status - a bitmask integer containing the pass/fail status for each EKF measurement innovation consistency check
	// Innovation Test Ratios - these are the ratio of the innovation to the acceptance threshold.
	// A value > 1 indicates that the sensor measurement has exceeded the maximum acceptable level and has been rejected by the EKF
	// Where a measurement type is a vector quantity, eg magnetoemter, GPS position, etc, the maximum value is returned.
	void get_innovation_test_status(uint16_t *status, float *mag, float *vel, float *pos, float *hgt, float *tas, float *hagl);

	// return a bitmask integer that describes which state estimates can be used for flight control
	void get_ekf_soln_status(uint16_t *status);

private:

	static const uint8_t _k_num_states = 24;
	static const float _k_earth_rate;
	static const float _gravity_mss;

	// reset event monitoring
	// structure containing velocity, position, height and yaw reset information
	struct {
		uint8_t velNE_counter;	// number of horizontal position reset events (allow to wrap if count exceeds 255)
		uint8_t velD_counter;	// number of vertical velocity reset events (allow to wrap if count exceeds 255)
		uint8_t posNE_counter;	// number of horizontal position reset events (allow to wrap if count exceeds 255)
		uint8_t posD_counter;	// number of vertical position reset events (allow to wrap if count exceeds 255)
		uint8_t quat_counter;	// number of quaternion reset events (allow to wrap if count exceeds 255)
		Vector2f velNE_change;  // North East velocity change due to last reset (m)
		float velD_change;	// Down velocity change due to last reset (m/s)
		Vector2f posNE_change;	// North, East position change due to last reset (m)
		float posD_change;	// Down position change due to last reset (m)
		Quaternion quat_change;	// quaternion delta due to last reset - multiply pre-reset quaternion by this to get post-reset quaternion
	} _state_reset_status;

	float _dt_ekf_avg;		// average update rate of the ekf

	stateSample _state;		// state struct of the ekf running at the delayed time horizon

	bool _filter_initialised;	// true when the EKF sttes and covariances been initialised
	bool _earth_rate_initialised;	// true when we know the earth rotatin rate (requires GPS)

	bool _fuse_height;		// baro height data should be fused
	bool _fuse_pos;			// gps position data should be fused
	bool _fuse_hor_vel;		// gps horizontal velocity measurement should be fused
	bool _fuse_vert_vel;		// gps vertical velocity measurement should be fused

	// booleans true when fresh sensor data is available at the fusion time horizon
	bool _gps_data_ready;
	bool _mag_data_ready;
	bool _baro_data_ready;
	bool _range_data_ready;
	bool _flow_data_ready;
	bool _ev_data_ready;
	bool _tas_data_ready;

	uint64_t _time_last_fake_gps;	// last time in us at which we have faked gps measurement for static mode

	uint64_t _time_last_pos_fuse;   // time the last fusion of horizontal position measurements was performed (usec)
	uint64_t _time_last_vel_fuse;   // time the last fusion of velocity measurements was performed (usec)
	uint64_t _time_last_hgt_fuse;   // time the last fusion of height measurements was performed (usec)
	uint64_t _time_last_of_fuse;    // time the last fusion of optical flow measurements were performed (usec)
	uint64_t _time_last_arsp_fuse;	// time the last fusion of airspeed measurements were performed (usec)
	uint64_t _time_last_beta_fuse;	// time the last fusion of synthetic sideslip measurements were performed (usec)
	Vector2f _last_known_posNE;     // last known local NE position vector (m)
	float _last_disarmed_posD;      // vertical position recorded at arming (m)
	float _last_dt_overrun;		// the amount of time the last IMU collection over-ran the target set by FILTER_UPDATE_PERIOD_MS (sec)

	Vector3f _earth_rate_NED;	// earth rotation vector (NED) in rad/s

	matrix::Dcm<float> _R_to_earth;	// transformation matrix from body frame to earth frame from last EKF predition

	float P[_k_num_states][_k_num_states];	// state covariance matrix

	float _vel_pos_innov[6];	// innovations: 0-2 vel,  3-5 pos
	float _vel_pos_innov_var[6];	// innovation variances: 0-2 vel, 3-5 pos

	float _mag_innov[3];		// earth magnetic field innovations
	float _mag_innov_var[3];	// earth magnetic field innovation variance

	float _airspeed_innov;		// airspeed measurement innovation
	float _airspeed_innov_var;	// airspeed measurement innovation variance

	float _beta_innov;		// synthetic sideslip measurement innovation
 	float _beta_innov_var;	// synthetic sideslip measurement innovation variance

	float _heading_innov;		// heading measurement innovation
	float _heading_innov_var;	// heading measurement innovation variance

	// optical flow processing
	float _flow_innov[2];		// flow measurement innovation
	float _flow_innov_var[2];	// flow innovation variance
	Vector3f _flow_gyro_bias;	// bias errors in optical flow sensor rate gyro outputs
	Vector3f _imu_del_ang_of;	// bias corrected delta angle measurements accumulated across the same time frame as the optical flow rates
	float _delta_time_of;		// time in sec that _imu_del_ang_of was accumulated over

	float _mag_declination;		// magnetic declination used by reset and fusion functions (rad)

	// output predictor states
	Vector3f _delta_angle_corr;	// delta angle correction vector
	imuSample _imu_down_sampled;	// down sampled imu data (sensor rate -> filter update rate)
	Quaternion _q_down_sampled;	// down sampled quaternion (tracking delta angles between ekf update steps)
	Vector3f _vel_err_integ;	// integral of velocity tracking error
	Vector3f _pos_err_integ;	// integral of position tracking error
	float _output_tracking_error[3];// contains the magnitude of the angle, velocity and position track errors (rad, m/s, m)

	// variables used for the GPS quality checks
	float _gpsDriftVelN;		// GPS north position derivative (m/s)
	float _gpsDriftVelE;		// GPS east position derivative (m/s)
	float _gps_drift_velD;		// GPS down position derivative (m/s)
	float _gps_velD_diff_filt;	// GPS filtered Down velocity (m/s)
	float _gps_velN_filt;		// GPS filtered North velocity (m/s)
	float _gps_velE_filt;		// GPS filtered East velocity (m/s)
	uint64_t _last_gps_fail_us;	// last system time in usec that the GPS failed it's checks

	// Variables used to publish the WGS-84 location of the EKF local NED origin
	uint64_t _last_gps_origin_time_us;  // time the origin was last set (uSec)
	float _gps_alt_ref;		// WGS-84 height (m)

	// Variables used to initialise the filter states
	uint32_t _hgt_counter;		// number of height samples read during initialisation
	float _rng_filt_state;		// filtered height measurement
	uint32_t _mag_counter;		// number of magnetometer samples read during initialisation
	uint32_t _ev_counter;		// number of exgernal vision samples read during initialisation
	uint64_t _time_last_mag;	// measurement time of last magnetomter sample
	Vector3f _mag_filt_state;	// filtered magnetometer measurement
	Vector3f _delVel_sum;		// summed delta velocity
	float _hgt_sensor_offset;	// set as necessary if desired to maintain the same height after a height reset (m)
	float _baro_hgt_offset;		// baro height reading at the local NED origin (m)

	// Variables used to control activation of post takeoff functionality
	float _last_on_ground_posD; // last vertical position when the in_air status was false (m)

	gps_check_fail_status_u _gps_check_fail_status;

	// Terrain height state estimation
	float _terrain_vpos;		// estimated vertical position of the terrain underneath the vehicle in local NED frame (m)
	float _terrain_var;		// variance of terrain position estimate (m^2)
	float _hagl_innov;		// innovation of the last height above terrain measurement (m)
	float _hagl_innov_var;		// innovation variance for the last height above terrain measurement (m^2)
	uint64_t _time_last_hagl_fuse;	// last system time in usec that the hagl measurement failed it's checks
	bool _terrain_initialised;	// true when the terrain estimator has been intialised

	// height sensor fault status
	bool _baro_hgt_faulty;		// true if valid baro data is unavailable for use
	bool _gps_hgt_faulty;		// true if valid gps height data is unavailable for use
	bool _rng_hgt_faulty;		// true if valid rnage finder height data is unavailable for use
	int _primary_hgt_source;	// priary source of height data set at initialisation

	// imu fault status
	uint64_t _time_bad_vert_accel;	// last time a bad vertical accel was detected (usec)

	// update the real time complementary filter states. This includes the prediction
	// and the correction step
	void calculateOutputStates();

	// initialise filter states of both the delayed ekf and the real time complementary filter
	bool initialiseFilter(void);

	// initialise ekf covariance matrix
	void initialiseCovariance();

	// predict ekf state
	void predictState();

	// predict ekf covariance
	void predictCovariance();

	// ekf sequential fusion of magnetometer measurements
	void fuseMag();

	// fuse the first euler angle from either a 321 or 312 rotation sequence as the observation (currently measures yaw using the magnetometer)
	void fuseHeading();

	// fuse magnetometer declination measurement
	void fuseDeclination();

	// fuse airspeed measurement
	void fuseAirspeed();

	// fuse synthetic zero sideslip measurement
 	void fuseSideslip();

	// fuse velocity and position measurements (also barometer height)
	void fuseVelPosHeight();

	// reset velocity states of the ekf
	bool resetVelocity();

	// fuse optical flow line of sight rate measurements
	void fuseOptFlow();

	// calculate optical flow bias errors
	void calcOptFlowBias();

	// initialise the terrain vertical position estimator
	// return true if the initialisation is successful
	bool initHagl();

	// predict the terrain vertical position state and variance
	void predictHagl();

	// update the terrain vertical position estimate using a height above ground measurement from the range finder
	void fuseHagl();

	// reset the heading and magnetic field states using the declination and magnetometer measurements
	// return true if successful
	bool resetMagHeading(Vector3f &mag_init);

	// calculate the magnetic declination to be used by the alignment and fusion processing
	void calcMagDeclination();

	// reset position states of the ekf (only vertical position)
	bool resetPosition();

	// reset height state of the ekf
	void resetHeight();

	// modify output filter to match the the EKF state at the fusion time horizon
	void alignOutputFilter();

	// limit the diagonal of the covariance matrix
	void fixCovarianceErrors();

	// make ekf covariance matrix symmetric between a nominated state indexe range
	void makeSymmetrical(float (&cov_mat)[_k_num_states][_k_num_states], uint8_t first, uint8_t last);

	// constrain the ekf states
	void constrainStates();

	// generic function which will perform a fusion step given a kalman gain K
	// and a scalar innovation value
	void fuse(float *K, float innovation);

	// calculate the earth rotation vector from a given latitude
	void calcEarthRateNED(Vector3f &omega, double lat_rad) const;

	// return true id the GPS quality is good enough to set an origin and start aiding
	bool gps_is_good(struct gps_message *gps);

	// Control the filter fusion modes
	void controlFusionModes();

	// control fusion of external vision observations
	void controlExternalVisionFusion();

	// control fusion of optical flow observtions
	void controlOpticalFlowFusion();

	// control fusion of GPS observations
	void controlGpsFusion();

	// control fusion of magnetometer observations
	void controlMagFusion();

	// control fusion of range finder observations
	void controlRangeFinderFusion();

	// control fusion of air data observations
	void controlAirDataFusion();

	// control fusion of synthetic sideslip observations
	void controlBetaFusion();

	// control fusion of pressure altitude observations
	void controlBaroFusion();

	// control fusion of velocity and position observations
	void controlVelPosFusion();

	// control for height sensor timeouts, sensor changes and state resets
	void controlHeightSensorTimeouts();

	// return the square of two floating point numbers - used in auto coded sections
	inline float sq(float var)
	{
		return var * var;
	}

	// zero the specified range of rows in the state covariance matrix
	void zeroRows(float (&cov_mat)[_k_num_states][_k_num_states], uint8_t first, uint8_t last);

	// zero the specified range of columns in the state covariance matrix
	void zeroCols(float (&cov_mat)[_k_num_states][_k_num_states], uint8_t first, uint8_t last);

	// calculate the measurement variance for the optical flow sensor
	float calcOptFlowMeasVar();

	// rotate quaternion covariances into variances for an equivalent rotation vector
	Vector3f calcRotVecVariances();

	// initialise the quaternion covariances using rotation vector variances
	void initialiseQuatCovariances(Vector3f &rot_vec_var);

	// perform a limited reset of the magnetic field state covariances
	void resetMagCovariance();

	// perform a limited reset of the wind state covariances
	void resetWindCovariance();

	// perform a reset of the wind states
	void resetWindStates();

};