erpc_rust 0.1.3

Rust implementation of eRPC (Embedded RPC) protocol
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
123
124
125
126
127
128
129
130

//! Serial transport implementation
//!
//! This transport implements FramedTransport for consistency with TCP transport

#[cfg(feature = "serial")]
use crate::error::{ErpcResult, TransportError};
#[cfg(feature = "serial")]
use crate::transport::FramedTransport;
#[cfg(feature = "serial")]
use async_trait::async_trait;
#[cfg(feature = "serial")]
use serialport::{SerialPort, SerialPortBuilder};
#[cfg(feature = "serial")]
use std::time::Duration;
#[cfg(feature = "serial")]
use tokio::sync::Mutex;

#[cfg(feature = "serial")]
/// Serial transport for eRPC communication
pub struct SerialTransport {
    port: Mutex<Box<dyn SerialPort>>,
    timeout: Duration,
    connected: bool,
}

#[cfg(feature = "serial")]
impl SerialTransport {
    /// Open a serial port
    pub fn open(port_name: &str, baud_rate: u32) -> ErpcResult<Self> {
        let mut builder = serialport::new(port_name, baud_rate);
        builder = builder.timeout(Duration::from_secs(1));

        let port = builder
            .open()
            .map_err(|e| TransportError::ConnectionFailed(e.to_string()))?;

        Ok(Self {
            port: Mutex::new(port),
            timeout: Duration::from_secs(30),
            connected: true,
        })
    }

    /// Create with custom serial port settings
    pub fn with_settings(settings: SerialPortBuilder) -> ErpcResult<Self> {
        let port = settings
            .open()
            .map_err(|e| TransportError::ConnectionFailed(e.to_string()))?;

        Ok(Self {
            port: Mutex::new(port),
            timeout: Duration::from_secs(30),
            connected: true,
        })
    }
}

#[cfg(feature = "serial")]
#[async_trait]
impl FramedTransport for SerialTransport {
    async fn base_send(&mut self, data: &[u8]) -> ErpcResult<()> {
        if !self.connected {
            return Err(TransportError::Closed.into());
        }

        let mut port = self.port.lock().await;

        port.write_all(data)
            .map_err(|e| TransportError::SendFailed(e.to_string()))?;

        port.flush()
            .map_err(|e| TransportError::SendFailed(e.to_string()))?;

        Ok(())
    }

    async fn base_receive(&mut self, length: usize) -> ErpcResult<Vec<u8>> {
        if !self.connected {
            return Err(TransportError::Closed.into());
        }

        let mut port = self.port.lock().await;
        let mut data = vec![0u8; length];
        let start = std::time::Instant::now();

        while start.elapsed() < self.timeout {
            match port.read_exact(&mut data) {
                Ok(()) => return Ok(data),
                Err(ref e) if e.kind() == std::io::ErrorKind::TimedOut => {
                    tokio::time::sleep(Duration::from_millis(10)).await;
                    continue;
                }
                Err(e) => {
                    self.connected = false;
                    return Err(TransportError::ReceiveFailed(e.to_string()).into());
                }
            }
        }

        self.connected = false;
        Err(TransportError::Timeout.into())
    }

    async fn close(&mut self) -> ErpcResult<()> {
        self.connected = false;
        Ok(())
    }

    fn is_connected(&self) -> bool {
        self.connected
    }

    fn set_timeout(&mut self, timeout: Duration) {
        self.timeout = timeout;
    }
}

#[cfg(not(feature = "serial"))]
/// Placeholder when serial feature is disabled
pub struct SerialTransport;

#[cfg(not(feature = "serial"))]
impl SerialTransport {
    pub fn open(_port_name: &str, _baud_rate: u32) -> Result<Self, crate::error::ErpcError> {
        Err(
            crate::error::CodecError::NotSupported("Serial transport not enabled".to_string())
                .into(),
        )
    }
}