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

//
// 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();
        loop {
            let mut buf = match self.conn.read(1, Duration::from_millis(1)) {
                Ok(buf) => buf,
                Err(_e) => {
                    break;
                }
            };
            buffer.append(&mut buf);
            if buffer.len() > 4096 {
                break;
            }
        }

        match kiss::decode(&buffer) {
            Ok((parsed, mut pre, mut post)) => {
                buffer.clear();
                buffer.append(&mut pre);
                buffer.append(&mut post);
                return Ok(parsed);
            }
            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 Ok(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(())
}