compile with esp mqtt lib

lib/espMqttClient/examples/largepayload-esp8266/largepayload-esp8266.ino

@@ -0,0 +1,91 @@
+#include <ESP8266WiFi.h>
+#include <Ticker.h>
+#include <espMqttClient.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST IPAddress(192, 168, 1, 10)
+#define MQTT_PORT 1883
+
+WiFiEventHandler wifiConnectHandler;
+WiFiEventHandler wifiDisconnectHandler;
+espMqttClient mqttClient;
+Ticker reconnectTimer;
+
+size_t fetchPayload(uint8_t* dest, size_t len, size_t index) {
+  Serial.printf("filling buffer at index %zu\n", index);
+  // fill the buffer with random bytes
+  // but maybe don't fill the entire buffer
+  size_t i = 0;
+  for (; i < len; ++i) {
+    dest[i] = random(0xFF);
+    if (dest[i] > 0xFC) {
+      ++i;  // extra increment to compensate 'break'
+      break;
+    }
+  }
+  return i; 
+}
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
+  Serial.println("Connected to Wi-Fi.");
+  connectToMqtt();
+}
+
+void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
+  Serial.println("Disconnected from Wi-Fi.");
+  reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
+  reconnectTimer.once(5, connectToWiFi);
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+  mqttClient.publish("topic/largepayload", 1, false, fetchPayload, 6000);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttPublish(uint16_t packetId) {
+  Serial.println("Publish acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+  wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
+  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+
+  connectToWiFi();
+}
+
+void loop() {
+  mqttClient.loop();
+}

lib/espMqttClient/examples/ota-esp8266/ota-esp8266.ino

@@ -0,0 +1,142 @@
+#include <ESP8266WiFi.h>
+#include <Updater.h>
+#include <Ticker.h>
+#include <espMqttClient.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST IPAddress(192, 168, 130, 10)
+#define MQTT_PORT 1883
+
+#define UPDATE_TOPIC "device/firmware/set"
+
+WiFiEventHandler wifiConnectHandler;
+WiFiEventHandler wifiDisconnectHandler;
+espMqttClient mqttClient;
+Ticker reconnectTimer;
+bool disconnectFlag = false;
+bool restartFlag = false;
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
+  Serial.println("Connected to Wi-Fi.");
+  connectToMqtt();
+}
+
+void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
+  Serial.println("Disconnected from Wi-Fi.");
+  reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
+  reconnectTimer.once(5, connectToWiFi);
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+  uint16_t packetIdSub = mqttClient.subscribe(UPDATE_TOPIC, 2);
+  Serial.print("Subscribing at QoS 2, packetId: ");
+  Serial.println(packetIdSub);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (disconnectFlag) {
+    restartFlag = true;
+    return;
+  }
+  
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  Serial.println("Subscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+  for (size_t i = 0; i < len; ++i) {
+    Serial.print("  qos: ");
+    Serial.println(static_cast<uint8_t>(codes[i]));
+  }
+}
+
+void handleUpdate(const uint8_t* payload, size_t length, size_t index, size_t total) {
+  // The Updater class takes a non-const pointer to write data although it doesn't change the data
+  uint8_t* data = const_cast<uint8_t*>(payload);
+  static size_t written = 0;
+  Update.runAsync(true);
+  if (index == 0) {
+    if (Update.isRunning()) {
+      Update.end();
+      Update.clearError();
+    }
+    Update.begin(total);
+    written = Update.write(data, length);
+    Serial.printf("Updating %u/%u\n", written, Update.size());
+  } else {
+    if (!Update.isRunning()) return;
+    written += Update.write(data, length);
+    Serial.printf("Updating %u/%u\n", written, Update.size());
+  }
+  if (Update.isFinished()) {
+    if (Update.end()) {
+      Serial.println("Update succes");
+      disconnectFlag = true;
+    } else {
+      Serial.printf("Update error: %u\n", Update.getError());
+      Update.printError(Serial);
+      Update.clearError();
+    }
+  }
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  if (strcmp(UPDATE_TOPIC, topic) != 0) {
+    Serial.println("Topic mismatch");
+    return;
+  }
+  handleUpdate(payload, len, index, total);
+}
+
+void setup() {
+  Serial.begin(74880);
+  Serial.println();
+  Serial.println();
+
+  wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
+  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+
+  connectToWiFi();
+}
+
+void loop() {
+  mqttClient.loop();
+
+  if (disconnectFlag) {
+    // it's safe to call this multiple times
+    mqttClient.disconnect();
+  }
+
+  if (restartFlag) {
+    Serial.println("Rebooting... See you next time!");
+    Serial.flush();
+    ESP.reset();
+  }
+}

