feat: smart decoder with RPC packet parsing

Author: eigen-value

examples/decoder_example/decoder_example.ino

@@ -1,3 +1,4 @@
+#define DEBUG
 #include <Arduino_RPClite.h>
 
 void blink_before(){
@@ -27,16 +28,29 @@ void loop() {
     blink_before();
     MsgPack::arr_size_t req_sz(4);
     MsgPack::arr_size_t par_sz(2);
+    packer.clear();
     packer.serialize(req_sz, 0, 1, "method", par_sz, 1.0, 2.0);
 
     DummyTransport dummy_transport(packer.data(), packer.size());
     RpcDecoder<> decoder(dummy_transport);
 
     while (!decoder.packet_available()){
+        decoder.print_buffer();
         Serial.println("Packet not ready");
         decoder.advance();
+        uint8_t decoded = decoder.parse_packet();
+        if (decoded > 0){
+            Serial.print("Bytes decoded: ");
+            Serial.println(decoded);
+        }
+        decoder.print_buffer();
+        delay(100);
+    }
+
+    if (decoder.packet_available()){
+        Serial.print("packet ready. size: ");
+        Serial.println(decoder.packet_size());
     }
 
-    Serial.println("packet ready");
 
 }

src/decoder.h

@@ -43,29 +43,68 @@ class RpcDecoder {
     }
 
     // Tries to parse the first packet only
-    void parse_packet(){
+    size_t parse_packet(){
 
         // Nop in case 1st packet is ready... waiting to deliver
-        if (_packet_ready){return;}
+        if (_packet_ready){return _packet_size;}
 
-        size_t bytes_checked = 0;
+        size_t bytes_checked = 3;
 
-        MsgPack::Unpacker unpacker;
         while (bytes_checked < _bytes_stored) {
-            if (unpacker.feed(_raw_buffer, bytes_checked)) {
+            bytes_checked++;
+
+            if (is_packet_complete(bytes_checked)) {
                 _packet_ready = true;
-                _packet_size = bytes_checked + 1;
-                return;
-            } else {
-                bytes_checked++;
+                _packet_size = bytes_checked;
+                break;
             }
         }
 
+        return _packet_size;
+
+    }
+
+    bool is_packet_complete(size_t size) {
+
+        static MsgPack::Unpacker unpacker;
+        unpacker.clear();
+
+        if (unpacker.feed(_raw_buffer, size)){
+            size_t min_packet_indices;
+
+            MsgPack::arr_size_t elem_size;
+            if (unpacker.deserialize(elem_size)){
+                min_packet_indices = elem_size.size() + 1;
+                if (unpacker.size() < min_packet_indices) return false;
+                int type;
+                if (unpacker.deserialize(type)) {
+                    if (type == 0 || type == 1) {   // request or response
+                        int _id;
+                        MsgPack::str_t callback;
+                        MsgPack::arr_size_t param_size;
+                        unpacker.deserialize(_id, callback, param_size);
+                        return (unpacker.size() == min_packet_indices + param_size.size());
+                    } else if (type == 2) { // notification
+                        MsgPack::str_t callback;
+                        MsgPack::arr_size_t param_size;
+                        unpacker.deserialize(callback, param_size);
+                        return (unpacker.size() == min_packet_indices + param_size.size());
+                    }
+                }
+
+            }
+
+        }
+
+        return false;
+
     }
 
     // Check if a packet is available
     bool packet_available() const { return _packet_ready; }
 
+    size_t packet_size() const {return _packet_size;}
+
     // Get the oldest packet (returns false if no packet available)
     bool get_next_packet(MsgPack::Unpacker& unpacker) {
         if (!_packet_ready) return false;
@@ -100,6 +139,21 @@ class RpcDecoder {
         return _packet_size;
     }
 
+#ifdef DEBUG
+void print_buffer(){
+
+    Serial.print("buf size: ");
+    Serial.print(_bytes_stored);
+    Serial.print(" : ");
+
+    for (size_t i = 0; i < _bytes_stored; i++) {
+        Serial.print(_raw_buffer[i], HEX);
+        Serial.print(" ");
+    }
+    Serial.println();
+}
+#endif
+
 private:
     ITransport& _transport;
     uint8_t _raw_buffer[BufferSize];