Version 0.9.9

Fix compilation error when not in debug
:xDefault client is no more empty
2022-12-24 02:01:27 +01:00 · 2022-12-23 18:06:35 +01:00 · 2022-12-17 18:36:32 +01:00 · 2022-12-04 02:41:11 +01:00 · 2022-12-04 02:30:37 +01:00 · 2022-12-04 02:03:28 +01:00
32 changed files with 3130 additions and 2290 deletions
--- a/.github/workflows/aunit.yml
+++ b/.github/workflows/aunit.yml
@@ -17,6 +17,7 @@ jobs:
    - name: Setup
      run: |
        cd ..
+        git clone https://github.com/hsaturn/TinyConsole
        git clone https://github.com/bxparks/EpoxyDuino
        git clone https://github.com/bxparks/AceRoutine
        git clone https://github.com/bxparks/AUnit
@@ -24,5 +25,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
--- a/.github/workflows/ci.yml
+++ b/.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"
--- a/.github/workflows/superlinter.yml
+++ b/.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
-  # when a job name is not provided
-  super-lint:
+  build:
    # Name the Job
-    name: Lint code base
-    # Set the type of machine to run on
+    name: Lint Code Base
+    # 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
-        uses: actions/checkout@v2
+      ##########################
+      # Checkout the code base #
+      ##########################
+      - 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
-        uses: github/super-linter@v3
+      ################################
+      # Run Linter against code base #
+      ################################
+      - 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 }}
--- a/README.md
+++ b/README.md
@@ -1,26 +1,36 @@
 # 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)
 [![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)
-![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)
+[![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
+- Wildcards supported (+ # $ and * (even if not part of the spec...))
 - Standalone (can work without WiFi) (degraded/local mode)
 - Brokers can connect to another broker and becomes then a
  proxy for clients that are connected to it.
 - zeroconf, this is a strange but very powerful mode where
  all brokers tries to connect together on the same local network.
+- small memory footprint (very efficient topic storage)
+- long messages are supported (>127 bytes)
+- TinyMQTT is largely unit tested, so once a bug is fixed, it is fixed forever
+
+## Limitations
+
+- Max of 255 different topics can be stored (change index_t type to allow more)
+- No Qos because messages are not queued but immediately sent to clients

 ## Quickstart

@@ -32,10 +42,11 @@ ESP 8266 is a small, fast and capable Mqtt Broker and Client

 | 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           |
-| tinymqtt-test       | Complex console example                    |
+| [client-with-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-with-wifi/client-with-wifi.ino) | standalone example                         |
+| [client-without-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-without-wifi/client-without-wifi.ino) | standalone example                         |
+| [simple-client](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-client/simple-client.ino)       | Connect the ESP to an external Mqtt broker |
+| [simple-broker](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-broker/simple-broker.ino)       | Simple Mqtt broker with your ESP           |
+| [tinymqtt-test](https://github.com/hsaturn/TinyMqtt/tree/main/examples/tinymqtt-test/tinymqtt-test.ino)       | Complex console example                    |

 - tinymqtt-test : This is a complex sketch with a terminal console
  that allows to add clients publish, connect etc with interpreted commands.
@@ -58,7 +69,7 @@ no need for having tons of clients (also RAM is the problem with many clients)
 * ~~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)
+* ~~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)

--- a/examples/client-with-wifi/client-with-wifi.ino
+++ b/examples/client-with-wifi/client-with-wifi.ino
@@ -1,6 +1,8 @@
 #include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt

 /** 
+  * Local broker that accept connections and two local clients
+  *
  * 
  *  +-----------------------------+
  *  | ESP                         |
@@ -9,9 +11,10 @@
  *  |       |         +--------+  |
  *  |       |             ^       |
  *  |       |             |       |
-  *  |       v             v       |
-  *  | +----------+  +----------+  |
-  *  | | internal |  | internal |  |
+  *  |       |             |       |     -----
+  *  |       v             v       |      ---  
+  *  | +----------+  +----------+  |       -  
+  *  | | internal |  | internal |  +-------*  Wifi
  *  | | client   |  | client   |  |          
  *  | +----------+  +----------+  |          
  *  |                             |
@@ -28,7 +31,8 @@
  *
  */

-#include <my_credentials.h>
+const char *ssid     = "";
+const char *password = "";

 std::string topic="sensor/temperature";

@@ -37,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()
 {
@@ -49,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);

@@ -73,14 +80,14 @@ void 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 ================
@@ -89,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()));
  }
 }
--- a/examples/client-without-wifi/client-without-wifi.ino
+++ b/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");
 	}
 }
--- a/examples/simple-broker/simple-broker.ino
+++ 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)
+		Console << TinyConsole::red << "****** PLEASE MODIFY ssid/password *************" << endl;
+
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

@@ -16,10 +35,10 @@ void setup()
    Serial << '.';
    delay(500);
  }
-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  
+  Console << TinyConsole::green << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;

  broker.begin();
-  Serial << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
+  Console << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
 }

 void loop()
--- a/examples/simple-client/simple-client.ino
+++ b/examples/simple-client/simple-client.ino
@@ -1,11 +1,26 @@
 #include "TinyMqtt.h"    // https://github.com/hsaturn/TinyMqtt
+#include "TinyStreaming.h" // https://github.com/hsaturn/TinyConsole

