table code types containing primitive and void fields

Each table has a four byte header, plus some number of entries (4
bytes). Each field consumes one entry.

The maximum encoded message length in bytes, size of the C message
struct in chars, and number of table entries all are limited to 65535
for table coding to be possible.

Also supports nested compound types containing these fields.

Author: tpwrules

canard.c

@@ -999,11 +999,28 @@ bool canardTableDecodeMessage(const CanardCodingTable* table,
                               const CanardRxTransfer* transfer,
                               void* msg)
 {
-    (void)table;
-    (void)transfer;
-    (void)msg;
+#if CANARD_ENABLE_TAO_OPTION
+    if (transfer->tao && (transfer->payload_len > table->max_size)) {
+        return true; // invalid length
+    }
+#endif
+
+    uint32_t bit_ofs = 0;
+    const CanardCodingTableEntry* entry = &table->entries[0];
+    const CanardCodingTableEntry* entry_last = &table->entries[table->entries_max];
+    if (tableDecodeCore(entry, entry_last, transfer, &bit_ofs, msg)) {
+        return true; // decode failure
+    }
 
-    return true;
+    const uint32_t byte_len = (bit_ofs+7U)/8U;
+#if CANARD_ENABLE_TAO_OPTION
+    // if this could be CANFD then the dlc could indicating more bytes than
+    // we actually have
+    if (!transfer->tao) {
+        return byte_len > transfer->payload_len;
+    }
+#endif
+    return byte_len != transfer->payload_len;
 }
 #endif
 
@@ -1016,14 +1033,14 @@ uint32_t canardTableEncodeMessage(const CanardCodingTable* table,
 #endif
                                  )
 {
-    (void)table;
-    (void)buffer;
-    (void)msg;
-#if CANARD_ENABLE_TAO_OPTION
-    (void)tao;
-#endif
+    memset(buffer, 0, table->max_size);
+
+    uint32_t bit_ofs = 0;
+    const CanardCodingTableEntry* entry = &table->entries[0];
+    const CanardCodingTableEntry* entry_last = &table->entries[table->entries_max];
+    tableEncodeCore(entry, entry_last, buffer, &bit_ofs, msg);
 
-    return 0;
+    return ((bit_ofs+7)/8);
 }
 #endif
 
@@ -1872,6 +1889,88 @@ CANARD_INTERNAL void swapByteOrder(void* data, unsigned size)
     }
 }
 
+/**
+ * Table coding functions
+ */
+#if CANARD_ENABLE_TABLE_DECODING
+CANARD_INTERNAL bool tableDecodeCore(const CanardCodingTableEntry* entry,
+                                     const CanardCodingTableEntry* entry_last,
+                                     const CanardRxTransfer* transfer,
+                                     uint32_t* bit_ofs,
+                                     void* msg)
+{
+    do {
+        void* p = (char*)msg + entry->offset;
+        uint8_t type = entry->type;
+        uint8_t bitlen = entry->bitlen;
+
+        switch (type) {
+        case CANARD_TABLE_CODING_UNSIGNED:
+        case CANARD_TABLE_CODING_SIGNED:
+        case CANARD_TABLE_CODING_FLOAT: {
+            canardDecodeScalar(transfer, *bit_ofs, bitlen, type != CANARD_TABLE_CODING_UNSIGNED, p);
+            if (type == CANARD_TABLE_CODING_FLOAT && bitlen == 16) {
+                uint16_t float16_val = (uint16_t)*(int16_t*)p;
+                *(float*)p = canardConvertFloat16ToNativeFloat(float16_val);
+            }
+
+            *bit_ofs += bitlen;
+            break;
+        }
+
+        case CANARD_TABLE_CODING_VOID:
+            // nothing to decode for void
+            *bit_ofs += bitlen;
+            break;
+
+        default:
+            return true; // invalid type
+        }
+    } while (++entry <= entry_last);
+
+    return false; // success
+}
+#endif
+
+#if CANARD_ENABLE_TABLE_ENCODING
+CANARD_INTERNAL void tableEncodeCore(const CanardCodingTableEntry* entry,
+                                     const CanardCodingTableEntry* entry_last,
+                                     uint8_t* buffer,
+                                     uint32_t* bit_ofs,
+                                     const void* msg)
+{
+    do {
+        const void* p = (const char*)msg + entry->offset;
+        uint8_t type = entry->type;
+        uint8_t bitlen = entry->bitlen;
+
+        switch (type) {
+        case CANARD_TABLE_CODING_UNSIGNED:
+        case CANARD_TABLE_CODING_SIGNED:
+        case CANARD_TABLE_CODING_FLOAT: {
+            uint16_t float16_val;
+            if (type == CANARD_TABLE_CODING_FLOAT && bitlen == 16) {
+                float16_val = canardConvertNativeFloatToFloat16(*(const float*)p);
+                p = &float16_val;
+            }
+            canardEncodeScalar(buffer, *bit_ofs, bitlen, p);
+
+            *bit_ofs += bitlen;
+            break;
+        }
+
+        case CANARD_TABLE_CODING_VOID:
+            // void encoding is taken care of by memset to 0 in the wrapper
+            *bit_ofs += bitlen;
+            break;
+
+        default:
+            return; // invalid type
+        }
+    } while (++entry <= entry_last);
+}
+#endif
+
 /*
  * CRC functions
  */

