Categorieën: Alle - navigation - sensors - manager - libraries

door Roberto Alejandro Morin Romero 7 jaren geleden

1185

Ardupilot

The provided text outlines a comprehensive list of libraries and dependencies used in an ArduPilot project. These libraries cover a wide range of functionalities necessary for the operation and control of autonomous vehicles, such as GPS, flash memory, analog to digital conversion, magnetometers, and inertial sensors.

Ardupilot

AP_Param/AP_Param.h

AP_Param.cpp

AP_Menu/AP_Menu.h

AP_Menu.h

AP_Math/AP_Math.h

vector3.h

vector2.h

rotations.h

quaternion.h

polygon.h

matrix3.h

location.h

edc.h

definitions.h

AP_Location.h

Location.cpp

AP_Common.cpp

Utility

AP_HAL

system.h

HAL.h

SPIDevice.h
Device.h

OpticalFlow.h

Util.h

Semaphores.h

Scheduler.h

RCOutput.h

RCInput.h

GPIO.h

Storage.h

AnalogIn.h

UARTDriver.h

AP_HAL_Main.h

AP_HAL_Macros.h

AP_HAL_Boards.h

AP_HAL_Namespace.h

AP_Avoidance/AP_Avoidance.h

AP_Common/AP_Common.h

AP_AdvancedFailsafe/AP_AdvancedFailsafe.h

#include // Common dependencies #include #include #include #include #include // Application dependencies #include #include // Serial manager library #include // ArduPilot GPS library #include // ArduPilot Mega Flash Memory Library #include // ArduPilot Mega Analog to Digital Converter Library #include #include // ArduPilot Mega Magnetometer Library #include // ArduPilot Mega Vector/Matrix math Library #include // interface and maths for accelerometer calibration #include // ArduPilot Mega Inertial Sensor (accel & gyro) Library #include #include #include #include // Mission command library #include // PID library #include // PID library (2-axis) #include // Heli specific Rate PID library #include // P library #include // Attitude control library #include // Attitude control library for traditional helicopter #include // Position control library #include // RC Channel Library #include // AP Motors library #include // Range finder library #include #include // statistics library #include #include // Optical Flow library #include // RSSI Library #include // Filter library #include // APM FIFO Buffer #include // APM relay #include #include // Photo or video camera #include // Camera/Antenna mount #include // needed for AHRS build #include // needed for AHRS build #include // ArduPilot Mega inertial navigation library #include // ArduCopter waypoint navigation library #include // circle navigation library #include // ArduPilot Mega Declination Helper Library #include // Arducopter Fence library #include // Arducopter stop at fence library #include // main loop scheduler #include // RC input mapping library #include // Notify library #include // Battery monitor library #include // board configuration library #include // Landing Gear library #include #include #include #include // Pilot input handling library #include // Heli specific pilot input handling library #include SITL/SITL.h

AP_Arming/AP_Arming.h

AP_Rally/AP_Rally.h

GCS_MAVLink/GCS.h

#include

AP_AHRS/AP_AHRS.h

ArduCopter.h

StorageManager/StorageManager.h

Copter.h

/*

  This program is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.


  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  GNU General Public License for more details.


  You should have received a copy of the GNU General Public License

  along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#pragma once

/*

 This is the main Copter class

 */


////////////////////////////////////////////////////////////////////////////////

// Header includes

////////////////////////////////////////////////////////////////////////////////


#include <cmath>

#include <stdio.h>

#include <stdarg.h>


#include <AP_HAL/AP_HAL.h>


// Common dependencies

#include <AP_Common/AP_Common.h>

#include <AP_Common/Location.h>

#include <AP_Menu/AP_Menu.h>

#include <AP_Param/AP_Param.h>

#include <StorageManager/StorageManager.h>


// Application dependencies

#include <GCS_MAVLink/GCS.h>

#include <AP_SerialManager/AP_SerialManager.h> // Serial manager library

#include <AP_GPS/AP_GPS.h>      // ArduPilot GPS library

#include <DataFlash/DataFlash.h>     // ArduPilot Mega Flash Memory Library

#include <AP_ADC/AP_ADC.h>      // ArduPilot Mega Analog to Digital Converter Library

#include <AP_Baro/AP_Baro.h>

#include <AP_Compass/AP_Compass.h>    // ArduPilot Mega Magnetometer Library

#include <AP_Math/AP_Math.h>      // ArduPilot Mega Vector/Matrix math Library

#include <AP_AccelCal/AP_AccelCal.h>        // interface and maths for accelerometer calibration

#include <AP_InertialSensor/AP_InertialSensor.h> // ArduPilot Mega Inertial Sensor (accel & gyro) Library

#include <AP_AHRS/AP_AHRS.h>

#include <AP_NavEKF2/AP_NavEKF2.h>

#include <AP_NavEKF3/AP_NavEKF3.h>

#include <AP_Mission/AP_Mission.h>    // Mission command library

#include <AC_PID/AC_PID.h>      // PID library

#include <AC_PID/AC_PI_2D.h>     // PID library (2-axis)

#include <AC_PID/AC_HELI_PID.h>    // Heli specific Rate PID library

#include <AC_PID/AC_P.h>       // P library

#include <AC_AttitudeControl/AC_AttitudeControl_Multi.h> // Attitude control library

#include <AC_AttitudeControl/AC_AttitudeControl_Heli.h> // Attitude control library for traditional helicopter

#include <AC_AttitudeControl/AC_PosControl.h>   // Position control library

#include <RC_Channel/RC_Channel.h>    // RC Channel Library

#include <AP_Motors/AP_Motors.h>     // AP Motors library

#include <AP_RangeFinder/AP_RangeFinder.h>  // Range finder library

#include <AP_Proximity/AP_Proximity.h>

#include <AP_Stats/AP_Stats.h>  // statistics library

#include <AP_Beacon/AP_Beacon.h>

#include <AP_OpticalFlow/AP_OpticalFlow.h>  // Optical Flow library

#include <AP_RSSI/AP_RSSI.h>         // RSSI Library

#include <Filter/Filter.h>      // Filter library

#include <AP_Buffer/AP_Buffer.h>     // APM FIFO Buffer

#include <AP_Relay/AP_Relay.h>     // APM relay

#include <AP_ServoRelayEvents/AP_ServoRelayEvents.h>

#include <AP_Camera/AP_Camera.h>     // Photo or video camera

#include <AP_Mount/AP_Mount.h>     // Camera/Antenna mount

#include <AP_Airspeed/AP_Airspeed.h>    // needed for AHRS build

#include <AP_Vehicle/AP_Vehicle.h>    // needed for AHRS build

#include <AP_InertialNav/AP_InertialNav.h>  // ArduPilot Mega inertial navigation library

#include <AC_WPNav/AC_WPNav.h>     // ArduCopter waypoint navigation library

#include <AC_WPNav/AC_Circle.h>     // circle navigation library

#include <AP_Declination/AP_Declination.h>  // ArduPilot Mega Declination Helper Library

#include <AC_Fence/AC_Fence.h>     // Arducopter Fence library

#include <AC_Avoidance/AC_Avoid.h>     // Arducopter stop at fence library

#include <AP_Scheduler/AP_Scheduler.h>   // main loop scheduler

#include <AP_RCMapper/AP_RCMapper.h>    // RC input mapping library

#include <AP_Notify/AP_Notify.h>     // Notify library

#include <AP_BattMonitor/AP_BattMonitor.h>  // Battery monitor library

#include <AP_BoardConfig/AP_BoardConfig.h>  // board configuration library

#include <AP_LandingGear/AP_LandingGear.h>  // Landing Gear library

#include <AP_Terrain/AP_Terrain.h>

#include <AP_ADSB/AP_ADSB.h>

#include <AP_RPM/AP_RPM.h>

#include <AC_InputManager/AC_InputManager.h>    // Pilot input handling library

#include <AC_InputManager/AC_InputManager_Heli.h> // Heli specific pilot input handling library

#include <AP_Button/AP_Button.h>

#include <AP_Arming/AP_Arming.h>


// Configuration

#include "defines.h"

#include "config.h"


#include "GCS_Mavlink.h"

#include "AP_Rally.h"     // Rally point library

#include "AP_Arming.h"


// libraries which are dependent on #defines in defines.h and/or config.h

#if SPRAYER == ENABLED

#include <AC_Sprayer/AC_Sprayer.h>    // crop sprayer library

#endif

#if GRIPPER_ENABLED == ENABLED

#include <AP_Gripper/AP_Gripper.h>      // gripper stuff

#endif

#if PARACHUTE == ENABLED

#include <AP_Parachute/AP_Parachute.h>   // Parachute release library

#endif

#if PRECISION_LANDING == ENABLED

#include <AC_PrecLand/AC_PrecLand.h>

#include <AP_IRLock/AP_IRLock.h>

#endif

#if FRSKY_TELEM_ENABLED == ENABLED

#include <AP_Frsky_Telem/AP_Frsky_Telem.h>

#endif


#if ADVANCED_FAILSAFE == ENABLED

#include "afs_copter.h"

#endif


// Local modules

#include "Parameters.h"

#include "avoidance_adsb.h"


#if CONFIG_HAL_BOARD == HAL_BOARD_SITL

#include <SITL/SITL.h>

#endif



class Copter : public AP_HAL::HAL::Callbacks {

public:

  friend class GCS_MAVLINK_Copter;

  friend class AP_Rally_Copter;

  friend class Parameters;

  friend class ParametersG2;

  friend class AP_Avoidance_Copter;

#if ADVANCED_FAILSAFE == ENABLED

  friend class AP_AdvancedFailsafe_Copter;

#endif

  friend class AP_Arming_Copter;


  Copter(void);


  // HAL::Callbacks implementation.

  void setup() override;

  void loop() override;


private:

  // key aircraft parameters passed to multiple libraries

  AP_Vehicle::MultiCopter aparm;



  // cliSerial isn't strictly necessary - it is an alias for hal.console. It may

  // be deprecated in favor of hal.console in later releases.

  AP_HAL::BetterStream* cliSerial;


  // Global parameters are all contained within the 'g' class.

  Parameters g;

  ParametersG2 g2;


  // main loop scheduler

  AP_Scheduler scheduler;


  // AP_Notify instance

  AP_Notify notify;


  // used to detect MAVLink acks from GCS to stop compassmot

  uint8_t command_ack_counter;


  // has a log download started?

  bool in_log_download;


  // primary input control channels

  RC_Channel *channel_roll;

  RC_Channel *channel_pitch;

  RC_Channel *channel_throttle;

  RC_Channel *channel_yaw;


  // Dataflash

  DataFlash_Class DataFlash;


  AP_GPS gps;


  // flight modes convenience array

  AP_Int8 *flight_modes;


  AP_Baro barometer;

  Compass compass;

  AP_InertialSensor ins;


  RangeFinder rangefinder {serial_manager, ROTATION_PITCH_270};

  struct {

    bool enabled:1;

    bool alt_healthy:1; // true if we can trust the altitude from the rangefinder

    int16_t alt_cm;  // tilt compensated altitude (in cm) from rangefinder

    uint32_t last_healthy_ms;

    LowPassFilterFloat alt_cm_filt; // altitude filter

    int8_t glitch_count;

  } rangefinder_state = { false, false, 0, 0 };


  AP_RPM rpm_sensor;


  // Inertial Navigation EKF

  NavEKF2 EKF2{&ahrs, barometer, rangefinder};

  NavEKF3 EKF3{&ahrs, barometer, rangefinder};

  AP_AHRS_NavEKF ahrs{ins, barometer, gps, rangefinder, EKF2, EKF3, AP_AHRS_NavEKF::FLAG_ALWAYS_USE_EKF};


#if CONFIG_HAL_BOARD == HAL_BOARD_SITL

  SITL::SITL sitl;

#endif


  // Mission library

  AP_Mission mission;


  // Arming/Disarming mangement class

  AP_Arming_Copter arming {ahrs, barometer, compass, battery, inertial_nav, ins};


  // Optical flow sensor

#if OPTFLOW == ENABLED

  OpticalFlow optflow{ahrs};

#endif


  // gnd speed limit required to observe optical flow sensor limits

  float ekfGndSpdLimit;


  // scale factor applied to velocity controller gain to prevent optical flow noise causing excessive angle demand noise

  float ekfNavVelGainScaler;


  // system time in milliseconds of last recorded yaw reset from ekf

  uint32_t ekfYawReset_ms = 0;

  int8_t ekf_primary_core;


  // GCS selection

  AP_SerialManager serial_manager;

  static const uint8_t num_gcs = MAVLINK_COMM_NUM_BUFFERS;


  GCS_MAVLINK_Copter gcs_chan[MAVLINK_COMM_NUM_BUFFERS];

  GCS _gcs; // avoid using this; use gcs()

  GCS &gcs() { return _gcs; }


  // User variables

#ifdef USERHOOK_VARIABLES

# include USERHOOK_VARIABLES

#endif


  // Documentation of GLobals:

  union {

    struct {

      uint8_t unused1        : 1; // 0

      uint8_t simple_mode      : 2; // 1,2  // This is the state of simple mode : 0 = disabled ; 1 = SIMPLE ; 2 = SUPERSIMPLE

      uint8_t pre_arm_rc_check    : 1; // 3   // true if rc input pre-arm checks have been completed successfully

      uint8_t pre_arm_check     : 1; // 4   // true if all pre-arm checks (rc, accel calibration, gps lock) have been performed

      uint8_t auto_armed       : 1; // 5   // stops auto missions from beginning until throttle is raised

      uint8_t logging_started    : 1; // 6   // true if dataflash logging has started

      uint8_t land_complete     : 1; // 7   // true if we have detected a landing

      uint8_t new_radio_frame    : 1; // 8   // Set true if we have new PWM data to act on from the Radio

      uint8_t usb_connected     : 1; // 9   // true if APM is powered from USB connection

      uint8_t rc_receiver_present  : 1; // 10   // true if we have an rc receiver present (i.e. if we've ever received an update

      uint8_t compass_mot      : 1; // 11   // true if we are currently performing compassmot calibration

      uint8_t motor_test       : 1; // 12   // true if we are currently performing the motors test

      uint8_t initialised      : 1; // 13   // true once the init_ardupilot function has completed. Extended status to GCS is not sent until this completes

      uint8_t land_complete_maybe  : 1; // 14   // true if we may have landed (less strict version of land_complete)

      uint8_t throttle_zero     : 1; // 15   // true if the throttle stick is at zero, debounced, determines if pilot intends shut-down when not using motor interlock

      uint8_t system_time_set    : 1; // 16   // true if the system time has been set from the GPS

      uint8_t gps_base_pos_set    : 1; // 17   // true when the gps base position has been set (used for RTK gps only)

      enum HomeState home_state   : 2; // 18,19 // home status (unset, set, locked)

      uint8_t using_interlock    : 1; // 20   // aux switch motor interlock function is in use

      uint8_t motor_emergency_stop  : 1; // 21   // motor estop switch, shuts off motors when enabled

      uint8_t land_repo_active    : 1; // 22   // true if the pilot is overriding the landing position

      uint8_t motor_interlock_switch : 1; // 23   // true if pilot is requesting motor interlock enable

      uint8_t in_arming_delay    : 1; // 24   // true while we are armed but waiting to spin motors

    };

    uint32_t value;

  } ap;


  // This is the state of the flight control system

  // There are multiple states defined such as STABILIZE, ACRO,

  control_mode_t control_mode;

  mode_reason_t control_mode_reason = MODE_REASON_UNKNOWN;


  control_mode_t prev_control_mode;

  mode_reason_t prev_control_mode_reason = MODE_REASON_UNKNOWN;


  // Structure used to detect changes in the flight mode control switch

  struct {

    int8_t debounced_switch_position; // currently used switch position

    int8_t last_switch_position;    // switch position in previous iteration

    uint32_t last_edge_time_ms;    // system time that switch position was last changed

  } control_switch_state;


  struct {

    bool running;

    float max_speed;

    float alt_delta;

    uint32_t start_ms;

  } takeoff_state;


  // altitude below which we do no navigation in auto takeoff

  float auto_takeoff_no_nav_alt_cm;

   

  RCMapper rcmap;


  // board specific config

  AP_BoardConfig BoardConfig;


  // receiver RSSI

  uint8_t receiver_rssi;


  // Failsafe

  struct {

    uint8_t rc_override_active : 1; // 0 // true if rc control are overwritten by ground station

    uint8_t radio       : 1; // 1 // A status flag for the radio failsafe

