ardupilot/ArduPlane/system.cpp

473 lines
14 KiB
C++
Raw Normal View History

2015-05-13 03:09:36 -03:00
#include "Plane.h"
2019-04-04 08:06:47 -03:00
#include <AP_Common/AP_FWVersion.h>
2015-05-13 03:09:36 -03:00
/*****************************************************************************
2012-08-21 23:19:51 -03:00
* The init_ardupilot function processes everything we need for an in - air restart
* We will determine later if we are actually on the ground and process a
* ground start in that case.
*
*****************************************************************************/
2015-05-13 03:09:36 -03:00
static void mavlink_delay_cb_static()
{
plane.mavlink_delay_cb();
}
static void failsafe_check_static()
{
plane.failsafe_check();
}
void Plane::init_ardupilot()
{
// initialise serial port
serial_manager.init_console();
hal.console->printf("\n\nInit %s"
2017-08-11 01:31:18 -03:00
"\n\nFree RAM: %u\n",
2018-06-13 08:12:16 -03:00
AP::fwversion().fw_string,
2017-08-11 01:31:18 -03:00
(unsigned)hal.util->available_memory());
//
2012-12-04 18:22:21 -04:00
// Check the EEPROM format version before loading any parameters from EEPROM
2012-08-21 23:19:51 -03:00
//
2012-02-12 04:20:56 -04:00
load_parameters();
2018-02-28 08:22:16 -04:00
#if STATS_ENABLED == ENABLED
// initialise stats module
g2.stats.init();
2018-02-28 08:22:16 -04:00
#endif
#if HIL_SUPPORT
if (g.hil_mode == 1) {
// set sensors to HIL mode
ins.set_hil_mode();
compass.set_hil_mode();
barometer.set_hil_mode();
}
#endif
ins.set_log_raw_bit(MASK_LOG_IMU_RAW);
set_control_channels();
mavlink_system.sysid = g.sysid_this_mav;
// initialise serial ports
serial_manager.init();
gcs().setup_console();
2017-02-14 08:07:54 -04:00
// Register mavlink_delay_cb, which will run anytime you have
// more than 5ms remaining in your call to hal.scheduler->delay
hal.scheduler->register_delay_callback(mavlink_delay_cb_static, 5);
// setup any board specific drivers
BoardConfig.init();
#if HAL_WITH_UAVCAN
BoardConfig_CAN.init();
#endif
// initialise rc channels including setting mode
rc().init();
relay.init();
// initialise notify system
2018-07-25 22:10:33 -03:00
notify.init();
notify_mode(*control_mode);
init_rc_out_main();
// keep a record of how many resets have happened. This can be
// used to detect in-flight resets
g.num_resets.set_and_save(g.num_resets+1);
2017-08-11 01:31:18 -03:00
// init baro
barometer.init();
// initialise rangefinder
rangefinder.set_log_rfnd_bit(MASK_LOG_SONAR);
2019-04-05 06:14:50 -03:00
rangefinder.init(ROTATION_PITCH_270);
// initialise battery monitoring
battery.init();
rpm_sensor.init();
2016-05-16 00:33:43 -03:00
// setup telem slots with serial ports
gcs().setup_uarts();
2018-06-23 04:11:05 -03:00
#if OSD_ENABLED == ENABLED
osd.init();
2018-06-23 04:11:05 -03:00
#endif
2011-12-21 08:29:22 -04:00
#if LOGGING_ENABLED == ENABLED
2015-05-13 03:09:36 -03:00
log_init();
2011-12-21 08:29:22 -04:00
#endif
// initialise airspeed sensor
airspeed.init();
AP::compass().set_log_bit(MASK_LOG_COMPASS);
AP::compass().init();
#if OPTFLOW == ENABLED
2015-01-02 20:09:02 -04:00
// make optflow available to libraries
if (optflow.enabled()) {
ahrs.set_optflow(&optflow);
}
#endif
2012-08-10 19:57:44 -03:00
// give AHRS the airspeed sensor
ahrs.set_airspeed(&airspeed);
// GPS Initialization
gps.set_log_gps_bit(MASK_LOG_GPS);
gps.init(serial_manager);
2013-12-21 07:27:15 -04:00
2012-08-21 23:19:51 -03:00
init_rc_in(); // sets up rc channels from radio
#if MOUNT == ENABLED
// initialise camera mount
camera_mount.init();
#endif
2018-06-10 03:33:06 -03:00
#if LANDING_GEAR_ENABLED == ENABLED
// initialise landing gear position
g2.landing_gear.init();
gear.last_auto_cmd = -1;
gear.last_cmd = -1;
#endif
#if FENCE_TRIGGERED_PIN > 0
2014-06-01 20:28:27 -03:00
hal.gpio->pinMode(FENCE_TRIGGERED_PIN, HAL_GPIO_OUTPUT);
hal.gpio->write(FENCE_TRIGGERED_PIN, 0);
#endif
/*
2012-08-21 23:19:51 -03:00
* setup the 'main loop is dead' check. Note that this relies on
* the RC library being initialised.
*/
2015-05-13 03:09:36 -03:00
hal.scheduler->register_timer_failsafe(failsafe_check_static, 1000);
quadplane.setup();
AP_Param::reload_defaults_file(true);
2017-01-09 05:52:49 -04:00
startup_ground();
// don't initialise aux rc output until after quadplane is setup as
// that can change initial values of channels
init_rc_out_aux();
// choose the nav controller
set_nav_controller();
set_mode_by_number((enum Mode::Number)g.initial_mode.get(), ModeReason::UNKNOWN);
2012-08-21 23:19:51 -03:00
// set the correct flight mode
// ---------------------------
reset_control_switch();
// initialise sensor
#if OPTFLOW == ENABLED
if (optflow.enabled()) {
optflow.init(-1);
}
#endif
2018-02-22 05:13:38 -04:00
// init cargo gripper
#if GRIPPER_ENABLED == ENABLED
g2.gripper.init();
#endif
// disable safety if requested
BoardConfig.init_safety();
2019-04-10 22:56:23 -03:00
#if AP_PARAM_KEY_DUMP
AP_Param::show_all(hal.console, true);
#endif
}
//********************************************************************************
//This function does all the calibrations, etc. that we need during a ground start
//********************************************************************************
2015-05-13 03:09:36 -03:00
void Plane::startup_ground(void)
{
set_mode(mode_initializing, ModeReason::UNKNOWN);
2012-08-21 23:19:51 -03:00
#if (GROUND_START_DELAY > 0)
gcs().send_text(MAV_SEVERITY_NOTICE,"Ground start with delay");
2012-08-21 23:19:51 -03:00
delay(GROUND_START_DELAY * 1000);
#else
gcs().send_text(MAV_SEVERITY_INFO,"Ground start");
2012-08-21 23:19:51 -03:00
#endif
//INS ground start
2012-08-21 23:19:51 -03:00
//------------------------
//
2015-03-10 20:16:59 -03:00
startup_INS_ground();
2012-08-21 23:19:51 -03:00
// Save the settings for in-air restart
// ------------------------------------
//save_EEPROM_groundstart();
// initialise mission library
mission.init();
// initialise AP_Logger library
#if LOGGING_ENABLED == ENABLED
logger.setVehicle_Startup_Writer(
FUNCTOR_BIND(&plane, &Plane::Log_Write_Vehicle_Startup_Messages, void)
);
#endif
2018-09-27 20:03:56 -03:00
#ifdef ENABLE_SCRIPTING
if (!g2.scripting.init()) {
gcs().send_text(MAV_SEVERITY_ERROR, "Scripting failed to start");
}
#endif // ENABLE_SCRIPTING
// reset last heartbeat time, so we don't trigger failsafe on slow
// startup
failsafe.last_heartbeat_ms = millis();
// we don't want writes to the serial port to cause us to pause
// mid-flight, so set the serial ports non-blocking once we are
// ready to fly
serial_manager.set_blocking_writes_all(false);
gcs().send_text(MAV_SEVERITY_INFO,"Ground start complete");
}
bool Plane::set_mode(Mode &new_mode, const ModeReason reason)
{
2019-04-01 14:43:12 -03:00
if (control_mode == &new_mode) {
// don't switch modes if we are already in the correct mode.
return true;
}
#if !QAUTOTUNE_ENABLED
if (&new_mode == &plane.mode_qautotune) {
gcs().send_text(MAV_SEVERITY_INFO,"QAUTOTUNE disabled");
set_mode(plane.mode_qhover, ModeReason::UNAVAILABLE);
return false;
}
#endif
// backup current control_mode and previous_mode
Mode &old_previous_mode = *previous_mode;
Mode &old_mode = *control_mode;
const ModeReason previous_mode_reason_backup = previous_mode_reason;
// update control_mode assuming success
// TODO: move these to be after enter() once start_command_callback() no longer checks control_mode
previous_mode = control_mode;
control_mode = &new_mode;
2016-08-13 04:54:37 -03:00
previous_mode_reason = control_mode_reason;
control_mode_reason = reason;
2012-08-21 23:19:51 -03:00
// attempt to enter new mode
if (!new_mode.enter()) {
// Log error that we failed to enter desired flight mode
gcs().send_text(MAV_SEVERITY_WARNING, "Flight mode change failed");
// we failed entering new mode, roll back to old
previous_mode = &old_previous_mode;
control_mode = &old_mode;
control_mode_reason = previous_mode_reason;
previous_mode_reason = previous_mode_reason_backup;
// currently, only Q modes can fail enter(). This will likely change in the future and all modes
// should be changed to check dependencies and fail early before depending on changes in Mode::set_mode()
if (control_mode->is_vtol_mode()) {
// ignore result because if we fail we risk looping at the qautotune check above
control_mode->enter();
}
return false;
2012-08-21 23:19:51 -03:00
}
2019-04-01 14:43:12 -03:00
if (previous_mode == &mode_autotune) {
// restore last gains
autotune_restore();
}
// exit previous mode
old_mode.exit();
2016-07-10 21:23:08 -03:00
// record reasons
previous_mode_reason = control_mode_reason;
control_mode_reason = reason;
// log and notify mode change
logger.Write_Mode(control_mode->mode_number(), control_mode_reason);
notify_mode(*control_mode);
2019-06-26 15:21:48 -03:00
gcs().send_message(MSG_HEARTBEAT);
return true;
}
bool Plane::set_mode(const uint8_t new_mode, const ModeReason reason)
{
static_assert(sizeof(Mode::Number) == sizeof(new_mode), "The new mode can't be mapped to the vehicles mode number");
Mode *mode = plane.mode_from_mode_num(static_cast<Mode::Number>(new_mode));
if (mode == nullptr) {
gcs().send_text(MAV_SEVERITY_INFO, "Error: invalid mode number: %u", (unsigned)new_mode);
return false;
}
return set_mode(*mode, reason);
}
bool Plane::set_mode_by_number(const Mode::Number new_mode_number, const ModeReason reason)
{
Mode *new_mode = plane.mode_from_mode_num(new_mode_number);
if (new_mode == nullptr) {
gcs().send_text(MAV_SEVERITY_INFO, "Error: invalid mode number: %d", new_mode_number);
return false;
}
return set_mode(*new_mode, reason);
}
2015-05-13 03:09:36 -03:00
void Plane::check_long_failsafe()
{
uint32_t tnow = millis();
2012-08-21 23:19:51 -03:00
// only act on changes
// -------------------
if (failsafe.state != FAILSAFE_LONG && failsafe.state != FAILSAFE_GCS && flight_stage != AP_Vehicle::FixedWing::FLIGHT_LAND) {
uint32_t radio_timeout_ms = failsafe.last_valid_rc_ms;
if (failsafe.state == FAILSAFE_SHORT) {
// time is relative to when short failsafe enabled
radio_timeout_ms = failsafe.short_timer_ms;
}
if (failsafe.rc_failsafe &&
(tnow - radio_timeout_ms) > g.fs_timeout_long*1000) {
failsafe_long_on_event(FAILSAFE_LONG, ModeReason::RADIO_FAILSAFE);
} else if (g.gcs_heartbeat_fs_enabled == GCS_FAILSAFE_HB_AUTO && control_mode == &mode_auto &&
failsafe.last_heartbeat_ms != 0 &&
(tnow - failsafe.last_heartbeat_ms) > g.fs_timeout_long*1000) {
failsafe_long_on_event(FAILSAFE_GCS, ModeReason::GCS_FAILSAFE);
} else if (g.gcs_heartbeat_fs_enabled == GCS_FAILSAFE_HEARTBEAT &&
failsafe.last_heartbeat_ms != 0 &&
(tnow - failsafe.last_heartbeat_ms) > g.fs_timeout_long*1000) {
failsafe_long_on_event(FAILSAFE_GCS, ModeReason::GCS_FAILSAFE);
} else if (g.gcs_heartbeat_fs_enabled == GCS_FAILSAFE_HB_RSSI &&
gcs().chan(0) != nullptr &&
gcs().chan(0)->last_radio_status_remrssi_ms != 0 &&
(tnow - gcs().chan(0)->last_radio_status_remrssi_ms) > g.fs_timeout_long*1000) {
failsafe_long_on_event(FAILSAFE_GCS, ModeReason::GCS_FAILSAFE);
2012-08-21 23:19:51 -03:00
}
} else {
uint32_t timeout_seconds = g.fs_timeout_long;
if (g.fs_action_short != FS_ACTION_SHORT_DISABLED) {
// avoid dropping back into short timeout
timeout_seconds = g.fs_timeout_short;
}
2012-08-21 23:19:51 -03:00
// We do not change state but allow for user to change mode
if (failsafe.state == FAILSAFE_GCS &&
(tnow - failsafe.last_heartbeat_ms) < timeout_seconds*1000) {
failsafe_long_off_event(ModeReason::GCS_FAILSAFE);
} else if (failsafe.state == FAILSAFE_LONG &&
!failsafe.rc_failsafe) {
failsafe_long_off_event(ModeReason::RADIO_FAILSAFE);
}
2012-08-21 23:19:51 -03:00
}
}
2015-05-13 03:09:36 -03:00
void Plane::check_short_failsafe()
{
2012-08-21 23:19:51 -03:00
// only act on changes
// -------------------
if (g.fs_action_short != FS_ACTION_SHORT_DISABLED &&
failsafe.state == FAILSAFE_NONE &&
flight_stage != AP_Vehicle::FixedWing::FLIGHT_LAND) {
// The condition is checked and the flag rc_failsafe is set in radio.cpp
if(failsafe.rc_failsafe) {
failsafe_short_on_event(FAILSAFE_SHORT, ModeReason::RADIO_FAILSAFE);
2012-08-21 23:19:51 -03:00
}
}
if(failsafe.state == FAILSAFE_SHORT) {
if(!failsafe.rc_failsafe || g.fs_action_short == FS_ACTION_SHORT_DISABLED) {
failsafe_short_off_event(ModeReason::RADIO_FAILSAFE);
2012-08-21 23:19:51 -03:00
}
}
}
2015-05-13 03:09:36 -03:00
void Plane::startup_INS_ground(void)
{
#if HIL_SUPPORT
if (g.hil_mode == 1) {
while (barometer.get_last_update() == 0) {
// the barometer begins updating when we get the first
// HIL_STATE message
gcs().send_text(MAV_SEVERITY_WARNING, "Waiting for first HIL_STATE message");
hal.scheduler->delay(1000);
}
}
#endif
if (ins.gyro_calibration_timing() != AP_InertialSensor::GYRO_CAL_NEVER) {
gcs().send_text(MAV_SEVERITY_ALERT, "Beginning INS calibration. Do not move plane");
} else {
gcs().send_text(MAV_SEVERITY_ALERT, "Skipping INS calibration");
}
2013-01-13 01:04:18 -04:00
ahrs.init();
ahrs.set_fly_forward(true);
2014-04-21 04:12:24 -03:00
ahrs.set_vehicle_class(AHRS_VEHICLE_FIXED_WING);
2013-05-23 22:21:32 -03:00
ahrs.set_wind_estimation(true);
2013-01-13 01:04:18 -04:00
ins.init(scheduler.get_loop_rate_hz());
ahrs.reset();
2012-08-21 23:19:51 -03:00
// read Baro pressure at ground
//-----------------------------
barometer.set_log_baro_bit(MASK_LOG_IMU);
barometer.calibrate();
if (airspeed.enabled()) {
// initialize airspeed sensor
// --------------------------
airspeed.calibrate(true);
} else {
gcs().send_text(MAV_SEVERITY_WARNING,"No airspeed");
}
}
// sets notify object flight mode information
void Plane::notify_mode(const Mode& mode)
{
notify.flags.flight_mode = mode.mode_number();
notify.set_flight_mode_str(mode.name4());
}
/*
should we log a message type now?
*/
2015-05-13 03:09:36 -03:00
bool Plane::should_log(uint32_t mask)
{
#if LOGGING_ENABLED == ENABLED
return logger.should_log(mask);
#else
return false;
#endif
}
/*
return throttle percentage from 0 to 100 for normal use and -100 to 100 when using reverse thrust
*/
int8_t Plane::throttle_percentage(void)
{
if (quadplane.in_vtol_mode()) {
return quadplane.throttle_percentage();
}
float throttle = SRV_Channels::get_output_scaled(SRV_Channel::k_throttle);
if (!have_reverse_thrust()) {
return constrain_int16(throttle, 0, 100);
}
return constrain_int16(throttle, -100, 100);
}