-/** Simple Client
+/** Simple Client (The simplest configuration)
  *
-	* This is the simplest Mqtt client configuration
  *                             
-	* 1 - edit my_credentials.h to setup wifi essid/password
+  *                   +--------+       
+  *           +------>| 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
@@ -18,7 +33,8 @@
 const char* BROKER = "broker.emqx.io";
 const uint16_t BROKER_PORT = 1883;

-#include <my_credentials.h>
+const char* ssid = "";
+const char* password = "";

 static float temp=19;
 static MqttClient client;
@@ -27,7 +43,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);
@@ -37,20 +56,33 @@ void setup()

  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  

-	client.connect(BROKER, BROKER_PORT);	// Put here your broker ip / port
+	client.connect(BROKER, BROKER_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));
+	}
 }
--- a/examples/tinymqtt-test/tinymqtt-test.ino
+++ b/examples/tinymqtt-test/tinymqtt-test.ino
@@ -1,39 +1,76 @@
+// vim: ts=2 sw=2 expandtab smartindent
+#include <TinyConsole.h>
 #include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
-#include <MqttStreaming.h>
+#include <TinyStreaming.h>
+#if defined(ESP8266)
  #include <ESP8266mDNS.h>
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #include <ESPmDNS.h>
+#else
+  #error Unsupported platform
+#endif

 #include <sstream>
+#include <string>
 #include <map>

-/**
-  * Console allowing to make any kind of test.
+bool echo_on = true;
+auto green = TinyConsole::green;
+auto red = TinyConsole::red;
+auto white = TinyConsole::white;
+auto cyan = TinyConsole::cyan;
+auto yellow = TinyConsole::yellow;
+auto magenta = TinyConsole::magenta;
+auto save_cursor = TinyConsole::save_cursor;
+auto restore_cursor = TinyConsole::restore_cursor;
+auto erase_to_end = TinyConsole::erase_to_end;
+
+const char* ssid = "";
+const char* password = "";
+
+struct free_broker
+{
+  public:
+    free_broker(const char* s, uint16_t p, const char* comment) : url(s), port(p) {}
+
+    std::string url;
+    uint16_t port;
+};
+
+const std::map<std::string, free_broker> list =
+{
+  { "mqtthq", { "public.mqtthq.com" , 8083, "publish/subscribe" }},
+  { "hivemq", { "broker.hivemq.com", 1883, "" }}
+};
+
+/** 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>
-
-std::string topic="sensor/temperature";
-
 void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
 {
-	Serial << "--> " << srce->id().c_str() << ": ======> received " << topic.c_str();
-	if (payload) Serial << ", payload[" << length << "]=[";
+  Console << cyan << "--> " << srce->id().c_str() << ": received " << topic.c_str() << white;
+  if (payload)
+  {
+    Console << ", payload[" << length << "]=[";
    while(length--)
    {
      const char c=*payload++;
-		if (c!=10 and c!=13 and c <32) Serial << '?';
-		Serial << *payload++;
+      if (c<32)
+        Console << '?';
+      else
+        Console << c;
+    }
+    Console << ']' << endl;
  }
-	Serial<< endl;
 }

 std::map<std::string, MqttClient*> clients;
@@ -43,53 +80,113 @@ void setup()
 {
  WiFi.persistent(false); // https://github.com/esp8266/Arduino/issues/1054
  Serial.begin(115200);
+  Console.begin(Serial);
+  Console.setPrompt("> ");
+  Console.setCallback(onCommand);
  delay(500);
-	Serial << endl << endl << endl
-	<< "Connecting to '" << ssid << "' ";

+  Console.cls();
+  Console << endl << endl;
+  Console << yellow
+          << "***************************************************************" << endl;
+  Console << "*  Welcome to the TinyMqtt console" << endl;
+  Console << "*  The console allows to test all features of the libraries." << endl;
+  Console << "*  Enter help to view the list of commands." << endl;
+  Console << "***************************************************************" << endl;
+  Console << endl;
+  if (strlen(ssid)==0)
+    Console << red << "*  ERROR: You must modify ssid/password in order" << endl
+                   << "          to be able to connect to your Wifi network." << endl;
+  Console << endl << white;
+
+  Console << "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); }
+  { Console << '-'; delay(500); }

-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
-	Serial << "Type help for more..." << endl;
+  Console << endl << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;

  const char* name="tinytest";
-  Serial << "Starting MDNS, name= " << name;
+  Console << "Starting MDNS, name= " << name;
  if (!MDNS.begin(name))
-    Serial << "  error, not available." << endl;
+    Console << "  error, not available." << endl;
  else
-    Serial << " ok." << endl;
+    Console << " ok." << endl;


  MqttBroker* broker = new MqttBroker(1883);
  broker->begin();
  brokers["broker"] = broker;
+
+  if (Console.isTerm()) onCommand("every 333 view");
 }

+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]!=')') Console << "Missing ')'" << endl;
+      }
+      else
+      {
+        to=from;
+        from=0;
+      }
+      return String(random(from,to)).c_str();
+    }
+    else
+    {
+      Console << "Missing '('" << endl;
+    }
+  }
+  while(str[0]==' ') str.erase(0,1);
  return sword;
 }

@@ -117,7 +214,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;
@@ -129,19 +226,20 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
    if (addr.length()) addr += '.';
    addr += s;
  }
+  Console << "connect address: " << addr << endl;
  return addr;
 }

 std::map<std::string, std::string> vars;

 std::set<std::string> commands = {
-	"auto", "broker", "blink", "client", "connect",
-	"create", "delete", "help", "interval",
-	"ls", "ip", "off", "on", "set",
-	"publish", "reset", "subscribe", "unsubscribe", "view", "every"
+  "broker", "blink", "client", "connect",
+  "create", "delete", "debug", "help", "interval",
+  "list", "ls", "ip", "off", "on", "set",
+  "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;
@@ -160,8 +258,8 @@ void getCommand(std::string& search)
    search = matches;
  else if (count>1)
  {
-		Serial << "Ambiguous command: " << matches << endl;
-		search="";
+    Console << "Ambiguous command: " << matches << endl;
+    search.clear();
  }
 }

@@ -177,7 +275,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,125 +293,9 @@ 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
-class automatic
-{
-	public:
-		automatic(MqttClient* clt, uint32_t intervl)
-		: client(clt), topic_(::topic)
-		{
-			interval(intervl);
-		  autos[clt] = this;
 }

-		void interval(uint32_t new_interval)
-		{
-			interval_ = new_interval;
-			if (interval_<1000) interval_=1000;
-			timer_ = millis() + interval_;
-		}
-
-		void loop_()
-		{
-			if (!bon) return;
-			if (interval_ && millis() > timer_)
-			{
-				Serial << "AUTO PUBLISH " << interval_ << endl;
-				timer_ += interval_;
-				client->publish(topic_, std::string(String(15+millis()%10).c_str()));
-			}
-		}
-
-		void topic(std::string new_topic) { topic_ = new_topic; }
-
-		static void loop()
-		{
-			for(auto it: autos)
-				it.second->loop_();
-		}
-
-		static void command(MqttClient* who, std::string cmd)
-		{
-			automatic* autop = nullptr;
-			if (autos.find(who) != autos.end())
-			{
-				autop=autos[who];
-			}
-			std::string s = getword(cmd);
-			if (compare(s, "create"))
-			{
-				std::string seconds=getword(cmd, "10000");
-				if (autop) delete autop;
-				std::string top = getword(cmd, ::topic.c_str());
-				autos[who] = new automatic(who, atol(seconds.c_str()));
-				autos[who]->topic(top);
-				autos[who]->bon=true;
-				Serial << "New auto (" << seconds.c_str() << " topic:" << top.c_str() << ')' << endl;
-			}
-			else if (autop)
-			{
-				while(s.length())
-				{
-					if (s=="on")
-					{
-						autop->bon = true;
-						autop->interval(autop->interval_);
-					}
-					else if (s=="off")
-						autop->bon=false;
-					else if (s=="interval")
-					{
-						int32_t i=getint(cmd);
-						if (i)
-							autop->interval(atol(s.c_str()));
-						else
-							Serial << "Bad value" << endl;
-					}
-				  else if (s=="view")
-					{
-						Serial << "  automatic "
-							<< (int32_t)autop->client
-							<< " interval " << autop->interval_
-							<< (autop->bon ? " on" : " off") << endl;
-					}
-					else
-					{
-						Serial << "Unknown auto command (" << s.c_str() << ")" << endl;
-						break;
-					}
-					s=getword(cmd);
-				}
-			}
-			else if (who==nullptr)
-			{
-				for(auto it: autos)
-					command(it.first, s+' '+cmd);
-			}
-			else
-				Serial << "what ? (" << s.c_str() << ")" << endl;
-		}
-
-		static void help()
-		{
-					Serial << "    auto [$id] on/off" << endl;
-					Serial << "    auto [$id] view" << endl;
-					Serial << "    auto [$id] interval [s]" << endl;
-					Serial << "    auto [$id] create [millis] [topic]" << endl;
-		}
-
-	private:
-		MqttClient* client;
-		uint32_t interval_;
-		uint32_t timer_;
-		std::string topic_;
-		bool bon=false;
-		static std::map<MqttClient*, automatic*> autos;
-		float temp=19;
-};
-std::map<MqttClient*, automatic*> automatic::autos;
-
 bool compare(std::string s, const char* cmd)
 {
  uint8_t p=0;
@@ -332,15 +314,22 @@ struct Every
  std::string cmd;
  uint32_t ms;
  uint32_t next;
+  uint32_t underrun=0;
+  bool active=true;

  void dump()
  {
-		auto mill=millis();
-		Serial << ms << "ms [" << cmd << "] next in ";
-		if (mill > next)
-			Serial << "now";
+    if (active)
+      Console << green << "enabled";
    else
-			Serial << next-mill << "ms";
+      Console << red << "disabled";
+
+    auto mill=millis();
+    Console << white << ms << "ms [" << cmd << "] next in ";
+    if (mill > next)
+      Console << "now";
+    else
+      Console << next-mill << "ms";
  }
 };

@@ -352,6 +341,34 @@ int16_t blink;

 std::vector<Every> everies;

+void onCommand(const std::string& command)
+{
+  Console << endl;
+  std::string cmd=command;
+  if (cmd.substr(0,3)!="set") replaceVars(cmd);
+  eval(cmd);
+  Console << endl;
+  Console.prompt();
+}
+
+void clientConnect(MqttClient* client, std::string& cmd)
+{
+  std::string remote = getword(cmd);
+  uint16_t port;
+  auto it=list.find(remote);
+  if (it != list.end())
+  {
+    Console << "Connecting to free broker: " << remote << endl;
+    remote = it->second.url;
+    port=it->second.port;
+  }
+  else
+    port=getint(cmd);
+
+  client->connect(remote.c_str(), port, getint(cmd, 60));
+  Console << (client->connected() ? "connected." : "not connected") << endl;
+}
+
 void eval(std::string& cmd)
 {
  while(cmd.length())
@@ -363,7 +380,6 @@ void eval(std::string& cmd)
    MqttClient* client = nullptr;

    // client.function notation
-		// ("a.fun " becomes "fun a ")
    if (cmd.find('.') != std::string::npos &&
        cmd.find('.') < cmd.find(' '))
    {
@@ -381,16 +397,32 @@ void eval(std::string& cmd)
        }
        else
        {
-					Serial << "Unknown class (" << s.c_str() << ")" << endl;
-					cmd="";
+          Console << red << "Unknown class (" << s.c_str() << ")" << white << endl;
+          cmd.clear();
        }
      }
    }

    s = getword(cmd);
-		if (s.length()) getCommand(s);
+    if (s.length()) convertToCommand(s);
    if (s.length()==0)
    {}
+    else if (compare(s, "debug"))
+    {
+#if TINY_MQTT_DEBUG
+      TinyMqtt::debug = getint(cmd);
+#else
+      Console << red << "TinyMqtt not compiled in debug" << endl;
+#endif
+    }
+    else if (compare(s, "list"))
+    {
+      Console << "List of free servers" << endl;
+      for(const auto& fb: list)
+      {
+        Console << "  " << fb.first << " : " << fb.second.url << ":" << fb.second.port << endl;
+      }
+    }
    else if (compare(s, "delete"))
    {
      if (client==nullptr && broker==nullptr)
@@ -405,14 +437,14 @@ void eval(std::string& cmd)
          broker = brokers[s];
        }
        else
-					Serial << "Unable to find (" << s.c_str() << ")" << endl;
+          Console << red << "Unable to find (" << s.c_str() << ")" << white << endl;
      }
      if (client)
      {
        for (auto it: clients)
        {
          if (it.second != client) continue;
-					Serial << "deleted" << endl;
+          Console << "deleted" << endl;
          delete (it.second);
          clients.erase(it.first);
          break;
@@ -424,7 +456,7 @@ void eval(std::string& cmd)
        for(auto it: brokers)
        {
          if (broker != it.second) continue;
-					Serial << "deleted" << endl;
+          Console << "deleted" << endl;
          delete (it.second);
          brokers.erase(it.first);
          break;
@@ -432,44 +464,51 @@ void eval(std::string& cmd)
        cmd += " ls";
      }
      else
-				Serial << "Nothing to delete" << endl;
+        Console << "Nothing to delete" << endl;
    }
    else if (broker)
    {
      if (compare(s,"connect"))
      {
-				Serial << "NYI" << endl;
+        Console << "NYI" << endl;
      }
      else if (compare(s, "view"))
      {
        broker->dump();
      }
+      else
+      {
+        Console << "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;
+        clientConnect(client, cmd);
      }
      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), getword(cmd));
      }
      else if (compare(s,"subscribe"))
      {
-				client->subscribe(getword(cmd, topic.c_str()));
+        client->subscribe(getword(cmd));
      }
      else if (compare(s, "unsubscribe"))
      {
-				client->unsubscribe(getword(cmd, topic.c_str()));
+        client->unsubscribe(getword(cmd));
      }
      else if (compare(s, "view"))
      {
        client->dump();
      }
+      else
+      {
+        Console << "Unknown client command (" << s << ")" << endl;
+        s.clear();
+      }
    }
    else if (compare(s, "on"))
    {
@@ -483,10 +522,28 @@ void eval(std::string& cmd)
      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
+      {
+        Console << s << ' ';
+        while(cmd.length())
+        {
+          Console << getword(cmd) << ' ';
+        }
+      }
+    }
    else if (compare(s, "every"))
    {
      uint32_t ms = getint(cmd, 0);
-			if (ms and cmd.length())
+      if (ms)
+      {
+        if (cmd.length())
        {
          Every every;
          every.ms=ms;
@@ -494,27 +551,53 @@ void eval(std::string& cmd)
          every.next=millis()+ms;
          everies.push_back(every);
          every.dump();
-				Serial << endl;
-				cmd="";
+          Console << endl;
+          cmd.clear();
        }
-			else if (ms==0 and compare(cmd, "list"))
+      }
+      else if (compare(cmd, "off") or compare(cmd, "on"))
      {
-				getword(cmd);
-				Serial << "List of everies (ms=" << millis() << ")" << endl;
+        bool active=getword(cmd)=="on";
+        uint8_t ever=getint(cmd, 100);
        uint8_t count=0;
        for(auto& every: everies)
        {
-					Serial << count << ": ";
-					every.dump();
-					Serial << endl;
+          if (count==ever or (ever==100))
+          {
+            if (every.active != active)
+            {
+              Console << "every #" << count << (active ? " on" :" off") << endl;
+              every.active = active;
+              every.underrun = 0;
+            }
+          }
          count++;
        }
      }
-			else if (ms==0 and compare(cmd, "remove"))
+      else if (compare(cmd, "list") or cmd.length()==0)
      {
+        getword(cmd);
+        Console << "List of everies (ms=" << millis() << ")" << endl;
+        uint8_t count=0;
+        for(auto& every: everies)
+        {
+          Console << count << ": ";
+          every.dump();
+          Console << endl;
+          count++;
+        }
+      }
+      else if (compare(cmd, "remove"))
+      {
+        Console << "Removing..." << endl;
        getword(cmd);
        int8_t every=getint(cmd, -1);
-				if (every==-1 and compare(cmd, "all"))
+        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();
@@ -523,7 +606,11 @@ void eval(std::string& cmd)
        {
          everies.erase(everies.begin()+every);
        }
+        else
+          Console << "Bad colmmand" << endl;
      }
+      else
+        Console << "Bad command" << endl;
    }
    else if (compare(s, "blink"))
    {
@@ -534,7 +621,7 @@ void eval(std::string& cmd)
        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;
+        Console << "Blink " << blink_nr << ' ' << (blink_ms_on[blink_nr] ? "on" : "off") << endl;
        if (blink_ms_on[blink_nr])
          blink |= 1<< blink_nr;
        else
@@ -543,16 +630,15 @@ void eval(std::string& cmd)
        }
      }
    }
-		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())
+      if (clients.find(id) != clients.end())
+      {
+        Console << "A client already have that name" << endl;
+        cmd.clear();
+      }
+      else if (id.length() or brokers.find(id)!=brokers.end())
      {
        int port=getint(cmd, 0);
        if (port)
@@ -561,40 +647,56 @@ void eval(std::string& cmd)
          broker->begin();

          brokers[id] = broker;
-					Serial << "new broker (" << id.c_str() << ")" << endl;
+          Console << "new broker (" << id.c_str() << ")" << endl;
        }
        else
-					Serial << "Missing port" << endl;
+        {
+          Console << "Missing port" << endl;
+          cmd.clear();
+        }
      }
      else
-				Serial << "Missing or existing broker name (" << id.c_str() << ")" << endl;
-			cmd+=" ls";
+      {
+        Console << "Missing or existing broker name (" << id.c_str() << ")" << endl;
+        cmd.clear();
+      }
    }
    else if (compare(s, "client"))
    {
      std::string id=getword(cmd);
-			if (id.length() or clients.find(id)!=clients.end())
+      if (brokers.find(id) != brokers.end())
      {
-				s=getword(cmd);	// broker name
-				if (s=="" or brokers.find(s) != brokers.end())
+        Console << "A broker have that name" << endl;
+        cmd.clear();
+      }
+      else if (id.length() or clients.find(id)!=clients.end())
+      {
+        s=getword(cmd);  // broker
+        if (s=="" or brokers.find(s) != brokers.end() or list.find(s) != list.end())
        {
          MqttBroker* broker = nullptr;
          if (s.length()) broker = brokers[s];
-					MqttClient* client = new MqttClient(broker);
-					client->id(id);
+          MqttClient* client = new MqttClient(broker, id);
          clients[id]=client;
          client->setCallback(onPublish);
-					client->subscribe(topic);
-					Serial << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
+          if (list.find(s) != list.end())
+          {
+            cmd=s+' '+cmd;
+            clientConnect(client, cmd);
+          }
+          Console << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
        }
        else if (s.length())
        {
-					Serial << " not found." << endl;
+          Console << " not found." << endl;
+          cmd.clear();
        }
      }
      else
-				Serial << "Missing or existing client name" << endl;
-			cmd+=" ls";
+      {
+        Console << "Missing or existing client name" << endl;
+        cmd.clear();
+      }
    }
    else if (compare(s, "set"))
    {
@@ -603,12 +705,12 @@ void eval(std::string& cmd)
      {
        for(auto it: vars)
        {
-					Serial << "  " << it.first << " -> " << it.second << endl;
+          Console << "  " << it.first << " -> " << it.second << endl;
        }
      }
      else if (commands.find(name) != commands.end())
      {
-				Serial << "Reserved keyword (" << name << ")" << endl;
+        Console << "Reserved keyword (" << name << ")" << endl;
        cmd.clear();
      }
      else
@@ -624,61 +726,76 @@ void eval(std::string& cmd)
    }
    else if (compare(s, "ls") or compare(s, "view"))
    {
-			Serial << "--< " << clients.size() << " client/s. >--" << endl;
+      bool view = compare(s, "view");
+      if (view)
+      {
+        Console << save_cursor << magenta;
+        Console.gotoxy(1,1);
+      }
+      Console << "--< " << '/' << clients.size() << " client/s. >--" << erase_to_end << endl;
      for(auto it: clients)
      {
-				Serial << "  "; it.second->dump();
+        it.second->dump("  ");
      }

-			Serial << "--< " << brokers.size() << " brokers/s. >--" << endl;
+      Console << "--< " << brokers.size() << " brokers/s. >--" << erase_to_end << endl;
      for(auto it: brokers)
      {
-				Serial << " ==[ Broker: " << it.first.c_str() << " ]== ";
-				it.second->dump();
+        Console << "  +-- '" << it.first.c_str() << "' " << it.second->clientsCount() << " client/s."<< erase_to_end << endl;
+        it.second->dump("     ");
+      }
+      if (view)
+      {
+        Console.bg(white);
+        Console << erase_to_end << restore_cursor;
      }
    }
    else if (compare(s, "reset"))
      ESP.restart();
    else if (compare(s, "ip"))
-			Serial << "IP: " << WiFi.localIP() << endl;
+      Console << "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 << "  every ms [command]; every list; every remove [nr|all]" << endl;
-			Serial << "  on {output}; off {output}" << endl;
-			Serial << "  $id : name of the client." << endl;
-			Serial << "  default topic is '" << topic.c_str() << "'" << endl;
-			Serial << endl;
+      Console << "syntax:" << endl;
+      Console << "  MqttBroker:" << endl;
+      Console << "    broker {broker_name} {port} : create a new broker" << endl;
+      Console << "      broker_name can be one of 'list'" << endl;
+      Console << "      broker_name.delete : delete a broker (buggy)" << endl;
+      Console << "      broker_name.view   : dump a broker" << endl;
+      Console << endl;
+      Console << "  MqttClient:" << endl;
+      Console << "    client {name} {broker} : create a client then" << endl;
+      Console << "      name.connect  [ip] [port] [alive]" << endl;
+      Console << "      name.[un]subscribe topic" << endl;
+      Console << "      name.publish topic [payload]" << endl;
+      Console << "      name.view" << endl;
+      Console << "      name.delete" << endl;
+      Console << endl;
+      Console << "  list : list of free brokers (debug 1 advised)" << endl;
+      Console << "  debug #" << endl;
+      Console << "  list : get list of free brokers" << endl;
+      Console << "  blink [Dx on_ms off_ms]    : make pin blink" << endl;
+      Console << "  ls / ip / reset" << endl;
+      Console << "  set [name][value]" << endl;
+      Console << "  !  repeat last command" << endl;
+      Console << endl;
+      Console << "  echo [on|off] or strings" << endl;
+      Console << "  every ms [command]; every list; every remove [nr|all]; every (on|off) [#]" << endl;
+      Console << "  on {output}; off {output}" << endl;
+      Console << "  $id : name of the client." << endl;
+      Console << "  rnd[(min[,max])] random number." << endl;
+      Console << endl;
    }
    else
    {
      while(s[0]==' ') s.erase(0,1);
      if (s.length())
-				Serial << "Unknown command (" << s.c_str() << ")" << endl;
+        Console << "Unknown command (" << s.c_str() << ")" << endl;
    }

    if (retval != MqttOk)
    {
-			Serial << "## ERROR " << retval << endl;
+      Console << "# MQTT ERROR " << retval << endl;
    }
  }
 }
@@ -688,16 +805,25 @@ 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)
+      {
+        every.next += every.ms;
+        Console << yellow << "Underrun every #" << e << ", " <<  (ms - every.next) << "ms late" << endl;
+        every.underrun = ms+5000;
      }
    }
+    e++;
+  }

  while(blink_bits)
  {
@@ -720,41 +846,15 @@ void loop()
  }

  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 (c==10 or c==14)
-		{
-			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;
-		}
-	}
+  Console.loop();
 }
--- a/library.json
+++ b/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"
-    ]
-}
--- a/library.properties
+++ b/library.properties
@@ -1,11 +1,11 @@
 name=TinyMqtt
-version=0.7.3
+version=0.9.9
 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=*
+depends=TinyConsole
 includes=TinyMqtt.h
-depends=AsyncTCP
--- a/src/MqttStreaming.h
+++ b/src/MqttStreaming.h
@@ -1,412 +0,0 @@
-/* MqttStreaming.h - Fork of Streaming.h adding std::string and with some minor fixes
- * (I have to speek to the author in order to include my changes to his library if possible)
- **/
-
-/*
-  Streaming.h - Arduino library for supporting the << streaming operator
-  Copyright (c) 2010-2012 Mikal Hart.  All rights reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-/*
-  Version 6 library changes
-    Copyright (c) 2019 Gazoodle. All rights reserved.
-
-  1.  _BASED moved to template to remove type conversion to long and
-      sign changes which break int8_t and int16_t negative numbers. 
-      The print implementation still upscales to long for it's internal
-      print routine.
-
-  2.  _PAD added to allow padding & filling of characters to the stream
-
-  3.  _WIDTH & _WIDTHZ added to allow width printing with space padding
-      and zero padding for numerics
-
-  4.  Simple _FMT mechanism ala printf, but without the typeunsafetyness 
-      and no internal buffers for replaceable stream printing
-*/
-
-#ifndef ARDUINO_STREAMING
-#define ARDUINO_STREAMING
-
-#if defined(ARDUINO) && ARDUINO >= 100
-#include "Arduino.h"
-#else
-#ifndef STREAMING_CONSOLE
-#include "WProgram.h"
-#endif
-#endif
-
-#include <string>
-
-#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR)
-// No stl library, so need trivial version of std::is_signed ...
-namespace std {
-template<typename T>
-  struct is_signed { static const bool value = false; };
-  template<>
-  struct is_signed<int8_t> { static const bool value = true; };
-  template<>
-  struct is_signed<int16_t> { static const bool value = true; };
-  template<>
-  struct is_signed<int32_t> { static const bool value = true; };
-};
-#else
-#include <type_traits>
-#endif
-
-#define STREAMING_LIBRARY_VERSION 6
-
-#if !defined(typeof)
-#define typeof(x) __typeof__(x)
-#endif
-
-// PrintBuffer implementation of Print, a small buffer to print in
-// see its use with pad_float()
-template <size_t N>
-class PrintBuffer : public Print
-{
-  size_t  pos = 0;
-  char    str[N] {};
-public:
-  inline const char *operator() () 
-  { return str; };
-  
-  // inline void clear() 
-  // { pos = 0; str[0] = '\0'; };
-  
-  inline size_t write(uint8_t c) 
-  { return write(&c, 1); };
-  
-  inline size_t write(const uint8_t *buffer, size_t size)
-  {
-    size_t s = std::min(size, N-1 - pos); // need a /0 left
-    if (s)
-    {
-      memcpy(&str[pos], buffer, s);
-      pos += s;
-    }
-    return s;
-  };
-};
-
-// Generic template
-template<class T>
-inline Print &operator <<(Print &stream, const T &arg)
-{ stream.print(arg); return stream; }
-
-// TODO sfinae maybe could do the trick ?
-inline Print &operator <<(Print &stream, const std::string &str)
-{ stream.print(str.c_str()); return stream; }
-
-template<typename T>
-struct _BASED
-{
-  T val;
-  int base;
-  _BASED(T v, int b): val(v), base(b)
-  {}
-};
-
-#if ARDUINO >= 100
-
-struct _BYTE_CODE
-{
-  byte val;
-  _BYTE_CODE(byte v) : val(v)
-  {}
-};
-#define _BYTE(a)    _BYTE_CODE(a)
-
-inline Print &operator <<(Print &obj, const _BYTE_CODE &arg)
-{ obj.write(arg.val); return obj; }
-
-#else
-
-#define _BYTE(a)    _BASED<typeof(a)>(a, BYTE)
-
-#endif
-
-#define _HEX(a)     _BASED<typeof(a)>(a, HEX)
-#define _DEC(a)     _BASED<typeof(a)>(a, DEC)
-#define _OCT(a)     _BASED<typeof(a)>(a, OCT)
-#define _BIN(a)     _BASED<typeof(a)>(a, BIN)
-
-// Specialization for class _BASED
-// Thanks to Arduino forum user Ben Combee who suggested this
-// clever technique to allow for expressions like
-//   Serial << _HEX(a);
-
-template<typename T>
-inline Print &operator <<(Print &obj, const _BASED<T> &arg)
-{ obj.print(arg.val, arg.base); return obj; }
-
-#if ARDUINO >= 18
-// Specialization for class _FLOAT
-// Thanks to Michael Margolis for suggesting a way
-// to accommodate Arduino 0018's floating point precision
-// feature like this:
-//   Serial << _FLOAT(gps_latitude, 6); // 6 digits of precision
-
-struct _FLOAT
-{
-  double val; // only Print::print(double)
-  int digits;
-  _FLOAT(double v, int d): val(v), digits(d)
-  {}
-};
-
-inline Print &operator <<(Print &obj, const _FLOAT &arg)
-{ obj.print(arg.val, arg.digits); return obj; }
-#endif
-
-// Specialization for enum _EndLineCode
-// Thanks to Arduino forum user Paul V. who suggested this
-// clever technique to allow for expressions like
-//   Serial << "Hello!" << endl;
-
-enum _EndLineCode { endl };
-
-inline Print &operator <<(Print &obj, _EndLineCode)
-{ obj.println(); return obj; }
-
-// Specialization for padding & filling, mainly utilized
-// by the width printers
-//
-//  Use like 
-//    Serial << _PAD(10,' ');   // Will output 10 spaces
-//    Serial << _PAD(4, '0');   // Will output 4 zeros
-struct _PAD
-{
-  int8_t width;
-  char   chr;
-  _PAD(int8_t w, char c) : width(w), chr(c) {}
-};
-
-inline Print &operator <<(Print& stm, const _PAD &arg)
-{
-  for(int8_t i = 0; i < arg.width; i++)
-    stm.print(arg.chr);
-  return stm;
-}
-
-// Specialization for width printing
-//
-//    Use like                            Result
-//    --------                            ------
-//    Serial << _WIDTH(1,5)               "    1"
-//    Serial << _WIDTH(10,5)              "   10"
-//    Serial << _WIDTH(100,5)             "  100"
-//    Serial << _WIDTHZ(1,5)              "00001"
-//
-//  Great for times & dates, or hex dumps
-//
-//    Serial << _WIDTHZ(hour,2) << ':' << _WIDTHZ(min,2) << ':' << _WIDTHZ(sec,2)
-//
-//    for(int index=0; index<byte_array_size; index++)
-//      Serial << _WIDTHZ(_HEX(byte_array[index]))
-
-template<typename T>
-struct __WIDTH
-{
-  const T val;
-  int8_t width;
-  char pad;
-  __WIDTH(const T& v, int8_t w, char p) : val(v), width(w), pad(p) {}
-};
-
-//  Count digits in an integer of specific base
-template<typename T>
-inline uint8_t digits(T v, int8_t base = 10)
-{
-  uint8_t digits = 0;
-  if ( std::is_signed<T>::value )
-  {
-    if ( v < 0 )
-    {
-      digits++;
-      v = -v; // v needs to be postive for the digits counter to work
-    }
-  }
-  do
-  {
-    v /= base;
-    digits++;
-  } while( v > 0 );
-  return digits;
-}
-
-// Generic get the width of a value in base 10
-template<typename T>
-inline uint8_t get_value_width(T val)
-{ return digits(val); }
-
-inline uint8_t get_value_width(const char * val)
-{ return strlen(val); }
-
-#ifdef ARDUINO
-inline uint8_t get_value_width(const __FlashStringHelper * val)
-{ return strlen_P(reinterpret_cast<const char *>(val)); }
-#endif
-
-// _BASED<T> get the width of a value
-template<typename T>
-inline uint8_t get_value_width(_BASED<T> b)
-{ return digits(b.val, b.base); }
-
-// Constructor wrapper to allow automatic template parameter deduction
-template<typename T>
-__WIDTH<T> _WIDTH(T val, int8_t width) { return __WIDTH<T>(val, width, ' '); }
-template<typename T>
-__WIDTH<T> _WIDTHZ(T val, int8_t width) { return __WIDTH<T>(val, width, '0'); }
-
-
-// Operator overload to handle width printing.
-template<typename T>
-inline Print &operator <<(Print &stm, const __WIDTH<T> &arg)
-{ stm << _PAD(arg.width - get_value_width(arg.val), arg.pad) << arg.val; return stm; }
-
-// explicit Operator overload to handle width printing of _FLOAT, double and float
-template<typename T>
-inline Print &pad_float(Print &stm, const __WIDTH<T> &arg, const double val, const int digits = 2) // see Print::print(double, int = 2)
-{
-  PrintBuffer<32> buf; // it's only ~45B on the stack, no allocation, leak or fragmentation
-  size_t size = buf.print(val, digits); // print in buf
-  return stm << _PAD(arg.width - size, arg.pad) << buf(); // pad and concat what's in buf
-}
-
-inline Print &operator <<(Print &stm, const __WIDTH<float>  &arg) 
-{ return pad_float(stm, arg, arg.val); }
-
-inline Print &operator <<(Print &stm, const __WIDTH<double> &arg) 
-{ return pad_float(stm, arg, arg.val); } 
-
-inline Print &operator <<(Print &stm, const __WIDTH<_FLOAT> &arg) 
-{ auto& f = arg.val; return pad_float(stm, arg, f.val, f.digits); }
-
-// a less verbose _FLOATW for _WIDTH(_FLOAT)
-#define _FLOATW(val, digits, width) _WIDTH<_FLOAT>(_FLOAT((val), (digits)), (width))
-
-// Specialization for replacement formatting
-//
-//  Designed to be similar to printf that everyone knows and loves/hates. But without
-//  the internal buffers and type agnosticism. This version only has placeholders in
-//  the format string, the actual values are supplied using the stream safe operators
-//  defined in this library.
-//
-//  Use like this:
-//
-//      Serial << FMT(F("Replace % with %"), 1, 2 )
-//      Serial << FMT("Time is %:%:%", _WIDTHZ(hours,2), _WIDTHZ(minutes,2), _WIDTHZ(seconds,2))
-//      Serial << FMT("Your score is %\\%", score);   // Note the \\ to escape the % sign
-
-// Ok, hold your hats. This is a foray into C++11's variadic template engine ...
-
-inline char get_next_format_char(const char *& format_string)
-{
-  char format_char = *format_string;
-  if ( format_char > 0 ) format_string++;
-  return format_char;
-}
-
-#ifdef ARDUINO
-inline char get_next_format_char(const __FlashStringHelper*& format_string)
-{
-  char format_char = pgm_read_byte(format_string);
-  if ( format_char > 0 ) format_string = reinterpret_cast<const __FlashStringHelper*>(reinterpret_cast<const char *>(format_string)+1);
-  return format_char;
-}
-#endif
-
-template<typename Ft>
-inline bool check_backslash(char& format_char, Ft& format_string)
-{
-  if ( format_char == '\\')
-  {
-    format_char = get_next_format_char(format_string);
-    return true;
-  }
-  return false;
-}
-
-// The template tail printer helper
-template<typename Ft, typename... Ts>
-struct __FMT
-{
-  Ft format_string;
-  __FMT(Ft f, Ts ... args) : format_string(f) {}
-  inline void tstreamf(Print& stm, Ft format) const
-  {
-    while(char c = get_next_format_char(format))
-    {
-      check_backslash(c, format);
-      if ( c )
-        stm.print(c);
-    }
-  }
-};
-
-// The variadic template helper
-template<typename Ft, typename T, typename... Ts>
-struct __FMT<Ft, T, Ts...> : __FMT<Ft, Ts...>
-{
-  T val;
-  __FMT(Ft f, T t, Ts... ts) : __FMT<Ft, Ts...>(f, ts...), val(t) {}
-  inline void tstreamf(Print& stm, Ft format) const
-  {
-    while(char c = get_next_format_char(format))
-    {
-      if (!check_backslash(c, format))
-      {
-        if ( c == '%')
-        {
-          stm << val;
-          // Variadic recursion ... compiler rolls this out during 
-          // template argument pack expansion
-          __FMT<Ft, Ts...>::tstreamf(stm, format);
-          return;
-        }
-      }
-      if (c)
-        stm.print(c);
-    }
-  }
-};
-
-// The actual operator should you only instanciate the FMT 
-// helper with a format string and no parameters
-template<typename Ft, typename... Ts>
-inline Print& operator <<(Print &stm, const __FMT<Ft, Ts...> &args)
-{
-    args.tstreamf(stm, args.format_string);
-    return stm;
-}
-
-// The variadic stream helper
-template<typename Ft, typename T, typename... Ts>
-inline Print& operator <<(Print &stm, const __FMT<Ft, T, Ts...> &args)
-{
-    args.tstreamf(stm, args.format_string);
-    return stm;
-}
-
-// As we don't have C++17, we can't get a constructor to use
-// automatic argument deduction, but ... this little trick gets
-// around that ...
-template<typename Ft, typename... Ts>
-__FMT<Ft, Ts...> _FMT(Ft format, Ts ... args) { return __FMT<Ft, Ts...>(format, args...); }
-
-#endif
--- a/src/StringIndexer.h
+++ b/src/StringIndexer.h
@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once
 #include <map>
 #include <string>