    uint8_t battery      : 1; // 2 // A status flag for the battery failsafe

    uint8_t gcs        : 1; // 4 // A status flag for the ground station failsafe

    uint8_t ekf        : 1; // 5 // true if ekf failsafe has occurred

    uint8_t terrain      : 1; // 6 // true if the missing terrain data failsafe has occurred

    uint8_t adsb        : 1; // 7 // true if an adsb related failsafe has occurred


    int8_t radio_counter;      // number of iterations with throttle below throttle_fs_value


    uint32_t last_heartbeat_ms;   // the time when the last HEARTBEAT message arrived from a GCS - used for triggering gcs failsafe

    uint32_t terrain_first_failure_ms; // the first time terrain data access failed - used to calculate the duration of the failure

    uint32_t terrain_last_failure_ms; // the most recent time terrain data access failed

  } failsafe;


  // sensor health for logging

  struct {

    uint8_t baro    : 1;  // true if baro is healthy

    uint8_t compass  : 1;  // true if compass is healthy

    uint8_t primary_gps;    // primary gps index

  } sensor_health;


  // Motor Output

#if FRAME_CONFIG == HELI_FRAME

 #define MOTOR_CLASS AP_MotorsHeli_Single

#else

 #define MOTOR_CLASS AP_MotorsMulticopter

#endif


  MOTOR_CLASS *motors;


  // GPS variables

  // Sometimes we need to remove the scaling for distance calcs

  float scaleLongDown;


  // Location & Navigation

  int32_t wp_bearing;

  // The location of home in relation to the copter in centi-degrees

  int32_t home_bearing;

  // distance between plane and home in cm

  int32_t home_distance;

  // distance between plane and next waypoint in cm.

  uint32_t wp_distance;

  LandStateType land_state = LandStateType_FlyToLocation; // records state of land (flying to location, descending)


  struct {

    PayloadPlaceStateType state = PayloadPlaceStateType_Calibrating_Hover_Start; // records state of place (descending, releasing, released, ...)

    uint32_t hover_start_timestamp; // milliseconds

    float hover_throttle_level;

    uint32_t descend_start_timestamp; // milliseconds

    uint32_t place_start_timestamp; // milliseconds

    float descend_throttle_level;

    float descend_start_altitude;

    float descend_max; // centimetres

  } nav_payload_place;


  // Auto

  AutoMode auto_mode; // controls which auto controller is run


  // Guided

  GuidedMode guided_mode; // controls which controller is run (pos or vel)


  // RTL

  RTLState rtl_state; // records state of rtl (initial climb, returning home, etc)

  bool rtl_state_complete; // set to true if the current state is completed


  struct {

    // NEU w/ Z element alt-above-ekf-origin unless use_terrain is true in which case Z element is alt-above-terrain

    Location_Class origin_point;

    Location_Class climb_target;

    Location_Class return_target;

    Location_Class descent_target;

    bool land;

    bool terrain_used;

  } rtl_path;


  // Circle

  bool circle_pilot_yaw_override; // true if pilot is overriding yaw


  // SIMPLE Mode

  // Used to track the orientation of the copter for Simple mode. This value is reset at each arming

  // or in SuperSimple mode when the copter leaves a 20m radius from home.

  float simple_cos_yaw;

  float simple_sin_yaw;

  int32_t super_simple_last_bearing;

  float super_simple_cos_yaw;

  float super_simple_sin_yaw;


  // Stores initial bearing when armed - initial simple bearing is modified in super simple mode so not suitable

  int32_t initial_armed_bearing;


  // Loiter control

  uint16_t loiter_time_max;        // How long we should stay in Loiter Mode for mission scripting (time in seconds)

  uint32_t loiter_time;          // How long have we been loitering - The start time in millis


  // Brake

  uint32_t brake_timeout_start;

  uint32_t brake_timeout_ms;


  // Delay the next navigation command

  int32_t nav_delay_time_max; // used for delaying the navigation commands (eg land,takeoff etc.)

  uint32_t nav_delay_time_start;


  // Flip

  Vector3f flip_orig_attitude;    // original copter attitude before flip


  // throw mode state

  struct {

    ThrowModeStage stage;

    ThrowModeStage prev_stage;

    uint32_t last_log_ms;

    bool nextmode_attempted;

    uint32_t free_fall_start_ms;  // system time free fall was detected

    float free_fall_start_velz;  // vertical velocity when free fall was detected

  } throw_state = {Throw_Disarmed, Throw_Disarmed, 0, false, 0, 0.0f};


  // Battery Sensors

  AP_BattMonitor battery;


  // FrSky telemetry support

#if FRSKY_TELEM_ENABLED == ENABLED

  AP_Frsky_Telem frsky_telemetry;

#endif


  // Variables for extended status MAVLink messages

  uint32_t control_sensors_present;

  uint32_t control_sensors_enabled;

  uint32_t control_sensors_health;

   

  // Altitude

  // The cm/s we are moving up or down based on filtered data - Positive = UP

  int16_t climb_rate;

  float target_rangefinder_alt; // desired altitude in cm above the ground

  int32_t baro_alt;      // barometer altitude in cm above home

  float baro_climbrate;    // barometer climbrate in cm/s

  LowPassFilterVector3f land_accel_ef_filter; // accelerations for land and crash detector tests


  // filtered pilot's throttle input used to cancel landing if throttle held high

  LowPassFilterFloat rc_throttle_control_in_filter;


  // 3D Location vectors

  // Current location of the copter (altitude is relative to home)

  Location_Class current_loc;


  // Navigation Yaw control

  // auto flight mode's yaw mode

  uint8_t auto_yaw_mode;


  // Yaw will point at this location if auto_yaw_mode is set to AUTO_YAW_ROI

  Vector3f roi_WP;


  // bearing from current location to the yaw_look_at_WP

  float yaw_look_at_WP_bearing;


  // yaw used for YAW_LOOK_AT_HEADING yaw_mode

  int32_t yaw_look_at_heading;


  // Deg/s we should turn

  int16_t yaw_look_at_heading_slew;


  // heading when in yaw_look_ahead_bearing

  float yaw_look_ahead_bearing;


  // Delay Mission Scripting Command

  int32_t condition_value; // used in condition commands (eg delay, change alt, etc.)

  uint32_t condition_start;


  // IMU variables

  // Integration time (in seconds) for the gyros (DCM algorithm)

  // Updated with the fast loop

  float G_Dt;


  // Inertial Navigation

  AP_InertialNav_NavEKF inertial_nav;


  // Attitude, Position and Waypoint navigation objects

  // To-Do: move inertial nav up or other navigation variables down here

  AC_AttitudeControl *attitude_control;

  AC_PosControl *pos_control;

  AC_WPNav *wp_nav;

  AC_Circle *circle_nav;


  // Performance monitoring

  int16_t pmTest1;


  // System Timers

  // --------------

  // Time in microseconds of main control loop

  uint32_t fast_loopTimer;

  // Counter of main loop executions. Used for performance monitoring and failsafe processing

  uint16_t mainLoop_count;

  // Loiter timer - Records how long we have been in loiter

  uint32_t rtl_loiter_start_time;

  // arm_time_ms - Records when vehicle was armed. Will be Zero if we are disarmed.

  uint32_t arm_time_ms;


  // Used to exit the roll and pitch auto trim function

  uint8_t auto_trim_counter;


  // Reference to the relay object

  AP_Relay relay;


  // handle repeated servo and relay events

  AP_ServoRelayEvents ServoRelayEvents;


  // Reference to the camera object (it uses the relay object inside it)

#if CAMERA == ENABLED

  AP_Camera camera;

#endif


  // Camera/Antenna mount tracking and stabilisation stuff

#if MOUNT == ENABLED

  // current_loc uses the baro/gps soloution for altitude rather than gps only.

  AP_Mount camera_mount;

#endif


  // AC_Fence library to reduce fly-aways

#if AC_FENCE == ENABLED

  AC_Fence  fence;

#endif

#if AC_AVOID_ENABLED == ENABLED

  AC_Avoid avoid;

#endif

  // Rally library

#if AC_RALLY == ENABLED

  AP_Rally_Copter rally;

#endif


  // RSSI 

  AP_RSSI rssi;   


  // Crop Sprayer

#if SPRAYER == ENABLED

  AC_Sprayer sprayer;

#endif


  // Parachute release

#if PARACHUTE == ENABLED

  AP_Parachute parachute;

#endif


  // Landing Gear Controller

  AP_LandingGear landinggear;


  // terrain handling

#if AP_TERRAIN_AVAILABLE && AC_TERRAIN

  AP_Terrain terrain;

#endif


  // Precision Landing

#if PRECISION_LANDING == ENABLED

  AC_PrecLand precland;

#endif


  // Pilot Input Management Library

  // Only used for Helicopter for AC3.3, to be expanded to include Multirotor

  // child class for AC3.4

#if FRAME_CONFIG == HELI_FRAME

  AC_InputManager_Heli input_manager;

#endif


  AP_ADSB adsb {ahrs};


  // avoidance of adsb enabled vehicles (normally manned vheicles)

  AP_Avoidance_Copter avoidance_adsb{ahrs, adsb};


  // use this to prevent recursion during sensor init

  bool in_mavlink_delay;


  // true if we are out of time in our event timeslice

  bool gcs_out_of_time;


  // last valid RC input time

  uint32_t last_radio_update_ms;

   

  // Top-level logic

  // setup the var_info table

  AP_Param param_loader;


#if FRAME_CONFIG == HELI_FRAME

  // Mode filter to reject RC Input glitches. Filter size is 5, and it draws the 4th element, so it can reject 3 low glitches,

  // and 1 high glitch. This is because any "off" glitches can be highly problematic for a helicopter running an ESC

  // governor. Even a single "off" frame can cause the rotor to slow dramatically and take a long time to restart.

  ModeFilterInt16_Size5 rotor_speed_deglitch_filter {4};


  // Tradheli flags

  struct {

    uint8_t dynamic_flight     : 1;  // 0 // true if we are moving at a significant speed (used to turn on/off leaky I terms)

    uint8_t init_targets_on_arming : 1;  // 1 // true if we have been disarmed, and need to reset rate controller targets when we arm

  } heli_flags;


  int16_t hover_roll_trim_scalar_slew;

#endif


  // ground effect detector

  struct {

    bool takeoff_expected;

    bool touchdown_expected;

    uint32_t takeoff_time_ms;

    float takeoff_alt_cm;

  } gndeffect_state;


  // set when we are upgrading parameters from 3.4

  bool upgrading_frame_params;

   

  static const AP_Scheduler::Task scheduler_tasks[];

  static const AP_Param::Info var_info[];

  static const struct LogStructure log_structure[];


  void compass_accumulate(void);

  void compass_cal_update(void);

  void barometer_accumulate(void);

  void perf_update(void);

  void fast_loop();

  void rc_loop();

  void throttle_loop();

  void update_mount();

  void update_trigger(void);

  void update_batt_compass(void);

  void ten_hz_logging_loop();

  void twentyfive_hz_logging();

  void three_hz_loop();

  void one_hz_loop();

  void update_GPS(void);

  void init_simple_bearing();

  void update_simple_mode(void);

  void update_super_simple_bearing(bool force_update);

  void read_AHRS(void);

  void update_altitude();

  void set_home_state(enum HomeState new_home_state);

  bool home_is_set();

  void set_auto_armed(bool b);

  void set_simple_mode(uint8_t b);

  void set_failsafe_radio(bool b);

  void set_failsafe_battery(bool b);

  void set_failsafe_gcs(bool b);

  void set_land_complete(bool b);

  void set_land_complete_maybe(bool b);

  void update_using_interlock();

  void set_motor_emergency_stop(bool b);

  float get_smoothing_gain();

  void get_pilot_desired_lean_angles(float roll_in, float pitch_in, float &roll_out, float &pitch_out, float angle_max);

  float get_pilot_desired_yaw_rate(int16_t stick_angle);

  void check_ekf_reset();

  float get_roi_yaw();

  float get_look_ahead_yaw();

  void update_throttle_hover();

  void set_throttle_takeoff();

  float get_pilot_desired_throttle(int16_t throttle_control, float thr_mid = 0.0f);

  float get_pilot_desired_climb_rate(float throttle_control);

  float get_non_takeoff_throttle();

  float get_surface_tracking_climb_rate(int16_t target_rate, float current_alt_target, float dt);

  float get_avoidance_adjusted_climbrate(float target_rate);

  void auto_takeoff_set_start_alt(void);

  void auto_takeoff_attitude_run(float target_yaw_rate);

  void set_accel_throttle_I_from_pilot_throttle();

  void rotate_body_frame_to_NE(float &x, float &y);

  void gcs_send_heartbeat(void);

  void gcs_send_deferred(void);

  void send_heartbeat(mavlink_channel_t chan);

  void send_attitude(mavlink_channel_t chan);

  void send_fence_status(mavlink_channel_t chan);

  void send_extended_status1(mavlink_channel_t chan);

  void send_location(mavlink_channel_t chan);

  void send_nav_controller_output(mavlink_channel_t chan);

  void send_simstate(mavlink_channel_t chan);

  void send_hwstatus(mavlink_channel_t chan);

  void send_vfr_hud(mavlink_channel_t chan);

  void send_current_waypoint(mavlink_channel_t chan);

  void send_rangefinder(mavlink_channel_t chan);

  void send_proximity(mavlink_channel_t chan, uint16_t count_max);

  void send_rpm(mavlink_channel_t chan);

  void rpm_update();

  void button_update();

  void init_proximity();

  void update_proximity();

  void stats_update();

  void init_beacon();

  void update_beacon();

  void send_pid_tuning(mavlink_channel_t chan);

  void gcs_send_message(enum ap_message id);

  void gcs_send_mission_item_reached_message(uint16_t mission_index);

  void gcs_data_stream_send(void);

  void gcs_check_input(void);

  void gcs_send_text(MAV_SEVERITY severity, const char *str);

  void do_erase_logs(void);

  void Log_Write_AutoTune(uint8_t axis, uint8_t tune_step, float meas_target, float meas_min, float meas_max, float new_gain_rp, float new_gain_rd, float new_gain_sp, float new_ddt);

  void Log_Write_AutoTuneDetails(float angle_cd, float rate_cds);

  void Log_Write_Current();

  void Log_Write_Optflow();

  void Log_Write_Nav_Tuning();

  void Log_Write_Control_Tuning();

  void Log_Write_Performance();

  void Log_Write_Attitude();

  void Log_Write_MotBatt();

  void Log_Write_Event(uint8_t id);

  void Log_Write_Data(uint8_t id, int32_t value);

  void Log_Write_Data(uint8_t id, uint32_t value);

  void Log_Write_Data(uint8_t id, int16_t value);

  void Log_Write_Data(uint8_t id, uint16_t value);

  void Log_Write_Data(uint8_t id, float value);

  void Log_Write_Error(uint8_t sub_system, uint8_t error_code);

  void Log_Write_Baro(void);

  void Log_Write_Parameter_Tuning(uint8_t param, float tuning_val, int16_t control_in, int16_t tune_low, int16_t tune_high);

  void Log_Write_Home_And_Origin();

  void Log_Sensor_Health();

#if FRAME_CONFIG == HELI_FRAME

  void Log_Write_Heli(void);

#endif

  void Log_Write_Precland();

  void Log_Write_GuidedTarget(uint8_t target_type, const Vector3f& pos_target, const Vector3f& vel_target);

  void Log_Write_Throw(ThrowModeStage stage, float velocity, float velocity_z, float accel, float ef_accel_z, bool throw_detect, bool attitude_ok, bool height_ok, bool position_ok);

  void Log_Write_Proximity();

  void Log_Write_Beacon();

  void Log_Write_Vehicle_Startup_Messages();

  void Log_Read(uint16_t log_num, uint16_t start_page, uint16_t end_page);

  void start_logging() ;

  void load_parameters(void);

  void convert_pid_parameters(void);

  void userhook_init();

  void userhook_FastLoop();

  void userhook_50Hz();

  void userhook_MediumLoop();

  void userhook_SlowLoop();

  void userhook_SuperSlowLoop();

  void update_home_from_EKF();

  void set_home_to_current_location_inflight();

  bool set_home_to_current_location();

  bool set_home_to_current_location_and_lock();

  bool set_home_and_lock(const Location& loc);

  bool set_home(const Location& loc);

  bool far_from_EKF_origin(const Location& loc);

  void set_system_time_from_GPS();

  void exit_mission();

  void do_RTL(void);