lib/espMqttClient/examples/simple-esp32/simple-esp32.ino

@@ -0,0 +1,127 @@
+#include <WiFi.h>
+#include <Ticker.h>
+#include <espMqttClient.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST IPAddress(192, 168, 1, 10)
+#define MQTT_PORT 1883
+
+espMqttClient mqttClient;
+Ticker reconnectTimer;
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void WiFiEvent(WiFiEvent_t event) {
+  Serial.printf("[WiFi-event] event: %d\n", event);
+  switch(event) {
+  case SYSTEM_EVENT_STA_GOT_IP:
+    Serial.println("WiFi connected");
+    Serial.println("IP address: ");
+    Serial.println(WiFi.localIP());
+    connectToMqtt();
+    break;
+  case SYSTEM_EVENT_STA_DISCONNECTED:
+    Serial.println("WiFi lost connection");
+    reconnectTimer.once(5, connectToWiFi);
+    break;
+  default:
+    break;
+  }
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+  uint16_t packetIdSub = mqttClient.subscribe("foo/bar", 2);
+  Serial.print("Subscribing at QoS 2, packetId: ");
+  Serial.println(packetIdSub);
+  mqttClient.publish("foo/bar", 0, true, "test 1");
+  Serial.println("Publishing at QoS 0");
+  uint16_t packetIdPub1 = mqttClient.publish("foo/bar", 1, true, "test 2");
+  Serial.print("Publishing at QoS 1, packetId: ");
+  Serial.println(packetIdPub1);
+  uint16_t packetIdPub2 = mqttClient.publish("foo/bar", 2, true, "test 3");
+  Serial.print("Publishing at QoS 2, packetId: ");
+  Serial.println(packetIdPub2);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  Serial.println("Subscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+  for (size_t i = 0; i < len; ++i) {
+    Serial.print("  qos: ");
+    Serial.println(static_cast<uint8_t>(codes[i]));
+  }
+}
+
+void onMqttUnsubscribe(uint16_t packetId) {
+  Serial.println("Unsubscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  Serial.println("Publish received.");
+  Serial.print("  topic: ");
+  Serial.println(topic);
+  Serial.print("  qos: ");
+  Serial.println(properties.qos);
+  Serial.print("  dup: ");
+  Serial.println(properties.dup);
+  Serial.print("  retain: ");
+  Serial.println(properties.retain);
+  Serial.print("  len: ");
+  Serial.println(len);
+  Serial.print("  index: ");
+  Serial.println(index);
+  Serial.print("  total: ");
+  Serial.println(total);
+}
+
+void onMqttPublish(uint16_t packetId) {
+  Serial.println("Publish acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+  WiFi.onEvent(WiFiEvent);
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onUnsubscribe(onMqttUnsubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+
+  connectToWiFi();
+}
+
+void loop() {
+  // nothing to do here
+}

lib/espMqttClient/examples/simple-esp8266/simple-esp8266.ino

@@ -0,0 +1,123 @@
+#include <ESP8266WiFi.h>
+#include <Ticker.h>
+#include <espMqttClient.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST IPAddress(192, 168, 1, 10)
+#define MQTT_PORT 1883
+
+WiFiEventHandler wifiConnectHandler;
+WiFiEventHandler wifiDisconnectHandler;
+espMqttClient mqttClient;
+Ticker reconnectTimer;
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
+  Serial.println("Connected to Wi-Fi.");
+  connectToMqtt();
+}
+
+void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
+  Serial.println("Disconnected from Wi-Fi.");
+  reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
+  reconnectTimer.once(5, connectToWiFi);
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+  uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
+  Serial.print("Subscribing at QoS 2, packetId: ");
+  Serial.println(packetIdSub);
+  mqttClient.publish("test/lol", 0, true, "test 1");
+  Serial.println("Publishing at QoS 0");
+  uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
+  Serial.print("Publishing at QoS 1, packetId: ");
+  Serial.println(packetIdPub1);
+  uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
+  Serial.print("Publishing at QoS 2, packetId: ");
+  Serial.println(packetIdPub2);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  Serial.println("Subscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+  for (size_t i = 0; i < len; ++i) {
+    Serial.print("  qos: ");
+    Serial.println(static_cast<uint8_t>(codes[i]));
+  }
+}
+
+void onMqttUnsubscribe(uint16_t packetId) {
+  Serial.println("Unsubscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  Serial.println("Publish received.");
+  Serial.print("  topic: ");
+  Serial.println(topic);
+  Serial.print("  qos: ");
+  Serial.println(properties.qos);
+  Serial.print("  dup: ");
+  Serial.println(properties.dup);
+  Serial.print("  retain: ");
+  Serial.println(properties.retain);
+  Serial.print("  len: ");
+  Serial.println(len);
+  Serial.print("  index: ");
+  Serial.println(index);
+  Serial.print("  total: ");
+  Serial.println(total);
+}
+
+void onMqttPublish(uint16_t packetId) {
+  Serial.println("Publish acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+  wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
+  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onUnsubscribe(onMqttUnsubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+
+  connectToWiFi();
+}
+
+void loop() {
+  mqttClient.loop();
+}

lib/espMqttClient/examples/simple-linux/main.cpp

@@ -0,0 +1,89 @@
+#include <iostream>
+#include <thread>
+#include <espMqttClient.h>
+
+#define MQTT_HOST IPAddress(192,168,1,10)
+#define MQTT_PORT 1883
+
+espMqttClient mqttClient;
+std::atomic_bool exitProgram(false);
+
+void connectToMqtt() {
+  std::cout << "Connecting to MQTT..." << std::endl;
+  mqttClient.connect();
+}
+
+void onMqttConnect(bool sessionPresent) {
+  std::cout << "Connected to MQTT." << std::endl;
+  std::cout << "Session present: " << sessionPresent << std::endl;
+  uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
+  std::cout << "Subscribing at QoS 2, packetId: " << packetIdSub << std::endl;
+  mqttClient.publish("test/lol", 0, true, "test 1");
+  std::cout << "Publishing at QoS 0" << std::endl;
+  uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
+  std::cout << "Publishing at QoS 1, packetId: " << packetIdPub1 << std::endl;
+  uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
+  std::cout << "Publishing at QoS 2, packetId: " << packetIdPub2 << std::endl;
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  std::cout << "Disconnected from MQTT: %u.\n" << unsigned(static_cast<uint8_t>(reason)) << std::endl;
+  exitProgram = true;
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  std::cout << "Subscribe acknowledged." << std::endl;
+  std::cout << "  packetId: " << packetId << std::endl;
+  for (size_t i = 0; i < len; ++i) {
+    std::cout << "  qos: " << unsigned(static_cast<uint8_t>(codes[i])) << std::endl;
+  }
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  (void) payload;
+  std::cout << "Publish received." << std::endl;
+  std::cout << "  topic: " << topic << std::endl;
+  std::cout << "  qos: " << unsigned(properties.qos) << std::endl;
+  std::cout << "  dup: " << properties.dup << std::endl;
+  std::cout << "  retain: " << properties.retain << std::endl;
+  std::cout << "  len: " << len << std::endl;
+  std::cout << "  index: " << index << std::endl;
+  std::cout << "  total: " << total << std::endl;
+}
+
+void onMqttPublish(uint16_t packetId) {
+  std::cout << "Publish acknowledged." << std::endl;
+  std::cout << "  packetId: " << packetId << std::endl;
+}
+
+void ClientLoop(void* arg) {
+  (void) arg;
+  for(;;) {
+    mqttClient.loop();  // includes a yield
+    if (exitProgram) break;
+  }
+}
+
+int main() {
+  std::cout << "Setting up sample MQTT client" << std::endl;
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+
+  std::cout << "Starting sample MQTT client" << std::endl;
+  std::thread t = std::thread(ClientLoop, nullptr);
+
+  connectToMqtt();
+  
+  while(1) {
+    if (exitProgram) break;
+    std::this_thread::yield();
+  }
+  
+  t.join();
+  return EXIT_SUCCESS;
+}

lib/espMqttClient/examples/simple-linux/platformio.ini

@@ -0,0 +1,28 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+;[platformio]
+;default_envs = esp8266
+
+[common]
+build_flags =
+  -D DEBUG_ESP_MQTT_CLIENT=1
+  -std=c++11
+  -pthread
+  -Wall
+  -Wextra
+
+[env:native]
+platform = native
+build_flags =
+  ${common.build_flags}
+  -D EMC_RX_BUFFER_SIZE=1500
+build_type = debug
+lib_compat_mode  = off

lib/espMqttClient/examples/simpleAsync-esp32/simpleAsync-esp32.ino

@@ -0,0 +1,127 @@
+#include <WiFi.h>
+#include <Ticker.h>
+#include <espMqttClientAsync.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST IPAddress(192, 168, 1, 10)
+#define MQTT_PORT 1883
+
+espMqttClientAsync mqttClient;
+Ticker reconnectTimer;
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void WiFiEvent(WiFiEvent_t event) {
+  Serial.printf("[WiFi-event] event: %d\n", event);
+  switch(event) {
+  case SYSTEM_EVENT_STA_GOT_IP:
+    Serial.println("WiFi connected");
+    Serial.println("IP address: ");
+    Serial.println(WiFi.localIP());
+    connectToMqtt();
+    break;
+  case SYSTEM_EVENT_STA_DISCONNECTED:
+    Serial.println("WiFi lost connection");
+    reconnectTimer.once(5, connectToWiFi);
+    break;
+  default:
+    break;
+  }
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+  uint16_t packetIdSub = mqttClient.subscribe("foo/bar", 2);
+  Serial.print("Subscribing at QoS 2, packetId: ");
+  Serial.println(packetIdSub);
+  mqttClient.publish("foo/bar", 0, true, "test 1");
+  Serial.println("Publishing at QoS 0");
+  uint16_t packetIdPub1 = mqttClient.publish("foo/bar", 1, true, "test 2");
+  Serial.print("Publishing at QoS 1, packetId: ");
+  Serial.println(packetIdPub1);
+  uint16_t packetIdPub2 = mqttClient.publish("foo/bar", 2, true, "test 3");
+  Serial.print("Publishing at QoS 2, packetId: ");
+  Serial.println(packetIdPub2);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  Serial.println("Subscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+  for (size_t i = 0; i < len; ++i) {
+    Serial.print("  qos: ");
+    Serial.println(static_cast<uint8_t>(codes[i]));
+  }
+}
+
+void onMqttUnsubscribe(uint16_t packetId) {
+  Serial.println("Unsubscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  Serial.println("Publish received.");
+  Serial.print("  topic: ");
+  Serial.println(topic);
+  Serial.print("  qos: ");
+  Serial.println(properties.qos);
+  Serial.print("  dup: ");
+  Serial.println(properties.dup);
+  Serial.print("  retain: ");
+  Serial.println(properties.retain);
+  Serial.print("  len: ");
+  Serial.println(len);
+  Serial.print("  index: ");
+  Serial.println(index);
+  Serial.print("  total: ");
+  Serial.println(total);
+}
+
+void onMqttPublish(uint16_t packetId) {
+  Serial.println("Publish acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+  WiFi.onEvent(WiFiEvent);
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onUnsubscribe(onMqttUnsubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+
+  connectToWiFi();
+}
+
+void loop() {
+  // nothing to do here
+}

lib/espMqttClient/examples/simpleAsync-esp8266/simpleAsync-esp8266.ino

@@ -0,0 +1,123 @@
+#include <ESP8266WiFi.h>
+#include <Ticker.h>
+#include <espMqttClientAsync.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST IPAddress(192, 168, 1, 10)
+#define MQTT_PORT 1883
+
+WiFiEventHandler wifiConnectHandler;
+WiFiEventHandler wifiDisconnectHandler;
+espMqttClientAsync mqttClient;
+Ticker reconnectTimer;
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
+  Serial.println("Connected to Wi-Fi.");
+  connectToMqtt();
+}
+
+void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
+  Serial.println("Disconnected from Wi-Fi.");
+  reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
+  reconnectTimer.once(5, connectToWiFi);
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+  uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
+  Serial.print("Subscribing at QoS 2, packetId: ");
+  Serial.println(packetIdSub);
+  mqttClient.publish("test/lol", 0, true, "test 1");
+  Serial.println("Publishing at QoS 0");
+  uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
+  Serial.print("Publishing at QoS 1, packetId: ");
+  Serial.println(packetIdPub1);
+  uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
+  Serial.print("Publishing at QoS 2, packetId: ");
+  Serial.println(packetIdPub2);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  Serial.println("Subscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+  for (size_t i = 0; i < len; ++i) {
+    Serial.print("  qos: ");
+    Serial.println(static_cast<uint8_t>(codes[i]));
+  }
+}
+
+void onMqttUnsubscribe(uint16_t packetId) {
+  Serial.println("Unsubscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  Serial.println("Publish received.");
+  Serial.print("  topic: ");
+  Serial.println(topic);
+  Serial.print("  qos: ");
+  Serial.println(properties.qos);
+  Serial.print("  dup: ");
+  Serial.println(properties.dup);
+  Serial.print("  retain: ");
+  Serial.println(properties.retain);
+  Serial.print("  len: ");
+  Serial.println(len);
+  Serial.print("  index: ");
+  Serial.println(index);
+  Serial.print("  total: ");
+  Serial.println(total);
+}
+
+void onMqttPublish(uint16_t packetId) {
+  Serial.println("Publish acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+  wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
+  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onUnsubscribe(onMqttUnsubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+
+  connectToWiFi();
+}
+
+void loop() {
+  // nothing to do here
+}

lib/espMqttClient/examples/tls-esp32/tls-esp32.ino

@@ -0,0 +1,145 @@
+#include <WiFi.h>
+#include <Ticker.h>
+#include <espMqttClient.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST "mqtt.yourhost.com"
+#define MQTT_PORT 8883
+#define MQTT_USER "username"
+#define MQTT_PASS "password"
+
+const char rootCA[] = \
+  "-----BEGIN CERTIFICATE-----\n" \
+  " add your certificate here \n" \
+  "-----END CERTIFICATE-----\n";
+
+espMqttClientSecure mqttClient;
+Ticker reconnectTimer;
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void WiFiEvent(WiFiEvent_t event) {
+  Serial.printf("[WiFi-event] event: %d\n", event);
+  switch(event) {
+    case SYSTEM_EVENT_STA_GOT_IP:
+      Serial.println("WiFi connected");
+      Serial.println("IP address: ");
+      Serial.println(WiFi.localIP());
+      connectToMqtt();
+      break;
+    case SYSTEM_EVENT_STA_DISCONNECTED:
+      Serial.println("WiFi lost connection");
+      reconnectTimer.once(5, connectToWiFi);
+      break;
+    default:
+      break;
+  }
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+
+  uint16_t packetIdSub0 = mqttClient.subscribe("foo/bar/0", 0);
+  Serial.print("Subscribing at QoS 0, packetId: ");
+  Serial.println(packetIdSub0);
+
+  uint16_t packetIdPub0 = mqttClient.publish("foo/bar/0", 0, false, "test");
+  Serial.println("Publishing at QoS 0, packetId: ");
+  Serial.println(packetIdPub0);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  Serial.println("Subscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+  for (size_t i = 0; i < len; ++i) {
+    Serial.print("  qos: ");
+    Serial.println(static_cast<uint8_t>(codes[i]));
+  }
+}
+
+void onMqttUnsubscribe(uint16_t packetId) {
+  Serial.println("Unsubscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  Serial.println("Publish received.");
+  Serial.print("  topic: ");
+  Serial.println(topic);
+  Serial.print("  qos: ");
+  Serial.println(properties.qos);
+  Serial.print("  dup: ");
+  Serial.println(properties.dup);
+  Serial.print("  retain: ");
+  Serial.println(properties.retain);
+  Serial.print("  len: ");
+  Serial.println(len);
+  Serial.print("  index: ");
+  Serial.println(index);
+  Serial.print("  total: ");
+  Serial.println(total);
+}
+
+void onMqttPublish(uint16_t packetId) {
+  Serial.println("Publish acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+  WiFi.onEvent(WiFiEvent);
+
+  //mqttClient.setInsecure();
+  mqttClient.setCACert(rootCA);
+  mqttClient.setCredentials(MQTT_USER, MQTT_PASS);
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onUnsubscribe(onMqttUnsubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+  mqttClient.setCleanSession(true);
+
+  connectToWiFi();
+}
+
+void loop() {
+  static uint32_t lastMillis = 0;
+  if (millis() - lastMillis > 5000) {
+    lastMillis = millis();
+    Serial.printf("heap: %u\n", ESP.getFreeHeap());
+  }
+
+  static uint32_t millisDisconnect = 0;
+  if (millis() - millisDisconnect > 60000) {
+    millisDisconnect = millis();
+    mqttClient.disconnect();
+  }
+}

lib/espMqttClient/examples/tls-esp8266/tls-esp8266.ino

@@ -0,0 +1,127 @@
+#include <ESP8266WiFi.h>
+#include <Ticker.h>
+#include <espMqttClient.h>
+
+#define WIFI_SSID "yourSSID"
+#define WIFI_PASSWORD "yourpass"
+
+#define MQTT_HOST "test.mosquitto.org"
+#define MQTT_PORT 1883
+
+// test.mosquitto.org
+const uint8_t fingerprint[] = {0xee, 0xbc, 0x4b, 0xf8, 0x57, 0xe3, 0xd3, 0xe4, 0x07, 0x54, 0x23, 0x1e, 0xf0, 0xc8, 0xa1, 0x56, 0xe0, 0xd3, 0x1a, 0x1c};
+
+WiFiEventHandler wifiConnectHandler;
+WiFiEventHandler wifiDisconnectHandler;
+espMqttClientSecure mqttClient;
+Ticker reconnectTimer;
+
+void connectToWiFi() {
+  Serial.println("Connecting to Wi-Fi...");
+  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+}
+
+void connectToMqtt() {
+  Serial.println("Connecting to MQTT...");
+  mqttClient.connect();
+}
+
+void onWiFiConnect(const WiFiEventStationModeGotIP& event) {
+  Serial.println("Connected to Wi-Fi.");
+  connectToMqtt();
+}
+
+void onWiFiDisconnect(const WiFiEventStationModeDisconnected& event) {
+  Serial.println("Disconnected from Wi-Fi.");
+  reconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
+  reconnectTimer.once(5, connectToWiFi);
+}
+
+void onMqttConnect(bool sessionPresent) {
+  Serial.println("Connected to MQTT.");
+  Serial.print("Session present: ");
+  Serial.println(sessionPresent);
+  uint16_t packetIdSub = mqttClient.subscribe("test/lol", 2);
+  Serial.print("Subscribing at QoS 2, packetId: ");
+  Serial.println(packetIdSub);
+  mqttClient.publish("test/lol", 0, true, "test 1");
+  Serial.println("Publishing at QoS 0");
+  uint16_t packetIdPub1 = mqttClient.publish("test/lol", 1, true, "test 2");
+  Serial.print("Publishing at QoS 1, packetId: ");
+  Serial.println(packetIdPub1);
+  uint16_t packetIdPub2 = mqttClient.publish("test/lol", 2, true, "test 3");
+  Serial.print("Publishing at QoS 2, packetId: ");
+  Serial.println(packetIdPub2);
+}
+
+void onMqttDisconnect(espMqttClientTypes::DisconnectReason reason) {
+  Serial.printf("Disconnected from MQTT: %u.\n", static_cast<uint8_t>(reason));
+
+  if (WiFi.isConnected()) {
+    reconnectTimer.once(5, connectToMqtt);
+  }
+}
+
+void onMqttSubscribe(uint16_t packetId, const espMqttClientTypes::SubscribeReturncode* codes, size_t len) {
+  Serial.println("Subscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+  for (size_t i = 0; i < len; ++i) {
+    Serial.print("  qos: ");
+    Serial.println(static_cast<uint8_t>(codes[i]));
+  }
+}
+
+void onMqttUnsubscribe(uint16_t packetId) {
+  Serial.println("Unsubscribe acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void onMqttMessage(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total) {
+  Serial.println("Publish received.");
+  Serial.print("  topic: ");
+  Serial.println(topic);
+  Serial.print("  qos: ");
+  Serial.println(properties.qos);
+  Serial.print("  dup: ");
+  Serial.println(properties.dup);
+  Serial.print("  retain: ");
+  Serial.println(properties.retain);
+  Serial.print("  len: ");
+  Serial.println(len);
+  Serial.print("  index: ");
+  Serial.println(index);
+  Serial.print("  total: ");
+  Serial.println(total);
+}
+
+void onMqttPublish(uint16_t packetId) {
+  Serial.println("Publish acknowledged.");
+  Serial.print("  packetId: ");
+  Serial.println(packetId);
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+  wifiConnectHandler = WiFi.onStationModeGotIP(onWiFiConnect);
+  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWiFiDisconnect);
+
+  mqttClient.onConnect(onMqttConnect);
+  mqttClient.onDisconnect(onMqttDisconnect);
+  mqttClient.onSubscribe(onMqttSubscribe);
+  mqttClient.onUnsubscribe(onMqttUnsubscribe);
+  mqttClient.onMessage(onMqttMessage);
+  mqttClient.onPublish(onMqttPublish);
+  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
+  mqttClient.setFingerprint(fingerprint);
+
+  connectToWiFi();
+}
+
+void loop() {
+  mqttClient.loop();
+}