Completely reworked Advanced Thermostat example

Jeroen88
1 parent 2b5c768b
Showing 8 changed files with 1997 additions and 128 deletions
examples/Advanced_Thermostat/Advanced_Thermostat.ino
examples/Advanced_Thermostat/JSONs.h
examples/Advanced_Thermostat/MQTTHelpers.cpp
examples/Advanced_Thermostat/MQTTHelpers.h
examples/Advanced_Thermostat/OpenThermHelpers.cpp
examples/Advanced_Thermostat/OpenThermHelpers.h
examples/Advanced_Thermostat/ThermoStateMachine.cpp
examples/Advanced_Thermostat/ThermoStateMachine.h
@@ -2,10 +2,70 @@
  *    https://github.com/Jeroen88/EasyOpenTherm
  *    https://www.tindie.com/products/Metriot/OpenTherm-adapter/
  *
- *    Advanced_Thermostat is a program to demonstrate a real working thermostat.
- *    A temperature sensor is used to measure room temperature. A fixed room
- *    setpoint is used. Ofcourse for a real life thermostat this should be 
- *    adjustable. Please adapt the program to your needs.
+ *    This software needs an OpenTherm controller like 
+ *    https://www.tindie.com/products/Metriot/OpenTherm-adapter/ or
+ *    https://www.tindie.com/products/Metriot/OpenTherm-adapter/ connected to a BOILER  SUPPORTING
+ *    THE OPENTHERM PROTOCOL, an ESP32-S2 mini, ESP32-C3 mini or ESP-D1 mini flashed with this 
+ *    software and Home Assistant or any other MQTT enabled home automation environment.
+ *
+ *    MQTT_Advanced_Thermostat is a real working thermostat over MQTT. It offers a HIGH LEVEL API
+ *    (OFF / HEAT / COOL / AUTO and room temperature setpoint) to control your boiler from any other 
+ *    system.
+ *    
+ *    It is SUPPOSED TO LOWER your energy bills, because  it modulates the boiler's maximum power. This 
+ *    MAY lead to a LONGER PERIOD OF TIME before your room temperature setpoint is reached. If you are 
+ *    not happy with it's present behaviour, please change any of the settings or program your OWN
+ *    heating or cooling STRATEGY!
+ *
+ *    The easiest way to use this thermostat is from Home Assistant:
+ *    - Set up a MQTT broker and integration in Home Assistant, if not already done
+ *      (https://www.home-assistant.io/integrations/mqtt/). The MQTT broker should be reachable without
+ *      using certificates (TLS).
+ *    - Change the WiFi credentials and MQTT credentials in this software
+ *    - Flash this software to a ESP mini, connect the ESP to the OpenTherm Adapter and connect the
+ *      OpenTherm Adapter to the boiler with the two wires of your present thermostat (replace it)
+ *    THAT'ALL, all integrations should automatically appear in Home Assistant and be active!
+
+ *    Although it is designed to work with Home Assistant and it's MQTT integration, it can fucntion
+ *    in any home automation system as long as it has an MQTT integration.
+ *    This program is developed and tested for a boiler, but could be easily adapted to work with HVAC
+ *    systems too.
+ *    Domestic Hot Water is supported if present (enabled by default and a sensor shows if the boiler
+ *    is running for DHW). A secondary Heating cicuit (CH2) is not supported nor is Outside Temperature
+ *    Compensation (OTC). If the boiler supports cooling too this is supported (though not tested).
+ *    The Home Assistant MQTT Auto Discovery feature is used to automatically add a Climate (thermostat)
+ *    entity to the user interface. Also several other sensors are added, like flame on / off, boiler
+ *    flow and return water temperatures, WiFi RSSI, boiler water pressure, etc, depending on the 
+ *    boiler's capabilities.
+ *
+ *    This thermostat subscribes to a MQTT topic, Metriot/EasyOpenTherm/112233445566/climate/state
+ *    (with 112233445566 being replaced by an unique chip ID) to receive a (frequent) room temperature 
+ *    update. THIS THERMOSTAT CAN NOT FUNCTION WITHOUT A REGULAR TEMPERATURE UPDATE. Temperature updates 
+ *    should be send in the format {"temperature": 20,1}.
+ *    
+ *    This thermostat subscribes to a MQTT topic, Metriot/EasyOpenTherm/112233445566/mode/set
+ *    to receive a mode (OFF, HEAT, COOL or AUTO). THIS THERMOSTAT CAN NOT FUNCTION WITHOUT A
+ *    A MODE UPDATE, since it starts in 'OFF' state. Mode updates should be send as plain text without
+ *    any leading or trailing spaces, in capitals, e.g. HEAT.
+ *    
+ *    This thermostat publishes to a MQTT topic, Metriot/EasyOpenTherm/112233445566/climate/state
+ *    the local temperature measures by an onboard sensor. The value message is a JSON, e.g.:
+ *    {"local_temperature": 20.1}. The software already has support for a Dallas Sensor that can be
+ *    enabled by defining the one wire pin the sensor is connected to (const int oneWireBus). If you want
+ *    to use this temerature as room temperature, you have to write an automationm that subscribes to the
+ *    above topic, extracts the temperature and publishes it in the right format to the room temperature
+ *    update topic.
+ *    
+ *    Unlike other examples on the internet, MQTT_Advanced_Thermostat already is a fully functional 
+ *    thermostat: just configure it once change the room temperature setpoint any time you want to.
+ *
+ *    Use your home automation system, like Home Assistant or Domoticz, to create e.g. schedules
+ *    and geo fencing, and have this program control your boiler by just setting the room 
+ *    temperature setpoint (and switching it on and off if the boiler supports cooling)
+ *
+ *    Please note that after a reboot or a power cycle the thermostat starts in 'OFF' mode. This
+ *    means that it will never activate the boiler after such an event. An 'ON' request is needed to 
+ *    (re-)activate the boiler.
  *
  *    Copyright (C) 2022  Jeroen Döll <info@metriot.nl>
  *
@@ -28,52 +88,155 @@
  *    Connect the OpenTherm TXD pin to the microcontroller's pin defined by #define OT_RX_PIN.
  *    Connect the OpenTherm RXD pin to the microcontroller's pin defined by #define OT_TX_PIN.
  *
- *    Connect the BME280 temperature sensor SDA pin to the microcontroller's pin defined by #define I2C_SDA_PIN
- *    Connect the BME280 temperature sensor SCL pin to the microcontroller's pin defined by #define I2C_SCL_PIN
- *    Check your sensor's address, it may differ from the value defined by #define BME_ADDRESS (0x76)
- *    Install the Adafruit BME280 library
- *    Any other temperature sensor may be used, like a Dallas sensor, BME380, BMP380, BME680 if you adapt the program accordingly.
+ *    You can also use this shield  <https://www.tindie.com/products/jeroen88/opentherm-controller/> and an
+ *    ESP32-S2 mini, an ESP32-C3 mini or an ESP D1 mini. With this shield all pins are already connected. The only thing you 
+ *    have to connect are the two OpenTherm thermostat wires.
  *
- *    Define the room temperature setpoint (desired room temperature) using #define ROOM_TEMPERATURE_SETPOINT. In a real application this should be settable.
- *    Eventually define the maximum central heating boiler temperature setpoint using #define CH_MAX_SETPOINT. 
+ *    If needed, connect a Dallas Temperature Sensor to the right pin or, if you use the above shield, use the onboard sensor.
+ *    Make sure though that the mesured temperature is not influenced too much by the heat produced by the processor. An 
+ *    ESP32-S2 e.g. becomes too hot.
+ *    Any other temperature sensor may be used, like a BME280, BME380, BMP380, BME680 if you adapt the program accordingly.
  *
- *    Compile and upload the program as normal. If the temperature measured by your sensor is lower than the ROOM_TEMPERATURE_SETPOINT this thermostat program will actually begin to heat up your room
-*/
+ *    I hope you enjoy working with this library, please share ideas in the Github Discussions sessions of this library.
+ */
  
  
+static const char * TAG = __FILE__;
+
+#if !defined(ESP32) && !defined(ESP_LOGE)
+#define ESP_LOGE(...)
+#define ESP_LOGI(...)
+#define ESP_LOGV(...)
+#endif
+
 #include <Arduino.h>
  
+#include <WiFi.h>
+
+#include <time.h>
+
+#include <ArduinoJson.h>
+
+// This example does not use the more popular PubSubClient, because that has too many issues, like losing a connection without possibilities to signal it and correct it
+// This MQTT client runs rock solid :)
+// https://github.com/monstrenyatko/ArduinoMqtt
+// Enable MqttClient logs
+#define MQTT_LOG_ENABLED 1
+// Include library
+#include <MqttClient.h>
+
+
+#include <OneWire.h>
+#include <DallasTemperature.h>
+
+#include <PubSubClient.h>
+
 #include <EasyOpenTherm.h>
  
-// ESP32-S2
+#include "OpenThermHelpers.h"
+#include "JSONs.h"
+#include "MQTTHelpers.h"
+#include "ThermoStateMachine.h"
+
+
+// Update these with values suitable for your network.
+const char * ssid = "H369A394602";
+const char * password = "445396F996E9";
+
+
+// Update these with values suitable for your MQTT broker, in this example TLS or certificates are not used
+const char * mqtt_server = "homeassistant.local";
+const char * mqtt_user = "mosquitto";
+const char * mqtt_password = "M0squ1tt0";
+
+
+// Your time zone, used to display times correctly (and needed for WiFiClientSecure TLS certificate validation, if used)
+#define TZ_Europe_Amsterdam	"CET-1CEST,M3.5.0,M10.5.0/3"
+#define TIME_ZONE TZ_Europe_Amsterdam
+
+
+// Define OT_RX_PIN, the GPIO pin used to read data from the boiler or HVAC. Must support interrupts
+// Define OT_TX_PIN, the GPIO pin used to send data to the boiier or HVAC. Must not be a 'read only' GPIO
+// Define DALLAS, the GPIO pin used for the Dallas sensor, if used
+
+#if defined(ARDUINO_LOLIN_S2_MINI)
 #define OT_RX_PIN (35)
 #define OT_TX_PIN (33)
+#define DALLAS (11)
+#elif defined(ARDUINO_LOLIN_C3_MINI)
+#define OT_RX_PIN (10)
+#define OT_TX_PIN (8)
+#define DALLAS (4)
+#else
+#define OT_RX_PIN (35)
+#define OT_TX_PIN (33)
+#define DALLAS (-1)
+#endif
+
+// The maximum room temperature
+#define ROOM_TEMPERATURE_MAX_SETPOINT (30.0f)
+// The minimum room temperature
+#define ROOM_TEMPERATURE_MIN_SETPOINT (10.0f)
+// The maximum Central Heating boiler temperature. If your house is well isolated and/or you have low temperature radiators this could be as low as 40.0f
+#define CH_MAX_SETPOINT (60.0f)
+// The minimum Central Heating boiler temperature. If the boiler can cool set this to a realistic minimum temperature. If the boiler can only heat, this value
+// is also used as an extra way to switch the boiler OFF
+#define CH_MIN_SETPOINT (10.0f)
+
+// Cheap sensor tend to be inaccurate. Accuracy can be increased by adding two temperatures as measured by the sensor and the 'real' temperature as measured with a calibrated thermometer
+// If your sensor is accurate or if you do not want to use this feature, set measured and calibrated values to the same value
+// Make sure that the lower temperatures and higher temperatures are a few degrees apart. Ideal would be to use temperatures around the minimum room temperature setpoint and the maximum room 
+// temperature setpoint
+// Make sure that the difference between both lower temperatures and both higher temperatures is about the same, otherwise your temperature sensor is really bad and you might get strange results 
+// from recalculateTemperatures();
+// Only used for (on board) temperature sensors, the room temperature coming in from MQTT is deemed to be correct
+// https://www.letscontrolit.com/wiki/index.php?title=Basics:_Calibration_and_Accuracy
+#define LOWER_MEASURED_TEMPERATURE (15.0)
+#define LOWER_CALIBRATED_TEMPERATURE (15.0)
+#define HIGHER_MEASURED_TEMPERATURE (20.0)
+#define HIGHER_CALIBRATED_TEMPERATURE (20.0)
  
-#define BME_ADDRESS (0x76)
-#define I2C_SDA_PIN (8)
-#define I2C_SCL_PIN (9)
  
+// Interval for publishing the thermostat state information (in seconds)
+#define PUBLISH_STATE_UPDATE_INTERVAL (10)
  
-#define ROOM_TEMPERATURE_SETPOINT (18.5f)       // The desired room temperature
-#define CH_MAX_SETPOINT (60.0f)                 // If your house is well isolated and/or you have low temperature radiators this could be as low as 40.0f
-#define CH_MIN_SETPOINT (10.0f)                 // If the boiler starts it will warm up untill at least this temperature (unless the desired room temperature is reached before)
+// Minimum interval for running the PID controller (in seconds)
+#define PID_INTERVAL_S (5)
  
-#define BOILER_ENABLE_HEATING (true)            // If the boiler supports Central Heating (CH), use the boiler for heating
-#define BOILER_ENABLE_COOLING (true)            // If the boiler supports cooling, use the boiler for cooling
-#define BOILER_ENABLE_DOMESTIC_HOT_WATER (true) // If the boiler supports Domestic Hot Water (DHW), use the boiler for DHW
  
-#include <Wire.h>
-#include <Adafruit_Sensor.h>
-#include <Adafruit_BME280.h>
+// MQTT client message buffer sizes, must be big enough to store a full message
+const size_t MSG_BUFFER_SEND_SIZE = 2 * 1024;
+const size_t MSG_BUFFER_RECV_SIZE = 256;  // Too small a receive buffer will fail on receiving subscribed topics...
+
+// Define a global WiFiClient instance for WiFi connection
+WiFiClient  wiFiClient;
+
+#define MQTT_ID	"EasyOpenTherm"
+static MqttClient *mqtt = NULL;
+
+
+// GPIO where the DS18B20 is connected to, set to '-1' if not used
+//const int oneWireBus = DALLAS;
+const int oneWireBus = -1;
+
+// Define a pointer to oneWire instance to communicate with any OneWire devices
+OneWire * oneWire = nullptr;
+
+// Define a pointer to DallasTemperature instance to communicate with any OneWire devices
+DallasTemperature * dallasSensors = nullptr;
+
+
+// Create a global OpenTherm instance called 'thermostat' (i.e primary and boiler is secondary) with OT_RX_PIN to receive data from boiler and OT_TX_PIN to send data to boiler
+// Only one OpenTherm object may be created!
+OpenTherm thermostat(OT_RX_PIN, OT_TX_PIN);
  
-Adafruit_BME280 bme; // I2C
  
 // Use a PID controller to calculate the CH setpoint. See e.g. https://en.wikipedia.org/wiki/PID_controller
 float pid(float                                 sp, 
           float                                 pv, 
           float                                 pv_last, 
           float &                               ierr, 
-          float dt) {
+          float                                 dt) {
   float KP = 30;
   float KI = 0.02;
  
@@ -90,140 +253,592 @@ float pid(float                                 sp,
   }
   ierr = I;
  
+  op = roundf(op * 10.0f) / 10.0f;  // Round to one decimal
+  
   return op;
 }
  
  
+// Lineair recalculation of the temperature measured by the sensor using two calibrated temperatures. Round to two decimals
+float recalculateTemperature(float temperature) {
+  // y = ax + b
+  if(LOWER_MEASURED_TEMPERATURE == HIGHER_MEASURED_TEMPERATURE) return temperature;     // Lower and higher temperatures should be a few degrees apart, so this is wrong. Return the measured temperature
+  float a = float(HIGHER_CALIBRATED_TEMPERATURE - LOWER_CALIBRATED_TEMPERATURE) / float(HIGHER_MEASURED_TEMPERATURE - LOWER_MEASURED_TEMPERATURE);
+  float b = float(LOWER_CALIBRATED_TEMPERATURE) - a * float(LOWER_MEASURED_TEMPERATURE);
+  return roundf(100.0f * a * (temperature + b)) / 100.0f;
+}
+
+
+// Global variables that are set by incoming MQTT messages and used by loop()
+// Global variable to store the room temperature setpoint. 
+float roomTemperatureSetpoint = ROOM_TEMPERATURE_MIN_SETPOINT;
+// Global variable to store OFF/AUTO/HEAT/COOL requests to the boiler
+ThermostatRequest thermostatRequest = ThermostatRequest::NONE;
+// Global variable to keep track of the lastest room temperature update timestamp (in seconds)
+uint32_t roomTemperatureTimestampS = 0;
+// Global variable to store the room temperature
+float roomTemperature;
+
+
+// ============== Subscription callbacks ========================================
+void processRoomTemperatureMessage(MqttClient::MessageData& md) {
+Serial.println("processRoomTemperatureMessage");
+	const MqttClient::Message& msg = md.message;
+	char payload[msg.payloadLen + 1];
+	memcpy(payload, msg.payload, msg.payloadLen);
+	payload[msg.payloadLen] = '\0';
+
+  StaticJsonDocument<32> roomTemperatureMsgDoc;
+  DeserializationError error = deserializeJson(roomTemperatureMsgDoc, payload);
+  if(error) {
+    ESP_LOGE(TAG, "Parsing JSON payload failed (%s): '%s'", error.f_str(), payload);
+Serial.printf("Parsing JSON payload failed (%s): '%s'\n", error.f_str(), payload);
+
+    return;
+  }
+  
+  if(!roomTemperatureMsgDoc.containsKey("temperature")) {
+    ESP_LOGE(TAG, "\"temperature\" tag is missing in JSON payload: '%s'", payload);
+Serial.printf("\"temperature\" tag is missing in JSON payload: '%s'\n", payload);
+
+    return;
+  }
+
+// What if {"temperature":15.3} a non float value is send? Value will evaluate to zero, which is also a valid temperature...
+
+  ESP_LOGI(TAG, "Received room temperature '%s'", payload);
+  roomTemperatureTimestampS = time(nullptr);
+  roomTemperature = roomTemperatureMsgDoc["temperature"];
+Serial.printf("Received room temperature %.01f ºC\n", roomTemperature);
+}
+
+
+void processSetpointTemperatureMessage(MqttClient::MessageData& md) {
+	const MqttClient::Message& msg = md.message;
+	char payload[msg.payloadLen + 1];
+	memcpy(payload, msg.payload, msg.payloadLen);
+	payload[msg.payloadLen] = '\0';
+
+  float setpoint;
+  if(sscanf(payload, "%f", &setpoint) != 1) {
+    ESP_LOGE(TAG, "Payload is not a float: '%s'", payload);
+
+    return;
+  }
+  
+  ESP_LOGI(TAG, "Received room temperature setpoint '%s'", payload);
+Serial.printf("Received room temperature setpoint '%s'\n", payload);
+  roomTemperatureSetpoint = setpoint;
+}
+
+
+void processClimateMessage(MqttClient::MessageData& md) {
+	const MqttClient::Message& msg = md.message;
+	char payload[msg.payloadLen + 1];
+	memcpy(payload, msg.payload, msg.payloadLen);
+	payload[msg.payloadLen] = '\0';
+	ESP_LOGI(TAG,
+		"Message arrived: qos %d, retained %d, dup %d, packetid %d, payload:[%s]",
+		msg.qos, msg.retained, msg.dup, msg.id, payload
+	);
+Serial.printf("processClimateMessage PAYLOAD: '%s'\n", payload);
+  ESP_LOGI(TAG, "processClimateMessage PAYLOAD: '%s'", payload);
+
+  if(strcasecmp(payload, "off") == 0) {
+    thermostatRequest = ThermostatRequest::OFF;
+  } else if(strcasecmp(payload, "auto") == 0) {
+    thermostatRequest = ThermostatRequest::AUTO;
+  } else if(strcasecmp(payload, "heat") == 0) {
+    thermostatRequest = ThermostatRequest::HEAT;
+  } else if(strcasecmp(payload, "cool") == 0) {
+    thermostatRequest = ThermostatRequest::COOL;
+  }
+}
+
+
 void setup() {
   Serial.begin(115200);
   delay(5000);                                                     // For debug only: give the Serial Monitor some time to connect to the native USB of the MCU for output
   Serial.println("\n\nStarted");
+  Serial.printf("Chip ID is %s\n", chipID());
+  ESP_LOGI(TAG, "Chip ID is %s", chipID());
+
+  Serial.printf("OpenTherm RX pin is %d, TX pin is %d\n", OT_RX_PIN, OT_TX_PIN);
+
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  // Connect WiFi
+  WiFi.mode(WIFI_STA);
+  WiFi.setAutoReconnect(true);
+  WiFi.begin(ssid, password);
+
+  uint32_t startMillis = millis();  
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    digitalWrite(LED_BUILTIN, digitalRead(LED_BUILTIN) == LOW ? HIGH : LOW);
  
-  Serial.println(F("\n-- BME280 test --"));
-  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
+    if(millis() - startMillis > 15000) ESP.restart();
+  }
+
+  ESP_LOGI(TAG, "WiFi connected to %s", ssid);
+  ESP_LOGI(TAG, "IP address: %s", WiFi.localIP().toString().c_str());
+
+// Set time and date, necessary for HTTPS certificate validation
+  configTzTime(TIME_ZONE, "pool.ntp.org", "time.nist.gov");
+  setenv("TZ", TIME_ZONE, 1); // Set environment variable with your time zone
+  tzset();
  
-  bool status = bme.begin(BME_ADDRESS);  
-  if (!status) {
-    Serial.println("Could not find a valid BME280 sensor, check wiring and address!");
-    while (1);
+  Serial.println("Waiting for NTP time sync: ");
+  time_t now = time(nullptr);
+  startMillis = millis();
+  while (now < 8 * 3600 * 2) {
+    delay(100);
+    digitalWrite(LED_BUILTIN, digitalRead(LED_BUILTIN) == LOW ? HIGH : LOW);
+    Serial.print(".");
+    now = time(nullptr);
+
+    if(millis() - startMillis > 15000) ESP.restart();
   }
-  Serial.println("-- Temperature sensor present --");
+  digitalWrite(LED_BUILTIN, LOW);
+  Serial.println();
+
+  const struct tm  * timeinfo = localtime(&now);
+  Serial.printf("%s %s", tzname[0], asctime(timeinfo));
  
-  bme.setSampling();
+  if(oneWireBus != -1) {
+    oneWire = new OneWire(oneWireBus);
+    dallasSensors = new DallasTemperature(oneWire);
+
+    // Start the DS18B20 sensor
+    dallasSensors->begin();
+    dallasSensors->setWaitForConversion(false);
+    dallasSensors->requestTemperatures(); 
+
+  }
+
+	// Setup MQTT client
+	MqttClient::System *mqttSystem = new System;
+#if defined(ARDUINO_LOLIN_S2_MINI)
+  MqttClient::Logger *mqttLogger = new MqttClient::LoggerImpl<USBCDC>(Serial);
+#elif defined(ARDUINO_LOLIN_C3_MINI)
+  MqttClient::Logger *mqttLogger = new MqttClient::LoggerImpl<HWCDC>(Serial);
+#else
+  MqttClient::Logger *mqttLogger = new MqttClient::LoggerImpl<HardwareSerial>(Serial);
+#endif
+	MqttClient::Network * mqttNetwork = new MqttClient::NetworkClientImpl<WiFiClient>(wiFiClient, *mqttSystem);
+	//// Make MSG_BUFFER_SIZE bytes send buffer
+	MqttClient::Buffer *mqttSendBuffer = new MqttClient::ArrayBuffer<MSG_BUFFER_SEND_SIZE>();
+	//// Make MSG_BUFFER_SIZE bytes receive buffer
+	MqttClient::Buffer *mqttRecvBuffer = new MqttClient::ArrayBuffer<MSG_BUFFER_RECV_SIZE>();
+	//// Allow up to 4 subscriptions simultaneously
+  MqttClient::MessageHandlers *mqttMessageHandlers = new MqttClient::MessageHandlersDynamicImpl<4>();
+  // Note: the MessageHandlersDynamicImpl does not copy the topic string. The second parameter to MessageHandlersStaticImpl is the maximum topic size
+  // NOT TRUE: https://github.com/monstrenyatko/ArduinoMqtt/blob/15091f0b8c05f843f93b73db9a98f7b59ffb4dfa/src/MqttClient.h#L390
+//  MqttClient::MessageHandlers *mqttMessageHandlers = new MqttClient::MessageHandlersStaticImpl<4, 128>();
+	//// Configure client options
+	MqttClient::Options mqttOptions;
+	////// Set command timeout to 10 seconds
+	mqttOptions.commandTimeoutMs = 10000;
+	//// Make client object
+	mqtt = new MqttClient(mqttOptions, *mqttLogger, *mqttSystem, *mqttNetwork, *mqttSendBuffer,	*mqttRecvBuffer, *mqttMessageHandlers);
+
+  wiFiClient.connect(mqtt_server, 1883);
+  if(!wiFiClient.connected()) {
+    ESP_LOGE(TAG, "Can't establish the TCP connection");
+    delay(5000);
+    ESP.restart();
+  }
+
+  Serial.println("Connect MQTT client...");
+
+  bool MQTTConnected = connectMQTT(*mqtt, MQTT_ID, mqtt_user, mqtt_password);
+  if(MQTTConnected) {
+    ESP_LOGI(TAG, "MQTT connected");
+Serial.println("MQTT connected");
+  } else {
+    ESP_LOGI(TAG, "MQTT NOT connected");
+Serial.println("MQTT NOT connected");
+    delay(30000);
+
+    return;
+  }
+
+  // Set all IDs for all discovery messages
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_RSSI_SENSOR);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR);
+  discoveryMessageSetIDs(EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR);
+
+  // Check all JSONs by parsing the JSONs
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_RSSI_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RSSI_SENSOR);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR);
+  if(!validJson(EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR)) Serial.printf("Invalid JSON '%s'\n", EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR);
+
+  // Add all 'always present' entities (the other entities are added only if supported by the boiler)
+  addEntity(*mqtt, "climate", "climate", EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE);
+  addEntity(*mqtt, "sensor", "boiler_setpoint", EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR);
+  addEntity(*mqtt, "sensor", "thermostat_rssi", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RSSI_SENSOR);
+  addEntity(*mqtt, "binary_sensor", "boiler_flame", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR);
+
+  char payload[16];
+  snprintf(payload, sizeof payload, "%.01f", ROOM_TEMPERATURE_MIN_SETPOINT);
+  // Set all sensors, except those that are directly updated, to 'None', the binary sensor to 'Unknown'
+  publish(*mqtt, topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR), "{\"ch_setpoint\":\"None\"}");
+  publish(*mqtt, topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR), "{\"flow_temperature\":\"None\"}");
+  publish(*mqtt, topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR), "{\"return_temperature\":\"None\"}");
+  publish(*mqtt, topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR), "{\"water_pressure\":\"None\"}");
+  publish(*mqtt, topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR), "{\"relative_modulation\":\"None\"}");
+  publish(*mqtt, topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR), "{\"flame\":\"None\"}");
+  publish(*mqtt, topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR), "{\"dhw\":\"None\"}");
  
   Serial.println("Setup done, start loop...");
 }
  
  
