Struct EpidFastDeviceSupport 

pub struct EpidFastDeviceSupport { /* private fields */ }

Fast Epid device support using asyn driver for high-speed (1+ kHz) PID.

Ported from devEpidFast.c. The PID computation runs in a background tokio task driven by asyn interrupt callbacks, not during record processing. The record merely copies parameters to/from the fast computation thread.

Architecture

┌─────────────┐    interrupt     ┌──────────────────┐
│ asyn driver  │ ──────────────► │ PID callback task │
│ (input ADC)  │    (new cval)   │  (tokio::spawn)   │
└─────────────┘                  │  runs do_pid()    │
                                 │  writes output    │
      ┌──────────────────────────┤  to output driver │
      │  shared EpidFastPvt      └──────────────────┘
      │  (Arc<Mutex>)                    ▲
      ▼                                  │
┌─────────────┐  read()         params   │
│ EpidRecord   │ ◄─────── copy ──────────┘
│ (process)    │ ────────► copy ──────────►
└─────────────┘  results

The start_callback_loop() method spawns the background task. Call it after connecting to the asyn input port.

Implementations

impl EpidFastDeviceSupport

pub fn new() -> Self

pub fn pvt(&self) -> Arc<Mutex<EpidFastPvt>>

Get a handle to the shared PID state for callback registration.

pub fn start_callback_loop( &self, input_rx: Receiver<f64>, output_fn: Arc<Mutex<dyn FnMut(f64) + Send>>, )

Start the interrupt-driven PID callback loop.

Spawns a tokio task that receives new readback values from input_rx and runs do_pid() on each. This is the high-speed PID path that runs at the interrupt rate (1kHz+), independent of record processing.

input_rx: receives new controlled-variable values from the input driver output_fn: called with each new output value (writes to output driver)

pub fn start_from_asyn_interrupts( &self, interrupt_rx: Receiver<InterruptValue>, input_reason: usize, output_fn: Arc<Mutex<dyn FnMut(f64) + Send>>, )

Start from an asyn interrupt subscription.

Subscribes to Float64 interrupts from the given broadcast sender and feeds them into the PID callback loop.

Trait Implementations

impl Default for EpidFastDeviceSupport

fn default() -> Self

Returns the “default value” for a type.

impl DeviceSupport for EpidFastDeviceSupport

fn dtyp(&self) -> &str

fn read(&mut self, record: &mut dyn Record) -> CaResult<DeviceReadOutcome>

Read from hardware into the record.

fn write(&mut self, _record: &mut dyn Record) -> CaResult<()>

fn init(&mut self, _record: &mut (dyn Record + 'static)) -> Result<(), CaError>

fn last_alarm(&self) -> Option<(u16, u16)>

Return the last alarm (status, severity) from the driver. None means the driver does not override alarms.

fn last_timestamp(&self) -> Option<SystemTime>

Return the last timestamp from the driver. None means the driver does not override timestamps.

fn set_record_info(&mut self, _name: &str, _scan: ScanType)

Called after init() with the record name and scan type.

fn io_intr_receiver(&mut self) -> Option<Receiver<()>>

Return a receiver for I/O Intr scan notifications. Only called for records with SCAN=I/O Intr.

fn write_begin( &mut self, _record: &mut (dyn Record + 'static), ) -> Result<Option<Box<dyn WriteCompletion>>, CaError>

Begin an asynchronous write (submit only, no blocking). Returns Some(handle) if the write was submitted to a worker queue — the caller should wait on the handle outside any record lock. Returns None to fall back to synchronous write().

fn handle_command( &mut self, _record: &mut (dyn Record + 'static), _command: &str, _args: &[EpicsValue], ) -> Result<(), CaError>

Handle a named command from the record’s process() via ProcessAction::DeviceCommand. This allows records to request driver operations (e.g., scaler reset/arm/write_preset) without holding a direct driver reference.