instrument-core 0.1.0

VISA-agnostic transport, SCPI session, discovery, and mock fixtures for instrument control
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

use std::time::Duration;

/// VISA access mode (maps to visa-rs AccessMode when using visa backend).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct AccessMode {
    pub exclusive_lock: bool,
    pub shared_lock: bool,
}

impl AccessMode {
    pub const NO_LOCK: Self = Self {
        exclusive_lock: false,
        shared_lock: false,
    };

    pub const SHARED_LOCK: Self = Self {
        exclusive_lock: false,
        shared_lock: true,
    };

    pub const EXCLUSIVE_LOCK: Self = Self {
        exclusive_lock: true,
        shared_lock: false,
    };
}

/// Options when opening an instrument session.
#[derive(Debug, Clone)]
pub struct ConnectOptions {
    pub open_timeout: Duration,
    pub read_timeout: Duration,
    pub write_timeout: Duration,
    pub per_op_timeout: Option<Duration>,
    pub terminator: String,
    pub access_mode: AccessMode,
    pub reset_on_connect: bool,
    pub retries: u32,
    pub retry_backoff: Duration,
    pub reconnect_on_failure: bool,
}

impl Default for ConnectOptions {
    fn default() -> Self {
        Self {
            open_timeout: Duration::from_secs(5),
            read_timeout: Duration::from_secs(10),
            write_timeout: Duration::from_secs(10),
            per_op_timeout: None,
            terminator: "\n".to_string(),
            access_mode: AccessMode::NO_LOCK,
            reset_on_connect: false,
            retries: 2,
            retry_backoff: Duration::from_millis(100),
            reconnect_on_failure: true,
        }
    }
}

impl ConnectOptions {
    pub fn with_read_timeout(mut self, timeout: Duration) -> Self {
        self.read_timeout = timeout;
        self
    }

    pub fn with_per_op_timeout(mut self, timeout: Duration) -> Self {
        self.per_op_timeout = Some(timeout);
        self
    }
}