Aligning serial data using the Read trait in Rust - rust

Question

So I have some data going through a serial port at regular intervals. Eight bytes are sent every 2 seconds.
I would read this data. Because transmission is constant, I can't just start reading at any moment. I need to align the data. So clearly, the way to do this is to send a header or some sort of separator bytes.
With the Read trait, I can read a certain number of bytes into my buffer. It might look like this:
let mut serial_buf: Vec<u8> = vec![0; 16];
loop {
match port.read(serial_buf.as_mut_slice()) {
Ok(t) => print_data(&serial_buf[..t]),
Err(ref e) if e.kind() == std::io::ErrorKind::TimedOut => (),
Err(e) => eprintln!("{:?}", e),
}
}
But the output I get will look something like this without alignment (with bytes 'abcd' being sent every 2 seconds):
abcd
a
bcd
abc
d
a
bcd
ab
cd
So what's the most practical way of reading and discarding until an alignment bit is found, then making sure that all subsequent reads are aligned?
Thanks,

Answer 1

You need a way to recognize a packet. For this you need to define your protocol.
I guess you want to keep it really simple and low-overhead, so I'll give an example.
+----------+-------+------+------+------+------+------+------+------+------+-----------+
| Byte | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+==========+=======+======+======+======+======+======+======+======+======+===========+
| Function | Start | Data | Data | Data | Data | Data | Data | Data | Data | CheckSum |
+----------+-------+------+------+------+------+------+------+------+------+-----------+
| Value | 0 | X | X | X | X | X | X | X | X | XOR 0..=8 |
+----------+-------+------+------+------+------+------+------+------+------+-----------+
So what do we have here?
Our message always starts with a 0. This way we can recognize the start of the message. The data can still contain 0's because we don't rely on it, it just makes our job easier.
(This could be any value, really, but 0 will do the job just fine)
After our start byte, we get our data. This is just the ABCD you used in your example.
Our last byte is a very simple checksum. We simple XOR together all the bytes.
How does this all work then?
Collect some data.
If data < 10 bytes, go to 1
If data[0] != 0 (our start byte), then remove the first byte from our buffer. Go to 2.
XOR together all bytes to get our calculated checksum.
If data[9] != calculated_checksum, then remove the first byte from our buffer. Go to 2.
(We did detect a start byte, but the checksum is incorrect. Therefore we know that the current data is not a packet)
We've got the packet! (Probably*) Read bytes 1..=8 for processing. Then remove the first 10 bytes from the buffer. Go to 2.
That's it!
But there's a lot of things to improve for performance and reliability.
Better start header that supports dynamic lengths and multiple message types.
Better checksum. XOR is not very good for reliability. A CRC is one of the best.
Buffer management. You could use a cyclical buffer so you don't have to remove any bytes.