  bool verify_takeoff();

  bool verify_land();

  bool verify_payload_place();

  bool verify_loiter_unlimited();

  bool verify_loiter_time();

  bool verify_RTL();

  bool verify_wait_delay();

  bool verify_within_distance();

  bool verify_yaw();

  void do_take_picture();

  void log_picture();

  MAV_RESULT mavlink_compassmot(mavlink_channel_t chan);

  void delay(uint32_t ms);

  bool acro_init(bool ignore_checks);

  void acro_run();

  void get_pilot_desired_angle_rates(int16_t roll_in, int16_t pitch_in, int16_t yaw_in, float &roll_out, float &pitch_out, float &yaw_out);

  bool althold_init(bool ignore_checks);

  void althold_run();

  bool auto_init(bool ignore_checks);

  void auto_run();

  void auto_takeoff_start(const Location& dest_loc);

  void auto_takeoff_run();

  void auto_wp_start(const Vector3f& destination);

  void auto_wp_start(const Location_Class& dest_loc);

  void auto_wp_run();

  void auto_spline_run();

  void auto_land_start();

  void auto_land_start(const Vector3f& destination);

  void auto_land_run();

  void do_payload_place(const AP_Mission::Mission_Command& cmd);

  void auto_payload_place_start();

  void auto_payload_place_start(const Vector3f& destination);

  void auto_payload_place_run();

  bool auto_payload_place_run_should_run();

  void auto_payload_place_run_loiter();

  void auto_payload_place_run_descend();

  void auto_payload_place_run_release();

  void auto_rtl_start();

  void auto_rtl_run();

  void auto_circle_movetoedge_start(const Location_Class &circle_center, float radius_m);

  void auto_circle_start();

  void auto_circle_run();

  void auto_nav_guided_start();

  void auto_nav_guided_run();

  bool auto_loiter_start();

  void auto_loiter_run();

  uint8_t get_default_auto_yaw_mode(bool rtl);

  void set_auto_yaw_mode(uint8_t yaw_mode);

  void set_auto_yaw_look_at_heading(float angle_deg, float turn_rate_dps, int8_t direction, uint8_t relative_angle);

  void set_auto_yaw_roi(const Location &roi_location);

  float get_auto_heading(void);

  bool autotune_init(bool ignore_checks);

  void autotune_stop();

  bool autotune_start(bool ignore_checks);

  void autotune_run();

  void autotune_attitude_control();

  void autotune_backup_gains_and_initialise();

  void autotune_load_orig_gains();

  void autotune_load_tuned_gains();

  void autotune_load_intra_test_gains();

  void autotune_load_twitch_gains();

  void autotune_save_tuning_gains();

  void autotune_update_gcs(uint8_t message_id);

  bool autotune_roll_enabled();

  bool autotune_pitch_enabled();

  bool autotune_yaw_enabled();

  void autotune_twitching_test(float measurement, float target, float &measurement_min, float &measurement_max);

  void autotune_updating_d_up(float &tune_d, float tune_d_min, float tune_d_max, float tune_d_step_ratio, float &tune_p, float tune_p_min, float tune_p_max, float tune_p_step_ratio, float target, float measurement_min, float measurement_max);

  void autotune_updating_d_down(float &tune_d, float tune_d_min, float tune_d_step_ratio, float &tune_p, float tune_p_min, float tune_p_max, float tune_p_step_ratio, float target, float measurement_min, float measurement_max);

  void autotune_updating_p_down(float &tune_p, float tune_p_min, float tune_p_step_ratio, float target, float measurement_max);

  void autotune_updating_p_up(float &tune_p, float tune_p_max, float tune_p_step_ratio, float target, float measurement_max);

  void autotune_updating_p_up_d_down(float &tune_d, float tune_d_min, float tune_d_step_ratio, float &tune_p, float tune_p_min, float tune_p_max, float tune_p_step_ratio, float target, float measurement_min, float measurement_max);

  void autotune_twitching_measure_acceleration(float &rate_of_change, float rate_measurement, float &rate_measurement_max);

  void autotune_get_poshold_attitude(float &roll_cd, float &pitch_cd, float &yaw_cd);

  void avoidance_adsb_update(void);

#if ADVANCED_FAILSAFE == ENABLED

  void afs_fs_check(void);

#endif

  bool brake_init(bool ignore_checks);

  void brake_run();

  void brake_timeout_to_loiter_ms(uint32_t timeout_ms);

  bool circle_init(bool ignore_checks);

  void circle_run();

  bool drift_init(bool ignore_checks);

  void drift_run();

  float get_throttle_assist(float velz, float pilot_throttle_scaled);

  bool flip_init(bool ignore_checks);

  void flip_run();

  bool guided_init(bool ignore_checks);

  bool guided_takeoff_start(float final_alt_above_home);

  void guided_pos_control_start();

  void guided_vel_control_start();

  void guided_posvel_control_start();

  void guided_angle_control_start();

  bool guided_set_destination(const Vector3f& destination);

  bool guided_set_destination(const Location_Class& dest_loc);

  void guided_set_velocity(const Vector3f& velocity);

  void guided_set_destination_posvel(const Vector3f& destination, const Vector3f& velocity);

  void guided_set_angle(const Quaternion &q, float climb_rate_cms, bool use_yaw_rate, float yaw_rate_rads);

  void guided_run();

  void guided_takeoff_run();

  void guided_pos_control_run();

  void guided_vel_control_run();

  void guided_posvel_control_run();

  void guided_angle_control_run();

  void guided_set_desired_velocity_with_accel_and_fence_limits(const Vector3f& vel_des);

  void guided_limit_clear();

  void guided_limit_set(uint32_t timeout_ms, float alt_min_cm, float alt_max_cm, float horiz_max_cm);

  void guided_limit_init_time_and_pos();

  bool guided_limit_check();

  bool guided_nogps_init(bool ignore_checks);

  void guided_nogps_run();

  bool land_init(bool ignore_checks);

  void land_run();

  void land_gps_run();

  void land_nogps_run();

  int32_t land_get_alt_above_ground(void);

  void land_run_vertical_control(bool pause_descent = false);

  void land_run_horizontal_control();

  void land_do_not_use_GPS();

  void set_mode_land_with_pause(mode_reason_t reason);

  bool landing_with_GPS();

  bool loiter_init(bool ignore_checks);

  void loiter_run();

#if PRECISION_LANDING == ENABLED

  bool do_precision_loiter() const;

  void precision_loiter_xy();

  void set_precision_loiter_enabled(bool value) { _precision_loiter_enabled = value; }

  bool _precision_loiter_enabled;

#endif

  bool poshold_init(bool ignore_checks);

  void poshold_run();

  void poshold_update_pilot_lean_angle(float &lean_angle_filtered, float &lean_angle_raw);

  int16_t poshold_mix_controls(float mix_ratio, int16_t first_control, int16_t second_control);

  void poshold_update_brake_angle_from_velocity(int16_t &brake_angle, float velocity);

  void poshold_update_wind_comp_estimate();

  void poshold_get_wind_comp_lean_angles(int16_t &roll_angle, int16_t &pitch_angle);

  void poshold_roll_controller_to_pilot_override();

  void poshold_pitch_controller_to_pilot_override();


  // Throw to launch functionality

  bool throw_init(bool ignore_checks);

  void throw_run();

  bool throw_detected();

  bool throw_attitude_good();

  bool throw_height_good();

  bool throw_position_good();


  bool rtl_init(bool ignore_checks);

  void rtl_restart_without_terrain();

  void rtl_run();

  void rtl_climb_start();

  void rtl_return_start();

  void rtl_climb_return_run();

  void rtl_loiterathome_start();

  void rtl_loiterathome_run();

  void rtl_descent_start();

  void rtl_descent_run();

  void rtl_land_start();

  void rtl_land_run();

  void rtl_build_path(bool terrain_following_allowed);

  void rtl_compute_return_target(bool terrain_following_allowed);

  bool sport_init(bool ignore_checks);

  void sport_run();

  bool stabilize_init(bool ignore_checks);

  void stabilize_run();

  void crash_check();

  void parachute_check();

  void parachute_release();

  void parachute_manual_release();


  // support for AP_Avoidance custom flight mode, AVOID_ADSB

  bool avoid_adsb_init(bool ignore_checks);

  void avoid_adsb_run();

  bool avoid_adsb_set_velocity(const Vector3f& velocity_neu);


  void ekf_check();

  bool ekf_over_threshold();

  void failsafe_ekf_event();

  void failsafe_ekf_off_event(void);

  void esc_calibration_startup_check();

  void esc_calibration_passthrough();

  void esc_calibration_auto();

  bool should_disarm_on_failsafe();

  void failsafe_radio_on_event();

  void failsafe_radio_off_event();

  void failsafe_battery_event(void);

  void failsafe_gcs_check();

  void failsafe_gcs_off_event(void);

  void failsafe_terrain_check();

  void failsafe_terrain_set_status(bool data_ok);

  void failsafe_terrain_on_event();

  void set_mode_RTL_or_land_with_pause(mode_reason_t reason);

  void update_events();

  void failsafe_enable();

  void failsafe_disable();

  void fence_check();

  void fence_send_mavlink_status(mavlink_channel_t chan);

  void update_sensor_status_flags(void);

  bool set_mode(control_mode_t mode, mode_reason_t reason);

  bool gcs_set_mode(uint8_t mode) { return set_mode((control_mode_t)mode, MODE_REASON_GCS_COMMAND); }

  void update_flight_mode();

  void exit_mode(control_mode_t old_control_mode, control_mode_t new_control_mode);

  bool mode_requires_GPS(control_mode_t mode);

  bool mode_has_manual_throttle(control_mode_t mode);

  bool mode_allows_arming(control_mode_t mode, bool arming_from_gcs);

  void notify_flight_mode(control_mode_t mode);

  void heli_init();

  void check_dynamic_flight(void);

  void update_heli_control_dynamics(void);

  void heli_update_landing_swash();

  void heli_update_rotor_speed_targets();

  bool heli_acro_init(bool ignore_checks);

  void heli_acro_run();

  bool heli_stabilize_init(bool ignore_checks);

  void heli_stabilize_run();

  void read_inertia();

  bool land_complete_maybe();

  void update_land_and_crash_detectors();

  void update_land_detector();

  void update_throttle_thr_mix();

  void update_ground_effect_detector(void);

  void landinggear_update();

  void update_notify();

  void motor_test_output();

  bool mavlink_motor_test_check(mavlink_channel_t chan, bool check_rc);

  uint8_t mavlink_motor_test_start(mavlink_channel_t chan, uint8_t motor_seq, uint8_t throttle_type, uint16_t throttle_value, float timeout_sec);

  void motor_test_stop();

  void arm_motors_check();

  void auto_disarm_check();

  bool init_arm_motors(bool arming_from_gcs);

  void init_disarm_motors();

  void motors_output();

  void lost_vehicle_check();

  void run_nav_updates(void);

  void calc_distance_and_bearing();

  void calc_wp_distance();

  void calc_wp_bearing();

  void calc_home_distance_and_bearing();

  void run_autopilot();

  void perf_info_reset();

  void perf_ignore_this_loop();

  void perf_info_check_loop_time(uint32_t time_in_micros);

  uint16_t perf_info_get_num_loops();

  uint32_t perf_info_get_max_time();

  uint32_t perf_info_get_min_time();

  uint16_t perf_info_get_num_long_running();

  uint32_t perf_info_get_num_dropped();

  Vector3f pv_location_to_vector(const Location& loc);

  float pv_alt_above_origin(float alt_above_home_cm);

  float pv_alt_above_home(float alt_above_origin_cm);

  float pv_get_bearing_cd(const Vector3f &origin, const Vector3f &destination);

  float pv_get_horizontal_distance_cm(const Vector3f &origin, const Vector3f &destination);

  float pv_distance_to_home_cm(const Vector3f &destination);

  void default_dead_zones();

  void init_rc_in();

  void init_rc_out();

  void enable_motor_output();

  void read_radio();

  void set_throttle_and_failsafe(uint16_t throttle_pwm);

  void set_throttle_zero_flag(int16_t throttle_control);

  void radio_passthrough_to_motors();

  void init_barometer(bool full_calibration);

  void read_barometer(void);

  void init_rangefinder(void);

  void read_rangefinder(void);

  bool rangefinder_alt_ok();

  void init_compass();

  void init_optflow();

  void update_optical_flow(void);

  void init_precland();

  void update_precland();

  void read_battery(void);

  void read_receiver_rssi(void);

  void epm_update();

  void gripper_update();

  void terrain_update();

  void terrain_logging();

  bool terrain_use();

  void report_batt_monitor();

  void report_frame();

  void report_radio();

  void report_ins();

  void report_flight_modes();

  void report_optflow();

  void print_radio_values();

  void print_switch(uint8_t p, uint8_t m, bool b);

  void print_accel_offsets_and_scaling(void);

  void print_gyro_offsets(void);

  void report_compass();

  void print_blanks(int16_t num);

  void print_divider(void);

  void print_enabled(bool b);

  void report_version();

  void read_control_switch();

  bool check_if_auxsw_mode_used(uint8_t auxsw_mode_check);

  bool check_duplicate_auxsw(void);

  void reset_control_switch();

  uint8_t read_3pos_switch(uint8_t chan);

  void read_aux_switches();

  void init_aux_switches();

  void init_aux_switch_function(int8_t ch_option, uint8_t ch_flag);

  void do_aux_switch_function(int8_t ch_function, uint8_t ch_flag);

  void save_trim();

  void auto_trim();

  void init_ardupilot();

  void startup_INS_ground();

  bool calibrate_gyros();

  bool position_ok();

  bool ekf_position_ok();

  bool optflow_position_ok();

  void update_auto_armed();

  void check_usb_mux(void);

  bool should_log(uint32_t mask);

  void set_default_frame_class();

  void allocate_motors(void);

  uint8_t get_frame_mav_type();

  const char* get_frame_string();

  bool current_mode_has_user_takeoff(bool must_navigate);

  bool do_user_takeoff(float takeoff_alt_cm, bool must_navigate);

  void takeoff_timer_start(float alt_cm);

  void takeoff_stop();

  void takeoff_get_climb_rates(float& pilot_climb_rate, float& takeoff_climb_rate);

  void print_hit_enter();

  void tuning();

  void gcs_send_text_fmt(MAV_SEVERITY severity, const char *fmt, ...);

  bool start_command(const AP_Mission::Mission_Command& cmd);

  bool verify_command(const AP_Mission::Mission_Command& cmd);

  bool verify_command_callback(const AP_Mission::Mission_Command& cmd);


  Location_Class terrain_adjusted_location(const AP_Mission::Mission_Command& cmd) const;


  bool do_guided(const AP_Mission::Mission_Command& cmd);

  void do_takeoff(const AP_Mission::Mission_Command& cmd);

  void do_nav_wp(const AP_Mission::Mission_Command& cmd);

  void do_land(const AP_Mission::Mission_Command& cmd);

  void do_loiter_unlimited(const AP_Mission::Mission_Command& cmd);

  void do_circle(const AP_Mission::Mission_Command& cmd);

  void do_loiter_time(const AP_Mission::Mission_Command& cmd);

  void do_spline_wp(const AP_Mission::Mission_Command& cmd);

#if NAV_GUIDED == ENABLED

  void do_nav_guided_enable(const AP_Mission::Mission_Command& cmd);

  void do_guided_limits(const AP_Mission::Mission_Command& cmd);

#endif

  void do_nav_delay(const AP_Mission::Mission_Command& cmd);

  void do_wait_delay(const AP_Mission::Mission_Command& cmd);

  void do_within_distance(const AP_Mission::Mission_Command& cmd);

  void do_yaw(const AP_Mission::Mission_Command& cmd);

  void do_change_speed(const AP_Mission::Mission_Command& cmd);

  void do_set_home(const AP_Mission::Mission_Command& cmd);

  void do_roi(const AP_Mission::Mission_Command& cmd);

  void do_mount_control(const AP_Mission::Mission_Command& cmd);

#if CAMERA == ENABLED

  void do_digicam_configure(const AP_Mission::Mission_Command& cmd);

  void do_digicam_control(const AP_Mission::Mission_Command& cmd);

#endif

#if PARACHUTE == ENABLED

  void do_parachute(const AP_Mission::Mission_Command& cmd);

#endif

#if GRIPPER_ENABLED == ENABLED

  void do_gripper(const AP_Mission::Mission_Command& cmd);

#endif

