ardupilot/libraries/AP_Scheduler/AP_Scheduler.h

113 lines
3.1 KiB
C
Raw Normal View History

/// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
/*
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/>.
*/
/*
* main loop scheduler for APM
* Author: Andrew Tridgell, January 2013
*
*/
#ifndef AP_SCHEDULER_H
#define AP_SCHEDULER_H
#include <AP_Param/AP_Param.h>
#define AP_SCHEDULER_NAME_INITIALIZER(_name) .name = #_name,
/*
A task scheduler for APM main loops
Sketches should call scheduler.init() on startup, then call
2015-05-24 16:04:34 -03:00
scheduler.tick() at regular intervals (typically every 10ms).
To run tasks use scheduler.run(), passing the amount of time that
the scheduler is allowed to use before it must return
*/
#include <AP_HAL/AP_HAL.h>
#include <AP_Vehicle/AP_Vehicle.h>
class AP_Scheduler
{
public:
2015-05-24 18:55:06 -03:00
FUNCTOR_TYPEDEF(task_fn_t, void);
2015-05-24 16:04:34 -03:00
struct Task {
task_fn_t function;
const char *name;
2015-05-24 16:04:34 -03:00
uint16_t interval_ticks;
uint16_t max_time_micros;
};
2015-05-24 16:04:34 -03:00
// initialise scheduler
void init(const Task *tasks, uint8_t num_tasks);
2015-05-24 16:04:34 -03:00
// call when one tick has passed
void tick(void);
2015-05-24 16:04:34 -03:00
// run the tasks. Call this once per 'tick'.
// time_available is the amount of time available to run
// tasks in microseconds
void run(uint16_t time_available);
2015-05-24 16:04:34 -03:00
// return the number of microseconds available for the current task
uint16_t time_available_usec(void);
2013-01-11 21:06:55 -04:00
// return debug parameter
uint8_t debug(void) { return _debug; }
// return load average, as a number between 0 and 1. 1 means
// 100% load. Calculated from how much spare time we have at the
// end of a run()
float load_average(uint32_t tick_time_usec) const;
2015-05-24 16:04:34 -03:00
static const struct AP_Param::GroupInfo var_info[];
// current running task, or -1 if none. Used to debug stuck tasks
static int8_t current_task;
private:
2015-05-24 16:04:34 -03:00
// used to enable scheduler debugging
AP_Int8 _debug;
// progmem list of tasks to run
const struct Task *_tasks;
// number of tasks in _tasks list
uint8_t _num_tasks;
// number of 'ticks' that have passed (number of times that
// tick() has been called
uint16_t _tick_counter;
// tick counter at the time we last ran each task
uint16_t *_last_run;
// number of microseconds allowed for the current task
uint32_t _task_time_allowed;
// the time in microseconds when the task started
uint32_t _task_time_started;
// number of spare microseconds accumulated
uint32_t _spare_micros;
// number of ticks that _spare_micros is counted over
uint8_t _spare_ticks;
};
#endif // AP_SCHEDULER_H