@alteriom/painlessmesh 1.6.1

package/src/boost/asynctcp.hpp

@@ -0,0 +1,279 @@
+#ifndef _BOOST_ASYNCTCP_HPP_
+#define _BOOST_ASYNCTCP_HPP_
+
+#include <boost/array.hpp>
+#include <boost/asio.hpp>
+#include <iostream>
+
+#ifndef TCP_MSS
+#define TCP_MSS 1024
+#endif
+
+using boost::asio::ip::tcp;
+
+#define ASYNC_WRITE_FLAG_COPY 0x01
+
+class AsyncClient;
+
+typedef std::function<void(void*, AsyncClient*)> AcConnectHandler;
+typedef std::function<void(void*, AsyncClient*, size_t len, uint32_t time)>
+    AcAckHandler;
+typedef std::function<void(void*, AsyncClient*, int8_t error)> AcErrorHandler;
+typedef std::function<void(void*, AsyncClient*, void* data, size_t len)>
+    AcDataHandler;
+// typedef std::function<void(void*, AsyncClient*, struct pbuf* pb)>
+//    AcPacketHandler;
+typedef std::function<void(void*, AsyncClient*, uint32_t time)>
+    AcTimeoutHandler;
+
+typedef boost::asio::ip::address IPAddress;
+
+class AsyncClient {
+ public:
+  AsyncClient(boost::asio::io_context& io_service)
+      : _io_service(io_service), mSocket(_io_service) {}
+
+  bool connect(IPAddress ipaddress, uint16_t port) {
+    namespace ip = boost::asio::ip;
+    auto endpoint = ip::tcp::endpoint(ipaddress, port);
+
+    mSocket.async_connect(endpoint, [&](auto& ec) { this->handleConnect(ec); });
+    return true;
+  }
+
+  void initRead() {
+    mSocket.async_read_some(
+        boost::asio::buffer(mInputBuffer, TCP_MSS),
+        [&](auto& ec, auto len) { this->handleData(ec, len); });
+  }
+
+  size_t write(const void* data, size_t len,
+               size_t copy = ASYNC_WRITE_FLAG_COPY) {
+    if (writing) return 0;
+    writing = true;
+    if (copy == ASYNC_WRITE_FLAG_COPY) {
+      memcpy(mWriteBuffer, data, len);
+      mSocket.async_send(
+          boost::asio::buffer(mWriteBuffer, len),
+          [&](auto& ec, auto len) { this->handleWrite(ec, len); });
+    } else {
+      mSocket.async_send(
+          boost::asio::buffer(data, len),
+          [&](auto& ec, auto len) { this->handleWrite(ec, len); });
+    }
+    return len;
+  }
+
+  // Dummy functions for compatibility with ESPAsycnTCP
+  void send() {}
+  void setNoDelay(bool value = true) {}
+  void setRxTimeout(uint32_t timeout) {}
+  const char* errorToString(int8_t error) { return ""; }
+
+  // TODO: check if there is a better one
+  void abort() { this->close(true); }
+
+  void onConnect(AcConnectHandler cb, void* arg = 0) {
+    _connect_cb = cb;
+    _connect_cb_arg = arg;
+  }
+
+  void onDisconnect(AcConnectHandler cb, void* arg = 0) {
+    _discard_cb = cb;
+    _discard_cb_arg = arg;
+  }
+
+  void onAck(AcAckHandler cb, void* arg = 0) {
+    _sent_cb = cb;
+    _sent_cb_arg = arg;
+  }
+
+  void onError(AcErrorHandler cb, void* arg = 0) {
+    _error_cb = cb;
+    _error_cb_arg = arg;
+  }
+
+  void onData(AcDataHandler cb, void* arg = 0) {
+    _recv_cb = cb;
+    _recv_cb_arg = arg;
+  }
+
+  void onTimeout(AcTimeoutHandler cb, void* arg = 0) {
+    _timeout_cb = cb;
+    _timeout_cb_arg = arg;
+  }
+
+  void onPoll(AcConnectHandler cb, void* arg = 0) {
+    _poll_cb = cb;
+    _poll_cb_arg = arg;
+  }
+
+  bool connected() { return mSocket.is_open(); }
+
+  bool freeable() { return !this->connected(); }
+
+  void close(bool now = true) {
+    if (this->connected()) {
+      mSocket.close();
+    }
+    if (!disconnectCalled) {
+      disconnectCalled = true;
+      if (_discard_cb) {
+        _discard_cb(_discard_cb_arg, this);
+      }
+    }
+  }
+
+  ~AsyncClient() { close(true); }
+
+  size_t space() {
+    // This could be more intelligent, but simple and safe for now
+    if (writing) return 0;
+    return TCP_MSS;
+  }
+
+  bool canSend() { return this->space() > 0; }
+
+  size_t ack(size_t len) {
+    // Currently assumes that len is actually the size of the data that was sent
+    // Otherwise it will break
+    initRead();
+    return len;
+  }
+
+  tcp::socket& socket() { return mSocket; }
+
+ protected:
+  boost::asio::io_context& _io_service;
+  tcp::socket mSocket;
+
+  char mInputBuffer[TCP_MSS];
+  char mWriteBuffer[TCP_MSS];
+  bool writing = false;
+
+  bool disconnectCalled = false;
+
+  AcConnectHandler _connect_cb = 0;
+  void* _connect_cb_arg = 0;
+  AcConnectHandler _discard_cb = 0;
+  void* _discard_cb_arg = 0;
+  AcAckHandler _sent_cb = 0;
+  void* _sent_cb_arg = 0;
+  AcErrorHandler _error_cb = 0;
+  void* _error_cb_arg = 0;
+  AcDataHandler _recv_cb = 0;
+  void* _recv_cb_arg = 0;
+  AcTimeoutHandler _timeout_cb = 0;
+  void* _timeout_cb_arg = 0;
+  AcConnectHandler _poll_cb = 0;
+  void* _poll_cb_arg = 0;
+
+  void handleConnect(const boost::system::error_code& ec) {
+    if (!ec) {
+      if (_connect_cb) _connect_cb(_connect_cb_arg, this);
+
+      initRead();
+    } else {
+      handleError(ec);
+      if (this->connected()) close(true);
+    }
+  }
+
+  void handleData(const boost::system::error_code& ec, size_t len) {
+    if (disconnectCalled) return;
+
+    if (!ec) {
+      if (_recv_cb) {
+        _recv_cb(_recv_cb_arg, this, (void*)mInputBuffer, len);
+      }
+    } else {
+      handleError(ec);
+      close(true);
+    }
+  }
+
+  void handleWrite(const boost::system::error_code& ec, size_t len) {
+    if (disconnectCalled) return;
+
+    if (!ec) {
+      if (_sent_cb) {
+        // TODO send actual time
+        _sent_cb(_sent_cb_arg, this, len, 0);
+      }
+      writing = false;
+    } else {
+      handleError(ec);
+      close(true);
+    }
+  }
+
+  void handleError(const boost::system::error_code& ec) {
+    if (ec != boost::asio::error::eof && _error_cb) {
+      _error_cb(_error_cb_arg, this, ec.value());
+    }
+  }
+};
+
+class AsyncServer {
+ public:
+  AsyncServer(boost::asio::io_context& io_service, uint16_t port)
+      : _io_service(io_service),
+        // mSocket(io_service),
+        _port(port),
+        mAcceptor(io_service) {}
+
+  ~AsyncServer() { this->end(); }
+
+  void onClient(AcConnectHandler cb, void* arg = 0) {
+    _connect_cb = cb;
+    _connect_cb_arg = arg;
+  }
+
+  // begin() should do start_accept (see server2):w
+  void begin() {
+    mAcceptor.open(tcp::v4());
+    int one = 1;
+    setsockopt(mAcceptor.native_handle(), SOL_SOCKET,
+               SO_REUSEADDR | SO_REUSEPORT, &one, sizeof(one));
+    boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), _port);
+    mAcceptor.set_option(boost::asio::socket_base::reuse_address(true));
+    mAcceptor.set_option(boost::asio::ip::tcp::no_delay(true));
+    mAcceptor.set_option(boost::asio::socket_base::send_buffer_size(65536));
+    mAcceptor.set_option(boost::asio::socket_base::receive_buffer_size(65536));
+    mAcceptor.bind(endpoint);
+    mAcceptor.listen();
+    initAccept();
+  }
+
+  // Acceptor stop?
+  void end() { mAcceptor.close(); }
+
+  // Dummy function for compatibility with ESPAsycnTCP
+  void setNoDelay(bool value = true) {}
+
+ protected:
+  boost::asio::io_context& _io_service;
+  uint16_t _port;
+  tcp::acceptor mAcceptor;
+  AcConnectHandler _connect_cb = 0;
+  void* _connect_cb_arg = 0;
+
+  void initAccept() {
+#if BOOST_VERSION >= 107000
+    AsyncClient* client = new AsyncClient(_io_service);
+#else
+    AsyncClient* client = new AsyncClient(mAcceptor.get_io_service());
+#endif
+    mAcceptor.async_accept(
+        client->socket(), [this, client](const boost::system::error_code& e) {
+          if (!e && this->_connect_cb) {
+            this->_connect_cb(this->_connect_cb_arg, client);
+            this->initAccept();
+            client->initRead();
+          } else
+            std::cout << "Error: " << e.message() << std::endl;
+        });
+  }
+};
+
+#endif

