Struct ControllerCtx 

#[non_exhaustive]
pub struct ControllerCtx {

    pub op_name: String,
    pub op_dir: PathBuf,
    pub dt_ns: u32,
    pub timeout_to_operating_ns: u32,
    pub binding_timeout_ms: u16,
    pub configuring_timeout_ms: u16,
    pub peripheral_loss_of_contact_limit: u16,
    pub controller_loss_of_contact_limit: u16,
    pub termination_criteria: Option<Termination>,
    pub loss_of_contact_policy: LossOfContactPolicy,
    pub loop_method: LoopMethod,
    pub user_ctx: BTreeMap<String, String>,
    pub user_channels: Arc<RwLock<BTreeMap<String, Channel>>>,
    pub manual_inputs: ManualInputMap,
    pub enable_manual_inputs: bool,
    pub channel_units: Vec<Option<String>>,
    pub calibration_offline_only: bool,
    pub calibration_local_sources: Vec<PathBuf>,
    pub calibration_allow_missing: bool,
    pub use_no_calibrations: bool,
}

Operation context, provided to appendages during init

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

op_name: String

A name for this controller op, which will be used as the name of the file/table/bucket/etc of each data dispatcher and must be compatible with that use.

op_dir: PathBuf

A directory to find file inputs and place outputs.

dt_ns: u32

Control cycle period in nanoseconds

timeout_to_operating_ns: u32

Delay from end of configuration window after which the peripherals time out to the Operating state

binding_timeout_ms: u16

Duration to wait for responses to binding

configuring_timeout_ms: u16

Duration for peripherals to wait to receive configuration after being bound

peripheral_loss_of_contact_limit: u16

Number of consecutive missed control inputs after which the peripheral should assume contact has been lost, de-energize their outputs, and wait to bind a controller again.

controller_loss_of_contact_limit: u16

Number of consecutive missed responses from a peripheral after which the controller should assume contact has been lost

termination_criteria: Option<Termination>

A condition for exiting the control loop, to be checked at each cycle

loss_of_contact_policy: LossOfContactPolicy

Response to losing contact with a peripheral

loop_method: LoopMethod

Whether to prioritize performance or efficiency in the control loop.

user_ctx: BTreeMap<String, String>

An escape hatch for sideloading user context (likely json-encoded) that is not yet implemented as a standalone field.

user_channels: Arc<RwLock<BTreeMap<String, Channel>>>

An escape hatch for sideloading communication between appendages. Each channel is a bidirectional MPMC message pipe.

Because bidirectional channels may not close until the program terminates on its own, the status of these channels should not be used to indicate when a freerunning thread should terminate, as this will often result in a resource leak.

manual_inputs: ManualInputMap

Manual input overrides that can be written while the controller is running.

enable_manual_inputs: bool

Whether manual input overrides should be applied during the control loop.

channel_units: Vec<Option<String>>

Units for each dispatched channel, in the same order as channel_names. None indicates the unit is unknown or dimensionless. Populated by the controller assembly pass before dispatchers are initialized. #[serde(default)] so snapshots serialized before this field was added deserialize to an empty Vec and are re-populated by the assembly pass.

calibration_offline_only: bool

Whether calibration lookup should be restricted to local stores.

When true, the controller will not attempt to retrieve calibration records from deimoscontrols.com.

calibration_local_sources: Vec<PathBuf>

Additional local calibration stores to search after the default user cache.

Each path is treated as the root of a calibration tree, so a peripheral with slug kind/sn is looked up at <path>/kind/sn/cal.json.

calibration_allow_missing: bool

Whether missing calibration records should fall back to peripheral defaults.

This defaults to true to preserve the historical behavior where standard calcs were built with an empty calibration string. Applications that require explicit calibration records should set this to false.

use_no_calibrations: bool

Whether peripherals should ignore discovered calibration records.

When true, the controller always passes Peripheral::default_cals() to standard_calcs(). This is useful for calibration procedures that need to generate a new calibration record even when an older one exists in a local or remote store.

Implementations

impl ControllerCtx

pub fn source_endpoint(&self, channel_name: &str) -> Endpoint

Get a handle to a source endpoint tx/rx pair for the channel, creating the channel if it does not exist.

Examples found in repository

examples/sideloading.rs (line 116)

    fn init(
        &mut self,
        ctx: ControllerCtx,
        _input_indices: Vec<usize>,
        output_range: Range<usize>,
    ) -> Result<(), String> {
        self.output_index = output_range.clone().next().unwrap();
        self.endpoint = ctx.source_endpoint(&self.channel_name);
        self.prefix = ctx.user_ctx.get("speaker_prefix").unwrap().to_owned();
        Ok(())
    }

pub fn sink_endpoint(&self, channel_name: &str) -> Endpoint

Get a handle to a sink endpoint tx/rx pair for the channel, creating the channel if it does not exist.

Examples found in repository

examples/sideloading.rs (line 199)

    fn init(
        &mut self,
        ctx: ControllerCtx,
        _input_indices: Vec<usize>,
        output_range: Range<usize>,
    ) -> Result<(), String> {
        self.output_index = output_range.clone().next().unwrap();
        self.endpoint = ctx.sink_endpoint(&self.channel_name);
        Ok(())
    }

Trait Implementations

impl Clone for ControllerCtx

fn clone(&self) -> ControllerCtx

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ControllerCtx

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ControllerCtx

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ControllerCtx

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ControllerCtx

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.