  bool verify_nav_wp(const AP_Mission::Mission_Command& cmd);

  bool verify_circle(const AP_Mission::Mission_Command& cmd);

  bool verify_spline_wp(const AP_Mission::Mission_Command& cmd);

#if NAV_GUIDED == ENABLED

  bool verify_nav_guided_enable(const AP_Mission::Mission_Command& cmd);

#endif

  bool verify_nav_delay(const AP_Mission::Mission_Command& cmd);


  void auto_spline_start(const Location_Class& destination, bool stopped_at_start, AC_WPNav::spline_segment_end_type seg_end_type, const Location_Class& next_destination);

  void print_flight_mode(AP_HAL::BetterStream *port, uint8_t mode);

  void log_init(void);

  void run_cli(AP_HAL::UARTDriver *port);

  void init_capabilities(void);

  void dataflash_periodic(void);

  void accel_cal_update(void);


public:

  void mavlink_delay_cb();

  void failsafe_check();

  int8_t dump_log(uint8_t argc, const Menu::arg *argv);

  int8_t erase_logs(uint8_t argc, const Menu::arg *argv);

  int8_t select_logs(uint8_t argc, const Menu::arg *argv);

  bool print_log_menu(void);


  int8_t process_logs(uint8_t argc, const Menu::arg *argv);

  int8_t main_menu_help(uint8_t, const Menu::arg*);

  int8_t setup_mode(uint8_t argc, const Menu::arg *argv);

  int8_t setup_factory(uint8_t argc, const Menu::arg *argv);

  int8_t setup_set(uint8_t argc, const Menu::arg *argv);

  int8_t setup_show(uint8_t argc, const Menu::arg *argv);

  int8_t esc_calib(uint8_t argc, const Menu::arg *argv);


  int8_t test_mode(uint8_t argc, const Menu::arg *argv);

  int8_t test_baro(uint8_t argc, const Menu::arg *argv);

  int8_t test_compass(uint8_t argc, const Menu::arg *argv);

  int8_t test_ins(uint8_t argc, const Menu::arg *argv);

  int8_t test_optflow(uint8_t argc, const Menu::arg *argv);

  int8_t test_relay(uint8_t argc, const Menu::arg *argv);

  int8_t test_shell(uint8_t argc, const Menu::arg *argv);

  int8_t test_rangefinder(uint8_t argc, const Menu::arg *argv);


  int8_t reboot_board(uint8_t argc, const Menu::arg *argv);

};


#define MENU_FUNC(func) FUNCTOR_BIND(&copter, &Copter::func, int8_t, uint8_t, const Menu::arg *)


extern const AP_HAL::HAL& hal;

extern Copter copter;


using AP_HAL::mill

avoidance_adsb.h

#pragma once


#include <AP_Avoidance/AP_Avoidance.h>


// Provide Copter-specific implementation of avoidance. While most of

// the logic for doing the actual avoidance is present in

// AP_Avoidance, this class allows Copter to override base

// functionality - for example, not doing anything while landed.

class AP_Avoidance_Copter : public AP_Avoidance {


public:


  AP_Avoidance_Copter(AP_AHRS &ahrs, class AP_ADSB &adsb) :

    AP_Avoidance(ahrs, adsb) { }


private:


  // helper function to set modes and always succeed

  void set_mode_else_try_RTL_else_LAND(control_mode_t mode);


protected:


  // override avoidance handler

  MAV_COLLISION_ACTION handle_avoidance(const AP_Avoidance::Obstacle *obstacle, MAV_COLLISION_ACTION requested_action) override;


  // override recovery handler

  void handle_recovery(uint8_t recovery_action) override;


  // check flight mode is avoid_adsb

  bool check_flightmode(bool allow_mode_change);


  // vertical avoidance handler

  bool handle_avoidance_vertical(const AP_Avoidance::Obstacle *obstacle, bool allow_mode_change);


  // horizontal avoidance handler

  bool handle_avoidance_horizontal(const AP_Avoidance::Obstacle *obstacle, bool allow_mode_change);


  // perpendicular (3 dimensional) avoidance handler

  bool handle_avoidance_perpendicular(const AP_Avoidance::Obstacle *obstacle, bool allow_mode_change);


  // control mode before avoidance began

  control_mode_t prev_control_mode = RTL;

};


Parameters.h

#pragma once


#include <AP_Common/AP_Common.h>


// Global parameter class.

//

class Parameters {

public:

  // The version of the layout as described by the parameter enum.

  //

  // When changing the parameter enum in an incompatible fashion, this

  // value should be incremented by one.

  //

  // The increment will prevent old parameters from being used incorrectly

  // by newer code.

  //

  static const uint16_t    k_format_version = 120;


  // The parameter software_type is set up solely for ground station use

  // and identifies the software type (eg ArduPilotMega versus

  // ArduCopterMega)

  // GCS will interpret values 0-9 as ArduPilotMega. Developers may use

  // values within that range to identify different branches.

  //

  static const uint16_t    k_software_type = 10;     // 0 for APM

                                // trunk


  // Parameter identities.

  //

  // The enumeration defined here is used to ensure that every parameter

  // or parameter group has a unique ID number.

This number is used by

  // AP_Param to store and locate parameters in EEPROM.

  //

  // Note that entries without a number are assigned the next number after

  // the entry preceding them.

When adding new entries, ensure that they

  // don't overlap.

  //

  // Try to group related variables together, and assign them a set

  // range in the enumeration.

Place these groups in numerical order

  // at the end of the enumeration.

  //

  // WARNING: Care should be taken when editing this enumeration as the

  //

AP_Param load/save code depends on the values here to identify

  //

variables saved in EEPROM.

  //

  //

  enum {

    // Layout version number, always key zero.

    //

    k_param_format_version = 0,

    k_param_software_type,

    k_param_ins_old,            // *** Deprecated, remove with next eeprom number change

    k_param_ins,              // libraries/AP_InertialSensor variables

    k_param_NavEKF2_old, // deprecated - remove

    k_param_NavEKF2,

    k_param_g2, // 2nd block of parameters

    k_param_NavEKF3,


    // simulation

    k_param_sitl = 10,


    // barometer object (needed for SITL)

    k_param_barometer,


    // scheduler object (for debugging)

    k_param_scheduler,


    // relay object

    k_param_relay,


    // (old) EPM object

    k_param_epm_unused,


    // BoardConfig object

    k_param_BoardConfig,


    // GPS object

    k_param_gps,


    // Parachute object

    k_param_parachute,


    // Landing gear object

    k_param_landinggear,  // 18


    // Input Management object

    k_param_input_manager, // 19


    // Misc

    //

    k_param_log_bitmask_old = 20,     // Deprecated

    k_param_log_last_filenumber,      // *** Deprecated - remove

                        // with next eeprom number

                        // change

    k_param_toy_yaw_rate,         // deprecated - remove

    k_param_crosstrack_min_distance,

// deprecated - remove with next eeprom number change

    k_param_rssi_pin,         // unused, replaced by rssi_ library parameters

    k_param_throttle_accel_enabled,  // deprecated - remove

    k_param_wp_yaw_behavior,

    k_param_acro_trainer,

    k_param_pilot_velocity_z_max,

    k_param_circle_rate,        // deprecated - remove

    k_param_rangefinder_gain,

    k_param_ch8_option,

    k_param_arming_check_old,   // deprecated - remove

    k_param_sprayer,

    k_param_angle_max,

    k_param_gps_hdop_good,

    k_param_battery,

    k_param_fs_batt_mah,

    k_param_angle_rate_max,    // remove

    k_param_rssi_range,      // unused, replaced by rssi_ library parameters

    k_param_rc_feel_rp,

    k_param_NavEKF,        // deprecated - remove

    k_param_mission,        // mission library

    k_param_rc_13_old,

    k_param_rc_14_old,

    k_param_rally,

    k_param_poshold_brake_rate,

    k_param_poshold_brake_angle_max,

    k_param_pilot_accel_z,

    k_param_serial0_baud,     // deprecated - remove

    k_param_serial1_baud,     // deprecated - remove

    k_param_serial2_baud,     // deprecated - remove

    k_param_land_repositioning,

    k_param_rangefinder, // rangefinder object

    k_param_fs_ekf_thresh,

    k_param_terrain,

    k_param_acro_rp_expo,

    k_param_throttle_deadzone,

    k_param_optflow,

    k_param_dcmcheck_thresh,    // deprecated - remove

    k_param_log_bitmask,

    k_param_cli_enabled,

    k_param_throttle_filt,

    k_param_throttle_behavior,

    k_param_pilot_takeoff_alt, // 64


    // 65: AP_Limits Library

    k_param_limits = 65,      // deprecated - remove

    k_param_gpslock_limit,     // deprecated - remove

    k_param_geofence_limit,    // deprecated - remove

    k_param_altitude_limit,    // deprecated - remove

    k_param_fence,

    k_param_gps_glitch,      // deprecated

    k_param_baro_glitch,      // 71 - deprecated


    // AP_ADSB Library

    k_param_adsb,         // 72

    k_param_notify,        // 73


    // 74: precision landing object

    k_param_precland = 74,


    //

    // 75: Singlecopter, CoaxCopter

    //

    k_param_single_servo_1 = 75,  // remove

    k_param_single_servo_2,    // remove

    k_param_single_servo_3,    // remove

    k_param_single_servo_4,    // 78 - remove


    //

    // 80: Heli

    //

    k_param_heli_servo_1 = 80, // remove

    k_param_heli_servo_2,   // remove

    k_param_heli_servo_3,   // remove

    k_param_heli_servo_4,   // remove

    k_param_heli_pitch_ff,   // remove

    k_param_heli_roll_ff,   // remove

    k_param_heli_yaw_ff,    // remove

    k_param_heli_stab_col_min, // remove

    k_param_heli_stab_col_max, // remove

    k_param_heli_servo_rsc,  // 89 = full! - remove


    //

    // 90: misc2

    //

    k_param_motors = 90,

    k_param_disarm_delay,

    k_param_fs_crash_check,

    k_param_throw_motor_start,

    k_param_terrain_follow,  // 94

    k_param_avoid,

    k_param_avoidance_adsb,


    // 97: RSSI

    k_param_rssi = 97,

         

    //

    // 100: Inertial Nav

    //

    k_param_inertial_nav = 100, // deprecated

    k_param_wp_nav,

    k_param_attitude_control,

    k_param_pos_control,

    k_param_circle_nav,  // 104


    // 110: Telemetry control

    //

    k_param_gcs0 = 110,

    k_param_gcs1,

    k_param_sysid_this_mav,

    k_param_sysid_my_gcs,

    k_param_serial1_baud_old, // deprecated

    k_param_telem_delay,

    k_param_gcs2,

    k_param_serial2_baud_old, // deprecated

    k_param_serial2_protocol, // deprecated

    k_param_serial_manager,

    k_param_ch9_option,

    k_param_ch10_option,

    k_param_ch11_option,

    k_param_ch12_option,

    k_param_takeoff_trigger_dz,

    k_param_gcs3,

    k_param_gcs_pid_mask,  // 126


    //

    // 135 : reserved for Solo until features merged with master

    //

    k_param_rtl_speed_cms = 135,

    k_param_fs_batt_curr_rtl,

    k_param_rtl_cone_slope, // 137


    //

    // 140: Sensor parameters

    //

    k_param_imu = 140, // deprecated - can be deleted

    k_param_battery_monitoring = 141, // deprecated - can be deleted

    k_param_volt_div_ratio, // deprecated - can be deleted

    k_param_curr_amp_per_volt, // deprecated - can be deleted

    k_param_input_voltage, // deprecated - can be deleted

    k_param_pack_capacity, // deprecated - can be deleted

    k_param_compass_enabled,

    k_param_compass,

    k_param_rangefinder_enabled_old, // deprecated

    k_param_frame_type,

    k_param_optflow_enabled,  // deprecated

    k_param_fs_batt_voltage,

    k_param_ch7_option,

    k_param_auto_slew_rate,  // deprecated - can be deleted

    k_param_rangefinder_type_old,  // deprecated

    k_param_super_simple = 155,

    k_param_axis_enabled = 157, // deprecated - remove with next eeprom number change

    k_param_copter_leds_mode, // deprecated - remove with next eeprom number change

    k_param_ahrs, // AHRS group // 159


    //

    // 160: Navigation parameters

    //

    k_param_rtl_altitude = 160,

    k_param_crosstrack_gain,

// deprecated - remove with next eeprom number change

    k_param_rtl_loiter_time,

    k_param_rtl_alt_final,

    k_param_tilt_comp,

//164

deprecated - remove with next eeprom number change



    //

    // Camera and mount parameters

    //

    k_param_camera = 165,

    k_param_camera_mount,

    k_param_camera_mount2,   // deprecated


    //

    // Batery monitoring parameters

    //

    k_param_battery_volt_pin = 168, // deprecated - can be deleted

    k_param_battery_curr_pin, // 169 deprecated - can be deleted


    //

    // 170: Radio settings

    //

    k_param_rc_1_old = 170,

    k_param_rc_2_old,

    k_param_rc_3_old,

    k_param_rc_4_old,

    k_param_rc_5_old,

    k_param_rc_6_old,

    k_param_rc_7_old,

    k_param_rc_8_old,

    k_param_rc_10_old,

    k_param_rc_11_old,

    k_param_throttle_min,     // remove

    k_param_throttle_max,     // remove

    k_param_failsafe_throttle,

    k_param_throttle_fs_action,  // remove

    k_param_failsafe_throttle_value,

    k_param_throttle_trim,     // remove

    k_param_esc_calibrate,

    k_param_radio_tuning,

    k_param_radio_tuning_high,

    k_param_radio_tuning_low,

    k_param_rc_speed = 192,

    k_param_failsafe_battery_enabled,

    k_param_throttle_mid,     // remove

    k_param_failsafe_gps_enabled, // remove

    k_param_rc_9_old,

    k_param_rc_12_old,

    k_param_failsafe_gcs,

    k_param_rcmap, // 199


    //

    // 200: flight modes

    //

    k_param_flight_mode1 = 200,

    k_param_flight_mode2,

    k_param_flight_mode3,

    k_param_flight_mode4,

    k_param_flight_mode5,

    k_param_flight_mode6,

    k_param_simple_modes,


    //

    // 210: Waypoint data

    //

    k_param_waypoint_mode = 210, // remove

    k_param_command_total,   // remove

    k_param_command_index,   // remove

    k_param_command_nav_index, // remove

    k_param_waypoint_radius,  // remove

    k_param_circle_radius,   // remove

    k_param_waypoint_speed_max, // remove

    k_param_land_speed,

    k_param_auto_velocity_z_min, // remove

    k_param_auto_velocity_z_max, // remove - 219

    k_param_land_speed_high,


    //

    // 220: PI/D Controllers

    //

    k_param_acro_rp_p = 221,

    k_param_axis_lock_p,  // remove

    k_param_pid_rate_roll,   // remove

    k_param_pid_rate_pitch,  // remove

    k_param_pid_rate_yaw,   // remove

    k_param_p_stabilize_roll, // remove

    k_param_p_stabilize_pitch, // remove

    k_param_p_stabilize_yaw,  // remove

    k_param_p_pos_xy,

    k_param_p_loiter_lon,   // remove

    k_param_pid_loiter_rate_lat,  // remove

    k_param_pid_loiter_rate_lon,  // remove

    k_param_pid_nav_lat,    // remove

    k_param_pid_nav_lon,    // remove

    k_param_p_alt_hold,

    k_param_p_vel_z,

    k_param_pid_optflow_roll,   // remove

    k_param_pid_optflow_pitch,   // remove

    k_param_acro_balance_roll_old, // remove

    k_param_acro_balance_pitch_old, // remove

    k_param_pid_accel_z,

    k_param_acro_balance_roll,

    k_param_acro_balance_pitch,

    k_param_acro_yaw_p,

    k_param_autotune_axis_bitmask,

    k_param_autotune_aggressiveness,

    k_param_pi_vel_xy,

    k_param_fs_ekf_action,

    k_param_rtl_climb_min,

    k_param_rpm_sensor,

    k_param_autotune_min_d, // 251

    k_param_arming, // 252 - AP_Arming

    k_param_DataFlash = 253, // 253 - Logging Group


    // 254,255: reserved


    // the k_param_* space is 9-bits in size

    // 511: reserved

  };


  AP_Int16    format_version;

  AP_Int8    software_type;


  // Telemetry control

  //

  AP_Int16    sysid_this_mav;

  AP_Int16    sysid_my_gcs;