canard.h

@@ -464,21 +464,52 @@ struct CanardRxTransfer
 };
 
 #if CANARD_ENABLE_TABLE_DECODING || CANARD_ENABLE_TABLE_ENCODING
+
+#define CANARD_TABLE_CODING_UNSIGNED (0)
+#define CANARD_TABLE_CODING_SIGNED (1)
+#define CANARD_TABLE_CODING_FLOAT (2)
+#define CANARD_TABLE_CODING_VOID (3)
+
 /**
  * This structure describes the encoded form of part of a particular message. It
  * can be contained in ROM. It should be generated using dronecan_dsdlc.
  */
 typedef struct {
+    uint16_t offset;
+    uint8_t type;
+    uint8_t bitlen;
 } CanardCodingTableEntry;
 
+/**
+ * Coding table entry for primitive types (unsigned, signed, float).
+ *
+ * offset: offset, in chars, to the storage in the message struct
+ * type: 0, 1, or 2 for unsigned, signed, float
+ * bitlen: number of bits the primitive is encoded into
+ */
+#define CANARD_TABLE_CODING_ENTRY_PRIMITIVE(offset, type, bitlen) \
+    {offset, type, bitlen}
+
+/**
+ * Coding table entry for void type.
+ *
+ * offset: always 0
+ * type: 3 for void
+ * bitlen: number of bits of padding in the encoded output
+ */
+#define CANARD_TABLE_CODING_ENTRY_VOID(bitlen) \
+    {0, CANARD_TABLE_CODING_VOID, bitlen}
+
 /**
  * This structure describes the encoded form of a particular message. It can be
  * contained in ROM. It should be generated using dronecan_dsdlc.
  */
 typedef struct {
-    size_t entries_max;
+    uint16_t max_size; // must be > 0
+    uint16_t entries_max;
     CanardCodingTableEntry entries[];
 } CanardCodingTable;
+
 #endif
 
 /**

canard_internals.h

@@ -150,6 +150,25 @@ CANARD_INTERNAL bool isBigEndian(void);
 
 CANARD_INTERNAL void swapByteOrder(void* data, unsigned size);
 
+/**
+ * Table coding functions
+ */
+#if CANARD_ENABLE_TABLE_DECODING
+CANARD_INTERNAL bool tableDecodeCore(const CanardCodingTableEntry* entry,
+                                     const CanardCodingTableEntry* entry_end,
+                                     const CanardRxTransfer* transfer,
+                                     uint32_t* bit_ofs,
+                                     void* msg);
+#endif
+
+#if CANARD_ENABLE_TABLE_ENCODING
+CANARD_INTERNAL void tableEncodeCore(const CanardCodingTableEntry* entry,
+                                     const CanardCodingTableEntry* entry_end,
+                                     uint8_t* buffer,
+                                     uint32_t* bit_ofs,
+                                     const void* msg);
+#endif
+
 /*
  * Transfer CRC
  */