Struct embedded_flight::scheduler::Task

pub struct Task<T, E = Error> {
    pub f: fn(_: Event<'_, T>) -> Result<(), E>,
    pub hz: f32,
    pub max_time_micros: u16,
    pub is_high_priority: bool,
    pub last_run: u16,
}

A task to run at specific frequency

Fields

f: fn(_: Event<'_, T>) -> Result<(), E>

The function to run.

hz: f32

The desired frequency (in hz) to run the task.

max_time_micros: u16

The max time for this task (in microseconds).

is_high_priority: bool

Determines if this task should be run every time the scheduler loops.

last_run: u16

The last tick this task was ran.

Implementations

impl<T, E> Task<T, E>

pub fn new(f: fn(_: Event<'_, T>) -> Result<(), E>) -> Self

Create a new task from the function to run.

pub fn high_priority(f: fn(_: Event<'_, T>) -> Result<(), E>) -> Self

Create a new high priority task from the function to run.

pub fn with_hz(self, hz: f32) -> Self

Builder method to set hz and return self

pub fn with_max_time(self, micros: u16) -> Self

Builder method to set max_time_micros and return self

pub fn with_high_priority(self, is_high_priority: bool) -> Self

Builder method to set is_high_priority and return self

pub fn ticks(&self, loop_rate_hz: i16) -> i16

Calculate the desired ticks between each run of the task

pub fn ready(&self, current_tick: u16, ticks: i16) -> Option<u16>

If this task is ready returns the ticks elapsed since the last run. Otherwise this returns None.

pub fn run(&mut self, state: Event<'_, T>, tick: u16) -> Result<(), E>

Run this task at the current tick.