pbio/drv/adc_ev3: Drop poll_soon and just poll faster.

Now that the ADC uses DMA, there is little cost in just polling faster. This way we don't end up polling in a tight loop when many NXT light or color sensors are attached.

Also add a way to await new samples so we don't have to hardcode delays at higher levels.

Author: laurensvalk

lib/pbio/drv/adc/adc_ev3.c

@@ -47,7 +47,7 @@ enum {
     // 150 MHz / 8 = 18.75 MHz actual
     SPI_CLK_SPEED_ADC = 20000000,
 
-    ADC_SAMPLE_PERIOD = 10,
+    ADC_SAMPLE_PERIOD = 2,
 };
 
 // Construct both SPI peripheral settings (data format, chip select)
@@ -94,8 +94,6 @@ static const uint32_t channel_cmd[PBDRV_CONFIG_ADC_EV3_ADC_NUM_CHANNELS + PBDRV_
 };
 static volatile uint16_t channel_data[PBDRV_CONFIG_ADC_EV3_ADC_NUM_CHANNELS + PBDRV_ADC_EV3_NUM_DELAY_SAMPLES];
 
-static int adc_soon;
-
 static pbdrv_adc_callback_t pbdrv_adc_callbacks[1];
 static uint32_t pbdrv_adc_callback_count = 0;
 
