impr: bridge, monitor thread protection of bool flags and initialization methods

Author: eigen-value

src/bridge.h

@@ -106,6 +106,7 @@ class BridgeClass {
 
     struct k_mutex read_mutex{};
     struct k_mutex write_mutex{};
+    struct k_mutex bridge_mutex{};
 
     k_tid_t upd_tid{};
     k_thread_stack_t *upd_stack_area{};
@@ -119,17 +120,27 @@ class BridgeClass {
         serial_ptr = &serial;
     }
 
-    operator bool() const {
-        return started;
+    operator bool() {
+        return is_started();
+    }
+
+    bool is_started() {
+        k_mutex_lock(&bridge_mutex, K_FOREVER);
+        bool out = started;
+        k_mutex_unlock(&bridge_mutex);
+        return out;
     }
 
     // Initialize the bridge
     bool begin(unsigned long baud=DEFAULT_SERIAL_BAUD) {
-        serial_ptr->begin(baud);
-        transport = new SerialTransport(*serial_ptr);
-
         k_mutex_init(&read_mutex);
         k_mutex_init(&write_mutex);
+        k_mutex_init(&bridge_mutex);
+
+        if (is_started()) return true;
+
+        serial_ptr->begin(baud);
+        transport = new SerialTransport(*serial_ptr);
 
         client = new RPCClient(*transport);
         server = new RPCServer(*transport);
@@ -141,32 +152,29 @@ class BridgeClass {
                                 NULL, NULL, NULL,
                                 UPDATE_THREAD_PRIORITY, 0, K_NO_WAIT);
 
-        bool res;
-        call(RESET_METHOD).result(res);
-        if (res) {
-            started = true;
-        }
+        k_mutex_lock(&bridge_mutex, K_FOREVER);
+        bool res = false;
+        started = call(RESET_METHOD).result(res) && res;
+        k_mutex_unlock(&bridge_mutex);
         return res;
     }
 
     template<typename F>
     bool provide(const MsgPack::str_t& name, F&& func) {
+        k_mutex_lock(&bridge_mutex, K_FOREVER);
         bool res;
-        if (!call(BIND_METHOD, name).result(res)) {
-            return false;
-        }
-        return server->bind(name, func);
+        bool out = call(BIND_METHOD, name).result(res) && res && server->bind(name, func);
+        k_mutex_unlock(&bridge_mutex);
+        return out;
     }
 
     template<typename F>
     bool provide_safe(const MsgPack::str_t& name, F&& func) {
+        k_mutex_lock(&bridge_mutex, K_FOREVER);
         bool res;
-        if (!call(BIND_METHOD, name).result(res)) {
-            return false;
-        }
-
-        return server->bind(name, func, "__safe__");
-
+        bool out = call(BIND_METHOD, name).result(res) && res && server->bind(name, func, "__safe__");
+        k_mutex_unlock(&bridge_mutex);
+        return out;
     }
 
     void update() {

src/monitor.h

@@ -30,7 +30,7 @@ class BridgeMonitor: public Stream {
     BridgeClass* bridge;
     RingBufferN<BufferSize> temp_buffer;
     struct k_mutex monitor_mutex{};
-    bool is_connected = false;
+    bool _connected = false;
 
 public:
     explicit BridgeMonitor(BridgeClass& bridge): bridge(&bridge) {}
@@ -40,15 +40,31 @@ class BridgeMonitor: public Stream {
     bool begin(unsigned long _legacy_baud=0, uint16_t _legacy_config=0) {
         k_mutex_init(&monitor_mutex);
 
+        if (is_connected()) return true;
+
         bool bridge_started = (*bridge);
         if (!bridge_started) {
             bridge_started = bridge->begin();
         }
-        return bridge_started && bridge->call(MON_CONNECTED_METHOD).result(is_connected);
+
+        if (!bridge_started) return false;
+
+        k_mutex_lock(&monitor_mutex, K_FOREVER);
+        bool out = false;
+        _connected = bridge->call(MON_CONNECTED_METHOD).result(out) && out;
+        k_mutex_unlock(&monitor_mutex);
+        return out;
+    }
+
+    bool is_connected() {
+        k_mutex_lock(&monitor_mutex, K_FOREVER);
+        bool out = _connected;
+        k_mutex_unlock(&monitor_mutex);
+        return out;
     }
 
-    explicit operator bool() const {
-        return is_connected;
+    explicit operator bool() {
+        return is_connected();
     }
 
     int read() override {
@@ -109,11 +125,11 @@ class BridgeMonitor: public Stream {
 
     bool reset() {
         bool res;
-        bool ok = bridge->call(MON_RESET_METHOD).result(res);
-        if (ok && res) {
-            is_connected = false;
-        }
-        return (ok && res);
+        bool ok = bridge->call(MON_RESET_METHOD).result(res) && res;
+        k_mutex_lock(&monitor_mutex, K_FOREVER);
+        _connected = !ok;
+        k_mutex_unlock(&monitor_mutex);
+        return ok;
     }
 
 private:
@@ -135,7 +151,9 @@ class BridgeMonitor: public Stream {
         }
 
         // if (async_rpc.error.code > NO_ERR) {
-        //     is_connected = false;
+        //     k_mutex_lock(&monitor_mutex, K_FOREVER);
+        //     _connected = false;
+        //     k_mutex_unlock(&monitor_mutex);
         // }
     }