@@ -28,29 +29,6 @@ class StringIndexer
  public:
    using index_t = uint8_t;

-		static index_t strToIndex(const char* str, uint8_t len)
-		{
-			for(auto it=strings.begin(); it!=strings.end(); it++)
-			{
-				if (strncmp(it->second.str.c_str(), str, len)==0)
-				{
-					it->second.used++;
-					return it->first;
-				}
-			}
-			for(index_t index=1; index; index++)
-			{
-				if (strings.find(index)==strings.end())
-				{
-					strings[index].str = std::string(str, len);
-					strings[index].used++;
-					// Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
-					return index;
-				}
-			}
-			return 0;	// TODO out of indexes
-		}
-
   static const std::string& str(const index_t& index)
    {
      static std::string dummy;
@@ -82,6 +60,32 @@ class StringIndexer
    static uint16_t count() { return strings.size(); }

  private:
+    friend class IndexedString;
+
+    // increment use of str or create a new index
+    static index_t strToIndex(const char* str, uint8_t len)
+    {
+      for(auto it=strings.begin(); it!=strings.end(); it++)
+      {
+        if (it->second.str.length() == len && strcmp(it->second.str.c_str(), str)==0)
+        {
+          it->second.used++;
+          return it->first;
+        }
+      }
+      for(index_t index=1; index; index++)
+      {
+        if (strings.find(index)==strings.end())
+        {
+          strings[index].str = std::string(str, len);
+          strings[index].used++;
+          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
+          return index;
+        }
+      }
+      return 0;  // TODO out of indexes
+    }
+
    static std::map<index_t, StringCounter> strings;
 };