  AP_Int8    telem_delay;

#if CLI_ENABLED == ENABLED

  AP_Int8    cli_enabled;

#endif


  AP_Float    throttle_filt;

  AP_Int16    throttle_behavior;

  AP_Int16    takeoff_trigger_dz;

  AP_Float    pilot_takeoff_alt;


  AP_Int16    rtl_altitude;

  AP_Int16    rtl_speed_cms;

  AP_Float    rtl_cone_slope;

  AP_Float    rangefinder_gain;


  AP_Int8    failsafe_battery_enabled; // battery failsafe enabled

  AP_Float    fs_batt_voltage;      // battery voltage below which failsafe will be triggered

  AP_Float    fs_batt_mah;        // battery capacity (in mah) below which failsafe will be triggered


  AP_Int8    failsafe_gcs;       // ground station failsafe behavior

  AP_Int16    gps_hdop_good;       // GPS Hdop value at or below this value represent a good position


  AP_Int8    compass_enabled;

  AP_Int8    super_simple;

  AP_Int16    rtl_alt_final;

  AP_Int16    rtl_climb_min;       // rtl minimum climb in cm


  AP_Int8    wp_yaw_behavior;      // controls how the autopilot controls yaw during missions

  AP_Int8    rc_feel_rp;        // controls vehicle response to user input with 0 being extremely soft and 100 begin extremely crisp


  AP_Int16    poshold_brake_rate;    // PosHold flight mode's rotation rate during braking in deg/sec

  AP_Int16    poshold_brake_angle_max;  // PosHold flight mode's max lean angle during braking in centi-degrees

   

  // Waypoints

  //

  AP_Int32    rtl_loiter_time;

  AP_Int16    land_speed;

  AP_Int16    land_speed_high;

  AP_Int16    pilot_velocity_z_max;    // maximum vertical velocity the pilot may request

  AP_Int16    pilot_accel_z;       // vertical acceleration the pilot may request


  // Throttle

  //

  AP_Int8    failsafe_throttle;

  AP_Int16    failsafe_throttle_value;

  AP_Int16    throttle_deadzone;


  // Flight modes

  //

  AP_Int8    flight_mode1;

  AP_Int8    flight_mode2;

  AP_Int8    flight_mode3;

  AP_Int8    flight_mode4;

  AP_Int8    flight_mode5;

  AP_Int8    flight_mode6;

  AP_Int8    simple_modes;


  // Misc

  //

  AP_Int32    log_bitmask;

  AP_Int8    esc_calibrate;

  AP_Int8    radio_tuning;

  AP_Int16    radio_tuning_high;

  AP_Int16    radio_tuning_low;

  AP_Int8    frame_type;

  AP_Int8    ch7_option;

  AP_Int8    ch8_option;

  AP_Int8    ch9_option;

  AP_Int8    ch10_option;

  AP_Int8    ch11_option;

  AP_Int8    ch12_option;

  AP_Int8    disarm_delay;


  AP_Int8    land_repositioning;

  AP_Int8    fs_ekf_action;

  AP_Int8    fs_crash_check;

  AP_Float    fs_ekf_thresh;

  AP_Int16    gcs_pid_mask;


  AP_Int8    throw_motor_start;

  AP_Int8    terrain_follow;


  AP_Int16        rc_speed; // speed of fast RC Channels in Hz


  // Acro parameters

  AP_Float        acro_rp_p;

  AP_Float        acro_yaw_p;

  AP_Float        acro_balance_roll;

  AP_Float        acro_balance_pitch;

  AP_Int8        acro_trainer;

  AP_Float        acro_rp_expo;


  // PI/D controllers

  AC_PI_2D        pi_vel_xy;


  AC_P          p_vel_z;

  AC_PID         pid_accel_z;


  AC_P          p_pos_xy;

  AC_P          p_alt_hold;


  // Autotune

  AP_Int8        autotune_axis_bitmask;

  AP_Float        autotune_aggressiveness;

  AP_Float        autotune_min_d;


  // Note: keep initializers here in the same order as they are declared

  // above.

  Parameters() :

    // PID controller

  initial P

   initial I    initial D   initial imax    initial filt hz  pid rate

    //---------------------------------------------------------------------------------------------------------------------------------

    pi_vel_xy       (VEL_XY_P,    VEL_XY_I,            VEL_XY_IMAX,    VEL_XY_FILT_HZ,  WPNAV_LOITER_UPDATE_TIME),


    p_vel_z        (VEL_Z_P),

    pid_accel_z      (ACCEL_Z_P,   ACCEL_Z_I,    ACCEL_Z_D,   ACCEL_Z_IMAX,   ACCEL_Z_FILT_HZ,  MAIN_LOOP_SECONDS),


    // P controller

    initial P

    //----------------------------------------------------------------------

    p_pos_xy        (POS_XY_P),


    p_alt_hold       (ALT_HOLD_P)

  {

  }

};


/*

 2nd block of parameters, to avoid going past 256 top level keys

 */

class ParametersG2 {

public:

  ParametersG2(void);


  // var_info for holding Parameter information

  static const struct AP_Param::GroupInfo var_info[];


  // altitude at which nav control can start in takeoff

  AP_Float wp_navalt_min;


  // button checking

  AP_Button button;


  // vehicle statistics

  AP_Stats stats;


#if GRIPPER_ENABLED

  AP_Gripper gripper;

#endif


  // Throw mode parameters

  AP_Int8 throw_nextmode;

  AP_Int8 throw_type;


  // ground effect compensation enable/disable

  AP_Int8 gndeffect_comp_enabled;


  // beacon (non-GPS positioning) library

  AP_Beacon beacon;


#if PROXIMITY_ENABLED == ENABLED

  // proximity (aka object avoidance) library

  AP_Proximity proximity;

#endif


  // whether to enforce acceptance of packets only from sysid_my_gcs

  AP_Int8 sysid_enforce;

   

#if ADVANCED_FAILSAFE == ENABLED

  // advanced failsafe library

  AP_AdvancedFailsafe_Copter afs;

#endif


  // developer options

  AP_Int32 dev_options;


  // acro exponent parameters

  AP_Float acro_y_expo;

  AP_Float acro_thr_mid;


  // frame class

  AP_Int8 frame_class;


  // RC input channels

  RC_Channels rc_channels;

   

  // control over servo output ranges

  SRV_Channels servo_channels;

};


extern const AP_Param::Info    var_info[];


afs_copter.h

/*

  This program is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.


  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  GNU General Public License for more details.


  You should have received a copy of the GNU General Public License

  along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#pragma once


/*

 advanced failsafe support for copter

 */


#if ADVANCED_FAILSAFE == ENABLED

#include <AP_AdvancedFailsafe/AP_AdvancedFailsafe.h>


/*

 a plane specific AP_AdvancedFailsafe class

 */

class AP_AdvancedFailsafe_Copter : public AP_AdvancedFailsafe

{

public:

  AP_AdvancedFailsafe_Copter(AP_Mission &_mission, AP_Baro &_baro, const AP_GPS &_gps, const RCMapper &_rcmap);


  // called to set all outputs to termination state

  void terminate_vehicle(void);

   

protected:

  // setup failsafe values for if FMU firmware stops running

  void setup_IO_failsafe(void);


  // return the AFS mapped control mode

  enum control_mode afs_mode(void);

};


#endif // ADVANCED_FAILSAFE


AP_Arming.h

#pragma once


#include <AP_Arming/AP_Arming.h>


class AP_Arming_Copter : public AP_Arming

{

public:

  AP_Arming_Copter(const AP_AHRS_NavEKF &ahrs_ref, const AP_Baro &baro, Compass &compass,

           const AP_BattMonitor &battery, const AP_InertialNav_NavEKF &inav,

           const AP_InertialSensor &ins) :

    AP_Arming(ahrs_ref, baro, compass, battery),

    _inav(inav),

    _ins(ins),

    _ahrs_navekf(ahrs_ref)

    {

  }


  void update(void);

  bool all_checks_passing(bool arming_from_gcs);

  void pre_arm_rc_checks(bool display_failure);


protected:


  bool pre_arm_checks(bool display_failure) override;

  bool pre_arm_gps_checks(bool display_failure);

  bool pre_arm_ekf_attitude_check();

  bool pre_arm_terrain_check(bool display_failure);

  bool pre_arm_proximity_check(bool display_failure);

  bool arm_checks(bool display_failure, bool arming_from_gcs);


  // NOTE! the following check functions *DO* call into AP_Arming:

  bool ins_checks(bool display_failure) override;

  bool compass_checks(bool display_failure) override;

  bool gps_checks(bool display_failure) override;


  // NOTE! the following check functions *DO NOT* call into AP_Arming!

  bool fence_checks(bool display_failure);

  bool board_voltage_checks(bool display_failure);

  bool parameter_checks(bool display_failure);

  bool motor_checks(bool display_failure);

  bool pilot_throttle_checks(bool display_failure);

  bool barometer_checks(bool display_failure);

  bool rc_calibration_checks(bool display_failure);


  void set_pre_arm_check(bool b);

  void set_pre_arm_rc_check(bool b);


  enum HomeState home_status() const override;


private:


  void gcs_send_text(MAV_SEVERITY severity, const char *str);


  const AP_InertialNav_NavEKF &_inav;

  const AP_InertialSensor &_ins;

  const AP_AHRS_NavEKF &_ahrs_navekf;


};


AP_Rally.h

#pragma once


#include <AP_Rally/AP_Rally.h>

#include <AP_AHRS/AP_AHRS.h>


class AP_Rally_Copter : public AP_Rally

{


public:

  // constructor

  AP_Rally_Copter(AP_AHRS &ahrs) : AP_Rally(ahrs) {};


private:

  bool is_valid(const Location &rally_point) const override;


};

GCS_Mavlink.h

#pragma once


#include <GCS_MAVLink/GCS.h>


// default sensors are present and healthy: gyro, accelerometer, barometer, rate_control, attitude_stabilization, yaw_position, altitude control, x/y position control, motor_control

#define MAVLINK_SENSOR_PRESENT_DEFAULT (MAV_SYS_STATUS_SENSOR_3D_GYRO | MAV_SYS_STATUS_SENSOR_3D_ACCEL | MAV_SYS_STATUS_SENSOR_ABSOLUTE_PRESSURE | MAV_SYS_STATUS_SENSOR_ANGULAR_RATE_CONTROL | MAV_SYS_STATUS_SENSOR_ATTITUDE_STABILIZATION | MAV_SYS_STATUS_SENSOR_YAW_POSITION | MAV_SYS_STATUS_SENSOR_Z_ALTITUDE_CONTROL | MAV_SYS_STATUS_SENSOR_XY_POSITION_CONTROL | MAV_SYS_STATUS_SENSOR_MOTOR_OUTPUTS | MAV_SYS_STATUS_AHRS)


class GCS_MAVLINK_Copter : public GCS_MAVLINK

{


public:


  void data_stream_send(void) override;


protected:


  uint32_t telem_delay() const override;


  bool accept_packet(const mavlink_status_t &status, mavlink_message_t &msg) override;

   

private:


  void handleMessage(mavlink_message_t * msg) override;

  bool handle_guided_request(AP_Mission::Mission_Command &cmd) override;

  void handle_change_alt_request(AP_Mission::Mission_Command &cmd) override;

  bool try_send_message(enum ap_message id) override;


  void packetReceived(const mavlink_status_t &status,

            mavlink_message_t &msg) override;

};


config.h

//

#pragma once


//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

//

// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING

//

// DO NOT EDIT this file to adjust your configuration. Create your own

// APM_Config.h and use APM_Config.h.example as a reference.

//

// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING

///

//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

//

// Default and automatic configuration details.

//

// Notes for maintainers:

//

// - Try to keep this file organised in the same order as APM_Config.h.example

//

#include "defines.h"


///

/// DO NOT EDIT THIS INCLUDE - if you want to make a local change, make that

/// change in your local copy of APM_Config.h.

///

#include "APM_Config.h"



//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

// HARDWARE CONFIGURATION AND CONNECTIONS

//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////


#ifndef CONFIG_HAL_BOARD

#error CONFIG_HAL_BOARD must be defined to build ArduCopter

#endif


//////////////////////////////////////////////////////////////////////////////

// HIL_MODE                OPTIONAL


#ifndef HIL_MODE

 #define HIL_MODE    HIL_MODE_DISABLED

#endif


#define MAGNETOMETER ENABLED


// run at 400Hz on all systems

# define MAIN_LOOP_RATE  400

# define MAIN_LOOP_SECONDS 0.0025f

# define MAIN_LOOP_MICROS 2500


#ifndef ARMING_DELAY_SEC

  # define ARMING_DELAY_SEC 2.0f

#endif


//////////////////////////////////////////////////////////////////////////////

// FRAME_CONFIG

//

#ifndef FRAME_CONFIG

 # define FRAME_CONFIG MULTICOPTER_FRAME

#endif


/////////////////////////////////////////////////////////////////////////////////

// TradHeli defaults

#if FRAME_CONFIG == HELI_FRAME

 # define RC_FAST_SPEED            125

 # define WP_YAW_BEHAVIOR_DEFAULT       WP_YAW_BEHAVIOR_LOOK_AHEAD

 # define THR_MIN_DEFAULT           0

 # define AUTOTUNE_ENABLED          DISABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// PWM control

// default RC speed in Hz

#ifndef RC_FAST_SPEED

  # define RC_FAST_SPEED 490

#endif


//////////////////////////////////////////////////////////////////////////////

// Rangefinder

//


#ifndef RANGEFINDER_ENABLED

 # define RANGEFINDER_ENABLED ENABLED

#endif


#ifndef RANGEFINDER_HEALTH_MAX

 # define RANGEFINDER_HEALTH_MAX 3     // number of good reads that indicates a healthy rangefinder

#endif


#ifndef RANGEFINDER_GAIN_DEFAULT

 # define RANGEFINDER_GAIN_DEFAULT 0.8f  // gain for controlling how quickly rangefinder range adjusts target altitude (lower means slower reaction)

#endif


#ifndef THR_SURFACE_TRACKING_VELZ_MAX

 # define THR_SURFACE_TRACKING_VELZ_MAX 150 // max vertical speed change while surface tracking with rangefinder

#endif


#ifndef RANGEFINDER_TIMEOUT_MS

 # define RANGEFINDER_TIMEOUT_MS 1000   // desired rangefinder alt will reset to current rangefinder alt after this many milliseconds without a good rangefinder alt

#endif


#ifndef RANGEFINDER_WPNAV_FILT_HZ

 # define RANGEFINDER_WPNAV_FILT_HZ 0.25f // filter frequency for rangefinder altitude provided to waypoint navigation class

#endif


#ifndef RANGEFINDER_TILT_CORRECTION    // by disable tilt correction for use of range finder data by EKF

 # define RANGEFINDER_TILT_CORRECTION ENABLED

#endif


#ifndef RANGEFINDER_GLITCH_ALT_CM

 # define RANGEFINDER_GLITCH_ALT_CM 200   // amount of rangefinder change to be considered a glitch

#endif


#ifndef RANGEFINDER_GLITCH_NUM_SAMPLES

 # define RANGEFINDER_GLITCH_NUM_SAMPLES 3 // number of rangefinder glitches in a row to take new reading

#endif


//////////////////////////////////////////////////////////////////////////////

// Proximity sensor

//

#ifndef PROXIMITY_ENABLED

 # define PROXIMITY_ENABLED ENABLED

#endif


#ifndef MAV_SYSTEM_ID

 # define MAV_SYSTEM_ID     1

#endif



//////////////////////////////////////////////////////////////////////////////

// Battery monitoring

//

#ifndef FS_BATT_VOLTAGE_DEFAULT

 # define FS_BATT_VOLTAGE_DEFAULT   10.5f   // default battery voltage below which failsafe will be triggered

#endif


#ifndef FS_BATT_MAH_DEFAULT

 # define FS_BATT_MAH_DEFAULT      0    // default battery capacity (in mah) below which failsafe will be triggered

#endif


#ifndef BOARD_VOLTAGE_MIN

 # define BOARD_VOLTAGE_MIN      4.3f    // min board voltage in volts for pre-arm checks

#endif


#ifndef BOARD_VOLTAGE_MAX

 # define BOARD_VOLTAGE_MAX      5.8f    // max board voltage in volts for pre-arm checks

#endif


// prearm GPS hdop check

#ifndef GPS_HDOP_GOOD_DEFAULT

 # define GPS_HDOP_GOOD_DEFAULT    140  // minimum hdop that represents a good position. used during pre-arm checks if fence is enabled

