feat: BridgeTCPClient constructor for established connections

feat: tcp_client getId method

feat: server-side client connection/disconnection

examples: server.ino with python test script

Author: eigen-value

examples/server/python/main.py

@@ -0,0 +1,27 @@
+# A python sketch that uses RPC Bridge to test the server.ino
+
+import time
+from arduino.app_utils import *
+
+
+def log(msg):
+    with open("./log.log", "a") as f:
+        f.write(str(msg) + "\n")
+
+def main():
+    res = Bridge.call("tcp/connect", "127.0.0.1", 5678)
+    log(f"Connection attempt id: {res}")
+
+    written = Bridge.call("tcp/write", res, "Hello friend")
+    log(f"Written msg of len: {written}")
+
+    time.sleep(1)
+
+    ok = Bridge.call("tcp/close", res)
+    log(f"Closed connection: {ok}")
+
+if __name__ == "__main__":
+
+    while True:
+        main()
+        time.sleep(1)

examples/server/server.ino

@@ -0,0 +1,45 @@
+#include <Arduino_RouterBridge.h>
+
+IPAddress localhost(127, 0, 0, 1);
+BridgeTCPServer<> server(Bridge, localhost, 5678);
+
+void setup() {
+    Serial.begin(115200);
+
+    if (!Bridge.begin()) {
+        Serial.println("cannot setup Bridge");
+        while (true) {}
+    }
+
+    server.begin();
+
+}
+
+void loop() {
+    Serial.println("loop");
+
+    BridgeTCPClient<> client = server.accept();
+
+    if (client.connected() == 1){
+        Serial.print("client ");
+        Serial.print(client.getId());
+        Serial.println(" connected");
+    }
+
+    if (client) {
+        Serial.println("A client established a connection");
+    }
+
+    while (client.connected()) {
+        size_t len = client.available();
+        if (len) {
+            Serial.println("Message received from client");
+            uint8_t buff[len];
+            client.read(buff, len);
+            Serial.write(buff, len);
+        }
+    }
+
+    server.disconnect();    // Disconnects the client server-side
+
+}

src/tcp_client.h

@@ -39,6 +39,8 @@ class BridgeTCPClient : public Client {
 public:
     explicit BridgeTCPClient(BridgeClass& bridge): bridge(&bridge) {}
 
+    BridgeTCPClient(BridgeClass& bridge, uint32_t connection_id, bool connected=true): bridge(&bridge), connection_id(connection_id), _connected {connected} {}
+
     bool begin() {
         k_mutex_init(&client_mutex);
         if (!(*bridge)) {
@@ -95,6 +97,10 @@ class BridgeTCPClient : public Client {
         return 0;
     }
 
+    uint32_t getId() const {
+        return connection_id;
+    }
+
     size_t write(uint8_t c) override {
         return write(&c, 1);
     }

src/tcp_server.h

@@ -35,6 +35,7 @@ class BridgeTCPServer final: public Server {
     bool _listening = false;
     uint32_t listener_id = 0;
     uint32_t connection_id = 0;
+    bool _connected = false;
     struct k_mutex server_mutex{};
 
 public:
@@ -60,7 +61,7 @@ class BridgeTCPServer final: public Server {
 
     BridgeTCPClient<BufferSize> accept() {
 
-        if (connection_id != 0) {
+        if (_connected) {
             return BridgeTCPClient<BufferSize>(*bridge, connection_id);
         }
 
@@ -70,12 +71,15 @@ class BridgeTCPServer final: public Server {
 
         k_mutex_unlock(&server_mutex);
 
-        if (ret && connection_id != 0) {    // connection_id 0 marks an invalid connection
+        if (ret) {    // connection_id 0 marks an invalid connection
+            _connected = true;
             return BridgeTCPClient<BufferSize>(*bridge, connection_id);
+        } else {
+            _connected = false;
+            // Return invalid client
+            return BridgeTCPClient<BufferSize>(*bridge, 0, false);
         }
 
-        // Return invalid client
-        return BridgeTCPClient<BufferSize>(*bridge, 0);
     }
 
     size_t write(uint8_t c) override {
@@ -86,7 +90,7 @@ class BridgeTCPServer final: public Server {
 
         BridgeTCPClient<BufferSize> client = accept();
 
-        if (client) {
+        if (client && _connected) {
             return client.write(buf, size);
         }
 
@@ -106,6 +110,13 @@ class BridgeTCPServer final: public Server {
         k_mutex_unlock(&server_mutex);
     }
 
+    void disconnect() {
+        k_mutex_lock(&server_mutex, K_FOREVER);
+        _connected = false;
+        connection_id = 0;
+        k_mutex_unlock(&server_mutex);
+    }
+
     bool is_listening() const {
         return _listening;
     }