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

//
// Copyright (C) 2019 Kubos Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License")
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

//!
//! Serial communications functionality for use in conjunction
//! with the communications service library. KISS framing is
//! implemented for data integrity over the serial link.
//!

use crate::kiss;
use crate::SerialServiceResult;
use rust_uart::Connection;
use std::cell::RefCell;
use std::sync::{Arc, Mutex};
use std::time::Duration;

pub struct SerialComms {
    conn: Connection,
    buffer: RefCell<Vec<u8>>,
}

impl SerialComms {
    pub fn new(path: &str) -> Self {
        let serial_settings = serial::PortSettings {
            baud_rate: serial::Baud115200,
            char_size: serial::Bits8,
            parity: serial::ParityNone,
            stop_bits: serial::Stop1,
            flow_control: serial::FlowNone,
        };

        let conn = Connection::from_path(path, serial_settings, Duration::from_millis(1)).unwrap();

        SerialComms {
            conn,
            buffer: RefCell::new(vec![]),
        }
    }

    // Function to allow reading a whole UDP packet from a serial socket
    // using KISS framing
    pub fn read(&self) -> SerialServiceResult<Vec<u8>> {
        let mut buffer = self.buffer.borrow_mut();
        while let Ok(mut buf) = self.conn.read(1, Duration::from_millis(1)) {
            buffer.append(&mut buf);
            if buffer.len() > 4096 {
                break;
            }
        }

        match kiss::decode(&buffer) {
            Ok(kiss::DecodedData {
                frame,
                mut pre_data,
                mut post_data,
            }) => {
                buffer.clear();
                buffer.append(&mut pre_data);
                buffer.append(&mut post_data);
                Ok(frame)
            }
            Err(e) => {
                bail!("Parse err {:?}", e);
            }
        }
    }

    // Function to allow writing over a UDP socket.
    pub fn write(&self, data: &[u8]) -> SerialServiceResult<()> {
        let wrapped = kiss::encode(data);
        self.conn.write(&wrapped)?;
        Ok(())
    }
}

pub fn read_ser(socket: &Arc<Mutex<SerialComms>>) -> SerialServiceResult<Vec<u8>> {
    if let Ok(socket) = socket.lock() {
        return socket.read();
    }
    bail!("Failed to lock socket");
}

pub fn write_ser(socket: &Arc<Mutex<SerialComms>>, data: &[u8]) -> SerialServiceResult<()> {
    if let Ok(socket) = socket.lock() {
        socket.write(data)?;
    }
    Ok(())
}