Serial read seems to be very buggy and unreliable (unless I'm using it wrong)

[SparkyTD]

I am trying to incorporate USB serial communication into a more complex program that does several operations between serial reads. While working on this, I have noticed a strange issue where any delay before the serial.read() call will cause most incoming bytes to be dropped for some reason. Here's a simple demonstration of a serial echo program:

#![no_std]
#![no_main]

use arduino_hal::delay_ms;
use arduino_hal::prelude::*;
use panic_halt as _;
use ufmt::uwriteln;

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);
    let mut serial = arduino_hal::default_serial!(dp, pins, 9600);

    loop {
        delay_ms(100);
        if let Ok(byte) = serial.read() {
            serial.write(byte).unwrap();
            continue;
        }
    }
}

This program is supposed to read all incoming bytes, and echo them back to the serial port. The issue is, that the delay_ms(100) causes most of the incoming bytes to be ignored.
Example input: ABCDEFGH
Output: AB

If I recreate the same program in C++, everything works as expected:

void setup() {
  Serial.begin(9600);
}

void loop() {
  delay(100);
  if (Serial.available() > 0) {
    Serial.print(String((char)Serial.read()));
  }
}

Example input: ABCDEFGH
Output: ABCDEFGH

This version of the program does exactly what it's supposed to do, which is echo back every character read with a 100ms delay.

I assume this is happening due to some internal hidden buffering that exists in the Arduino C++ framework which presumably isn't implemented in the Rust HAL. Is there a way to make this program function the same way it does in C++?

[Rahix]

The serial implementation here in avr-hal works differently than the one in Arduino C++: We don't have any internal buffers while they do. So if you don't read by the time each new bytes becomes available, you will loose data as you noticed.

There are two solutions:

1. Either just read fast enough and don't delay.
2. Or move the reads into the corresponding RX interrupt and write received data into a buffer. This is essentially what the C++ implementation does under the hood as well.

[Rahix]

You can activate the relevant interrupt using the listen() method. Check the interrupt examples for some code example of setting up an interrupt handler.

[SparkyTD]

Awesome, thank you! This seems like exactly what I need.

[Rahix]

If you do end up writing some code like this and it is reusable enough, feel free to submit a new example showcasing this :)

[SparkyTD]

Alright, will do!