package/src/painlessMesh.h

@@ -0,0 +1,70 @@
+#ifndef _EASY_MESH_H_
+#define _EASY_MESH_H_
+
+#include "painlessTaskOptions.h"
+
+#include <Arduino.h>
+#include <functional>
+#include <list>
+#include <memory>
+#include "painlessmesh/configuration.hpp"
+#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
+
+#ifdef PAINLESSMESH_ENABLE_ARDUINO_WIFI
+#include "painlessMeshSTA.h"
+
+#include "arduino/wifi.hpp"
+#endif
+
+#ifdef PAINLESSMESH_ENABLE_OTA
+#include "painlessmesh/ota.hpp"
+#endif
+
+// Include improvement modules when enabled
+#ifdef PAINLESSMESH_ENABLE_VALIDATION
+#include "painlessmesh/validation.hpp"
+#endif
+
+#ifdef PAINLESSMESH_ENABLE_METRICS
+#include "painlessmesh/metrics.hpp"
+#endif
+
+#ifdef PAINLESSMESH_ENABLE_MEMORY_OPTIMIZATION
+#include "painlessmesh/memory.hpp"
+#endif
+
+#include "painlessmesh/buffer.hpp"
+#include "painlessmesh/layout.hpp"
+#include "painlessmesh/logger.hpp"
+#include "painlessmesh/mesh.hpp"
+#include "painlessmesh/ntp.hpp"
+#include "painlessmesh/plugin.hpp"
+#include "painlessmesh/protocol.hpp"
+#include "painlessmesh/router.hpp"
+#include "painlessmesh/tcp.hpp"
+using namespace painlessmesh::logger;
+
+/*! \mainpage painlessMesh: A painless way to setup a mesh.
+ *
+ * painlessMesh is designed in a modular way, with many parent classes. The best
+ * place to get started with the documentation is to have a look at
+ * painlessmesh::wifi::Mesh (the main painlessMesh class is an alias (typedef)
+ * of the painlessmesh::wifi::Mesh class). Make sure to also explore the public
+ * member functions inherited from other classes, to get full information on the
+ * functions available to you.
+ */
+
+#ifndef PAINLESSMESH_ENABLE_ARDUINO_WIFI
+using painlessMesh = painlessmesh::Mesh<Connection>;
+#endif
+
+#endif  //   _EASY_MESH_H_