#endif


// GCS failsafe

#ifndef FS_GCS

 # define FS_GCS            DISABLED

#endif

#ifndef FS_GCS_TIMEOUT_MS

 # define FS_GCS_TIMEOUT_MS      5000  // gcs failsafe triggers after 5 seconds with no GCS heartbeat

#endif


// Radio failsafe while using RC_override

#ifndef FS_RADIO_RC_OVERRIDE_TIMEOUT_MS

 # define FS_RADIO_RC_OVERRIDE_TIMEOUT_MS 1000  // RC Radio failsafe triggers after 1 second while using RC_override from ground station

#endif


// Radio failsafe

#ifndef FS_RADIO_TIMEOUT_MS

 #define FS_RADIO_TIMEOUT_MS      500  // RC Radio Failsafe triggers after 500 miliseconds with No RC Input

#endif


// missing terrain data failsafe

#ifndef FS_TERRAIN_TIMEOUT_MS

 #define FS_TERRAIN_TIMEOUT_MS     5000  // 5 seconds of missing terrain data will trigger failsafe (RTL)

#endif


#ifndef PREARM_DISPLAY_PERIOD

# define PREARM_DISPLAY_PERIOD 30

#endif


// pre-arm baro vs inertial nav max alt disparity

#ifndef PREARM_MAX_ALT_DISPARITY_CM

 # define PREARM_MAX_ALT_DISPARITY_CM   100  // barometer and inertial nav altitude must be within this many centimeters

#endif


//////////////////////////////////////////////////////////////////////////////

// EKF Failsafe

#ifndef FS_EKF_ACTION_DEFAULT

 # define FS_EKF_ACTION_DEFAULT    FS_EKF_ACTION_LAND // EKF failsafe triggers land by default

#endif

#ifndef FS_EKF_THRESHOLD_DEFAULT

 # define FS_EKF_THRESHOLD_DEFAULT   0.8f  // EKF failsafe's default compass and velocity variance threshold above which the EKF failsafe will be triggered

#endif


#ifndef EKF_ORIGIN_MAX_DIST_M

 # define EKF_ORIGIN_MAX_DIST_M    50000 // EKF origin and waypoints (including home) must be within 50km

#endif


//////////////////////////////////////////////////////////////////////////////

// MAGNETOMETER

#ifndef MAGNETOMETER

 # define MAGNETOMETER         ENABLED

#endif


#ifndef COMPASS_CAL_STICK_GESTURE_TIME

 #define COMPASS_CAL_STICK_GESTURE_TIME 2.0f // 2 seconds

#endif

#ifndef COMPASS_CAL_STICK_DELAY

 #define COMPASS_CAL_STICK_DELAY 5.0f

#endif


//////////////////////////////////////////////////////////////////////////////

// OPTICAL_FLOW

#ifndef OPTFLOW

 # define OPTFLOW   ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// Auto Tuning

#ifndef AUTOTUNE_ENABLED

 # define AUTOTUNE_ENABLED ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// Crop Sprayer

#ifndef SPRAYER

 # define SPRAYER ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// Precision Landing with companion computer or IRLock sensor

#ifndef PRECISION_LANDING

 # define PRECISION_LANDING ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

//

gripper

#ifndef GRIPPER_ENABLED

 # define GRIPPER_ENABLED ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// Parachute release

#ifndef PARACHUTE

 # define PARACHUTE ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// ADSB support

#ifndef ADSB_ENABLED

# define ADSB_ENABLED ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// Nav-Guided - allows external nav computer to control vehicle

#ifndef NAV_GUIDED

 # define NAV_GUIDED  ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// RADIO CONFIGURATION

//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////



//////////////////////////////////////////////////////////////////////////////

// FLIGHT_MODE

//


#ifndef FLIGHT_MODE_1

 # define FLIGHT_MODE_1         STABILIZE

#endif

#ifndef FLIGHT_MODE_2

 # define FLIGHT_MODE_2         STABILIZE

#endif

#ifndef FLIGHT_MODE_3

 # define FLIGHT_MODE_3         STABILIZE

#endif

#ifndef FLIGHT_MODE_4

 # define FLIGHT_MODE_4         STABILIZE

#endif

#ifndef FLIGHT_MODE_5

 # define FLIGHT_MODE_5         STABILIZE

#endif

#ifndef FLIGHT_MODE_6

 # define FLIGHT_MODE_6         STABILIZE

#endif



//////////////////////////////////////////////////////////////////////////////

// Throttle Failsafe

//

#ifndef FS_THR_VALUE_DEFAULT

 # define FS_THR_VALUE_DEFAULT      975

#endif


//////////////////////////////////////////////////////////////////////////////

// Takeoff

//

#ifndef PILOT_TKOFF_ALT_DEFAULT

 # define PILOT_TKOFF_ALT_DEFAULT     0  // default final alt above home for pilot initiated takeoff

#endif



//////////////////////////////////////////////////////////////////////////////

// Landing

//

#ifndef LAND_SPEED

 # define LAND_SPEED  50     // the descent speed for the final stage of landing in cm/s

#endif

#ifndef LAND_START_ALT

 # define LAND_START_ALT 1000    // altitude in cm where land controller switches to slow rate of descent

#endif

#ifndef LAND_REPOSITION_DEFAULT

 # define LAND_REPOSITION_DEFAULT 1 // by default the pilot can override roll/pitch during landing

#endif

#ifndef LAND_WITH_DELAY_MS

 # define LAND_WITH_DELAY_MS    4000  // default delay (in milliseconds) when a land-with-delay is triggered during a failsafe event

#endif

#ifndef LAND_CANCEL_TRIGGER_THR

 # define LAND_CANCEL_TRIGGER_THR 700  // land is cancelled by input throttle above 700

#endif

#ifndef LAND_RANGEFINDER_MIN_ALT_CM

#define LAND_RANGEFINDER_MIN_ALT_CM 200

#endif


//////////////////////////////////////////////////////////////////////////////

// Landing Detector

//

#ifndef LAND_DETECTOR_TRIGGER_SEC

 # define LAND_DETECTOR_TRIGGER_SEC    1.0f  // number of seconds to detect a landing

#endif

#ifndef LAND_DETECTOR_MAYBE_TRIGGER_SEC

 # define LAND_DETECTOR_MAYBE_TRIGGER_SEC 0.2f  // number of seconds that means we might be landed (used to reset horizontal position targets to prevent tipping over)

#endif

#ifndef LAND_DETECTOR_ACCEL_LPF_CUTOFF

# define LAND_DETECTOR_ACCEL_LPF_CUTOFF  1.0f  // frequency cutoff of land detector accelerometer filter

#endif

#ifndef LAND_DETECTOR_ACCEL_MAX

# define LAND_DETECTOR_ACCEL_MAX      1.0f  // vehicle acceleration must be under 1m/s/s

#endif


//////////////////////////////////////////////////////////////////////////////

// CAMERA TRIGGER AND CONTROL

//

#ifndef CAMERA

 # define CAMERA    ENABLED

#endif


//////////////////////////////////////////////////////////////////////////////

// MOUNT (ANTENNA OR CAMERA)

//

#ifndef MOUNT

 # define MOUNT    ENABLED

#endif



//////////////////////////////////////////////////////////////////////////////

// Flight mode definitions

//


// Acro Mode

#ifndef ACRO_RP_P

 # define ACRO_RP_P        4.5f

#endif


#ifndef ACRO_YAW_P

 # define ACRO_YAW_P        4.5f

#endif


#ifndef ACRO_LEVEL_MAX_ANGLE

 # define ACRO_LEVEL_MAX_ANGLE   3000

#endif


#ifndef ACRO_BALANCE_ROLL

 #define ACRO_BALANCE_ROLL     1.0f

#endif


#ifndef ACRO_BALANCE_PITCH

 #define ACRO_BALANCE_PITCH    1.0f

#endif


#ifndef ACRO_RP_EXPO_DEFAULT

 #define ACRO_RP_EXPO_DEFAULT   0.3f

#endif


#ifndef ACRO_Y_EXPO_DEFAULT

 #define ACRO_Y_EXPO_DEFAULT    0.0f

#endif


#ifndef ACRO_THR_MID_DEFAULT

 #define ACRO_THR_MID_DEFAULT   0.0f

#endif


// RTL Mode

#ifndef RTL_ALT_FINAL

 # define RTL_ALT_FINAL      0   // the altitude the vehicle will move to as the final stage of Returning to Launch. Set to zero to land.

#endif


#ifndef RTL_ALT

 # define RTL_ALT

  1500  // default alt to return to home in cm, 0 = Maintain current altitude

#endif


#ifndef RTL_ALT_MIN

 # define RTL_ALT_MIN       200  // min height above ground for RTL (i.e 2m)

#endif


#ifndef RTL_CLIMB_MIN_DEFAULT

 # define RTL_CLIMB_MIN_DEFAULT  0   // vehicle will always climb this many cm as first stage of RTL

#endif


#ifndef RTL_ABS_MIN_CLIMB

 # define RTL_ABS_MIN_CLIMB    250  // absolute minimum initial climb

#endif


#ifndef RTL_CONE_SLOPE_DEFAULT

 # define RTL_CONE_SLOPE_DEFAULT  3.0f  // slope of RTL cone (height / distance). 0 = No cone

#endif


#ifndef RTL_MIN_CONE_SLOPE

 # define RTL_MIN_CONE_SLOPE    0.5f  // minimum slope of cone

#endif


#ifndef RTL_LOITER_TIME

 # define RTL_LOITER_TIME     5000  // Time (in milliseconds) to loiter above home before beginning final descent

#endif


// AUTO Mode

#ifndef WP_YAW_BEHAVIOR_DEFAULT

 # define WP_YAW_BEHAVIOR_DEFAULT WP_YAW_BEHAVIOR_LOOK_AT_NEXT_WP_EXCEPT_RTL

#endif


#ifndef AUTO_YAW_SLEW_RATE

 # define AUTO_YAW_SLEW_RATE  60       // degrees/sec

#endif


#ifndef YAW_LOOK_AHEAD_MIN_SPEED

 # define YAW_LOOK_AHEAD_MIN_SPEED 100      // minimum ground speed in cm/s required before copter is aimed at ground course

#endif


// Super Simple mode

#ifndef SUPER_SIMPLE_RADIUS

 # define SUPER_SIMPLE_RADIUS   1000

#endif


//////////////////////////////////////////////////////////////////////////////

// Stabilize Rate Control

//

#ifndef ROLL_PITCH_YAW_INPUT_MAX

 # define ROLL_PITCH_YAW_INPUT_MAX   4500    // roll, pitch and yaw input range

#endif

#ifndef DEFAULT_ANGLE_MAX

 # define DEFAULT_ANGLE_MAX    4500      // ANGLE_MAX parameters default value

#endif

#ifndef ANGLE_RATE_MAX

 # define ANGLE_RATE_MAX      18000     // default maximum rotation rate in roll/pitch axis requested by angle controller used in stabilize, loiter, rtl, auto flight modes

#endif


//////////////////////////////////////////////////////////////////////////////

// Loiter position control gains

//

#ifndef POS_XY_P

 # define POS_XY_P      

1.0f

#endif


//////////////////////////////////////////////////////////////////////////////

// Stop mode defaults

//

#ifndef BRAKE_MODE_SPEED_Z

 # define BRAKE_MODE_SPEED_Z  250 // z-axis speed in cm/s in Brake Mode

#endif

#ifndef BRAKE_MODE_DECEL_RATE

 # define BRAKE_MODE_DECEL_RATE 750 // acceleration rate in cm/s/s in Brake Mode

#endif


//////////////////////////////////////////////////////////////////////////////

// Velocity (horizontal) gains

//

#ifndef VEL_XY_P

 # define VEL_XY_P       1.0f

#endif

#ifndef VEL_XY_I

 # define VEL_XY_I       0.5f

#endif

#ifndef VEL_XY_IMAX

 # define VEL_XY_IMAX     1000

#endif

#ifndef VEL_XY_FILT_HZ

 # define VEL_XY_FILT_HZ    5.0f

#endif


//////////////////////////////////////////////////////////////////////////////

// PosHold parameter defaults

//

#ifndef POSHOLD_ENABLED

 # define POSHOLD_ENABLED       ENABLED // PosHold flight mode enabled by default

#endif

#ifndef POSHOLD_BRAKE_RATE_DEFAULT

 # define POSHOLD_BRAKE_RATE_DEFAULT  8   // default POSHOLD_BRAKE_RATE param value. Rotation rate during braking in deg/sec

#endif

#ifndef POSHOLD_BRAKE_ANGLE_DEFAULT

 # define POSHOLD_BRAKE_ANGLE_DEFAULT 3000  // default POSHOLD_BRAKE_ANGLE param value. Max lean angle during braking in centi-degrees

#endif


//////////////////////////////////////////////////////////////////////////////

// Throttle control gains

//


#ifndef THR_DZ_DEFAULT

# define THR_DZ_DEFAULT    100      // the deadzone above and below mid throttle while in althold or loiter

#endif


#ifndef ALT_HOLD_P

 # define ALT_HOLD_P      1.0f

#endif


// Velocity (vertical) control gains

#ifndef VEL_Z_P

 # define VEL_Z_P   5.0f

#endif


// Accel (vertical) control gains

#ifndef ACCEL_Z_P

 # define ACCEL_Z_P  0.50f

#endif

#ifndef ACCEL_Z_I

 # define ACCEL_Z_I  1.00f

#endif

#ifndef ACCEL_Z_D

 # define ACCEL_Z_D  0.0f

#endif

#ifndef ACCEL_Z_IMAX

 # define ACCEL_Z_IMAX 800

#endif

#ifndef ACCEL_Z_FILT_HZ

 # define ACCEL_Z_FILT_HZ 20.0f

#endif


// default maximum vertical velocity and acceleration the pilot may request

#ifndef PILOT_VELZ_MAX

 # define PILOT_VELZ_MAX  250  // maximum vertical velocity in cm/s

#endif

#ifndef PILOT_ACCEL_Z_DEFAULT

 # define PILOT_ACCEL_Z_DEFAULT 250 // vertical acceleration in cm/s/s while altitude is under pilot control

#endif


// max distance in cm above or below current location that will be used for the alt target when transitioning to alt-hold mode

#ifndef ALT_HOLD_INIT_MAX_OVERSHOOT

 # define ALT_HOLD_INIT_MAX_OVERSHOOT 200

#endif

// the acceleration used to define the distance-velocity curve

#ifndef ALT_HOLD_ACCEL_MAX

 # define ALT_HOLD_ACCEL_MAX 250  // if you change this you must also update the duplicate declaration in AC_WPNav.h

#endif


#ifndef AUTO_DISARMING_DELAY

# define AUTO_DISARMING_DELAY 10

#endif


//////////////////////////////////////////////////////////////////////////////

// Throw mode configuration

//

#ifndef THROW_HIGH_SPEED

# define THROW_HIGH_SPEED   500.0f // vehicle much reach this total 3D speed in cm/s (or be free falling)

#endif

#ifndef THROW_VERTICAL_SPEED

# define THROW_VERTICAL_SPEED 50.0f // motors start when vehicle reaches this total 3D speed in cm/s

#endif


//////////////////////////////////////////////////////////////////////////////

// Dataflash logging control

//

#ifndef LOGGING_ENABLED

 # define LOGGING_ENABLED        ENABLED

#endif


// Default logging bitmask

#ifndef DEFAULT_LOG_BITMASK

 # define DEFAULT_LOG_BITMASK \

  MASK_LOG_ATTITUDE_MED | \

  MASK_LOG_GPS | \

  MASK_LOG_PM | \

  MASK_LOG_CTUN | \

  MASK_LOG_NTUN | \

  MASK_LOG_RCIN | \

  MASK_LOG_IMU | \

  MASK_LOG_CMD | \

  MASK_LOG_CURRENT | \

  MASK_LOG_RCOUT | \

  MASK_LOG_OPTFLOW | \

  MASK_LOG_COMPASS | \

  MASK_LOG_CAMERA | \

  MASK_LOG_MOTBATT

#endif


//////////////////////////////////////////////////////////////////////////////

// Fence, Rally and Terrain and AC_Avoidance defaults

//


// Enable/disable Fence

#ifndef AC_FENCE

 #define AC_FENCE ENABLED

#endif


#ifndef AC_RALLY

 #define AC_RALLY ENABLED

#endif


