Release 0.9.1

was pr#22 : added reply to message subscribe and unsubscribe

.github/workflows/aunit.yml

@@ -24,5 +24,11 @@ jobs:
         git clone https://github.com/hsaturn/EspMock
     - name: Verify tests
       run: |
-        make -C tests
+        # Run tests for ESP8266
+        make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
         make -C tests runtests
+        make -C tests clean
+        # Run tests for ESP32
+        #make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
+        #make -C tests runtests
+        #make -C tests clean

.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: "CI"
+on:
+  
+jobs:
+  ci:
+    runs-on: ubuntu-20.04
+    steps:
+    - name: Checkout this repository
+      uses: actions/checkout@v2.3.4
+    - name: Cache for arduino-ci
+      uses: actions/cache@v2.1.3
+      with:
+        path: |
+          ~/.arduino15
+        key: ${{ runner.os }}-arduino
+    - name: Install nix
+      uses: cachix/install-nix-action@v12
+    - run: nix-shell -I nixpkgs=channel:nixpkgs-unstable -p arduino-ci --run "arduino-ci"

.github/workflows/superlinter.yml

@@ -1,26 +1,52 @@
-name: Super-Linter
+---
+#################################
+#################################
+## Super Linter GitHub Actions ##
+#################################
+#################################
+name: Lint Code Base
 
-# Run this workflow every time a new commit pushed to your repository
 #
+# Documentation:
+# https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions
+#
+
+#############################
+# Start the job on all push #
+#############################
 on: push
 
+###############
+# Set the Job #
+###############
 jobs:
-  # Set the job key. The key is displayed as the job name
+  build:
-  # when a job name is not provided
-  super-lint:
     # Name the Job
-    name: Lint code base
+    name: Lint Code Base
-    # Set the type of machine to run on
+    # Set the agent to run on
     runs-on: ubuntu-latest
 
+    ##################
+    # Load all steps #
+    ##################
     steps:
-      # Checks out a copy of your repository on the ubuntu-latest machine
+      ##########################
-      - name: Checkout code
+      # Checkout the code base #
-        uses: actions/checkout@v2
+      ##########################
+      - name: Checkout Code
+        uses: actions/checkout@v3
+        with:
+          # Full git history is needed to get a proper
+          # list of changed files within `super-linter`
+          fetch-depth: 0
 
-      # Runs the Super-Linter action
+      ################################
-      - name: Run Super-Linter
+      # Run Linter against code base #
-        uses: github/super-linter@v3
+      ################################
+      - name: Lint Code Base
+        uses: github/super-linter/slim@v4
         env:
+          VALIDATE_ALL_CODEBASE: false
+          # Change to 'master' if your main branch differs
           DEFAULT_BRANCH: main
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -1,17 +1,19 @@
 # TinyMqtt
 