package/src/painlessMeshSTA.cpp

@@ -0,0 +1,236 @@
+//
+//  painlessMeshSTA.cpp
+//
+//
+//  Created by Bill Gray on 7/26/16.
+//
+//
+#include "painlessmesh/configuration.hpp"
+
+#ifdef PAINLESSMESH_ENABLE_ARDUINO_WIFI
+
+#include <Arduino.h>
+#include <algorithm>
+#include <memory>
+
+#include "arduino/wifi.hpp"
+
+#include "painlessmesh/layout.hpp"
+#include "painlessmesh/tcp.hpp"
+
+extern painlessmesh::logger::LogClass Log;
+
+//***********************************************************************
+// Calculate NodeID from a hardware MAC address
+void ICACHE_FLASH_ATTR StationScan::init(painlessmesh::wifi::Mesh *pMesh,
+                                         TSTRING pssid, TSTRING ppassword,
+                                         uint16_t pport, uint8_t pchannel,
+                                         bool phidden) {
+  ssid = pssid;
+  password = ppassword;
+  mesh = pMesh;
+  port = pport;
+  channel = pchannel;
+  hidden = phidden;
+
+  task.set(SCAN_INTERVAL, TASK_FOREVER, [this]() { stationScan(); });
+}
+
+// Starts scan for APs whose name is Mesh SSID
+void ICACHE_FLASH_ATTR StationScan::stationScan() {
+  using namespace painlessmesh::logger;
+  Log(CONNECTION, "stationScan(): %s\n", ssid.c_str());
+
+#ifdef ESP32
+  WiFi.scanNetworks(true, hidden, false, 300U, channel);
+#elif defined(ESP8266)
+  // WiFi.scanNetworksAsync([&](int networks) { this->scanComplete(); }, true);
+  // Try 600 times (60 seconds). If not completed after that, give up
+  asyncTask.set(100 * TASK_MILLISECOND, 600, [this]() {
+    auto num = WiFi.scanComplete();
+    if (num == WIFI_SCAN_FAILED || num > 0) {
+      this->asyncTask.disable();
+      this->scanComplete();
+    }
+  });
+  mesh->mScheduler->addTask(asyncTask);
+  asyncTask.enableDelayed();
+  WiFi.scanNetworks(true, hidden, channel);
+#endif
+
+  task.delay(10 * SCAN_INTERVAL);  // Scan should be completed by then and next
+                                   // step called. If not then we restart here.
+  return;
+}
+
+void ICACHE_FLASH_ATTR StationScan::scanComplete() {
+  using namespace painlessmesh::logger;
+  Log(CONNECTION, "scanComplete(): Scan finished\n");
+
+  aps.clear();
+  Log(CONNECTION, "scanComplete():-- > Cleared old APs.\n");
+
+  auto num = WiFi.scanComplete();
+  if (num == WIFI_SCAN_FAILED) {
+    Log(ERROR, "wifi scan failed. Retrying....\n");
+    task.forceNextIteration();
+    return;
+  } else if (num == WIFI_SCAN_RUNNING) {
+    Log(ERROR,
+        "scanComplete should never be called when scan is still running.\n");
+    return;
+  }
+
+  Log(CONNECTION, "scanComplete(): num = %d\n", num);
+
+  for (auto i = 0; i < num; ++i) {
+    WiFi_AP_Record_t record;
+    record.ssid = WiFi.SSID(i);
+
+    if (WiFi.channel(i) != mesh->_meshChannel) {
+      continue;
+    }
+
+    if (record.ssid != ssid) {
+      if (record.ssid.equals("") && mesh->_meshHidden) {
+        // Hidden mesh
+        record.ssid = ssid;
+      } else {
+        continue;
+      }
+    }
+
+    record.rssi = WiFi.RSSI(i);
+    if (record.rssi == 0) continue;
+
+    memcpy((void *)&record.bssid, (void *)WiFi.BSSID(i), sizeof(record.bssid));
+    aps.push_back(record);
+    Log(CONNECTION, "\tfound : %s, %ddBm\n", record.ssid.c_str(),
+        (int16_t)record.rssi);
+  }
+
+  Log(CONNECTION, "\tFound %d nodes\n", aps.size());
+
+  task.yield([this]() {
+    // Task filter all unknown
+    filterAPs();
+
+    lastAPs = aps;
+
+    // Next task is to sort by strength
+    task.yield([this] {
+      aps.sort([](WiFi_AP_Record_t a, WiFi_AP_Record_t b) {
+        return a.rssi > b.rssi;
+      });
+      // Next task is to connect to the top ap
+      task.yield([this]() { connectToAP(); });
+    });
+  });
+}
+
+void ICACHE_FLASH_ATTR StationScan::filterAPs() {
+  auto ap = aps.begin();
+  while (ap != aps.end()) {
+    auto apNodeId = painlessmesh::tcp::encodeNodeId(ap->bssid);
+    if (painlessmesh::router::findRoute<painlessmesh::Connection>(
+            (*mesh), apNodeId) != NULL) {
+      ap = aps.erase(ap);
+    } else {
+      ap++;
+    }
+  }
+}
+
+void ICACHE_FLASH_ATTR StationScan::requestIP(WiFi_AP_Record_t &ap) {
+  using namespace painlessmesh::logger;
+  Log(CONNECTION, "connectToAP(): Best AP is %u<---\n",
+      painlessmesh::tcp::encodeNodeId(ap.bssid));
+  WiFi.begin(ap.ssid.c_str(), password.c_str(), mesh->_meshChannel, ap.bssid);
+  return;
+}
+
+void ICACHE_FLASH_ATTR StationScan::connectToAP() {
+  using namespace painlessmesh;
+  using namespace painlessmesh::logger;
+  // Next task will be to rescan
+  task.setCallback([this]() { stationScan(); });
+
+  if (manual) {
+    if ((WiFi.SSID() == ssid) && WiFi.status() == WL_CONNECTED) {
+      Log(CONNECTION,
+          "connectToAP(): Already connected using manual connection. "
+          "Disabling scanning.\n");
+      task.disable();
+      return;
+    } else {
+      if (WiFi.status() == WL_CONNECTED) {
+        Log.remote("Close Sta because trying to connect manually\n");
+        mesh->closeConnectionSTA();
+        task.enableDelayed(10 * SCAN_INTERVAL);
+        return;
+      } else if (aps.empty() || !ssid.equals(aps.begin()->ssid)) {
+        task.enableDelayed(SCAN_INTERVAL);
+        return;
+      }
+    }
+  }
+  bool isRooted = layout::isRooted(mesh->asNodeTree());
+  if (aps.empty()) {
+    // No unknown nodes found
+    if (WiFi.status() == WL_CONNECTED &&
+        !(mesh->shouldContainRoot && !isRooted)) {
+      // if already connected -> scan slow
+      Log(CONNECTION,
+          "connectToAP(): Already connected, and no unknown nodes found: "
+          "scan rate set to slow\n");
+      task.delay(4 * SCAN_INTERVAL);
+    } else {
+      // else scan fast (SCAN_INTERVAL)
+      Log(CONNECTION,
+          "connectToAP(): No unknown nodes found scan rate set to "
+          "fast\n");
+      task.setInterval(0.5 * SCAN_INTERVAL);
+    }
+    mesh->stability += min(1000 - mesh->stability, (size_t)25);
+  } else {
+    if (WiFi.status() == WL_CONNECTED) {
+      // TODO: Use %u instead of String() here and below
+      // Also prob is always equal to stability, so we should use that directly
+      Log(CONNECTION,
+          "connectToAP(): Unknown nodes found. Current stability: %s\n",
+          String(mesh->stability).c_str());
+
+      int prob = mesh->stability;
+      if (!isRooted && random(0, 1000) < prob) {
+        Log(CONNECTION, "connectToAP(): Reconfigure network: %s\n",
+            String(prob).c_str());
+        // close STA connection, this will trigger station disconnect which
+        // will trigger connectToAP()
+        mesh->closeConnectionSTA();
+        mesh->stability = 0;  // Discourage switching again
+        Log.remote("Close Sta to reconfigure network\n");
+        // wifiEventCB should be triggered before this delay runs out
+        // and reset the connecting
+        task.delay(4 * SCAN_INTERVAL);
+      } else {
+        if (!isRooted && mesh->shouldContainRoot)
+          // Increase scanning rate, because we want to find root
+          task.delay(0.5 * SCAN_INTERVAL);
+        else
+          task.delay(4 * SCAN_INTERVAL);
+      }
+    } else {
+      // Else try to connect to first
+      auto ap = aps.front();
+      aps.pop_front();  // drop bestAP from mesh list, so if doesn't work out,
+                        // we can try the next one
+      requestIP(ap);
+      // Trying to connect, if that fails we will reconnect later
+      Log(CONNECTION,
+          "connectToAP(): Trying to connect, scan rate set to "
+          "4*normal\n");
+      task.delay(4 * SCAN_INTERVAL);
+    }
+  }
+}
+#endif

