Installed new TinyFrame

TinyFrame/TF_Config.h

@@ -7,48 +7,18 @@
 
 #include "platform.h"
 #include <stdint.h>
-//#include <esp8266.h> // when using with esphttpd
 
-//----------------------------- FRAME FORMAT ---------------------------------
-// The format can be adjusted to fit your particular application needs
-
-// If the connection is reliable, you can disable the SOF byte and checksums.
-// That can save up to 9 bytes of overhead.
-
-// ,-----+----+-----+------+------------+- - - -+------------,
-// | SOF | ID | LEN | TYPE | HEAD_CKSUM | DATA  | PLD_CKSUM  |
-// | 1   | ?  | ?   | ?    | ?          | ...   | ?          | <- size (bytes)
-// '-----+----+-----+------+------------+- - - -+------------'
-
-// !!! BOTH SIDES MUST USE THE SAME SETTINGS !!!
-
-// Adjust sizes as desired (1,2,4)
 #define TF_ID_BYTES     2
 #define TF_LEN_BYTES    2
 #define TF_TYPE_BYTES   1
-
-// Checksum type
-//#define TF_CKSUM_TYPE TF_CKSUM_NONE
 #define TF_CKSUM_TYPE TF_CKSUM_XOR
-//#define TF_CKSUM_TYPE TF_CKSUM_CRC16
-//#define TF_CKSUM_TYPE TF_CKSUM_CRC32
-
-// Use a SOF byte to mark the start of a frame
 #define TF_USE_SOF_BYTE 1
-// Value of the SOF byte (if TF_USE_SOF_BYTE == 1)
 #define TF_SOF_BYTE     0x01
-
-//----------------------- PLATFORM COMPATIBILITY ----------------------------
-
-// used for timeout tick counters - should be large enough for all used timeouts
 typedef uint16_t TF_TICKS;
-
-// used in loops iterating over listeners
 typedef uint8_t TF_COUNT;
+#define TF_USE_MUTEX  1
 
-//----------------------------- PARAMETERS ----------------------------------
-
-// buffers, counts and timeout are defined in plat_compat.h
+// buffer sizes and listener counts are in plat_compat.h
 
 #define TF_Error(format, ...) dbg("[TF] " format, ##__VA_ARGS__)
 

TinyFrame/TF_Integration.c

@@ -14,7 +14,7 @@
 extern osSemaphoreId semVcomTxReadyHandle;
 extern osMutexId mutTinyFrameTxHandle;
 
-void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, size_t len)
+void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len)
 {
     (void) tf;
 #define CHUNK 64 // same as TF_SENDBUF_LEN, so we should always have only one run of the loop
@@ -30,13 +30,15 @@ void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, size_t len)
 }
 
 /** Claim the TX interface before composing and sending a frame */
-void TF_ClaimTx(TinyFrame *tf)
+bool TF_ClaimTx(TinyFrame *tf)
 {
     (void) tf;
     assert_param(osThreadGetId() != tskMainHandle);
     assert_param(!inIRQ());
 
     assert_param(osOK == osMutexWait(mutTinyFrameTxHandle, 5000));
+
+    return true;
 }
 
 /** Free the TX interface after composing and sending a frame */

TinyFrame/TinyFrame.c

@@ -1,6 +1,6 @@
 //---------------------------------------------------------------------------
 #include "TinyFrame.h"
-#include <malloc.h>
+#include <stdlib.h> // - for malloc() if dynamic constructor is used
 //---------------------------------------------------------------------------
 
 // Compatibility with ESP8266 SDK
@@ -10,29 +10,88 @@
 #define _TF_FN
 #endif
 
+
 // Helper macros
-#define TF_MAX(a, b) ((a)>(b)?(a):(b))
 #define TF_MIN(a, b) ((a)<(b)?(a):(b))
+#define TF_TRY(func) do { if(!(func)) return false; } while (0)
+
+
+// Type-dependent masks for bit manipulation in the ID field
+#define TF_ID_MASK (TF_ID)(((TF_ID)1 << (sizeof(TF_ID)*8 - 1)) - 1)
+#define TF_ID_PEERBIT (TF_ID)((TF_ID)1 << ((sizeof(TF_ID)*8) - 1))
+
+
+#if !TF_USE_MUTEX
+    // Not thread safe lock implementation, used if user did not provide a better one.
+    // This is less reliable than a real mutex, but will catch most bugs caused by
+    // inappropriate use fo the API.
+
+    /** Claim the TX interface before composing and sending a frame */
+    static bool TF_ClaimTx(TinyFrame *tf) {
+        if (tf->soft_lock) {
+            TF_Error("TF already locked for tx!");
+            return false;
+        }
+
+        tf->soft_lock = true;
+        return true;
+    }
 
-// TODO It would be nice to have per-instance configurable checksum types, but that would
-// mandate configurable field sizes unless we use u32 everywhere (and possibly shorten
-// it when encoding to the buffer). I don't really like this idea so much. -MP
+    /** Free the TX interface after composing and sending a frame */
+    static void TF_ReleaseTx(TinyFrame *tf)
+    {
+        tf->soft_lock = false;
+    }
+#endif
 
 //region Checksums
 
 #if TF_CKSUM_TYPE == TF_CKSUM_NONE
 
-// NONE
-#define CKSUM_RESET(cksum)
-#define CKSUM_ADD(cksum, byte)
-#define CKSUM_FINALIZE(cksum)
+    static TF_CKSUM TF_CksumStart(void)
+      { return 0; }
+
+    static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
+      { return cksum; }
+
+    static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
+      { return cksum; }
 
 #elif TF_CKSUM_TYPE == TF_CKSUM_XOR
 
