pbio/drv/uart: Refactor async read and write.

This squashes the following intermediate commits:

pbio/drv/uart: Don't broadcast uart events to all processes.

Instead poll subscribers, which is just the legodev
process for now. This can be expanded to poll the
specific uart instead of all of them.

This also drops the uart processes, which were not
doing anything, saving some code size.

pbio/drv/uart: Replace begin/end with single protothread.

UART read and write always used begin/end sequentially, each wrapped
in a wait for err != PBIO_ERROR_AGAIN. This replaces the begin/end
pattern with one awaitable protothread.

This makes the code easier to follow and reduces code size.

pbio/drv/uart: Set callback per device.

Not all devices may be used by the legodev driver.

Author: laurensvalk

lib/pbio/drv/ioport/ioport_debug_uart.c

@@ -5,6 +5,8 @@
 
 #if PBDRV_CONFIG_IOPORT_DEBUG_UART
 
+#error "This driver can currently not be used."
+
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>

lib/pbio/drv/legodev/legodev_pup.c

@@ -14,6 +14,7 @@
 #include <contiki.h>
 
 #include <pbdrv/gpio.h>
+#include <pbdrv/uart.h>
 
 #include <pbsys/status.h>
 
@@ -107,6 +108,11 @@ static void legodev_pup_enable_uart(const pbdrv_ioport_pup_pins_t *pins) {
     pbdrv_gpio_out_low(&pins->uart_buf);
 }
 
+static void legodev_pup_disable_uart(const pbdrv_ioport_pup_pins_t *pins) {
+    // REVISIT: Move to ioport.
+    pbdrv_gpio_out_high(&pins->uart_buf);
+}
+
 // This is the device connection manager (dcm). It monitors the ID1 and ID2 pins
 // on the port to see when devices are connected or disconnected.
 // It is expected for there to be a 2ms delay between calls to this function.