-void loop() {
-  // Create an OpenTherm thermostat (boiler is secondary) with OT_RX_PIN to receive data from boiler and OT_TX_PIN to send data to boiler
-  // Only one OpenTherm object may be created!
-  static OpenTherm thermostat(OT_RX_PIN, OT_TX_PIN);
-
-  // static variables used by the PID controller
-  static uint32_t previousTimestamp = millis();                // Previous timestamp
-  static float previousTemperature = bme.readTemperature();  // Previous temperature
-  static float ierr = 0;                                     // Integral error
+// updateClimateEntity()
+// If the boikler can both heat and cool adds 'auto', 'off', 'cool' and 'heat' to the thermmostat modes
+// If the boikler can only heat adds 'off' and 'heat' to the thermmostat modes
+void updateClimateEntity(bool                           canCool) {
+  StaticJsonDocument<fullJsonDocSize> discoveryMsgDoc;
  
-  
-  uint32_t timestamp = millis();
-  if(timestamp - previousTimestamp >= 1000) {
-    float roomTemperature = bme.readTemperature();           // Read the sensor to get the current room temperature
-    Serial.printf("Room temperature is %.02f *C, room temperature setpoint is %.02f *C\n", roomTemperature, ROOM_TEMPERATURE_SETPOINT);
-
-    float dt = (timestamp - previousTimestamp) / 1000.0;     // Time between measurements in seconds
-    float CHSetpoint = pid(ROOM_TEMPERATURE_SETPOINT, roomTemperature, previousTemperature, ierr, dt);
-    previousTimestamp = timestamp;
-    previousTemperature = roomTemperature;
-
-    Serial.printf("New Central Heating (CH) setpoint computed by PID is %.02f\n", CHSetpoint);
-
-
-    // First try to connect to the boiler to read it's capabilities. The boiler returns an 8 bit secondaryFlags and each bit has a meaning. The bits are defined in enum class OpenTherm::CONFIGURATION_FLAGS
-    // The secondaryMemberIDCode identifies the manufacturer of the boiler
-    uint8_t secondaryFlags;
-    uint8_t secondaryMemberIDCode;
-    if(thermostat.read(OpenTherm::READ_DATA_ID::SECONDARY_CONFIGURATION, secondaryFlags, secondaryMemberIDCode)) {      // Mandatory support
-      Serial.printf("Secondary configuration flags is 0x%02x, boiler manufacturer's ID is %d (0x%02x)\n", secondaryFlags, secondaryMemberIDCode, secondaryMemberIDCode);
-      if(secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_DHW_PRESENT)) Serial.println("Domestic Hot Water (DHW) present"); else Serial.println("Domestic Hot Water (DHW) not present");
-      if(secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_CONTROL_TYPE)) Serial.println("Control type on/off"); else Serial.println("Control type modulating");
-      if(secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_COOLING)) Serial.println("Cooling supprted"); else Serial.println("Cooling not supported");
-      if(secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_DHW)) Serial.println("Domestic Hot Water (DHW) storage tank"); else Serial.println("Domestic Hot Water (DHW) instantaneous or not-specified"); 
-      if(secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_LOW_OFF_PUMP_CTRL)) Serial.println("Low off and pump control not allowed"); else Serial.println("Low off and pump control allowed");
-      if(secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_CH2_PRESENT)) Serial.println("Second Centrel Heating system (CH2) present"); else Serial.println("Second Central Heating system (CH2) not present");
+  if(discoveryMsgToJsonDoc(discoveryMsgDoc, EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE)) {
+    JsonArray modesArray = discoveryMsgDoc["modes"];
+    if(canCool) {
+      modesArray.add("auto");
+      modesArray.add("off");
+      modesArray.add("cool");
     } else {
-      secondaryFlags = 0;
-
-      if(thermostat.error() == OpenTherm::ERROR_CODES::UNKNOWN_DATA_ID) {
-        // Valid data is received but the for boilers mandatory DATA-ID OpenTherm::READ_DATA_ID::SECONDARY_CONFIGURATION is not recognised. This is not a boiler but another device!
-        Serial.println("Your remote device is not a boiler");
-      } else {
-        // No data or invalid data received
-        Serial.println("Failed to get secondary configuration; is a boiler connected?");
-      }
-
-      // Wait 5 secs and try again
-      delay(5000);
-      return;
+      modesArray.add("off");        
     }
+    modesArray.add("heat");
+
+    addEntity(*mqtt, "climate", "climate", discoveryMsgDoc);
+
+    const char * availabilityTopic = topicByReference("availability_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE);
+    publish(*mqtt, availabilityTopic, "{\"climate_available\":\"ONLINE\"}");
+  }
+}
+
+
+// Adds a DHW binary sensor entity, only if the boiler can run for Domestic Hot Water
+void updateDHWEntity(bool                             enableDHW) {
+  if(enableDHW) {
+    addEntity(*mqtt, "binary_sensor", "boiler_dhw", EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR);
  
-    // Tell the boiler the desired CH boiler water temperature 
-    // This is done by writing this value to DATA-ID OpenTherm::WRITE_DATA_ID::CONTROL_SETPOINT_CH
-    if(thermostat.write(OpenTherm::WRITE_DATA_ID::CONTROL_SETPOINT_CH, CHSetpoint)) {
-      Serial.printf("Central Heating (CH) temperature setpoint set to %.01f *C\n", CHSetpoint);
+    const char * topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR);
+    publish(*mqtt, topic, "{\"dhw\":\"OFF\"}");
+  } else {
+    addEntity(*mqtt, "binary_sensor", "boiler_dhw", "");
+  }
+}
+
+
+// updateFlameSensor
+// Update the value of the flame sensor in Home Assistant. Usually this sensor reacts within one second
+// If the sensor is 'ON' the boiler is running for Central Heating or Domestic Hot Water (see updateDHWSensor to see which is active)
+// If the sensor is 'OFF' the boiler is idle (no heat demand)
+void updateFlameSensor(uint8_t                          statusFlags) {
+  static bool flameSensorInitialised = false;
+  static uint8_t previousStatusFlags = 0;
+Serial.printf("Secondary status flags is 0x%02x\n", statusFlags);
+
+  if(!flameSensorInitialised || (statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_FLAME_STATUS)) != (previousStatusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_FLAME_STATUS))) {
+    const char * topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR);
+    if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_FLAME_STATUS)) {
+      publish(*mqtt, topic, "{\"flame\":\"ON\"}");
     } else {
-      Serial.printf("Failed to set Central Heating (CH) temperature setpoint to %.01f *C\n", CHSetpoint);
+      publish(*mqtt, topic, "{\"flame\":\"OFF\"}");
     }
