feat: server impl and simple client TBT

Author: eigen-value

examples/rpc_lite_server/rpc_lite_server.ino

@@ -1,15 +1,23 @@
 #include <RPClite.h>
 #include <HardwareSerial.h>
 
-HardwareSerial* uart = new HardwareSerial(0);
-
-SerialTransport transport(uart);
+SerialTransport transport(&Serial2);
 RPCServer server(transport);
 
+int add(int a, int b){
+    return a+b;
+}
+
+
 void setup() {
+    Serial2.begin(115200);
     transport.begin();
     pinMode(LED_BUILTIN, OUTPUT);
-    Serial.begin(9600);    
+    Serial.begin(9600);
+    while(!Serial);
+
+    server.bind("add", add);
+
 }
 
 void blink_before(){

examples/simple_client/simple_client.ino

@@ -0,0 +1,72 @@
+#include <RPClite.h>
+
+SerialTransport transport(&Serial1);
+RPCClient client(transport);
+
+void setup() {
+    Serial1.begin(115200);
+    transport.begin();
+    pinMode(LED_BUILTIN, OUTPUT);
+    Serial.begin(9600);
+    while(!Serial);
+}
+
+void blink_before(){
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(200);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(200);
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(200);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(200);
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(200);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(200);
+}
+
+void loop() {
+
+    blink_before();
+
+    int result;
+    bool ok = client.call("add", result, 15, 7);
+
+    if (ok) {
+        Serial.print("Result: ");
+        Serial.println(result);
+    }
+
+    // ok = client.call("divi", result, 2.0, 0.0);
+    // if (!ok) {
+    //     Serial.println("Testing Server-side exception OK");
+    // }
+
+    // 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");
+
+    // int duration_ms = 100;
+    // client.notify("blink", duration_ms);
+    // Serial.println("Sent a 100ms blink notification");
+
+    // MsgPack::object::nil_t out;
+    // ok = client.call("blink", out);
+    // Serial.print("Sent a blink RPC -> ");
+
+    // if (ok) {
+    //     Serial.println("Server returns without issues");
+    // } else {
+    //     Serial.println("Server could not handle a notification as a call");
+    // }
+
+    delay(2000);
+}

src/server.h

@@ -8,37 +8,48 @@
 #include "rpc.h"
 #include "error.h"
 #include "wrapper.h"
+#include "dispatcher.h"
 
 class RPCServer {
     ITransport& transport;
 
 public:
     RPCServer(ITransport& t) : transport(t) {}
 
-    int response_type = 1;
+    template<typename F>
+    void bind(const MsgPack::str_t& name, F&& func){
+        dispatcher.bind(name, func);
+    }
 
     void loop() {
-        MsgPack::Unpacker unpacker;
+
         if (!recv_msg(transport, unpacker)) return;
 
         int msg_type;
         int msg_id;
         MsgPack::str_t method;
-        float a;
-        float b;
-
-        unpacker.deserialize(msg_type, msg_id, method, a, b);
-
-        float result = a * b;
+        if (!unpacker.deserialize(msg_type, msg_id, method)){
+            Serial.println("unable to deserialize a msg received");
+            flush_buffer();
+            return;
+        }
 
-        MsgPack::Packer packer;
+        MsgPack::arr_size_t resp_size(4);
+        packer.clear();
+        packer.serialize(resp_size, RESP_MSG, msg_id);
 
-        MsgPack::object::nil_t null;
+        dispatcher.call(method, unpacker, packer);
 
-        packer.serialize(response_type, msg_id, null, result);
         send_msg(transport, packer.packet());
 
     }
+
+private:
+
+    RpcFunctionDispatcher dispatcher;
+    MsgPack::Unpacker unpacker;
+    MsgPack::Packer packer;
+
 };
 
 #endif //RPCLITE_SERVER_H