Merge branch 'issue_2_broken_large_payloads' into main

Fix unit tests for EpoxyDuino

.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"

.gitignore

@@ -1,5 +0,0 @@
-*~
-src/my_credentials.h
-*.o
-*.swp
-*.out

README.md

@@ -1,17 +1,19 @@
 # TinyMqtt
 
-![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)
-![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)
-![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)
-![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)
-![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)
+[![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/releases)
+[![AUnit Tests](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml)
+[![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/issues)
+[![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
+[![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
-  clients that had subscribed (payload ~15 bytes). No topic lost.
+- Very fast broker I saw it re-sent 1000 topics per second for two
+  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
@@ -21,32 +23,16 @@ ESP 8266 is a small, fast and capable Mqtt Broker and Client
 - zeroconf, this is a strange but very powerful mode where
   all brokers tries to connect together on the same local network.
 
-## TODO List
-* 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)
-* Why not a 'global' TinyMqtt::loop() instead of having to call loop for all broker/clients instances
-* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
-* ~~MqttMessage uses a buffer 256 bytes which is usually far than needed.~~
-* ~~MqttClient does not support more than one subscription at time~~
-* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
-* MqttClient auto reconnection
-* ~~MqttClient unsubscribe~~
-* MqttClient does not sent payload to callback...
-* MqttClient user/password
-* Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)
-
 ## Quickstart
 
 * install [TinyMqtt library](https://github.com/hsaturn/TinyMqtt)
+  (you can use the Arduino library manager and search for TinyMqtt)
 * modify <libraries/TinyMqtt/src/my_credentials.h> (wifi setup)
 
 ## Examples
 
-
 | Example             | Description                                |
-| ---------------------------- | --------------------------------- |
+| ------------------- | ------------------------------------------ |
 | client-without-wifi | standalone example                         |
 | simple-client       | Connect the ESP to an external Mqtt broker |
 | simple-broker       | Simple Mqtt broker with your ESP           |
@@ -57,11 +43,25 @@ no need for having tons of clients (also RAM is the problem with many clients)
 
 ## Standalone mode (zeroconf)
 -> The zeroconf mode is not yet implemented
-zerofonf clients to connect to broker on local network.
+zeroconf clients to connect to broker on local network.
 
 In Zeroconf mode, each ESP is a a broker and scans the local network.
 After a while one ESP naturally becomes a 'master' and all ESP are connected together.
 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)~~
+* 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)
+* Why not a 'global' TinyMqtt::loop() instead of having to call loop for all broker/clients instances
+* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
+* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
+* MqttClient auto reconnection
+* MqttClient user/password
+* Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)
+* I suspect that MqttClient::parent could be removed and replaced with a simple boolean
+  (this'll need to rewrite a few functions)
+
 ## License
 Gnu GPL 3.0, see [LICENSE](https://github.com/hsaturn/TinyMqtt/blob/main/LICENSE).

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

@@ -3,6 +3,23 @@
 /** 
   * 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
@@ -12,14 +29,10 @@
   * cons - Takes more memory
   *      - 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,11 +41,11 @@ 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)
-{ Serial << endl << "---------> A Received " << topic.c_str() << endl; }
+void onPublishA(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client A received " << topic.c_str() << ", " << payload << endl; }
 
-void onPublishB(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
-{ Serial << endl << "---------> B Received " << topic.c_str() << endl; }
+void onPublishB(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client B Received " << topic.c_str() << ", " << payload << endl; }
 
 void setup()
 {
@@ -40,6 +53,9 @@ void setup()
   delay(500);
   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);
 
@@ -58,20 +74,20 @@ 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;
 
   if (millis() > timerA)
   {
     Serial << "A is publishing " << topic.c_str() << endl;
     timerA += intervalA;
-		mqtt_a.publish(topic);
+    mqtt_a.publish(topic, " sent by A");
   }
 
   // ============= client B publish ================
@@ -80,8 +96,9 @@ void loop()
 
   if (millis() > timerB)
   {
+		static int temperature;
     Serial << "B is publishing " << topic.c_str() << endl;
     timerB += intervalB;
-		mqtt_b.publish(topic, std::string(String(15+millis()%10).c_str()));
+    mqtt_b.publish(topic, " sent by B: "+std::string(String(16+temperature++%6).c_str()));
   }
 }

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

@@ -1,11 +1,29 @@
 #include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt
 
 /** TinyMQTT allows a disconnected mode:
+  * 
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  |
+  *  |       +-------->| 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)
-{ Serial << "--> A Received " << topic.c_str() << endl; }
+void onPublishA(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ 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)
-{ Serial << "--> B Received " << topic.c_str() << endl; }
+void onPublishB(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ 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;
+
+		if (not client.connected())
+		{
+			Serial << millis() << ": Not connected to broker" << endl;
+			return;
+		}
 
 		auto rnd=random(100);
 
 		if (rnd > 66) temp += 0.1;
 		else if (rnd < 33) temp -= 0.1;
 
-	client.publish("sensor/temperature", String(temp));
+		Serial << "--> Publishing a new sensor/temperature value: " << temp << endl;
 
+		client.publish("sensor/temperature", String(temp));
+	}
 }

examples/tinymqtt-test/tinymqtt-test.ino

@@ -1,24 +1,32 @@
-#define TINY_MQTT_DEBUG
 #include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
 #include <MqttStreaming.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>
 
-/** 
-  * Console allowing to make any kind of test.
+bool echo_on = true;
+
+/** 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)
-  *      - 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)
-	*      - accepts external clients
-  *
-  * cons - Takes more memory
-	*      - a bit hard to understand
+	* Upload the sketch, the use the terminal.
+	* Press H for mini help.
 	*
+  * 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";
 
@@ -43,44 +51,107 @@ 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 << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
-	Serial << "Type help for more..." << endl;
+  Serial << endl << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  const char* name="tinytest";
+  Serial << "Starting MDNS, name= " << name;
+  if (!MDNS.begin(name))
+    Serial << "  error, not available." << endl;
+  else
+    Serial << " ok." << endl;
+
 
 	MqttBroker* broker = new MqttBroker(1883);
 	broker->begin();
 	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;
-	while(str.length() && str[0]>='0' && str[0]<='9')
+	std::string str2=str;
+	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);
-	if (if_empty and sword.length()==0) return if_empty;
-	return atoi(sword.c_str());
+	str=str2;
+  return if_empty;
 }
 
-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;
 }
 
@@ -108,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;
@@ -126,13 +197,13 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
 std::map<std::string, std::string> vars;
 
 std::set<std::string> commands = {
-	"auto", "broker", "client", "connect",
+	"auto", "broker", "blink", "client", "connect",
 	"create", "delete", "help", "interval",
 	"ls", "ip", "off", "on", "set",
-	"publish", "reset", "subscribe", "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;
@@ -152,7 +223,7 @@ void getCommand(std::string& search)
 	else if (count>1)
 	{
 		Serial << "Ambiguous command: " << matches << endl;
-		search="";
+		search.clear();
 	}
 }
 
@@ -168,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;
 		}
 	}
 }
@@ -186,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
@@ -307,44 +379,47 @@ 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;
-	return strncmp(cmd, s.c_str(), s.length())==0;
+	uint8_t p=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);
 
-void loop()
+struct Every
 {
-	static long count;
-	if (MqttClient::counter != count)
+	std::string cmd;
+	uint32_t ms;
+	uint32_t next;
+	uint32_t underrun=0;
+	bool active=true;
+
+	void dump()
 	{
-		Serial << "# " << MqttClient::counter << endl;
-		count = MqttClient::counter;
-	}
-	for(auto it: brokers)
-		it.second->loop();
-
-	for(auto it: clients)
-		it.second->loop();
-
-	automatic::loop();
-
-	if (Serial.available())
-	{
-		static std::string cmd;
-		char c=Serial.read();
-
-		if (c==10 or c==14)
-		{
-
-			Serial << "----------------[ " << cmd.c_str() << " ]--------------" << endl;
-			static std::string last_cmd;
-			if (cmd=="!")
-				cmd=last_cmd;
+		Serial << (active ? "enabled  " : "disabled ");
+		auto mill=millis();
+		Serial << ms << "ms [" << cmd << "] next in ";
+		if (mill > next)
+			Serial << "now";
 		else
-				last_cmd=cmd;
+			Serial << next-mill << "ms";
+	}
+};
 
-			if (cmd.substr(0,3)!="set") replaceVars(cmd);
+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;
@@ -354,7 +429,6 @@ void loop()
 		MqttClient* client = nullptr;
 
 		// client.function notation
-				// ("a.fun " becomes "fun a ")
 		if (cmd.find('.') != std::string::npos &&
 				cmd.find('.') < cmd.find(' '))
 		{
@@ -373,13 +447,13 @@ void loop()
 				else
 				{
 					Serial << "Unknown class (" << s.c_str() << ")" << endl;
-							cmd="";
+					cmd.clear();
 				}
 			}
 		}
 
 		s = getword(cmd);
-				if (s.length()) getCommand(s);
+		if (s.length()) convertToCommand(s);
 		if (s.length()==0)
 		{}
 		else if (compare(s, "delete"))
@@ -435,6 +509,11 @@ void loop()
 			{
 				broker->dump();
 			}
+			else
+			{
+				Serial << "Unknown broker command (" << s << ")" << endl;
+				s.clear();
+			}
 		}
 		else if (client)
 		{
@@ -445,18 +524,145 @@ void loop()
 			}
 			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
+				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"))
 		{
@@ -542,14 +748,14 @@ void loop()
 			Serial << "--< " << clients.size() << " client/s. >--" << endl;
 			for(auto it: clients)
 			{
-						Serial << "  "; it.second->dump();
+				it.second->dump("  ");
 			}
 
 			Serial << "--< " << brokers.size() << " brokers/s. >--" << endl;
 			for(auto it: brokers)
 			{
-						Serial << " ==[ Broker: " << it.first.c_str() << " ]== ";
-						it.second->dump();
+				Serial << "  +-- '" << it.first.c_str() << "' " << it.second->clientsCount() << " client/s."<< endl;
+				it.second->dump("     ");
 			}
 		}
 		else if (compare(s, "reset"))
@@ -565,7 +771,7 @@ void loop()
 			Serial << "  MqttClient:" << endl;
 			Serial << "    client {name} {parent broker} : create a client then" << endl;
 			Serial << "      name.connect  [ip] [port] [alive]" << endl;
-					Serial << "      name.subscribe [topic]" << endl;
+			Serial << "      name.[un]subscribe [topic]" << endl;
 			Serial << "      name.publish [topic][payload]" << endl;
 			Serial << "      name.view" << endl;
 			Serial << "      name.delete" << endl;
@@ -573,11 +779,16 @@ void loop()
 			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;
 		}
@@ -590,10 +801,92 @@ void loop()
 
 		if (retval != MqttOk)
 		{
-					Serial << "## ERROR " << retval << endl;
+			Serial << "# MQTT ERROR " << retval << endl;
 		}
 	}
 }
+
+void loop()
+{
+	auto ms=millis();
+	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])
+		{
+			if (blink_state[out])
+			{
+				blink_next[out] += blink_ms_on[out];
+				digitalWrite(out, LOW);
+			}
+			else
+			{
+				blink_next[out] += blink_ms_off[out];
+				digitalWrite(abs(out), HIGH);
+			}
+			blink_state[out] = not blink_state[out];
+		}
+		blink_bits >>=1;
+		out++;
+	}
+
+	static long count;
+  #if defined(ESP9266)
+  MDNS.update();
+  #endif
+
+	if (MqttClient::counter != count)
+	{
+		Serial << "# " << MqttClient::counter << endl;
+		count = MqttClient::counter;
+	}
+	for(auto it: brokers)
+		it.second->loop();
+
+	for(auto it: clients)
+		it.second->loop();
+
+	automatic::loop();
+
+	if (Serial.available())
+	{
+		static std::string cmd;
+		char c=Serial.read();
+		if (echo_on)
+			Serial << c;
+
+		if (c==10 or c==13)
+		{
+			Serial << "----------------[ " << cmd.c_str() << " ]--------------" << endl;
+			static std::string last_cmd;
+			if (cmd=="!")
+				cmd=last_cmd;
+			else
+				last_cmd=cmd;
+
+			if (cmd.substr(0,3)!="set") replaceVars(cmd);
+			eval(cmd);
+		}
 		else
 		{
 			cmd=cmd+c;

library.json

@@ -1,12 +1,12 @@
 {
     "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 without QOS=0.",
+    "description": "MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive and host a broker for MQTT. It does support MQTT 3.1.1 with QOS=0 on ESP8266 and ESP32 WROOM platfrms.",
     "repository": {
         "type": "git",
         "url": "https://github.com/hsaturn/TinyMqtt.git"
     },
-    "version": "0.7.3",
+    "version": "0.8.0",
     "exclude": "",
     "examples": "examples/*/*.ino",
     "frameworks": "arduino",

library.properties

@@ -1,11 +1,11 @@
 name=TinyMqtt
-version=0.7.3
+version=0.8.0
 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 without 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=*
 includes=TinyMqtt.h
-depends=
+depends=AsyncTCP

src/MqttStreaming.h

@@ -42,7 +42,7 @@
 #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 +154,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

@@ -2,7 +2,6 @@
 #include <map>
 #include <string>
 #include <string.h>
-#include <ESP8266WiFi.h>
 
 /***
  * Allows to store up to 255 different strings with one byte class
@@ -29,7 +28,7 @@ class StringIndexer
 	public:
 		using index_t=uint8_t;
 
-		static const 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++)
 			{

src/TinyMqtt.cpp

@@ -9,8 +9,12 @@ void outstring(const char* prefix, const char*p, uint16_t len)
 	Serial << '\'' << endl;
 }
 
-MqttBroker::MqttBroker(uint16_t port) : server(port)
+MqttBroker::MqttBroker(uint16_t port)
 {
+	server = new TcpServer(port);
+#ifdef TCP_ASYNC
+	server->onClient(onClient, this);
+#endif
 }
 
 MqttBroker::~MqttBroker()
@@ -19,15 +23,22 @@ MqttBroker::~MqttBroker()
 	{
 		delete clients[0];
 	}
-	server.close();
+	delete server;
 }
 
 // private constructor used by broker only
-MqttClient::MqttClient(MqttBroker* parent, WiFiClient& new_client)
+MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
 	: parent(parent)
 {
-	client = new WiFiClient(new_client);
-	alive = millis()+5000;	// client expires after 5s if no CONNECT msg
+#ifdef TCP_ASYNC
+	client = new_client;
+	client->onData(onData, this);
+	// client->onConnect() TODO
+	// client->onDisconnect() TODO
+#else
+	client = new WiFiClient(*new_client);
+#endif
+	alive = millis()+5000;	// TODO MAGIC client expires after 5s if no CONNECT msg
 }
 
 MqttClient::MqttClient(MqttBroker* parent, const std::string& id)
@@ -48,7 +59,7 @@ void MqttClient::close(bool bSendDisconnect)
 {
 	debug("close " << id().c_str());
 	mqtt_connected = false;
-	if (client)
+	if (client)	// connected to a remote broker
 	{
 		if (bSendDisconnect and client->connected())
 		{
@@ -65,32 +76,31 @@ void MqttClient::close(bool bSendDisconnect)
 	}
 }
 
+void MqttClient::connect(MqttBroker* parentBroker)
+{
+	close();
+	parent = parentBroker;
+}
+
 void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
 {
 	debug("cnx: closing");
+	keep_alive = ka;
 	close();
 	if (client) delete client;
-	client = new WiFiClient;
+	client = new TcpClient;
+
 	debug("Trying to connect to " << broker.c_str() << ':' << port);
+#ifdef TCP_ASYNC
+	client->onData(onData, this);
+	client->onConnect(onConnect, this);
+	client->connect(broker.c_str(), port);
+#else
 	if (client->connect(broker.c_str(), port))
 	{
-	  debug("cnx: connecting");
-		MqttMessage msg(MqttMessage::Type::Connect);
-		msg.add("MQTT",4);
-		msg.add(0x4);	// Mqtt protocol version 3.1.1
-		msg.add(0x0);	// Connect flags         TODO user / name
-
-		keep_alive = ka;
-		msg.add(0x00);			// keep_alive
-		msg.add((char)keep_alive);
-		msg.add(clientId);
-	  debug("cnx: mqtt connecting");
-		msg.sendTo(this);
-		msg.reset();
-	  debug("cnx: mqtt sent " << (int32_t)parent);
-
-		clientAlive(0);
+		onConnect(this, client);
 	}
+#endif
 }
 
 void MqttBroker::addClient(MqttClient* client)
@@ -126,10 +136,24 @@ void MqttBroker::removeClient(MqttClient* remove)
 	debug("Error cannot remove client");	// TODO should not occur
 }
 
+void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
+{
+	MqttBroker* broker = static_cast<MqttBroker*>(broker_ptr);
+
+	broker->addClient(new MqttClient(broker, client));
+	debug("New client");
+}
+
 void MqttBroker::loop()
 {
-  WiFiClient client = server.available();
+#ifndef TCP_ASYNC
+  WiFiClient client = server->available();
 
+  if (client)
+	{
+		onClient(this, &client);
+	}
+#endif
 	if (broker)
 	{
 		// TODO should monitor broker's activity.
@@ -137,11 +161,6 @@ void MqttBroker::loop()
 		broker->loop();
 	}
 
-  if (client)
-	{
-		addClient(new MqttClient(this, client));
-		debug("New client (" << clients.size() << ')');
-	}
 
   // for(auto it=clients.begin(); it!=clients.end(); it++)
 	// use index because size can change during the loop
@@ -154,7 +173,7 @@ void MqttBroker::loop()
 		}
 		else
 		{
-      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (int32_t)client->parent);
+      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (dbg_ptr)client->parent);
 			// Note: deleting a client not added by the broker itself will probably crash later.
 			delete client;
 			break;
@@ -168,9 +187,10 @@ MqttError MqttBroker::subscribe(const Topic& topic, uint8_t qos)
 	{
 		return broker->subscribe(topic, qos);
 	}
+	return MqttNowhereToSend;
 }
 
-MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, const MqttMessage& msg) const
+MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const
 {
 	MqttError retval = MqttOk;
 
@@ -179,7 +199,7 @@ MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, cons
 	for(auto client: clients)
 	{
 		i++;
-#if TINY_MQTT_DEBUG
+#ifdef TINY_MQTT_DEBUG
 		Serial << "brk_" << (broker && broker->connected() ? "con" : "dis") <<
 			 "	srce=" << (source->isLocal() ? "loc" : "rem") << " clt#" << i << ", local=" << client->isLocal() << ", con=" << client->connected() << endl;
 #endif
@@ -200,7 +220,7 @@ MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, cons
 		{
 			doit = true;
 		}
-#if TINY_MQTT_DEBUG
+#ifdef TINY_MQTT_DEBUG
 		Serial << ", doit=" << doit << ' ';
 #endif
 
@@ -250,14 +270,14 @@ void MqttClient::loop()
 		{
 			debug("pingreq");
 			uint16_t pingreq = MqttMessage::Type::PingReq;
-			client->write((uint8_t*)(&pingreq), 2);
+			client->write((const char*)(&pingreq), 2);
 			clientAlive(0);
 
-			// TODO when many MqttClient passes through a local browser
+			// TODO when many MqttClient passes through a local broker
 			// there is no need to send one PingReq per instance.
 		}
 	}
-
+#ifndef TCP_ASYNC
 	while(client && client->available()>0)
 	{
 		message.incoming(client->read());
@@ -267,8 +287,47 @@ void MqttClient::loop()
 			message.reset();
 		}
 	}
+#endif
 }
 
+void MqttClient::onConnect(void *mqttclient_ptr, TcpClient*)
+{
+	MqttClient* mqtt = static_cast<MqttClient*>(mqttclient_ptr);
+	debug("cnx: connecting");
+	MqttMessage msg(MqttMessage::Type::Connect);
+	msg.add("MQTT",4);
+	msg.add(0x4);	// Mqtt protocol version 3.1.1
+	msg.add(0x0);	// Connect flags         TODO user / name
+
+	msg.add(0x00);			// keep_alive
+	msg.add((char)mqtt->keep_alive);
+	msg.add(mqtt->clientId);
+	debug("cnx: mqtt connecting");
+	msg.sendTo(mqtt);
+	msg.reset();
+	debug("cnx: mqtt sent " << (dbg_ptr)mqtt->parent);
+
+	mqtt->clientAlive(0);
+}
+
+#ifdef TCP_ASYNC
+void MqttClient::onData(void* client_ptr, TcpClient*, void* data, size_t len)
+{
+	char* char_ptr = static_cast<char*>(data);
+	MqttClient* client=static_cast<MqttClient*>(client_ptr);
+	while(len>0)
+	{
+		client->message.incoming(*char_ptr++);
+		if (client->message.type())
+		{
+			client->processMessage(&client->message);
+			client->message.reset();
+		}
+		len--;
+	}
+}
+#endif
+
 void MqttClient::resubscribe()
 {
 	// TODO resubscription limited to 256 bytes
@@ -338,14 +397,19 @@ MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint
 
 long MqttClient::counter=0;
 
-void MqttClient::processMessage(const MqttMessage* mesg)
+void MqttClient::processMessage(MqttMessage* mesg)
 {
 	counter++;
-#if TINY_MQTT_DEBUG
+#ifdef TINY_MQTT_DEBUG
 if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::Type::PingResp)
 {
-	Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (int)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
+	#ifdef NOT_ESP_CORE
+		Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << " ESP.getFreeHeap() "<< endl;
+	#else
+		Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
+	#endif
 	// mesg->hexdump("Incoming");
+	mesg->hexdump("Incoming");
 }
 #endif
   auto header = mesg->getVHeader();
@@ -438,7 +502,7 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 			if (client)
 			{
 				uint16_t pingreq = MqttMessage::Type::PingResp;
-				client->write((uint8_t*)(&pingreq), 2);
+				client->write((const char*)(&pingreq), 2);
 			  bclose = false;
 			}
 			else
@@ -453,25 +517,27 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 				if (!mqtt_connected) break;
 				payload = header+2;
 				
-				debug("subscribe loop");
+				debug("un/subscribe loop");
 				while(payload < mesg->end())
 				{
 					mesg->getString(payload, len);	// Topic
 					debug( "  topic (" << std::string(payload, len) << ')');
-					outstring("Subscribes", payload, len);
+					outstring("  un/subscribes", payload, len);
 					// subscribe(Topic(payload, len));
 					Topic topic(payload, len);
+					payload += len;
 					if ((mesg->type() & 0XF0) == MqttMessage::Type::Subscribe)
+					{
+						uint8_t qos = *payload++;
+						if (qos != 0) debug("Unsupported QOS" << qos << endl);
 						subscriptions.insert(topic);
+					}
 					else
 					{
 						auto it=subscriptions.find(topic);
 						if (it != subscriptions.end())
 							subscriptions.erase(it);
 					}
-					payload += len;
-					uint8_t qos = *payload++;
-					debug("  qos=" << qos);
 				}
 				debug("end loop");
 				bclose = false;
@@ -479,7 +545,15 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 			}
 			break;
 
+		case MqttMessage::Type::UnSuback:
+			if (!mqtt_connected) break;
+			bclose = false;
+			break;
+
 		case MqttMessage::Type::Publish:
+			#ifdef TINY_MQTT_DEBUG
+				Serial << "publish " << mqtt_connected << '/' << (long) client << endl;
+			#endif
 			if (mqtt_connected or client == nullptr)
 			{
 				uint8_t qos = mesg->type() & 0x6;
@@ -494,8 +568,12 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 				// TODO reset DUP
 				// TODO reset RETAIN
 
-				if (client==nullptr)	// internal MqttClient receives publish
+				if (parent==nullptr or client==nullptr)	// internal MqttClient receives publish
 				{
+					#ifdef TINY_MQTT_DEBUG
+						Serial << (isSubscribedTo(published) ? "not" : "") << " subscribed.\n";
+						Serial << "has " << (callback ? "" : "no ") << " callback.\n";
+					#endif
 					if (callback and isSubscribedTo(published))
 					{
 						callback(this, published, payload, len);	// TODO send the real payload
@@ -550,6 +628,7 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
 	msg.add(topic);
 	msg.add(payload, pay_length, false);
 	msg.complete();
+
 	if (parent)
 	{
 		return parent->publish(this, topic, msg);
@@ -561,7 +640,7 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
 }
 
 // republish a received publish if it matches any in subscriptions
-MqttError MqttClient::publishIfSubscribed(const Topic& topic, const MqttMessage& msg)
+MqttError MqttClient::publishIfSubscribed(const Topic& topic, MqttMessage& msg)
 {
 	MqttError retval=MqttOk;
 
@@ -573,6 +652,10 @@ MqttError MqttClient::publishIfSubscribed(const Topic& topic, const MqttMessage&
 		else
 		{
 			processMessage(&msg);
+
+			#ifdef TINY_MQTT_DEBUG
+				Serial << "Should call the callback ?\n";
+			#endif
 			// callback(this, topic, nullptr, 0);	// TODO Payload
 		}
 	}
@@ -601,24 +684,23 @@ void MqttMessage::incoming(char in_byte)
 	switch(state)
 	{
 		case FixedHeader:
-			size=0;
+			size=MaxBufferLength;
 			state = Length;
 			break;
 		case Length:
-			size = (size<<7) + (in_byte & 0x3F);
+
+		  if (size==MaxBufferLength)
+        size = in_byte & 0x7F;
+		  else
+		    size += static_cast<uint16_t>(in_byte & 0x7F)<<7;
+
 			if (size > MaxBufferLength)
-			{
 				state = Error;
-			}
 			else if ((in_byte & 0x80) == 0)
 			{
 				vheader = buffer.length();
 				if (size==0)
 					state = Complete;
-				else if (size > 500)	// TODO magic
-				{
-					state = Error;
-				}
 				else
 				{
 					buffer.reserve(size);
@@ -645,7 +727,7 @@ void MqttMessage::incoming(char in_byte)
 			reset();
 			break;
 	}
-	if (buffer.length() > MaxBufferLength)	// TODO magic 256 ?
+	if (buffer.length() > MaxBufferLength)
 	{
 		debug("Too long " << state);
 		reset();
@@ -656,35 +738,33 @@ void MqttMessage::add(const char* p, size_t len, bool addLength)
 {
 	if (addLength)
 	{
+		buffer.reserve(buffer.length()+2);
 		incoming(len>>8);
 		incoming(len & 0xFF);
 	}
 	while(len--) incoming(*p++);
 }
 
-void MqttMessage::encodeLength(char* msb, int length) const
+void MqttMessage::encodeLength()
 {
-	do
+	if (state != Complete)
 	{
-		uint8_t encoded(length & 0x7F);
-		length >>=7;
-		if (length) encoded |= 0x80;
-		*msb++ = encoded;
-	} while (length);
-};
+		int length = buffer.size()-3;	// 3 = 1 byte for header + 2 bytes for pre-reserved length field.
+    buffer[1] = 0x80 | (length & 0x7F);
+    buffer[2] = (length >> 7);
+    vheader = 3;
       
-void MqttMessage::complete()
-{
-		encodeLength(&buffer[1], buffer.size()-2);
+    // We could check that buffer[2] < 128 (end of length encoding)
     state = Complete;
   }
+};
 
-MqttError MqttMessage::sendTo(MqttClient* client) const
+MqttError MqttMessage::sendTo(MqttClient* client)
 {
 	if (buffer.size())
 	{
 		debug("sending " << buffer.size() << " bytes");
-		encodeLength(&buffer[1], buffer.size()-2);
+		encodeLength();
 		// hexdump("snd");
 		client->write(&buffer[0], buffer.size());
 	}

src/TinyMqtt.h

@@ -1,18 +1,47 @@
+#pragma once
+
+// 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
 #include <vector>
 #include <set>
 #include <string>
 #include "StringIndexer.h"
 #include <MqttStreaming.h>
 
-#if 0
+// #define TINY_MQTT_DEBUG
+
+#ifdef TINY_MQTT_DEBUG
   #define debug(what) { Serial << __LINE__ << ' ' << what << endl; delay(100); }
-  #define TINY_MQTT_DEBUG 1
 #else
-  #define TINY_MQTT_DEBUG 0
   #define debug(what) {}
 #endif
 
+#ifdef TCP_ASYNC
+  using TcpClient = AsyncClient;
+  using TcpServer = AsyncServer;
+#else
+  using TcpClient = WiFiClient;
+  using TcpServer = WiFiServer;
+#endif
+
 enum MqttError
 {
 	MqttOk = 0,
@@ -35,7 +64,7 @@ class Topic : public IndexedString
 class MqttClient;
 class MqttMessage
 {
-	const uint16_t MaxBufferLength = 255;
+	const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
 	public:
 		enum Type
 		{
@@ -47,6 +76,7 @@ class MqttMessage
 			Subscribe   = 0x80,
 			SubAck      = 0x90,
 			UnSubscribe = 0xA0,
+			UnSuback	= 0xB0,
 			PingReq     = 0xC0,
 			PingResp    = 0xD0,
 			Disconnect  = 0xE0
@@ -71,8 +101,7 @@ class MqttMessage
 		void add(const Topic& t) { add(t.str()); }
 		const char* end() const { return &buffer[0]+buffer.size(); }
 		const char* getVHeader() const { return &buffer[vheader]; }
-		uint16_t length() const { return buffer.size(); }
-		void complete();
+		void complete() { encodeLength(); }
 
 		void reset();
 
@@ -80,34 +109,27 @@ class MqttMessage
 		// output buff+=2, len=length(str)
 		static void getString(const char* &buff, uint16_t& len);
 
-
 		Type type() const
 		{
 			return state == Complete ? static_cast<Type>(buffer[0]) : Unknown;
 		}
 
-		// shouldn't exist because it breaks constness :-(
-		// but this saves memory so ...
-		void changeType(Type type) const
-		{
-			buffer[0] = type;
-		}
-
 		void create(Type type)
 		{
 			buffer=(char)type;
-			buffer+='\0';
-			vheader=2;
+			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*) const;
+		MqttError sendTo(MqttClient*);
 		void hexdump(const char* prefix=nullptr) const;
 
 	private:
-		void encodeLength(char* msb, int length) const;
+		void encodeLength();
 
-		mutable std::string buffer;	// mutable -> sendTo()
+		std::string buffer;
 		uint8_t vheader;
 		uint16_t size;	// bytes left to receive
 		State state;
@@ -150,10 +172,18 @@ class MqttClient
 		/** Should be called in main loop() */
 		void loop();
 		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
 		MqttError publish(const Topic&, const char* payload, size_t pay_length);
+		MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
 		MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
 		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);};
@@ -166,43 +196,50 @@ class MqttClient
 		// TODO seems to be useless
 		bool isLocal() const { return client == nullptr; }
 
-		void dump()
+		void dump(std::string indent="")
 		{
 			uint32_t ms=millis();
-			Serial << "MqttClient (" << clientId.c_str() << ") " << (connected() ? " ON " : " OFF");
-			Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive;
+			Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
+			Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
 			Serial << (client && client->connected() ? "" : "dis") << "connected";
-            message.hexdump("entrant msg");
+			if (subscriptions.size())
+			{
 				bool c = false;
 				Serial << " [";
 				for(auto s: subscriptions)
 				{
-				Serial << (c?", ": "")<< s.str().c_str();
+					if (c) Serial << ", ";
+					Serial << s.str().c_str();
 					c=true;
 				}
-
-			
-			Serial << "]" << endl;
+				Serial << ']';
+			}
+			Serial << endl;
 		}
 
-		/** Count the number of messages that have been sent **/
-		static long counter;
+		static long counter;  // Number of processed messages
 
 	private:
+
+		// event when tcp/ip link established (real or fake)
+		static void onConnect(void * client_ptr, TcpClient*);
+#ifdef TCP_ASYNC
+		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;
-		MqttClient(MqttBroker* parent, WiFiClient& client);
+		MqttClient(MqttBroker* parent, TcpClient* client);
 		// 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 processMessage(const MqttMessage* message);
+		void processMessage(MqttMessage* message);
 
 		bool mqtt_connected = false;
 		char mqtt_flags;
-		uint32_t keep_alive;
+		uint32_t keep_alive = 60;
 		uint32_t alive;
 		MqttMessage message;
 
@@ -211,7 +248,7 @@ class MqttClient
 		// (this is the case when MqttBroker isn't used except here)
 		MqttBroker* parent=nullptr;		// connection to local broker
 
-		WiFiClient* client=nullptr;		// connection to mqtt client or to remote broker
+		TcpClient* client=nullptr;		// connection to remote broker
 		std::set<Topic>	subscriptions;
 		std::string clientId;
 		CallBack callback = nullptr;
@@ -230,29 +267,24 @@ class MqttBroker
 		MqttBroker(uint16_t port);
 		~MqttBroker();
 
-		void begin() { server.begin(); }
+		void begin() { server->begin(); }
 		void loop();
 
-		uint16_t port() const { return server.port(); }
-
 		void connect(const std::string& host, uint16_t port=1883);
 		bool connected() const { return state == Connected; }
 
 		size_t clientsCount() const { return clients.size(); }
 
-		void dump()
+		void dump(std::string indent="")
 		{
-			Serial << clients.size() << " client/s" << endl;
 			for(auto client: clients)
-			{
-				Serial << "  ";
-				client->dump();
-			}
+				client->dump(indent);
 		}
 
 	private:
 		friend class MqttClient;
 
+		static void onClient(void*, TcpClient*);
 		bool checkUser(const char* user, uint8_t len) const
 		{ return compareString(auth_user, user, len); }
 
@@ -260,7 +292,7 @@ class MqttBroker
 		{ 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);
 
@@ -270,7 +302,7 @@ class MqttBroker
 
 		bool compareString(const char* good, const char* str, uint8_t str_len) const;
 		std::vector<MqttClient*>	clients;
-		WiFiServer server;
+		TcpServer* server;
 
 		const char* auth_user = "guest";
 		const char* auth_password = "guest";

tests/Makefile

@@ -5,7 +5,7 @@ tests:
 		$(MAKE) -C $$(dirname $$i) -j; \
 	done
 
-runtests:
+runtests: tests
 	set -e; \
 	for i in *-tests/Makefile; do \
 		echo '==== Running:' $$(dirname $$i); \

tests/howto

@@ -0,0 +1,6 @@
+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

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

@@ -2,5 +2,7 @@
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
 APP_NAME := local-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+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>
@@ -6,7 +7,7 @@
 	* TinyMqtt local unit tests.
 	*
 	* Clients are connected to pseudo remote broker
-	* The remote will be 127.0.0.1:1883
+	* 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
 	**/

tests/nowifi-tests/Makefile

@@ -1,6 +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
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+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>
@@ -15,14 +16,16 @@ MqttBroker broker(1883);
 
 std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
 
-const char* lastPayload;
+char* lastPayload = nullptr;
 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;
+	
+	if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
 	lastLength = length;
 }
 
@@ -129,9 +132,8 @@ 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)
 {
-  return; // FIXME
 	published.clear();
 
 	const char* payload="abcd";
@@ -148,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,5 +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
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk

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

@@ -1,28 +1,15 @@
+#include <Arduino.h>
 #include <AUnit.h>
-#include <TinyMqtt.h>
+#include <StringIndexer.h>
 #include <map>
 
 /**
-	* TinyMqtt local unit tests.
+	* TinyMqtt / StringIndexer unit tests.
 	*
-	* Clients are connected to pseudo remote broker
-	* The remote will be 127.0.0.1:1883
-	* 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
-
-void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
-{
-	if (srce)
-		published[srce->id()][topic]++;
-}
-
 test(indexer_empty)
 {
   assertEqual(StringIndexer::count(), 0);
@@ -119,5 +106,5 @@ void setup() {
 void loop() {
 	aunit::TestRunner::run();
 
-	if (Serial.available()) ESP.reset();
+	// if (Serial.available()) ESP.reset();
 }