various speed-ups in TF_WriteImpl and elsewhere

TinyFrame/TF_Integration.c

@@ -4,48 +4,40 @@
 // TinyFrame integration
 //
 
-#include <USB/usb_device.h>
 #include "platform.h"
 #include "task_main.h"
 
 #include "USB/usbd_cdc_if.h"
+#include "USB/usb_device.h"
 #include "TinyFrame.h"
 
 extern osSemaphoreId semVcomTxReadyHandle;
 extern osMutexId mutTinyFrameTxHandle;
 
-static volatile bool first_tx = false; // XXX global
-
 void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len)
 {
 #if 1
-//    if (!first_tx) {
-//        // wait for the last USB transmission to be finished
-//        int32_t mxStatus;
-//        mxStatus = osSemaphoreWait(semVcomTxReadyHandle, 100);
-//        if (mxStatus != osOK) {
-//            TF_Error("Tx stalled");
-//            return;
-//        }
-//    }
-//    first_tx = false;
+    const uint32_t real_size = len;
 
-    // Padding to a multiple of 64 bytes
+    // Padding to a multiple of 64 bytes - this is supposed to maximize the bulk transfer speed
     if (len&0x3F) {
         uint32_t pad = (64 - (len&0x3F));
         memset((void *) (buff + len), 0, pad);
         len += pad; // padding to a multiple of 64 (size of the endpoint)
     }
 
+    // We bypass the USBD driver library's overhead by using the HAL function directly
     assert_param(HAL_OK == HAL_PCD_EP_Transmit(hUsbDeviceFS.pData, CDC_IN_EP, (uint8_t *) buff, len));
 
-    // Wait for the semaphore - HAL keeps a pointer to the buffer, and it's the TinyFrame Tx buffer,
-    // so if we let it process it in the background, it could get corrupted before the Tx is completed.
-    int32_t mxStatus;
-    mxStatus = osSemaphoreWait(semVcomTxReadyHandle, 100);
-    if (mxStatus != osOK) {
-        TF_Error("Tx stalled");
-        return;
+    // The buffer is the TF transmit buffer, we can't leave it to work asynchronously because
+    // the next call could modify it before it's been transmitted (in the case of a chunked / multi-part frame)
+
+    // the assumption here is that all until the last chunk use the full buffer capacity
+    if (real_size == TF_SENDBUF_LEN) {
+        if (pdTRUE != xSemaphoreTake(semVcomTxReadyHandle, 100)) {
+            TF_Error("Tx stalled in WriteImpl");
+            return;
+        }
     }
 #else
     (void) tf;
@@ -76,20 +68,18 @@ void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len)
 bool TF_ClaimTx(TinyFrame *tf)
 {
     (void) tf;
-//    assert_param(osThreadGetId() != tskMainHandle);
-    assert_param(!inIRQ());
+//    assert_param(!inIRQ()); // useless delay
+    assert_param(pdTRUE == xSemaphoreTake(mutTinyFrameTxHandle, 5000)); // trips the wd
 
-    assert_param(osOK == osMutexWait(mutTinyFrameTxHandle, 5000));
+    // The last chunk from some previous frame may still be being transmitted,
+    // wait for it to finish (the semaphore is given in the CDC tx done handler)
+    if (pdTRUE != xSemaphoreTake(semVcomTxReadyHandle, 100)) {
+        TF_Error("Tx stalled in Claim");
 
-//    // wait for the last USB transmission to be finished
-//    int32_t mxStatus;
-//    mxStatus = osSemaphoreWait(semVcomTxReadyHandle, 100);
-//    if (mxStatus != osOK) {
-//        TF_Error("Tx stalled");
-//        return false;
-//    }
-
-    first_tx = true;
+        // release the guarding mutex again
+        assert_param(pdTRUE == xSemaphoreGive(mutTinyFrameTxHandle));
+        return false;
+    }
 
     return true;
 }
@@ -98,5 +88,7 @@ bool TF_ClaimTx(TinyFrame *tf)
 void TF_ReleaseTx(TinyFrame *tf)
 {
     (void) tf;
-    assert_param(osOK == osMutexRelease(mutTinyFrameTxHandle));
+    assert_param(pdTRUE == xSemaphoreGive(mutTinyFrameTxHandle));
+
+    // the last payload is sent asynchronously
 }

TinyFrame/TinyFrame.c

@@ -870,7 +870,11 @@ static inline uint32_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
  */
 static bool _TF_FN TF_SendFrame_Begin(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
 {
-    TF_TRY(TF_ClaimTx(tf));
+    bool suc = TF_ClaimTx(tf);
+    if (!suc) {
+        TF_Error("TF lock not free");
+        return false;
+    }
 
     tf->tx_pos = (uint32_t) TF_ComposeHead(tf, tf->sendbuf, msg); // frame ID is incremented here if it's not a response
     tf->tx_len = msg->len;
@@ -1031,10 +1035,10 @@ bool _TF_FN TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener,
     return TF_Query(tf, msg, listener, timeout);
 }
 
-void _TF_FN TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg)
+bool _TF_FN TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg)
 {
     msg->data = NULL;
-    TF_Respond(tf, msg);
+    return TF_Respond(tf, msg);
 }
 
 void _TF_FN TF_Multipart_Payload(TinyFrame *tf, const uint8_t *buff, uint32_t length)

TinyFrame/TinyFrame.h

@@ -369,7 +369,7 @@ bool TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TIC
  * TF_Respond() with multipart payload.
  * msg.data is ignored and set to NULL
  */
-void TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg);
+bool TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg);
 
 /**
  * Send the payload for a started multipart frame. This can be called multiple times