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>>,
}

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.

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 113)

    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 196)

    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.