-![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)
+[![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/releases)
-![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)
+[![AUnit Tests](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml)
-![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)
+[![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/issues)
-![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)
+[![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
-![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)
+[![Esp32](https://img.shields.io/badge/platform-ESP32-green)](https://www.espressif.com/en/products/socs/esp32)
+[![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)](https://www.gnu.org/licenses/gpl-3.0.fr.html)
+[![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)](https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html#_Toc442180822)
 
-ESP 8266 is a small, fast and capable Mqtt Broker and Client
+TinyMqtt is a small, fast and capable Mqtt Broker and Client for Esp8266 / Esp32 / Esp WROOM
 
 ## Features
 
-- Very (very !!) fast broker I saw it re-sent 1000 topics per second for two
+- Very fast broker I saw it re-sent 1000 topics per second for two
-  clients that had subscribed (payload ~15 bytes). No topic lost.
+  clients that had subscribed (payload ~15 bytes ESP8266). No topic lost.
   The max I've seen was 2k msg/s (1 client 1 subscription)
 - Act as as a mqtt broker and/or a mqtt client
 - Mqtt 3.1.1 / Qos 0 supported
@@ -48,7 +50,7 @@ After a while one ESP naturally becomes a 'master' and all ESP are connected tog
 No problem if the master dies, a new master will be choosen soon.
 
 ## TODO List
-* Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)
+* ~~Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)~~
 * Implement zeroconf mode (needs async)
 * Add a max_clients in MqttBroker. Used with zeroconf, there will be
 no need for having tons of clients (also RAM is the problem with many clients)

examples/client-with-wifi/client-with-wifi.ino

@@ -3,23 +3,36 @@
 /** 
   * Local broker that accept connections and two local clients
   *
+  * 
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  | 1883 <--- External client/s
+  *  |       +-------->| broker |  | 1883 <--- External client/s
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       |             |       |     -----
+  *  |       v             v       |      ---  
+  *  | +----------+  +----------+  |       -  
+  *  | | internal |  | internal |  +-------*  Wifi
+  *  | | client   |  | client   |  |          
+  *  | +----------+  +----------+  |          
+  *  |                             |
+  *  +-----------------------------+
+  * 
   * pros - Reduces internal latency (when publish is received by the same ESP)
   *      - Reduces wifi traffic
   *      - No need to have an external broker
-	*      - can still report to a 'main' broker (TODO see documentation that have to be written)
+  *      - can still report to a 'main' broker (TODO see documentation that have to be written)
-	*      - accepts external clients
+  *      - accepts external clients
   *
   * cons - Takes more memory
-	*      - a bit hard to understand
+  *      - a bit hard to understand
-	*
+  *
-  * This sounds crazy: a mqtt mqtt that do not need a broker !
-  *  The use case arise when one ESP wants to publish topics and subscribe to them at the same time.
-  *  Without broker, the ESP won't react to its own topics.
-  *  
-  *  TinyMqtt mqtt allows this use case to work.
   */
 
-#include <my_credentials.h>
+const char *ssid     = "";
+const char *password = "";
 
 std::string topic="sensor/temperature";
 
@@ -28,17 +41,20 @@ MqttBroker broker(1883);
 MqttClient mqtt_a(&broker);
 MqttClient mqtt_b(&broker);
 
-void onPublishA(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
+void onPublishA(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << endl << "---------> A Received " << topic.c_str() << endl; }
+{ Serial << "--> client A received " << topic.c_str() << ", " << payload << endl; }
 
-void onPublishB(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
+void onPublishB(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << endl << "---------> B Received " << topic.c_str() << endl; }
+{ Serial << "--> client B Received " << topic.c_str() << ", " << payload << endl; }
 
 void setup()
 {
   Serial.begin(115200);
-	delay(500);
+  delay(500);
-	Serial << "Clients with wifi " << endl;
+  Serial << "Clients with wifi " << endl;
+
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE EDIT THE EXAMPLE AND MODIFY ssid/password *************" << endl;
 
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
@@ -47,8 +63,8 @@ void setup()
 
   Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
 
-	broker.begin();
+  broker.begin();
- 
+
   mqtt_a.setCallback(onPublishA);
   mqtt_a.subscribe(topic);
 
@@ -58,30 +74,31 @@ void setup()
 
 void loop()
 {
-	broker.loop();
+  broker.loop();  // Don't forget to add loop for every broker and clients
 
   mqtt_a.loop();
   mqtt_b.loop();
 
   // ============= client A publish ================
-	static const int intervalA = 5000;  // publishes every 5s
+  static const int intervalA = 5000;  // publishes every 5s (please avoid usage of delay())
-	static uint32_t timerA = millis() + intervalA;
+  static uint32_t timerA = millis() + intervalA;
-	
+
-	if (millis() > timerA)
+  if (millis() > timerA)
-	{
+  {
-		Serial << "A is publishing " << topic.c_str() << endl;
+    Serial << "A is publishing " << topic.c_str() << endl;
-		timerA += intervalA;
+    timerA += intervalA;
-		mqtt_a.publish(topic);
+    mqtt_a.publish(topic, " sent by A");
-	}
+  }
 
   // ============= client B publish ================
-	static const int intervalB = 7000;	// will send topic each 7s
+  static const int intervalB = 7000;	// will send topic each 7s
-	static uint32_t timerB = millis() + intervalB;
+  static uint32_t timerB = millis() + intervalB;
-	
+
-	if (millis() > timerB)
+  if (millis() > timerB)
-	{
+  {
-		Serial << "B is publishing " << topic.c_str() << endl;
+		static int temperature;
-		timerB += intervalB;
+    Serial << "B is publishing " << topic.c_str() << endl;
-		mqtt_b.publish(topic, std::string(String(15+millis()%10).c_str()));
+    timerB += intervalB;
-	}
+    mqtt_b.publish(topic, " sent by B: "+std::string(String(16+temperature++%6).c_str()));
+  }
 }

examples/client-without-wifi/client-without-wifi.ino

@@ -1,12 +1,30 @@
 #include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt
 
 /** TinyMQTT allows a disconnected mode:
- * 
+  * 
- *  In this example, local clients A and B are talking together, no need to be connected.
+  *  +-----------------------------+
- *  A single ESP can use this to be able to comunicate with itself with the power
+  *  | ESP                         |
- *  of MQTT, and once connected still continue to work with others.
+  *  |                 +--------+  |
- *  
+  *  |       +-------->| broker |  |
- */
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       v             v       |
+  *  | +----------+  +----------+  |
+  *  | | internal |  | internal |  |
+  *  | | client   |  | client   |  |          
+  *  | +----------+  +----------+  |          
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  In this example, local clients A and B are talking together, no need to be connected.
+  *
+  *  A single ESP can use this to be able to comunicate with itself with the power
+  *  of MQTT, and once connected still continue to work with others.
+  *
+  *  The broker may still be conected if wifi is on.
+  *
+  */
 
 std::string topic="sensor/temperature";
 
@@ -14,11 +32,11 @@ MqttBroker broker(1883);
 MqttClient mqtt_a(&broker);
 MqttClient mqtt_b(&broker);
 
-void onPublishA(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+void onPublishA(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << "--> A Received " << topic.c_str() << endl; }
+{ Serial << "--> Client A received msg on topic " << topic.c_str() << ", " << payload << endl; }
 
-void onPublishB(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+void onPublishB(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << "--> B Received " << topic.c_str() << endl; }
+{ Serial << "--> Client B received msg on topic " << topic.c_str() << ", " << payload << endl; }
 
 void setup()
 {
@@ -35,7 +53,7 @@ void setup()
 
 void loop()
 {
-	broker.loop();
+	broker.loop();	// Don't forget to call loop() for all brokers and clients
   mqtt_a.loop();
   mqtt_b.loop();
 
@@ -47,7 +65,7 @@ void loop()
 	{
 		Serial << "A is publishing " << topic.c_str() << endl;
 		timerA += intervalA;
-		mqtt_a.publish(topic);
+		mqtt_a.publish(topic, "sent by A");
 	}
 
   // ============= client B publish ================
@@ -58,6 +76,6 @@ void loop()
 	{
 		Serial << "B is publishing " << topic.c_str() << endl;
 		timerB += intervalB;
-		mqtt_b.publish(topic);
+		mqtt_b.publish(topic, "sent by B");
 	}
 }

examples/simple-broker/simple-broker.ino

@@ -1,14 +1,33 @@
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt
 
-#include <my_credentials.h>
-
 #define PORT 1883
 MqttBroker broker(PORT);
 
+/** Basic Mqtt Broker
+  *
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |       +--------+            | 
+  *  |       | broker |            | 1883 <--- External client/s
+  *  |       +--------+            |
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  Your ESP will become a MqttBroker.
+	*  You can test it with any client such as mqtt-spy for example
+	*  
+  */
+
+const char* ssid = "";
+const char* password = "";
+
 void setup() 
 {
   Serial.begin(115200);
 
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
+
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
  

examples/simple-client/simple-client.ino

@@ -1,9 +1,25 @@
-#include <ESP8266WiFi.h>
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt
 
-/** Simple Client
+/** Simple Client (The simplest configuration)
   *
-	* This is the simplest Mqtt client configuration
+  *                             
+  *                   +--------+       
+  *           +------>| broker |<--- <  Other client
+  *           |       +--------+       
+  *           |                               
+  *   +-----------------+
+  *   | ESP   |         |           
+  *   | +----------+    |          
+  *   | | internal |    |              
+  *   | | client   |    |          
+  *   | +----------+    |          
+  *   |                 |
+  *   +-----------------+
+  * 
+	* 1 - change the ssid/password
+	* 2 - change BROKER values (or keep emqx.io test broker)
+	* 3 - you can use mqtt-spy to connect to the same broker and
+	*     see the sensor/temperature updated by the client.
 	*
 	* pro  - small memory footprint (both ram and flash)
 	*      - very simple to setup and use
@@ -13,7 +29,11 @@
 	*      - local publishes takes more time (because they go outside)
 	*/
 
-#include <my_credentials.h>
+const char* BROKER = "broker.emqx.io";
+const uint16_t BROKER_PORT = 1883;
+
+const char* ssid = "";
+const char* password = "";
 
 static float temp=19;
 static MqttClient client;
@@ -22,7 +42,10 @@ void setup()
 {
   Serial.begin(115200);
 	delay(500);
+
 	Serial << "Simple clients with wifi " << endl;
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
 
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
@@ -32,21 +55,33 @@ void setup()
 
   Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  
 
-	client.connect("192.168.1.40", 1883);	// Put here your broker ip / port
+	client.connect(BROKER, BROKER_PORT);	// Put here your broker ip / port
-
 }
 
 void loop()
 {
-	client.loop();
+	client.loop();	// Don't forget to call loop() for each broker and client
 
-	delay(1000);
+	// delay(1000);		please avoid usage of delay (see below how this done using next_send and millis())
+	static auto next_send = millis();
+	
+	if (millis() > next_send)
+	{
+		next_send += 1000;
 
-	auto rnd=random(100);
+		if (not client.connected())
+		{
+			Serial << millis() << ": Not connected to broker" << endl;
+			return;
+		}
 
-	if (rnd > 66) temp += 0.1;
+		auto rnd=random(100);
-	else if (rnd < 33) temp -= 0.1;
 
-	client.publish("sensor/temperature", String(temp));
+		if (rnd > 66) temp += 0.1;
+		else if (rnd < 33) temp -= 0.1;
 
+		Serial << "--> Publishing a new sensor/temperature value: " << temp << endl;
+
+		client.publish("sensor/temperature", String(temp));
+	}
 }

examples/tinymqtt-test/tinymqtt-test.ino

@@ -1,25 +1,32 @@
 #include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
 #include <MqttStreaming.h>
-#include <ESP8266mDNS.h>
+#if defined(ESP8266)
+  #include <ESP8266mDNS.h>
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #include <ESPmDNS.h>
+#else
+  #error Unsupported platform
+#endif
 
 #include <sstream>
 #include <map>
 
-/**
+bool echo_on = true;
-  * Console allowing to make any kind of test.
+
+/** Very complex example
+  * Console allowing to make any kind of test,
+	* even some stress tests.
   *
-  * pros - Reduces internal latency (when publish is received by the same ESP)
+	* Upload the sketch, the use the terminal.
-  *      - Reduces wifi traffic
+	* Press H for mini help.
-  *      - No need to have an external broker
-	*      - can still report to a 'main' broker (TODO see documentation that have to be written)
-	*      - accepts external clients
-  *
-  * cons - Takes more memory
-	*      - a bit hard to understand
 	*
+  * tested with mqtt-spy-0.5.4
+	* TODO examples of scripts
   */
 
-#include <my_credentials.h>
+const char* ssid = "";
+const char* password = "";
 
 std::string topic="sensor/temperature";
 
@@ -44,17 +51,32 @@ void setup()
 	WiFi.persistent(false); // https://github.com/esp8266/Arduino/issues/1054
   Serial.begin(115200);
 	delay(500);
-	Serial << endl << endl << endl
-	<< "Connecting to '" << ssid << "' ";
 
+  Serial << endl << endl;
+  Serial << "***************************************************************" << endl;
+  Serial << "*  Welcome to the TinyMqtt console" << endl;
+  Serial << endl;
+  Serial << "*  The console allows to test all features of the libraries." << endl;
+  Serial << endl;
+  if (strlen(ssid)==0)
+    Serial << "*  WARNING: You may want to modify ssid/password in order" << endl
+		       << "            to reflect your Wifi configuration." << endl;
+  Serial << endl;
+	Serial << "*  Enter help to view the list of commands." << endl;
+  Serial << "***************************************************************" << endl;
+  Serial << endl;
+
+	Serial << "Connecting to '" << ssid << "' ";
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
 
   while (WiFi.status() != WL_CONNECTED)
-	{ Serial << '-'; delay(500); }
+  { Serial << '-'; delay(500); }
 
-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+  Serial << endl << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
-	Serial << "Type help for more..." << endl;
 
   const char* name="tinytest";
   Serial << "Starting MDNS, name= " << name;
@@ -69,27 +91,67 @@ void setup()
 	brokers["broker"] = broker;
 }
 
+std::string getword(std::string& str, const char* if_empty=nullptr, char sep=' ');
+
 int getint(std::string& str, const int if_empty=0)
 {
-	std::string sword;
+	std::string str2=str;
-	while(str.length() && str[0]>='0' && str[0]<='9')
+	std::string sword = getword(str);
+	if (sword[0] and isdigit(sword[0]))
 	{
-		sword += str[0]; str.erase(0,1);
+		int ret=atoi(sword.c_str());
+		while(isdigit(sword[0]) or sword[0]==' ') sword.erase(0,1);
+		if (sword.length()) str = sword+' '+str;
+	  return ret;
 	}
-	while(str[0]==' ') str.erase(0,1);
+	str=str2;
-	if (if_empty and sword.length()==0) return if_empty;
+  return if_empty;
-	return atoi(sword.c_str());
 }
 
-std::string getword(std::string& str, const char* if_empty=nullptr, char sep=' ')
+std::string getword(std::string& str, const char* if_empty/*=nullptr*/, char sep/*=' '*/)
 {
+	char quote=(str[0]=='"' or str[0]=='\'' ? str[0] : 0);
+	if (quote) str.erase(0,1);
 	std::string sword;
-	while(str.length() && str[0]!=sep)
+	while(str.length() and (str[0]!=sep or quote))
 	{
-		sword += str[0]; str.erase(0,1);
+		if (str[0]==quote)
+		{
+			str.erase(0,1);
+			break;
+		}
+		sword += str[0];
+		str.erase(0,1);
 	}
 	while(str[0]==sep) str.erase(0,1);
 	if (if_empty and sword.length()==0) return if_empty;
+	if (quote==false and sword.length()>=4 and sword.substr(0,3)=="rnd")
+	{
+		sword.erase(0,3);
+		if (sword[0]=='(')
+		{
+			int to = 100;
+			sword.erase(0,1);
+			int from=getint(sword);
+			if (sword[0]==',')
+			{
+				sword.erase(0,1);
+				to = getint(sword);
+				if (sword[0]!=')') Serial << "Missing ')'" << endl;
+			}
+			else
+			{
+				to=from;
+				from=0;
+			}
+			return String(random(from,to)).c_str();
+		}
+		else
+		{
+			Serial << "Missing '('" << endl;
+		}
+	}
+	while(str[0]==' ') str.erase(0,1);
 	return sword;
 }
 
@@ -117,7 +179,7 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
 			return addr;
 	}
 	IPAddress local=WiFi.localIP();
-	addr="";
+	addr.clear();
 	while(build.size()!=4)
 	{
 		std::stringstream b;
@@ -138,10 +200,10 @@ std::set<std::string> commands = {
 	"auto", "broker", "blink", "client", "connect",
 	"create", "delete", "help", "interval",
 	"ls", "ip", "off", "on", "set",
-	"publish", "reset", "subscribe", "unsubscribe", "view"
+	"publish", "reset", "subscribe", "unsubscribe", "view", "echo", "every"
 };
 
-void getCommand(std::string& search)
+void convertToCommand(std::string& search)
 {
 	while(search[0]==' ') search.erase(0,1);
 	if (search.length()==0) return;
@@ -161,7 +223,7 @@ void getCommand(std::string& search)
 	else if (count>1)
 	{
 		Serial << "Ambiguous command: " << matches << endl;
-		search="";
+		search.clear();
 	}
 }
 
@@ -177,7 +239,7 @@ void replace(const char* d, std::string& str, std::string srch, std::string to)
 		{
 			str.erase(pos, srch.length());
 			str.insert(pos, to);
-			pos += to.length();
+			pos += to.length()-1;
 		}
 	}
 }
@@ -195,6 +257,7 @@ void replaceVars(std::string& cmd)
 	}
 	cmd.erase(0, cmd.find_first_not_of(" "));
 	cmd.erase(cmd.find_last_not_of(" ")+1);
+
 }
 
 // publish at regular interval
@@ -316,22 +379,457 @@ std::map<MqttClient*, automatic*> automatic::autos;
 
 bool compare(std::string s, const char* cmd)
 {
-	if (s.length()==0 or s.length()>strlen(cmd))  return false;
+	uint8_t p=0;
-	return strncmp(cmd, s.c_str(), s.length())==0;
+	while(s[p++]==*cmd++)
+	{
+		if (*cmd==0 or s[p]==0) return true;
+		if (s[p]==' ') return true;
+	}
+	return false;
 }
 
 using ClientFunction = void(*)(std::string& cmd, MqttClient* publish);
 
+struct Every
+{
+	std::string cmd;
+	uint32_t ms;
+	uint32_t next;
+	uint32_t underrun=0;
+	bool active=true;
+
+	void dump()
+	{
+		Serial << (active ? "enabled  " : "disabled ");
+		auto mill=millis();
+		Serial << ms << "ms [" << cmd << "] next in ";
+		if (mill > next)
+			Serial << "now";
+		else
+			Serial << next-mill << "ms";
+	}
+};
+
 uint32_t blink_ms_on[16];
 uint32_t blink_ms_off[16];
 uint32_t blink_next[16];
 bool blink_state[16];
 int16_t blink;
+
+std::vector<Every> everies;
+
+void eval(std::string& cmd)
+{
+	while(cmd.length())
+	{
+		MqttError retval = MqttOk;
+
+		std::string s;
+		MqttBroker* broker = nullptr;
+		MqttClient* client = nullptr;
+
+		// client.function notation
+		if (cmd.find('.') != std::string::npos &&
+				cmd.find('.') < cmd.find(' '))
+		{
+			s=getword(cmd, nullptr, '.');
+
+			if (s.length())
+			{
+				if (clients.find(s) != clients.end())
+				{
+					client = clients[s];
+				}
+				else if (brokers.find(s) != brokers.end())
+				{
+					broker = brokers[s];
+				}
+				else
+				{
+					Serial << "Unknown class (" << s.c_str() << ")" << endl;
+					cmd.clear();
+				}
+			}
+		}
+
+		s = getword(cmd);
+		if (s.length()) convertToCommand(s);
+		if (s.length()==0)
+		{}
+		else if (compare(s, "delete"))
+		{
+			if (client==nullptr && broker==nullptr)
+			{
+				s = getword(cmd);
+				if (clients.find(s) != clients.end())
+				{
+					client = clients[s];
+				}
+				else if (brokers.find(s) != brokers.end())
+				{
+					broker = brokers[s];
+				}
+				else
+					Serial << "Unable to find (" << s.c_str() << ")" << endl;
+			}
+			if (client)
+			{
+				for (auto it: clients)
+				{
+					if (it.second != client) continue;
+					Serial << "deleted" << endl;
+					delete (it.second);
+					clients.erase(it.first);
+					break;
+				}
+				cmd += " ls";
+			}
+			else if (broker)
+			{
+				for(auto it: brokers)
+				{
+					if (broker != it.second) continue;
+					Serial << "deleted" << endl;
+					delete (it.second);
+					brokers.erase(it.first);
+					break;
+				}
+				cmd += " ls";
+			}
+			else
+				Serial << "Nothing to delete" << endl;
+		}
+		else if (broker)
+		{
+			if (compare(s,"connect"))
+			{
+				Serial << "NYI" << endl;
+			}
+			else if (compare(s, "view"))
+			{
+				broker->dump();
+			}
+			else
+			{
+				Serial << "Unknown broker command (" << s << ")" << endl;
+				s.clear();
+			}
+		}
+		else if (client)
+		{
+			if (compare(s,"connect"))
+			{
+				client->connect(getip(cmd,"192.168.1.40").c_str(), getint(cmd, 1883), getint(cmd, 60));
+				Serial << (client->connected() ? "connected." : "not connected") << endl;
+			}
+			else if (compare(s,"publish"))
+			{
+				retval = client->publish(getword(cmd, topic.c_str()), getword(cmd));
+			}
+			else if (compare(s,"subscribe"))
+			{
+				client->subscribe(getword(cmd, topic.c_str()));
+			}
+			else if (compare(s, "unsubscribe"))
+			{
+				client->unsubscribe(getword(cmd, topic.c_str()));
+			}
+			else if (compare(s, "view"))
+			{
+				client->dump();
+			}
+			else
+			{
+				Serial << "Unknown client command (" << s << ")" << endl;
+				s.clear();
+			}
+		}
+		else if (compare(s, "on"))
+		{
+			uint8_t pin=getint(cmd, 2);
+			pinMode(pin, OUTPUT);
+			digitalWrite(pin, HIGH);
+		}
+		else if (compare(s, "off"))
+		{
+			uint8_t pin=getint(cmd, 2);
+			pinMode(pin, OUTPUT);
+			digitalWrite(pin, LOW);
+		}
+		else if (compare(s, "echo"))
+		{
+			s=getword(cmd);
+			if (s=="on")
+				echo_on = true;
+			else if (s=="off")
+				echo_on = false;
+			else
+			{
+				Serial << s << ' ';
+				while(cmd.length())
+				{
+					Serial << getword(cmd) << ' ';
+				}
+			}
+		}
+		else if (compare(s, "every"))
+		{
+			uint32_t ms = getint(cmd, 0);
+			if (ms)
+			{
+				if (cmd.length())
+				{
+					Every every;
+					every.ms=ms;
+					every.cmd=cmd;
+					every.next=millis()+ms;
+					everies.push_back(every);
+					every.dump();
+					Serial << endl;
+					cmd.clear();
+				}
+			}
+			else if (compare(cmd, "off") or compare(cmd, "on"))
+			{
+				bool active=getword(cmd)=="on";
+				uint8_t ever=getint(cmd, 100);
+				uint8_t count=0;
+				for(auto& every: everies)
+				{
+					if (count==ever or (ever==100))
+					{
+						if (every.active != active)
+						{
+							Serial << "every #" << count << (active ? " on" :" off") << endl;
+							every.active = active;
+							every.underrun = 0;
+						}
+					}
+					count++;
+				}
+			}
+			else if (compare(cmd, "list") or cmd.length()==0)
+			{
+				getword(cmd);
+				Serial << "List of everies (ms=" << millis() << ")" << endl;
+				uint8_t count=0;
+				for(auto& every: everies)
+				{
+					Serial << count << ": ";
+					every.dump();
+					Serial << endl;
+					count++;
+				}
+			}
+			else if (compare(cmd, "remove"))
+			{
+				Serial << "Removing..." << endl;
+				getword(cmd);
+				int8_t every=getint(cmd, -1);
+				if (every==-1 and compare(cmd, "last") and everies.size())
+				{
+					getword(cmd);
+					everies.erase(everies.begin()+everies.size()-1);
+				}
+				else if (every==-1 and compare(cmd, "all"))
+				{
+					getword(cmd);
+					everies.clear();
+				}
+				else if (everies.size() > (uint8_t)every)
+				{
+					everies.erase(everies.begin()+every);
+				}
+				else
+					Serial << "Bad colmmand" << endl;
+			}
+			else
+				Serial << "Bad command" << endl;
+		}
+		else if (compare(s, "blink"))
+		{
+			int8_t blink_nr = getint(cmd, -1);
+			if (blink_nr >= 0)
+			{
+				blink_ms_on[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+				blink_ms_off[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+				pinMode(blink_nr, OUTPUT);
+				blink_next[blink_nr] = millis();
+				Serial << "Blink " << blink_nr << ' ' << (blink_ms_on[blink_nr] ? "on" : "off") << endl;
+				if (blink_ms_on[blink_nr])
+					blink |= 1<< blink_nr;
+				else
+				{
+					blink &= ~(1<< blink_nr);
+				}
+			}
+		}
+		else if (compare(s, "auto"))
+		{
+			automatic::command(client, cmd);
+			if (client == nullptr)
+				cmd.clear();
+		}
+		else if (compare(s, "broker"))
+		{
+			std::string id=getword(cmd);
+			if (id.length() or brokers.find(id)!=brokers.end())
+			{
+				int port=getint(cmd, 0);
+				if (port)
+				{
+					MqttBroker* broker = new MqttBroker(port);
+					broker->begin();
+
+					brokers[id] = broker;
+					Serial << "new broker (" << id.c_str() << ")" << endl;
+				}
+				else
+					Serial << "Missing port" << endl;
+			}
+			else
+				Serial << "Missing or existing broker name (" << id.c_str() << ")" << endl;
+			cmd+=" ls";
+		}
+		else if (compare(s, "client"))
+		{
+			std::string id=getword(cmd);
+			if (id.length() or clients.find(id)!=clients.end())
+			{
+				s=getword(cmd);	// broker name
+				if (s=="" or brokers.find(s) != brokers.end())
+				{
+					MqttBroker* broker = nullptr;
+					if (s.length()) broker = brokers[s];
+					MqttClient* client = new MqttClient(broker);
+					client->id(id);
+					clients[id]=client;
+					client->setCallback(onPublish);
+					client->subscribe(topic);
+					Serial << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
+				}
+				else if (s.length())
+				{
+					Serial << " not found." << endl;
+				}
+			}
+			else
+				Serial << "Missing or existing client name" << endl;
+			cmd+=" ls";
+		}
+		else if (compare(s, "set"))
+		{
+			std::string name(getword(cmd));
+			if (name.length()==0)
+			{
+				for(auto it: vars)
+				{
+					Serial << "  " << it.first << " -> " << it.second << endl;
+				}
+			}
+			else if (commands.find(name) != commands.end())
+			{
+				Serial << "Reserved keyword (" << name << ")" << endl;
+				cmd.clear();
+			}
+			else
+			{
+				if (cmd.length())
+				{
+					vars[name] = cmd;
+					cmd.clear();
+				}
+				else if (vars.find(name) != vars.end())
+					vars.erase(vars.find(name));
+			}
+		}
+		else if (compare(s, "ls") or compare(s, "view"))
+		{
+			Serial << "--< " << clients.size() << " client/s. >--" << endl;
+			for(auto it: clients)
+			{
+				it.second->dump("  ");
+			}
+
+			Serial << "--< " << brokers.size() << " brokers/s. >--" << endl;
+			for(auto it: brokers)
+			{
+				Serial << "  +-- '" << it.first.c_str() << "' " << it.second->clientsCount() << " client/s."<< endl;
+				it.second->dump("     ");
+			}
+		}
+		else if (compare(s, "reset"))
+			ESP.restart();
+		else if (compare(s, "ip"))
+			Serial << "IP: " << WiFi.localIP() << endl;
+		else if (compare(s,"help"))
+		{
+			Serial << "syntax:" << endl;
+			Serial << "  MqttBroker:" << endl;
+			Serial << "    broker {name} {port} : create a new broker" << endl;
+			Serial << endl;
+			Serial << "  MqttClient:" << endl;
+			Serial << "    client {name} {parent broker} : create a client then" << endl;
+			Serial << "      name.connect  [ip] [port] [alive]" << endl;
+			Serial << "      name.[un]subscribe [topic]" << endl;
+			Serial << "      name.publish [topic][payload]" << endl;
+			Serial << "      name.view" << endl;
+			Serial << "      name.delete" << endl;
+
+			automatic::help();
+			Serial << endl;
+			Serial << "    help" << endl;
+			Serial << "    blink [Dx on_ms off_ms]" << endl;
+			Serial << "    ls / ip / reset" << endl;
+			Serial << "    set [name][value]" << endl;
+			Serial << "    !  repeat last command" << endl;
+			Serial << endl;
+			Serial << "  echo [on|off] or strings" << endl;
+			Serial << "  every ms [command]; every list; every remove [nr|all], every (on|off) [#]" << endl;
+			Serial << "  on {output}; off {output}" << endl;
+			Serial << "  $id : name of the client." << endl;
+			Serial << "  rnd[(min[,max])] random number." << endl;
+			Serial << "  default topic is '" << topic.c_str() << "'" << endl;
+			Serial << endl;
+		}
+		else
+		{
+			while(s[0]==' ') s.erase(0,1);
+			if (s.length())
+				Serial << "Unknown command (" << s.c_str() << ")" << endl;
+		}
+
+		if (retval != MqttOk)
+		{
+			Serial << "# MQTT ERROR " << retval << endl;
+		}
+	}
+}
+
 void loop()
 {
 	auto ms=millis();
-	int8_t out=1;
+	int8_t out=0;
 	int16_t blink_bits = blink;
+	uint8_t e=0;
+
+	for(auto& every: everies)
+	{
+		if (not every.active) continue;
+		if (every.ms && every.cmd.length() && ms > every.next)
+		{
+			std::string cmd(every.cmd);
+			eval(cmd);
+			every.next += every.ms;
+			if (ms > every.next and ms > every.underrun)
+			{
+				Serial << "Underrun every #" << e << ", " <<  (ms - every.next) << "ms late" << endl;
+				every.underrun = ms+5000;
+			}
+		}
+		e++;
+	}
+
 	while(blink_bits)
 	{
 		if (blink_ms_on[out] and ms > blink_next[out])
@@ -353,7 +851,9 @@ void loop()
 	}
 
 	static long count;
+  #if defined(ESP9266)
   MDNS.update();
+  #endif
 
 	if (MqttClient::counter != count)
 	{
@@ -372,10 +872,11 @@ void loop()
 	{
 		static std::string cmd;
 		char c=Serial.read();
+		if (echo_on)
+			Serial << c;
 
-		if (c==10 or c==14)
+		if (c==10 or c==13)
 		{
-
 			Serial << "----------------[ " << cmd.c_str() << " ]--------------" << endl;
 			static std::string last_cmd;
 			if (cmd=="!")
@@ -384,277 +885,7 @@ void loop()
 				last_cmd=cmd;
 
 			if (cmd.substr(0,3)!="set") replaceVars(cmd);
-			while(cmd.length())
+			eval(cmd);
-			{
-				MqttError retval = MqttOk;
-
-				std::string s;
-				MqttBroker* broker = nullptr;
-				MqttClient* client = nullptr;
-
-				// client.function notation
-				// ("a.fun " becomes "fun a ")
-				if (cmd.find('.') != std::string::npos &&
-						cmd.find('.') < cmd.find(' '))
-				{
-					s=getword(cmd, nullptr, '.');
-
-					if (s.length())
-					{
-						if (clients.find(s) != clients.end())
-						{
-							client = clients[s];
-						}
-						else if (brokers.find(s) != brokers.end())
-						{
-							broker = brokers[s];
-						}
-						else
-						{
-							Serial << "Unknown class (" << s.c_str() << ")" << endl;
-							cmd="";
-						}
-					}
-				}
-				
-				s = getword(cmd);
-				if (s.length()) getCommand(s);
-				if (s.length()==0)
-				{}
-				else if (compare(s, "delete"))
-				{
-					if (client==nullptr && broker==nullptr)
-					{
-						s = getword(cmd);
-						if (clients.find(s) != clients.end())
-						{
-							client = clients[s];
-						}
-						else if (brokers.find(s) != brokers.end())
-						{
-							broker = brokers[s];
-						}
-						else
-							Serial << "Unable to find (" << s.c_str() << ")" << endl;
-					}
-					if (client)
-					{
-						for (auto it: clients)
-						{
-							if (it.second != client) continue;
-							Serial << "deleted" << endl;
-							delete (it.second);
-							clients.erase(it.first);
-							break;
-						}
-						cmd += " ls";
-					}
-					else if (broker)
-					{
-						for(auto it: brokers)
-						{
-							if (broker != it.second) continue;
-							Serial << "deleted" << endl;
-							delete (it.second);
-							brokers.erase(it.first);
-							break;
-						}
-						cmd += " ls";
-					}
-					else
-						Serial << "Nothing to delete" << endl;
-				}
-				else if (broker)
-				{
-					if (compare(s,"connect"))
-				  {
-						Serial << "NYI" << endl;
-				  }
-					else if (compare(s, "view"))
-					{
-						broker->dump();
-					}
-			  }
-				else if (client)
-				{
-					if (compare(s,"connect"))
-					{
-						client->connect(getip(cmd,"192.168.1.40").c_str(), getint(cmd, 1883), getint(cmd, 60));
-						Serial << (client->connected() ? "connected." : "not connected") << endl;
-					}
-					else if (compare(s,"publish"))
-					{
-						while (cmd[0]==' ') cmd.erase(0,1);
-						retval = client->publish(getword(cmd, topic.c_str()), cmd.c_str(), cmd.length());
-						cmd="";	// remove payload
-					}
-					else if (compare(s,"subscribe"))
-					{
-						client->subscribe(getword(cmd, topic.c_str()));
-					}
-					else if (compare(s, "unsubscribe"))
-					{
-						client->unsubscribe(getword(cmd, topic.c_str()));
-					}
-					else if (compare(s, "view"))
-					{
-						client->dump();
-					}
-				}
-				else if (compare(s, "blink"))
-				{
-					uint8_t blink_nr = getint(cmd, 0);
-					if (blink_nr)
-					{
-						blink_ms_on[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
-						blink_ms_off[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
-						pinMode(blink_nr, OUTPUT);
-						blink_next[blink_nr] = millis();
-						Serial << "Blink " << blink_nr << ' ' << (blink_ms_on[blink_nr] ? "on" : "off") << endl;
-						if (blink_ms_on[blink_nr])
-							blink |= 1<< (blink_nr-1);
-						else
-						{
-							blink &= ~(1<<(blink_nr-1));
-						}
-					}
-				}
-				else if (compare(s, "auto"))
-				{
-					automatic::command(client, cmd);
-					if (client == nullptr)
-						cmd.clear();
-				}
-				else if (compare(s, "broker"))
-				{
-					std::string id=getword(cmd);
-					if (id.length() or brokers.find(id)!=brokers.end())
-					{
-						int port=getint(cmd, 0);
-						if (port)
-						{
-							MqttBroker* broker = new MqttBroker(port);
-							broker->begin();
-
-							brokers[id] = broker;
-							Serial << "new broker (" << id.c_str() << ")" << endl;
-						}
-						else
-							Serial << "Missing port" << endl;
-					}
-					else
-						Serial << "Missing or existing broker name (" << id.c_str() << ")" << endl;
-					cmd+=" ls";
-				}
-				else if (compare(s, "client"))
-				{
-					std::string id=getword(cmd);
-					if (id.length() or clients.find(id)!=clients.end())
-					{
-						s=getword(cmd);	// broker name
-						if (s=="" or brokers.find(s) != brokers.end())
-						{
-							MqttBroker* broker = nullptr;
-							if (s.length()) broker = brokers[s];
-							MqttClient* client = new MqttClient(broker);
-							client->id(id);
-							clients[id]=client;
-							client->setCallback(onPublish);
-							client->subscribe(topic);
-							Serial << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
-						}
-						else if (s.length())
-						{
-							Serial << " not found." << endl;
-						}
-					}
-					else
-						Serial << "Missing or existing client name" << endl;
-					cmd+=" ls";
-				}
-				else if (compare(s, "set"))
-				{
-					std::string name(getword(cmd));
-					if (name.length()==0)
-					{
-						for(auto it: vars)
-						{
-							Serial << "  " << it.first << " -> " << it.second << endl;
-						}
-					}
-					else if (commands.find(name) != commands.end())
-					{
-						Serial << "Reserved keyword (" << name << ")" << endl;
-						cmd.clear();
-					}
-					else
-					{
-						if (cmd.length())
-						{
-							vars[name] = cmd;
-							cmd.clear();
-						}
-						else if (vars.find(name) != vars.end())
-							vars.erase(vars.find(name));
-					}
-				}
-				else if (compare(s, "ls") or compare(s, "view"))
-				{
-					Serial << "--< " << clients.size() << " client/s. >--" << endl;
-					for(auto it: clients)
-					{
-						Serial << "  "; it.second->dump();
-					}
-
-					Serial << "--< " << brokers.size() << " brokers/s. >--" << endl;
-					for(auto it: brokers)
-					{
-						Serial << " ==[ Broker: " << it.first.c_str() << " ]== ";
-						it.second->dump();
-					}
-				}
-				else if (compare(s, "reset"))
-					ESP.restart();
-				else if (compare(s, "ip"))
-					Serial << "IP: " << WiFi.localIP() << endl;
-				else if (compare(s,"help"))
-				{
-					Serial << "syntax:" << endl;
-					Serial << "  MqttBroker:" << endl;
-					Serial << "    broker {name} {port} : create a new broker" << endl;
-					Serial << endl;
-					Serial << "  MqttClient:" << endl;
-					Serial << "    client {name} {parent broker} : create a client then" << endl;
-					Serial << "      name.connect  [ip] [port] [alive]" << endl;
-					Serial << "      name.[un]subscribe [topic]" << endl;
-					Serial << "      name.publish [topic][payload]" << endl;
-					Serial << "      name.view" << endl;
-					Serial << "      name.delete" << endl;
-
-					automatic::help();
-					Serial << endl;
-					Serial << "    help" << endl;
-					Serial << "    blink [Dx on_ms off_ms]" << endl;
-					Serial << "    ls / ip / reset" << endl;
-					Serial << "    set [name][value]" << endl;
-					Serial << "    !  repeat last command" << endl;
-					Serial << endl;
-					Serial << "  $id : name of the client." << endl;
-					Serial << "  default topic is '" << topic.c_str() << "'" << endl;
-					Serial << endl;
-				}
-				else
-				{
-					while(s[0]==' ') s.erase(0,1);
-					if (s.length())
-						Serial << "Unknown command (" << s.c_str() << ")" << endl;
-				}
-
-				if (retval != MqttOk)
-				{
-					Serial << "## ERROR " << retval << endl;
-				}
-			}
 		}
 		else
 		{

library.json

@@ -1,18 +0,0 @@
-{
-    "name": "TinyMqtt",
-    "keywords": "ethernet, mqtt, m2m, iot",
-    "description": "MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages. It does support MQTT 3.1.1 with QOS=0.",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/hsaturn/TinyMqtt.git"
-    },
-    "version": "0.7.3",
-    "exclude": "",
-    "examples": "examples/*/*.ino",
-    "frameworks": "arduino",
-    "platforms": [
-        "atmelavr",
-        "espressif8266",
-        "espressif32"
-    ]
-}

library.properties

@@ -1,9 +1,9 @@
 name=TinyMqtt
-version=0.7.3
+version=0.9.1
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
-paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP. It does support MQTT 3.1.1 with QoS=0.
+paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP 8266 and 32 WROOM. It does support MQTT 3.1.1 with QoS=0.
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*

src/MqttStreaming.h

@@ -38,11 +38,12 @@
   4.  Simple _FMT mechanism ala printf, but without the typeunsafetyness 
       and no internal buffers for replaceable stream printing
 */
+#pragma once
 
 #ifndef ARDUINO_STREAMING
 #define ARDUINO_STREAMING
 
-#if defined(ARDUINO) && ARDUINO >= 100
+#if (defined(ARDUINO) && ARDUINO >= 100) || defined(EPOXY_DUINO)
 #include "Arduino.h"
 #else
 #ifndef STREAMING_CONSOLE
@@ -154,7 +155,7 @@ template<typename T>
 inline Print &operator <<(Print &obj, const _BASED<T> &arg)
 { obj.print(arg.val, arg.base); return obj; }
 
-#if ARDUINO >= 18
+#if ARDUINO >= 18 || defined(EPOXY_DUINO)
 // Specialization for class _FLOAT
 // Thanks to Michael Margolis for suggesting a way
 // to accommodate Arduino 0018's floating point precision

src/StringIndexer.h

@@ -9,121 +9,121 @@
  */
 class StringIndexer
 {
-	class StringCounter
+  class StringCounter
-	{
+  {
-		std::string str;
+    std::string str;
-		uint8_t used=0;
+    uint8_t used=0;
-		friend class StringIndexer;
+    friend class StringIndexer;
 
-		#if EPOXY_DUINO
+    #if EPOXY_DUINO
-		public:
+    public:
-		// Workaround to avoid coredump in Indexer::release
+    // Workaround to avoid coredump in Indexer::release
-		// when destroying a Topic after the deletion of
+    // when destroying a Topic after the deletion of
-		// StringIndexer::strings map (which can occurs only with AUnit,
+    // StringIndexer::strings map (which can occurs only with AUnit,
-		// never in the ESP itself, because ESP never ends)
+    // never in the ESP itself, because ESP never ends)
-		// (I hate static vars)
+    // (I hate static vars)
-		~StringCounter() { used=255; }
+    ~StringCounter() { used=255; }
-		#endif
+    #endif
-	};
+  };
-	public:
+  public:
-		using index_t=uint8_t;
+    using index_t=uint8_t;
 
-		static index_t strToIndex(const char* str, uint8_t len)
+    static index_t strToIndex(const char* str, uint8_t len)
-		{
+    {
-			for(auto it=strings.begin(); it!=strings.end(); it++)
+      for(auto it=strings.begin(); it!=strings.end(); it++)
-			{
+      {
-				if (strncmp(it->second.str.c_str(), str, len)==0)
+        if (strncmp(it->second.str.c_str(), str, len)==0)
-				{
+        {
-					it->second.used++;
+          it->second.used++;
-					return it->first;
+          return it->first;
-				}
+        }
-			}
+      }
-			for(index_t index=1; index; index++)
+      for(index_t index=1; index; index++)
-			{
+      {
-				if (strings.find(index)==strings.end())
+        if (strings.find(index)==strings.end())
-				{
+        {
-					strings[index].str = std::string(str, len);
+          strings[index].str = std::string(str, len);
-					strings[index].used++;
+          strings[index].used++;
-					// Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
+          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
-					return index;
+          return index;
-				}
+        }
-			}
+      }
-			return 0;	// TODO out of indexes
+      return 0;  // TODO out of indexes
-		}
+    }
 
-		static const std::string& str(const index_t& index)
+    static const std::string& str(const index_t& index)
-		{
+    {
-			static std::string dummy;
+      static std::string dummy;
-			const auto& it=strings.find(index);
+      const auto& it=strings.find(index);
-			if (it == strings.end()) return dummy;
+      if (it == strings.end()) return dummy;
-			return it->second.str;
+      return it->second.str;
-		}
+    }
 
-		static void use(const index_t& index)
+    static void use(const index_t& index)
-		{
+    {
-			auto it=strings.find(index);
+      auto it=strings.find(index);
-			if (it != strings.end()) it->second.used++;
+      if (it != strings.end()) it->second.used++;
-		}
+    }
 
-		static void release(const index_t& index)
+    static void release(const index_t& index)
-		{
+    {
-			auto it=strings.find(index);
+      auto it=strings.find(index);
-			if (it != strings.end())
+      if (it != strings.end())
-			{
+      {
-				it->second.used--;
+        it->second.used--;
-				if (it->second.used == 0)
+        if (it->second.used == 0)
-				{
+        {
-					strings.erase(it);
+          strings.erase(it);
-					// Serial << "Removing string(" << it->second.str.c_str() << ") size=" << strings.size() << endl;
+          // Serial << "Removing string(" << it->second.str.c_str() << ") size=" << strings.size() << endl;
-				}
+        }
-			}
+      }
-		}
+    }
 
-		static uint16_t count() { return strings.size(); }
+    static uint16_t count() { return strings.size(); }
 
-	private:
+  private:
-		static std::map<index_t, StringCounter> strings;
+    static std::map<index_t, StringCounter> strings;
 };
 
 class IndexedString
 {
-	public:
+  public:
-		IndexedString(const IndexedString& source)
+    IndexedString(const IndexedString& source)
-		{
+    {
-			StringIndexer::use(source.index);
+      StringIndexer::use(source.index);
-			index = source.index;
+      index = source.index;
-		}
+    }
 
-		IndexedString(const char* str, uint8_t len)
+    IndexedString(const char* str, uint8_t len)
-		{
+    {
-			index=StringIndexer::strToIndex(str, len);
+      index=StringIndexer::strToIndex(str, len);
-		}
+    }
 
-		IndexedString(const std::string& str) : IndexedString(str.c_str(), str.length()) {};
+    IndexedString(const std::string& str) : IndexedString(str.c_str(), str.length()) {};
 
-		~IndexedString() { StringIndexer::release(index); }
+    ~IndexedString() { StringIndexer::release(index); }
 
-		IndexedString& operator=(const IndexedString& source)
+    IndexedString& operator=(const IndexedString& source)
-		{
+    {
-			StringIndexer::use(source.index);
+      StringIndexer::use(source.index);
-			index = source.index;
+      index = source.index;
-			return *this;
+      return *this;
-		}
+    }
 
-		friend bool operator<(const IndexedString& i1, const IndexedString& i2)
+    friend bool operator<(const IndexedString& i1, const IndexedString& i2)
-		{
+    {
-			return i1.index < i2.index;
+      return i1.index < i2.index;
-		}
+    }
 
-		friend bool operator==(const IndexedString& i1, const IndexedString& i2)
+    friend bool operator==(const IndexedString& i1, const IndexedString& i2)
-		{
+    {
-			return i1.index == i2.index;
+      return i1.index == i2.index;
-		}
+    }
 
-		const std::string& str() const { return StringIndexer::str(index); }
+    const std::string& str() const { return StringIndexer::str(index); }
 
-		const StringIndexer::index_t& getIndex() const { return index; }
+    const StringIndexer::index_t& getIndex() const { return index; }
 
-	private:
+  private:
-		StringIndexer::index_t index;
+    StringIndexer::index_t index;
 };

src/TinyMqtt.h

@@ -1,6 +1,33 @@
 #pragma once
-#include <ESP8266WiFi.h>
+
-#include <ESPAsyncTCP.h>
+// TODO Should add a AUnit with both TCP_ASYNC and not TCP_ASYNC
+// #define TCP_ASYNC  // Uncomment this to use ESPAsyncTCP instead of normal cnx
+
+#if defined(ESP8266) || defined(EPOXY_DUINO)
+  #ifdef TCP_ASYNC
+    #include <ESPAsyncTCP.h>
+  #else
+    #include <ESP8266WiFi.h>
+  #endif
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #ifdef TCP_ASYNC
+    #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
+  #endif
+#endif
+#ifdef EPOXY_DUINO
+  #define dbg_ptr uint64_t
+#else
+  #define dbg_ptr uint32_t
+#endif
+
+#ifdef WIO_TERMINAL
+  // Uncommon board handling
+  // If you have a problem with this line, just remove it.
+  // Note: https://github.com/hsaturn/TinyMqtt/issues/41
+  #include <rpcWiFi.h>
+#endif
+
 #include <vector>
 #include <set>
 #include <string>
@@ -10,265 +37,294 @@
 // #define TINY_MQTT_DEBUG
 
 #ifdef TINY_MQTT_DEBUG
-  #define debug(what) { Serial << __LINE__ << ' ' << what << endl; delay(100); }
+  #define debug(what) { Serial << (int)__LINE__ << ' ' << what << endl; delay(100); }
 #else
   #define debug(what) {}
 #endif
 
-enum MqttError
+#ifdef TCP_ASYNC
+  using TcpClient = AsyncClient;
+  using TcpServer = AsyncServer;
+#else
+  using TcpClient = WiFiClient;
+  using TcpServer = WiFiServer;
+#endif
+
+enum __attribute__((packed)) MqttError
 {
-	MqttOk = 0,
+  MqttOk = 0,
-	MqttNowhereToSend=1,
+  MqttNowhereToSend=1,
-	MqttInvalidMessage=2,
+  MqttInvalidMessage=2,
 };
 
 class Topic : public IndexedString
 {
-	public:
+  public:
-		Topic(const char* s, uint8_t len) : IndexedString(s,len){}
+    Topic(const char* s, uint8_t len) : IndexedString(s,len){}
-		Topic(const char* s) : Topic(s, strlen(s)) {}
+    Topic(const char* s) : Topic(s, strlen(s)) {}
-		Topic(const std::string s) : Topic(s.c_str(), s.length()){};
+    Topic(const std::string s) : Topic(s.c_str(), s.length()){};
 
-		const char* c_str() const { return str().c_str(); }
+    const char* c_str() const { return str().c_str(); }
 
-		bool matches(const Topic&) const;
+    bool matches(const Topic&) const;
 };
 
 class MqttClient;
 class MqttMessage
 {
-	const uint16_t MaxBufferLength = 255;
+  const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
-	public:
+  public:
-		enum Type
+    enum __attribute__((packed)) Type
-		{
+    {
-			Unknown     =    0,
+      Unknown     =    0,
-			Connect     = 0x10,
+      Connect     = 0x10,
-			ConnAck     = 0x20,
+      ConnAck     = 0x20,
-			Publish     = 0x30,
+      Publish     = 0x30,
-			PubAck      = 0x40,
+      PubAck      = 0x40,
-			Subscribe   = 0x80,
+      Subscribe   = 0x80,
-			SubAck      = 0x90,
+      SubAck      = 0x90,
-			UnSubscribe = 0xA0,
+      UnSubscribe = 0xA0,
-			PingReq     = 0xC0,
+      UnSuback    = 0xB0,
-			PingResp    = 0xD0,
+      PingReq     = 0xC0,
-			Disconnect  = 0xE0
+      PingResp    = 0xD0,
-		};
+      Disconnect  = 0xE0
-		enum State
+    };
-		{
+    enum __attribute__((packed)) State
-			FixedHeader=0,
+    {
-			Length=1,
+      FixedHeader=0,
-			VariableHeader=2,
+      Length=1,
-			PayLoad=3,
+      VariableHeader=2,
-			Complete=4,
+      PayLoad=3,
-			Error=5,
+      Complete=4,
-			Create=6
+      Error=5,
-		};
+      Create=6
+    };
 
-		MqttMessage() { reset(); }
+    MqttMessage() { reset(); }
-		MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
+    MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
-		void incoming(char byte);
+    void incoming(char byte);
-		void add(char byte) { incoming(byte); }
+    void add(char byte) { incoming(byte); }
-		void add(const char* p, size_t len, bool addLength=true );
+    void add(const char* p, size_t len, bool addLength=true );
-		void add(const std::string& s) { add(s.c_str(), s.length()); }
+    void add(const std::string& s) { add(s.c_str(), s.length()); }
-		void add(const Topic& t) { add(t.str()); }
+    void add(const Topic& t) { add(t.str()); }
-		const char* end() const { return &buffer[0]+buffer.size(); }
+    const char* end() const { return &buffer[0]+buffer.size(); }
-		const char* getVHeader() const { return &buffer[vheader]; }
+    const char* getVHeader() const { return &buffer[vheader]; }
-		uint16_t length() const { return buffer.size(); }
+    void complete() { encodeLength(); }
-		void complete();
 
-		void reset();
+    void reset();
 
-		// buff is MSB/LSB/STRING
+    // buff is MSB/LSB/STRING
-		// output buff+=2, len=length(str)
+    // output buff+=2, len=length(str)
-		static void getString(const char* &buff, uint16_t& len);
+    static void getString(const char* &buff, uint16_t& len);
 
-		Type type() const
+    Type type() const
-		{
+    {
-			return state == Complete ? static_cast<Type>(buffer[0]) : Unknown;
+      return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
-		}
+    }
 
-		void create(Type type)
+    uint8_t flags() const { return static_cast<uint8_t>(buffer[0] & 0x0F); }
-		{
-			buffer=(char)type;
-			buffer+='\0';		// reserved for msg length
-			vheader=2;
-			size=0;
-			state=Create;
-		}
-		MqttError sendTo(MqttClient*) const;
-		void hexdump(const char* prefix=nullptr) const;
 
-	private:
+    void create(Type type)
-		void encodeLength(char* msb, int length) const;
+    {
+      buffer=(decltype(buffer)::value_type)type;
+      buffer+='\0';    // reserved for msg length byte 1/2
+      buffer+='\0';    // reserved for msg length byte 2/2 (fixed)
+      vheader=3;      // Should never change
+      size=0;
+      state=Create;
+    }
+    MqttError sendTo(MqttClient*);
+    void hexdump(const char* prefix=nullptr) const;
 
-		mutable std::string buffer;	// mutable -> sendTo()
+  private:
-		uint8_t vheader;
+    void encodeLength();
-		uint16_t size;	// bytes left to receive
+
-		State state;
+    std::string buffer;
+    uint8_t vheader;
+    uint16_t size;  // bytes left to receive
+    State state;
 };
 
 class MqttBroker;
 class MqttClient
 {
-	using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
+  using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
-	enum Flags
+  enum __attribute__((packed)) Flags
-	{
+  {
-		FlagUserName = 128,
+    FlagUserName = 128,
-		FlagPassword = 64,
+    FlagPassword = 64,
-		FlagWillRetain = 32,	// unsupported
+    FlagWillRetain = 32,  // unsupported
-		FlagWillQos = 16 | 8, // unsupported
+    FlagWillQos = 16 | 8, // unsupported
-		FlagWill = 4,			    // unsupported
+    FlagWill = 4,          // unsupported
-		FlagCleanSession = 2,	// unsupported
+    FlagCleanSession = 2,  // unsupported
-		FlagReserved = 1
+    FlagReserved = 1
-	};
+  };
-	public:
+  public:
-	  /** Constructor. If broker is not null, this is the adress of a local broker.
+    /** Constructor. If broker is not null, this is the adress of a local broker.
-		    If you want to connect elsewhere, leave broker null and use connect() **/
+        If you want to connect elsewhere, leave broker null and use connect() **/
-		MqttClient(MqttBroker* broker = nullptr, const std::string& id="");
+    MqttClient(MqttBroker* broker = nullptr, const std::string& id="");
-		MqttClient(const std::string& id) : MqttClient(nullptr, id){}
+    MqttClient(const std::string& id) : MqttClient(nullptr, id){}
 
-		~MqttClient();
+    ~MqttClient();
 
-		void connect(MqttBroker* parent);
+    void connect(MqttBroker* parent);
-		void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);
+    void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);
 
-		bool connected() { return
+    // TODO it seems that connected returns true in tcp mode even if
-			(parent!=nullptr and client==nullptr) or
+    // no negociation occured (only if tcp link is established)
-			(client and client->connected()); }
+    bool connected() { return
-		void write(const char* buf, size_t length)
+      (parent!=nullptr and client==nullptr) or
-		{ if (client) client->write(buf, length); }
+      (client and client->connected()); }
+    void write(const char* buf, size_t length)
+    { if (client) client->write(buf, length); }
 
-		const std::string& id() const { return clientId; }
+    const std::string& id() const { return clientId; }
-		void id(std::string& new_id) { clientId = new_id; }
+    void id(std::string& new_id) { clientId = new_id; }
 
-		/** Should be called in main loop() */
+    /** Should be called in main loop() */
-		void loop();
+    void loop();
-		void close(bool bSendDisconnect=true);
+    void close(bool bSendDisconnect=true);
-		void setCallback(CallBack fun) {callback=fun; };
+    void setCallback(CallBack fun)
+    {
+      callback=fun;
+      #ifdef TINY_MQTT_DEBUG
+        Serial << "Callback set to " << (long)fun << endl;
+        if (callback) callback(this, "test/topic", "value", 5);
+      #endif
+    };
 
-		// Publish from client to the world
+    // Publish from client to the world
-		MqttError publish(const Topic&, const char* payload, size_t pay_length);
+    MqttError publish(const Topic&, const char* payload, size_t pay_length);
-		MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
+    MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
-		MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
+    MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
-		MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};
+    MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
+    MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};
 
-		MqttError subscribe(Topic topic, uint8_t qos=0);
+    MqttError subscribe(Topic topic, uint8_t qos=0);
-		MqttError unsubscribe(Topic topic);
+    MqttError unsubscribe(Topic topic);
-		bool isSubscribedTo(const Topic& topic) const;
+    bool isSubscribedTo(const Topic& topic) const;
 
-		// connected to local broker
+    // connected to local broker
-		// TODO seems to be useless
+    // TODO seems to be useless
-		bool isLocal() const { return client == nullptr; }
+    bool isLocal() const { return client == nullptr; }
 
-		void dump()
+    void dump(std::string indent="")
-		{
+    {
-			uint32_t ms=millis();
+      (void)indent;
-			Serial << "MqttClient (" << clientId.c_str() << ") " << (connected() ? " ON " : " OFF");
+      #ifdef TINY_MQTT_DEBUG
-			Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive;
+        uint32_t ms=millis();
-			Serial << (client && client->connected() ? "" : "dis") << "connected";
+        Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
-            message.hexdump("entrant msg");
+        Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
-			bool c=false;
+        Serial << (client && client->connected() ? "" : "dis") << "connected";
-			Serial << " [";
+        if (subscriptions.size())
-			for(auto s: subscriptions)
+        {
-			{
+          bool c = false;
-				Serial << (c?", ": "")<< s.str().c_str();
+          Serial << " [";
-				c=true;
+          for(auto s: subscriptions)
-			}
+            (void)indent;
+          {
+            if (c) Serial << ", ";
+            Serial << s.str().c_str();
+            c=true;
+          }
+          Serial << ']';
+        }
+        Serial << endl;
+      #endif
+    }
 
-			
+#ifdef EPOXY_DUINO
-			Serial << "]" << endl;
+    static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
-		}
+#endif
 
-		/** Count the number of messages that have been sent **/
+  private:
-		static long counter;
 
-	private:
+    // event when tcp/ip link established (real or fake)
-		static void onData(void* client_ptr, AsyncClient*, void* data, size_t len);
+    static void onConnect(void * client_ptr, TcpClient*);
-		MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);
+#ifdef TCP_ASYNC
-		void resubscribe();
+    static void onData(void* client_ptr, TcpClient*, void* data, size_t len);
+#endif
+    MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);
+    void resubscribe();
 
-		friend class MqttBroker;
+    friend class MqttBroker;
-		MqttClient(MqttBroker* parent, AsyncClient* client);
+    MqttClient(MqttBroker* parent, TcpClient* client);
-		// republish a received publish if topic matches any in subscriptions
+    // republish a received publish if topic matches any in subscriptions
-		MqttError publishIfSubscribed(const Topic& topic, const MqttMessage& msg);
+    MqttError publishIfSubscribed(const Topic& topic, MqttMessage& msg);
 
-		void clientAlive(uint32_t more_seconds);
+    void clientAlive(uint32_t more_seconds);
-		void processMessage(const MqttMessage* message);
+    void processMessage(MqttMessage* message);
 
-		bool mqtt_connected = false;
+    bool mqtt_connected = false;
-		char mqtt_flags;
+    char mqtt_flags;
-		uint32_t keep_alive = 60;
+    uint32_t keep_alive = 60;
-		uint32_t alive;
+    uint32_t alive;
-		MqttMessage message;
+    MqttMessage message;
 
-		// TODO	having a pointer on MqttBroker may produce larger binaries
+    // TODO  having a pointer on MqttBroker may produce larger binaries
-		// due to unecessary function linked if ever parent is not used
+    // due to unecessary function linked if ever parent is not used
-		// (this is the case when MqttBroker isn't used except here)
+    // (this is the case when MqttBroker isn't used except here)
-		MqttBroker* parent=nullptr;		// connection to local broker
+    MqttBroker* parent=nullptr;    // connection to local broker
 
-		AsyncClient* client=nullptr;		// connection to mqtt client or to remote broker
+    TcpClient* client=nullptr;    // connection to remote broker
-		std::set<Topic>	subscriptions;
+    std::set<Topic>  subscriptions;
-		std::string clientId;
+    std::string clientId;
-		CallBack callback = nullptr;
+    CallBack callback = nullptr;
 };
 
 class MqttBroker
 {
-	enum State
+  enum __attribute__((packed)) State
-	{
+  {
-		Disconnected,	// Also the initial state
+    Disconnected,  // Also the initial state
-		Connecting,		// connect and sends a fake publish to avoid circular cnx
+    Connecting,    // connect and sends a fake publish to avoid circular cnx
-		Connected,		// this->broker is connected and circular cnx avoided
+    Connected,    // this->broker is connected and circular cnx avoided
-	};
+  };
-	public:
+  public:
-	  // TODO limit max number of clients
+    // TODO limit max number of clients
-		MqttBroker(uint16_t port);
+    MqttBroker(uint16_t port);
-		~MqttBroker();
+    ~MqttBroker();
 
-		void begin() { server->begin(); }
+    void begin() { server->begin(); }
-		void loop();
+    void loop();
 
-		void connect(const std::string& host, uint16_t port=1883);
+    void connect(const std::string& host, uint16_t port=1883);
-		bool connected() const { return state == Connected; }
+    bool connected() const { return state == Connected; }
 
-		size_t clientsCount() const { return clients.size(); }
+    size_t clientsCount() const { return clients.size(); }
 
-		void dump()
+    void dump(std::string indent="")
-		{
+    {
-			Serial << clients.size() << " client/s" << endl;
+      for(auto client: clients)
-			for(auto client: clients)
+        client->dump(indent);
-			{
+    }
-				Serial << "  ";
-				client->dump();
-			}
-		}
 
-	private:
+  private:
-		friend class MqttClient;
+    friend class MqttClient;
 
-		static void onClient(void*, AsyncClient*);
+    static void onClient(void*, TcpClient*);
-		bool checkUser(const char* user, uint8_t len) const
+    bool checkUser(const char* user, uint8_t len) const
-		{ return compareString(auth_user, user, len); }
+    { return compareString(auth_user, user, len); }
 
-		bool checkPassword(const char* password, uint8_t len) const
+    bool checkPassword(const char* password, uint8_t len) const
-		{ return compareString(auth_password, password, len); }
+    { return compareString(auth_password, password, len); }
 
 
-		MqttError publish(const MqttClient* source, const Topic& topic, const MqttMessage& msg) const;
+    MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const;
 
-		MqttError subscribe(const Topic& topic, uint8_t qos);
+    MqttError subscribe(const Topic& topic, uint8_t qos);
 
-		// For clients that are added not by the broker itself
+    // For clients that are added not by the broker itself
-		void addClient(MqttClient* client);
+    void addClient(MqttClient* client);
-		void removeClient(MqttClient* client);
+    void removeClient(MqttClient* client);
 
-		bool compareString(const char* good, const char* str, uint8_t str_len) const;
+    bool compareString(const char* good, const char* str, uint8_t str_len) const;
-		std::vector<MqttClient*>	clients;
+    std::vector<MqttClient*>  clients;
-		AsyncServer* server;
+    TcpServer* server;
 
-		const char* auth_user = "guest";
+    const char* auth_user = "guest";
-		const char* auth_password = "guest";
+    const char* auth_password = "guest";
-		State state = Disconnected;
+    State state = Disconnected;
 
-		MqttClient* broker = nullptr;
+    MqttClient* broker = nullptr;
 };

tests/howto

@@ -0,0 +1,7 @@
+cd TinyMqtt/tests/../..
+git clone https://github.com/hsaturn/EspMock.git
+git clone https://github.com/bxparks/AUnit.git
+git clone https://github.com/bxparks/EpoxyDuino.git
+cd TinyMqtt/tests
+make
+make runtests

tests/length-tests.todo/Makefile

@@ -0,0 +1,8 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+APP_NAME := length-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/length-tests.todo/length-tests.ino

@@ -0,0 +1,53 @@
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+	* TinyMqtt local unit tests.
+	*
+	* Clients are connected to pseudo remote broker
+	* The remote should be 127.0.0.1:1883 <--- But this does not work due to Esp network limitations
+	* We are using 127.0.0.1 because this is simpler to test with a single ESP
+	* Also, this will allow to mock and thus run Action on github
+	**/
+
+using namespace std;
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+
+const char* lastPayload;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+  lastPayload = payload;
+	lastLength = length;
+}
+
+test(length_decode_greater_than_127)
+{
+  // TODO WRITE THIS TEST
+  // The test should verify than a mqtt message with more than 127 bytes is correctly decoded
+	assertEqual(1,2);
+}
+
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}

tests/local-tests/Makefile

@@ -1,7 +1,13 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
 APP_NAME := local-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
-ESP_LIBS = ESP8266WiFi ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
-include ../../../EspMock/EspMock.mk
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/local-tests/local-tests.ino

@@ -1,3 +1,4 @@
+#include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
 #include <map>
@@ -30,12 +31,10 @@ void onPublish(const MqttClient* srce, const Topic& topic, const char* payload,
 
 test(local_client_should_unregister_when_destroyed)
 {
-return;
 	assertEqual(broker.clientsCount(), (size_t)0);
 	{
-		MqttClient client;
 		assertEqual(broker.clientsCount(), (size_t)0);	// Ensure client is not yet connected
-		client.connect("127.0.0.1", 1883);
+		MqttClient client(&broker);
 		assertEqual(broker.clientsCount(), (size_t)1);	// Ensure client is now connected
 	}
 	assertEqual(broker.clientsCount(), (size_t)0);
@@ -67,8 +66,8 @@ test(local_publish_should_be_dispatched)
 	publisher.publish("a/c");
 
 	assertEqual(published.size(), (size_t)1);	// 1 client has received something
-	assertTrue(published[""]["a/b"] == 1);
+	assertEqual(published[""]["a/b"], 1);
-	assertTrue(published[""]["a/c"] == 2);
+	assertEqual(published[""]["a/c"], 2);
 }
 
 test(local_publish_should_be_dispatched_to_local_clients)
@@ -90,10 +89,10 @@ test(local_publish_should_be_dispatched_to_local_clients)
 	publisher.publish("a/c");
 
 	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
-	assertTrue(published["A"]["a/b"] == 1);
+	assertEqual(published["A"]["a/b"], 1);
-	assertTrue(published["A"]["a/c"] == 1);
+	assertEqual(published["A"]["a/c"], 1);
-	assertTrue(published["B"]["a/b"] == 1);
+	assertEqual(published["B"]["a/b"], 1);
-	assertTrue(published["B"]["a/c"] == 0);
+	assertEqual(published["B"]["a/c"], 0);
 }
 
 test(local_unsubscribe)
@@ -113,7 +112,7 @@ test(local_unsubscribe)
 	publisher.publish("a/b");
 	publisher.publish("a/b");
 
-	assertTrue(published[""]["a/b"] == 1);	// Only one publish has been received
+	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
 }
 
 test(local_nocallback_when_destroyed)
@@ -142,7 +141,7 @@ void setup() {
 	Serial.begin(115200);
 	while(!Serial);
 
-	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+	Serial.println("=============[ LOCAL TinyMqtt TESTS              ]========================");
 }
 
 void loop() {

tests/network-tests/Makefile

@@ -0,0 +1,13 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := network-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/network-tests/network-tests.ino

@@ -0,0 +1,429 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+/**
+  * TinyMqtt network unit tests.
+	*
+	* No wifi connection unit tests.
+  * Checks with a local broker. Clients must connect to the local broker
+	**/
+
+// if ascii_pos = 0, no ascii dump, else ascii dump starts after column ascii_pos
+std::string bufferToHexa(const uint8_t* buffer, size_t length, char sep = 0, size_t ascii_pos = 0)
+{
+  std::stringstream out;
+  std::string ascii;
+  std::string h("0123456789ABCDEF");
+  for(size_t i=0; i<length; i++)
+  {
+    uint8_t c = buffer[i];
+    out << h[ c >> 4] << h[ c & 0x0F ];
+    if (sep) out << sep;
+    if (ascii_pos)
+    {
+      if (c>=32)
+        ascii += c;
+      else
+        ascii +='.';
+    }
+  }
+  std::string ret(out.str());
+  if (ascii_pos)
+  {
+    while(ret.length() < ascii_pos)
+      ret += ' ';
+    ret +='[' + ascii + ']';
+  }
+  return ret;
+}
+
+void dumpMqttMessage(const uint8_t* buffer, size_t length)
+{
+  std::map<int, std::string> pkt =
+  { { MqttMessage::Unknown     , "Unknown     " },
+    { MqttMessage::Connect     , "Connect     " },
+    { MqttMessage::ConnAck     , "ConnAck     " },
+    { MqttMessage::Publish     , "Publish     " },
+    { MqttMessage::PubAck      , "PubAck      " },
+    { MqttMessage::Subscribe   , "Subscribe   " },
+    { MqttMessage::SubAck      , "SubAck      " },
+    { MqttMessage::UnSubscribe , "Unsubscribe " },
+    { MqttMessage::UnSuback    , "UnSubAck    " },
+    { MqttMessage::PingReq     , "PingReq     " },
+    { MqttMessage::PingResp    , "PingResp    " },
+    { MqttMessage::Disconnect  , "Disconnect  " } };
+
+  std::cout << "       |   data sent " << std::setw(3) << length << " : ";
+  auto it = pkt.find(buffer[0] & 0xF0);
+  if (it == pkt.end())
+    std::cout << pkt[MqttMessage::Unknown];
+  else
+    std::cout << it->second;
+
+  std::cout << bufferToHexa(buffer, length, ' ', 60) << std::endl;
+}
+
+String toString(const IPAddress& ip)
+{
+  return String(ip[0])+'.'+String(ip[1])+'.'+String(ip[2])+'.'+String(ip[3]);
+}
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+
+char* lastPayload = nullptr;
+size_t lastLength;
+
+void start_servers(int n, bool early_accept = true)
+{
+    ESP8266WiFiClass::resetInstances();
+    ESP8266WiFiClass::earlyAccept = early_accept;
+    while(n)
+    {
+      ESP8266WiFiClass::selectInstance(n--);
+      WiFi.mode(WIFI_STA);
+      WiFi.begin("fake_ssid", "fake_pwd");
+    }
+}
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+	
+	if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
+	lastLength = length;
+}
+
+test(network_single_broker_begin)
+{
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+
+  // TODO Nothing is tested here !
+}
+
+test(suback)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+test(network_client_to_broker_connexion)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+}
+
+test(network_one_client_one_broker_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", "ab");
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+  
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((int)lastLength, (int)2); // sizeof(ab)
+}
+
+test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  std::string sent;
+
+  for(int i=0; i<200; i++)
+    sent += char('0'+i%10);
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", sent.c_str());
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((unsigned int)lastLength, (unsigned int)sent.size());
+}
+
+test(network_client_should_unregister_when_destroyed)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+	{
+		MqttClient client(&broker);
+		assertEqual(broker.clientsCount(), (size_t)1);
+	}
+	assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+
+// THESE TESTS ARE IN LOCAL MODE
+// WE HAVE TO CONVERT THEM TO WIFI MODE (pass through virtual TCP link)
+
+test(network_connect)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient client(&broker);
+	assertTrue(client.connected());
+	assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(network_publish_should_be_dispatched)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.subscribe("a/b");
+	subscriber.subscribe("a/c");
+	subscriber.setCallback(onPublish);
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");
+	publisher.publish("a/c");
+	publisher.publish("a/c");
+
+	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+	assertEqual(published[""]["a/b"], 1);
+	assertEqual(published[""]["a/c"], 2);
+}
+
+test(network_publish_should_be_dispatched_to_clients)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber_a(&broker, "A");
+	subscriber_a.setCallback(onPublish);
+	subscriber_a.subscribe("a/b");
+	subscriber_a.subscribe("a/c");
+
+	MqttClient subscriber_b(&broker, "B");
+	subscriber_b.setCallback(onPublish);
+	subscriber_b.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// A and B should receive this
+	publisher.publish("a/c");		// A should receive this 
+
+	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+	assertEqual(published["A"]["a/b"], 1);
+	assertEqual(published["A"]["a/c"], 1);
+	assertEqual(published["B"]["a/b"], 1);
+	assertEqual(published["B"]["a/c"], 0);
+}
+
+test(network_unsubscribe)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// This publish is received
+
+	subscriber.unsubscribe("a/b");
+
+	publisher.publish("a/b");		// Those one, no (unsubscribed)
+	publisher.publish("a/b");
+
+	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+}
+
+test(network_nocallback_when_destroyed)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient publisher(&broker);
+
+	{
+		MqttClient subscriber(&broker);
+		subscriber.setCallback(onPublish);
+		subscriber.subscribe("a/b");
+		publisher.publish("a/b");
+	}
+
+	publisher.publish("a/b");
+
+	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+}
+
+test(network_small_payload)
+{
+	published.clear();
+
+	const char* payload="abcd";
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload, strlen(payload));		// This publish is received
+
+  // coming from MqttClient::publish(...)
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, (size_t)4);
+}
+
+test(network_hudge_payload)
+{
+  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");          // Note -> this does not send any byte .... (nowhere to send)
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload);		// This publish is received
+
+  // onPublish should have filled lastPayload and lastLength
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, strlen(payload));
+	assertEqual(strcmp(payload, lastPayload), 0);
+}
+
+test(connack)
+{
+  const bool view = false;
+
+  NetworkObserver check(
+    [this](const WiFiClient*, const uint8_t* buffer, size_t length)
+    {
+      if (view) dumpMqttMessage(buffer, length);
+      if (buffer[0] == MqttMessage::ConnAck)
+      {
+        std::string hex = bufferToHexa(buffer, length);
+        assertStringCaseEqual(hex.c_str(), "20020000");
+      }
+    }
+  );
+
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	/* delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+	*/
+
+	Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+
+	WiFi.mode(WIFI_STA);
+	WiFi.begin("network", "password");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}

