Struct ControlRunner 

pub struct ControlRunner<P: ControlProgram> { /* private fields */ }

The main execution engine for control programs.

ControlRunner handles all the infrastructure required to run a control program:

• Connecting to the autocore-server via IPC
• Opening and mapping shared memory
• Setting up synchronization signals
• Running the real-time control loop
• Sending log messages to the server

Usage

use autocore_std::{ControlRunner, RunnerConfig};

let config = RunnerConfig {
    shm_name: "my_project_shm".to_string(),
    tick_signal_name: "tick".to_string(),
    ..Default::default()
};

ControlRunner::new(MyProgram::new())
    .config(config)
    .run()?;  // Blocks forever

Control Loop

The runner executes a synchronous control loop:

1. Wait - Blocks until the tick signal is set by the server
2. Read - Copies shared memory to a local buffer (acquire barrier)
3. Execute - Calls your process_tick method
4. Write - Copies local buffer back to shared memory (release barrier)
5. Signal - Sets the busy signal (if configured) to indicate completion

This ensures your code always sees a consistent snapshot of the data and that your writes are atomically visible to other processes.

Implementations

impl<P: ControlProgram> ControlRunner<P>

pub fn new(program: P) -> Self

Creates a new runner for the given control program.

Uses default configuration. Call .config() to customize.

Arguments

• program - Your control program instance

Example

let runner = ControlRunner::new(MyProgram::new());

pub fn config(self, config: RunnerConfig) -> Self

Sets the configuration for this runner.

Arguments

• config - The configuration to use

Example

ControlRunner::new(MyProgram::new())
    .config(RunnerConfig {
        shm_name: "custom_shm".to_string(),
        ..Default::default()
    })
    .run()?;

pub fn run(self) -> Result<()>

Starts the control loop.

This method blocks indefinitely, running the control loop until an error occurs or the process is terminated.

Returns

Returns Ok(()) only if the loop exits cleanly (which typically doesn’t happen). Returns an error if:

• IPC connection fails
• Shared memory cannot be opened
• Signal offsets cannot be found
• A critical error occurs during execution

Example

fn main() -> anyhow::Result<()> {
    ControlRunner::new(MyProgram::new())
        .config(config)
        .run()
}