+    previousStatusFlags = statusFlags;
+    flameSensorInitialised = true;
+  }
+}
+
+
+// updateDHWSensor
+// Update the value of the DHW sensor in Home Assistant. Usually this sensor reacts within one second
+// If the sensor is 'ON' the boiler is running for Domestic Hot Water
+// If the sensor is 'OFF' the boiler is either idle or running for Central Heating (this can be checked woth the flame sensor)
+void updateDHWSensor(uint8_t                            statusFlags) {
+  static uint8_t previousStatusFlags = 0;
  
-    // Tell the boiler the current room temperature (optional?)
-    // This is done by writing this value to DATA-ID OpenTherm::WRITE_DATA_ID::ROOM_TEMPERATURE
-    if(thermostat.write(OpenTherm::WRITE_DATA_ID::ROOM_TEMPERATURE, roomTemperature)) {
-      Serial.printf("Room temperature set to %.02f *C\n", roomTemperature);
+  bool changedDHW = (statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_DHW_MODE)) != (previousStatusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_DHW_MODE)) |
+                    (statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_CH_MODE)) != (previousStatusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_CH_MODE));
+  if(changedDHW) {
+    const char * topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR);
+    if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_DHW_MODE)) {
+      publish(*mqtt, topic, "{\"dhw\":\"ON\"}");
     } else {
-      Serial.println("Failed to set room temperature to sensor value");
+      publish(*mqtt, topic, "{\"dhw\":\"OFF\"}");
     }