#ifndef AC_TERRAIN

 #define AC_TERRAIN ENABLED

#endif


#if AC_TERRAIN && !AC_RALLY

 #error Terrain relies on Rally which is disabled

#endif


#ifndef AC_AVOID_ENABLED

 #define AC_AVOID_ENABLED ENABLED

#endif


#if AC_AVOID_ENABLED && !PROXIMITY_ENABLED

 #error AC_Avoidance relies on PROXIMITY_ENABLED which is disabled

#endif

#if AC_AVOID_ENABLED && !AC_FENCE

 #error AC_Avoidance relies on AC_FENCE which is disabled

#endif


//////////////////////////////////////////////////////////////////////////////

// Developer Items

//


// use this to completely disable the CLI

#ifndef CLI_ENABLED

 # define CLI_ENABLED     ENABLED

#endif


//use this to completely disable FRSKY TELEM

#ifndef FRSKY_TELEM_ENABLED

 # define FRSKY_TELEM_ENABLED     ENABLED

#endif


#ifndef ADVANCED_FAILSAFE

# define ADVANCED_FAILSAFE DISABLED

#endif


APM_Config.h

// User specific config file. Any items listed in config.h can be overridden here.


// If you used to define your CONFIG_APM_HARDWARE setting here, it is no longer

// valid! You should switch to using a HAL_BOARD flag in your local config.mk.


// uncomment the lines below to disable features (flash sizes listed are for APM2 boards and will underestimate savings on Pixhawk and other boards)

//#define LOGGING_ENABLED   DISABLED      // disable dataflash logging to save 11K of flash space

//#define MOUNT        DISABLED      // disable the camera gimbal to save 8K of flash space

//#define AUTOTUNE_ENABLED   DISABLED      // disable the auto tune functionality to save 7k of flash

//#define AC_FENCE       DISABLED      // disable fence to save 2k of flash

//#define CAMERA        DISABLED      // disable camera trigger to save 1k of flash

//#define RANGEFINDER_ENABLED DISABLED      // disable rangefinder to save 1k of flash

//#define PROXIMITY_ENABLED  DISABLED      // disable proximity sensors

//#define POSHOLD_ENABLED   DISABLED      // disable PosHold flight mode to save 4.5k of flash

//#define AC_RALLY       DISABLED      // disable rally points library (must also disable terrain which relies on rally)

//#define AC_TERRAIN      DISABLED      // disable terrain library

//#define PARACHUTE      DISABLED      // disable parachute release to save 1k of flash

//#define CLI_ENABLED     DISABLED      // disable the CLI (command-line-interface) to save 21K of flash space

//#define NAV_GUIDED      DISABLED      // disable external navigation computer ability to control vehicle through MAV_CMD_NAV_GUIDED mission commands

//#define OPTFLOW       DISABLED      // disable optical flow sensor to save 5K of flash space

//#define FRSKY_TELEM_ENABLED DISABLED      // disable FRSky telemetry

//#define ADSB_ENABLED     DISABLED      // disable ADSB support

//#define PRECISION_LANDING  DISABLED      // disable precision landing using companion computer or IRLock sensor

//#define SPRAYER       DISABLED      // disable the crop sprayer feature (two ESC controlled pumps the speed of which depends upon the vehicle's horizontal velocity)


// features below are disabled by default on all boards

//#define CAL_ALWAYS_REBOOT            // flight controller will reboot after compass or accelerometer calibration completes

//#define DISALLOW_GCS_MODE_CHANGE_DURING_RC_FAILSAFE // disable mode changes from GCS during Radio failsafes. Avoids a race condition for vehicle like Solo in which the RC and telemetry travel along the same link

//#define ADVANCED_FAILSAFE  ENABLED      // enabled advanced failsafe which allows running a portion of the mission in failsafe events


// other settings

//#define THROTTLE_IN_DEADBAND 100        // redefine size of throttle deadband in pwm (0 ~ 1000)


//#define HIL_MODE       HIL_MODE_SENSORS  // build for hardware-in-the-loop simulation


// User Hooks : For User Developed code that you wish to run

// Put your variable definitions into the UserVariables.h file (or another file name and then change the #define below).

//#define USERHOOK_VARIABLES "UserVariables.h"

// Put your custom code into the UserCode.cpp with function names matching those listed below and ensure the appropriate #define below is uncommented below

//#define USERHOOK_INIT userhook_init();           // for code to be run once at startup

//#define USERHOOK_FASTLOOP userhook_FastLoop();      // for code to be run at 100hz

//#define USERHOOK_50HZLOOP userhook_50Hz();         // for code to be run at 50hz

//#define USERHOOK_MEDIUMLOOP userhook_MediumLoop();    // for code to be run at 10hz

//#define USERHOOK_SLOWLOOP userhook_SlowLoop();      // for code to be run at 3.3hz

//#define USERHOOK_SUPERSLOWLOOP userhook_SuperSlowLoop(); // for code to be run at 1hz


defines.h

#pragma once


#include <AP_HAL/AP_HAL_Boards.h>


// Just so that it's completely clear...

#define ENABLED        1

#define DISABLED        0


// this avoids a very common config error

#define ENABLE ENABLED

#define DISABLE DISABLED


// Autopilot Yaw Mode enumeration

enum autopilot_yaw_mode {

  AUTO_YAW_HOLD =      0, // pilot controls the heading

  AUTO_YAW_LOOK_AT_NEXT_WP = 1, // point towards next waypoint (no pilot input accepted)

  AUTO_YAW_ROI =       2, // point towards a location held in roi_WP (no pilot input accepted)

  AUTO_YAW_LOOK_AT_HEADING = 3, // point towards a particular angle (not pilot input accepted)

  AUTO_YAW_LOOK_AHEAD =   4, // point in the direction the copter is moving

  AUTO_YAW_RESETTOARMEDYAW = 5, // point towards heading at time motors were armed

};


// Ch6... Ch12 aux switch control

#define AUX_SWITCH_PWM_TRIGGER_HIGH 1800 // pwm value above which the ch7 or ch8 option will be invoked

#define AUX_SWITCH_PWM_TRIGGER_LOW 1200 // pwm value below which the ch7 or ch8 option will be disabled

#define CH6_PWM_TRIGGER_HIGH  1800

#define CH6_PWM_TRIGGER_LOW  1200


// values used by the ap.ch7_opt and ap.ch8_opt flags

#define AUX_SWITCH_LOW       0   // indicates auxiliary switch is in the low position (pwm <1200)

#define AUX_SWITCH_MIDDLE     1   // indicates auxiliary switch is in the middle position (pwm >1200, <1800)

#define AUX_SWITCH_HIGH      2   // indicates auxiliary switch is in the high position (pwm >1800)


// Aux Switch enumeration

enum aux_sw_func {

  AUXSW_DO_NOTHING =     0, // aux switch disabled

  AUXSW_FLIP =        2, // flip

  AUXSW_SIMPLE_MODE =     3, // change to simple mode

  AUXSW_RTL =         4, // change to RTL flight mode

  AUXSW_SAVE_TRIM =      5, // save current position as level

  AUXSW_SAVE_WP =       7, // save mission waypoint or RTL if in auto mode

  AUXSW_CAMERA_TRIGGER =   9, // trigger camera servo or relay

  AUXSW_RANGEFINDER =    10, // allow enabling or disabling rangefinder in flight which helps avoid surface tracking when you are far above the ground

  AUXSW_FENCE =       11, // allow enabling or disabling fence in flight

  AUXSW_RESETTOARMEDYAW =  12, // deprecated. changes yaw to be same as when quad was armed

  AUXSW_SUPERSIMPLE_MODE =  13, // change to simple mode in middle, super simple at top

  AUXSW_ACRO_TRAINER =    14, // low = disabled, middle = leveled, high = leveled and limited

  AUXSW_SPRAYER =      15, // enable/disable the crop sprayer

  AUXSW_AUTO =        16, // change to auto flight mode

  AUXSW_AUTOTUNE =      17, // auto tune

  AUXSW_LAND =        18, // change to LAND flight mode

  AUXSW_GRIPPER =      19, // Operate cargo grippers low=off, middle=neutral, high=on

  AUXSW_PARACHUTE_ENABLE = 21, // Parachute enable/disable

  AUXSW_PARACHUTE_RELEASE = 22, // Parachute release

  AUXSW_PARACHUTE_3POS =   23, // Parachute disable, enable, release with 3 position switch

  AUXSW_MISSION_RESET =   24, // Reset auto mission to start from first command

  AUXSW_ATTCON_FEEDFWD =   25, // enable/disable the roll and pitch rate feed forward

  AUXSW_ATTCON_ACCEL_LIM =  26, // enable/disable the roll, pitch and yaw accel limiting

  AUXSW_RETRACT_MOUNT =   27, // Retract Mount

  AUXSW_RELAY =       28, // Relay pin on/off (only supports first relay)

  AUXSW_LANDING_GEAR =    29, // Landing gear controller

  AUXSW_LOST_COPTER_SOUND = 30, // Play lost copter sound

  AUXSW_MOTOR_ESTOP =    31, // Emergency Stop Switch

  AUXSW_MOTOR_INTERLOCK =  32, // Motor On/Off switch

  AUXSW_BRAKE =       33, // Brake flight mode

AUXSW_RELAY2 =       34, // Relay2 pin on/off (in Mission planner set CH8_OPT = 34)

  AUXSW_RELAY3 =       35, // Relay3 pin on/off (in Mission planner set CH9_OPT = 35)

  AUXSW_RELAY4 =       36, // Relay4 pin on/off (in Mission planner set CH10_OPT = 36)

  AUXSW_THROW =       37, // change to THROW flight mode

  AUXSW_AVOID_ADSB =     38, // enable AP_Avoidance library

  AUXSW_PRECISION_LOITER =  39, // enable precision loiter

  AUXSW_AVOID_PROXIMITY =  40, // enable object avoidance using proximity sensors (ie. horizontal lidar)

  AUXSW_ARMDISARM =     41, // arm or disarm vehicle

  AUXSW_SWITCH_MAX,

};


// Frame types

#define UNDEFINED_FRAME 0

#define MULTICOPTER_FRAME 1

#define HELI_FRAME 2


// HIL enumerations

#define HIL_MODE_DISABLED       0

#define HIL_MODE_SENSORS        1


// Auto Pilot Modes enumeration

enum control_mode_t {

  STABILIZE =  0, // manual airframe angle with manual throttle

  ACRO =     1, // manual body-frame angular rate with manual throttle

  ALT_HOLD =   2, // manual airframe angle with automatic throttle

  AUTO =     3, // fully automatic waypoint control using mission commands

  GUIDED =    4, // fully automatic fly to coordinate or fly at velocity/direction using GCS immediate commands

  LOITER =    5, // automatic horizontal acceleration with automatic throttle

  RTL =     6, // automatic return to launching point

  CIRCLE =    7, // automatic circular flight with automatic throttle

  LAND =     9, // automatic landing with horizontal position control

  DRIFT =    11, // semi-automous position, yaw and throttle control

  SPORT =    13, // manual earth-frame angular rate control with manual throttle

  FLIP =    14, // automatically flip the vehicle on the roll axis

  AUTOTUNE =  15, // automatically tune the vehicle's roll and pitch gains

  POSHOLD =   16, // automatic position hold with manual override, with automatic throttle

  BRAKE =    17, // full-brake using inertial/GPS system, no pilot input

  THROW =    18, // throw to launch mode using inertial/GPS system, no pilot input

  AVOID_ADSB = 19, // automatic avoidance of obstacles in the macro scale - e.g. full-sized aircraft

  GUIDED_NOGPS = 20, // guided mode but only accepts attitude and altitude

};


enum mode_reason_t {

  MODE_REASON_UNKNOWN=0,

  MODE_REASON_TX_COMMAND,

  MODE_REASON_GCS_COMMAND,

  MODE_REASON_RADIO_FAILSAFE,

  MODE_REASON_BATTERY_FAILSAFE,

  MODE_REASON_GCS_FAILSAFE,

  MODE_REASON_EKF_FAILSAFE,

  MODE_REASON_GPS_GLITCH,

  MODE_REASON_MISSION_END,

  MODE_REASON_THROTTLE_LAND_ESCAPE,

  MODE_REASON_FENCE_BREACH,

  MODE_REASON_TERRAIN_FAILSAFE,

  MODE_REASON_BRAKE_TIMEOUT,

  MODE_REASON_FLIP_COMPLETE,

  MODE_REASON_AVOIDANCE,

  MODE_REASON_AVOIDANCE_RECOVERY,

  MODE_REASON_THROW_COMPLETE,

};


// Tuning enumeration

enum tuning_func {

  TUNING_NONE =            0, //

  TUNING_STABILIZE_ROLL_PITCH_KP =  1, // stabilize roll/pitch angle controller's P term

  TUNING_STABILIZE_YAW_KP =      3, // stabilize yaw heading controller's P term

  TUNING_RATE_ROLL_PITCH_KP =     4, // body frame roll/pitch rate controller's P term

  TUNING_RATE_ROLL_PITCH_KI =     5, // body frame roll/pitch rate controller's I term

  TUNING_YAW_RATE_KP =        6, // body frame yaw rate controller's P term

  TUNING_THROTTLE_RATE_KP =      7, // throttle rate controller's P term (desired rate to acceleration or motor output)

  TUNING_WP_SPEED =         10, // maximum speed to next way point (0 to 10m/s)

  TUNING_LOITER_POSITION_KP =    12, // loiter distance controller's P term (position error to speed)

  TUNING_HELI_EXTERNAL_GYRO =    13, // TradHeli specific external tail gyro gain

  TUNING_ALTITUDE_HOLD_KP =     14, // altitude hold controller's P term (alt error to desired rate)

  TUNING_RATE_ROLL_PITCH_KD =    21, // body frame roll/pitch rate controller's D term

  TUNING_VEL_XY_KP =         22, // loiter rate controller's P term (speed error to tilt angle)

  TUNING_ACRO_RP_KP =        25, // acro controller's P term. converts pilot input to a desired roll, pitch or yaw rate

  TUNING_YAW_RATE_KD =        26, // body frame yaw rate controller's D term

  TUNING_VEL_XY_KI =         28, // loiter rate controller's I term (speed error to tilt angle)

  TUNING_AHRS_YAW_KP =        30, // ahrs's compass effect on yaw angle (0 = very low, 1 = very high)

  TUNING_AHRS_KP =          31, // accelerometer effect on roll/pitch angle (0=low)

  TUNING_ACCEL_Z_KP =        34, // accel based throttle controller's P term

  TUNING_ACCEL_Z_KI =        35, // accel based throttle controller's I term

  TUNING_ACCEL_Z_KD =        36, // accel based throttle controller's D term

  TUNING_DECLINATION =        38, // compass declination in radians

  TUNING_CIRCLE_RATE =        39, // circle turn rate in degrees (hard coded to about 45 degrees in either direction)

  TUNING_ACRO_YAW_KP =        40, // acro controller's P term. converts pilot input to a desired roll, pitch or yaw rate

  TUNING_RANGEFINDER_GAIN =     41, // rangefinder gain

  TUNING_EKF_VERTICAL_POS =     42, // EKF's baro vs accel (higher rely on accels more, baro impact is reduced). Range should be 0.2 ~ 4.0? 2.0 is default

  TUNING_EKF_HORIZONTAL_POS =    43, // EKF's gps vs accel (higher rely on accels more, gps impact is reduced). Range should be 1.0 ~ 3.0? 1.5 is default

  TUNING_EKF_ACCEL_NOISE =      44, // EKF's accel noise (lower means trust accels more, gps & baro less). Range should be 0.02 ~ 0.5 0.5 is default (but very robust at that level)

  TUNING_RC_FEEL_RP =        45, // roll-pitch input smoothing

  TUNING_RATE_PITCH_KP =       46, // body frame pitch rate controller's P term

  TUNING_RATE_PITCH_KI =       47, // body frame pitch rate controller's I term

  TUNING_RATE_PITCH_KD =       48, // body frame pitch rate controller's D term

  TUNING_RATE_ROLL_KP =       49, // body frame roll rate controller's P term

  TUNING_RATE_ROLL_KI =       50, // body frame roll rate controller's I term

  TUNING_RATE_ROLL_KD =       51, // body frame roll rate controller's D term

  TUNING_RATE_PITCH_FF =       52, // body frame pitch rate controller FF term

  TUNING_RATE_ROLL_FF =       53, // body frame roll rate controller FF term

  TUNING_RATE_YAW_FF =        54, // body frame yaw rate controller FF term