--- a/src/TinyMqtt.cpp
+++ b/src/TinyMqtt.cpp
@@ -1,18 +1,24 @@
+// vim: ts=2 sw=2 expandtab
 #include "TinyMqtt.h"
 #include <sstream>

-void outstring(const char* prefix, const char*p, uint16_t len)
-{
-	return;
-	Serial << prefix << "='";
-	while(len--) Serial << (char)*p++;
-	Serial << '\'' << endl;
-}
+#if TINY_MQTT_DEBUG
+static auto cyan = TinyConsole::cyan;
+static auto white = TinyConsole::white;
+static auto red = TinyConsole::red;
+static auto yellow = TinyConsole::yellow;
+
+int TinyMqtt::debug=2;
+#endif
+
+#ifdef EPOXY_DUINO
+  std::map<MqttMessage::Type, int> MqttClient::counters;
+#endif

 MqttBroker::MqttBroker(uint16_t port)
 {
  server = new TcpServer(port);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
  server->onClient(onClient, this);
 #endif
 }
@@ -27,10 +33,11 @@ MqttBroker::~MqttBroker()
 }

 // private constructor used by broker only
-MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
-	: parent(parent)
+MqttClient::MqttClient(MqttBroker* local_broker, TcpClient* new_client)
+  : local_broker(local_broker)
 {
-#ifdef TCP_ASYNC
+  debug("MqttClient private with broker");
+#ifdef TINY_MQTT_ASYNC
  client = new_client;
  client->onData(onData, this);
  // client->onConnect() TODO
@@ -38,15 +45,19 @@ MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
 #else
  client = new WiFiClient(*new_client);
 #endif
-	alive = millis()+5000;	// client expires after 5s if no CONNECT msg
+#ifdef EPOXY_DUINO
+  alive = millis()+500000;
+#else
+  alive = millis()+5000;  // TODO MAGIC client expires after 5s if no CONNECT msg
+#endif
 }

-MqttClient::MqttClient(MqttBroker* parent, const std::string& id)
-	: parent(parent), clientId(id)
+MqttClient::MqttClient(MqttBroker* local_broker, const std::string& id)
+  : local_broker(local_broker), clientId(id)
 {
    client = nullptr;

-		if (parent) parent->addClient(this);
+    if (local_broker) local_broker->addClient(this);
 }

 MqttClient::~MqttClient()
@@ -59,58 +70,73 @@ 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())
    {
      message.create(MqttMessage::Type::Disconnect);
+      message.hexdump("close");
      message.sendTo(this);
    }
    client->stop();
  }

-	if (parent)
+  if (local_broker)
  {
-		parent->removeClient(this);
-		parent=nullptr;
+    local_broker->removeClient(this);
+    local_broker = nullptr;
  }
 }

+void MqttClient::connect(MqttBroker* local)
+{
+  debug("MqttClient::connect_local");
+  close();
+  local_broker = local;
+}
+
 void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
 {
-	debug("cnx: closing");
+  debug("MqttClient::connect_to_host " << broker << ':' << port);
  keep_alive = ka;
  close();
  if (client) delete client;
  client = new TcpClient;

-	debug("Trying to connect to " << broker.c_str() << ':' << port);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
  client->onData(onData, this);
  client->onConnect(onConnect, this);
-	client->connect(broker.c_str(), port);
+  client->connect(broker.c_str(), port, ka);
 #else
  if (client->connect(broker.c_str(), port))
  {
+    debug("link established");
    onConnect(this, client);
  }
+  else
+  {
+    debug("unable to connect.");
+  }
 #endif
 }

 void MqttBroker::addClient(MqttClient* client)
 {
+  debug("MqttBroker::addClient");
  clients.push_back(client);
 }

 void MqttBroker::connect(const std::string& host, uint16_t port)
 {
+  debug("MqttBroker::connect");
  if (broker == nullptr) broker = new MqttClient;
  broker->connect(host, port);
-	broker->parent = this;	// Because connect removed the link
+  broker->local_broker = this;  // Because connect removed the link
 }

 void MqttBroker::removeClient(MqttClient* remove)
 {
+  debug("removeClient");
  for(auto it=clients.begin(); it!=clients.end(); it++)
  {
    auto client=*it;
@@ -127,11 +153,12 @@ void MqttBroker::removeClient(MqttClient* remove)
      return;
    }
  }
