Struct ThrottleRecord 

pub struct ThrottleRecord {

    pub val: f64,
    pub oval: f64,
    pub sent: f64,
    pub osent: f64,
    pub wait: i16,
    pub hopr: f64,
    pub lopr: f64,
    pub drvlh: f64,
    pub drvll: f64,
    pub drvls: i16,
    pub drvlc: i16,
    pub ver: String,
    pub sts: i16,
    pub prec: i16,
    pub dprec: i16,
    pub dly: f64,
    pub out: String,
    pub ov: i16,
    pub sinp: String,
    pub siv: i16,
    pub sync: i16,
    /* private fields */
}

Throttle record — rate-limits value changes to prevent device damage.

Ported from EPICS std module throttleRecord.c.

When VAL is written, the record checks drive limits, optionally clips the value, sets WAIT=True, then writes SENT to the OUT link only after the minimum delay (DLY) has elapsed since the last output. If a new value arrives during the delay, it queues the latest value and sends it when the delay expires.

Fields

val: f64

Set value (VAL)

oval: f64

Previous set value (OVAL), read-only

sent: f64

Last sent value (SENT), read-only

osent: f64

Previous sent value (OSENT), read-only

wait: i16

Busy flag (WAIT): 0=False, 1=True, read-only

hopr: f64

High operating range (HOPR)

lopr: f64

Low operating range (LOPR)

drvlh: f64

High drive limit (DRVLH)

drvll: f64

Low drive limit (DRVLL)

drvls: i16

Limit status: 0=Normal, 1=Low, 2=High (DRVLS), read-only

drvlc: i16

Limit clipping: 0=Off, 1=On (DRVLC)

ver: String

Code version string (VER), read-only

sts: i16

Record status: 0=Unknown, 1=Error, 2=Success (STS), read-only

prec: i16

Display precision (PREC)

dprec: i16

Delay display precision (DPREC)

dly: f64

Delay between outputs in seconds (DLY)

out: String

Output link (OUT)

ov: i16

Output link valid: 0=ExtNC, 1=Ext, 2=Local, 3=Constant (OV), read-only

sinp: String

Sync input link (SINP)

siv: i16

Sync input link valid (SIV), read-only

sync: i16

Sync trigger: 0=Idle, 1=Process (SYNC)

Trait Implementations

impl Default for ThrottleRecord

fn default() -> Self

Returns the “default value” for a type.

impl Record for ThrottleRecord

fn record_type(&self) -> &'static str

Return the record type name (e.g., “ai”, “ao”, “bi”).

fn pre_process_actions(&mut self) -> Vec<ProcessAction>

Return pre-process actions (ReadDbLink) that the framework should execute BEFORE calling process(). This is called once per cycle. Default returns empty. Override in records that need link reads to be available during process().

fn process(&mut self) -> CaResult<ProcessOutcome>

Process the record (scan/compute cycle).

fn can_device_write(&self) -> bool

Whether this record type supports device write (output records only).

fn special(&mut self, field: &str, after: bool) -> CaResult<()>

Called before/after a field put for side-effect processing.

fn get_field(&self, name: &str) -> Option<EpicsValue>

Get a field value by name.

fn put_field(&mut self, name: &str, value: EpicsValue) -> CaResult<()>

Set a field value by name.

fn field_list(&self) -> &'static [FieldDesc]

Return the list of field descriptors.

fn init_record(&mut self, pass: u8) -> CaResult<()>

Initialize record (pass 0: field defaults; pass 1: dependent init).

fn validate_put(&self, _field: &str, _value: &EpicsValue) -> Result<(), CaError>

Validate a put before it is applied. Return Err to reject.

fn on_put(&mut self, _field: &str)

Hook called after a successful put_field.

fn primary_field(&self) -> &'static str

Primary field name (default “VAL”). Override for waveform etc.

fn val(&self) -> Option<EpicsValue>

Get the primary value.

fn set_val(&mut self, value: EpicsValue) -> Result<(), CaError>

Set the primary value.

fn is_put_complete(&self) -> bool

Whether async processing has completed and put_notify can respond. Records that return AsyncPendingNotify should return false while async work is in progress, and true when done. Default: true (synchronous records are always complete).

fn should_fire_forward_link(&self) -> bool

Whether this record should fire its forward link after processing.

fn should_output(&self) -> bool

Whether this record’s OUT link should be written after processing. Defaults to true. Override in calcout to implement OOPT conditional output.

fn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>

Downcast to concrete type for device support init injection. Override in record types that need device support to inject state (e.g., MotorRecord).

fn clears_udf(&self) -> bool

Whether processing this record should clear UDF. Override to return false for record types that don’t produce a valid value every cycle.

fn multi_input_links(&self) -> &[(&'static str, &'static str)]

Return multi-input link field pairs: (link_field, value_field). Override in calc, calcout, sel, sub to return INPA..INPL → A..L mappings.

fn multi_output_links(&self) -> &[(&'static str, &'static str)]

Return multi-output link field pairs: (link_field, value_field). Override in transform to return OUTA..OUTP → A..P mappings.

fn put_field_internal( &mut self, name: &str, value: EpicsValue, ) -> Result<(), CaError>

Internal field write that bypasses read-only checks. Used by the framework to write values from ReadDbLink actions into fields that are normally read-only (e.g., epid.CVAL). Default implementation delegates to put_field().

fn set_device_did_compute(&mut self, _did_compute: bool)

Called by the framework before process() to indicate whether device support’s read() already performed the record’s compute step. Override in records that have a built-in compute (e.g., epid PID) to skip it when device support already ran it. Default: ignore.