instrument-core 0.1.1

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::connect::ConnectOptions;
use crate::error::{Error, Result};
use crate::transport::TransportIdentity;
use std::future::Future;
use std::pin::Pin;
use std::time::Duration;

/// Boxed async transport for dynamic dispatch at the session boundary.
pub type DynAsyncTransport = Box<dyn AsyncTransport>;

/// Async byte-level transport for instrument I/O.
pub trait AsyncTransport: Send {
    /// Writes bytes asynchronously.
    fn write<'a>(
        &'a mut self,
        data: &'a [u8],
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>>;

    /// Reads bytes asynchronously.
    fn read<'a>(
        &'a mut self,
        buf: &'a mut [u8],
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'a>>;

    /// Clears the transport buffer.
    fn clear<'a>(&'a mut self) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async { Ok(()) })
    }

    /// Sets the read timeout.
    fn set_read_timeout<'a>(
        &'a mut self,
        _timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async { Ok(()) })
    }

    /// Synchronously applies a read timeout so cancel/drop can restore I/O timeout.
    fn apply_read_timeout(&mut self, _timeout: Duration) -> Result<()> {
        Ok(())
    }

    /// Reopens a dropped connection (e.g. TCPIP). Default: unsupported.
    fn reconnect<'a>(&'a mut self) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async { Err(Error::Unsupported("reconnect")) })
    }

    /// Pre-SCPI identity hints. Default: empty.
    fn identity(&self) -> TransportIdentity {
        TransportIdentity::default()
    }

    /// Applies connect options (timeouts, etc.).
    fn configure<'a>(
        &'a mut self,
        opts: &'a ConnectOptions,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        let timeout = opts.io_timeout();
        Box::pin(async move { self.set_read_timeout(timeout).await })
    }
}

/// Wraps a sync [`crate::transport::Transport`] as an async transport (for mocks/tests).
pub struct SyncAsAsyncTransport<T: crate::transport::Transport + Send> {
    inner: T,
}

impl<T: crate::transport::Transport + Send> SyncAsAsyncTransport<T> {
    pub fn new(inner: T) -> Self {
        Self { inner }
    }

    pub fn into_inner(self) -> T {
        self.inner
    }
}

impl<T: crate::transport::Transport + Send> AsyncTransport for SyncAsAsyncTransport<T> {
    fn write<'a>(
        &'a mut self,
        data: &'a [u8],
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async move { self.inner.write(data) })
    }

    fn read<'a>(
        &'a mut self,
        buf: &'a mut [u8],
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'a>> {
        Box::pin(async move { self.inner.read(buf) })
    }

    fn clear<'a>(&'a mut self) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async move { self.inner.clear() })
    }

    fn set_read_timeout<'a>(
        &'a mut self,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async move { self.inner.set_read_timeout(timeout) })
    }

    fn apply_read_timeout(&mut self, timeout: Duration) -> Result<()> {
        self.inner.set_read_timeout(timeout)
    }

    fn reconnect<'a>(&'a mut self) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async move { self.inner.reconnect() })
    }

    fn identity(&self) -> TransportIdentity {
        self.inner.identity()
    }

    fn configure<'a>(
        &'a mut self,
        opts: &'a ConnectOptions,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
        Box::pin(async move { self.inner.configure(opts) })
    }
}