+    previousStatusFlags = statusFlags;
+  }
+}
  
  
-    // primaryFlags is used to tell the secondary device (boiler) what available services (Central heating, cooling, domestic hot water) it wants to make use of, if present
-    // The meaning of each bit is defined in enum class OpenTherm::STATUS_FLAGS
-    // BOILER_ENABLE_DOMESTIC_HOT_WATER is a #define. If defined 'true' then domestic hot water is enabled if it is available in the boiler. The previously read secondaryFlags are used to detect this capability
-    uint8_t primaryFlags;
-    if(BOILER_ENABLE_DOMESTIC_HOT_WATER && (secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_DHW))) {
-      Serial.println("Enable Domestic Hot Water (DHW)");
-      primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_DHW_ENABLE);
+// updateSensors
+// Update the values of all 'interval' sensors in Home Assistant by sending the value in the right format to the topic looked up in the discovery JSON. OpenTherm sensor can be read and do not have 
+// an entity yet in Home Assistant are created by sending the discovery JSON to the right '/config' topic.
+void updateSensors(MqttClient &                         client,
+                    float                               CHSetpoint,
+                    uint32_t &                          previousOTCommunicationMs) {
+  if(client.isConnected()) {
+    char payload[64];
+    const char * topic;
+
+    // Publish RSSI
+    snprintf(payload, sizeof payload, "{\"RSSI\":%d}", WiFi.RSSI());
+    topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RSSI_SENSOR);
+    publish(client, topic, payload);
+
+    // Publish the Dallas sensor value if such a sensor is present. This value can be used as room temperatur value using an automation in Home Assistant publishing it back to the same topic
+    // but with the JSON key 'temperature' instead
+    if(dallasSensors) {
+      snprintf(payload, sizeof payload, "{\"local_temperature\":%.01f}", recalculateTemperature(dallasSensors->getTempCByIndex(0)));
+      topic = topicByReference("current_temperature_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE);
+      publish(client, topic, payload);
     }
  
-    // BOILER_ENABLE_HEATING is a #define. If defined 'true' then central heating is enabled.
-//    if(roomTemperature < ROOM_TEMPERATURE_SETPOINT && BOILER_ENABLE_HEATING) {
-    if(BOILER_ENABLE_HEATING) {
-      Serial.println("Enable Central Heating (CH)");
-      primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_CH_ENABLE);
+    // Publish the Central Heating setpoint temperature
+    snprintf(payload, sizeof payload, "{\"ch_setpoint\":%.01f}", CHSetpoint);
+    topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR);
+    publish(client, topic, payload);
+
+    float value;
+    // Test if Relative Modulation Level can be read from the boiler
+    if(readSensor(thermostat, OpenTherm::READ_DATA_ID::RELATIVE_MODULATION_LEVEL, value, previousOTCommunicationMs)) {
+      Serial.printf("Relative Modulation level is %.01f %\n", value);
+      // Use a static variable to keep track of the entity already being created
+      static bool relativeModulationLevelDiscoveryPublished = false;
+      if(!relativeModulationLevelDiscoveryPublished) {
+        // Create the entity
+        addEntity(client, "sensor", "relative_modulation", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR);
+        relativeModulationLevelDiscoveryPublished = true;
+      }
+      // Publish the Relative Modulation Level
+      snprintf(payload, sizeof payload, "{\"relative_modulation\":%.01f}", value);
+      topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR);
+      publish(client, topic, payload);
+    }
+    // Test if Relative Central Heating Water Pressure can be read from the boiler
+    if(readSensor(thermostat, OpenTherm::READ_DATA_ID::CH_WATER_PRESSURE, value, previousOTCommunicationMs)) {
+      Serial.printf("Central Heating water pressure is %.01f bar\n", value);
+      // Use a static variable to keep track of the entity already being created
+      static bool waterPressureEntityAdded = false;
+        // Create the entity
+      if(!waterPressureEntityAdded) {
+        addEntity(client, "sensor", "water_pressure", EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR);
+        waterPressureEntityAdded = true;
+      }
+      // Publish the Central Heating Water Pressure
+      snprintf(payload, sizeof payload, "{\"water_pressure\":%.01f}", value);
+      topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR);
+      publish(client, topic, payload);
+    }
+    // Test if Flow Temperature can be read from the boiler
+    if(readSensor(thermostat, OpenTherm::READ_DATA_ID::BOILER_WATER_TEMP, value, previousOTCommunicationMs)) {
+      Serial.printf("Flow water temperature from boiler is %.01f %\n", value);
+      // Use a static variable to keep track of the entity already being created
+      static bool flowTemperatureEntityAdded = false;
+        // Create the entity
+      if(!flowTemperatureEntityAdded) {
+        addEntity(client, "sensor", "flow_temperature", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR);
+        flowTemperatureEntityAdded = true;
+      }
+      // Publish the Flow Temperature
+      snprintf(payload, sizeof payload, "{\"flow_temperature\":%.01f}", value);
+      topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR);
+      publish(client, topic, payload);
+    }
+    // Test if Return Temperature can be read from the boiler
+    if(readSensor(thermostat, OpenTherm::READ_DATA_ID::RETURN_WATER_TEMPERATURE, value, previousOTCommunicationMs)) {
+      Serial.printf("Return water temperature to boiler is %.01f %\n", value);
+      // Use a static variable to keep track of the entity already being created
+      static bool returnTemperatureEntityAdded = false;
+        // Create the entity
+      if(!returnTemperatureEntityAdded) {
+        addEntity(client, "sensor", "return_temperature", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR);
+        returnTemperatureEntityAdded = true;
+      }
+      // Publish the Return Temperature
+      snprintf(payload, sizeof payload, "{\"return_temperature\":%.01f}", value);
+      topic = topicByReference("state_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR);
+      publish(client, topic, payload);
     }
+    // Any other OpenTherm sensor that returns a float (f8.8) can be added in the same way as above by using the correct OpenTherm::READ_DATA_ID::, adding a dicovery JSON in JSONs.h, calling
+    // addEntity with the according parameters and publishing the value to the right topic in the right format
+  }
+}
+
+
+// updateRoomTemperatureStale()
+// If the room temperature becomes stale, after it has not been updated within the ROOM_TEMPERATURE_STALE_INTERVAL_S that defaults to 15 minutes,
+// signal this to Home Assistant by setting the room temperature to None/
+void updateRoomTemperatureStale(bool                    stale) {
+  static bool previousStale = false;
+
+  if(stale && !previousStale) {
+    const char * topic = topicByReference("current_temperature_topic", EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE);
+    publish(*mqtt, topic, "{\"temperature\":\"None\"}");
+  }
+
+  previousStale = stale;
+}
+
  
-    // BOILER_ENABLE_COOLING is a #define. If defined 'true' then cooling is enabled. secondaryFlags is used to detect the capability
-    if(BOILER_ENABLE_COOLING && (secondaryFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_COOLING))) {
-      Serial.println("Enable cooling");
-      primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_COOLING_ENABLE);
+// subscribeAll()
+// Subsbribe to all needed topics: one for the room temperature setpoint, one for the mode (OFF / HEAT / COOL / AUTO) and one for 
+// the actual room temperature
+bool subscribeAll(MqttClient &                          client) {
+  if(client.isConnected()) {
+    subscribe(client, processSetpointTemperatureMessage, EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE, "temperature_command_topic");
+    subscribe(client, processClimateMessage, EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE, "mode_command_topic");
+    subscribe(client, processRoomTemperatureMessage, EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE, "current_temperature_topic");
+//    subscribe(client, processClimateMessage, EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE, "preset_mode_command_topic");  // Not implemented yet
+
+    return true;
+  }
+
+  return false;
+}
+
+
+// The main loop, repeat over and over again:
+// - Try to connect to the boiler if not connected yet
+// - If connected, every second:
+//    - Inform the boiler of room temperature setpoint and actual room tenperature
+//    - Update the state (from OFF to IDLE to HEATING or COOLING to ANTI_HUNTING
+//    - Update the primary flags according to the state. The primary flags control if the boiler will statrt heating (or cooling) or not
+//    - Compute the new Central Heating Setpoint using the PID controller, if enough time (PID_INTERVAL_S) has lapsed 
+//    - Inform the boiler of the Central Heating water temperature setpoint
+//    - read the boiler status (this also updates the primary falgs) and update all sensors
+void loop() {
+  static ThermoStateMachine thermoStateMachine;
+
+  // Static variable to (re-)subscribe to topics
+  static bool subscribed = false;
+  // static variables used by the PID controller
+  static uint32_t previousPIDTimestampS;                                                      // Save timestamp that the PID was previously run
+  static float previousPIDRoomTemperature;                                                    // Save previous room temperature
+  static float ierr;                                                                          // Save PID integral error
+
+  // static variable to store the CH setpoint
+  static float CHSetpoint = CH_MIN_SETPOINT;
+  // static variable used to comply to the OpenTherm specification to have a primary to secondary communication at least once every second
+  static uint32_t previousOTCommunicationMs = millis() - 1000;      // Initialise to force the first communication
+  // static variables used to decide if the thermostat state should be published
+  static uint32_t publishedThermostatStateTimestamp = time(nullptr);                        // Initialise previous thermostat state publishing timestamp
+
+
+  // Check if we are still connected to the MQTT broker. If not, reconnect and resubscribe to the topics we are interested in
+  if(!mqtt->isConnected()) {
+    ESP_LOGI(TAG, "MQTT disconnected");
+Serial.println("MQTT disconnected");
+		wiFiClient.stop();
+		wiFiClient.connect(mqtt_server, 1883);
+    connectMQTT(*mqtt, MQTT_ID, mqtt_user, mqtt_password);
+    subscribed = false;
+  }
+
+// Subscribe to all relevant topics after a new connection
+  if(!subscribed) {
+    if(subscribeAll(*mqtt)) {
+      subscribed = true;
     }
+  }
  
-    // Enable Outside Temperature Compensation by default
-    primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_OTC_ENABLE);
-
-    // Send primaryFlags to the boiler to request services. Using statusFlags the boiler returns if it is in fault status, if it is in central heating status or domestic hot water, if it's flame is burning, etc.
-    Serial.println("Request services from the boiler and check it's status...");
-    uint8_t statusFlags;
-    if(thermostat.status(primaryFlags, statusFlags)) {                                                        // Mandatory support
-      Serial.printf("Status flags is 0x%02x\n", statusFlags);
- 
-      if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_FAULT_INDICATION)) Serial.println("FAULT NOTIFICATION");
-      if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_CH_MODE)) Serial.println("Central Heating (CH) MODE");
-      if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_DHW_MODE)) Serial.println("Domestc Hot Water (DHW) MODE");
-      if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_FLAME_STATUS)) Serial.println("Flame is on");
-      if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_COOLING_STATUS)) Serial.println("Cooling");
-      if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_CH2_MODE)) Serial.println("Second Central Heating system (CH2) is active");
-      if(statusFlags & uint8_t(OpenTherm::STATUS_FLAGS::SECONDARY_DIAGNOSTIC_IND)) Serial.println("DIAGNOSTICS INDICATION");
-    } else {
-      Serial.println("Failed to get status");
+  uint32_t thermostatStateTimestampAligned = ldiv(time(nullptr), PUBLISH_STATE_UPDATE_INTERVAL).quot * PUBLISH_STATE_UPDATE_INTERVAL;    // Align to exact intervals
+  uint32_t thermostatStateTimestampMs = millis();
+
+  if(millis() - previousOTCommunicationMs >= 1000) {      // OpenTherm specifies that primary to secondary communication should take place at least every second
+    // connected() becomes 'true' after communication has taken place between thermostat and boiler and the boiler's configuration flags are read
+    if(!thermoStateMachine.connected()) {
+      // Try to contact the boiler and construct the thermostat's primary flags from the boiler's capabilities
+      OpenTherm::CONFIGURATION_FLAGS configurationFlags;
+      if(readSecondaryConfiguration(thermostat, configurationFlags, previousOTCommunicationMs)) {
+        thermoStateMachine.initPrimaryFlags(configurationFlags);
+
+        updateClimateEntity((uint8_t(configurationFlags) & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_COOLING)) != 0);
+        updateDHWEntity((uint8_t(configurationFlags) & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_DHW_PRESENT)) != 0);
+      }
     }