-// ~XOR
-#define CKSUM_RESET(cksum) do { (cksum) = 0; } while (0)
-#define CKSUM_ADD(cksum, byte) do { (cksum) ^= (byte); } while(0)
-#define CKSUM_FINALIZE(cksum)  do { (cksum) = (TF_CKSUM)~cksum; } while(0)
+    static TF_CKSUM TF_CksumStart(void)
+      { return 0; }
+
+    static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
+      { return cksum ^ byte; }
+
+    static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
+      { return (TF_CKSUM) ~cksum; }
+
+#elif TF_CKSUM_TYPE == TF_CKSUM_CRC8
+
+    static inline uint8_t crc8_bits(uint8_t data)
+    {
+        uint8_t crc = 0;
+        if(data & 1)     crc ^= 0x5e;
+        if(data & 2)     crc ^= 0xbc;
+        if(data & 4)     crc ^= 0x61;
+        if(data & 8)     crc ^= 0xc2;
+        if(data & 0x10)  crc ^= 0x9d;
+        if(data & 0x20)  crc ^= 0x23;
+        if(data & 0x40)  crc ^= 0x46;
+        if(data & 0x80)  crc ^= 0x8c;
+        return crc;
+    }
+
+    static TF_CKSUM TF_CksumStart(void)
+      { return 0; }
+
+    static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
+      { return crc8_bits(byte ^ cksum); }
+
+    static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
+      { return cksum; }
 
 #elif TF_CKSUM_TYPE == TF_CKSUM_CRC16
 
@@ -73,14 +132,14 @@ static const uint16_t crc16_table[256] = {
         0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
     };
 
-static inline uint16_t crc16_byte(uint16_t cksum, const uint8_t byte)
-{
-    return (cksum >> 8) ^ crc16_table[(cksum ^ byte) & 0xff];
-}
+    static TF_CKSUM TF_CksumStart(void)
+      { return 0; }
+
+    static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
+      { return (cksum >> 8) ^ crc16_table[(cksum ^ byte) & 0xff]; }
 
-#define CKSUM_RESET(cksum) do { (cksum) = 0; } while (0)
-#define CKSUM_ADD(cksum, byte) do { (cksum) = crc16_byte((cksum), (byte)); } while(0)
-#define CKSUM_FINALIZE(cksum)
+    static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
+      { return cksum; }
 
 #elif TF_CKSUM_TYPE == TF_CKSUM_CRC32
 
@@ -131,23 +190,33 @@ static const uint32_t crc32_table[] = { /* CRC polynomial 0xedb88320 */
         0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
     };
 
-static inline uint32_t crc32_byte(uint32_t cksum, const uint8_t byte)
-{
-    return (crc32_table[((cksum) ^ ((uint8_t)byte)) & 0xff] ^ ((cksum) >> 8));
-}
+    static TF_CKSUM TF_CksumStart(void)
+      { return (TF_CKSUM)0xFFFFFFFF; }
 
-#define CKSUM_RESET(cksum) do { (cksum) = (TF_CKSUM)0xFFFFFFFF; } while (0)
-#define CKSUM_ADD(cksum, byte) do { (cksum) = crc32_byte(cksum, byte); } while(0)
-#define CKSUM_FINALIZE(cksum)  do { (cksum) = (TF_CKSUM)~(cksum); } while(0)
+    static TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte)
+      { return crc32_table[((cksum) ^ ((uint8_t)byte)) & 0xff] ^ ((cksum) >> 8); }
+
+    static TF_CKSUM TF_CksumEnd(TF_CKSUM cksum)
+      { return (TF_CKSUM) ~cksum; }
 
 #endif
 
+#define CKSUM_RESET(cksum)     do { (cksum) = TF_CksumStart(); } while (0)
+#define CKSUM_ADD(cksum, byte) do { (cksum) = TF_CksumAdd((cksum), (byte)); } while (0)
+#define CKSUM_FINALIZE(cksum)  do { (cksum) = TF_CksumEnd((cksum)); } while (0)
+
 //endregion
 
+
+//region Init
+
 /** Init with a user-allocated buffer */
-void _TF_FN TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit)
+bool _TF_FN TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit)
 {
-    if (tf == NULL) return;
+    if (tf == NULL) {
+        TF_Error("TF_InitStatic() failed, tf is null.");
+        return false;
+    }
 
     // Zero it out, keeping user config
     uint32_t usertag = tf->usertag;
@@ -159,12 +228,18 @@ void _TF_FN TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit)
     tf->userdata = userdata;
 
     tf->peer_bit = peer_bit;
+    return true;
 }
 
 /** Init with malloc */
 TinyFrame * _TF_FN TF_Init(TF_Peer peer_bit)
 {
     TinyFrame *tf = malloc(sizeof(TinyFrame));
+    if (!tf) {
+        TF_Error("TF_Init() failed, out of memory.");
+        return NULL;
+    }
+
     TF_InitStatic(tf, peer_bit);
     return tf;
 }
@@ -176,6 +251,9 @@ void TF_DeInit(TinyFrame *tf)
     free(tf);
 }
 
+//endregion Init
+
+
 //region Listeners
 
 /** Reset ID listener's timeout to the original value */