-	debug("Error cannot remove client");	// TODO should not occur
+  debug(red << "Error cannot remove client");  // TODO should not occur
 }

 void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
 {
+  debug("MqttBroker::onClient");
  MqttBroker* broker = static_cast<MqttBroker*>(broker_ptr);

  broker->addClient(new MqttClient(broker, client));
@@ -140,7 +167,7 @@ void MqttBroker::onClient(void* broker_ptr, TcpClient* client)

 void MqttBroker::loop()
 {
-#ifndef TCP_ASYNC
+#ifndef TINY_MQTT_ASYNC
  WiFiClient client = server->available();

  if (client)
@@ -167,7 +194,7 @@ void MqttBroker::loop()
    }
    else
    {
-      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (dbg_ptr)client->parent);
+      debug("Client " << client->id().c_str() << "  Disconnected, local_broker=" << (dbg_ptr)client->local_broker);
      // Note: deleting a client not added by the broker itself will probably crash later.
      delete client;
      break;
@@ -177,6 +204,7 @@ void MqttBroker::loop()

 MqttError MqttBroker::subscribe(const Topic& topic, uint8_t qos)
 {
+  debug("MqttBroker::subscribe");
  if (broker && broker->connected())
  {
    return broker->subscribe(topic, qos);
@@ -184,17 +212,17 @@ MqttError MqttBroker::subscribe(const Topic& topic, uint8_t 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;

-	debug("publish ");
+  debug("MqttBroker::publish");
  int i=0;
  for(auto client: clients)
  {
    i++;
-#ifdef TINY_MQTT_DEBUG
-		Serial << "brk_" << (broker && broker->connected() ? "con" : "dis") <<
+#if TINY_MQTT_DEBUG
+    Console << __LINE__ << " broker:" << (broker && broker->connected() ? "linked" : "alone") <<
       "  srce=" << (source->isLocal() ? "loc" : "rem") << " clt#" << i << ", local=" << client->isLocal() << ", con=" << client->connected() << endl;
 #endif
    bool doit = false;
@@ -214,8 +242,8 @@ MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, cons
    {
      doit = true;
    }
-#ifdef TINY_MQTT_DEBUG
-		Serial << ", doit=" << doit << ' ';
+#if TINY_MQTT_DEBUG
+    Console << ", doit=" << doit << ' ';
 #endif

    if (doit) retval = client->publishIfSubscribed(topic, msg);
@@ -236,15 +264,20 @@ bool MqttBroker::compareString(

 void MqttMessage::getString(const char* &buff, uint16_t& len)
 {
-	len = (buff[0]<<8)|(buff[1]);
+  len = getSize(buff);
  buff+=2;
 }

 void MqttClient::clientAlive(uint32_t more_seconds)
 {
+  debug("MqttClient::clientAlive");
  if (keep_alive)
  {
+#ifdef EPOXY_DUINO
+    alive=millis()+500000+0*more_seconds;
+#else
    alive=millis()+1000*(keep_alive+more_seconds);
+#endif
  }
  else
    alive=0;
@@ -254,11 +287,11 @@ void MqttClient::loop()
 {
  if (alive && (millis() > alive))
  {
-		if (parent)
+    if (local_broker)
    {
-			debug("timeout client");
+      debug(red << "timeout client");
      close();
-			debug("closed");
+      debug(red << "closed");
    }
    else if (client && client->connected())
    {
@@ -271,7 +304,7 @@ void MqttClient::loop()
      // there is no need to send one PingReq per instance.
    }
  }
-#ifndef TCP_ASYNC
+#ifndef TINY_MQTT_ASYNC
  while(client && client->available()>0)
  {
    message.incoming(client->read());
@@ -287,24 +320,24 @@ void MqttClient::loop()
 void MqttClient::onConnect(void *mqttclient_ptr, TcpClient*)
 {
  MqttClient* mqtt = static_cast<MqttClient*>(mqttclient_ptr);
-	debug("cnx: connecting");
+  debug("MqttClient::onConnect");
  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((char)(mqtt->keep_alive >> 8));   // keep_alive
+  msg.add((char)(mqtt->keep_alive & 0xFF));
  msg.add(mqtt->clientId);
  debug("cnx: mqtt connecting");
  msg.sendTo(mqtt);
  msg.reset();
-	debug("cnx: mqtt sent " << (dbg_ptr)mqtt->parent);
+  debug("cnx: mqtt sent " << (dbg_ptr)mqtt->local_broker);

  mqtt->clientAlive(0);
 }

-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
 void MqttClient::onData(void* client_ptr, TcpClient*, void* data, size_t len)
 {
  char* char_ptr = static_cast<char*>(data);
@@ -344,29 +377,30 @@ void MqttClient::resubscribe()

 MqttError MqttClient::subscribe(Topic topic, uint8_t qos)
 {
-	debug("subsribe(" << topic.c_str() << ")");
+  debug("MqttClient::subsribe(" << topic.c_str() << ")");
  MqttError ret = MqttOk;

   subscriptions.insert(topic);

-	if (parent==nullptr) // remote broker
+  if (local_broker==nullptr) // remote broker
  {
    return sendTopic(topic, MqttMessage::Type::Subscribe, qos);
  }
  else
  {
-		return parent->subscribe(topic, qos);
+    return local_broker->subscribe(topic, qos);
  }
  return ret;
 }

 MqttError MqttClient::unsubscribe(Topic topic)
 {
+  debug("MqttClient::unsubscribe");
  auto it=subscriptions.find(topic);
  if (it != subscriptions.end())
  {
    subscriptions.erase(it);
-		if (parent==nullptr) // remote broker
+    if (local_broker==nullptr) // remote broker
    {
      return sendTopic(topic, MqttMessage::Type::UnSubscribe, 0);
    }
@@ -376,6 +410,7 @@ MqttError MqttClient::unsubscribe(Topic topic)

 MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos)
 {
+  debug("MqttClient::sendTopic");
  MqttMessage msg(type, 2);

  // TODO manage packet identifier
@@ -389,24 +424,21 @@ MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint
  return msg.sendTo(this);
 }

-long MqttClient::counter=0;
-
-void MqttClient::processMessage(const MqttMessage* mesg)
+void MqttClient::processMessage(MqttMessage* mesg)
 {
-	counter++;
-#ifdef TINY_MQTT_DEBUG
-if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::Type::PingResp)
-{
-	Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
-	// mesg->hexdump("Incoming");
-}
+#if TINY_MQTT_DEBUG
+  mesg->hexdump("Incoming");
 #endif
  auto header = mesg->getVHeader();
  const char* payload;
  uint16_t len;
  bool bclose=true;

-	switch(mesg->type() & 0XF0)
+#ifdef EPOXY_DUINO
+  counters[mesg->type()]++;
+#endif
+
+  switch(mesg->type())
  {
    case MqttMessage::Type::Connect:
      if (mqtt_connected)
@@ -416,7 +448,7 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      }
      payload = header+10;
      mqtt_flags = header[7];
-			keep_alive = (header[8]<<8)|(header[9]);
+      keep_alive = MqttMessage::getSize(header+8);
      if (strncmp("MQTT", header+2,4))
      {
        debug("bad mqtt header");
@@ -436,28 +468,28 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      if (mqtt_flags & FlagWill)  // Will topic
      {
        mesg->getString(payload, len);  // Will Topic
-				outstring("WillTopic", payload, len);
        payload += len;

        mesg->getString(payload, len);  // Will Message
-				outstring("WillMessage", payload, len);
        payload += len;
      }
      // FIXME forgetting credential is allowed (security hole)
      if (mqtt_flags & FlagUserName)
      {
        mesg->getString(payload, len);
-				if (!parent->checkUser(payload, len)) break;
+        if (not local_broker->checkUser(payload, len)) break;
        payload += len;
      }
      if (mqtt_flags & FlagPassword)
      {
        mesg->getString(payload, len);
-				if (!parent->checkPassword(payload, len)) break;
+        if (not local_broker->checkPassword(payload, len)) break;
        payload += len;
      }

-			Serial << "Connected client:" << clientId.c_str() << ", keep alive=" << keep_alive << '.' << endl;
+      #if TINY_MQTT_DEBUG
+        Console << yellow << "Client " << clientId << " connected : keep alive=" << keep_alive << '.' << white << endl;
+      #endif
      bclose = false;
      mqtt_connected=true;
      {
@@ -491,12 +523,13 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      if (client)
      {
        uint16_t pingreq = MqttMessage::Type::PingResp;
+        debug(cyan << "Ping response to client ");
        client->write((const char*)(&pingreq), 2);
        bclose = false;
      }
      else
      {
-				debug("internal pingreq ?");
+        debug(red << "internal pingreq ?");
      }
      break;

@@ -507,18 +540,25 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
        payload = header+2;
        
        debug("un/subscribe loop");
+        std::string qoss;
        while(payload < mesg->end())
        {
          mesg->getString(payload, len);  // Topic
          debug( "  topic (" << std::string(payload, len) << ')');
-					outstring("  un/subscribes", payload, len);
          // subscribe(Topic(payload, len));
          Topic topic(payload, len);
+
          payload += len;
-					if ((mesg->type() & 0XF0) == MqttMessage::Type::Subscribe)
+          if (mesg->type() == MqttMessage::Type::Subscribe)
          {
            uint8_t qos = *payload++;
-						if (qos != 0) debug("Unsupported QOS" << qos << endl);
+            if (qos != 0)
+            {
+              debug("Unsupported QOS" << qos << endl);
+              qoss.push_back(0x80);
+            }
+            else
+              qoss.push_back(qos);
            subscriptions.insert(topic);
          }
          else
@@ -530,7 +570,12 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
        }
        debug("end loop");
        bclose = false;
-				// TODO SUBACK
+
+        MqttMessage ack(mesg->type() == MqttMessage::Type::Subscribe ? MqttMessage::Type::SubAck : MqttMessage::Type::UnSuback);
+        ack.add(header[0]);
+        ack.add(header[1]);
+        ack.add(qoss.c_str(), qoss.size(), false);
+        ack.sendTo(this);
      }
      break;

@@ -540,31 +585,43 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      break;

    case MqttMessage::Type::Publish:
+      #if TINY_MQTT_DEBUG
+        Console << "publish " << mqtt_connected << '/' << (long) client << endl;
+      #endif
      if (mqtt_connected or client == nullptr)
      {
-				uint8_t qos = mesg->type() & 0x6;
+        uint8_t qos = mesg->flags();
        payload = header;
        mesg->getString(payload, len);
        Topic published(payload, len);
        payload += len;
-				// Serial << "Received Publish (" << published.str().c_str() << ") size=" << (int)len
+        #if TINY_MQTT_DEBUG
+          Console << "Received Publish (" << published.str().c_str() << ") size=" << (int)len << endl;
+        #endif
        // << '(' << std::string(payload, len).c_str() << ')'  << " msglen=" << mesg->length() << endl;
        if (qos) payload+=2;  // ignore packet identifier if any
        len=mesg->end()-payload;
        // TODO reset DUP
        // TODO reset RETAIN

-				if (client==nullptr)	// internal MqttClient receives publish
+        if (local_broker==nullptr or client==nullptr)  // internal MqttClient receives publish
        {
+          #if TINY_MQTT_DEBUG
+            if (TinyMqtt::debug >= 2)
+            {
+              Console << (isSubscribedTo(published) ? "not" : "") << " subscribed.\n";
+              Console << "has " << (callback ? "" : "no ") << " callback.\n";
+            }
+          #endif
          if (callback and isSubscribedTo(published))
          {
            callback(this, published, payload, len);  // TODO send the real payload
          }
        }
-				else if (parent) // from outside to inside
+        else if (local_broker) // from outside to inside
        {
-				  debug("publishing to parent");
-					parent->publish(this, published, *mesg);
+          debug("publishing to local_broker");
+          local_broker->publish(this, published, *mesg);
        }
        bclose = false;
      }
@@ -584,24 +641,82 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
  };
  if (bclose)
  {
-		Serial << "*************** Error msg 0x" << _HEX(mesg->type());
+    #if TINY_MQTT_DEBUG
+      Console << red << "*************** Error msg 0x" << _HEX(mesg->type());
      mesg->hexdump("-------ERROR ------");
      dump();
-		Serial << endl;
+      Console << white << endl;
+    #endif
    close();
  }
  else
  {
-		clientAlive(parent ? 5 : 0);
+    clientAlive(local_broker ? 5 : 0);
  }
 }

 bool Topic::matches(const Topic& topic) const
 {
  if (getIndex() == topic.getIndex()) return true;
-	if (str() == topic.str()) return true;
+  const char* p1 = c_str();
+  const char* p2 = topic.c_str();
+
+  if (p1 == p2) return true;
+  if (*p2 == '$' and *p1 != '$') return false;
+
+  while(*p1 and *p2)
+  {
+    if (*p1 == '+')
+    {
+      ++p1;
+      if (*p1 and *p1!='/') return false;
+      if (*p1) ++p1;
+      while(*p2 and *p2++!='/');
+    }
+    else if (*p1 == '#')
+    {
+      if (*++p1==0) return true;
      return false;
    }
+    else if (*p1 == '*')
+    {
+      const char c=*(p1+1);
+      if (c==0) return true;
+      if (c!='/') return false;
+      const char*p = p1+2;
+      while(*p and *p2)
+      {
+        if (*p == *p2)
+        {
+          if (*p==0) return true;
+          if (*p=='/')
+          {
+            p1=p;
+            break;
+          }
+        }
+        else
+        {
+          while(*p2 and *p2++!='/');
+          break;
+        }
+        ++p;
+        ++p2;
+      }
+      if (*p==0) return true;
+    }
+    else if (*p1 == *p2)
+    {
+      ++p1;
+      ++p2;
+    }
+    else
+      return false;
+  }
+  if (*p1=='/' and p1[1]=='#' and p1[2]==0) return true;
+  return *p1==0 and *p2==0;
+}
+

 // publish from local client
 MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pay_length)
@@ -610,9 +725,10 @@ 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)
+
+  if (local_broker)
  {
-		return parent->publish(this, topic, msg);
+    return local_broker->publish(this, topic, msg);
  }
  else if (client)
    return msg.sendTo(this);
@@ -621,11 +737,11 @@ 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;

-	debug("mqttclient publish " << subscriptions.size());
+  debug("mqttclient publishIfSubscribed " << topic.c_str() << ' ' << subscriptions.size());
  if (isSubscribedTo(topic))
  {
    if (client)
@@ -633,6 +749,10 @@ MqttError MqttClient::publishIfSubscribed(const Topic& topic, const MqttMessage&
    else
    {
      processMessage(&msg);
+
+      #if TINY_MQTT_DEBUG
+        Console << "Should call the callback ?\n";
+      #endif
      // callback(this, topic, nullptr, 0);  // TODO Payload
    }
  }
@@ -661,24 +781,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);
@@ -700,12 +819,14 @@ void MqttMessage::incoming(char in_byte)
      break;
    case Complete:
    default:
-			Serial << "Spurious " << _HEX(in_byte) << endl;
+      #if TINY_MQTT_DEBUG
+        Console << red << "Spurious " << _HEX(in_byte) << white << endl;
        hexdump("spurious");
+      #endif
      reset();
      break;
  }
-	if (buffer.length() > MaxBufferLength)	// TODO magic 256 ?
+  if (buffer.length() > MaxBufferLength)
  {
    debug("Too long " << state);
    reset();
@@ -716,42 +837,49 @@ void MqttMessage::add(const char* p, size_t len, bool addLength)
 {
  if (addLength)
  {
-		buffer.reserve(buffer.length()+addLength+2);
+    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
+  debug("encodingLength");
+  if (state != Complete)
  {
-		uint8_t encoded(length & 0x7F);
-		length >>=7;
-		if (length) encoded |= 0x80;
-		*msb++ = encoded;
-	} while (length);
-};
-
-void MqttMessage::complete()
+    int length = buffer.size()-3;  // 3 = 1 byte for header + 2 bytes for pre-reserved length field.
+    if (length <= 0x7F)
    {
-		encodeLength(&buffer[1], buffer.size()-2);
-		state = Complete;
+      buffer.erase(1,1);
+      buffer[1] = length;
+      vheader = 2;
+    }
+    else
+    {
+      buffer[1] = 0x80 | (length & 0x7F);
+      buffer[2] = (length >> 7);
+      vheader = 3;
    }
      
-MqttError MqttMessage::sendTo(MqttClient* client) const
+    // We could check that buffer[2] < 128 (end of length encoding)
+    state = Complete;
+  }
+};
+
+MqttError MqttMessage::sendTo(MqttClient* client)
 {
  if (buffer.size())
  {
-		debug("sending " << buffer.size() << " bytes");
-		encodeLength(&buffer[1], buffer.size()-2);
-		// hexdump("snd");
+    debug(cyan << "sending " << buffer.size() << " bytes to " << client->id());
+    encodeLength();
+    hexdump("Sending ");
    client->write(&buffer[0], buffer.size());
  }
  else
  {
-		debug("??? Invalid send");
+    debug(red << "??? Invalid send");
    return MqttInvalidMessage;
  }
  return MqttOk;
@@ -759,6 +887,34 @@ MqttError MqttMessage::sendTo(MqttClient* client) const

 void MqttMessage::hexdump(const char* prefix) const
 {
+  (void)prefix;
+#if TINY_MQTT_DEBUG
+  if (TinyMqtt::debug<2) return;
+  static std::map<Type, std::string> tts={
+    { Connect, "Connect" },
+    { ConnAck, "Connack" },
+    { Publish, "Publish" },
+    { PubAck,  "Puback" },
+    { Subscribe, "Subscribe" },
+    { SubAck,   "Suback" },
+    { UnSubscribe, "Unsubscribe" },
+    { UnSuback, "Unsuback" },
+    { PingReq, "Pingreq" },
+    { PingResp, "Pingresp" },
+    { Disconnect, "Disconnect" }
+  };
+  std::string t("Unknown");
+  Type typ=static_cast<Type>(buffer[0] & 0xF0);
+  if (tts.find(typ) != tts.end())
+    t=tts[typ];
+  Console.fg(cyan);
+#ifdef NOT_ESP_CORE
+  Console << "---> MESSAGE " << t << ' ' << _HEX(typ) << ' ' << " mem=???" << endl;
+#else
+  Console << "---> MESSAGE " << t << ' ' << _HEX(typ) << ' ' << " mem=" << ESP.getFreeHeap() << endl;
+#endif
+  Console.fg(white);
+
  uint16_t addr=0;
  const int bytes_per_row = 8;
  const char* hex_to_str = " | ";
@@ -766,19 +922,19 @@ void MqttMessage::hexdump(const char* prefix) const
  const char* half_sep = " - ";
  std::string ascii;

-	Serial << prefix << " size(" << buffer.size() << "), state=" << state << endl;
+  Console << prefix << " size(" << buffer.size() << "), state=" << state << endl;

  for(const char chr: buffer)
  {
    if ((addr % bytes_per_row) == 0)
    {
-			if (ascii.length()) Serial << hex_to_str << ascii << separator << endl;
-			if (prefix) Serial << prefix << separator;
+      if (ascii.length()) Console << hex_to_str << ascii << separator << endl;
+      if (prefix) Console << prefix << separator;
      ascii.clear();
    }
    addr++;
-		if (chr<16) Serial << '0';
-		Serial << _HEX(chr) << ' ';
+    if (chr<16) Console << '0';
+    Console << _HEX(chr) << ' ';

    ascii += (chr<32 ? '.' : chr);
    if (ascii.length() == (bytes_per_row/2)) ascii += half_sep;
@@ -787,11 +943,12 @@ void MqttMessage::hexdump(const char* prefix) const
  {
    while(ascii.length() < bytes_per_row+strlen(half_sep))
    {
-			Serial << "   ";	// spaces per hexa byte
+      Console << "   ";  // spaces per hexa byte
      ascii += ' ';
    }
-		Serial << hex_to_str << ascii << separator;
+    Console << hex_to_str << ascii << separator;
  }

-	Serial << endl;
+  Console << endl;
+#endif
 }
--- a/src/TinyMqtt.h
+++ b/src/TinyMqtt.h
@@ -1,43 +1,56 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once
+#define TINY_MQTT_DEBUG 0

-// 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
+// TODO Should add a AUnit with both TINY_MQTT_ASYNC and not TINY_MQTT_ASYNC
+// #define TINY_MQTT_ASYNC  // Uncomment this to use ESPAsyncTCP instead of normal cnx

 #if defined(ESP8266) || defined(EPOXY_DUINO)
-	#ifdef TCP_ASYNC
+  #ifdef TINY_MQTT_ASYNC
    #include <ESPAsyncTCP.h>
  #else
    #include <ESP8266WiFi.h>
  #endif
 #elif defined(ESP32)
-	#ifdef TCP_ASYNC
-	    #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
-    #else
  #include <WiFi.h>
+  #ifdef TINY_MQTT_ASYNC
+    #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
  #endif
-#else
-	#error "Unsupported platform"
 #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>
 #include "StringIndexer.h"
-#include <MqttStreaming.h>

-// #define TINY_MQTT_DEBUG
+#define TINY_MQTT_DEFAULT_CLIENT_ID "Tiny"

-#ifdef TINY_MQTT_DEBUG
-  #define debug(what) { Serial << __LINE__ << ' ' << what << endl; delay(100); }
+#include <TinyStreaming.h>
+#if TINY_MQTT_DEBUG
+include <TinyConsole.h>    // https://github.com/hsaturn/TinyConsole
+  struct TinyMqtt
+  {
+    static int debug;
+  };
+
+  #define debug(what) { if (TinyMqtt::debug>=1) Console << (int)__LINE__ << ' ' << what << TinyConsole::white << endl; delay(100); }
 #else
  #define debug(what) {}
 #endif

-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
  using TcpClient = AsyncClient;
  using TcpServer = AsyncServer;
 #else
@@ -45,7 +58,7 @@
  using TcpServer = WiFiServer;
 #endif

-enum MqttError
+enum __attribute__((packed)) MqttError
 {
  MqttOk = 0,
  MqttNowhereToSend=1,
@@ -67,9 +80,9 @@ 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
+    enum __attribute__((packed)) Type
    {
      Unknown     =    0,
      Connect     = 0x10,
@@ -84,7 +97,8 @@ class MqttMessage
      PingResp    = 0xD0,
      Disconnect  = 0xE0
    };
-		enum State
+
+    enum __attribute__((packed)) State
    {
      FixedHeader=0,
      Length=1,
@@ -95,6 +109,11 @@ class MqttMessage
      Create=6
    };

+    static inline uint32_t getSize(const char* buffer)
+    {
+      const unsigned char* bun = (const unsigned char*)buffer;
+      return (*bun << 8) | bun[1]; }
+
    MqttMessage() { reset(); }
    MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
    void incoming(char byte);
@@ -104,8 +123,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();

@@ -115,24 +133,27 @@ class MqttMessage

    Type type() const
    {
-			return state == Complete ? static_cast<Type>(buffer[0]) : Unknown;
+      return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
    }

+    uint8_t flags() const { return static_cast<uint8_t>(buffer[0] & 0x0F); }
+
    void create(Type type)
    {
-			buffer=(char)type;
-			buffer+='\0';		// reserved for msg length
-			vheader=2;
+      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*) 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;
@@ -142,7 +163,7 @@ class MqttBroker;
 class MqttClient
 {
  using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
-	enum Flags
+  enum __attribute__((packed)) Flags
  {
    FlagUserName = 128,
    FlagPassword = 64,
@@ -153,32 +174,46 @@ class MqttClient
    FlagReserved = 1
  };
  public:
-	  /** Constructor. If broker is not null, this is the adress of a local broker.
+    /** Constructor. Broker is the adress of a local broker if not null
        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 = TINY_MQTT_DEFAULT_CLIENT_ID);
    MqttClient(const std::string& id) : MqttClient(nullptr, id){}

    ~MqttClient();

-		void connect(MqttBroker* parent);
+    void connect(MqttBroker* local_broker);
    void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);

-		bool connected() { return
-			(parent!=nullptr and client==nullptr) or
-			(client and client->connected()); }
+    // TODO it seems that connected returns true in tcp mode even if
+    // no negociation occurred
+    bool connected()
+    {
+      return (local_broker!=nullptr and client==nullptr) or (client and client->connected());
+    }
+
    void write(const char* buf, size_t length)
-		{ if (client) client->write(buf, length); }
+    {
+      if (client) client->write(buf, length);
+    }

    const std::string& id() const { return clientId; }
-		void id(std::string& new_id) { clientId = new_id; }
+    void id(const std::string& new_id) { clientId = new_id; }

    /** 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;
+      #if TINY_MQTT_DEBUG
+        Console << TinyConsole::magenta << "Callback set to " << (long)fun << TinyConsole::white << 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);};
@@ -191,56 +226,71 @@ class MqttClient
    // TODO seems to be useless
    bool isLocal() const { return client == nullptr; }

-		void dump()
+    void dump(std::string indent="")
    {
+      (void)indent;
+      #if TINY_MQTT_DEBUG
        uint32_t ms=millis();
-			Serial << "MqttClient (" << clientId.c_str() << ") " << (connected() ? " ON " : " OFF");
-			Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive;
-			Serial << (client && client->connected() ? "" : "dis") << "connected";
-            message.hexdump("entrant msg");
+        Console << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
+        Console << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
+        if (client)
+        {
+          if (client->connected())
+            Console << TinyConsole::green << "connected";
+          else
+            Console << TinyConsole::red << "disconnected";
+          Console << TinyConsole::white;
+        }
+        if (subscriptions.size())
+        {
          bool c = false;
-			Serial << " [";
+          Console << " [";
          for(auto s: subscriptions)
          {
-				Serial << (c?", ": "")<< s.str().c_str();
+            if (c) Console << ", ";
+            Console << s.str().c_str();
            c=true;
          }
-
-			
-			Serial << "]" << endl;
+          Console << ']';
+        }
+        Console << TinyConsole::erase_to_end << endl;
+      #endif
    }

-		/** Count the number of messages that have been sent **/
-		static long counter;
+#ifdef EPOXY_DUINO
+    static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
+#endif
+    uint32_t keepAlive() const { return keep_alive; }

  private:
+
+    // event when tcp/ip link established (real or fake)
    static void onConnect(void * client_ptr, TcpClient*);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_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, TcpClient* client);
+    MqttClient(MqttBroker* local_broker, 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 = 60;
+    uint32_t keep_alive = 30;
    uint32_t alive;
    MqttMessage message;

-		// TODO	having a pointer on MqttBroker may produce larger binaries
-		// due to unecessary function linked if ever parent is not used
-		// (this is the case when MqttBroker isn't used except here)
-		MqttBroker* parent=nullptr;		// connection to local broker
+    // connection to local broker, or link to the parent
+    // when MqttBroker uses MqttClient for each external connexion
+    MqttBroker* local_broker=nullptr;

-		TcpClient* 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;
@@ -248,7 +298,7 @@ class MqttClient

 class MqttBroker
 {
-	enum State
+  enum __attribute__((packed)) State
  {
    Disconnected,  // Also the initial state
    Connecting,    // connect and sends a fake publish to avoid circular cnx
@@ -267,16 +317,14 @@ class MqttBroker

    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);
    }

+    const std::vector<MqttClient*>  getClients() const { return clients; }
+
  private:
    friend class MqttClient;

@@ -288,21 +336,23 @@ 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);

-		// For clients that are added not by the broker itself
+    // For clients that are added not by the broker itself (local clients)
    void addClient(MqttClient* client);
    void removeClient(MqttClient* client);

    bool compareString(const char* good, const char* str, uint8_t str_len) const;
    std::vector<MqttClient*>  clients;
-		TcpServer* server;
+
+  private:
+    TcpServer* server = nullptr;

    const char* auth_user = "guest";
    const char* auth_password = "guest";
-		State state = Disconnected;
-
    MqttClient* broker = nullptr;
+
+    State state = Disconnected;
 };
--- a/src/my_credentials.h
+++ b/src/my_credentials.h
@@ -1,2 +0,0 @@
-const char *ssid     = "YOUR-SSID-HERE";
-const char *password = "YOUR-PASSWORD-HERE";
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -5,7 +5,15 @@ tests:
 		$(MAKE) -C $$(dirname $$i) -j; \
 	done

-runtests: tests
+debugtest:
+	set -e; \
+	$(MAKE) clean; \
+	$(MAKE) -C debug-mode -j; \
+	debug-mode/debug-tests.out
+
+runtests: debugtest
+	$(MAKE) clean
+	$(MAKE) tests
 	set -e; \
 	for i in *-tests/Makefile; do \
 		echo '==== Running:' $$(dirname $$i); \
--- a/tests/debug-mode/Makefile
+++ b/tests/debug-mode/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 -DTINY_MQTT_DEBUG
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := debug-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/debug-mode/debug-tests.ino
+++ b/tests/debug-mode/debug-tests.ino
@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+// Only compilation check, so do nothing
+
+void setup() {}
+void loop() {
+  aunit::TestRunner::run();
+}
--- a/tests/howto
+++ b/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
--- a/tests/length-tests.todo/Makefile
+++ b/tests/length-tests.todo/Makefile
@@ -0,0 +1,10 @@
+# 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
+
+APP_NAME := length-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/length-tests.todo/length-tests.ino
+++ b/tests/length-tests.todo/length-tests.ino
@@ -0,0 +1,54 @@
+// vim: ts=2 sw=2 expandtab
+#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();
+}
--- a/tests/local-tests/Makefile
+++ b/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
-ESP_LIBS = ESP8266WiFi ESPAsyncTCP
-include ../../../EspMock/EspMock.mk
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/local-tests/local-tests.ino
+++ b/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);
-	assertTrue(published[""]["a/c"] == 2);
+  assertEqual(published[""]["a/b"], 1);
+  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);
-	assertTrue(published["A"]["a/c"] == 1);
-	assertTrue(published["B"]["a/b"] == 1);
-	assertTrue(published["B"]["a/c"] == 0);
+  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(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() {
--- a/tests/network-tests/Makefile
+++ b/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 TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/network-tests/network-tests.ino
+++ b/tests/network-tests/network-tests.ino
@@ -0,0 +1,466 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <iostream>
+
+/**
+  * 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_keep_alive_high)
+{
+  const uint32_t keep_alive=1000;
+  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, keep_alive);
+  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);
+
+  uint32_t sz = broker.getClients().size();
+  assertEqual(sz , (uint32_t)1);
+
+  uint32_t ka = broker.getClients()[0]->keepAlive();
+  assertEqual(ka, keep_alive);
+
+}
+
+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[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["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[TINY_MQTT_DEFAULT_CLIENT_ID]["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();
+}
--- a/tests/nowifi-tests/Makefile
+++ b/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
-ESP_LIBS = ESP8266WiFi ESPAsyncTCP
-include ../../../EspMock/EspMock.mk
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/nowifi-tests/nowifi-tests.ino
+++ b/tests/nowifi-tests/nowifi-tests.ino
@@ -1,3 +1,5 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
 #include <map>
@@ -63,8 +65,8 @@ test(nowifi_publish_should_be_dispatched)
  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);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/c"], 2);
 }

 test(nowifi_publish_should_be_dispatched_to_clients)
@@ -92,6 +94,104 @@ test(nowifi_publish_should_be_dispatched_to_clients)
  assertEqual(published["B"]["a/c"], 0);
 }

+test(nowifi_subscribe_with_star_wildcard)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("house/*/temp");
+
+  MqttClient publisher(&broker);
+  publisher.publish("house/bedroom/temp");
+  publisher.publish("house/kitchen/temp");
+  publisher.publish("house/living_room/tv/temp");
+  publisher.publish("building/location1/bedroom/temp");
+
+  assertEqual(published["A"]["house/bedroom/temp"], 1);
+  assertEqual(published["A"]["house/kitchen/temp"], 1);
+  assertEqual(published["A"]["house/living_room/tv/temp"], 1);
+  assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_subscribe_with_plus_wildcard)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("house/+/temp");
+
+  MqttClient publisher(&broker);
+  publisher.publish("house/bedroom/temp");
+  publisher.publish("house/kitchen/temp");
+  publisher.publish("house/living_room/tv/temp");
+  publisher.publish("building/location1/bedroom/temp");
+
+  assertEqual(published["A"]["house/bedroom/temp"], 1);
+  assertEqual(published["A"]["house/kitchen/temp"], 1);
+  assertEqual(published["A"]["house/living_room/tv/temp"], 0);
+  assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_should_not_receive_sys_msg)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("+/data");
+
+  MqttClient publisher(&broker);
+  publisher.publish("$SYS/data");
+
+  assertEqual(published["A"]["$SYS/data"], 0);
+}
+
+test(nowifi_subscribe_with_mixed_wildcards)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("+/data/#");
+
+  MqttClient publisher(&broker);
+  publisher.publish("node1/data/update");
+  publisher.publish("node2/data/delta");
+  publisher.publish("node3/data");
+
+  assertEqual(published["A"]["node1/data/update"], 1);
+  assertEqual(published["A"]["node2/data/delta"], 1);
+  assertEqual(published["A"]["node3/data"], 1);
+}
+
+test(nowifi_unsubscribe_with_wildcards)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("one/two/+");
+  subscriber.subscribe("one/two/three");
+
+  MqttClient publisher(&broker);
+  publisher.publish("one/two/three");
+  publisher.publish("one/two/four");
+
+  subscriber.unsubscribe("one/two/+");
+  publisher.publish("one/two/five");
+
+  assertEqual(published["A"]["one/two/three"], 1);
+  assertEqual(published["A"]["one/two/four"], 1);
+  assertEqual(published["A"]["one/two/five"], 0);
+}
+
 test(nowifi_unsubscribe)
 {
  published.clear();
@@ -109,7 +209,7 @@ test(nowifi_unsubscribe)
  publisher.publish("a/b");    // Those one, no (unsubscribed)
  publisher.publish("a/b");

-	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
 }

 test(nowifi_nocallback_when_destroyed)
@@ -131,7 +231,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 +249,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() {
--- a/tests/string-indexer-tests/Makefile
+++ b/tests/string-indexer-tests/Makefile
@@ -1,7 +1,10 @@
 # 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
+
 APP_NAME := string-indexer-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
-ESP_LIBS = ESP8266WiFi ESPAsyncTCP
-include ../../../EspMock/EspMock.mk
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/string-indexer-tests/string-indexer-tests.ino
+++ b/tests/string-indexer-tests/string-indexer-tests.ino
@@ -1,3 +1,5 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
 #include <AUnit.h>
 #include <StringIndexer.h>
 #include <map>
@@ -61,6 +63,14 @@ test(indexer_same_strings_should_equal)
  assertTrue(one == two);
 }

+test(indexer_compare_strings_with_same_beginning)
+{
+  IndexedString two("one_two");
+  IndexedString one("one");
+
+  assertNotEqual(one.getIndex(), two.getIndex());
+}
+
 test(indexer_indexed_operator_eq)
 {
  IndexedString one("one");
@@ -105,5 +115,5 @@ void setup() {
 void loop() {
  aunit::TestRunner::run();

-	if (Serial.available()) ESP.reset();
+  // if (Serial.available()) ESP.reset();
 }
--- a/tests/topic-tests/Makefile
+++ b/tests/topic-tests/Makefile
@@ -0,0 +1,10 @@
+# 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
+
+APP_NAME := topic-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/topic-tests/topic-tests.ino
+++ b/tests/topic-tests/topic-tests.ino
@@ -0,0 +1,86 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+
+#define endl "\n"
+
+/**
+  * TinyMqtt / StringIndexer unit tests.
+  *
+  **/
+
+using namespace std;
+
+bool testTopicMatch(const char* a, const char* b, bool expected)
+{
+  Topic ta(a);
+  Topic tb(b);
+  bool match(ta.matches(tb));
+  cout << "  " << ta.c_str() << ' ';
+  if (match != expected)
+    cout << (expected ? " should match " : " should not match ");
+  else
+    cout << (expected ? " matches " : " unmatches ");
+  cout << tb.c_str() << endl;
+  return expected == match;
+}
+
+test(topic_matches)
+{
+  // matching
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/c"     , true));
+  assertTrue(testTopicMatch("a/*/c"    , "a/xyz/c"   , true));
+  assertTrue(testTopicMatch("a/*/e"    , "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("a/*"      , "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("*/c"      , "a/b/c"     , true));
+  assertTrue(testTopicMatch("/*/c"     , "/a/b/c"    , true));
+  assertTrue(testTopicMatch("a/*"      , "a/b/c/d"   , true));
+  assertTrue(testTopicMatch("a/+/c"    , "a/b/c"     , true));
+  assertTrue(testTopicMatch("a/+/c/+/e", "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("a/*/c/+/e", "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("/+/b"     , "/a/b"      , true));
+  assertTrue(testTopicMatch("+"        , "a"         , true));
+  assertTrue(testTopicMatch("a/b/#"    , "a/b/c/d"   , true));
+  assertTrue(testTopicMatch("a/b/#"    , "a/b"       , true));
+  assertTrue(testTopicMatch("a/*/c"    , "a/*/c"     , true));
+
+  // not matching
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/*/e"    , "a/b/c/d/f" , false));
+  assertTrue(testTopicMatch("a/+"      , "a"         , false));
+  assertTrue(testTopicMatch("a/+"      , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/+/"     , "a/"        , false));
+
+  // $SYS topics
+  assertTrue(testTopicMatch("+/any"    , "$SYS/any"  , false));
+  assertTrue(testTopicMatch("*/any"    , "$SYS/any"  , false));
+  assertTrue(testTopicMatch("$SYS/any" , "$SYS/any"  , true));
+  assertTrue(testTopicMatch("$SYS/+/y" , "$SYS/a/y"  , true));
+  assertTrue(testTopicMatch("$SYS/#"   , "$SYS/a/y"  , true));
+
+  // not valid
+  assertTrue(testTopicMatch("a/#/b"    , "a/x/b"     , false));
+  assertTrue(testTopicMatch("a+"      , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/b/#/d"  , "a/b/c/d"   , false));
+
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  // if (Serial.available()) ESP.reset();
+}
Author	SHA1	Message	Date
hsaturn	a9ebf31e6f	Version 0.9.9	2022-12-24 02:01:27 +01:00
hsaturn	4b4eb0b684	Fix compilation error when not in debug	2022-12-23 18:06:35 +01:00
HSaturn	18ce34c458	:xDefault client is no more empty	2022-12-17 18:36:32 +01:00
Francois BIOT	70ca3787bb	Better debugging code	2022-12-04 02:41:11 +01:00
Francois BIOT	396e3fde95	Moved MqttStreaming to TinyConsole	2022-12-04 02:30:37 +01:00
Francois BIOT	c913bc61bb	tinymqtt-test : new commands	2022-12-04 02:03:28 +01:00
Francois BIOT	7af8e46b59	simple-client typo	2022-12-04 02:00:50 +01:00
Francois BIOT	0569bc6000	[tinytest] Removed auto commands and default topic	2022-12-04 00:25:43 +01:00
Francois BIOT	708a2b41dc	tinymqtt-test enhancements	2022-12-03 23:09:20 +01:00
Francois BIOT	c4edfb6e40	fix bug in simple-broker example	2022-12-03 21:27:03 +01:00
Francois BIOT	cf724507e9	fix typo	2022-12-03 21:03:05 +01:00
Francois BIOT	744a590467	Replaced tabs by spaces	2022-12-03 20:47:02 +01:00
Francois BIOT	5a3e9bd90e	Fix reboot bugs due to TinyConsole	2022-12-03 20:34:59 +01:00
hsaturn	d8b24adef7	[MqttClient] Fix compilation warnings	2022-12-03 20:25:03 +01:00
hsaturn	4726ff293c	[MqttClient] Fix keep_alive decoding	2022-12-03 20:23:15 +01:00
hsaturn	2a4e84d827	[TinyMqtt.h] rework code	2022-12-01 08:07:25 +01:00
hsaturn	9ef47fa6a4	[MqttClient] Renamed parent to local_broker	2022-12-01 07:49:56 +01:00
hsaturn	3358340319	Fix unit tests	2022-11-30 20:52:29 +01:00
Francois BIOT	1fff9fd0e1	Use TinyConsole instead of Serial	2022-11-30 20:06:15 +01:00
hsaturn	d12096ef51	Ooops bad tag	2022-11-23 13:01:24 +01:00
hsaturn	ea56d21190	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2022-11-23 12:56:35 +01:00
hsaturn	c802c895b6	Version 0.9.6 bump	2022-11-23 12:54:15 +01:00
hsaturn	074bca971f	Update README.md	2022-11-23 12:51:12 +01:00
hsaturn	7bd9c27b89	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2022-11-21 04:42:30 +01:00
hsaturn	3e73673302	[tinymqtt-test] Fix lot of errors - TINY_MQTT_DEBUG was not set (no dump) - MqttClient::counter has disapeared (compilation error) - payload was badly displayed - broker/client names could be reused for client/brokers	2022-11-21 04:42:16 +01:00
hsaturn	4b12aaa198	Update README.md Unit tests in features	2022-11-21 01:47:47 +01:00
hsaturn	5f9cab8992	Update README.md Wildcards	2022-11-21 01:44:54 +01:00
hsaturn	96766f7091	[Topic] Wildcards added + wildcard added # wildcard added * wildcard added (but does not appear in mqtt specification...) $SYS messages compare is supported	2022-11-21 01:37:55 +01:00
hsaturn	354aec239f	[tests] Re-added debug mode in tests The EXTRA_FLAGS needs some clean before running tests. This commit allows to compile twice for this situation, but it is not perfect because EXTRA_CFLAGS can still cause some problems. The tests Makefile should be able to detect this and to group builds and tests with each own EXTRA flags.	2022-10-31 02:12:15 +01:00
hsaturn	3839a0a830	[tests] Fix unit tests timed out The debug-tests was changing the compilation (TINY_MQTT_DEBUG on) Thus the other tests were too long to execute due to Serial output emulation.	2022-10-31 01:49:11 +01:00
hsaturn	0444a4c348	[tests] removed useless code in debug-tests.ino	2022-10-31 01:35:21 +01:00
hsaturn	73207e4745	Renamed TCP_ASYNC define to TINY_MQTT_ASYNC for name consistency.	2022-10-31 01:24:41 +01:00
hsaturn	b7d44445af	[tests] Added a debug mode compilation phase (and fixed it)	2022-10-31 01:20:30 +01:00
hsaturn	cce6b2ecfc	Update README.md Added links for examples	2022-10-30 22:01:54 +01:00
hsaturn	883f1e27e6	Release 0.9.3	2022-10-30 21:47:58 +01:00
hsaturn	e7fc147424	Changed tab to spaces	2022-10-30 21:43:45 +01:00
hsaturn	2147b147fc	[Readme] Some minor changes	2022-10-30 21:42:59 +01:00
hsaturn	f5e9a43461	[StringIndexer] Fix compare bug and moved strToIndex to private strToIndex is dangerous because it can increment the use of a string, or create a new string. This method should only be called by IndexedString.	2022-10-30 21:41:52 +01:00
hsaturn	cabb56fc8c	[tests] Added -g3 for tests for debugging purposes	2022-10-30 20:44:44 +01:00
hsaturn	58786eb6d9	Release 0.9.2	2022-10-30 19:48:04 +01:00
hsaturn	776242b259	Release 0.9.1	2022-10-30 19:45:50 +01:00
hsaturn	a9d19c3218	[lib] Remove library.json	2022-10-30 18:31:46 +01:00
hsaturn	7bd299ec07	Use slim lint	2022-10-30 15:23:50 +01:00
hsaturn	107469cd78	Lint action, upgrade to latest	2022-10-30 15:13:42 +01:00
hsaturn	709e1fd567	Tabs changed to spaces (at least)	2022-10-30 13:26:33 +01:00
hsaturn	4eb8f18ebf	[MqttMessage] Rewrite of the length encoding	2022-10-30 13:24:05 +01:00
hsaturn	d5d27c8020	Merge pull request #25 from hsaturn/pr22 was pr#22 : added reply to message subscribe and unsubscribe	2022-01-10 05:28:08 +01:00
hsaturn	da3ec41d71	Update network-tests.ino Remove useless code	2022-01-10 05:27:15 +01:00
hsaturn	5f7b4537c8	Enhance PR#22	2022-01-05 02:03:42 +01:00
hsaturn	cce4fecac6	Fix test local_client_should_unregister_when_destroyed	2022-01-05 02:02:18 +01:00
hsaturn	737e217172	fix type return value	2022-01-05 02:01:22 +01:00
hsaturn	8fe3517894	added packed attribute for enums	2022-01-05 02:00:02 +01:00
hsaturn	710503663a	better type management	2022-01-05 01:59:16 +01:00
hsaturn	a5b8afc0bd	Added some ifdef for debugging purposes	2022-01-05 01:56:45 +01:00
terror	f1d3a15498	added reply to message subscribe and unsubscribe	2021-09-25 15:44:09 +03:00
hsaturn	dfd5983715	Rewrite comments and added hudge payload test	2021-09-20 01:57:40 +02:00
hsaturn	4dcc6a6cf4	Minor changes	2021-09-19 12:40:04 +02:00
hsaturn	b58f3e3d67	Merge branch 'issue_2_broken_large_payloads' into main	2021-09-17 22:35:28 +02:00
hsaturn	a6b3540cb8	Fix issue_2 : Broken large payloads	2021-09-17 22:32:00 +02:00
hsaturn	ccbf42f81b	howto added for building and running tests	2021-09-17 19:58:24 +02:00
hsaturn	d39c58d8f5	Fix issue_2 broken payload	2021-09-17 19:51:32 +02:00
hsaturn	36dde2c063	Fix for debugging for other platform than ESP	2021-08-09 11:24:27 +02:00
hsaturn	64a05bb60b	Release 0.7.9	2021-08-09 10:47:18 +02:00
hsaturn	bb89fc5284	Release 0.7.8	2021-08-09 10:45:17 +02:00
hsaturn	c1fd1bc907	Remove pending length test	2021-08-09 10:44:19 +02:00
hsaturn	d919188eb0	Merge pull request #15 from bxparks/epoxyfix Fix unit tests for EpoxyDuino	2021-08-09 10:39:26 +02:00
hsaturn	9c7f3b6b8e	Fix of decode length	2021-08-09 10:37:46 +02:00
Brian Park	88c7d552cb	Fix unit tests for EpoxyDuino	2021-08-08 19:37:04 -07:00
hsaturn	fab242e212	Version 0.7.6	2021-08-09 03:04:21 +02:00
hsaturn	56a2be621f	Fix message length error	2021-08-09 03:00:28 +02:00
hsaturn	c4cf39ab68	Fix aunit tests	2021-08-09 02:33:01 +02:00
hsaturn	90dea36ab0	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	25a721e06a	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	b228d35ab0	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	c70716a595	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	8d5cad5fec	Added overload of Client::publish, fix compilation	2021-05-13 03:21:03 +02:00
hsaturn	d5430228e5	Fix cr/lf bug Added echo on\|off for later vt100 terminal Added rnd(min,max) function Simplied every function Better parsing for getword (accept strings) Fix for blink command	2021-05-13 03:21:03 +02:00
hsaturn	91c1f96146	Update README.md links updates	2021-05-08 15:14:59 +02:00
hsaturn	f04a2a07c0	Fix aunit.yml	2021-04-28 21:22:07 +00:00
hsaturn	38f306c170	Fix compilation esp8266 esp32	2021-04-28 23:16:33 +02:00
hsaturn	024e80c9dc	Perpare for future ESP32 aunit tests	2021-04-28 21:00:31 +00:00
hsaturn	2249ddef7f	Release 0.7.5	2021-04-28 18:57:24 +02:00
hsaturn	e193929f8f	changed every command	2021-04-28 18:56:17 +02:00
hsaturn	e00e31de33	Fix build in Esp8266 mode Modify dump() functions	2021-04-28 18:55:57 +02:00
hsaturn	20292b7b7b	Fix example syntax	2021-04-28 08:24:44 +02:00
hsaturn	26de3befa8	TinyTest Esp32 port Update library definition	2021-04-28 08:19:55 +02:00
hsaturn	1098466055	Update README.md	2021-04-28 08:14:46 +02:00
hsaturn	2d3663e78c	Update README.md	2021-04-28 07:32:56 +02:00
hsaturn	5e16282ad0	Disable ci.yml	2021-04-21 01:10:35 +02:00
hsaturn	e35a43c4a4	Trying to remove unsupported platform that break ci.yml	2021-04-21 01:05:31 +02:00
hsaturn	087a203ba0	Create ci.yml	2021-04-21 00:56:49 +02:00
hsaturn	5d313bbf5e	Rewrite examples	2021-04-12 00:27:25 +02:00
hsaturn	ce896f02c4	Merge pull request #6 from hsaturn/AsyncAndWifi AsyncTcp can be activated by removing the command on TCP_ASYNC in TinyMqtt.h But the code is not bug free yet.	2021-04-11 23:33:29 +02:00