+
+    if(thermoStateMachine.connected()) {
+      // Inform the boiler of the room temperature setpoint; is automatically ignored if setpoint did not change or if not supported by the boiler
+      roomTemperatureSetpointToBoiler(thermostat, roomTemperatureSetpoint, previousOTCommunicationMs);
+      // Check if roomTemperatureTimestampS is zero (No room temperature received yet)
+      if(roomTemperatureTimestampS != 0) {
+        // Inform the boiler of the room temperature; is automatically ignored if room temperature did not change or if not supported by the boiler
+        roomTemperatureToBoiler(thermostat, roomTemperature, previousOTCommunicationMs);
+
+        uint32_t stateTimestampS = time(nullptr);
+        // State changes from IDLE -> HEATING or COOLING -> ANTI_HUNTING > IDLE, depending on the current state and changes in temperature setpoint and / or room temperature
+        // updateState returns true if the state has changed
+        if(thermoStateMachine.update(roomTemperature, roomTemperatureTimestampS, roomTemperatureSetpoint, thermostatRequest)) {
+          // state has changed, update the primary flags to the new state
+          thermoStateMachine.updatePrimaryFlags();
+          Serial.printf("State changed to '%s'\n", thermoStateMachine.c_str());
+          // Initialise the PID variables
+          ierr = 0;
+          previousPIDTimestampS = stateTimestampS;
+          previousPIDRoomTemperature = roomTemperature;            
+        } else {
+          Serial.printf("State still is '%s'\n", thermoStateMachine.c_str());
+          // state did not change, update the CH setpoint using the PID if state is HEATING or COOLING
+          switch(thermoStateMachine.getState()) {
+            case ThermostatState::HEATING:
+            case ThermostatState::COOLING:
+              // If at least PID_INTERVAL_S seconds have elapsed, compute the new CH temperature setpoint using the PID
+              if(stateTimestampS - previousPIDTimestampS >= PID_INTERVAL_S) {
+                // Time between measurements in seconds
+                float dt = stateTimestampS - previousPIDTimestampS;
+                CHSetpoint = pid(roomTemperatureSetpoint, roomTemperature, previousPIDRoomTemperature, ierr, dt);
+                previousPIDTimestampS = stateTimestampS;
+                previousPIDRoomTemperature = roomTemperature;
+                Serial.printf("Computed CH setpoint using PID is %.01f\n", CHSetpoint);
+              }
+
+            break;
+            default:
+              CHSetpoint = CH_MIN_SETPOINT; // Just to be sure, the boiler should alreay been disabled by the primary flags
+            break;
+          }
+        }
+      }
+
+      // If room temperature gone stale, signal this to Home Assistant by setting the room temperature to None
+      updateRoomTemperatureStale(thermoStateMachine.getRoomTemperatureStale());
+
+      // Inform the boiler of the boiler water setpoint; is automatically ignored if CH setpoint temperature did not change
+      CHSetpointToBoiler(thermostat, CHSetpoint, previousOTCommunicationMs);
+
+      uint8_t primaryFlags = uint8_t(thermoStateMachine.getPrimaryFlags());
+      uint8_t statusFlags;
+      // Read status in every loop, to meet the 'communication each second' requirement
+      if(readStatus(thermostat, primaryFlags, statusFlags, previousOTCommunicationMs)) {
+        // Inform Home Assitant directly about the status; is automatically ignored if the flame status or CH / DHW status did not change
+        updateFlameSensor(statusFlags);
+        updateDHWSensor(statusFlags);
+      }
+    }
+  }
+
+  // Publish the 'interval' sensors' at exact 'PUBLISH_STATE_UPDATE_INTERVAL' intervals
+  if(thermostatStateTimestampAligned - publishedThermostatStateTimestamp >= PUBLISH_STATE_UPDATE_INTERVAL) {
+    updateSensors(*mqtt, CHSetpoint, previousOTCommunicationMs);
+    publishedThermostatStateTimestamp = thermostatStateTimestampAligned;
   }
+
+  mqtt->yield(100);
 }
+#pragma once
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE
+// Home Assistant Climate MQTT Discovery Message
+// https://www.home-assistant.io/integrations/climate.mqtt/
+// 
+// This JSON is sent to topic "homeassistant/climate/112233445566/climate/config" to automatically configurate a thermostat in Home Assistant
+// Before sending this JSON all "112233445566" are replaced by the hexadecimal chip ID, i.e. the same as the MAC address in reverse 
+// order. Also all 11:22:33:44:55:66 are replaced by the MAC address and #### by the hex value of the least significant 4 bytes of the
+// chip ID. Because this is done in place, the exact space in the character array is already reserved.
+// All topics MAY begin with "~/". If so "~" must be defined by a key-value pair in this JSON. This is NOT CHECKED by the code.
+// The following topics MUST be present. Again this is NOT CHECKED by the code:
+// - "current_temperature_topic"
+// - "temperature_command_topic"
+// - "mode_command_topic"
+// - "preset_mode_command_topic"
+// - "outside_temperature_command_topic"
+// Templates are used to pick out the right value. For the climate entity "current_temperature_topic" is the state topic, associated with the
+// template "current_temperature_template".
+// A subset of "modes":["auto","off","cool","heat"] is added to the ArduinoJson document depending on the capabilities of the boiler.
+// If the boiler is for heating only, ["off","heat"] is added. If the boiler can also cool, the full set is added.
+// If topic "mode_state_topic":"~/mode/state" or topic "temperature_state_topic":"~/setpoint/state" is defined the Home Assistant
+// Thermostat is not properly updated, because of 'optimistic mode'
+// For readability 'pretty' format is used, for saving a few bytes of memory it may also be minified.
+
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_CLIMATE[] = R"DISCMQTTCLIMATE(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Thermostat",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-thermostat",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "precision":0.1,
+  "temp_step":0.5,
+  "min_temp":10.0,
+  "max_temp": 30.0,
+  "initial":12,
+  "preset_modes":["eco","away","boost","comfort","home","sleep","activity"],
+  "preset_mode_command_topic":"~/preset_mode/set",
+  "current_temperature_topic":"~/climate/state",
+  "current_temperature_template":"{{value_json.temperature}}",
+  "temperature_command_topic":"~/setpoint/set",
+  "temperature_high_state_topic":"~/high_temperature/state",
+  "temperature_high_command_topic":"~/high_temperature/set",
+  "temperature_low_state_topic":"~/low_temperature/state",
+  "temperature_low_command_topic":"~/low_temperature/set",
+  "modes":[],  
+  "mode_command_topic":"~/mode/set",
+  "availability_topic":"~/sensors/state",
+  "availability_template":"{{value_json.climate_available}}",
+  "payload_available":"ONLINE",
+  "payload_not_available":"OFFLINE",
+  "retain":false
+}
+)DISCMQTTCLIMATE";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR
+// Discovery message for the central heating boiler temperature setpoint sensor. Since the setpoint is computed by the thermostat, this
+// sensor is always present in Home Assistant
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_SETPOINT_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Boiler Setpoint",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-boiler_ch_setpoint",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "device_class":"temperature",
+  "state_topic":"~/ch_setpoint/state",
+  "unit_of_measurement":"°C",
+  "value_template":"{{value_json.ch_setpoint}}",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR
+// Discovery message for the boiler flow temperature sensor. The flow temperature is the temperature of
+// the water leaving the boiler.
+// This sensor is only added to Home Assistant if it can be read using the OpenTherm interface
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLOW_TEMPERATURE_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Boiler Flow Temperature",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-boiler_flow_temperature",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "device_class":"temperature",
+  "state_topic":"~/flow_temperature/state",
+  "unit_of_measurement":"°C",
+  "value_template":"{{value_json.flow_temperature}}",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR
+// Discovery message for the boiler return temperature sensor. The return temperature is the temperature of
+// the water returning to the boiler.
+// This sensor is only added to Home Assistant if it can be read using the OpenTherm interface
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_RETURN_TEMPERATURE_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Boiler Return Temperature",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-boiler_return_temperature",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "device_class":"temperature",
+  "state_topic":"~/return_temperature/state",
+  "unit_of_measurement":"°C",
+  "value_template":"{{value_json.return_temperature}}",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR
+// Discovery message for the boiler water pressure sensor.
+// This sensor is only added to Home Assistant if it can be read using the OpenTherm interface
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_WATER_PRESSURE_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Boiler Water Pressure",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-boiler_water_pressure",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "device_class":"pressure",
+  "state_topic":"~/water_pressure/state",
+  "unit_of_measurement":"bar",
+  "value_template":"{{value_json.water_pressure}}",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR
+// Discovery message for the boiler relative modulation sensor.
+// This sensor is only added to Home Assistant if it can be read using the OpenTherm interface
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_RELATIVE_MODULATION_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Boiler Relative Modulation",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-boiler_relative_modulation",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "icon":"mdi:percent-outline",
+  "state_topic":"~/relative_modulation/state",
+  "unit_of_measurement":"%",
+  "value_template":"{{value_json.relative_modulation}}",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_RSSI_SENSOR
+// Discovery message for the RSSI signal strength sensor.
+// This sensor is always added to Home Assistant
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_RSSI_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Thermostat RSSI",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-thermostat_rssi",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "device_class":"signal_strength",
+  "state_topic":"~/RSSI/state",
+  "unit_of_measurement":"dBm",
+  "value_template":"{{value_json.RSSI}}",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR
+// Discovery message for the boiler flame on / off binary sensor.
+// This sensor is always added to Home Assistant
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_FLAME_BINARY_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Boiler Flame",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-boiler_flame",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "icon":"mdi:fire",
+  "state_topic":"~/flame/state",
+  "value_template":"{{value_json.flame}}",
+  "payload_on":"ON",
+  "payload_off":"OFF",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+
+
+// EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR
+// Discovery message for the boiler Domestic Hot Water on / off binary sensor.
+// This sensor is 'on' if the boiler is running for Domestoc Hot Wtaer and 'off' if
+// the boiler is running for Central Heating or is not running. 
+// This sensor is only added to Home Assistant if the boiler supports DHW
+char EASYOPENTHERM_MQTT_DISCOVERY_MSG_DHW_BINARY_SENSOR[] = R"DISCMQTTSENSOR(
+{
+  "~":"Metriot/EasyOpenTherm/112233445566",
+  "name":"EasyOpenTherm #### Boiler Domestic Hot Water",
+  "unique_id":"Metriot-EasyOpenTherm-112233445566-boiler_DHW",
+  "device":
+  {
+    "identifiers":["112233445566"],
+    "connections":[["mac","11:22:33:44:55:66"]],
+    "name":"EasyOpenTherm:boiler ####",
+    "suggested_area":"Living Room",
+    "manufacturer":"Metriot",
+    "model":"EasyOpenTherm:boiler",
+    "sw_version":"1.0"
+  },
+  "icon":"mdi:shower",
+  "state_topic":"~/dhw/state",
+  "payload_on":"ON",
+  "payload_off":"OFF",
+  "value_template":"{{value_json.dhw}}",
+  "retain":false
+}
+)DISCMQTTSENSOR";
+#include "MQTTHelpers.h"
+
+#if defined(ESP32)
+#include <WiFi.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#else 
+#error Unsupported or unknown board
+#endif
+
+static const char * TAG = "EasyOpenTherm MQTTHelpers";
+
+#if !defined(ESP32) && !defined(ESP_LOGE)
+#define ESP_LOGE(...)
+#define ESP_LOGI(...)
+#define ESP_LOGV(...)
+#endif
+
+
+const size_t smallJsonDocSize = 256;
+
+
+/*
+ * chipID()
+ * Store the ESP32 unique ID once. Return a pointer to the stored chip ID. The ID is the same as the MAC but in reversed byte order
+ */
+const char * chipID() {
+  static char serialNumber[13] = "";
+
+  if(*serialNumber == '\0') {
+#if defined(ESP32)
+    sprintf(serialNumber, "%012llx", ESP.getEfuseMac());
+#elif defined(ESP8266)
+    sprintf(serialNumber, "%012llx", ESP.getChipId());
+#else
+#error Unsupported or unknown board
+#endif
+    ESP_LOGI(TAG, "Serial number is %s", serialNumber);
+  }
+
+  return serialNumber;
+}
+
+#include <machine/types.h>
+/*
+ * shortID()
+ * Store the least significant two bytes of the ESP32 unique ID once. Return a pointer to the stored short ID. The ID is the same as the last two MAC bytes, in the same order
+ */
+const char * shortID() {
+  static char shortNumber[5] = "";
+
+  if(*shortNumber == '\0') {
+#if defined(ESP32)
+    uint64_t mac = ESP.getEfuseMac();
+#elif defined(ESP8266)
+    uint64_t mac = ESP.getChipId();
+#else
+#error Unsupported or unknown board
+#endif
+
+    uint8_t * MAC = (uint8_t *) &mac;
+    sprintf(shortNumber, "%02X%02X", MAC[4], MAC[5]);
+    ESP_LOGI(TAG, "Short ID is %s", shortNumber);
+  }
+
+  return shortNumber;
+}
+
+
+/*
+ * replaceAll()
+ * Do an 'in place' replacement into 'destination' of all occurances of the 'search' by 'replace'
+ */
+bool replaceAll(char *                                  destination,
+                const char *                            search,
+                const char *                            replace) {
+  size_t searchLength = strlen(search);
+  if(strlen(replace) != searchLength) {
+    ESP_LOGE(TAG, "Length of search string (%s) does not match replace string (%s)\n", search, replace);
+
+    return false;
+  }
+
+  size_t length = strlen(destination);
+  char * searchFrom = destination;
+  bool replaced = false;
+  for(;;) {
+    char * found = strstr(searchFrom, search);
+    if(found == nullptr) break;
+    memcpy(found, replace, searchLength);
+    replaced = true;
+
+    searchFrom = found + searchLength;
+    if(searchFrom >= destination + length) break;
+  }
+  
+  return replaced;
+}
+
+
+/*
+ * discoveryMessageSetIDs()
+ * Replace all placeholders '112233445566' with the chip ID, all placeholders '11:22:33:44:55:66' with the MAC and all placeholder '####' with the short ID.
+ */
+void discoveryMessageSetIDs(char *                      discoveryMsgJson) {
+  replaceAll(discoveryMsgJson, "112233445566", chipID());
+  replaceAll(discoveryMsgJson, "11:22:33:44:55:66", WiFi.macAddress().c_str());
+  replaceAll(discoveryMsgJson, "####", shortID());
+}
+
+
+const char * topicByReference(const char *              key,
+                              const char *              discoveryMsgJson) {
+  static char * topicBuffer = nullptr;
+  static size_t topicBufferSize = 0;  // Includes the trailing `\0'
+
+  StaticJsonDocument<smallJsonDocSize> discoveryJsonPartDoc;
+
+  StaticJsonDocument<smallJsonDocSize> filter;
+  filter["~"] = true;
+  filter[key] = true;
+
+  DeserializationError error = deserializeJson(discoveryJsonPartDoc, discoveryMsgJson, DeserializationOption::Filter(filter));
+  if(error) {
+    ESP_LOGE(TAG, "Deserialize error %s for JSON '%s'", error.f_str(), discoveryMsgJson);
+
+    return nullptr;
+  }
+
+  const char * baseTopic = discoveryJsonPartDoc["~"];
+  const char * topic = discoveryJsonPartDoc[key];
+  if(topic == nullptr) {
+    ESP_LOGE(TAG, "Key '%s' not found in JSON '%s'", key, discoveryMsgJson);
+
+    return nullptr;
+  }
+
+  if(*topic == '~' && baseTopic == nullptr) {
+    ESP_LOGE(TAG, "Base topic '~' not found in JSON '%s'", discoveryMsgJson);
+
+    return nullptr;
+  }
+
+  size_t newSize = strlen(topic) + 1;
+  if(*topic == '~') newSize += strlen(baseTopic);
+  if(topicBufferSize < newSize) {
+    free(topicBuffer);
+    topicBuffer = (char *) malloc(newSize);
+    if(topicBuffer == nullptr) {
+      topicBufferSize = 0;
+      ESP_LOGE(TAG, "topicByReference out of memory");
+
+      return nullptr;
+    }
+    topicBufferSize = newSize;
+  }
+
+  if(*topic == '~') {
+    sprintf(topicBuffer, "%s%s", baseTopic, topic + 1);
+  } else {
+    sprintf(topicBuffer, "%s", topic);
+  }
+
+  return topicBuffer;
+}
+
+
+bool validJson(const char *                             discoveryMsgJson) {
+  StaticJsonDocument<0> emptyDoc;
+
+  StaticJsonDocument<0> filter;
+
+  DeserializationError error = deserializeJson(emptyDoc, discoveryMsgJson, DeserializationOption::Filter(filter));
+  if(error) {
+    ESP_LOGE(TAG, "Deserialize error %s for JSON '%s'", error.f_str(), discoveryMsgJson);
+  }
+
+  return error == DeserializationError::Ok;
+}
+
+
+bool connectMQTT(MqttClient &                           client,
+                  const char *                          clientID,
+                  const char *                          user, 
+                  const char *                          password) {
+  // Start new MQTT connection
+  ESP_LOGI(TAG, "Connecting");
+  MqttClient::ConnectResult connectResult;
+  // Connect
+  MQTTPacket_connectData options = MQTTPacket_connectData_initializer;
+  options.MQTTVersion = 4;
+  options.clientID.cstring = (char *)clientID;
+  options.username.cstring = (char *)user;
+  options.password.cstring = (char *)password;
+  options.cleansession = true;
+  options.keepAliveInterval = 15; // 15 seconds
+  MqttClient::Error::type rc = client.connect(options, connectResult);
+  if (rc != MqttClient::Error::SUCCESS) {
+    ESP_LOGE(TAG, "Connection error: %i", rc);
+
+    return false;
+  }
+
+  return true;
+}
+
+
+bool publish(MqttClient &                               client,
+              const char *                              topic, 
+              const char *                              payload, 
+              bool                                      retained) {
+  if(!client.isConnected()) return false;
+
+  MqttClient::Message message;
+  message.qos = MqttClient::QOS0;
+  message.retained = retained;
+  message.dup = true;
+  message.payload = (void *)payload;
+  message.payloadLen = strlen(payload);
+  client.publish(topic, message);
+Serial.printf("PUBLISH topic is '%s' message is '%s'\n", topic, message.payload);
+
+  return true;
+}
+
+
+bool discoveryMsgToJsonDoc(JsonDocument &               discoveryMsgDoc,
+                            const char *                discoveryMsgJson) {
+  DeserializationError error = deserializeJson(discoveryMsgDoc, discoveryMsgJson);
+  if(error) {
+    ESP_LOGE(TAG, "Deserialize error %s for JSON '%s'", error.f_str(), discoveryMsgJson);
+
+    return false;
+  }
+
+  return true;
+}
+
+
+/*
+ * addEntity()
+ * Publish the prepared and deserialized discovery message to topic 'homeassistant/[component]/[chip ID]/[object]/config', with component being one of the
+ * Home Assistant MQTT components like 'climate', 'sensor' or 'binary_sensor' and object a unique ID to differentiate between e.g. two sensors in the same
+ * device.
+ */
+bool addEntity(MqttClient &                             client,
+                const char *                            component,
+                const char *                            object,
+                JsonDocument &                          discoveryMsgDoc) {
+  if(!client.isConnected()) return false;
+
+  size_t jsonSize = measureJson(discoveryMsgDoc);
+  char discoveryMsgJson[jsonSize + 1];
+  serializeJson(discoveryMsgDoc, discoveryMsgJson, sizeof discoveryMsgJson);
+
+  ESP_LOGI(TAG, "Discovery topic is '%s'\n", (String("homeassistant/") + String(component) + String("/") + String(chipID()) + String("/") + String(object) + String("/config")).c_str());
+  ESP_LOGI(TAG, "Discovery message is '%s'", discoveryMsgJson);
+
+  MqttClient::Message message;
+  message.qos = MqttClient::QOS0;
+  message.retained = false;
+  message.dup = false;
+  message.payload = (void*) discoveryMsgJson;
+  message.payloadLen = jsonSize;
+  client.publish((String("homeassistant/") + String(component) + String("/") + String(chipID()) + String("/") + String(object) + String("/config")).c_str(), message);
+Serial.printf("PUBLISH topic is '%s' message is '%s'\n", (String("homeassistant/") + String(component) + String("/") + String(chipID()) + String("/") + String(object) + String("/config")).c_str(), message.payload);
+
+  return true;
+}
+
+
+// addEntity()
+// Same as above but providing the discovery message as a const char * JSON 
+bool addEntity(MqttClient &                             client,
+                const char *                            component,
+                const char *                            object,
+                const char *                            discoveryMsgJson) {
+  DynamicJsonDocument discoveryMsgDoc(fullJsonDocSize);
+
+  if(!discoveryMsgToJsonDoc(discoveryMsgDoc, discoveryMsgJson)) return false;
+
+  return addEntity(client, component, object, discoveryMsgDoc);
+}
+
+/*
+ * subscribe()
+ * Subscribe to the topic at at the given key in the discovery message. Before subscription the topic in the discovery
+ * message is expanded to the full topic by prefixing the "~" path.
+ */
+bool subscribe(MqttClient &                             client,
+                MqttClient::MessageHandlerCbk           cbk,
+                const char *                            discoveryMessage,
+                const char *                            key) {
+  const char * topic = topicByReference(key, discoveryMessage);
+  if(topic == nullptr) return false;
+
+  MqttClient::Error::type rc = client.subscribe(topic, MqttClient::QOS0, cbk);
+  if (rc != MqttClient::Error::SUCCESS) {
+    ESP_LOGE(TAG, "Subscribe error: %i for topic '%s'", rc, topic);
+    ESP_LOGE(TAG, "Drop connection");
+    client.disconnect();
+
+    return false;
+  }
+  ESP_LOGI(TAG, "Subscribed to '%s'", topic);
+Serial.printf("Subscribed to '%s'\n", topic);
+
+  return true;
+}
 \ No newline at end of file