@@ -191,7 +269,7 @@ static void _TF_FN cleanup_id_listener(TinyFrame *tf, TF_COUNT i, struct TF_IdLi
     if (lst->fn == NULL) return;
 
     // Make user clean up their data - only if not NULL
-    if (lst->userdata != NULL) {
+    if (lst->userdata != NULL || lst->userdata2 != NULL) {
         msg.userdata = lst->userdata;
         msg.userdata2 = lst->userdata2;
         msg.data = NULL; // this is a signal that the listener should clean up
@@ -444,12 +522,33 @@ static void _TF_FN TF_HandleReceivedMessage(TinyFrame *tf)
     TF_Error("Unhandled message, type %d", (int)msg.type);
 }
 
+/** Externally renew an ID listener */
+bool _TF_FN TF_RenewIdListener(TinyFrame *tf, TF_ID id)
+{
+    TF_COUNT i;
+    struct TF_IdListener_ *lst;
+    for (i = 0; i < tf->count_id_lst; i++) {
+        lst = &tf->id_listeners[i];
+        // test if live & matching
+        if (lst->fn != NULL && lst->id == id) {
+            renew_id_listener(lst);
+            return true;
+        }
+    }
+
+    TF_Error("Renew listener: not found (id %d)", (int)id);
+    return false;
+}
+
 //endregion Listeners
 
+
+//region Parser
+
 /** Handle a received byte buffer */
-void _TF_FN TF_Accept(TinyFrame *tf, const uint8_t *buffer, size_t count)
+void _TF_FN TF_Accept(TinyFrame *tf, const uint8_t *buffer, uint32_t count)
 {
-    size_t i;
+    uint32_t i;
     for (i = 0; i < count; i++) {
         TF_AcceptChar(tf, buffer[i]);
     }
@@ -586,8 +685,8 @@ void _TF_FN TF_AcceptChar(TinyFrame *tf, unsigned char c)
             if (tf->rxi == tf->len) {
                 #if TF_CKSUM_TYPE == TF_CKSUM_NONE
                     // All done
-                    TF_HandleReceivedMessage();
-                    TF_ResetParser();
+                    TF_HandleReceivedMessage(tf);
+                    TF_ResetParser(tf);
                 #else
                     // Enter DATA_CKSUM state
                     tf->state = TFState_DATA_CKSUM;
@@ -614,18 +713,17 @@ void _TF_FN TF_AcceptChar(TinyFrame *tf, unsigned char c)
             break;
     }
     //@formatter:on
-
-    // we get here after finishing HEAD, if no data are to be received - handle and clear
-    // TODO verify - this seems unreachable under normal circumstances
-    if (tf->len == 0 && tf->state == TFState_DATA) {
-        TF_HandleReceivedMessage(tf);
-        TF_ResetParser(tf);
-    }
 }
 
+//endregion Parser
+
+
+//region Compose and send
+
 // Helper macros for the Compose functions
 // use variables: si - signed int, b - byte, outbuff - target buffer, pos - count of bytes in buffer
 
+
 /**
  * Write a number to the output buffer.
  *
@@ -669,15 +767,15 @@ void _TF_FN TF_AcceptChar(TinyFrame *tf, unsigned char c)
  * @param msg - message written to the buffer
  * @return nr of bytes in outbuff used by the frame, 0 on failure
  */
-static inline size_t _TF_FN TF_ComposeHead(TinyFrame *tf, uint8_t *outbuff, TF_Msg *msg)
+static inline uint32_t _TF_FN TF_ComposeHead(TinyFrame *tf, uint8_t *outbuff, TF_Msg *msg)
 {
     int8_t si = 0; // signed small int
     uint8_t b = 0;
     TF_ID id = 0;
     TF_CKSUM cksum = 0;
-    size_t pos = 0; // can be needed to grow larger than TF_LEN
+    uint32_t pos = 0;
 
-    (void)cksum;
+    (void)cksum; // suppress "unused" warning if checksums are disabled
 
     CKSUM_RESET(cksum);
 
@@ -724,13 +822,13 @@ static inline size_t _TF_FN TF_ComposeHead(TinyFrame *tf, uint8_t *outbuff, TF_M
  * @param cksum - checksum variable, used for all calls to TF_ComposeBody. Must be reset before first use! (CKSUM_RESET(cksum);)
  * @return nr of bytes in outbuff used
  */
-static size_t _TF_FN TF_ComposeBody(uint8_t *outbuff,
+static inline uint32_t _TF_FN TF_ComposeBody(uint8_t *outbuff,
                                     const uint8_t *data, TF_LEN data_len,
                                     TF_CKSUM *cksum)
 {
     TF_LEN i = 0;
     uint8_t b = 0;
-    size_t pos = 0;
+    uint32_t pos = 0;
 
     for (i = 0; i < data_len; i++) {
         b = data[i];
@@ -748,11 +846,11 @@ static size_t _TF_FN TF_ComposeBody(uint8_t *outbuff,
  * @param cksum - checksum variable used for the body
  * @return nr of bytes in outbuff used
  */
-static size_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
+static inline uint32_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
 {
     int8_t si = 0; // signed small int
     uint8_t b = 0;
-    size_t pos = 0;
+    uint32_t pos = 0;
 
 #if TF_CKSUM_TYPE != TF_CKSUM_NONE
     CKSUM_FINALIZE(*cksum);
@@ -762,60 +860,109 @@ static size_t _TF_FN TF_ComposeTail(uint8_t *outbuff, TF_CKSUM *cksum)
 }
 
 /**
- * Send a message
+ * Begin building and sending a frame
  *
  * @param tf - instance
- * @param msg - message object
- * @param listener - ID listener, or NULL
- * @param timeout - listener timeout, 0 is none
- * @return true if sent
+ * @param msg - message to send
+ * @param listener - response listener or NULL
+ * @param timeout - listener timeout ticks, 0 = indefinite
+ * @return success (mutex claimed and listener added, if any)
  */
-static bool _TF_FN TF_SendFrame(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
+static bool _TF_FN TF_SendFrame_Begin(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
 {
-    size_t len = 0;
-    size_t remain = 0;
-    size_t sent = 0;
-    TF_CKSUM cksum = 0;
+    TF_TRY(TF_ClaimTx(tf));
 
-    TF_ClaimTx(tf);
+    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;
 
-    len = TF_ComposeHead(tf, tf->sendbuf, msg);
-    if (listener) TF_AddIdListener(tf, msg, listener, timeout);
+    if (listener) {
+        TF_TRY(TF_AddIdListener(tf, msg, listener, timeout));
+    }
 
-    CKSUM_RESET(cksum);
+    CKSUM_RESET(tf->tx_cksum);
+    return true;
+}
 
-    remain = msg->len;
+/**
+ * Build and send a part (or all) of a frame body.
+ * Caution: this does not check the total length against the length specified in the frame head
+ *
+ * @param tf - instance
+ * @param buff - bytes to write
+ * @param length - count
+ */
+static void _TF_FN TF_SendFrame_Chunk(TinyFrame *tf, const uint8_t *buff, uint32_t length)
+{
+    uint32_t remain;
+    uint32_t chunk;
+    uint32_t sent = 0;
+
+    remain = length;
     while (remain > 0) {
-        size_t chunk = TF_MIN(TF_SENDBUF_LEN - len, remain);
-        len += TF_ComposeBody(tf->sendbuf+len, msg->data+sent, (TF_LEN) chunk, &cksum);
+        // Write what can fit in the tx buffer
+        chunk = TF_MIN(TF_SENDBUF_LEN - tf->tx_pos, remain);
+        tf->tx_pos += TF_ComposeBody(tf->sendbuf+tf->tx_pos, buff+sent, (TF_LEN) chunk, &tf->tx_cksum);
         remain -= chunk;
         sent += chunk;
 
-        // Flush if the buffer is full and we have more to send
-        if (remain > 0 && len == TF_SENDBUF_LEN) {
-            TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len);
-            len = 0;
+        // Flush if the buffer is full
+        if (tf->tx_pos == TF_SENDBUF_LEN) {
+            TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
+            tf->tx_pos = 0;
+        }
     }
 }
 
+/**
+ * End a multi-part frame. This sends the checksum and releases mutex.
+ *
+ * @param tf - instance
+ */
+static void _TF_FN TF_SendFrame_End(TinyFrame *tf)
+{
     // Checksum only if message had a body
-    if (msg->len > 0) {
+    if (tf->tx_len > 0) {
         // Flush if checksum wouldn't fit in the buffer
-        if (TF_SENDBUF_LEN - len < sizeof(TF_CKSUM)) {
-            TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len);
-            len = 0;
+        if (TF_SENDBUF_LEN - tf->tx_pos < sizeof(TF_CKSUM)) {
+            TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
+            tf->tx_pos = 0;
         }
 
         // Add checksum, flush what remains to be sent
-        len += TF_ComposeTail(tf->sendbuf + len, &cksum);
+        tf->tx_pos += TF_ComposeTail(tf->sendbuf + tf->tx_pos, &tf->tx_cksum);
     }
 
-    TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, len);
+    TF_WriteImpl(tf, (const uint8_t *) tf->sendbuf, tf->tx_pos);
     TF_ReleaseTx(tf);
+}
 
+/**
+ * Send a message
+ *
+ * @param tf - instance
+ * @param msg - message object
+ * @param listener - ID listener, or NULL
+ * @param timeout - listener timeout, 0 is none
+ * @return true if sent
+ */
+static bool _TF_FN TF_SendFrame(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
+{
+    TF_TRY(TF_SendFrame_Begin(tf, msg, listener, timeout));
+    if (msg->len == 0 || msg->data != NULL) {
+        // Send the payload and checksum only if we're not starting a multi-part frame.
+        // A multi-part frame is identified by passing NULL to the data field and setting the length.
+        // User then needs to call those functions manually
+        TF_SendFrame_Chunk(tf, msg->data, msg->len);
+        TF_SendFrame_End(tf);
+    }
     return true;
 }
 
+//endregion Compose and send
+
+
+//region Sending API funcs
+
 /** send without listener */
 bool _TF_FN TF_Send(TinyFrame *tf, TF_Msg *msg)
 {
@@ -857,28 +1004,56 @@ bool _TF_FN TF_Respond(TinyFrame *tf, TF_Msg *msg)
     return TF_Send(tf, msg);
 }
 
-/** Externally renew an ID listener */
-bool _TF_FN TF_RenewIdListener(TinyFrame *tf, TF_ID id)
+//endregion Sending API funcs
+
+
+//region Sending API funcs - multipart
+
+bool _TF_FN TF_Send_Multipart(TinyFrame *tf, TF_Msg *msg)
 {
-    TF_COUNT i;
-    struct TF_IdListener_ *lst;
-    for (i = 0; i < tf->count_id_lst; i++) {
-        lst = &tf->id_listeners[i];
-        // test if live & matching
-        if (lst->fn != NULL && lst->id == id) {
-            renew_id_listener(lst);
-            return true;
+    msg->data = NULL;
+    return TF_Send(tf, msg);
 }
+
+bool _TF_FN TF_SendSimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len)
+{
+    return TF_SendSimple(tf, type, NULL, len);
 }
 
-    TF_Error("Renew listener: not found (id %d)", (int)id);
-    return false;
+bool _TF_FN TF_QuerySimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len, TF_Listener listener, TF_TICKS timeout)
+{
+    return TF_QuerySimple(tf, type, NULL, len, listener, timeout);
+}
+
+bool _TF_FN TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout)
+{
+    msg->data = NULL;
+    return TF_Query(tf, msg, listener, timeout);
+}
+
+void _TF_FN TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg)
+{
+    msg->data = NULL;
+    TF_Respond(tf, msg);
+}
+
+void _TF_FN TF_Multipart_Payload(TinyFrame *tf, const uint8_t *buff, uint32_t length)
+{
+    TF_SendFrame_Chunk(tf, buff, length);
 }
 
+void _TF_FN TF_Multipart_Close(TinyFrame *tf)
+{
+    TF_SendFrame_End(tf);
+}
+
+//endregion Sending API funcs - multipart
+
+
 /** Timebase hook - for timeouts */
 void _TF_FN TF_Tick(TinyFrame *tf)
 {
-    TF_COUNT i = 0;
+    TF_COUNT i;
     struct TF_IdListener_ *lst;
 
     // increment parser timeout (timeout is handled when receiving next byte)
@@ -898,19 +1073,3 @@ void _TF_FN TF_Tick(TinyFrame *tf)
         }
     }
 }
-
-/** Default impl for claiming write mutex; can be specific to the instance */
-void __attribute__((weak)) TF_ClaimTx(TinyFrame *tf)
-{
-    (void) tf;
-
-    // do nothing
-}
-
-/** Default impl for releasing write mutex; can be specific to the instance */
-void __attribute__((weak)) TF_ReleaseTx(TinyFrame *tf)
-{
-    (void) tf;
-
-    // do nothing
-}

TinyFrame/TinyFrame.h

@@ -4,13 +4,13 @@
 /**
  * TinyFrame protocol library
  *
- * (c) Ondřej Hruška 2017, MIT License
+ * (c) Ondřej Hruška 2017-2018, MIT License
  * no liability/warranty, free for any use, must retain this notice & license
  *
  * Upstream URL: https://github.com/MightyPork/TinyFrame
  */
 
-#define TF_VERSION "2.1.0"
+#define TF_VERSION "2.3.0"
 
 //---------------------------------------------------------------------------
 #include <stdint.h>  // for uint8_t etc
@@ -19,11 +19,15 @@
 #include <string.h>  // for memset()
 //---------------------------------------------------------------------------
 
-// Select checksum type (0 = none, 8 = ~XOR, 16 = CRC16 0x8005, 32 = CRC32)
-#define TF_CKSUM_NONE  0
-#define TF_CKSUM_XOR   8
-#define TF_CKSUM_CRC16 16
-#define TF_CKSUM_CRC32 32
+// Checksum type (0 = none, 8 = ~XOR, 16 = CRC16 0x8005, 32 = CRC32)
+#define TF_CKSUM_NONE  0  // no checksums
+#define TF_CKSUM_XOR   8  // inverted xor of all payload bytes
+#define TF_CKSUM_CRC8  9  // Dallas/Maxim CRC8 (1-wire)
+#define TF_CKSUM_CRC16 16 // CRC16 with the polynomial 0x8005 (x^16 + x^15 + x^2 + 1)
+#define TF_CKSUM_CRC32 32 // CRC32 with the polynomial 0xedb88320
+#define TF_CKSUM_CUSTOM8  1  // Custom 8-bit checksum
+#define TF_CKSUM_CUSTOM16 2  // Custom 16-bit checksum
+#define TF_CKSUM_CUSTOM32 3  // Custom 32-bit checksum
 
 #include "TF_Config.h"
 
@@ -62,35 +66,30 @@ typedef uint32_t TF_ID;
 #endif
 
 
-#if TF_CKSUM_TYPE == TF_CKSUM_XOR || TF_CKSUM_TYPE == TF_CKSUM_NONE
+#if (TF_CKSUM_TYPE == TF_CKSUM_XOR) || (TF_CKSUM_TYPE == TF_CKSUM_NONE) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM8) || (TF_CKSUM_TYPE == TF_CKSUM_CRC8)
     // ~XOR (if 0, still use 1 byte - it won't be used)
     typedef uint8_t TF_CKSUM;
-#elif TF_CKSUM_TYPE == TF_CKSUM_CRC16
+#elif (TF_CKSUM_TYPE == TF_CKSUM_CRC16) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM16)
     // CRC16
     typedef uint16_t TF_CKSUM;
-#elif TF_CKSUM_TYPE == TF_CKSUM_CRC32
+#elif (TF_CKSUM_TYPE == TF_CKSUM_CRC32) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM32)
     // CRC32
     typedef uint32_t TF_CKSUM;
 #else
-#error Bad value for TF_CKSUM_TYPE, must be 8, 16 or 32
+    #error Bad value for TF_CKSUM_TYPE
 #endif
 
 //endregion
 
 //---------------------------------------------------------------------------
 
-// Type-dependent masks for bit manipulation in the ID field
-#define TF_ID_MASK (TF_ID)(((TF_ID)1 << (sizeof(TF_ID)*8 - 1)) - 1)
-#define TF_ID_PEERBIT (TF_ID)((TF_ID)1 << ((sizeof(TF_ID)*8) - 1))
-
-//---------------------------------------------------------------------------
-
 /** Peer bit enum (used for init) */
 typedef enum {
     TF_SLAVE = 0,
     TF_MASTER = 1,
 } TF_Peer;
 
+
 /** Response from listeners */
 typedef enum {
     TF_NEXT = 0,   //!< Not handled, let other listeners handle it
@@ -99,117 +98,59 @@ typedef enum {
     TF_CLOSE = 3,  //!< Handled, remove self
 } TF_Result;
 
+
 /** Data structure for sending / receiving messages */
-typedef struct _TF_MSG_STRUCT_ {
+typedef struct TF_Msg_ {
     TF_ID frame_id;       //!< message ID
     bool is_response;     //!< internal flag, set when using the Respond function. frame_id is then kept unchanged.
     TF_TYPE type;         //!< received or sent message type
-    const uint8_t *data;  //!< buffer of received data or data to send. NULL = listener timed out, free userdata!
-    TF_LEN len;           //!< length of the buffer
-    void *userdata;       //!< here's a place for custom data; this data will be stored with the listener
+
+    /**
+     * Buffer of received data, or data to send.
+     *
+     * - If (data == NULL) in an ID listener, that means the listener timed out and
+     *   the user should free any userdata and take other appropriate actions.
+     *
+     * - If (data == NULL) and length is not zero when sending a frame, that starts a multi-part frame.
+     *   This call then must be followed by sending the payload and closing the frame.
+     */
+    const uint8_t *data;
+    TF_LEN len; //!< length of the payload
+
+    /**
+     * Custom user data for the ID listener.
+     *
+     * This data will be stored in the listener slot and passed to the ID callback
+     * via those same fields on the received message.
+     */
+    void *userdata;
     void *userdata2;
 } TF_Msg;
 
 /**
  * Clear message struct
+ *
+ * @param msg - message to clear in-place
  */
 static inline void TF_ClearMsg(TF_Msg *msg)
 {
     memset(msg, 0, sizeof(TF_Msg));
 }
 
+/** TinyFrame struct typedef */
 typedef struct TinyFrame_ TinyFrame;
 
 /**
  * TinyFrame Type Listener callback
  *
- * @param frame_id - ID of the received frame
- * @param type - type field from the message
- * @param data - byte buffer with the application data
- * @param len - number of bytes in the buffer
+ * @param tf - instance
+ * @param msg - the received message, userdata is populated inside the object
  * @return listener result
  */
 typedef TF_Result (*TF_Listener)(TinyFrame *tf, TF_Msg *msg);
 
-// -------------------------------------------------------------------
-
-// region Internal
-
-enum TFState_ {
-    TFState_SOF = 0,      //!< Wait for SOF
-    TFState_LEN,          //!< Wait for Number Of Bytes
-    TFState_HEAD_CKSUM,   //!< Wait for header Checksum
-    TFState_ID,           //!< Wait for ID
-    TFState_TYPE,         //!< Wait for message type
-    TFState_DATA,         //!< Receive payload
-    TFState_DATA_CKSUM    //!< Wait for Checksum
-};
-
-struct TF_IdListener_ {
-    TF_ID id;
-    TF_Listener fn;
-    TF_TICKS timeout;     // nr of ticks remaining to disable this listener
-    TF_TICKS timeout_max; // the original timeout is stored here
-    void *userdata;
-    void *userdata2;
-};
-
-struct TF_TypeListener_ {
-    TF_TYPE type;
-    TF_Listener fn;
-};
-
-struct TF_GenericListener_ {
-    TF_Listener fn;
-};
-
-/**
- * Frame parser internal state.
- */
-struct TinyFrame_ {
-    /* Public user data */
-    void *userdata;
-    uint32_t usertag;
-
-    // --- the rest of the struct is internal, do not access directly ---
-
-    /* Own state */
-    TF_Peer peer_bit;       //!< Own peer bit (unqiue to avoid msg ID clash)
-    TF_ID next_id;          //!< Next frame / frame chain ID
-
-    /* Parser state */
-    enum TFState_ state;
-    TF_TICKS parser_timeout_ticks;
-    TF_ID id;               //!< Incoming packet ID
-    TF_LEN len;             //!< Payload length
-    uint8_t data[TF_MAX_PAYLOAD_RX]; //!< Data byte buffer
-    TF_LEN rxi;             //!< Field size byte counter
-    TF_CKSUM cksum;         //!< Checksum calculated of the data stream
-    TF_CKSUM ref_cksum;     //!< Reference checksum read from the message
-    TF_TYPE type;           //!< Collected message type number
-    bool discard_data;      //!< Set if (len > TF_MAX_PAYLOAD) to read the frame, but ignore the data.
-
-    /* --- Callbacks --- */
 
-    /* Transaction callbacks */
-    struct TF_IdListener_ id_listeners[TF_MAX_ID_LST];
-    struct TF_TypeListener_ type_listeners[TF_MAX_TYPE_LST];
-    struct TF_GenericListener_ generic_listeners[TF_MAX_GEN_LST];
-
-    // Those counters are used to optimize look-up times.
-    // They point to the highest used slot number,
-    // or close to it, depending on the removal order.
-    TF_COUNT count_id_lst;
-    TF_COUNT count_type_lst;
-    TF_COUNT count_generic_lst;
-
-    // Buffer for building frames
-    uint8_t sendbuf[TF_SENDBUF_LEN];
-};
-
-// endregion
-
-// -------------------------------------------------------------------
+// ---------------------------------- INIT ------------------------------
 
 /**
  * Initialize the TinyFrame engine.
@@ -221,7 +162,9 @@ struct TinyFrame_ {
  * This function is a wrapper around TF_InitStatic that calls malloc() to obtain
  * the instance.
  *
+ * @param tf - instance
  * @param peer_bit - peer bit to use for self
+ * @return TF instance or NULL
  */
 TinyFrame *TF_Init(TF_Peer peer_bit);
 
@@ -231,26 +174,66 @@ TinyFrame *TF_Init(TF_Peer peer_bit);
  *
  * The .userdata / .usertag field is preserved when TF_InitStatic is called.
  *
+ * @param tf - instance
  * @param peer_bit - peer bit to use for self
+ * @return success
  */
-void TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit);
+bool TF_InitStatic(TinyFrame *tf, TF_Peer peer_bit);
 
 /**
  * De-init the dynamically allocated TF instance
  *
- * @param tf
+ * @param tf - instance
  */
 void TF_DeInit(TinyFrame *tf);
 
+
+// ---------------------------------- API CALLS --------------------------------------
+
+/**
+ * Accept incoming bytes & parse frames
+ *
+ * @param tf - instance
+ * @param buffer - byte buffer to process
+ * @param count - nr of bytes in the buffer
+ */
+void TF_Accept(TinyFrame *tf, const uint8_t *buffer, uint32_t count);
+
+/**
+ * Accept a single incoming byte
+ *
+ * @param tf - instance
+ * @param c - a received char
+ */
+void TF_AcceptChar(TinyFrame *tf, uint8_t c);
+
+/**
+ * This function should be called periodically.
+ * The time base is used to time-out partial frames in the parser and
+ * automatically reset it.
+ * It's also used to expire ID listeners if a timeout is set when registering them.
+ *
+ * A common place to call this from is the SysTick handler.
+ *
+ * @param tf - instance
+ */
+void TF_Tick(TinyFrame *tf);
+
 /**
  * Reset the frame parser state machine.
  * This does not affect registered listeners.
+ *
+ * @param tf - instance
  */
 void TF_ResetParser(TinyFrame *tf);
 
+
+// ---------------------------- MESSAGE LISTENERS -------------------------------
+
 /**
  * Register a frame type listener.
  *
+ * @param tf - instance
  * @param msg - message (contains frame_id and userdata)
  * @param cb - callback
  * @param timeout - timeout in ticks to auto-remove the listener (0 = keep forever)
@@ -261,6 +244,7 @@ bool TF_AddIdListener(TinyFrame *tf, TF_Msg *msg, TF_Listener cb, TF_TICKS timeo
 /**
  * Remove a listener by the message ID it's registered for
  *
+ * @param tf - instance
  * @param frame_id - the frame we're listening for
  */
 bool TF_RemoveIdListener(TinyFrame *tf, TF_ID frame_id);
@@ -268,6 +252,7 @@ bool TF_RemoveIdListener(TinyFrame *tf, TF_ID frame_id);
 /**
  * Register a frame type listener.
  *
+ * @param tf - instance
  * @param frame_type - frame type to listen for
  * @param cb - callback
  * @return slot index (for removing), or TF_ERROR (-1)
@@ -277,6 +262,7 @@ bool TF_AddTypeListener(TinyFrame *tf, TF_TYPE frame_type, TF_Listener cb);
 /**
  * Remove a listener by type.
  *
+ * @param tf - instance
  * @param type - the type it's registered for
  */
 bool TF_RemoveTypeListener(TinyFrame *tf, TF_TYPE type);
@@ -284,6 +270,7 @@ bool TF_RemoveTypeListener(TinyFrame *tf, TF_TYPE type);
 /**
  * Register a generic listener.
  *
+ * @param tf - instance
  * @param cb - callback
  * @return slot index (for removing), or TF_ERROR (-1)
  */
@@ -292,13 +279,27 @@ bool TF_AddGenericListener(TinyFrame *tf, TF_Listener cb);
 /**
  * Remove a generic listener by function pointer
  *
+ * @param tf - instance
  * @param cb - callback function to remove
  */
 bool TF_RemoveGenericListener(TinyFrame *tf, TF_Listener cb);
 
+/**
+ * Renew an ID listener timeout externally (as opposed to by returning TF_RENEW from the ID listener)
+ *
+ * @param tf - instance
+ * @param id - listener ID to renew
+ * @return true if listener was found and renewed
+ */
+bool TF_RenewIdListener(TinyFrame *tf, TF_ID id);
+
+
+// ---------------------------- FRAME TX FUNCTIONS ------------------------------
+
 /**
  * Send a frame, no listener
  *
+ * @param tf - instance
  * @param msg - message struct. ID is stored in the frame_id field
  * @return success
  */
@@ -312,73 +313,214 @@ bool TF_SendSimple(TinyFrame *tf, TF_TYPE type, const uint8_t *data, TF_LEN len)
 /**
  * Send a frame, and optionally attach an ID listener.
  *
+ * @param tf - instance
  * @param msg - message struct. ID is stored in the frame_id field
  * @param listener - listener waiting for the response (can be NULL)
  * @param timeout - listener expiry time in ticks
  * @return success
  */
-bool TF_Query(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout);
+bool TF_Query(TinyFrame *tf, TF_Msg *msg,
+              TF_Listener listener, TF_TICKS timeout);
 
 /**
- * Like TF_Query, but without the struct
+ * Like TF_Query(), but without the struct
  */
-bool TF_QuerySimple(TinyFrame *tf, TF_TYPE type, const uint8_t *data, TF_LEN len,
+bool TF_QuerySimple(TinyFrame *tf, TF_TYPE type,
+                    const uint8_t *data, TF_LEN len,
                     TF_Listener listener, TF_TICKS timeout);
 
 /**
  * Send a response to a received message.
  *
+ * @param tf - instance
  * @param msg - message struct. ID is read from frame_id. set ->renew to reset listener timeout
  * @return success
  */
 bool TF_Respond(TinyFrame *tf, TF_Msg *msg);
 
+
+// ------------------------ MULTIPART FRAME TX FUNCTIONS -----------------------------
+// Those routines are used to send long frames without having all the data available
+// at once (e.g. capturing it from a peripheral or reading from a large memory buffer)
+
 /**
- * Renew an ID listener timeout externally (as opposed to by returning TF_RENEW from the ID listener)
- *
- * @param id - listener ID to renew
- * @return true if listener was found and renewed
+ * TF_Send() with multipart payload.
+ * msg.data is ignored and set to NULL
  */
-bool TF_RenewIdListener(TinyFrame *tf, TF_ID id);
+bool TF_Send_Multipart(TinyFrame *tf, TF_Msg *msg);
 
 /**
- * Accept incoming bytes & parse frames
- *
- * @param buffer - byte buffer to process
- * @param count - nr of bytes in the buffer
+ * TF_SendSimple() with multipart payload.
  */
-void TF_Accept(TinyFrame *tf, const uint8_t *buffer, size_t count);
+bool TF_SendSimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len);
 
 /**
- * Accept a single incoming byte
- *
- * @param c - a received char
+ * TF_QuerySimple() with multipart payload.
  */
-void TF_AcceptChar(TinyFrame *tf, uint8_t c);
+bool TF_QuerySimple_Multipart(TinyFrame *tf, TF_TYPE type, TF_LEN len, TF_Listener listener, TF_TICKS timeout);
 
 /**
- * This function should be called periodically.
+ * TF_Query() with multipart payload.
+ * msg.data is ignored and set to NULL
+ */
+bool TF_Query_Multipart(TinyFrame *tf, TF_Msg *msg, TF_Listener listener, TF_TICKS timeout);
+
+/**
+ * TF_Respond() with multipart payload.
+ * msg.data is ignored and set to NULL
+ */
+void TF_Respond_Multipart(TinyFrame *tf, TF_Msg *msg);
+
+/**
+ * Send the payload for a started multipart frame. This can be called multiple times
+ * if needed, until the full length is transmitted.
  *
- * The time base is used to time-out partial frames in the parser and
- * automatically reset it.
+ * @param tf - instance
+ * @param buff - buffer to send bytes from
+ * @param length - number of bytes to send
+ */
+void TF_Multipart_Payload(TinyFrame *tf, const uint8_t *buff, uint32_t length);
+
+/**
+ * Close the multipart message, generating chekcsum and releasing the Tx lock.
  *
- * (suggestion - call this in a SysTick handler)
+ * @param tf - instance
  */
-void TF_Tick(TinyFrame *tf);
+void TF_Multipart_Close(TinyFrame *tf);
 
-// --- TO BE IMPLEMENTED BY USER ---
+
+// ---------------------------------- INTERNAL ----------------------------------
+// This is publicly visible only to allow static init.
+
+enum TF_State_ {
+    TFState_SOF = 0,      //!< Wait for SOF
+    TFState_LEN,          //!< Wait for Number Of Bytes
+    TFState_HEAD_CKSUM,   //!< Wait for header Checksum
+    TFState_ID,           //!< Wait for ID
+    TFState_TYPE,         //!< Wait for message type
+    TFState_DATA,         //!< Receive payload
+    TFState_DATA_CKSUM    //!< Wait for Checksum
+};
+
+struct TF_IdListener_ {
+    TF_ID id;
+    TF_Listener fn;
+    TF_TICKS timeout;     // nr of ticks remaining to disable this listener
+    TF_TICKS timeout_max; // the original timeout is stored here (0 = no timeout)
+    void *userdata;
+    void *userdata2;
+};
+
+struct TF_TypeListener_ {
+    TF_TYPE type;
+    TF_Listener fn;
+};
+
+struct TF_GenericListener_ {
+    TF_Listener fn;
+};
+
+/**
+ * Frame parser internal state.
+ */
+struct TinyFrame_ {
+    /* Public user data */
+    void *userdata;
+    uint32_t usertag;
+
+    // --- the rest of the struct is internal, do not access directly ---
+
+    /* Own state */
+    TF_Peer peer_bit;       //!< Own peer bit (unqiue to avoid msg ID clash)
+    TF_ID next_id;          //!< Next frame / frame chain ID
+
+    /* Parser state */
+    enum TF_State_ state;
+    TF_TICKS parser_timeout_ticks;
+    TF_ID id;               //!< Incoming packet ID
+    TF_LEN len;             //!< Payload length
+    uint8_t data[TF_MAX_PAYLOAD_RX]; //!< Data byte buffer
+    TF_LEN rxi;             //!< Field size byte counter
+    TF_CKSUM cksum;         //!< Checksum calculated of the data stream
+    TF_CKSUM ref_cksum;     //!< Reference checksum read from the message
+    TF_TYPE type;           //!< Collected message type number
+    bool discard_data;      //!< Set if (len > TF_MAX_PAYLOAD) to read the frame, but ignore the data.
+
+    /* Tx state */
+    // Buffer for building frames
+    uint8_t sendbuf[TF_SENDBUF_LEN]; //!< Transmit temporary buffer
+
+    uint32_t tx_pos;        //!< Next write position in the Tx buffer (used for multipart)
+    uint32_t tx_len;        //!< Total expected Tx length
+    TF_CKSUM tx_cksum;      //!< Transmit checksum accumulator
+
+#if !TF_USE_MUTEX
+    bool soft_lock;         //!< Tx lock flag used if the mutex feature is not enabled.
+#endif
+
+    /* --- Callbacks --- */
+
+    /* Transaction callbacks */
+    struct TF_IdListener_ id_listeners[TF_MAX_ID_LST];
+    struct TF_TypeListener_ type_listeners[TF_MAX_TYPE_LST];
+    struct TF_GenericListener_ generic_listeners[TF_MAX_GEN_LST];
+
+    // Those counters are used to optimize look-up times.
+    // They point to the highest used slot number,
+    // or close to it, depending on the removal order.
+    TF_COUNT count_id_lst;
+    TF_COUNT count_type_lst;
+    TF_COUNT count_generic_lst;
+};
+
+
+// ------------------------ TO BE IMPLEMENTED BY USER ------------------------
 
 /**
  * 'Write bytes' function that sends data to UART
  *
  * ! Implement this in your application code !
  */
-extern void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, size_t len);
+extern void TF_WriteImpl(TinyFrame *tf, const uint8_t *buff, uint32_t len);
+
+// Mutex functions
+#if TF_USE_MUTEX
 
     /** Claim the TX interface before composing and sending a frame */
-extern void TF_ClaimTx(TinyFrame *tf);
+    extern bool TF_ClaimTx(TinyFrame *tf);
 
     /** Free the TX interface after composing and sending a frame */
     extern void TF_ReleaseTx(TinyFrame *tf);
 
 #endif
+
+// Custom checksum functions
+#if (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM8) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM16) || (TF_CKSUM_TYPE == TF_CKSUM_CUSTOM32)
+
+    /**
+     * Initialize a checksum
+     *
+     * @return initial checksum value
+     */
+    extern TF_CKSUM TF_CksumStart(void);
+
+    /**
+     * Update a checksum with a byte
+     *
+     * @param cksum - previous checksum value
+     * @param byte - byte to add
+     * @return updated checksum value
+     */
+    extern TF_CKSUM TF_CksumAdd(TF_CKSUM cksum, uint8_t byte);
+
+    /**
+     * Finalize the checksum calculation
+     *
+     * @param cksum - previous checksum value
+     * @return final checksum value
+     */
+    extern TF_CKSUM TF_CksumEnd(TF_CKSUM cksum);
+
+#endif
+
+#endif

platform/irq_dispatcher.c

@@ -146,7 +146,10 @@ static struct cbslot *get_slot_for_periph(void *periph)
 void irqd_attach(void *periph, IrqCallback callback, void *arg)
 {
     struct cbslot *slot = get_slot_for_periph(periph);
-    assert_param(slot->callback == NULL);
+    if (slot->callback != NULL) {
+        trap("Attach IRQ %p() to %p but %p() already bound", callback, periph, slot->callback);
+    }
+
     slot->callback = callback;
     slot->arg = arg;
 }
@@ -157,6 +160,8 @@ void irqd_detach(void *periph, IrqCallback callback)
     if (slot->callback == callback) {
         slot->callback = NULL;
         slot->arg = NULL;
+    } else {
+        trap("Detach IRQ %p() from %p but %p() bound instead", callback, periph, slot->callback);
     }
 }
 

units/usart/_dmas.c

@@ -433,8 +433,8 @@ void UUSART_DeInitDMAs(Unit *unit)
     struct priv *priv = unit->data;
     assert_param(priv);
 
-    irqd_detach(priv->dma_tx, UUSART_DMA_RxHandler);
-    irqd_detach(priv->dma_rx, UUSART_DMA_TxHandler);
+    irqd_detach(priv->dma_tx, UUSART_DMA_TxHandler);
+    irqd_detach(priv->dma_rx, UUSART_DMA_RxHandler);
 
     LL_DMA_DeInit(priv->dma, priv->dma_rx_chnum);
     LL_DMA_DeInit(priv->dma, priv->dma_tx_chnum);