Struct Scheduler

pub struct Scheduler<'a, C, T, E = Error> {
    pub tasks: &'a mut [Task<T, E>],
    pub clock: C,
    pub tick: u16,
    pub max_task_slowdown: u8,
    pub loop_rate_hz: i16,
    pub task_not_achieved: u32,
    pub task_all_achieved: u32,
    pub loop_timer_start_us: u32,
    pub last_loop_time_s: f32,
    pub extra_loop_us: u32,
    /* private fields */
}

Task scheduler for flight controllers

Fields

tasks: &'a mut [Task<T, E>]

The tasks to run in order of highest to lowest priority.

clock: C

The clock used for timing.

tick: u16

The current tick, incremented each run.

max_task_slowdown: u8

The maximum amount of ticks a task can miss before slowing down the scheduler.

loop_rate_hz: i16

The desired loop rate to run (in hz).

task_not_achieved: u32

The amount of ticks with tasks that exceed the max_task_slowdown.

task_all_achieved: u32

The amount of ticks with tasks that remain in the max_task_slowdown.

loop_timer_start_us: u32

The start time of the run loop (in microseconds).

last_loop_time_s: f32

The start time of the run loop (in seconds).

extra_loop_us: u32

Extra time to spend in the loop to catch up on tasks not achieved (in microseconds).

Implementations

impl<'a, C, T, E> Scheduler<'a, C, T, E>

where C: Clock, C::T: ToPrimitive, E: From<Error>,

pub fn new(tasks: &'a mut [Task<T, E>], clock: C, loop_rate_hz: i16) -> Self

Create a new scheduler from a slice of tasks, a clock, and the loop rate (in hz)

pub fn run(&mut self, state: &mut T) -> Result<(), E>

Calculate the time available and run as many tasks as possible.

pub fn run_with_time_available( &mut self, system: &mut T, time_available: u32, ) -> Result<(), E>

Run as many tasks as possible in the given time_available.