mimxrt: Refactor timeout handling for uart.write().

robert-hh · robert-hh · commit 40d6c27e6da1 · 2022-09-11T16:43:11.000+02:00
1. if a transmission is ongoing
   - if the blocking time is longer than the timeout,
     set MP_AGAIN and return MP_STREAM_ERROR.
   - If the blocking time is shorter than the timeout, wait.

2. if no transmission is ongoing
   - if the message is shorter than the buffer, just send it.
   - if the message is longer than the buffer and the expected blocking
     time is larger than the timeout, just send a buffer size amount of data
     and return that size.
   - if the message is longer than the buffer and the expected blocking
     time is smaller than the timeout, send all data and return that size.
diff --git a/ports/mimxrt/machine_uart.c b/ports/mimxrt/machine_uart.c
@@ -372,9 +372,22 @@ STATIC mp_uint_t machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uin
     lpuart_transfer_t xfer;
     uint64_t t;
     size_t remaining = size;
+    size_t sent = 0;
     size_t offset = 0;
+    uint32_t block_time;
+    uint32_t timeout_budget = self->timeout;
     uint8_t fifo_size = FSL_FEATURE_LPUART_FIFO_SIZEn(0);
 
+    // Check if a tansmission is still going on and write will block longer than timeout
+    if (self->tx_status != kStatus_LPUART_TxIdle) {
+        block_time = (fifo_size + self->handle.txDataSize) * (13000000 / self->config.baudRate_Bps) / 1000;
+        if (timeout_budget < block_time) {
+            *errcode = MP_EAGAIN;
+            return MP_STREAM_ERROR;
+        }
+        timeout_budget -= block_time;
+    }
+
     // First check if a previous transfer is still ongoing,
     // then wait at least the number of remaining character times.
     t = ticks_us64() + (uint64_t)(self->handle.txDataSize + fifo_size) * (13000000 / self->config.baudRate_Bps + 1000);
@@ -388,31 +401,33 @@ STATIC mp_uint_t machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uin
 
     // Check if the first part has to be sent semi-blocking.
     if (size > self->txbuf_len) {
-        // Send the first block.
-        xfer.data = (uint8_t *)buf_in;
-        offset = xfer.dataSize = size - self->txbuf_len;
-        self->tx_status = kStatus_LPUART_TxBusy;
-        LPUART_TransferSendNonBlocking(self->lpuart, &self->handle, &xfer);
-
-        // Wait at least the number of character times for this chunk.
-        t = ticks_us64() + (uint64_t)xfer.dataSize * (13000000 / self->config.baudRate_Bps + 1000);
-        while (self->tx_status != kStatus_LPUART_TxIdle) {
-            // Wait for the first/next character to be sent.
-            if (ticks_us64() > t) { // timed out
-                if (self->handle.txDataSize >= size) {
-                    *errcode = MP_ETIMEDOUT;
-                    return MP_STREAM_ERROR;
-                } else {
-                    return size - self->handle.txDataSize;
+        // check it it blocks shorter than a timeout
+        block_time = (size - self->txbuf_len) * (13000000 / self->config.baudRate_Bps) / 1000;
+        if (timeout_budget > block_time) {
+            // Send the first block.
+            xfer.data = (uint8_t *)buf_in;
+            sent = size - self->txbuf_len;
+            offset = xfer.dataSize = sent;
+            self->tx_status = kStatus_LPUART_TxBusy;
+            LPUART_TransferSendNonBlocking(self->lpuart, &self->handle, &xfer);
+
+            // Wait at least the number of character times for this chunk.
+            t = ticks_us64() + (uint64_t)xfer.dataSize * (13000000 / self->config.baudRate_Bps + 1000);
+            while (self->tx_status != kStatus_LPUART_TxIdle) {
+                // Wait for the first/next character to be sent.
+                if (ticks_us64() > t) { // timed out
+                    if (self->handle.txDataSize >= sent) {
+                        *errcode = MP_ETIMEDOUT;
+                        return MP_STREAM_ERROR;
+                    } else {
+                        return sent - self->handle.txDataSize;
+                    }
                 }
+                MICROPY_EVENT_POLL_HOOK
             }
-            MICROPY_EVENT_POLL_HOOK
         }
+        // In any case, just sent a buffer sized chunk in the next step
         remaining = self->txbuf_len;
-    } else {
-        // The data fits into the tx buffer.
-        offset = 0;
-        remaining = size;
     }
 
     // Send the remaining data without waiting for completion.
@@ -422,7 +437,7 @@ STATIC mp_uint_t machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uin
     self->tx_status = kStatus_LPUART_TxBusy;
     LPUART_TransferSendNonBlocking(self->lpuart, &self->handle, &xfer);
 
-    return size;
+    return sent + remaining;
 }
 
 STATIC mp_uint_t machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
