Reduce FIFO threshold in read_exact_async

Author: bugadani

esp-hal/CHANGELOG.md

@@ -23,6 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - RMT: `ChannelCreator::configure_tx` and `ChannelCreator::configure_rx` don't take a pin anymore, instead `Channel::with_pin` has been added. (#4302)
 - RMT: Configuration errors have been split out of `rmt::Error` into the new `rmt::ConfigError` enum. (#4494)
 - RMT: `Rmt::new()` now returns `Error::UnreachableTargetFrequency` instead of panicking when requesting 0 Hz. (#4509)
+- UART: changed the FIFO threshold in `read_exact_async` to reduce the likelyhood of `FifoOverflowed` errors. (#?)
 
 - Internal clock configuration rework (#4501)
 

esp-hal/src/uart/mod.rs

@@ -1072,21 +1072,17 @@ impl<'d> UartRx<'d, Async> {
     async fn wait_for_buffered_data(
         &mut self,
         minimum: usize,
-        preferred: usize,
+        max_threshold: u16,
         listen_for_timeout: bool,
     ) -> Result<(), RxError> {
         while self.uart.info().rx_fifo_count() < (minimum as u16).min(Info::RX_FIFO_MAX_THRHD) {
-            let amount = u16::try_from(preferred)
-                .unwrap_or(Info::RX_FIFO_MAX_THRHD)
-                .min(Info::RX_FIFO_MAX_THRHD);
-
             let current = self.uart.info().rx_fifo_full_threshold();
-            let _guard = if current > amount {
+            let _guard = if current > max_threshold {
                 // We're ignoring the user configuration here to ensure that this is not waiting
                 // for more data than the buffer. We'll restore the original value after the
                 // future resolved.
                 let info = self.uart.info();
-                unwrap!(info.set_rx_fifo_full_threshold(amount));
+                unwrap!(info.set_rx_fifo_full_threshold(max_threshold));
                 Some(OnDrop::new(|| {
                     unwrap!(info.set_rx_fifo_full_threshold(current));
                 }))
@@ -1153,7 +1149,12 @@ impl<'d> UartRx<'d, Async> {
             return Ok(0);
         }
 
-        self.wait_for_buffered_data(1, buf.len(), true).await?;
+        self.wait_for_buffered_data(
+            1,
+            buf.len().min(Info::RX_FIFO_MAX_THRHD as usize) as u16,
+            true,
+        )
+        .await?;
 
         self.read_buffered(buf)
     }
@@ -1177,8 +1178,16 @@ impl<'d> UartRx<'d, Async> {
             // No point in listening for timeouts, as we're waiting for an exact amount of
             // data. On ESP32 and S2, the timeout interrupt can't be cleared unless the FIFO
             // is empty, so listening could cause an infinite loop here.
-            self.wait_for_buffered_data(buf.len(), buf.len(), false)
-                .await?;
+            //
+            // The threshold is set to 75% of the FIFO to reduce the likelihood of overflows.
+            self.wait_for_buffered_data(
+                buf.len(),
+                buf.len()
+                    .min((Info::RX_FIFO_MAX_THRHD - Info::RX_FIFO_MAX_THRHD / 4) as usize)
+                    as u16,
+                false,
+            )
+            .await?;
 
             let read = self.uart.info().read_buffered(buf)?;
             buf = &mut buf[read..];