package/src/painlessMeshSTA.h

@@ -0,0 +1,58 @@
+#ifndef _PAINLESS_MESH_STA_H_
+#define _PAINLESS_MESH_STA_H_
+
+#include "painlessmesh/configuration.hpp"
+
+#include "painlessmesh/mesh.hpp"
+
+#include <list>
+
+typedef struct {
+  uint8_t bssid[6];
+  TSTRING ssid;
+  int8_t rssi;
+} WiFi_AP_Record_t;
+
+class StationScan {
+ public:
+  Task task;  // Station scanning for connections
+
+#ifdef ESP8266
+  Task asyncTask;
+#endif
+
+  StationScan() {}
+  void init(painlessmesh::wifi::Mesh *pMesh, TSTRING ssid, TSTRING password,
+            uint16_t port, uint8_t channel, bool hidden);
+  void stationScan();
+  void scanComplete();
+  void filterAPs();
+  void connectToAP();
+  // This one will call the connectToAP next in the task and should be used
+  // instead of connectToAP
+  void yieldConnectToAP() {
+    task.yield([this]() { connectToAP(); });
+  }
+
+  /// Valid APs found during the last scan
+  std::list<WiFi_AP_Record_t> lastAPs;
+
+ protected:
+  TSTRING ssid;
+  TSTRING password;
+  painlessMesh *mesh;
+  uint16_t port;
+  uint8_t channel;
+  bool hidden;
+  std::list<WiFi_AP_Record_t> aps;
+
+  void requestIP(WiFi_AP_Record_t &ap);
+
+  // Manually configure network and ip
+  bool manual = false;
+  IPAddress manualIP = IPAddress(0, 0, 0, 0);
+
+  friend painlessMesh;
+};
+
+#endif

package/src/painlessTaskOptions.h

@@ -0,0 +1,4 @@
+//  The following two complie options are required for painlessMesh
+#define _TASK_PRIORITY      // Support for layered scheduling priority
+#define _TASK_STD_FUNCTION  // Support for std::function (ESP8266 and ESP32
+                            // ONLY)