@alteriom/painlessmesh 1.6.1 → 1.7.2

package/src/painlessmesh/configuration.hpp

@@ -1,77 +1,77 @@
-#ifndef _PAINLESS_MESH_CONFIGURATION_HPP_
-#define _PAINLESS_MESH_CONFIGURATION_HPP_
-
-// Include Arduino.h in test environment to ensure TSTRING is defined
-#if defined(PAINLESSMESH_BOOST) || defined(ARDUINO_ARCH_ESP8266) || \
-    defined(ARDUINO_ARCH_ESP32)
-#ifndef ARDUINO
-#include "Arduino.h"
-#endif
-#endif
-
-#include <list>
-
-#include "painlessTaskOptions.h"
-
-#include <TaskSchedulerDeclarations.h>
-
-#define ARDUINOJSON_USE_LONG_LONG 1
-#undef ARDUINOJSON_ENABLE_STD_STRING
-#include <ArduinoJson.h>
-#undef ARDUINOJSON_ENABLE_STD_STRING
-
-// Enable (arduino) wifi support
-#define PAINLESSMESH_ENABLE_ARDUINO_WIFI
-
-// Enable OTA support
-#define PAINLESSMESH_ENABLE_OTA
-
-// Minimum free memory, besides here all packets in queue are discarded.
-#define MIN_FREE_MEMORY 4000
-// MAX number of unsent messages in queue. Newer messages are discarded
-#define MAX_MESSAGE_QUEUE 50
-
-#define NODE_TIMEOUT 10 * TASK_SECOND
-#define SCAN_INTERVAL 30 * TASK_SECOND  // AP scan period in ms
-
-#ifdef ESP32
-#include <AsyncTCP.h>
-#include <WiFi.h>
-#if ESP_ARDUINO_VERSION_MAJOR >= 3
-#include "esp_mac.h"  // required for core 3.x - exposes esp_mac_type_t values
-#endif
-#elif defined(ESP8266)
-#include <ESP8266WiFi.h>
-#include <ESPAsyncTCP.h>
-#endif  // ESP32
-
-// Define TSTRING - use std::string in test environment, Arduino String
-// otherwise
-#if defined(PAINLESSMESH_BOOST)
-// Test environment - TSTRING already defined in test Arduino.h as std::string
-#else
-typedef String TSTRING;
-#endif
-
-// backward compatibility
-template <typename T>
-using SimpleList = std::list<T>;
-
-namespace painlessmesh {
-namespace wifi {
-class Mesh;
-};
-};  // namespace painlessmesh
-
-/** A convenience typedef to access the mesh class*/
-#ifdef PAINLESSMESH_ENABLE_ARDUINO_WIFI
-using painlessMesh = painlessmesh::wifi::Mesh;
-#endif
-
-#ifdef ESP32
-#define MAX_CONN 10
-#else
-#define MAX_CONN 4
-#endif  // DEBUG
-
-#endif
+#ifndef _PAINLESS_MESH_CONFIGURATION_HPP_
+#define _PAINLESS_MESH_CONFIGURATION_HPP_
+
+// Include Arduino.h in test environment to ensure TSTRING is defined
+#if defined(PAINLESSMESH_BOOST) || defined(ARDUINO_ARCH_ESP8266) || \
+    defined(ARDUINO_ARCH_ESP32)
+#ifndef ARDUINO
+#include "Arduino.h"
+#endif
+#endif
+
+#include <list>
+
+#include "painlessTaskOptions.h"
+
+#include <TaskSchedulerDeclarations.h>
+
+#define ARDUINOJSON_USE_LONG_LONG 1
+#undef ARDUINOJSON_ENABLE_STD_STRING
+#include <ArduinoJson.h>
+#undef ARDUINOJSON_ENABLE_STD_STRING
+
+// Enable (arduino) wifi support
+#define PAINLESSMESH_ENABLE_ARDUINO_WIFI
+
+// Enable OTA support
+#define PAINLESSMESH_ENABLE_OTA
+
+// Minimum free memory, besides here all packets in queue are discarded.
+#define MIN_FREE_MEMORY 4000
+// MAX number of unsent messages in queue. Newer messages are discarded
+#define MAX_MESSAGE_QUEUE 50
+
+#define NODE_TIMEOUT 10 * TASK_SECOND
+#define SCAN_INTERVAL 30 * TASK_SECOND  // AP scan period in ms
+
+#ifdef ESP32
+#include <AsyncTCP.h>
+#include <WiFi.h>
+#if ESP_ARDUINO_VERSION_MAJOR >= 3
+#include "esp_mac.h"  // required for core 3.x - exposes esp_mac_type_t values
+#endif
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#endif  // ESP32
+
+// Define TSTRING - use std::string in test environment, Arduino String
+// otherwise
+#if defined(PAINLESSMESH_BOOST)
+// Test environment - TSTRING already defined in test Arduino.h as std::string
+#else
+typedef String TSTRING;
+#endif
+
+// backward compatibility
+template <typename T>
+using SimpleList = std::list<T>;
+
+namespace painlessmesh {
+namespace wifi {
+class Mesh;
+};
+};  // namespace painlessmesh
+
+/** A convenience typedef to access the mesh class*/
+#ifdef PAINLESSMESH_ENABLE_ARDUINO_WIFI
+using painlessMesh = painlessmesh::wifi::Mesh;
+#endif
+
+#ifdef ESP32
+#define MAX_CONN 10
+#else
+#define MAX_CONN 4
+#endif  // DEBUG
+
+#endif