  TUNING_RATE_MOT_YAW_HEADROOM =   55, // motors yaw headroom minimum

  TUNING_RATE_YAW_FILT =       56 // yaw rate input filter

};


// Acro Trainer types

#define ACRO_TRAINER_DISABLED 0

#define ACRO_TRAINER_LEVELING 1

#define ACRO_TRAINER_LIMITED  2


// RC Feel roll/pitch definitions

#define RC_FEEL_RP_VERY_SOFT    0

#define RC_FEEL_RP_SOFT      25

#define RC_FEEL_RP_MEDIUM     50

#define RC_FEEL_RP_CRISP      75

#define RC_FEEL_RP_VERY_CRISP   100


// Yaw behaviours during missions - possible values for WP_YAW_BEHAVIOR parameter

#define WP_YAW_BEHAVIOR_NONE             0 // auto pilot will never control yaw during missions or rtl (except for DO_CONDITIONAL_YAW command received)

#define WP_YAW_BEHAVIOR_LOOK_AT_NEXT_WP       1 // auto pilot will face next waypoint or home during rtl

#define WP_YAW_BEHAVIOR_LOOK_AT_NEXT_WP_EXCEPT_RTL  2 // auto pilot will face next waypoint except when doing RTL at which time it will stay in it's last

#define WP_YAW_BEHAVIOR_LOOK_AHEAD          3 // auto pilot will look ahead during missions and rtl (primarily meant for traditional helicotpers)


// Auto modes

enum AutoMode {

  Auto_TakeOff,

  Auto_WP,

  Auto_Land,

  Auto_RTL,

  Auto_CircleMoveToEdge,

  Auto_Circle,

  Auto_Spline,

  Auto_NavGuided,

  Auto_Loiter,

  Auto_NavPayloadPlace,

};


// Guided modes

enum GuidedMode {

  Guided_TakeOff,

  Guided_WP,

  Guided_Velocity,

  Guided_PosVel,

  Guided_Angle,

};


// RTL states

enum RTLState {

  RTL_InitialClimb,

  RTL_ReturnHome,

  RTL_LoiterAtHome,

  RTL_FinalDescent,

  RTL_Land

};


// Alt_Hold states

enum AltHoldModeState {

  AltHold_MotorStopped,

  AltHold_Takeoff,

  AltHold_Flying,

  AltHold_Landed

};


// Loiter states

enum LoiterModeState {

  Loiter_MotorStopped,

  Loiter_Takeoff,

  Loiter_Flying,

  Loiter_Landed

};


// Sport states

enum SportModeState {

  Sport_MotorStopped,

  Sport_Takeoff,

  Sport_Flying,

  Sport_Landed

};


// Flip states

enum FlipState {

  Flip_Start,

  Flip_Roll,

  Flip_Pitch_A,

  Flip_Pitch_B,

  Flip_Recover,

  Flip_Abandon

};


// Throw stages

enum ThrowModeStage {

  Throw_Disarmed,

  Throw_Detecting,

  Throw_Uprighting,

  Throw_HgtStabilise,

  Throw_PosHold

};


// Throw types

enum ThrowModeType {

  ThrowType_Upward = 0,

  ThrowType_Drop = 1

};


enum LandStateType {

  LandStateType_FlyToLocation = 0,

  LandStateType_Descending = 1

};


enum PayloadPlaceStateType {

  PayloadPlaceStateType_FlyToLocation,

  PayloadPlaceStateType_Calibrating_Hover_Start,

  PayloadPlaceStateType_Calibrating_Hover,

  PayloadPlaceStateType_Descending_Start,

  PayloadPlaceStateType_Descending,

  PayloadPlaceStateType_Releasing_Start,

  PayloadPlaceStateType_Releasing,

  PayloadPlaceStateType_Released,

  PayloadPlaceStateType_Ascending_Start,

  PayloadPlaceStateType_Ascending,

  PayloadPlaceStateType_Done,

};


// bit options for DEV_OPTIONS parameter

enum DevOptions {

  DevOptionADSBMAVLink = 1,

};


// Logging parameters

#define TYPE_AIRSTART_MSG       0x00

#define TYPE_GROUNDSTART_MSG      0x01

#define LOG_CONTROL_TUNING_MSG     0x04

#define LOG_NAV_TUNING_MSG       0x05

#define LOG_PERFORMANCE_MSG      0x06

#define LOG_OPTFLOW_MSG        0x0C

#define LOG_EVENT_MSG         0x0D

#define LOG_PID_MSG          0x0E  // deprecated

#define LOG_INAV_MSG          0x11  // deprecated

#define LOG_CAMERA_MSG_DEPRECATED   0x12  // deprecated

#define LOG_ERROR_MSG         0x13

#define LOG_DATA_INT16_MSG       0x14

#define LOG_DATA_UINT16_MSG      0x15

#define LOG_DATA_INT32_MSG       0x16

#define LOG_DATA_UINT32_MSG      0x17

#define LOG_DATA_FLOAT_MSG       0x18

#define LOG_AUTOTUNE_MSG        0x19

#define LOG_AUTOTUNEDETAILS_MSG    0x1A

#define LOG_MOTBATT_MSG        0x1E

#define LOG_PARAMTUNE_MSG       0x1F

#define LOG_HELI_MSG          0x20

#define LOG_PRECLAND_MSG        0x21

#define LOG_GUIDEDTARGET_MSG      0x22

#define LOG_THROW_MSG         0x23

#define LOG_PROXIMITY_MSG       0x24

#define LOG_BEACON_MSG         0x25


#define MASK_LOG_ATTITUDE_FAST     (1<<0)

#define MASK_LOG_ATTITUDE_MED     (1<<1)

#define MASK_LOG_GPS          (1<<2)

#define MASK_LOG_PM          (1<<3)

#define MASK_LOG_CTUN         (1<<4)

#define MASK_LOG_NTUN         (1<<5)

#define MASK_LOG_RCIN         (1<<6)

#define MASK_LOG_IMU          (1<<7)

#define MASK_LOG_CMD          (1<<8)

#define MASK_LOG_CURRENT        (1<<9)

#define MASK_LOG_RCOUT         (1<<10)

#define MASK_LOG_OPTFLOW        (1<<11)

#define MASK_LOG_PID          (1<<12)

#define MASK_LOG_COMPASS        (1<<13)

#define MASK_LOG_INAV         (1<<14) // deprecated

#define MASK_LOG_CAMERA        (1<<15)

#define MASK_LOG_MOTBATT        (1UL<<17)

#define MASK_LOG_IMU_FAST       (1UL<<18)

#define MASK_LOG_IMU_RAW        (1UL<<19)

#define MASK_LOG_ANY          0xFFFF


// DATA - event logging

#define DATA_AP_STATE           7

#define DATA_SYSTEM_TIME_SET        8

#define DATA_INIT_SIMPLE_BEARING      9

#define DATA_ARMED             10

#define DATA_DISARMED           11

#define DATA_AUTO_ARMED          15

#define DATA_LAND_COMPLETE_MAYBE      17

#define DATA_LAND_COMPLETE         18

#define DATA_NOT_LANDED          28

#define DATA_LOST_GPS           19

#define DATA_FLIP_START          21

#define DATA_FLIP_END           22

#define DATA_SET_HOME           25

#define DATA_SET_SIMPLE_ON         26

#define DATA_SET_SIMPLE_OFF        27

#define DATA_SET_SUPERSIMPLE_ON      29

#define DATA_AUTOTUNE_INITIALISED     30

#define DATA_AUTOTUNE_OFF         31

#define DATA_AUTOTUNE_RESTART       32

#define DATA_AUTOTUNE_SUCCESS       33

#define DATA_AUTOTUNE_FAILED        34

#define DATA_AUTOTUNE_REACHED_LIMIT    35

#define DATA_AUTOTUNE_PILOT_TESTING    36

#define DATA_AUTOTUNE_SAVEDGAINS      37

#define DATA_SAVE_TRIM           38

#define DATA_SAVEWP_ADD_WP         39

#define DATA_FENCE_ENABLE         41

#define DATA_FENCE_DISABLE         42

#define DATA_ACRO_TRAINER_DISABLED     43

#define DATA_ACRO_TRAINER_LEVELING     44

#define DATA_ACRO_TRAINER_LIMITED     45

#define DATA_GRIPPER_GRAB         46

#define DATA_GRIPPER_RELEASE        47

#define DATA_PARACHUTE_DISABLED      49

#define DATA_PARACHUTE_ENABLED       50

#define DATA_PARACHUTE_RELEASED      51

#define DATA_LANDING_GEAR_DEPLOYED     52

#define DATA_LANDING_GEAR_RETRACTED    53

#define DATA_MOTORS_EMERGENCY_STOPPED   54

#define DATA_MOTORS_EMERGENCY_STOP_CLEARED 55

#define DATA_MOTORS_INTERLOCK_DISABLED   56

#define DATA_MOTORS_INTERLOCK_ENABLED   57

#define DATA_ROTOR_RUNUP_COMPLETE     58 // Heli only

#define DATA_ROTOR_SPEED_BELOW_CRITICAL  59 // Heli only

#define DATA_EKF_ALT_RESET         60

#define DATA_LAND_CANCELLED_BY_PILOT    61

#define DATA_EKF_YAW_RESET         62

#define DATA_AVOIDANCE_ADSB_ENABLE     63

#define DATA_AVOIDANCE_ADSB_DISABLE    64

#define DATA_AVOIDANCE_PROXIMITY_ENABLE  65

#define DATA_AVOIDANCE_PROXIMITY_DISABLE  66

#define DATA_GPS_PRIMARY_CHANGED      67


// Centi-degrees to radians

#define DEGX100 5729.57795f


// Error message sub systems and error codes

#define ERROR_SUBSYSTEM_MAIN        1

#define ERROR_SUBSYSTEM_RADIO       2

#define ERROR_SUBSYSTEM_COMPASS      3

#define ERROR_SUBSYSTEM_OPTFLOW      4

#define ERROR_SUBSYSTEM_FAILSAFE_RADIO   5

#define ERROR_SUBSYSTEM_FAILSAFE_BATT   6

#define ERROR_SUBSYSTEM_FAILSAFE_GPS    7 // not used

#define ERROR_SUBSYSTEM_FAILSAFE_GCS    8

#define ERROR_SUBSYSTEM_FAILSAFE_FENCE   9

#define ERROR_SUBSYSTEM_FLIGHT_MODE    10

#define ERROR_SUBSYSTEM_GPS        11 // not used

#define ERROR_SUBSYSTEM_CRASH_CHECK    12

#define ERROR_SUBSYSTEM_FLIP        13

#define ERROR_SUBSYSTEM_AUTOTUNE      14

#define ERROR_SUBSYSTEM_PARACHUTE     15

#define ERROR_SUBSYSTEM_EKFCHECK      16

#define ERROR_SUBSYSTEM_FAILSAFE_EKFINAV  17

#define ERROR_SUBSYSTEM_BARO        18

#define ERROR_SUBSYSTEM_CPU        19

#define ERROR_SUBSYSTEM_FAILSAFE_ADSB   20

#define ERROR_SUBSYSTEM_TERRAIN      21

#define ERROR_SUBSYSTEM_NAVIGATION     22

#define ERROR_SUBSYSTEM_FAILSAFE_TERRAIN  23

#define ERROR_SUBSYSTEM_EKF_PRIMARY    24

// general error codes

#define ERROR_CODE_ERROR_RESOLVED     0

#define ERROR_CODE_FAILED_TO_INITIALISE  1

#define ERROR_CODE_UNHEALTHY        4

// subsystem specific error codes -- radio

#define ERROR_CODE_RADIO_LATE_FRAME    2

// subsystem specific error codes -- failsafe_thr, batt, gps

#define ERROR_CODE_FAILSAFE_RESOLVED    0

#define ERROR_CODE_FAILSAFE_OCCURRED    1

// subsystem specific error codes -- compass

#define ERROR_CODE_COMPASS_FAILED_TO_READ 2

// subsystem specific error codes -- main

#define ERROR_CODE_MAIN_INS_DELAY     1

// subsystem specific error codes -- crash checker

#define ERROR_CODE_CRASH_CHECK_CRASH    1

#define ERROR_CODE_CRASH_CHECK_LOSS_OF_CONTROL 2

// subsystem specific error codes -- flip

#define ERROR_CODE_FLIP_ABANDONED     2

// subsystem specific error codes -- terrain

#define ERROR_CODE_MISSING_TERRAIN_DATA  2

// subsystem specific error codes -- navigation

#define ERROR_CODE_FAILED_TO_SET_DESTINATION  2

#define ERROR_CODE_RESTARTED_RTL      3

#define ERROR_CODE_FAILED_CIRCLE_INIT   4

#define ERROR_CODE_DEST_OUTSIDE_FENCE   5


// parachute failed to deploy because of low altitude or landed

#define ERROR_CODE_PARACHUTE_TOO_LOW    2

#define ERROR_CODE_PARACHUTE_LANDED    3

// EKF check definitions

#define ERROR_CODE_EKFCHECK_BAD_VARIANCE   2

#define ERROR_CODE_EKFCHECK_VARIANCE_CLEARED 0

// Baro specific error codes

#define ERROR_CODE_BARO_GLITCH       2


// Arming Check Enable/Disable bits

#define ARMING_CHECK_NONE         0x00

#define ARMING_CHECK_ALL          0x01

#define ARMING_CHECK_BARO         0x02

#define ARMING_CHECK_COMPASS        0x04

#define ARMING_CHECK_GPS          0x08

#define ARMING_CHECK_INS          0x10

#define ARMING_CHECK_PARAMETERS      0x20

#define ARMING_CHECK_RC          0x40

#define ARMING_CHECK_VOLTAGE        0x80


// Radio failsafe definitions (FS_THR parameter)

#define FS_THR_DISABLED          0

#define FS_THR_ENABLED_ALWAYS_RTL     1

#define FS_THR_ENABLED_CONTINUE_MISSION  2

#define FS_THR_ENABLED_ALWAYS_LAND    3


// Battery failsafe definitions (FS_BATT_ENABLE parameter)

#define FS_BATT_DISABLED          0   // battery failsafe disabled

#define FS_BATT_LAND            1   // switch to LAND mode on battery failsafe

#define FS_BATT_RTL            2   // switch to RTL mode on battery failsafe


// GCS failsafe definitions (FS_GCS_ENABLE parameter)

#define FS_GCS_DISABLED          0

#define FS_GCS_ENABLED_ALWAYS_RTL     1

#define FS_GCS_ENABLED_CONTINUE_MISSION  2


// EKF failsafe definitions (FS_EKF_ACTION parameter)

#define FS_EKF_ACTION_LAND         1   // switch to LAND mode on EKF failsafe

#define FS_EKF_ACTION_ALTHOLD       2   // switch to ALTHOLD mode on EKF failsafe

#define FS_EKF_ACTION_LAND_EVEN_STABILIZE 3   // switch to Land mode on EKF failsafe even if in a manual flight mode like stabilize


// for mavlink SET_POSITION_TARGET messages

#define MAVLINK_SET_POS_TYPE_MASK_POS_IGNORE   ((1<<0) | (1<<1) | (1<<2))

#define MAVLINK_SET_POS_TYPE_MASK_VEL_IGNORE   ((1<<3) | (1<<4) | (1<<5))

#define MAVLINK_SET_POS_TYPE_MASK_ACC_IGNORE   ((1<<6) | (1<<7) | (1<<8))

#define MAVLINK_SET_POS_TYPE_MASK_FORCE     (1<<9)

#define MAVLINK_SET_POS_TYPE_MASK_YAW_IGNORE   (1<<10)

#define MAVLINK_SET_POS_TYPE_MASK_YAW_RATE_IGNORE (1<<11)


// for PILOT_THR_BHV parameter

#define THR_BEHAVE_FEEDBACK_FROM_MID_STICK (1<<0)

#define THR_BEHAVE_HIGH_THROTTLE_CANCELS_LAND (1<<1)

#define THR_BEHAVE_DISARM_ON_LAND_DETECT (1<<2)


Mindomo

Over Mindomo
Help
Contact
Prijzen
Publieke Mindmap Galerij
Mindmapsjablonen

Meer informatie

Blog
Gebruiksvoorwaarden
Privacybeleid
Security
Accessibility
Security Policy

Veelgestelde vragen

Wat is mindmappen?
Maak online een mindmap
Mind Map Eksempler
Wat is conceptmapping?
Concept Map Maker