serialmessage 0.2.0

Pack serial data into a fast, reliable, and packetized form for communicating with e.g. a Microcontroller.
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

extern crate serialmessage;
extern crate serialport;

use serialmessage::{ParseState, SerMsg};
use std::{env, thread, time::Duration};
use zerocopy::{AsBytes, FromBytes};

#[repr(C, packed)]
#[derive(FromBytes, AsBytes, Debug, Clone, Copy)]
struct OneNumber {
    num: i32,
}

#[repr(C, packed)]
#[derive(FromBytes, AsBytes, Debug, Clone, Copy)]
struct TwoNumbers {
    num1: i16,
    num2: i16,
}

fn print_port_names() {
    let portlist = serialport::available_ports().unwrap();
    println!("Available ports: ");
    for portinfo in portlist.iter() {
        println!("{:?}", portinfo.port_name.to_owned());
    }
}

fn main() {
    if env::args().count() < 2 {
        println!("No port was provided as an argument");
        print_port_names();
        panic!()
    }
    let args: Vec<String> = env::args().collect();
    let port = serialport::new(args[1].to_owned(), 115_200).open();

    let mut port = match port {
        Ok(port) => port,
        Err(_) => {
            println!("No valid port was provided or there was an error accessing the port");
            print_port_names();
            panic!()
        }
    };

    let send_data = TwoNumbers { num1: 26, num2: 8 };

    let send_bytes = send_data.as_bytes();
    let send_msg = SerMsg::create_msg_vec(send_bytes, 1).unwrap();

    let _written_amount = port.write(&send_msg).unwrap();

    thread::sleep(Duration::from_millis(100));

    let mut ser_msg = SerMsg::new();
    let mut buffer = [0; 256];
    let read_amount = port.read(&mut buffer).unwrap();
    let read_bytes = buffer[..read_amount].to_owned();
    let mut all_parsed_bytes = 0;

    while read_amount > all_parsed_bytes {
        let (state, parsed_bytes) = ser_msg.parse_read_bytes(&read_bytes[all_parsed_bytes..]);
        all_parsed_bytes += parsed_bytes;

        match state {
            ParseState::DataReady => {
                if ser_msg.return_msg_id() == 1 {
                    let rcvd_two_nums = TwoNumbers::read_from(ser_msg.return_read_data()).unwrap();
                    println!("Rcvd: {:?}", rcvd_two_nums);
                } else if ser_msg.return_msg_id() == 2 {
                    let rcvd_one_num = OneNumber::read_from(ser_msg.return_read_data()).unwrap();
                    println!("Rcvd: {:?}", rcvd_one_num);
                } else {
                    println!("Invalid ID: {}", ser_msg.return_msg_id());
                }
            }
            _ => {
                println!("State: {:?}", state);
            }
        }
    }
}