Continuously reading from serial port - rust

Question

I have a LoRa module which is connected to a serial port. I want to send a number of argument to configure it, but the connection times out after the first argument. Any ideas what I'm doing wrong?
use std::io::{self, Write};
use std::time::Duration;
fn main() {
let port = serialport::new("/dev/ttyS0", 115_200)
.timeout(Duration::from_millis(6000))
.open();
match port {
Ok(mut port) => {
let mut serial_buf: Vec<u8> = vec![0; 1000];
let config = vec![
"AT+CFG=433500000,5,9,7,1,1,0,0,0,0,3000,8,4\r\n",
"AT+RX\r\n",
"AT+SAVE\r\n",
];
for entry in config.iter() {
port.write(entry.as_bytes()).expect("Write failed!");
Duration::from_millis(1500);
loop {
match port.read(serial_buf.as_mut_slice()) {
Ok(t) => io::stdout().write_all(&serial_buf[..t]).unwrap(),
Err(e) => eprintln!("{:?}", e),
}
}
}
}
Err(e) => {
eprintln!("Error: {}", e);
::std::process::exit(1);
}
}
}
My working Python code:
main.py:
connection = Connection('/dev/ttys013', 115200, 8, 'N', 1, 1)
configuration.config_module(
'AT+CFG=433500000,5,9,7,1,1,0,0,0,0,3000,8,4', 'AT+RX', 'AT+SAVE')
configuration.py:
def config_module(self, *arguments):
self.connection.write_to_mcu(arguments[0])
for i in range(0, 1):
time.sleep(2)
validation = self.connection.read_from_mcu()
print(validation[:-1].decode())
for i in range(1, len(arguments)):
self.connection.write_to_mcu(arguments[i])
time.sleep(2)
validation_from_mcu = self.connection.read_from_mcu()
print(validation_from_mcu[:-1].decode())
connection.py:
def write_to_mcu(self, message):
self.serial_connection.write((message + '\r\n').encode())
def read_from_mcu(self):
return self.serial_connection.readline()

Answer 1

You probably already found the bug, but i'll try to answer the question anyway. The main issue was your infinite loop.
use std::io::{self, Write, BufRead, BufReader};
use std::time::Duration;
fn main() {
let mut port = serialport::new("/dev/ttyS0", 115_200)
.timeout(Duration::from_millis(6000))
.open()
// expect does exactly the same thing as your match did
.expect("Error: ");
// in your python you use readline, to archive this
// in rust the easiest way is to use a BufReader
let mut port = BufReader::new(port);
let mut line_buffer = String::new();
let config = vec![
"AT+CFG=433500000,5,9,7,1,1,0,0,0,0,3000,8,4\r\n",
"AT+RX\r\n",
"AT+SAVE\r\n",
];
for entry in config.iter() {
// get_mut is required because BufReader does not implement
// io::Write
port.get_mut()
// use write_all because write does not guarantee that
// every byte gets written
.write_all(entry.as_bytes()).expect("Write failed!");
// Duration::from_millis only returns a Duration and does not sleep
std::thread::sleep(Duration::from_millis(1500));
// clear the line buffer to use it again
line_buffer.clear();
// previously you never stopped reading
port.read_line(&mut line_buffer).expect("Read failed!");
// maybe you have a reason to use io::stdout().write_all()
// but most times you can just use println or print
print!("{}", line_buffer);
}
}
Docs
Write::write
BufRead::read_line
Duration::from_millis
std::thread::sleep