@@ -137,39 +135,33 @@ pbio_error_t pbdrv_adc_ev3_exit(pbio_os_state_t *state) {
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
-pbio_error_t pbdrv_adc_ev3_process_thread(pbio_os_state_t *state, void *context) {
+static pbio_error_t pbdrv_adc_ev3_process_thread(pbio_os_state_t *state, void *context) {
     static pbio_os_timer_t timer;
 
     PBIO_OS_ASYNC_BEGIN(state);
 
-    pbio_os_timer_set(&timer, ADC_SAMPLE_PERIOD);
-
-    for (;;) {
-        PBIO_OS_AWAIT_UNTIL(state, pbdrv_adc_ev3_process.request || adc_soon || pbio_os_timer_is_expired(&timer));
-
-        // Here we can exit gracefully since no SPI operation is in progress.
-        if (pbdrv_adc_ev3_process.request & PBIO_OS_PROCESS_REQUEST_TYPE_CANCEL) {
-            break;
-        }
-
-        if (adc_soon) {
-            adc_soon = 0;
-            pbio_os_timer_set(&timer, ADC_SAMPLE_PERIOD);
-        } else {
-            // TODO: There should probably be a pbio OS function for this
-            timer.start += timer.duration;
-        }
+    // Poll continuously until cancellation is requested.
+    while (!(pbdrv_adc_ev3_process.request & PBIO_OS_PROCESS_REQUEST_TYPE_CANCEL)) {
 
-        // Do a sample of all channels
+        // Start a sample of all channels
         pbdrv_block_device_ev3_spi_begin_for_adc(
             channel_cmd,
             channel_data,
             PBDRV_CONFIG_ADC_EV3_ADC_NUM_CHANNELS + PBDRV_ADC_EV3_NUM_DELAY_SAMPLES);
+
+        // Allow event loop to run once so that processes that await new
+        // samples can begin awaiting completion of the transfer.
+        PBIO_OS_AWAIT_ONCE_AND_POLL(state);
+
+        // Await for actual transfer to complete.
         PBIO_OS_AWAIT_WHILE(state, pbdrv_block_device_ev3_is_busy());
 
         for (uint32_t i = 0; i < pbdrv_adc_callback_count; i++) {
             pbdrv_adc_callbacks[i]();
         }
+
+        pbio_os_timer_set(&timer, ADC_SAMPLE_PERIOD);
+        PBIO_OS_AWAIT_UNTIL(state, pbdrv_adc_ev3_process.request || pbio_os_timer_is_expired(&timer));
     }
 
     // Processes may be waiting on us to complete, so kick when done.
@@ -178,9 +170,11 @@ pbio_error_t pbdrv_adc_ev3_process_thread(pbio_os_state_t *state, void *context)
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
-void pbdrv_adc_update_soon(void) {
-    adc_soon = 1;
-    pbio_os_request_poll();
+pbio_error_t pbdrv_adc_await_new_samples(pbio_os_state_t *state) {
+    PBIO_OS_ASYNC_BEGIN(state);
+    PBIO_OS_AWAIT_UNTIL(state, pbdrv_block_device_ev3_is_busy());
+    PBIO_OS_AWAIT_UNTIL(state, !pbdrv_block_device_ev3_is_busy());
+    PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
 // Public init is not used.

lib/pbio/drv/adc/adc_stm32_hal.c

@@ -50,7 +50,8 @@ PROCESS(pbdrv_adc_process, "ADC");
 void pbdrv_adc_set_callback(pbdrv_adc_callback_t callback) {
 }
 
-void pbdrv_adc_update_soon(void) {
+pbio_error_t pbdrv_adc_await_new_samples(pbio_os_state_t *state) {
+    return PBIO_ERROR_NOT_SUPPORTED;
 }
 
 pbio_error_t pbdrv_adc_get_ch(uint8_t ch, uint16_t *value) {

lib/pbio/drv/adc/adc_stm32f0.c

@@ -69,7 +69,8 @@ void pbdrv_adc_init(void) {
 void pbdrv_adc_set_callback(pbdrv_adc_callback_t callback) {
 }
 
-void pbdrv_adc_update_soon(void) {
+pbio_error_t pbdrv_adc_await_new_samples(pbio_os_state_t *state) {
+    return PBIO_ERROR_NOT_SUPPORTED;
 }
 
 // does a single conversion for the specified channel

lib/pbio/include/pbdrv/adc.h

@@ -13,6 +13,7 @@
 
 #include <pbdrv/config.h>
 #include <pbio/error.h>
+#include <pbio/os.h>
 
 typedef void (*pbdrv_adc_callback_t)(void);
 
@@ -38,11 +39,13 @@ pbio_error_t pbdrv_adc_get_ch(uint8_t ch, uint16_t *value);
 void pbdrv_adc_set_callback(pbdrv_adc_callback_t callback);
 
 /**
- * Requests the ADC to update soon.
+ * Awaits for ADC to have new samples ready to be read.
  *
- * NB: Not implemented on all platforms.
+ * Not implemented on all platforms.
+ *
+ * @param [in] state    Protothread state.
  */
-void pbdrv_adc_update_soon(void);
+pbio_error_t pbdrv_adc_await_new_samples(pbio_os_state_t *state);
 
 #else
 
@@ -54,7 +57,8 @@ static inline pbio_error_t pbdrv_adc_get_ch(uint8_t ch, uint16_t *value) {
 static inline void pbdrv_adc_set_callback(pbdrv_adc_callback_t callback) {
 }
 
-static inline void pbdrv_adc_update_soon(void) {
+static inline pbio_error_t pbdrv_adc_await_new_samples(pbio_os_state_t *state) {
+    return PBIO_ERROR_NOT_SUPPORTED;
 }
 
 #endif

lib/pbio/src/port_dcm_ev3.c

@@ -317,25 +317,6 @@ static pbio_port_dcm_t dcm_state[PBIO_CONFIG_PORT_DCM_NUM_DEV];
 #define DCM_LOOP_STEADY_STATE_COUNT (20)
 #define DCM_LOOP_DISCONNECT_COUNT (5)
 
-pbio_error_t pbio_port_dcm_await_new_nxt_analog_sample(pbio_port_dcm_t *dcm, pbio_os_timer_t *timer, const pbdrv_ioport_pins_t *pins, uint32_t *value) {
-    pbio_os_state_t *state = &dcm->child;
-
-    PBIO_OS_ASYNC_BEGIN(state);
-
-    // Wait for LED to settle.
-    PBIO_OS_AWAIT_MS(state, timer, 1);
-
-    // Request a new ADC sample. Revisit: Call back on completion instead of time.
-    pbdrv_adc_update_soon();
-    PBIO_OS_AWAIT_MS(state, timer, 4);
-
-    // Get the value.
-    uint8_t pin = dcm->category == DCM_CATEGORY_NXT_COLOR ? 6 : 1;
-    *value = pbio_port_dcm_get_mv(pins, pin);
-
-    PBIO_OS_ASYNC_END(PBIO_SUCCESS);
-}
-
 /**
  * Thread that detects the device type. It monitors the ID1 and ID2 pins
  * on the port to see when devices are connected or disconnected.
@@ -387,6 +368,25 @@ pbio_error_t pbio_port_dcm_thread(pbio_os_state_t *state, pbio_os_timer_t *timer
             continue;
         }
 
+        if (dcm->category == DCM_CATEGORY_NXT_LIGHT) {
+            debug_pr("Reading NXT Light Sensor until disconnected.\n");
+            // While plugged in, get reflected and ambient light intensity.
+            while (!pbdrv_gpio_input(&pins->p2)) {
+                // Reflected intensity.
+                pbdrv_gpio_out_high(&pins->p5);
+                PBIO_OS_AWAIT_MS(state, timer, 2);
+                PBIO_OS_AWAIT(state, &dcm->child, pbdrv_adc_await_new_samples(&dcm->child));
+                dcm->nxt_rgba.r = pbio_port_dcm_get_mv(pins, 1);
+
+                // Ambient intensity.
+                pbdrv_gpio_out_low(&pins->p5);
+                PBIO_OS_AWAIT_MS(state, timer, 2);
+                PBIO_OS_AWAIT(state, &dcm->child, pbdrv_adc_await_new_samples(&dcm->child));
+                dcm->nxt_rgba.a = pbio_port_dcm_get_mv(pins, 1);
+            }
+            continue;
+        }
+
         if (dcm->category == DCM_CATEGORY_NXT_COLOR) {
             debug_pr("Initializing NXT Color Sensor.\n");
 
@@ -405,30 +405,31 @@ pbio_error_t pbio_port_dcm_thread(pbio_os_state_t *state, pbio_os_timer_t *timer
                     pbio_port_dcm_nxt_color_rx_msg(&dcm->child, &dcm->nxt_color_state, pins, timer, (uint8_t *)&dcm->nxt_color_state.data + dcm->count));
             }
 
-            // Checksum and continue on failure.
+            // REVISIT: Test checksum and exit on failure.
             debug_pr("Finished initializing NXT Color Sensor.\n");
-        }
 
-        if (dcm->category == DCM_CATEGORY_NXT_LIGHT || dcm->category == DCM_CATEGORY_NXT_COLOR) {
-            debug_pr("Reading NXT Light/Color Sensor until disconnected.\n");
-            // While plugged in, toggle through available colors.
+            // While plugged in, toggle through available colors and measure intensity.
             while (!pbdrv_gpio_input(&pins->p2)) {
 
                 pbdrv_gpio_out_low(&pins->p5);
-                PBIO_OS_AWAIT(state, &dcm->child, pbio_port_dcm_await_new_nxt_analog_sample(dcm, timer, pins, &dcm->nxt_rgba.a));
-                pbdrv_gpio_out_high(&pins->p5);
-                PBIO_OS_AWAIT(state, &dcm->child, pbio_port_dcm_await_new_nxt_analog_sample(dcm, timer, pins, &dcm->nxt_rgba.r));
+                PBIO_OS_AWAIT_MS(state, timer, 2);
+                PBIO_OS_AWAIT(state, &dcm->child, pbdrv_adc_await_new_samples(&dcm->child));
+                dcm->nxt_rgba.a = pbio_port_dcm_get_mv(pins, 6);
 
-                if (dcm->category == DCM_CATEGORY_NXT_LIGHT) {
-                    // Light sensor doesn't have green and blue.
-                    continue;
-                }
+                pbdrv_gpio_out_high(&pins->p5);
+                PBIO_OS_AWAIT_MS(state, timer, 2);
+                PBIO_OS_AWAIT(state, &dcm->child, pbdrv_adc_await_new_samples(&dcm->child));
+                dcm->nxt_rgba.r = pbio_port_dcm_get_mv(pins, 6);
 
                 pbdrv_gpio_out_low(&pins->p5);
-                PBIO_OS_AWAIT(state, &dcm->child, pbio_port_dcm_await_new_nxt_analog_sample(dcm, timer, pins, &dcm->nxt_rgba.g));
-                pbdrv_gpio_out_high(&pins->p5);
-                PBIO_OS_AWAIT(state, &dcm->child, pbio_port_dcm_await_new_nxt_analog_sample(dcm, timer, pins, &dcm->nxt_rgba.b));
+                PBIO_OS_AWAIT_MS(state, timer, 2);
+                PBIO_OS_AWAIT(state, &dcm->child, pbdrv_adc_await_new_samples(&dcm->child));
+                dcm->nxt_rgba.g = pbio_port_dcm_get_mv(pins, 6);
 
+                pbdrv_gpio_out_high(&pins->p5);
+                PBIO_OS_AWAIT_MS(state, timer, 2);
+                PBIO_OS_AWAIT(state, &dcm->child, pbdrv_adc_await_new_samples(&dcm->child));
+                dcm->nxt_rgba.b = pbio_port_dcm_get_mv(pins, 6);
             }
             pbdrv_gpio_out_low(&pins->p5);
             continue;