tests/nowifi-tests/Makefile

@@ -1,7 +1,13 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
 APP_NAME := nowifi-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
-ESP_LIBS = ESP8266WiFi ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
-include ../../../EspMock/EspMock.mk
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/nowifi-tests/nowifi-tests.ino

@@ -1,3 +1,4 @@
+#include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
 #include <map>
@@ -131,7 +132,7 @@ test(nowifi_nocallback_when_destroyed)
 	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
 }
 
-test(nowifi_payload_nullptr)
+test(nowifi_small_payload)
 {
 	published.clear();
 
@@ -149,6 +150,22 @@ test(nowifi_payload_nullptr)
 	assertEqual(lastLength, (size_t)4);
 }
 
+test(nowifi_hudge_payload)
+{
+  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload);		// This publish is received
+
+  // onPublish should have filled lastPayload and lastLength
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, strlen(payload));
+}
+
 //----------------------------------------------------------------------------
 // setup() and loop()
 void setup() {

tests/string-indexer-tests/Makefile

@@ -2,6 +2,7 @@
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
 APP_NAME := string-indexer-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
-ESP_LIBS = ESP8266WiFi ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
-include ../../../EspMock/EspMock.mk
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/string-indexer-tests/string-indexer-tests.ino

@@ -1,3 +1,4 @@
+#include <Arduino.h>
 #include <AUnit.h>
 #include <StringIndexer.h>
 #include <map>
@@ -105,5 +106,5 @@ void setup() {
 void loop() {
 	aunit::TestRunner::run();
 
-	if (Serial.available()) ESP.reset();
+	// if (Serial.available()) ESP.reset();
 }