mod: call method yields but re-attempts deserialization on no new bytes received. feat: notifications. test: checked param-less calls/notif

Author: eigen-value

examples/rpc_lite_client/rpc_lite_client.ino

@@ -44,5 +44,16 @@ void loop() {
         Serial.println(result);
     }
 
+    int rand_int;
+    ok = client.call("get_rand", rand_int);
+
+    if (ok) {
+        Serial.print("Random int from server: ");
+        Serial.println(rand_int);
+    }
+
+    client.notify("blink");
+    Serial.println("Sent a blink notification");
+
     delay(2000);
 }

extras/examples/serial_server_example.py

@@ -1,3 +1,4 @@
+import random
 from serial_server import SerialServer
 
 def add(a, b):
@@ -10,15 +11,35 @@ def multiply(a, b):
     return a*b
 
 def divide(a, b):
+    if b == 0:
+        print("0 denominator: this will raise an exception")
     return a/b
 
+def blink():
+    """
+    Used for notification
+    """
+    print("Blink maybe")
+
+def get_rand():
+    """
+    Used for testing parameter-less RPCs
+    """
+    r = random.randint(0, 10)
+    print(f"returning a random integer: {r}")
+    return r
+
+
 PORT = '/dev/ttySTM0'
 
 server = SerialServer(port=PORT, baudrate=115200)
 server.register_callback('add', add)
 server.register_callback('mult', multiply)
 server.register_callback('divi', divide)
 server.register_callback('greet', greet)
+server.register_callback('blink', blink)
+server.register_callback('get_rand', get_rand)
+
 server.start()
 
 print("Serial server running... Press Ctrl+C to exit.")

extras/serial_server.py

@@ -27,7 +27,14 @@ def on_request(self, msg_id, command, args):
         except Exception as e:
             return [RESPONSE, msg_id, [GENERIC_EXCEPTION, str(e)] ,None]
 
-    def handle_message(self, message) -> bytes:
+    def on_notify(self, command, args):
+        """Execute the callback"""
+        try:
+            self.callbacks[command](*args)
+        except Exception as e:
+            print(f"Exception on notification... the client will never know {str(e)}")
+
+    def handle_message(self, message) -> bytes | None:
         """Process incoming messages"""
         msgsize = len(message)
         if msgsize != 4 and msgsize != 3:
@@ -40,9 +47,8 @@ def handle_message(self, message) -> bytes:
             raise Exception("Server receiving RESPONSE not implemented")
             # response = self.on_response(message[1], message[2], message[3])
         elif msgtype == NOTIFY:
-            print("Server does nothing on notification")
-            # self.on_notify(message[1], message[2])
-            response = None
+            self.on_notify(message[1], message[2])
+            return None
         else:
             raise Exception("Unknown message type: type = {0}".format(msgtype))
 

src/SerialTransport.h

@@ -35,6 +35,7 @@ class SerialTransport: public ITransport {
                 }
                 buffer[r_size] = _stream->read();
                 r_size++;
+                // TODO the following delay is essential for GIGA to work. Is it worth making giga-specific?
                 delay(1);
             }
 

src/client.h

@@ -14,12 +14,29 @@ class RPCClient {
 public:
     RPCClient(ITransport& t) : transport(t) {}
 
+    template<typename... Args>
+    void notify(const MsgPack::str_t method, Args&&... args)  {
+        MsgPack::Packer packer;
+
+        int msg_type = NOTIFY_MSG;
+
+        MsgPack::arr_size_t notify_size(3);
+
+        packer.serialize(notify_size, msg_type, method);
+
+        MsgPack::arr_size_t arg_size(sizeof...(args));
+
+        packer.serialize(arg_size, std::forward<Args>(args)...);
+
+        send_msg(transport, packer.packet());
+    }
+
     template<typename RType, typename... Args>
     bool call(const MsgPack::str_t method, RType& result, Args&&... args) {
 
         MsgPack::Packer packer;
 
-        int msg_type = 0;
+        int msg_type = CALL_MSG;
 
         MsgPack::arr_size_t call_size(4);
 
@@ -37,7 +54,12 @@ class RPCClient {
 
         while (true){
             if (!recv_msg(transport, unpacker)){
+                // If not receiving new bytes yield first then attempt a new deserialization
                 delay(1);
+            }
+
+            if (raw_buffer_fill == 0){
+                //Serial.println("Empty buffer... waiting response");
                 continue;
             }
 

src/rpc.h

@@ -8,6 +8,11 @@
 #include "transport.h"
 #include "MsgPack.h"
 
+
+#define CALL_MSG        0
+#define RESP_MSG        1
+#define NOTIFY_MSG      2
+
 #define MAX_BUFFER_SIZE 1024
 #define CHUNK_SIZE      32