+#pragma once
+
+
+#include <Arduino.h>
+#include <MqttClient.h>
+#include <ArduinoJson.h>
+
+
+const size_t fullJsonDocSize = 2 * 1024;
+
+const char * chipID();
+
+const char * shortID();
+
+
+// ============== Object to supply system functions ============================
+class System: public MqttClient::System {
+public:
+
+	unsigned long millis() const {
+		return ::millis();
+	}
+
+	void yield(void) {
+		::yield();
+	}
+};
+
+void discoveryMessageSetIDs(char *                      discoveryMsgJson);
+
+const char * topicByReference(const char *              key,
+                              const char *              discoveryMsgJson);
+
+bool validJson(const char *                             discoveryMsgJson);
+
+bool connectMQTT(MqttClient &                           client,
+                  const char *                          clientID,
+                  const char *                          user, 
+                  const char *                          password);
+
+bool publish(MqttClient &                               client,
+              const char *                              topic, 
+              const char *                              payload, 
+              bool                                      retained = false);
+
+bool discoveryMsgToJsonDoc(JsonDocument &               discoveryMsgDoc,
+                            const char *                discoveryMsgJson);
+
+bool addEntity(MqttClient &                             client,
+                const char *                            component,
+                const char *                            object,
+                JsonDocument &                          discoveryMsgDoc);
+
+bool addEntity(MqttClient &                             client,
+                const char *                            component,
+                const char *                            object,
+                const char *                            discoveryMsgJson);
+
+bool subscribe(MqttClient &                             client,
+                MqttClient::MessageHandlerCbk           cbk,
+                const char *                            discoveryMessage,
+                const char *                            key);
 \ No newline at end of file
