br-serial 0.0.1

This is an COM and Serial Port
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

use std::{io, thread};
use std::sync::mpsc::Sender;
use json::JsonValue;
use log::info;
use crate::{BLACKLIST, Device, DEVICES, SubDevice};
use serial2::SerialPort;
use crate::protocol::Protocol;

#[derive(Clone, Debug)]
pub struct Usb {
    pub com: String,
    pub step: i32,
    pub tx: Sender<SubDevice>,
}

impl Usb {
    pub fn get_device(&mut self) -> Device {
        let data = DEVICES.lock().unwrap().get(&*self.com).unwrap().clone();
        data
    }
    pub fn connect(&mut self) {
        let mut device = self.get_device();
        match SerialPort::open(device.com.clone(), device.rate.clone()) {
            Ok(port) => {
                device.state = 1;
                device.save_data();
                let mut that = self.clone();
                thread::spawn(move || {
                    that.start(port);
                });
            }
            Err(_) => {
                if device.reconnect >= 10 {
                    info!("连接断开: {} {} {}",device.com.clone(), device.rate.clone(), device.uuid.clone());
                    BLACKLIST.lock().unwrap().insert(device.com.clone(), "".to_string());
                    DEVICES.lock().unwrap().remove(&*device.com.clone()).unwrap();
                } else {
                    info!("重试连接: {} {} {}",device.com.clone(), device.rate.clone(), device.uuid.clone());
                    device.reconnect += 1;
                    match device.reconnect {
                        3..=6 => {
                            device.rate = 9600;
                        }
                        _ => {
                            device.rate = 115200;
                        }
                    }
                    device.save_data();
                }
            }
        };
    }
    /// 连接设置
    pub fn start(&mut self, port: SerialPort) {
        let device = self.get_device();
        info!("连接成功: {} {} {}",device.com.clone(), device.rate.clone(), device.uuid.clone());
        loop {
            let mut device = self.get_device();
            let mut serial_buf: Vec<u8> = vec![0; 1000];
            match port.read(serial_buf.as_mut_slice()) {
                Ok(t) => {
                    let data = serial_buf[..t].to_vec();

                    // 判断通讯协议类型
                    let res = Protocol::new(data.clone());
                    if res.is_empty() {
                        DEVICES.lock().unwrap().remove(&*device.com.clone()).unwrap();
                        return;
                    }

                    if res["data_type"] == "values" {
                        for item in res["value"].members() {
                            self.send(item.clone());
                        }
                    } else {
                        self.send(res.clone());
                    }
                    continue;
                }
                Err(ref e) if e.kind() == io::ErrorKind::TimedOut => (),
                Err(_) => {
                    device.state = 0;
                    device.save_data();
                    return;
                }
            }
        }
    }

    pub fn send(&mut self, data: JsonValue) {
        let mut device = self.get_device();
        let id = data["id"].to_string();
        let sub_device = device.sub_device.get(&*id.clone()).is_none();
        if sub_device {
            device.sub_device.insert(id.clone(), SubDevice {
                mode: "USB".to_string(),
                id: id.clone(),
                name: "".to_string(),
                state: 4,
                device: true,
                device_id: device.uuid.clone(),
                data_mode: data["data_mode"].to_string(),
                data_type: data["data_type"].to_string(),
                value: data["value"].as_f64().unwrap_or(0.0),
            });
            device.save_data();
        }
        let mut res = device.sub_device.get(&*id.clone()).unwrap().clone();
        res.value = data["value"].as_f64().unwrap_or(0.0);
        self.tx.send(res).unwrap();
    }
}