How to read UART without blocking

[ZoutigeWolf]

Im running esp-hal (no_std) on an esp-wroom-32, and im trying to read UART without blocking. But the read function is blocking when there are no bytes even though the docs specificy non blocking operation.

This is the code im using, trying to make a function that will either return a full line or nothing if there isnt a full line available.
I have tried using embedded_hal_nb but i just ended up with trait errors on read().

use esp_hal::uart::Uart;
use esp_hal::Blocking;
use core::str;

pub struct LineReader<const N: usize> {
    buf: [u8; N],
    len: usize,
}

impl<const N: usize> LineReader<N> {
    pub const fn new() -> Self {
        Self {
            buf: [0; N],
            len: 0,
        }
    }

    pub fn poll(&mut self, uart: &mut Uart<'_, Blocking>) -> Option<&str> {
        let mut byte_buf = [0u8; 1];

        let n = uart.read(&mut byte_buf).unwrap_or(0);

        if n == 0 { return None;}

        let byte = byte_buf[0];

        if byte == b'\n' || byte == b'\r' {
            if self.len == 0 {
                return None;
            }

            let line = &self.buf[..self.len];
            self.len = 0;

            if let Ok(line_str) = str::from_utf8(line) {
                return Some(line_str);
            }
            return None;
        }

        if self.len < N {
            self.buf[self.len] = byte;
            self.len += 1;
        } else {
            self.len = 0;
        }

        None
    }
}

[ZoutigeWolf]

I looked into the source code and the so called non-blocking function calls another function that literally blocks operation

uart.read:

self.rx.read:

[bugadani]

I think this is a documentation issue, we correctly state that the function only returns 0 (bytes read) if the destination buffer is empty. You can use read_ready to check if there are any bytes to read.

[ZoutigeWolf]

I was trying to avoid any unstable features, but it seems there is no other way. Code works perfectly using read_ready.