Struct World 

pub struct World<B, E, C, M, CI, PD, R: FlightFloat>
where
    B: BoardIo,
    E: Estimator<R>,
    C: Controller<R, State = E::State> + RcTrimCalibrator,
    M: Mixer<R, MixerInput = C::ControlOutput>,
    M::ActuatorCommands: AsRef<[R]> + Copy,
    E::State: Copy + Default,
    CI: CommInterface<B>,
    PD: PwmDriver<R>,
{ /* private fields */ }

Implementations

impl<B, E, C, M, CI, PD, R> World<B, E, C, M, CI, PD, R>

where B: BoardIo, E: Estimator<R>, C: Controller<R, State = E::State> + RcTrimCalibrator, M: Mixer<R, MixerInput = C::ControlOutput>, M::ActuatorCommands: AsRef<[R]> + Copy, E::State: Copy + Default, CI: CommInterface<B>, PD: PwmDriver<R>, R: FlightFloat,

pub fn run_once(&mut self) -> bool

pub fn set_telemetry_rates(&mut self, telemetry_rates: TelemetryRates)

pub fn set_control_loop_rates(&mut self, control_loop_rates: ControlLoopRates)

pub fn set_test_pin_3(&mut self, high: bool)

pub fn set_test_pin_2(&mut self, high: bool)

pub fn run_comm_param_sensor_stages(&mut self)

pub fn imu_pending(&self) -> bool

pub fn realtime_scheduler_step(&self) -> RealtimeSchedulerStep

pub fn run_imu_control_tick(&mut self) -> bool

pub fn run_control_update_tick(&mut self) -> bool

pub fn run_rc_command_state_stages(&mut self, fresh_rc: Option<RcPacket>)

pub fn run_pwm_output_stage(&mut self) -> bool

pub fn run_control_stages_if_new_imu(&mut self) -> bool

pub fn run_control_and_mixing_stage_if_new_imu(&mut self) -> bool

impl<B, E, C, M, CI, PD, R> World<B, E, C, M, CI, PD, R>

where B: BoardIo, E: Estimator<R>, C: Controller<R, State = E::State> + RcTrimCalibrator, M: Mixer<R, MixerInput = C::ControlOutput>, M::ActuatorCommands: AsRef<[R]> + Copy, E::State: Copy + Default, CI: CommInterface<B>, PD: PwmDriver<R>, R: FlightFloat,

pub fn run_prioritized_service_steps_with_policy( &mut self, policy: RealtimeServicePolicy, ) -> WorldReport

pub fn run_communication_and_parameter_service_stage(&mut self)

pub fn run_sensor_ingestion_and_health_stage(&mut self)

impl<B, E, C, M, CI, PD, R> World<B, E, C, M, CI, PD, R>

where B: BoardIo, E: Estimator<R>, C: Controller<R, State = E::State> + RcTrimCalibrator, M: Mixer<R, MixerInput = C::ControlOutput>, M::ActuatorCommands: AsRef<[R]> + Copy, E::State: Copy + Default, CI: CommInterface<B>, PD: PwmDriver<R>, R: FlightFloat,

pub fn run_telemetry_stage(&mut self)

pub fn run_realtime_telemetry_stage_budgeted( &mut self, max_streams: usize, ) -> usize

Sends up to max_streams currently due named telemetry streams.

Board realtime loops may call this after a completed control update when hardware timing shows enough post-control slack and service phases alone do not provide enough telemetry scheduling opportunities. Keep the budget board-specific and validate the resulting control p99/max timing with scope pins before making it a production default.

pub fn run_realtime_telemetry_stage_with_available_slack(&mut self) -> usize

Sends due streams until there is no work left or the measured control slack reaches the board’s safety margin. The slack check occurs between individual streams, so this never turns an arbitrary stream count into a scheduling bottleneck.

pub fn run_realtime_telemetry_stage_prioritized( &mut self, priority_streams: &[RealtimeTelemetryPriority], max_streams: usize, ) -> usize

Sends board-selected priority streams first, then fills the remaining budget normally.

priority_streams is a board policy list. Core applies each stream’s configured priority gate, so boards can choose normal due-deadline behavior or a stricter freshness gate for streams paced by the control tick.

impl<B, E, C, M, CI, PD, R> World<B, E, C, M, CI, PD, R>

where B: BoardIo, E: Estimator<R>, C: Controller<R, State = E::State> + RcTrimCalibrator, M: Mixer<R, MixerInput = C::ControlOutput>, M::ActuatorCommands: AsRef<[R]> + Copy, E::State: Copy + Default, CI: CommInterface<B>, PD: PwmDriver<R>, R: FlightFloat,

pub fn init( board: B, params: Params, comm_link: CI, state: StateManager, estimator: E, controller: C, mixer: M, pwm: PD, ) -> Self