dynamixel 0.1.1

A (soon to be) full featured dynamixel servo library in rust
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

use std;
use serialport;

use std::ops::DerefMut;

use {
    CommunicationError,
    Interface,
    BaudRate,
};

impl From<serialport::Error> for CommunicationError {
    fn from(e: serialport::Error) -> CommunicationError {
        match e {
            serialport::Error{kind: serialport::ErrorKind::Io(std::io::ErrorKind::TimedOut), ..} => CommunicationError::TimedOut,
            _ => CommunicationError::Other,
        }
    }
}

impl From<BaudRate> for serialport::BaudRate {
    fn from(b: BaudRate) -> serialport::BaudRate {
        match b {
            BaudRate::Baud9600 => serialport::BaudRate::Baud9600,
            BaudRate::Baud19200 => serialport::BaudRate::Baud19200,
            BaudRate::Baud57600 => serialport::BaudRate::Baud57600,
            BaudRate::Baud115200 => serialport::BaudRate::Baud115200,
            BaudRate::Baud500000 => serialport::BaudRate::Baud500000,
            BaudRate::Baud1000000 => serialport::BaudRate::Baud1000000,
            BaudRate::Baud2000000 => serialport::BaudRate::Baud2000000,
            BaudRate::Baud3000000 => serialport::BaudRate::Baud3000000,
            BaudRate::Baud4000000 => serialport::BaudRate::Baud4000000,
            b => serialport::BaudRate::BaudOther(u32::from(b)),
        }
    }
}

impl Interface for std::boxed::Box<serialport::SerialPort> {
    fn set_baud_rate(&mut self, b: BaudRate) -> Result<(), CommunicationError> {
        match serialport::SerialPort::set_baud_rate(self.deref_mut(), serialport::BaudRate::from(b)) {
            Ok(_) => Ok(()),
            Err(_) => Err(CommunicationError::UnsupportedBaud(b)),
        }
    }

    fn flush(&mut self) {
        let mut buf = Vec::new();
        let _res = self.read_to_end(&mut buf);
    }
    
    fn read(&mut self, data: &mut [u8]) -> Result<(), CommunicationError> {
        self.set_timeout(std::time::Duration::new(0, 100000000))?;
        Ok(std::io::Read::read_exact(self, data)?)
    }

    fn write(&mut self, data: &[u8]) -> Result<(), CommunicationError> {
        self.set_timeout(std::time::Duration::new(0, 100000000))?;
        Ok(std::io::Write::write_all(self, data)?)
    }
}