feat: zephyr mutexes and thread example

Author: eigen-value

examples/zephyr_thread/zephyr_thread.ino

@@ -0,0 +1,10 @@
+#include <Arduino_BridgeImola.h>
+
+
+void setup() {
+    BRIDGE.begin();
+}
+
+void loop() {
+    delay(10);
+}

src/bridge.h

@@ -6,6 +6,7 @@
 #define RESET_METHOD "$/reset"
 #define BIND_METHOD "$/register"
 
+#include <zephyr/kernel.h>
 #include <Arduino_RPClite.h>
 
 
@@ -15,14 +16,22 @@ class Bridge {
     RPCServer* server = nullptr;
     ITransport* transport;
 
+    struct k_mutex read_mutex;
+    struct k_mutex write_mutex;
+
 public:
     Bridge(ITransport& t) : transport(&t) {}
+
     Bridge(Stream& stream) {
         transport = new SerialTransport(stream);
     }
 
     // Initialize the bridge
     bool begin() {
+
+        k_mutex_init(&read_mutex);
+        k_mutex_init(&write_mutex);
+
         client = new RPCClient(*transport);
         server = new RPCServer(*transport);
         bool res;
@@ -38,19 +47,60 @@ class Bridge {
         return server->bind(name, func);
     }
 
+    template<typename F>
+    bool provide_safe(const MsgPack::str_t& name, F&& func) {
+        bool res;
+        if (!call(BIND_METHOD, res, name)) {
+            return false;
+        }
+
+        return server->bind(name, func, "__safe__");
+    
+    }
+
     void update() {
-        // Protect the following calls with a mutex if necessary
-        // server->read_request();  // <- inbound
-        // server->serve();         // -> outbound
-        server->run();
+
+        // Lock read mutex
+        while(1){
+            k_mutex_lock(&read_mutex, K_FOREVER);
+            if (server->get_rpc()) {
+                k_mutex_unlock(&read_mutex);
+                break;
+            }
+            k_mutex_unlock(&read_mutex);
+            k_msleep(1);
+        }
+
+        server->process_request();
+        
+        // Lock write mutex
+        k_mutex_lock(&write_mutex, K_FOREVER);
+        server->send_response();
+        k_mutex_unlock(&write_mutex);
+
     }
 
     template<typename RType, typename... Args>
     bool call(const MsgPack::str_t method, RType& result, Args&&... args) {
-        // Protect the following calls with a mutex if necessary
-        // client->send_call();         // -> outbound
-        // client->read_response();     // <- inbound
-        return client->call(method, result, std::forward<Args>(args)...);
+
+        // Lock write mutex
+        k_mutex_lock(&write_mutex, K_FOREVER);
+        client->send_rpc(method, std::forward<Args>(args)...);
+        k_mutex_unlock(&write_mutex);
+
+        // Lock read mutex
+        while(1) {
+            k_mutex_lock(&read_mutex, K_FOREVER);
+            if (client->get_response(result)) {
+                k_mutex_unlock(&read_mutex);
+                break;
+            }
+            k_mutex_unlock(&read_mutex);
+            k_msleep(1);
+        }
+
+        return (client->lastError.code == NO_ERR);
+
     }
 
     template<typename... Args>
@@ -66,6 +116,52 @@ class Bridge {
         return (uint8_t) client->lastError.code;
     }
 
+private:
+
+    void update_safe() {
+
+        // Lock read mutex
+        while(1){
+            k_mutex_lock(&read_mutex, K_FOREVER);
+            if (server->get_rpc()) {
+                k_mutex_unlock(&read_mutex);
+                break;
+            }
+            k_mutex_unlock(&read_mutex);
+            k_msleep(1);
+        }
+
+        server->process_request("__safe__");
+        
+        // Lock write mutex
+        k_mutex_lock(&write_mutex, K_FOREVER);
+        server->send_response();
+        k_mutex_unlock(&write_mutex);
+
+    }
+
+    friend class BridgeUpdater;
+
 };
 
+class BridgeUpdater {
+public:
+    static void safeUpdate(Bridge& bridge) {
+        bridge.update_safe();  // access private method
+    }
+
+private:
+    BridgeUpdater() = delete; // prevents instantiation
+};
+
+Bridge BRIDGE(Serial1);
+
+static void safeUpdate(){
+    BridgeUpdater::safeUpdate(BRIDGE);
+}
+
+void __loopHook(){
+    safeUpdate();
+}
+
 #endif // BRIDGE_IMOLA_H