should be listed here, along with how often they should be called
(in 2.5ms units) and the maximum time they are expected to take (in
microseconds)
1 = 400hz
2 = 200hz
4 = 100hz
8 = 50hz
20 = 20hz
40 = 10hz
133 = 3hz
400 = 1hz
4000 = 0.1hz
*/
const AP_Scheduler::Task Copter::scheduler_tasks[] = {
SCHED_TASK(rc_loop, 100, 130),
SCHED_TASK(throttle_loop, 50, 75),
SCHED_TASK(update_GPS, 50, 200),
#if OPTFLOW == ENABLED
SCHED_TASK(update_optical_flow, 200, 160),
#endif
SCHED_TASK(update_batt_compass, 10, 120),
SCHED_TASK(read_aux_switches, 10, 50),
SCHED_TASK(arm_motors_check, 10, 50),
SCHED_TASK(auto_disarm_check, 10, 50),
SCHED_TASK(auto_trim, 10, 75),
SCHED_TASK(update_altitude, 10, 140),
SCHED_TASK(run_nav_updates, 50, 100),
SCHED_TASK(update_thr_average, 100, 90),
SCHED_TASK(three_hz_loop, 3, 75),
SCHED_TASK(compass_accumulate, 100, 100),
#include "Rover.h"
const AP_HAL::HAL& hal = AP_HAL::get_HAL();
Rover rover;
#define SCHED_TASK(func, _interval_ticks, _max_time_micros) SCHED_TASK_CLASS(Rover, &rover, func, _interval_ticks, _max_time_micros)
/*
scheduler table - all regular tasks should be listed here, along
with how often they should be called (in 20ms units) and the maximum
time they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Rover::scheduler_tasks[] = {
SCHED_TASK(read_radio, 50, 1000),
SCHED_TASK(ahrs_update, 50, 6400),
SCHED_TASK(read_sonars, 50, 2000),
SCHED_TASK(update_current_mode, 50, 1500),
SCHED_TASK(set_servos, 50, 1500),
SCHED_TASK(update_GPS_50Hz, 50, 2500),
SCHED_TASK(update_GPS_10Hz, 10, 2500),
SCHED_TASK(update_alt, 10, 3400),
SCHED_TASK(navigate, 10, 1600),
SCHED_TASK(update_compass, 10, 2000),
SCHED_TASK(update_commands, 10, 1000),
SCHED_TASK(update_logging1, 10, 1000),
SCHED_TASK(update_logging2, 10, 1000),
SCHED_TASK(gcs_retry_deferred, 50, 1000),
SCHED_TASK(gcs_update, 50, 1700),
SCHED_TASK(gcs_data_stream_send, 50, 3000),
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Plane.h"
#define SCHED_TASK(func, rate_hz, max_time_micros) SCHED_TASK_CLASS(Plane, &plane, func, rate_hz, max_time_micros)
/*
scheduler table - all regular tasks are listed here, along with how
often they should be called (in Hz) and the maximum time
they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Plane::scheduler_tasks[] = {
// Units: Hz us
SCHED_TASK(ahrs_update, 400, 400),
SCHED_TASK(read_radio, 50, 100),
SCHED_TASK(check_short_failsafe, 50, 100),
SCHED_TASK(update_speed_height, 50, 200),
SCHED_TASK(update_flight_mode, 400, 100),
SCHED_TASK(stabilize, 400, 100),
SCHED_TASK(set_servos, 400, 100),
SCHED_TASK(read_control_switch, 7, 100),
SCHED_TASK(gcs_retry_deferred, 50, 500),
SCHED_TASK(update_GPS_50Hz, 50, 300),
SCHED_TASK(update_GPS_10Hz, 10, 400),
SCHED_TASK(navigate, 10, 150),
SCHED_TASK(update_compass, 10, 200),
SCHED_TASK(read_airspeed, 10, 100),
SCHED_TASK(update_alt, 10, 200),
SCHED_TASK(adjust_altitude_target, 10, 200),
#include "Tracker.h"
#define FORCE_VERSION_H_INCLUDE
#include "version.h"
#undef FORCE_VERSION_H_INCLUDE
#define SCHED_TASK(func, _interval_ticks, _max_time_micros) SCHED_TASK_CLASS(Tracker, &tracker, func, _interval_ticks, _max_time_micros)
/*
scheduler table - all regular tasks apart from the fast_loop()
should be listed here, along with how often they should be called
(in 20ms units) and the maximum time they are expected to take (in
microseconds)
*/
const AP_Scheduler::Task Tracker::scheduler_tasks[] = {
SCHED_TASK(update_ahrs, 50, 1000),
SCHED_TASK(read_radio, 50, 200),
SCHED_TASK(update_tracking, 50, 1000),
SCHED_TASK(update_GPS, 10, 4000),
SCHED_TASK(update_compass, 10, 1500),
SCHED_TASK_CLASS(AP_BattMonitor, &tracker.battery, read, 10, 1500),
SCHED_TASK_CLASS(AP_Baro, &tracker.barometer, update, 10, 1500),
SCHED_TASK(gcs_update, 50, 1700),
SCHED_TASK(gcs_data_stream_send, 50, 3000),
SCHED_TASK(compass_accumulate, 50, 1500),
SCHED_TASK_CLASS(AP_Baro, &tracker.barometer, accumulate, 50, 900),
SCHED_TASK(ten_hz_logging_loop, 10, 300),
#if LOGGING_ENABLED == ENABLED
SCHED_TASK_CLASS(DataFlash_Class, &tracker.DataFlash, periodic_tasks, 50, 300),
#endif
SCHED_TASK_CLASS(AP_InertialSensor, &tracker.ins, periodic, 50, 50),
* Code commit statistics can be found here: https://github.com/ArduPilot/ardupilot/graphs/contributors
* Wiki: http://copter.ardupilot.org/
*
*/
#include "Copter.h"
#define SCHED_TASK(func, rate_hz, max_time_micros) SCHED_TASK_CLASS(Copter, &copter, func, rate_hz, max_time_micros)
/*
scheduler table for fast CPUs - all regular tasks apart from the fast_loop()
should be listed here, along with how often they should be called (in hz)
and the maximum time they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Copter::scheduler_tasks[] = {
SCHED_TASK(rc_loop, 100, 130),
SCHED_TASK(throttle_loop, 50, 75),
SCHED_TASK(update_GPS, 50, 200),
#if OPTFLOW == ENABLED
SCHED_TASK_CLASS(OpticalFlow, &copter.optflow, update, 200, 160),
#endif
SCHED_TASK(update_batt_compass, 10, 120),
SCHED_TASK_CLASS(RC_Channels, (RC_Channels*)&copter.g2.rc_channels, read_aux_all, 10, 50),
SCHED_TASK(arm_motors_check, 10, 50),
#if TOY_MODE_ENABLED == ENABLED
SCHED_TASK_CLASS(ToyMode, &copter.g2.toy_mode, update, 10, 50),
#endif
SCHED_TASK(auto_disarm_check, 10, 50),
SCHED_TASK(auto_trim, 10, 75),
#if RANGEFINDER_ENABLED == ENABLED
SCHED_TASK(read_rangefinder, 20, 100),
should be listed here, along with how often they should be called
(in 2.5ms units) and the maximum time they are expected to take (in
microseconds)
1 = 400hz
2 = 200hz
4 = 100hz
8 = 50hz
20 = 20hz
40 = 10hz
133 = 3hz
400 = 1hz
4000 = 0.1hz
*/
const AP_Scheduler::Task Copter::scheduler_tasks[] PROGMEM = {
{ SCHED_TASK(rc_loop), 4, 130 },
{ SCHED_TASK(throttle_loop), 8, 75 },
{ SCHED_TASK(update_GPS), 8, 200 },
#if OPTFLOW == ENABLED
{ SCHED_TASK(update_optical_flow), 2, 160 },
#endif
{ SCHED_TASK(update_batt_compass), 40, 120 },
{ SCHED_TASK(read_aux_switches), 40, 50 },
{ SCHED_TASK(arm_motors_check), 40, 50 },
{ SCHED_TASK(auto_trim), 40, 75 },
{ SCHED_TASK(update_altitude), 40, 140 },
{ SCHED_TASK(run_nav_updates), 8, 100 },
{ SCHED_TASK(update_thr_average), 4, 90 },
{ SCHED_TASK(three_hz_loop), 133, 75 },
{ SCHED_TASK(compass_accumulate), 8, 100 },
{ SCHED_TASK(barometer_accumulate), 8, 90 },
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// ArduSub scheduling, originally copied from ArduCopter
#include "Sub.h"
#define SCHED_TASK(func, rate_hz, max_time_micros) SCHED_TASK_CLASS(Sub, &sub, func, rate_hz, max_time_micros)
/*
scheduler table for fast CPUs - all regular tasks apart from the fast_loop()
should be listed here, along with how often they should be called (in hz)
and the maximum time they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Sub::scheduler_tasks[] = {
SCHED_TASK(fifty_hz_loop, 50, 75),
SCHED_TASK(update_GPS, 50, 200),
#if OPTFLOW == ENABLED
SCHED_TASK(update_optical_flow, 200, 160),
#endif
SCHED_TASK(update_batt_compass, 10, 120),
SCHED_TASK(read_rangefinder, 20, 100),
SCHED_TASK(update_altitude, 10, 100),
SCHED_TASK(three_hz_loop, 3, 75),
SCHED_TASK(update_turn_counter, 10, 50),
SCHED_TASK(compass_accumulate, 100, 100),
SCHED_TASK(barometer_accumulate, 50, 90),
SCHED_TASK(update_notify, 50, 90),
SCHED_TASK(one_hz_loop, 1, 100),
SCHED_TASK(gcs_check_input, 400, 180),
SCHED_TASK(gcs_send_heartbeat, 1, 110),
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Plane.h"
#define SCHED_TASK(func, rate_hz, max_time_micros) SCHED_TASK_CLASS(Plane, &plane, func, rate_hz, max_time_micros)
/*
scheduler table - all regular tasks are listed here, along with how
often they should be called (in Hz) and the maximum time
they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Plane::scheduler_tasks[] = {
// Units: Hz us
SCHED_TASK(ahrs_update, 400, 400),
SCHED_TASK(read_radio, 50, 100),
SCHED_TASK(check_short_failsafe, 50, 100),
SCHED_TASK(update_speed_height, 50, 200),
SCHED_TASK(update_flight_mode, 400, 100),
SCHED_TASK(stabilize, 400, 100),
SCHED_TASK(set_servos, 400, 100),
SCHED_TASK(read_control_switch, 7, 100),
SCHED_TASK(update_GPS_50Hz, 50, 300),
SCHED_TASK(update_GPS_10Hz, 10, 400),
SCHED_TASK(navigate, 10, 150),
SCHED_TASK(update_compass, 10, 200),
SCHED_TASK(read_airspeed, 10, 100),
SCHED_TASK(update_alt, 10, 200),
SCHED_TASK(adjust_altitude_target, 10, 200),
SCHED_TASK(afs_fs_check, 10, 100),
#include "Rover.h"
const AP_HAL::HAL& hal = AP_HAL::get_HAL();
Rover rover;
#define SCHED_TASK(func, _interval_ticks, _max_time_micros) SCHED_TASK_CLASS(Rover, &rover, func, _interval_ticks, _max_time_micros)
/*
scheduler table - all regular tasks are listed here, along with how
often they should be called (in Hz) and the maximum time
they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Rover::scheduler_tasks[] = {
// Function name, Hz, us,
SCHED_TASK(read_radio, 50, 200),
SCHED_TASK(ahrs_update, 50, 1500),
SCHED_TASK(read_rangefinders, 50, 200),
SCHED_TASK(update_current_mode, 50, 200),
SCHED_TASK(set_servos, 50, 200),
SCHED_TASK(update_GPS, 50, 300),
SCHED_TASK_CLASS(AP_Baro, &rover.barometer, update, 10, 200),
SCHED_TASK_CLASS(AP_Beacon, &rover.g2.beacon, update, 50, 200),
SCHED_TASK_CLASS(AP_Proximity, &rover.g2.proximity, update, 50, 200),
SCHED_TASK(update_visual_odom, 50, 200),
SCHED_TASK(update_wheel_encoder, 20, 200),
SCHED_TASK(update_compass, 10, 200),
SCHED_TASK(update_mission, 50, 200),
SCHED_TASK(update_logging1, 10, 200),
SCHED_TASK(update_logging2, 10, 200),
SCHED_TASK(gcs_retry_deferred, 50, 1000),
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Plane.h"
#define SCHED_TASK(func) FUNCTOR_BIND(&plane, &Plane::func, void)
/*
scheduler table - all regular tasks are listed here, along with how
often they should be called (in 20ms units) and the maximum time
they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Plane::scheduler_tasks[] PROGMEM = {
{ SCHED_TASK(read_radio), 1, 700 }, // 0
{ SCHED_TASK(check_short_failsafe), 1, 1000 },
{ SCHED_TASK(ahrs_update), 1, 6400 },
{ SCHED_TASK(update_speed_height), 1, 1600 },
{ SCHED_TASK(update_flight_mode), 1, 1400 },
{ SCHED_TASK(stabilize), 1, 3500 },
{ SCHED_TASK(set_servos), 1, 1600 },
{ SCHED_TASK(read_control_switch), 7, 1000 },
{ SCHED_TASK(gcs_retry_deferred), 1, 1000 },
{ SCHED_TASK(update_GPS_50Hz), 1, 2500 },
{ SCHED_TASK(update_GPS_10Hz), 5, 2500 }, // 10
{ SCHED_TASK(navigate), 5, 3000 },
{ SCHED_TASK(update_compass), 5, 1200 },
{ SCHED_TASK(read_airspeed), 5, 1200 },
{ SCHED_TASK(update_alt), 5, 3400 },
{ SCHED_TASK(adjust_altitude_target), 5, 1000 },
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// ArduSub scheduling, originally copied from ArduCopter
#include "Sub.h"
#define SCHED_TASK(func, rate_hz, max_time_micros) SCHED_TASK_CLASS(Sub, &sub, func, rate_hz, max_time_micros)
/*
scheduler table for fast CPUs - all regular tasks apart from the fast_loop()
should be listed here, along with how often they should be called (in hz)
and the maximum time they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Sub::scheduler_tasks[] = {
SCHED_TASK(rc_loop, 100, 130),
SCHED_TASK(throttle_loop, 50, 75),
SCHED_TASK(update_GPS, 50, 200),
#if OPTFLOW == ENABLED
SCHED_TASK(update_optical_flow, 200, 160),
#endif
SCHED_TASK(update_batt_compass, 10, 120),
SCHED_TASK(read_aux_switches, 10, 50),
SCHED_TASK(auto_disarm_check, 10, 50),
SCHED_TASK(auto_trim, 10, 75),
SCHED_TASK(read_rangefinder, 20, 100),
SCHED_TASK(update_altitude, 10, 100),
SCHED_TASK(run_nav_updates, 50, 100),
SCHED_TASK(three_hz_loop, 3, 75),
SCHED_TASK(update_turn_counter, 10, 50),
SCHED_TASK(compass_accumulate, 100, 100),
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// ArduSub scheduling, originally copied from ArduCopter
#include "Sub.h"
#define SCHED_TASK(func, rate_hz, max_time_micros) SCHED_TASK_CLASS(Sub, &sub, func, rate_hz, max_time_micros)
/*
scheduler table for fast CPUs - all regular tasks apart from the fast_loop()
should be listed here, along with how often they should be called (in hz)
and the maximum time they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Sub::scheduler_tasks[] = {
SCHED_TASK(fifty_hz_loop, 50, 75),
SCHED_TASK(update_GPS, 50, 200),
#if OPTFLOW == ENABLED
SCHED_TASK_CLASS(OpticalFlow, &sub.optflow, update, 200, 160),
#endif
SCHED_TASK(update_batt_compass, 10, 120),
SCHED_TASK(read_rangefinder, 20, 100),
SCHED_TASK(update_altitude, 10, 100),
SCHED_TASK(three_hz_loop, 3, 75),
SCHED_TASK(update_turn_counter, 10, 50),
SCHED_TASK_CLASS(AP_Baro, &sub.barometer, accumulate, 50, 90),
SCHED_TASK_CLASS(AP_Notify, &sub.notify, update, 50, 90),
SCHED_TASK(one_hz_loop, 1, 100),
SCHED_TASK_CLASS(GCS, (GCS*)&sub._gcs, update, 400, 180),
SCHED_TASK(gcs_send_heartbeat, 1, 110),
SCHED_TASK_CLASS(GCS, (GCS*)&sub._gcs, retry_deferred, 50, 550),
void ins_update(void);
void one_hz_print(void);
void five_second_call(void);
};
static SchedTest schedtest;
#define SCHED_TASK(func) FUNCTOR_BIND(&schedtest, &SchedTest::func, void)
/*
scheduler table - all regular tasks are listed here, along with how
often they should be called (in 20ms units) and the maximum time
they are expected to take (in microseconds)
*/
const AP_Scheduler::Task SchedTest::scheduler_tasks[] PROGMEM = {
{ SCHED_TASK(ins_update), 1, 1000 },
{ SCHED_TASK(one_hz_print), 50, 1000 },
{ SCHED_TASK(five_second_call), 250, 1800 },
};
void SchedTest::setup(void)
{
// we
ins.init(AP_InertialSensor::COLD_START,
AP_InertialSensor::RATE_50HZ);
// initialise the scheduler
scheduler.init(&scheduler_tasks[0], ARRAY_SIZE(scheduler_tasks));
}
#define SCHED_TASK(func, _interval_ticks, _max_time_micros) {\
.function = FUNCTOR_BIND(&tracker, &Tracker::func, void),\
AP_SCHEDULER_NAME_INITIALIZER(func)\
.interval_ticks = _interval_ticks,\
.max_time_micros = _max_time_micros,\
}
/*
scheduler table - all regular tasks apart from the fast_loop()
should be listed here, along with how often they should be called
(in 20ms units) and the maximum time they are expected to take (in
microseconds)
*/
const AP_Scheduler::Task Tracker::scheduler_tasks[] PROGMEM = {
SCHED_TASK(update_ahrs, 1, 1000),
SCHED_TASK(read_radio, 1, 200),
SCHED_TASK(update_tracking, 1, 1000),
SCHED_TASK(update_GPS, 5, 4000),
SCHED_TASK(update_compass, 5, 1500),
SCHED_TASK(update_barometer, 5, 1500),
SCHED_TASK(gcs_update, 1, 1700),
SCHED_TASK(gcs_data_stream_send, 1, 3000),
SCHED_TASK(compass_accumulate, 1, 1500),
SCHED_TASK(barometer_accumulate, 1, 900),
SCHED_TASK(update_notify, 1, 100),
SCHED_TASK(check_usb_mux, 5, 300),
SCHED_TASK(gcs_retry_deferred, 1, 1000),
SCHED_TASK(one_second_loop, 50, 3900),
SCHED_TASK(compass_cal_update, 1, 100),
};
const AP_HAL::HAL& hal = AP_HAL_BOARD_DRIVER;
Rover rover;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpmf-conversions"
#define SCHED_TASK(func) FUNCTOR_BIND_VOID(&rover, &Rover::func, void)
/*
scheduler table - all regular tasks should be listed here, along
with how often they should be called (in 20ms units) and the maximum
time they are expected to take (in microseconds)
*/
const AP_Scheduler::Task Rover::scheduler_tasks[] PROGMEM = {
{ SCHED_TASK(read_radio), 1, 1000 },
{ SCHED_TASK(ahrs_update), 1, 6400 },
{ SCHED_TASK(read_sonars), 1, 2000 },
{ SCHED_TASK(update_current_mode), 1, 1500 },
{ SCHED_TASK(set_servos), 1, 1500 },
{ SCHED_TASK(update_GPS_50Hz), 1, 2500 },
{ SCHED_TASK(update_GPS_10Hz), 5, 2500 },
{ SCHED_TASK(update_alt), 5, 3400 },
{ SCHED_TASK(navigate), 5, 1600 },
{ SCHED_TASK(update_compass), 5, 2000 },
{ SCHED_TASK(update_commands), 5, 1000 },
{ SCHED_TASK(update_logging1), 5, 1000 },
{ SCHED_TASK(update_logging2), 5, 1000 },
{ SCHED_TASK(gcs_retry_deferred), 1, 1000 },
{ SCHED_TASK(gcs_update), 1, 1700 },
{ SCHED_TASK(gcs_data_stream_send), 1, 3000 },
