asyn-rs 0.6.1

Rust port of EPICS asyn - async device I/O framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! GPIB (IEEE-488) interface definitions.

use crate::error::AsynResult;
use crate::user::AsynUser;

/// GPIB addressed commands (require device address).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GpibCommand {
    /// Group Execute Trigger
    GET,
    /// Go To Local
    GTL,
    /// Selected Device Clear
    SDC,
    /// Serial Poll Disable
    SPD,
    /// Serial Poll Enable
    SPE,
    /// Take Control Synchronous
    TCTSynch,
    /// Take Control Asynchronous
    TCTAsync,
    /// Unlisten
    UNL,
    /// Untalk
    UNT,
}

/// GPIB universal commands (no device address needed).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GpibUniversalCommand {
    /// Device Clear (all devices)
    DCL,
    /// Local Lockout
    LLO,
    /// Serial Poll Disable
    SPD,
    /// Serial Poll Enable
    SPE,
    /// Interface Clear
    IFC,
    /// Remote Enable
    REN,
}

/// SRQ (Service Request) status.
#[derive(Debug, Clone)]
pub struct SrqStatus {
    /// Whether SRQ is currently asserted.
    pub srq_asserted: bool,
    /// Status byte from serial poll (if available).
    pub status_byte: Option<u8>,
}

/// GPIB interface trait.
///
/// Provides IEEE-488 bus control operations for GPIB-capable drivers.
pub trait AsynGpib: Send + Sync {
    /// Send an addressed GPIB command.
    fn addressed_cmd(
        &mut self,
        user: &AsynUser,
        cmd: GpibCommand,
        addr: i32,
    ) -> AsynResult<()>;

    /// Send a universal GPIB command.
    fn universal_cmd(
        &mut self,
        user: &AsynUser,
        cmd: GpibUniversalCommand,
    ) -> AsynResult<()>;

    /// Assert Interface Clear (IFC).
    fn ifc(&mut self, user: &AsynUser) -> AsynResult<()>;

    /// Set Remote Enable (REN) state.
    fn ren(&mut self, user: &AsynUser, enable: bool) -> AsynResult<()>;

    /// Query SRQ (Service Request) status.
    fn srq_status(&self, user: &AsynUser) -> AsynResult<SrqStatus>;

    /// Enable or disable SRQ notification.
    fn srq_enable(&mut self, user: &AsynUser, enable: bool) -> AsynResult<()>;

    /// Perform a serial poll, returning the status byte.
    fn serial_poll(&mut self, user: &AsynUser) -> AsynResult<u8>;
}