+#include "OpenThermHelpers.h"
+
+
+#include <unordered_map>
+
+
+static const char * TAG = "EasyOpenTherm OpenThermHelpers";
+
+#if !defined(ESP32) && !defined(ESP_LOGE)
+#define ESP_LOGE(...)
+#define ESP_LOGI(...)
+#define ESP_LOGV(...)
+#endif
+
+
+// If CH setpoint has changed write it to the boiler
+// If writing CH setpoint to the boiler is successful, update the static previous CH setpoint for the next round
+// Since OpenTherm::WRITE_DATA_ID::CONTROL_SETPOINT_CH is mandatory no need for tracking if the command is supported
+// Returns false if writing to the boiler failed
+// This function is robust: if writing fails it will write again in de next loop
+bool CHSetpointToBoiler(OpenTherm &                                 thermostat,
+                        float                                       CHSetpoint,
+                        uint32_t &                                  previousOTCommunicationMs) {
+  static float previousCHSetpoint = -1000.0f;
+
+  if(CHSetpoint == previousCHSetpoint) return true;
+
+  uint32_t timestampMs = millis();
+  if(thermostat.write(OpenTherm::WRITE_DATA_ID::CONTROL_SETPOINT_CH, CHSetpoint)) {
+    previousOTCommunicationMs = timestampMs;
+    Serial.printf("Central Heating (CH) temperature setpoint set to %.01f ºC\n", CHSetpoint);
+    previousCHSetpoint = CHSetpoint;
+
+    return true;
+  } else {
+    Serial.printf("Failed to set Central Heating (CH) temperature setpoint to %.01f ºC\n", CHSetpoint);
+
+    return false;
+  }
+}
+
+
+// If room temperature setpoint has changed write it to the boiler
+// If writing room temperature setpoint to the boiler is successful, update the static previous room temperature setpoint for the next round
+// Since OpenTherm::WRITE_DATA_ID::ROOM_SETPOINT is optional, so track if the command is supported
+// Returns false if writing to the boiler failed
+// This function is robust: if writing fails it will write again in de next loop
+bool roomTemperatureSetpointToBoiler(OpenTherm &                    thermostat,
+                                      float                         roomTemperatureSetpoint,
+                                      uint32_t &                    previousOTCommunicationMs) {
+  static float previousRoomTemperatureSetpoint = -1000.0f;
+  static bool dataIDSupported = true; // until proven otherwise
+
+  roomTemperatureSetpoint = roundf(roomTemperatureSetpoint * 10.0f) / 10.0f;      // Round to one decimal
+
+  if(roomTemperatureSetpoint == previousRoomTemperatureSetpoint) return true;
+
+  if(!dataIDSupported) return false;
+
+  uint32_t timestampMs = millis();
+  if(thermostat.write(OpenTherm::WRITE_DATA_ID::ROOM_SETPOINT, roomTemperatureSetpoint)) {
+    previousOTCommunicationMs = timestampMs;
+    if(thermostat.error() == OpenTherm::ERROR_CODES::UNKNOWN_DATA_ID) {
+      Serial.println("ROOM_SETPOINT not supported");
+      dataIDSupported = false;      // Remember for the next round that this data ID is not supported
+
+      return false;
+    }
+
+    Serial.printf("Room temperature setpoint set to %.01f ºC\n", roomTemperatureSetpoint);
+    previousRoomTemperatureSetpoint = roomTemperatureSetpoint;
+
+    return true;
+  } else {
+    Serial.printf("Failed to set room temperature setpoint to %.01f ºC\n", roomTemperatureSetpoint);
+
+    return false;
+  }
+}
+
+
+// If room temperature has changed write it to the boiler
+// If writing room temperature to the boiler is successful, update the static previous room temperature for the next round
+// Since OpenTherm::WRITE_DATA_ID::ROOM_TEMPERATURE is optional, so track if the command is supported
+// Returns false if writing to the boiler failed
+// This function is robust: if writing fails it will write again in de next loop
+bool roomTemperatureToBoiler(OpenTherm &                            thermostat,
+                              float                                 roomTemperature,
+                              uint32_t &                            previousOTCommunicationMs) {
+  static float previousRoomTemperature = -1000.0f;
+  static bool dataIDSupported = true; // until proven otherwise
+
+  roomTemperature = roundf(roomTemperature * 10.0f) / 10.0f;      // Round to one decimal
+
+  if(roomTemperature == previousRoomTemperature) return true;
+
+  if(!dataIDSupported) return false;
+
+  uint32_t timestampMs = millis();
+  if(thermostat.write(OpenTherm::WRITE_DATA_ID::ROOM_TEMPERATURE, roomTemperature)) {
+    previousOTCommunicationMs = timestampMs;
+    if(thermostat.error() == OpenTherm::ERROR_CODES::UNKNOWN_DATA_ID) {
+      Serial.println("ROOM_TEMPERATURE not supported");
+      dataIDSupported = false;      // Remember for the next round that this data ID is not supported
+
+      return false;
+    }
+
+    Serial.printf("Room temperature set to %.01f ºC\n", roomTemperature);
+    previousRoomTemperature = roomTemperature;
+
+    return true;
+  } else {
+    Serial.printf("Failed to set room temperature to %.01f ºC\n", roomTemperature);
+
+    return false;
+  }
+}
+
+
+// Read the secondary configuration. Upon success return true
+bool readSecondaryConfiguration(OpenTherm &                         thermostat,
+                                OpenTherm::CONFIGURATION_FLAGS &    configurationFlags,
+                                uint32_t &                          previousOTCommunicationMs) {
+  uint8_t secondaryMemberIDCode;
+  uint8_t flags;
+  uint32_t timestampMs = millis();
+  if(thermostat.read(OpenTherm::READ_DATA_ID::SECONDARY_CONFIGURATION, flags, secondaryMemberIDCode)) {        // It is mandatory for a boiler to suppport SECONDARY_CONFIGURATION
+    previousOTCommunicationMs = timestampMs;
+    if(thermostat.error() == OpenTherm::ERROR_CODES::UNKNOWN_DATA_ID) {
+      // Valid data is received but the for boilers mandatory DATA-ID OpenTherm::READ_DATA_ID::SECONDARY_CONFIGURATION is not recognised. This is not a boiler but another device!
+      ESP_LOGE(TAG, "Your remote device is not a boiler");
+
+      return true;
+    }
+
+    configurationFlags = OpenTherm::CONFIGURATION_FLAGS(flags);
+
+    return true;
+  } else {
+    // No data or invalid data received
+    ESP_LOGI(TAG, "Failed to get secondary configuration; is a boiler connected?");
+
+    return false;
+  }
+}
+
+
+// Read the secondary status flags. Upon success set the status flags and return true
+bool readStatus(OpenTherm &                                         thermostat,
+                uint8_t                                             primaryFlags,
+                uint8_t &                                           statusFlags,
+                uint32_t &                                          previousOTCommunicationMs) {
+  static uint8_t previousStatusFlags = 0;
+
+  uint32_t timestampMs = millis();
+  if(thermostat.status(primaryFlags, statusFlags)) {                                                        // It is mandatory for the boiler to support it's status
+    previousOTCommunicationMs = timestampMs;
+    if(statusFlags != previousStatusFlags) {
+//      showSecondaryStatus(statusFlags);             // UPDATE STATE JSON INSTEAD!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+      previousStatusFlags = statusFlags;
+    } else {
+      ESP_LOGV(TAG, "Secondary status checked; unchanged");
+    }
+
+    return true;
+  } else {
+    ESP_LOGI(TAG, "Failed to get secondary status, error code is %d\n", thermostat.error());
+
+    return false;
+  }
+}
+
+
+// Read any sensor from the boiler over the OpenTherm interface that returns a float (f8.8) by using the DATA ID
+// If the readSensor is called for the first time for a particular DATA ID, the sensor is read over the OpenTherm interface
+// If the sensor can be read succesfully, this is stored as true into the unordered map
+// If the instead an INVALID DATA ID response is read from the boiler, this is flagged as false into the unordered map, so
+// the bext time this function is called it inmediately returns false without trying to read the sensor again.
+bool readSensor(OpenTherm &                             thermostat,
+                OpenTherm::READ_DATA_ID                 dataID,
+                float &                                 value,
+                uint32_t &                              previousOTCommunicationMs) {
+  static std::unordered_map<OpenTherm::READ_DATA_ID, bool> sensorPresent;
+
+  auto got = sensorPresent.find(dataID);
+  if(got != sensorPresent.end() && !got->second) {
+
+    return false;
+  }
+
+  uint32_t timestampMs = millis();
+  if(thermostat.read(dataID, value)) {
+    previousOTCommunicationMs = timestampMs;
+    if(thermostat.error() == OpenTherm::ERROR_CODES::UNKNOWN_DATA_ID) {
+      // Valid data is received for the dataID, however the boiler does not support it. Add an entry in the sensorPresent unordered_map to prevent another read out
+      ESP_LOGI(TAG, "Sensor with DATA ID %d not present", dataID);
+      sensorPresent[dataID] = false;
+
+      return false;
+    } else {
+      // Valid data is received for the dataID and the boiler supports it. Add an entry in the sensorPresent unordered_map, if not already present, to enable another read out
+      if(got == sensorPresent.end()) sensorPresent[dataID] = true;
+
+      return true;
+    }
+  } else {
+    // No data or invalid data received
+
+    return false;   
+  }
+}
 \ No newline at end of file
+#pragma once
+
+#include <Arduino.h>
+
+#include <EasyOpenTherm.h>
+
+
+bool CHSetpointToBoiler(OpenTherm &                                 thermostat,
+                        float                                       CHSetpoint,
+                        uint32_t &                                  previousOTCommunicationMs);
+
+bool roomTemperatureSetpointToBoiler(OpenTherm &                    thermostat,
+                                      float                         roomTemperatureSetpoint,
+                                      uint32_t &                    previousOTCommunicationMs);
+
+bool roomTemperatureToBoiler(OpenTherm &                            thermostat,
+                              float                                 roomTemperature,
+                              uint32_t &                            previousOTCommunicationMs);
+
+bool readSecondaryConfiguration(OpenTherm &                         thermostat,
+                                OpenTherm::CONFIGURATION_FLAGS &    configurationFlags,
+                                uint32_t &                          previousOTCommunicationMs);
+
+bool readStatus(OpenTherm &                                         thermostat,
+                uint8_t                                             primaryFlags,
+                uint8_t &                                           statusFlags,
+                uint32_t &                                          previousOTCommunicationMs);
+
+bool readSensor(OpenTherm &                                         thermostat,
+                OpenTherm::READ_DATA_ID                             dataID,
+                float &                                             value,
+                uint32_t &                                          previousOTCommunicationMs);
 \ No newline at end of file