package/src/painlessmesh/connection.hpp

@@ -1,192 +1,192 @@
-#ifndef _PAINLESS_MESH_CONNECTION_HPP_
-#define _PAINLESS_MESH_CONNECTION_HPP_
-
-#include <memory>
-
-#include "Arduino.h"
-#include "painlessmesh/configuration.hpp"
-
-#include "painlessmesh/buffer.hpp"
-#include "painlessmesh/logger.hpp"
-
-extern painlessmesh::logger::LogClass Log;
-
-namespace painlessmesh {
-namespace tcp {
-
-// Shared buffer for reading/writing to the buffer
-static painlessmesh::buffer::temp_buffer_t shared_buffer;
-
-/**
- * Class that performs buffered read and write to the tcp connection
- * (asyncclient)
- *
- * Note that the class expects to be wrapped in a shared_ptr to ensure proper
- * lifetime management. Objects generally will only be destroyed after close is
- * called (and the reading and writing tasks are stopped).
- */
-class BufferedConnection
-    : public std::enable_shared_from_this<BufferedConnection> {
- public:
-  /**
-   * Create a buffered connection around the client
-   *
-   *
-   * BufferedConnection takes ownership of the client  and will delete the
-   * pointer at the end.
-   *
-   * One should always call initialize after construction
-   */
-  BufferedConnection(AsyncClient *client) : client(client) {}
-
-  ~BufferedConnection() {
-    Log.remote("~BufferedConnection");
-    this->close();
-    if (!client->freeable()) {
-      client->close(true);
-    }
-    client->abort();
-    delete client;
-  }
-
-  void initialize(Scheduler *scheduler) {
-    auto self = this->shared_from_this();
-    sentBufferTask.set(TASK_SECOND, TASK_FOREVER, [self]() {
-      if (!self->sentBuffer.empty() && self->client->canSend()) {
-        auto ret = self->writeNext();
-        if (ret)
-          self->sentBufferTask.forceNextIteration();
-        else
-          self->sentBufferTask.delay(100 * TASK_MILLISECOND);
-      }
-    });
-    scheduler->addTask(sentBufferTask);
-    sentBufferTask.enableDelayed();
-
-    readBufferTask.set(TASK_SECOND, TASK_FOREVER, [self]() {
-      if (!self->receiveBuffer.empty()) {
-        TSTRING frnt = self->receiveBuffer.front();
-        self->receiveBuffer.pop_front();
-        if (!self->receiveBuffer.empty())
-          self->readBufferTask.forceNextIteration();
-        if (self->receiveCallback) self->receiveCallback(frnt);
-      }
-    });
-    scheduler->addTask(readBufferTask);
-    readBufferTask.enableDelayed();
-
-    client->onAck(
-        [self](void *arg, AsyncClient *client, size_t len, uint32_t time) {
-          self->sentBufferTask.forceNextIteration();
-        },
-        NULL);
-
-    client->onData(
-        [self](void *arg, AsyncClient *client, void *data, size_t len) {
-          self->receiveBuffer.push(static_cast<const char *>(data), len,
-                                   shared_buffer);
-          // Signal that we are done
-          self->client->ack(len);
-          self->readBufferTask.forceNextIteration();
-        },
-        NULL);
-
-    client->onDisconnect(
-        [self](void *arg, AsyncClient *client) { self->close(); }, NULL);
-  }
-
-  void close() {
-    if (!mConnected) return;
-
-    // Disable tasks and callbacks
-    this->sentBufferTask.setCallback(NULL);
-    this->sentBufferTask.disable();
-    this->readBufferTask.setCallback(NULL);
-    this->readBufferTask.disable();
-
-    this->client->onData(NULL, NULL);
-    this->client->onAck(NULL, NULL);
-    this->client->onDisconnect(NULL, NULL);
-    this->client->onError(NULL, NULL);
-
-    if (client->connected()) {
-      client->close();
-    }
-
-    receiveBuffer.clear();
-    sentBuffer.clear();
-
-    if (disconnectCallback) disconnectCallback();
-
-    receiveCallback = NULL;
-    disconnectCallback = NULL;
-
-    mConnected = false;
-  }
-
-  bool write(const TSTRING &data, bool priority = false) {
-    sentBuffer.push(data, priority);
-    sentBufferTask.forceNextIteration();
-    return true;
-  }
-
-  void onDisconnect(std::function<void()> callback) {
-    disconnectCallback = callback;
-  }
-
-  void onReceive(std::function<void(TSTRING)> callback) {
-    receiveCallback = callback;
-  }
-
-  bool connected() { return mConnected; }
-
- protected:
-  bool mConnected = true;
-
-  AsyncClient *client;
-
-  std::function<void(TSTRING)> receiveCallback;
-  std::function<void()> disconnectCallback;
-
-  painlessmesh::buffer::ReceiveBuffer<TSTRING> receiveBuffer;
-  painlessmesh::buffer::SentBuffer<TSTRING> sentBuffer;
-
-  bool writeNext() {
-    if (sentBuffer.empty()) {
-      return false;
-    }
-    auto len = sentBuffer.requestLength(shared_buffer.length);
-    auto snd_len = client->space();
-    if (len > snd_len) len = snd_len;
-    if (len > 0) {
-      // sentBuffer.read(len, shared_buffer);
-      // auto written = client->write(shared_buffer.buffer, len, 1);
-      auto data_ptr = sentBuffer.readPtr(len);
-      auto written = client->write(data_ptr, len, 1);
-      if (written == len) {
-        client->send();  // TODO only do this for priority messages
-        sentBuffer.freeRead();
-        sentBufferTask.forceNextIteration();
-        return true;
-      } else if (written == 0) {
-        return false;
-      } else {
-        return false;
-      }
-    } else {
-      return false;
-    }
-  }
-
-  Task sentBufferTask;
-  Task readBufferTask;
-
-  template <typename T>
-  std::shared_ptr<T> shared_from(T *derived) {
-    return std::static_pointer_cast<T>(shared_from_this());
-  }
-};  // namespace tcp
-};  // namespace tcp
-};  // namespace painlessmesh
-
-#endif
+#ifndef _PAINLESS_MESH_CONNECTION_HPP_
+#define _PAINLESS_MESH_CONNECTION_HPP_
+
+#include <memory>
+
+#include "Arduino.h"
+#include "painlessmesh/configuration.hpp"
+
+#include "painlessmesh/buffer.hpp"
+#include "painlessmesh/logger.hpp"
+
+extern painlessmesh::logger::LogClass Log;
+
+namespace painlessmesh {
+namespace tcp {
+
+// Shared buffer for reading/writing to the buffer
+static painlessmesh::buffer::temp_buffer_t shared_buffer;
+
+/**
+ * Class that performs buffered read and write to the tcp connection
+ * (asyncclient)
+ *
+ * Note that the class expects to be wrapped in a shared_ptr to ensure proper
+ * lifetime management. Objects generally will only be destroyed after close is
+ * called (and the reading and writing tasks are stopped).
+ */
+class BufferedConnection
+    : public std::enable_shared_from_this<BufferedConnection> {
+ public:
+  /**
+   * Create a buffered connection around the client
+   *
+   *
+   * BufferedConnection takes ownership of the client  and will delete the
+   * pointer at the end.
+   *
+   * One should always call initialize after construction
+   */
+  BufferedConnection(AsyncClient *client) : client(client) {}
+
+  ~BufferedConnection() {
+    Log.remote("~BufferedConnection");
+    this->close();
+    if (!client->freeable()) {
+      client->close(true);
+    }
+    client->abort();
+    delete client;
+  }
+
+  void initialize(Scheduler *scheduler) {
+    auto self = this->shared_from_this();
+    sentBufferTask.set(TASK_SECOND, TASK_FOREVER, [self]() {
+      if (!self->sentBuffer.empty() && self->client->canSend()) {
+        auto ret = self->writeNext();
+        if (ret)
+          self->sentBufferTask.forceNextIteration();
+        else
+          self->sentBufferTask.delay(100 * TASK_MILLISECOND);
+      }
+    });
+    scheduler->addTask(sentBufferTask);
+    sentBufferTask.enableDelayed();
+
+    readBufferTask.set(TASK_SECOND, TASK_FOREVER, [self]() {
+      if (!self->receiveBuffer.empty()) {
+        TSTRING frnt = self->receiveBuffer.front();
+        self->receiveBuffer.pop_front();
+        if (!self->receiveBuffer.empty())
+          self->readBufferTask.forceNextIteration();
+        if (self->receiveCallback) self->receiveCallback(frnt);
+      }
+    });
+    scheduler->addTask(readBufferTask);
+    readBufferTask.enableDelayed();
+
+    client->onAck(
+        [self](void *arg, AsyncClient *client, size_t len, uint32_t time) {
+          self->sentBufferTask.forceNextIteration();
+        },
+        NULL);
+
+    client->onData(
+        [self](void *arg, AsyncClient *client, void *data, size_t len) {
+          self->receiveBuffer.push(static_cast<const char *>(data), len,
+                                   shared_buffer);
+          // Signal that we are done
+          self->client->ack(len);
+          self->readBufferTask.forceNextIteration();
+        },
+        NULL);
+
+    client->onDisconnect(
+        [self](void *arg, AsyncClient *client) { self->close(); }, NULL);
+  }
+
+  void close() {
+    if (!mConnected) return;
+
+    // Disable tasks and callbacks
+    this->sentBufferTask.setCallback(NULL);
+    this->sentBufferTask.disable();
+    this->readBufferTask.setCallback(NULL);
+    this->readBufferTask.disable();
+
+    this->client->onData(NULL, NULL);
+    this->client->onAck(NULL, NULL);
+    this->client->onDisconnect(NULL, NULL);
+    this->client->onError(NULL, NULL);
+
+    if (client->connected()) {
+      client->close();
+    }
+
+    receiveBuffer.clear();
+    sentBuffer.clear();
+
+    if (disconnectCallback) disconnectCallback();
+
+    receiveCallback = NULL;
+    disconnectCallback = NULL;
+
+    mConnected = false;
+  }
+
+  bool write(const TSTRING &data, bool priority = false) {
+    sentBuffer.push(data, priority);
+    sentBufferTask.forceNextIteration();
+    return true;
+  }
+
+  void onDisconnect(std::function<void()> callback) {
+    disconnectCallback = callback;
+  }
+
+  void onReceive(std::function<void(TSTRING)> callback) {
+    receiveCallback = callback;
+  }
+
+  bool connected() { return mConnected; }
+
+ protected:
+  bool mConnected = true;
+
+  AsyncClient *client;
+
+  std::function<void(TSTRING)> receiveCallback;
+  std::function<void()> disconnectCallback;
+
+  painlessmesh::buffer::ReceiveBuffer<TSTRING> receiveBuffer;
+  painlessmesh::buffer::SentBuffer<TSTRING> sentBuffer;
+
+  bool writeNext() {
+    if (sentBuffer.empty()) {
+      return false;
+    }
+    auto len = sentBuffer.requestLength(shared_buffer.length);
+    auto snd_len = client->space();
+    if (len > snd_len) len = snd_len;
+    if (len > 0) {
+      // sentBuffer.read(len, shared_buffer);
+      // auto written = client->write(shared_buffer.buffer, len, 1);
+      auto data_ptr = sentBuffer.readPtr(len);
+      auto written = client->write(data_ptr, len, 1);
+      if (written == len) {
+        client->send();  // TODO only do this for priority messages
+        sentBuffer.freeRead();
+        sentBufferTask.forceNextIteration();
+        return true;
+      } else if (written == 0) {
+        return false;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  Task sentBufferTask;
+  Task readBufferTask;
+
+  template <typename T>
+  std::shared_ptr<T> shared_from(T *derived) {
+    return std::static_pointer_cast<T>(shared_from_this());
+  }
+};  // namespace tcp
+};  // namespace tcp
+};  // namespace painlessmesh
+
+#endif