@@ -343,6 +349,7 @@ static PT_THREAD(pbdrv_legodev_pup_thread(ext_dev_t * dev)) {
     while (true) {
 
         // Initially assume nothing is connected.
+        legodev_pup_disable_uart(dev->pins);
         dev->dcm.connected_type_id = PBDRV_LEGODEV_TYPE_ID_NONE;
         dev->dcm.dev_id_match_count = 0;
 
@@ -369,6 +376,7 @@ static PT_THREAD(pbdrv_legodev_pup_thread(ext_dev_t * dev)) {
         // disconnects, as observed by the UART process not getting valid data.
         legodev_pup_enable_uart(dev->pins);
         PT_SPAWN(&dev->pt, &dev->child, pbdrv_legodev_pup_uart_thread(&dev->child, dev->uart_dev));
+
     }
     PT_END(&dev->pt);
 }
@@ -405,6 +413,14 @@ PROCESS_THREAD(pbio_legodev_pup_process, ev, data) {
     PROCESS_END();
 }
 
+/**
+ * We get notified when the uart driver has completed sending or receiving data.
+ */
+static void uart_poll_callback(pbdrv_uart_dev_t *uart) {
+    // REVISIT: Only need to poll the specified uart device.
+    process_poll(&pbio_legodev_pup_process);
+}
+
 void pbdrv_legodev_init(void) {
     #if PBDRV_CONFIG_LEGODEV_PUP_NUM_INT_DEV > 0
     for (uint8_t i = 0; i < PBDRV_CONFIG_LEGODEV_PUP_NUM_INT_DEV; i++) {
@@ -431,7 +447,15 @@ void pbdrv_legodev_init(void) {
         pbio_dcmotor_get_dcmotor(legodev, &dcmotor);
         legodev->ext_dev->uart_dev = pbdrv_legodev_pup_uart_configure(legodev_data->ioport_index, port_data->uart_driver_index, dcmotor);
 
+        // legodev driver is started after all other drivers, so we
+        // assume that we do not need to wait for this to be ready.
+        pbdrv_uart_dev_t *uart;
+        pbdrv_uart_get(port_data->uart_driver_index, &uart);
+
+        // Set callback for uart driver.
+        pbdrv_uart_set_poll_callback(uart, uart_poll_callback);
     }
+
     process_start(&pbio_legodev_pup_process);
 }
 

lib/pbio/drv/legodev/legodev_pup_uart.c

@@ -160,6 +160,8 @@ struct _pbdrv_legodev_pup_uart_dev_t {
     struct pt pt;
     /** Protothread for receiving sensor data, running in parallel to the data send thread. */
     struct pt recv_pt;
+    /** Child protothread of the main protothread used for reading data */
+    struct pt read_pt;
     /** Child protothread of the main protothread used for writing data */
     struct pt write_pt;
     /** Timer for sending keepalive messages and other delays. */
@@ -199,8 +201,6 @@ struct _pbdrv_legodev_pup_uart_dev_t {
     uint32_t err_count;
     /** Number of bad reads when receiving DATA ludev->msgs. */
     uint32_t num_data_err;
-    /** Time of most recently started transmission. */
-    uint32_t tx_start_time;
     /** Flag that indicates that good DATA ludev->msg has been received since last watchdog timeout. */
     bool data_rec;
     /** Return value for synchronization thread. */
@@ -229,8 +229,6 @@ static pbdrv_legodev_pup_uart_dev_t ludevs[PBDRV_CONFIG_LEGODEV_PUP_UART_NUM_DEV
 static uint8_t data_read_bufs[PBDRV_CONFIG_LEGODEV_PUP_UART_NUM_DEV][PBDRV_LEGODEV_MAX_DATA_SIZE] __attribute__((aligned(4)));
 static pbdrv_legodev_pup_uart_data_set_t data_set_bufs[PBDRV_CONFIG_LEGODEV_PUP_UART_NUM_DEV];
 
-#define PBIO_PT_WAIT_READY(pt, expr) PT_WAIT_UNTIL((pt), (expr) != PBIO_ERROR_AGAIN)
-
 pbdrv_legodev_pup_uart_dev_t *pbdrv_legodev_pup_uart_configure(uint8_t device_index, uint8_t uart_driver_index, pbio_dcmotor_t *dcmotor) {
     pbdrv_legodev_pup_uart_dev_t *ludev = &ludevs[device_index];
     ludev->dcmotor = dcmotor;
@@ -694,16 +692,6 @@ static void pbdrv_legodev_pup_uart_reset(pbdrv_legodev_pup_uart_dev_t *ludev) {
     }
 }
 
-static PT_THREAD(pbdrv_legodev_pup_uart_send_prepared_msg(pbdrv_legodev_pup_uart_dev_t * ludev, pbio_error_t * err)) {
-    PT_BEGIN(&ludev->write_pt);
-    ludev->tx_start_time = pbdrv_clock_get_ms();
-    PBIO_PT_WAIT_READY(&ludev->write_pt, *err = pbdrv_uart_write_begin(ludev->uart, ludev->tx_msg, ludev->tx_msg_size, EV3_UART_IO_TIMEOUT));
-    if (*err == PBIO_SUCCESS) {
-        PBIO_PT_WAIT_READY(&ludev->write_pt, *err = pbdrv_uart_write_end(ludev->uart));
-    }
-    PT_END(&ludev->write_pt);
-}
-
 /**
  * The synchronization thread for the LEGO UART device.
  *
@@ -734,7 +722,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_synchronize_thread(pbdrv_legodev_pup_uar
 
     pbdrv_uart_flush(ludev->uart);
 
-    PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_legodev_pup_uart_send_prepared_msg(ludev, &ludev->err));
+    PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_uart_write(&ludev->write_pt, ludev->uart, ludev->tx_msg, ludev->tx_msg_size, EV3_UART_IO_TIMEOUT, &ludev->err));
     if (ludev->err != PBIO_SUCCESS) {
         DBG_ERR(ludev->last_err = "Speed tx failed");
         PT_EXIT(&ludev->pt);
@@ -743,13 +731,8 @@ static PT_THREAD(pbdrv_legodev_pup_uart_synchronize_thread(pbdrv_legodev_pup_uar
     pbdrv_uart_flush(ludev->uart);
 
     // read one byte to check for ACK
-    PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_begin(ludev->uart, ludev->rx_msg, 1, 10));
-    if (ludev->err != PBIO_SUCCESS) {
-        DBG_ERR(ludev->last_err = "UART Rx error during baud");
-        PT_EXIT(&ludev->pt);
-    }
+    PT_SPAWN(&ludev->pt, &ludev->read_pt, pbdrv_uart_read(&ludev->read_pt, ludev->uart, ludev->rx_msg, 1, 10, &ludev->err));
 
-    PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_end(ludev->uart));
     if ((ludev->err == PBIO_SUCCESS && ludev->rx_msg[0] != LUMP_SYS_ACK) || ludev->err == PBIO_ERROR_TIMEDOUT) {
         // if we did not get ACK within 100ms, then switch to slow baud rate for sync
         pbdrv_uart_set_baud_rate(ludev->uart, EV3_UART_SPEED_MIN);
@@ -758,18 +741,14 @@ static PT_THREAD(pbdrv_legodev_pup_uart_synchronize_thread(pbdrv_legodev_pup_uar
         DBG_ERR(ludev->last_err = "UART Rx error during baud");
         PT_EXIT(&ludev->pt);
     }
-
 sync:
 
     // To get in sync with the data stream from the sensor, we look for a valid TYPE command.
     for (;;) {
-
-        PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_begin(ludev->uart, ludev->rx_msg, 1, EV3_UART_IO_TIMEOUT));
-        if (ludev->err != PBIO_SUCCESS) {
-            DBG_ERR(ludev->last_err = "UART Rx error during sync");
-            PT_EXIT(&ludev->pt);
-        }
-        PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_end(ludev->uart));
+        // If there are multiple bytes waiting to be read, this drains them one
+        // by one without requiring additional polls. This means we won't need
+        // exact timing to get in sync.
+        PT_SPAWN(&ludev->pt, &ludev->read_pt, pbdrv_uart_read(&ludev->read_pt, ludev->uart, ludev->rx_msg, 1, EV3_UART_IO_TIMEOUT, &ludev->err));
         if (ludev->err == PBIO_ERROR_TIMEDOUT) {
             continue;
         }
@@ -784,13 +763,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_synchronize_thread(pbdrv_legodev_pup_uar
     }
 
     // then read the rest of the message
-
-    PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_begin(ludev->uart, ludev->rx_msg + 1, 2, EV3_UART_IO_TIMEOUT));
-    if (ludev->err != PBIO_SUCCESS) {
-        DBG_ERR(ludev->last_err = "UART Rx error while reading type");
-        PT_EXIT(&ludev->pt);
-    }
-    PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_end(ludev->uart));
+    PT_SPAWN(&ludev->pt, &ludev->read_pt, pbdrv_uart_read(&ludev->read_pt, ludev->uart, ludev->rx_msg + 1, 2, EV3_UART_IO_TIMEOUT, &ludev->err));
     if (ludev->err != PBIO_SUCCESS) {
         DBG_ERR(ludev->last_err = "UART Rx error while reading type");
         PT_EXIT(&ludev->pt);
@@ -825,12 +798,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_synchronize_thread(pbdrv_legodev_pup_uar
 
     while (ludev->status == PBDRV_LEGODEV_PUP_UART_STATUS_INFO) {
         // read the message header
-        PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_begin(ludev->uart, ludev->rx_msg, 1, EV3_UART_IO_TIMEOUT));
-        if (ludev->err != PBIO_SUCCESS) {
-            DBG_ERR(ludev->last_err = "UART Rx begin error during info header");
-            PT_EXIT(&ludev->pt);
-        }
-        PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_end(ludev->uart));
+        PT_SPAWN(&ludev->pt, &ludev->read_pt, pbdrv_uart_read(&ludev->read_pt, ludev->uart, ludev->rx_msg, 1, EV3_UART_IO_TIMEOUT, &ludev->err));
         if (ludev->err != PBIO_SUCCESS) {
             DBG_ERR(ludev->last_err = "UART Rx end error during info header");
             PT_EXIT(&ludev->pt);
@@ -845,12 +813,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_synchronize_thread(pbdrv_legodev_pup_uar
 
         // read the rest of the message
         if (ludev->rx_msg_size > 1) {
-            PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_begin(ludev->uart, ludev->rx_msg + 1, ludev->rx_msg_size - 1, EV3_UART_IO_TIMEOUT));
-            if (ludev->err != PBIO_SUCCESS) {
-                DBG_ERR(ludev->last_err = "UART Rx begin error during info");
-                PT_EXIT(&ludev->pt);
-            }
-            PBIO_PT_WAIT_READY(&ludev->pt, ludev->err = pbdrv_uart_read_end(ludev->uart));
+            PT_SPAWN(&ludev->pt, &ludev->read_pt, pbdrv_uart_read(&ludev->read_pt, ludev->uart, ludev->rx_msg + 1, ludev->rx_msg_size - 1, EV3_UART_IO_TIMEOUT, &ludev->err));
             if (ludev->err != PBIO_SUCCESS) {
                 DBG_ERR(ludev->last_err = "UART Rx end error during info");
                 PT_EXIT(&ludev->pt);
@@ -871,7 +834,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_synchronize_thread(pbdrv_legodev_pup_uar
     // reply with ACK
     ludev->tx_msg[0] = LUMP_SYS_ACK;
     ludev->tx_msg_size = 1;
-    PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_legodev_pup_uart_send_prepared_msg(ludev, &ludev->err));
+    PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_uart_write(&ludev->write_pt, ludev->uart, ludev->tx_msg, ludev->tx_msg_size, EV3_UART_IO_TIMEOUT, &ludev->err));
     if (ludev->err != PBIO_SUCCESS) {
         DBG_ERR(ludev->last_err = "UART Tx error during ack.");
         PT_EXIT(&ludev->pt);
@@ -942,7 +905,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_send_thread(pbdrv_legodev_pup_uart_dev_t
             ludev->data_rec = false;
             ludev->tx_msg[0] = LUMP_SYS_NACK;
             ludev->tx_msg_size = 1;
-            PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_legodev_pup_uart_send_prepared_msg(ludev, &ludev->err));
+            PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_uart_write(&ludev->write_pt, ludev->uart, ludev->tx_msg, ludev->tx_msg_size, EV3_UART_IO_TIMEOUT, &ludev->err));
             if (ludev->err != PBIO_SUCCESS) {
                 DBG_ERR(ludev->last_err = "Error during keepalive.");
                 PT_EXIT(&ludev->pt);
@@ -959,7 +922,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_send_thread(pbdrv_legodev_pup_uart_dev_t
         if (ludev->mode_switch.requested) {
             ludev->mode_switch.requested = false;
             ev3_uart_prepare_tx_msg(ludev, LUMP_MSG_TYPE_CMD, LUMP_CMD_SELECT, &ludev->mode_switch.desired_mode, 1);
-            PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_legodev_pup_uart_send_prepared_msg(ludev, &ludev->err));
+            PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_uart_write(&ludev->write_pt, ludev->uart, ludev->tx_msg, ludev->tx_msg_size, EV3_UART_IO_TIMEOUT, &ludev->err));
             if (ludev->err != PBIO_SUCCESS) {
                 DBG_ERR(ludev->last_err = "Setting requested mode failed.");
                 PT_EXIT(&ludev->pt);
@@ -973,7 +936,7 @@ static PT_THREAD(pbdrv_legodev_pup_uart_send_thread(pbdrv_legodev_pup_uart_dev_t
                 ev3_uart_prepare_tx_msg(ludev, LUMP_MSG_TYPE_DATA, ludev->data_set->desired_mode, ludev->data_set->bin_data, ludev->data_set->size);
                 ludev->data_set->size = 0;
                 ludev->data_set->time = pbdrv_clock_get_ms();
-                PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_legodev_pup_uart_send_prepared_msg(ludev, &ludev->err));
+                PT_SPAWN(&ludev->pt, &ludev->write_pt, pbdrv_uart_write(&ludev->write_pt, ludev->uart, ludev->tx_msg, ludev->tx_msg_size, EV3_UART_IO_TIMEOUT, &ludev->err));
                 if (ludev->err != PBIO_SUCCESS) {
                     DBG_ERR(ludev->last_err = "Setting requested data failed.");
                     PT_EXIT(&ludev->pt);
@@ -1004,19 +967,11 @@ static PT_THREAD(pbdrv_legodev_pup_uart_receive_data_thread(pbdrv_legodev_pup_ua
     // loose data. For now, the retry after bad message size helps get back into
     // sync with the data stream.
 
-    pbio_error_t err;
-
     PT_BEGIN(&ludev->recv_pt);
 
     while (true) {
-        PBIO_PT_WAIT_READY(&ludev->recv_pt,
-            err = pbdrv_uart_read_begin(ludev->uart, ludev->rx_msg, 1, EV3_UART_IO_TIMEOUT));
-        if (err != PBIO_SUCCESS) {
-            DBG_ERR(ludev->last_err = "UART Rx data header begin error");
-            break;
-        }
-        PBIO_PT_WAIT_READY(&ludev->recv_pt, err = pbdrv_uart_read_end(ludev->uart));
-        if (err != PBIO_SUCCESS) {
+        PT_SPAWN(&ludev->recv_pt, &ludev->read_pt, pbdrv_uart_read(&ludev->read_pt, ludev->uart, ludev->rx_msg, 1, EV3_UART_IO_TIMEOUT, &ludev->err));
+        if (ludev->err != PBIO_SUCCESS) {
             DBG_ERR(ludev->last_err = "UART Rx data header end error");
             break;
         }
@@ -1035,14 +990,8 @@ static PT_THREAD(pbdrv_legodev_pup_uart_receive_data_thread(pbdrv_legodev_pup_ua
             continue;
         }
 
-        PBIO_PT_WAIT_READY(&ludev->recv_pt,
-            err = pbdrv_uart_read_begin(ludev->uart, ludev->rx_msg + 1, ludev->rx_msg_size - 1, EV3_UART_IO_TIMEOUT));
-        if (err != PBIO_SUCCESS) {
-            DBG_ERR(ludev->last_err = "UART Rx data begin error");
-            break;
-        }
-        PBIO_PT_WAIT_READY(&ludev->recv_pt, err = pbdrv_uart_read_end(ludev->uart));
-        if (err != PBIO_SUCCESS) {
+        PT_SPAWN(&ludev->recv_pt, &ludev->read_pt, pbdrv_uart_read(&ludev->read_pt, ludev->uart, ludev->rx_msg + 1, ludev->rx_msg_size - 1, EV3_UART_IO_TIMEOUT, &ludev->err));
+        if (ludev->err != PBIO_SUCCESS) {
             DBG_ERR(ludev->last_err = "UART Rx data end error");
             break;
         }