cleanup and added sync + async commands

units/usart/unit_usart.c

@@ -6,10 +6,36 @@
 #include "comm/messages.h"
 #include "unit_base.h"
 #include "unit_usart.h"
+#include "tasks/task_msg.h"
 
 #define UUSART_INTERNAL
 #include "_internal.h"
 
+static void UUSART_SendReceivedDataToMaster(Job *job)
+{
+    Unit *unit = job->data1;
+    struct priv *priv = unit->data;
+
+    uint32_t readpos = job->d32;
+    uint32_t count = job->len;
+
+    // Debug: print to debug port
+//    PUTS("Job rx >");
+//    PUTSN((char *) priv->rx_buffer + readpos, (uint16_t) count);
+//    PUTS("<\r\n");
+
+    // Debug: Write out
+//    UU_USART_Write(unit, (const uint8_t *) (priv->rx_buffer + readpos), count);
+
+    // TODO modify TF to allow writing in multiple chunks to avoid this useless buffer copying
+    PayloadBuilder pb = pb_start(unit_tmp512, UNIT_TMP_LEN, NULL);
+    pb_u8(&pb, unit->callsign);
+    pb_u8(&pb, 0x00); // report type "Data received"
+    pb_buf(&pb, (uint8_t *) (priv->rx_buffer + readpos), count);
+    assert_param(pb.ok);
+    com_send_pb(MSG_UNIT_REPORT, &pb);
+}
+
 /**
  * Handle received data (we're inside the IRQ)
  *
@@ -23,55 +49,90 @@ void UUSART_DMA_HandleRxFromIRQ(Unit *unit, uint16_t endpos)
     assert_param(priv);
 
     uint16_t readpos = priv->rx_buf_readpos;
-
     assert_param(endpos > readpos);
 
     uint16_t count = (endpos - readpos);
-    uint8_t *start = (uint8_t *) (priv->rx_buffer + readpos);
 
-    // Do something with the data...
-    PUTSN((char *) start, count);
-    PUTNL();
+    // We defer it to the job queue
+    // FIXME this can starve the shared queue if full duplex is used, we need a second higher priority queue for those report jobs
+    Job j = {
+        .data1 = unit,
+        .d32 = priv->rx_buf_readpos,
+        .len = count,
+        .cb = UUSART_SendReceivedDataToMaster
+    };
+    scheduleJob(&j);
 
     // Move the read cursor, wrap around if needed
     if (endpos == UUSART_RXBUF_LEN) endpos = 0;
     priv->rx_buf_readpos = endpos;
 }
 
+
+error_t UU_USART_Write(Unit *unit, const uint8_t *buffer, uint32_t len)
+{
+    CHECK_TYPE(unit, &UNIT_USART);
+    struct priv *priv = unit->data;
+
+    uint32_t t_start = HAL_GetTick();
+    while (len > 0) {
+        // this should be long enough even for the slowest bitrates and 512 bytes
+        if (HAL_GetTick() - t_start > 5000) {
+            return E_HW_TIMEOUT;
+        }
+
+        uint16_t chunk = UUSART_DMA_TxQueue(priv, buffer, (uint16_t) len);
+
+        buffer += chunk;
+        len -= chunk;
+
+        // We give up control if there's another thread waiting and this isn't the last cycle
+        if (len > 0) {
+            osThreadYield();
+        }
+    }
+
+    return E_SUCCESS;
+}
+
+error_t UU_USART_WriteSync(Unit *unit, const uint8_t *buffer, uint32_t len)
+{
+    CHECK_TYPE(unit, &UNIT_USART);
+    struct priv *priv = unit->data;
+
+    TRY(UU_USART_Write(unit, buffer, len));
+
+    // Now wait for the last DMA to complete
+    uint32_t t_start = HAL_GetTick();
+    while (priv->tx_dma_busy) {
+        if (HAL_GetTick() - t_start > 1000) {
+            return E_HW_TIMEOUT;
+        }
+    }
+
+    return E_SUCCESS;
+}
+
 enum PinCmd_ {
     CMD_WRITE = 0,
+    CMD_WRITE_SYNC = 1,
 };
 
 /** Handle a request message */
 static error_t UUSART_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command, PayloadParser *pp)
 {
-    struct priv *priv = unit->data;
-
+    uint32_t len;
+    const uint8_t *pld;
     switch (command) {
-        case CMD_WRITE:;
-            uint32_t len;
-            const uint8_t *pld = pp_tail(pp, &len);
-
-            uint32_t t_start = HAL_GetTick();
-            while (len > 0) {
-                // this should be long enough even for the slowest bitrates and 512 bytes
-                if (HAL_GetTick() - t_start > 5000) {
-                    return E_HW_TIMEOUT;
-                }
-
-                uint16_t chunk = UUSART_DMA_TxQueue(priv, pld, (uint16_t) len);
-
-                pld += chunk;
-                len -= chunk;
-
-                // We give up control if there's another thread waiting and this isn't the last cycle
-                if (len > 0) {
-                    osThreadYield();
-                }
-            }
-
+        case CMD_WRITE:
+            pld = pp_tail(pp, &len);
+            TRY(UU_USART_Write(unit, pld, len));
+            return E_SUCCESS;
+
+        case CMD_WRITE_SYNC:
+            pld = pp_tail(pp, &len);
+            TRY(UU_USART_WriteSync(unit, pld, len));
             return E_SUCCESS;
-            //return E_NOT_IMPLEMENTED;
 
         default:
             return E_UNKNOWN_COMMAND;

units/usart/unit_usart.h

@@ -9,4 +9,26 @@
 
 extern const UnitDriver UNIT_USART;
 
+/**
+ * Write bytes. This function is asynchronous and does not wait for completion.
+ * It blocks until there's space in the Tx buffer for the data.
+ *
+ * @param unit
+ * @param buffer - bytes to send
+ * @param len - number of bytes to send
+ * @return success
+ */
+error_t UU_USART_Write(Unit *unit, const uint8_t *buffer, uint32_t len);
+
+/**
+ * Write bytes. Same like UU_USART_Write(), except it waits for the transmission
+ * to complete after sending the last data.
+ *
+ * @param unit
+ * @param buffer - bytes to send
+ * @param len - number of bytes to send
+ * @return success
+ */
+error_t UU_USART_WriteSync(Unit *unit, const uint8_t *buffer, uint32_t len);
+
 #endif //GEX_F072_UNIT_USART_H