pbio/sys/host: Duplicate stdout to ble and usb.

Also change the signature of pbsys_bluetooth_tx and pbdrv_usb_stdout_tx to return PBIO_SUCCESS upon completion (not partial completion) and PBIO_ERROR_AGAIN for zero or partial transfers, which makes more sense with our other protothreads.

Author: laurensvalk

bricks/_common_stm32/mphalport.c

@@ -65,24 +65,10 @@ int mp_hal_stdin_rx_chr(void) {
 
 // Send string of given length
 void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
-    while (len) {
-        uint32_t size = len;
-        pbio_error_t err = pbsys_host_tx((const uint8_t *)str, &size);
-
-        if (err == PBIO_SUCCESS) {
-            str += size;
-            len -= size;
-            continue;
-        }
-
+    while (pbsys_host_tx((const uint8_t *)str, len) == PBIO_ERROR_AGAIN) {
         MICROPY_EVENT_POLL_HOOK
-
-        if (err != PBIO_ERROR_AGAIN) {
-            // Ignoring error for now. This means stdout lost if Bluetooth is
-            // disconnected.
-            return;
-        }
     }
+    // Not raising the error. This means stdout lost if host is not connected.
 }
 
 void mp_hal_stdout_tx_flush(void) {

lib/pbio/drv/usb/usb_stm32.c

@@ -191,20 +191,22 @@ void pbdrv_usb_stm32_handle_vbus_irq(bool active) {
  * @param data  [in]        The data to be sent.
  * @param size  [in, out]   The size of @p data in bytes. After return, @p size
  *                          contains the number of bytes actually written.
- * @return                  ::PBIO_SUCCESS if @p data was queued, ::PBIO_ERROR_AGAIN
- *                          if @p data could not be queued at this time (e.g. buffer
+ * @return                  ::PBIO_SUCCESS if all @p data was queued, ::PBIO_ERROR_AGAIN
+ *                          if not all @p data could not be queued at this time (e.g. buffer
  *                          is full), ::PBIO_ERROR_INVALID_OP if there is not an
  *                          active USB connection or ::PBIO_ERROR_NOT_SUPPORTED
  *                          if this platform does not support USB.
  */
 pbio_error_t pbdrv_usb_stdout_tx(const uint8_t *data, uint32_t *size) {
     uint8_t *ptr = usb_stdout_buf;
     uint32_t ptr_len = sizeof(usb_stdout_buf);
+    uint32_t full_size = *size;
 
     if (!pbdrv_usb_stdout_is_awaitable()) {
         return PBIO_ERROR_INVALID_OP;
     }
     if (usb_stdout_sz) {
+        *size = 0;
         return PBIO_ERROR_AGAIN;
     }
 
@@ -214,14 +216,14 @@ pbio_error_t pbdrv_usb_stdout_tx(const uint8_t *data, uint32_t *size) {
     *ptr++ = PBIO_PYBRICKS_EVENT_WRITE_STDOUT;
     ptr_len--;
 
-    *size = MIN(*size, ptr_len);
+    *size = MIN(full_size, ptr_len);
     memcpy(ptr, data, *size);
 
     usb_stdout_sz = 1 + 1 + *size;
 
     process_poll(&pbdrv_usb_process);
 
-    return PBIO_SUCCESS;
+    return *size == full_size ? PBIO_SUCCESS : PBIO_ERROR_AGAIN;
 }
 
 /**

lib/pbio/include/pbsys/host.h

@@ -32,7 +32,7 @@ uint32_t pbsys_host_rx_get_available(void);
 uint32_t pbsys_host_rx_get_free(void);
 void pbsys_host_rx_write(const uint8_t *data, uint32_t size);
 pbio_error_t pbsys_host_rx(uint8_t *data, uint32_t *size);
-pbio_error_t pbsys_host_tx(const uint8_t *data, uint32_t *size);
+pbio_error_t pbsys_host_tx(const uint8_t *data, uint32_t size);
 bool pbsys_host_tx_is_idle(void);
 
 #else // PBSYS_CONFIG_HOST
@@ -47,7 +47,7 @@ bool pbsys_host_tx_is_idle(void);
 static inline pbio_error_t pbsys_host_rx(uint8_t *data, uint32_t *size) {
     return PBIO_ERROR_NOT_SUPPORTED;
 }
-static inline pbio_error_t pbsys_host_tx(const uint8_t *data, uint32_t *size) {
+static inline pbio_error_t pbsys_host_tx(const uint8_t *data, uint32_t size) {
     return PBIO_ERROR_NOT_SUPPORTED;
 }
 static inline bool pbsys_host_tx_is_idle(void) {

lib/pbio/sys/bluetooth.c

@@ -153,13 +153,17 @@ void pbsys_bluetooth_rx_flush(void) {
  * @param data  [in]        The data to be sent.
  * @param size  [in, out]   The size of @p data in bytes. After return, @p size
  *                          contains the number of bytes actually written.
- * @return                  ::PBIO_SUCCESS if @p data was queued, ::PBIO_ERROR_AGAIN
- *                          if @p data could not be queued at this time (e.g. buffer
- *                          is full), ::PBIO_ERROR_INVALID_OP if there is not an
+ * @return                  ::PBIO_SUCCESS if all @p data was queued,
+ *                          ::PBIO_ERROR_AGAIN if not all @p data could not be
+ *                          queued at this time (e.g. buffer is full),
+ *                          ::PBIO_ERROR_INVALID_OP if there is not an
  *                          active Bluetooth connection or ::PBIO_ERROR_NOT_SUPPORTED
  *                          if this platform does not support Bluetooth.
  */
 pbio_error_t pbsys_bluetooth_tx(const uint8_t *data, uint32_t *size) {
+
+    uint32_t full_size = *size;
+
     // make sure we have a Bluetooth connection
     if (!pbdrv_bluetooth_is_connected(PBDRV_BLUETOOTH_CONNECTION_PYBRICKS)) {
         return PBIO_ERROR_INVALID_OP;
@@ -176,15 +180,15 @@ pbio_error_t pbsys_bluetooth_tx(const uint8_t *data, uint32_t *size) {
         stdout_msg.is_queued = true;
     }
 
-    if ((*size = lwrb_write(&stdout_ring_buf, data, *size)) == 0) {
+    if ((*size = lwrb_write(&stdout_ring_buf, data, full_size)) == 0) {
         return PBIO_ERROR_AGAIN;
     }
 
     // poke the process to start tx soon-ish. This way, we can accumulate up to
     // MAX_CHAR_SIZE bytes before actually transmitting
     pbsys_bluetooth_process_poll();
 
-    return PBIO_SUCCESS;
+    return *size == full_size ? PBIO_SUCCESS : PBIO_ERROR_AGAIN;
 }
 
 /**

lib/pbio/sys/host.c

@@ -5,6 +5,8 @@
 
 #if PBSYS_CONFIG_HOST
 
+#include <pbdrv/usb.h>
+
 #include <pbsys/host.h>
 
 #include "bluetooth.h"
@@ -37,8 +39,54 @@ pbio_error_t pbsys_host_rx(uint8_t *data, uint32_t *size) {
     return pbsys_bluetooth_rx(data, size);
 }
 
-pbio_error_t pbsys_host_tx(const uint8_t *data, uint32_t *size) {
-    return pbsys_bluetooth_tx(data, size);
+/**
+ * Transmits data over Bluetooth and USB.
+ *
+ * Should be called in a loop with the same arguments until it no longer
+ * returns ::PBIO_ERROR_AGAIN.
+ *
+ * @param data  [in]   The data to transmit.
+ * @param size  [in]   The size of the data to transmit.
+ * @return             ::PBIO_ERROR_AGAIN if the data is still being transmitted
+ *                     ::PBIO_SUCCESS if complete or failed.
+ */
+pbio_error_t pbsys_host_tx(const uint8_t *data, uint32_t size) {
+
+    static bool transmitting = false;
+    static uint32_t tx_done_ble;
+    static uint32_t tx_done_usb;
+
+    if (!transmitting) {
+        tx_done_ble = 0;
+        tx_done_usb = 0;
+        transmitting = true;
+    }
+
+    pbio_error_t err_ble = PBIO_SUCCESS;
+    pbio_error_t err_usb = PBIO_SUCCESS;
+    uint32_t size_now;
+
+    if (tx_done_ble < size) {
+        size_now = size - tx_done_ble;
+        err_ble = pbsys_bluetooth_tx(data + tx_done_ble, &size_now);
+        tx_done_ble += size_now;
+    }
+
+    if (tx_done_usb < size) {
+        size_now = size - tx_done_usb;
+        err_usb = pbdrv_usb_stdout_tx(data + tx_done_usb, &size_now);
+        tx_done_usb += size_now;
+    }
+
+    // Keep waiting as long as at least has not completed or errored.
+    if (err_ble == PBIO_ERROR_AGAIN || err_usb == PBIO_ERROR_AGAIN) {
+        return PBIO_ERROR_AGAIN;
+    }
+
+    // Both of them are either complete or failed. The caller of this function
+    // does not currently raise errors, so we just return success.
+    transmitting = false;
+    return PBIO_SUCCESS;
 }
 
 bool pbsys_host_tx_is_idle(void) {