serialport_srwp 2.2.1

A simple serial port protocol (SRWP) for read/write operations with the Blaustahl Storage Device. Enables memory access via basic commands for data transmission and device 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
123
124
125
126
127

use std::{
    sync::{Arc, Mutex},
    time::Duration,
};

use serialport::{ClearBuffer, DataBits, FlowControl, Parity, SerialPort, StopBits};
use thiserror::Error;

mod device;
mod srwp;
mod types;

pub use device::*;
pub use srwp::*;
pub use types::*;

#[derive(Debug, Error)]
pub enum DeviceError {
    #[error("Device not found")]
    NotFound,
    #[error("Serial port error")]
    SerialPortError(serialport::Error),
    #[error("I/O error")]
    IOError(std::io::Error),
    #[error("Port is locked")]
    PortIsLocked,
}

#[derive(Debug)]
pub struct SerialPortBox {
    port: Box<dyn SerialPort>,
}

#[derive(Debug)]
pub struct SerialPortDataManager(Arc<Mutex<SerialPortBox>>);

impl SerialPortDataManager {
    pub fn new(path: &str) -> Result<Self, DeviceError> {
        serialport::new(path, 9600)
            .data_bits(DataBits::Eight)
            .stop_bits(StopBits::One)
            .flow_control(FlowControl::None)
            .parity(Parity::None)
            .timeout(Duration::from_millis(1000))
            .open()
            .map(|port| SerialPortBox { port })
            .map(Mutex::new)
            .map(Arc::new)
            .map(SerialPortDataManager)
            .map_err(DeviceError::SerialPortError)
    }

    pub fn get_available_ports() -> Result<Vec<String>, DeviceError> {
        serialport::available_ports()
            .map_err(DeviceError::SerialPortError)
            .map(|ports| {
                ports
                    .iter()
                    .filter_map(|port| {
                        if let serialport::SerialPortType::UsbPort(_) = &port.port_type {
                            Some(port.port_name.clone())
                        } else {
                            None
                        }
                    })
                    .collect::<Vec<_>>()
            })
            .and_then(|ports| {
                if ports.is_empty() {
                    Err(DeviceError::NotFound)
                } else {
                    Ok(ports)
                }
            })
    }

    pub fn get_serial_port(&mut self) -> Result<&mut SerialPortBox, DeviceError> {
        Arc::get_mut(&mut self.0)
            .ok_or(DeviceError::PortIsLocked)?
            .get_mut()
            .map_err(|_| DeviceError::PortIsLocked)
    }
}

impl Clone for SerialPortDataManager {
    fn clone(&self) -> Self {
        SerialPortDataManager(Arc::clone(&self.0))
    }
}

impl SerialPortBox {
    pub fn read_data_set_ready(&mut self) -> Result<bool, DeviceError> {
        self.port
            .read_data_set_ready()
            .map_err(DeviceError::SerialPortError)
    }

    pub fn write_data_terminal_ready(&mut self, ready: bool) -> Result<(), DeviceError> {
        self.port
            .write_data_terminal_ready(ready)
            .map_err(DeviceError::SerialPortError)
    }

    pub fn write_request_to_send(&mut self, ready: bool) -> Result<(), DeviceError> {
        self.port
            .write_request_to_send(ready)
            .map_err(DeviceError::SerialPortError)
    }

    pub fn write(&mut self, data: &[u8]) -> Result<(), DeviceError> {
        self.port.write_all(data).map_err(DeviceError::IOError)
    }

    pub fn read(&mut self, buffer: &mut [u8]) -> Result<usize, DeviceError> {
        self.port.read(buffer).map_err(DeviceError::IOError)
    }

    pub fn clear(&mut self) -> Result<(), DeviceError> {
        self.port
            .clear(ClearBuffer::All)
            .map_err(DeviceError::SerialPortError)
    }

    pub fn flush(&mut self) -> Result<(), DeviceError> {
        self.port.flush().map_err(DeviceError::IOError)
    }
}