+#include "ThermoStateMachine.h"
+
+static const char * TAG = "EasyOpenTherm ThermoStateMachine";
+
+// Define a dead zone: the boiler will start heating if room temperature is below room setpoint minus lower dead zone to prevent oscillation or 'hunting'
+#define ROOM_TEMPERATURE_SETPOINT_LOWER_DEAD_ZONE (0.1f)
+// Define a dead zone: the boiler will start cooling if room temperature is aboce room setpoint plus higher dead zone (if the boiler can cool) to prevent oscillation or 'hunting'
+#define ROOM_TEMPERATURE_SETPOINT_HIGHER_DEAD_ZONE (0.1f)
+ // Anti hunting tim einterval in seconds
+#define ANTI_HUNTING_TIME_INTERVAL_S (600)
+
+#define ROOM_TEMPERATURE_STALE_INTERVAL_S (900)
+
+                          ThermoStateMachine::ThermoStateMachine() {
+}
+
+
+                          ThermoStateMachine::~ThermoStateMachine() {
+}
+
+
+bool                      ThermoStateMachine::connected() {
+  return _state != ThermostatState::WAITING_FOR_SECONDARY_CONFIGURATION;
+}
+
+
+void                      ThermoStateMachine::initPrimaryFlags(OpenTherm::CONFIGURATION_FLAGS configurationFlags) {
+  _configurationFlags = uint8_t(configurationFlags);
+  _primaryFlags = 0;
+  // Enable DHW if boiler is capable of DHW
+  if(_configurationFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_DHW_PRESENT)) {
+    _primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_DHW_ENABLE);
+  }
+  // If boiler is capable of cooling, signal this by setting 'canCool'
+  _canCool = (_configurationFlags & uint8_t(OpenTherm::CONFIGURATION_FLAGS::SECONDARY_COOLING)) != 0;
+
+  // Do not enable OTC
+  // _primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_OTC_ENABLE);
+
+  _state = ThermostatState::OFF;
+}
+
+
+// Observe a dead zone around the room temperature setpoint of ROOM_TEMPERATURE_SETPOINT_LOWER_DEAD_ZONE below the setpoint and of ROOM_TEMPERATURE_SETPOINT_HIGHER_DEAD_ZONE above the setpoint
+// If state is IDLE stay IDLE if the room temperature is in between roomTemperatureSetpoint - ROOM_TEMPERATURE_SETPOINT_LOWER_DEAD_ZONE and roomTemperatureSetpoint + ROOM_TEMPERATURE_SETPOINT_HIGHER_DEAD_ZONE
+// UNLESS the room temperature setpoint is changed (indicating a user request for a change in temperature), change the state to HEATING or COOLING depending on the difference between actual room 
+// temperature and room temperature setpoint
+// If state is OFF and either an 'ON'-request is set, or the room temperature setpoint is set change to IDLE
+// in any state but OFF, if an 'OFF'-request is set change to OFF
+// If state is IDLE and the room temperature drops below roomTemperatureSetpoint - ROOM_TEMPERATURE_SETPOINT_LOWER_DEAD_ZONE change the state to HEATING
+// If state is IDLE and the room temperature rises above roomTemperatureSetpoint - ROOM_TEMPERATURE_SETPOINT_HIGHER_DEAD_ZONE change the state to COOLING
+// If state is HEATING and the room temperature is equal or above the room temperature setpoint change state to ANTI_HUNTING
+// If state is COOLING and the room temperature is equal or below the room temperature setpoint change state to ANTI_HUNTING
+// If state is COOLING and 'canCool' is false change state to IDLE since there is nothing the boiler can do
+// If state is ANTI_HUNTING for ANTI_HUNTING_INTERVAL_S seconds change state to IDLE
+// If state is WAITING_FOR_SECONDARY_CONFIGURATION keep that state, no communcation has yet taken place between thermostat (primary) and boiler (secondary)
+// Return true if the state has changed, false otherwise. Any state change MUST return true, because otherwise the caller of this function does not take any action
+bool                      ThermoStateMachine::update(float                    roomTemperature,
+                                                      uint32_t                roomTemperatureTimestampS,
+                                                      float                   roomTemperatureSetpoint,
+                                                      ThermostatRequest       request) {
+  _roomTemperatureStale = (_previousRoomTemperatureTimestampS != 0 && roomTemperatureTimestampS - _previousRoomTemperatureTimestampS > ROOM_TEMPERATURE_STALE_INTERVAL_S);
+  _previousRoomTemperatureTimestampS = roomTemperatureTimestampS;
+
+  
+  roomTemperature = roundf(roomTemperature * 10.0f) / 10.0f;                      // Round to one decimal
+  roomTemperatureSetpoint = roundf(roomTemperatureSetpoint * 10.0f) / 10.0f;      // Round to one decimal
+
+  // Record room temperature for use by other member functions
+  _roomTemperature = roomTemperature;
+
+  Serial.printf("updateState room temperature is %.01f, room temperature setpoint is %.01f, previous is %.01f\n", roomTemperature, roomTemperatureSetpoint, _previousRoomTemperatureSetpoint);
+
+  if(request == ThermostatRequest::OFF) {
+    // If an 'OFF' request is received and the thermoostat state is NOT OFF and NOT waiting for secondary configuration, change state to OFF
+    // If an 'OFF' request is received and the thermostat state was already off, the state does not change
+    // In both cases there is nothing more to do
+    if(_state != ThermostatState::OFF && _state != ThermostatState::WAITING_FOR_SECONDARY_CONFIGURATION) {
+      _state = ThermostatState::OFF;
+
+      return true;
+    }
+
+    return false;
+  }
+
+  // If an 'ON' request is received and the thermostate state is OFF, change state to IDLE (IDLE implies that the boiler is NOT switched on, 
+  // unless in te NEXT run room temperature and room temperature setpoint imply to turn on heating or cooling)
+  // In all other cases the thermostat was already 'on' (any state but OFF), so the request is ignored
+  if(request == ThermostatRequest::AUTO || request == ThermostatRequest::HEAT || request == ThermostatRequest::COOL) {
+    if(_state == ThermostatState::OFF) {
+      _state = ThermostatState::IDLE;
+
+      return true;
+    }
+  }
+
+  // A change in roomtemperature setpoint is received in 'OFF' state; just record the new setpoint
+  if(_state == ThermostatState::OFF && roomTemperatureSetpoint != _previousRoomTemperatureSetpoint) {
+    _previousRoomTemperatureSetpoint = roomTemperatureSetpoint;
+
+    return false;
+  }
+
+  if(_state == ThermostatState::IDLE) {
+    // A change in setpoint is directly honoured, without taking deadzones into regard unless the room temperature timestamp is stale
+    if(_roomTemperatureStale) {
+      _previousRoomTemperatureSetpoint = roomTemperatureSetpoint;
+
+      return false;
+    }
+
+    if(roomTemperatureSetpoint != _previousRoomTemperatureSetpoint) {
+      _previousRoomTemperatureSetpoint = roomTemperatureSetpoint;
+      if(roomTemperature < roomTemperatureSetpoint) {
+        if(request == ThermostatRequest::AUTO || request == ThermostatRequest::HEAT) {
+          _state = ThermostatState::HEATING;
+
+          return true;
+        } else {
+
+          // It is colder than the setpoint but heating is requested, so stay IDLE
+          return false;          
+        }
+      } else if(roomTemperature > roomTemperatureSetpoint) {
+        if(_canCool && (request == ThermostatRequest::AUTO || request == ThermostatRequest::COOL)) {
+          _state = ThermostatState::COOLING;
+
+          return true;
+        } else {
+
+          // It is hotter than the setpoint but either cooling is not enabled or not requested, so stay IDLE
+          return false;   
+        }
+      } else {
+        // Room temperature is exactly at setpoint, stay IDLE
+
+        return false;
+      }
+    }
+    
+    if(roomTemperature >= roomTemperatureSetpoint - ROOM_TEMPERATURE_SETPOINT_LOWER_DEAD_ZONE && roomTemperature <= roomTemperatureSetpoint + ROOM_TEMPERATURE_SETPOINT_HIGHER_DEAD_ZONE) {
+      // Room temperature at setpoint plus or minus the dead zones, so stay idle
+
+      return false;
+    }
+
+    if(roomTemperature < roomTemperatureSetpoint - ROOM_TEMPERATURE_SETPOINT_LOWER_DEAD_ZONE) {
+      _state = ThermostatState::HEATING;
+
+      return true;
+    } else {
+      if(_canCool) {
+        _state = ThermostatState::COOLING;
+
+        return true;
+      } else {
+
+        return false;   // It is too hot but cooling is not enabled. Stay IDLE
+      }
+    }
+
+    return false; // Not reached
+  } else if(_state == ThermostatState::HEATING) {
+    _previousRoomTemperatureSetpoint = roomTemperatureSetpoint;
+    if(roomTemperature < roomTemperatureSetpoint && !_roomTemperatureStale) {
+  
+      return false; // Keep on heating
+    } else {
+      _state = ThermostatState::ANTI_HUNTING;
+      _antiHuntingStartTimestampS = time(nullptr);
+
+      return true;
+    }
+  } else if(_state == ThermostatState::COOLING) {
+    _previousRoomTemperatureSetpoint = roomTemperatureSetpoint;
+    if(roomTemperature > roomTemperatureSetpoint && !_roomTemperatureStale) {
+  
+      return false; // Keep on cooling
+    } else {
+      _state = ThermostatState::ANTI_HUNTING;
+      _antiHuntingStartTimestampS = time(nullptr);
+
+      return true;
+    }
+  } else if(_state == ThermostatState::ANTI_HUNTING) {
+    if(time(nullptr) - _antiHuntingStartTimestampS > ANTI_HUNTING_TIME_INTERVAL_S) {
+      _state = ThermostatState::IDLE;
+
+      return true;
+    }
+
+    return false; // Stay in anti hunting state until enough time has passed
+  } else if(_state == ThermostatState::WAITING_FOR_SECONDARY_CONFIGURATION) {
+    _previousRoomTemperatureSetpoint = roomTemperatureSetpoint;
+
+    return false;
+  } else {
+    Serial.println("Unknown state");
+
+    return false;
+  }
+}
+
+
+void                      ThermoStateMachine::updatePrimaryFlags() {
+  switch(_state) {
+    case ThermostatState::OFF:
+      _state_c_str = "Off";
+      // Switch off the boiler by disabling both heating and cooling
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_CH_ENABLE);
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_COOLING_ENABLE);
+    break;
+    case ThermostatState::IDLE:
+      _state_c_str = "Idle";
+      // Switch off the boiler by disabling both heating and cooling (may already be done by state change to anti hunting)
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_CH_ENABLE);
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_COOLING_ENABLE);
+    break;
+    case ThermostatState::HEATING:
+      _state_c_str = "Heating";
+      // Switch on the boiler by enabling heating and disabling heating and cooling
+      _primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_CH_ENABLE);
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_COOLING_ENABLE);
+    break;
+    case ThermostatState::COOLING:
+      _state_c_str = "Cooling";
+      // Switch on the cooling capabolities of the  boiler by disabling heating and enabling heating and cooling
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_CH_ENABLE);
+      _primaryFlags |= uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_COOLING_ENABLE);
+    break;
+    case ThermostatState::ANTI_HUNTING:
+      _state_c_str = "Anti hunting";
+      // Switch off the boiler by disabling both heating and cooling
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_CH_ENABLE);
+      _primaryFlags &= ~uint8_t(OpenTherm::STATUS_FLAGS::PRIMARY_COOLING_ENABLE);
+    break;
+    case ThermostatState::WAITING_FOR_SECONDARY_CONFIGURATION:
+      _state_c_str = "Waiting for seconday configuration";
+    break;
+    default:
+      _state_c_str = "Unknown";
+    break;
+  }
+}
+
+
+OpenTherm::STATUS_FLAGS   ThermoStateMachine::getPrimaryFlags() {
+  return OpenTherm::STATUS_FLAGS(_primaryFlags);
+}
+
+
+ThermostatState           ThermoStateMachine::getState() {
+  return _state;
+}
+
+bool                      ThermoStateMachine::getRoomTemperatureStale() {
+  return _roomTemperatureStale;
+}
+
+
+
+const char *              ThermoStateMachine::c_str() {
+  return _state_c_str;
+}
+
+
+#pragma once
+
+#include <Arduino.h>
+#include <EasyOpenTherm.h>
+
+
+// ThermostatState
+// The current state the thermostat is in
+// WAITING_FOR_SECONDARY_CONFIGURATION: waiting for a valid response from the boiler over the OpenTherm interface
+// OFF: a connection with the boiler over the OpenTherm interface has been made, the thermostat is waiting for a request to become active (AUTO, HEAT or COOL)
+// IDLE: the boiler is idle but the thermostat is repeatingly comparing the setpoint room temperature with the actual room temperature to decide what actin should be taken (either HEATING or COOLING)
+// HEATING: the thermostat is computing the CH setpoint and sends it to the boiler. The boiler decides upon the CH setpoint to start heating up
+// COOLING: the thermostat is computing the CH setpoint and sends it to the boiler. The boiler decides upon the CH setpoint to start cooling (only if the boiler has this capability)
+// ANTI_HUNTING: after the boiler has been active, the boiler stays deactivated for a couple of minutes to prevent the boiler from repeatedly switching om and off
+enum class ThermostatState {
+  WAITING_FOR_SECONDARY_CONFIGURATION,
+  OFF,
+  IDLE,
+  HEATING,
+  COOLING,
+  ANTI_HUNTING,
+};
+
+
+// Different requests from the Climate entity to the thermostat can come in over MQTT in text. These text messages requests are translated into these values
+// NONE: no request is yet received
+// OFF: request to put the thermostat into 'OFF' position
+// AUTO (only exists if the boiler can both heat and cool): keep the room at the room temperature setpoint by both heating and cooling
+// HEAT: keep the room at or above the room temperature setpoint by heating if necessary
+// COOL (only exists if the boiler can cool): keep the room at or below the room temperature setpoint by cooling if necessary
+enum class ThermostatRequest {
+  NONE,
+  OFF,
+  AUTO,
+  HEAT,
+  COOL,
+};
+
+
+// ThermoStateMachine
+// Record and change the thermostat state reacting to changes in the room temperature, room temperature setpoint and user requests all coming in
+// over MQTT. Also change the state to IDLE if no room temperature is received for too long a period of time.
+// update(): changes the state depending on the input parameters provided. Returns true if the state was changed, false otherwise
+// updatePrimaryFlags(): updates the primary flags (enabling and disabling heating and / or cooling) depending on the state
+// getPrimaryFlags() returns the primary flags to be send to the boiler over the OpenTherm interface
+// getState() returns the current state as an enum value
+// getRoomTemperatureStale() returns true if no room temperature update was received within the defined interval
+// c_str(): returns the state as a zero terminated const char * pointer, i.e. a 'c'-string. Pointer stays accesible during the life time of the ThermostatState instance
+class ThermoStateMachine {
+public:
+                          ThermoStateMachine();
+
+                          ~ThermoStateMachine();
+
+  bool                    connected();
+
+  void                    initPrimaryFlags(OpenTherm::CONFIGURATION_FLAGS configurationFlags);
+
+  bool                    update(float                    roomTemperature,
+                                  uint32_t                roomTemperatureTimestampS,
+                                  float                   roomTemperatureSetpoint,
+                                  ThermostatRequest       request = ThermostatRequest::NONE);
+
+  void                    updatePrimaryFlags();
+
+  OpenTherm::STATUS_FLAGS getPrimaryFlags();
+
+  ThermostatState         getState();
+
+  bool                    getRoomTemperatureStale();
+
+  const char *            c_str();
+
+private:
+  ThermostatState         _state = ThermostatState::WAITING_FOR_SECONDARY_CONFIGURATION;
+  char *                  _state_c_str = "Waiting for seconday configuration";
+
+  uint8_t                 _configurationFlags = 0;
+  uint8_t                 _primaryFlags = 0;
+
+  bool                    _canCool = false;
+  float                   _previousRoomTemperatureSetpoint = -1000.0f;
+  float                   _roomTemperature;
+  uint32_t                _previousRoomTemperatureTimestampS = 0;
+  bool                    _roomTemperatureStale = false;
+  uint32_t                _antiHuntingStartTimestampS;
+};