diff --git a/main/TheengsCommon.h b/main/TheengsCommon.h
index f52cea6..5b53add 100644
--- a/main/TheengsCommon.h
+++ b/main/TheengsCommon.h
@@ -97,9 +97,9 @@ void Config_update(JsonObject& data, const char* key, T& var) {
   if (data.containsKey(key)) {
     if (var != data[key].as<T>()) {
       var = data[key].as<T>();
-      Log.notice(F("Config %s changed to: %T" CR), key, data[key].as<T>());
+      THEENGS_LOG_NOTICE(F("Config %s changed to: %T" CR), key, data[key].as<T>());
     } else {
-      Log.notice(F("Config %s unchanged, currently: %T" CR), key, data[key].as<T>());
+      THEENGS_LOG_NOTICE(F("Config %s unchanged, currently: %T" CR), key, data[key].as<T>());
     }
   }
 }
diff --git a/main/User_config.h b/main/User_config.h
index 51c8281..31a8351 100644
--- a/main/User_config.h
+++ b/main/User_config.h
@@ -599,11 +599,47 @@ extern ss_cnt_parameters cnt_parameters_array[];
 #  define subjectMQTTtoSYSupdate "/commands/MQTTtoSYS/firmware_update"
 #endif
 #define TimeToResetAtStart 5000 // Time we allow the user at start for the reset command by button press
+
+#include <ArduinoLog.h>
+
 /*-------------------DEFINE LOG LEVEL----------------------*/
 #ifndef LOG_LEVEL
 #  define LOG_LEVEL LOG_LEVEL_NOTICE
 #endif
 
+/*-------------------SIMPLIFIED LOGGING MACROS----------------------*/
+// ArduinoLog levels: SILENT=0, FATAL=1, ERROR=2, WARNING=3, NOTICE=4, TRACE=5, VERBOSE=6
+#if LOG_LEVEL >= LOG_LEVEL_VERBOSE
+#  define THEENGS_LOG_VERBOSE(...) Log.verbose(__VA_ARGS__)
+#else
+#  define THEENGS_LOG_VERBOSE(...) ((void)0)
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_TRACE
+#  define THEENGS_LOG_TRACE(...) Log.trace(__VA_ARGS__)
+#else
+#  define THEENGS_LOG_TRACE(...) ((void)0)
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_NOTICE
+#  define THEENGS_LOG_NOTICE(...) Log.notice(__VA_ARGS__)
+#else
+#  define THEENGS_LOG_NOTICE(...) ((void)0)
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_WARNING
+#  define THEENGS_LOG_WARNING(...) Log.warning(__VA_ARGS__)
+#else
+#  define THEENGS_LOG_WARNING(...) ((void)0)
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_ERROR
+#  define THEENGS_LOG_ERROR(...) Log.error(__VA_ARGS__)
+#else
+#  define THEENGS_LOG_ERROR(...) ((void)0)
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_FATAL
+#  define LOG_FATAL(...) Log.fatal(__VA_ARGS__)
+#else
+#  define LOG_FATAL(...) ((void)0)
+#endif
+
 /*-------------------ESP Wifi band and tx power ---------------------*/
 //Certain sensors are sensitive to Wifi which can cause interference with their normal operation
 //For example it can cause false triggers on a PIR HC-SR501
diff --git a/main/actuatorFASTLED.cpp b/main/actuatorFASTLED.cpp
index 6070eb8..324561f 100644
--- a/main/actuatorFASTLED.cpp
+++ b/main/actuatorFASTLED.cpp
@@ -46,9 +46,9 @@ CRGBPalette16 gPal;
 void Fire2012WithPalette();
 
 void setupFASTLED() {
-  Log.notice(F("FASTLED_DATA_GPIO: %d" CR), FASTLED_DATA_GPIO);
-  Log.notice(F("FASTLED_NUM_LEDS: %d" CR), FASTLED_NUM_LEDS);
-  Log.trace(F("actuatorFASTLED setup done " CR));
+  THEENGS_LOG_NOTICE(F("FASTLED_DATA_GPIO: %d" CR), FASTLED_DATA_GPIO);
+  THEENGS_LOG_NOTICE(F("FASTLED_NUM_LEDS: %d" CR), FASTLED_NUM_LEDS);
+  THEENGS_LOG_TRACE(F("actuatorFASTLED setup done " CR));
   FastLED.addLeds<FASTLED_TYPE, FASTLED_DATA_GPIO>(leds, FASTLED_NUM_LEDS);
 }
 
@@ -108,16 +108,16 @@ void XtoFASTLED(const char* topicOri, JsonObject& jsonData) {
   //number = (long)strtol(&datacallback[1], NULL, 16);
 
   if (cmpToMainTopic(topicOri, subjectMQTTtoFASTLEDsetled)) {
-    Log.trace(F("MQTTtoFASTLED JSON analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoFASTLED JSON analysis" CR));
     int ledNr = jsonData["led"];
-    Log.notice(F("Led numero: %d" CR), ledNr);
+    THEENGS_LOG_NOTICE(F("Led numero: %d" CR), ledNr);
     const char* color = jsonData["hex"];
-    Log.notice(F("Color hex: %s" CR), color);
+    THEENGS_LOG_NOTICE(F("Color hex: %s" CR), color);
 
     long number = (long)strtol(color, NULL, 16);
     bool blink = jsonData["blink"];
     if (ledNr <= FASTLED_NUM_LEDS) {
-      Log.notice(F("Blink: %d" CR), blink);
+      THEENGS_LOG_NOTICE(F("Blink: %d" CR), blink);
       blinkLED[ledNr] = blink;
       leds[ledNr] = number;
     }
@@ -127,24 +127,24 @@ void XtoFASTLED(const char* topicOri, JsonObject& jsonData) {
 
 #  if simpleReceiving
 void XtoFASTLED(const char* topicOri, const char* datacallback) {
-  Log.trace(F("MQTTtoFASTLED: " CR));
+  THEENGS_LOG_TRACE(F("MQTTtoFASTLED: " CR));
   currentLEDState = GENERAL;
   long number = 0;
   if (cmpToMainTopic(topicOri, subjectMQTTtoFASTLED)) {
     number = (long)strtol(&datacallback[1], NULL, 16);
-    Log.notice(F("Number: %l" CR), number);
+    THEENGS_LOG_NOTICE(F("Number: %l" CR), number);
     for (int i = 0; i < FASTLED_NUM_LEDS; i++) {
       leds[i] = number;
     }
     FastLED.show();
   } else if (cmpToMainTopic(topicOri, subjectMQTTtoFASTLEDsetbrightness)) {
     number = (long)strtol(&datacallback[1], NULL, 16);
-    Log.notice(F("Number: %l" CR), number);
+    THEENGS_LOG_NOTICE(F("Number: %l" CR), number);
     FastLED.setBrightness(number);
     FastLED.show();
   } else if (cmpToMainTopic(topicOri, subjectMQTTtoFASTLEDsetanimation)) {
     String payload = datacallback;
-    Log.notice(F("Datacallback: %s" CR), datacallback);
+    THEENGS_LOG_NOTICE(F("Datacallback: %s" CR), datacallback);
     if (strstr(datacallback, "fire") != NULL) {
       currentLEDState = FIRE;
       gPal = HeatColors_p;
diff --git a/main/actuatorONOFF.cpp b/main/actuatorONOFF.cpp
index 0d9bb01..de7af8c 100644
--- a/main/actuatorONOFF.cpp
+++ b/main/actuatorONOFF.cpp
@@ -56,11 +56,11 @@ void ONOFFConfig_fromJson(JsonObject& ONOFFdata) {
     preferences.begin(Gateway_Short_Name, false);
     if (preferences.isKey("ONOFFConfig")) {
       int result = preferences.remove("ONOFFConfig");
-      Log.notice(F("ONOFF config erase result: %d" CR), result);
+      THEENGS_LOG_NOTICE(F("ONOFF config erase result: %d" CR), result);
       preferences.end();
       return; // Erase prevails on save, so skipping save
     } else {
-      Log.notice(F("ONOFF config not found" CR));
+      THEENGS_LOG_NOTICE(F("ONOFF config not found" CR));
       preferences.end();
     }
   }
@@ -75,7 +75,7 @@ void ONOFFConfig_fromJson(JsonObject& ONOFFdata) {
     preferences.begin(Gateway_Short_Name, false);
     int result = preferences.putString("ONOFFConfig", conf);
     preferences.end();
-    Log.notice(F("ONOFF Config_save: %s, result: %d" CR), conf.c_str(), result);
+    THEENGS_LOG_NOTICE(F("ONOFF Config_save: %s, result: %d" CR), conf.c_str(), result);
   }
 }
 
@@ -86,19 +86,19 @@ void ONOFFConfig_load() {
     auto error = deserializeJson(jsonBuffer, preferences.getString("ONOFFConfig", "{}"));
     preferences.end();
     if (error) {
-      Log.error(F("ONOFF config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+      THEENGS_LOG_ERROR(F("ONOFF config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
       return;
     }
     if (jsonBuffer.isNull()) {
-      Log.warning(F("ONOFF config is null" CR));
+      THEENGS_LOG_WARNING(F("ONOFF config is null" CR));
       return;
     }
     JsonObject jo = jsonBuffer.as<JsonObject>();
     ONOFFConfig_fromJson(jo);
-    Log.notice(F("ONOFF config loaded" CR));
+    THEENGS_LOG_NOTICE(F("ONOFF config loaded" CR));
   } else {
     preferences.end();
-    Log.notice(F("ONOFF config not found" CR));
+    THEENGS_LOG_NOTICE(F("ONOFF config not found" CR));
   }
 }
 #  else
@@ -126,11 +126,11 @@ void overLimitTemp(void* pvParameters) {
   for (;;) {
     static float previousInternalTempc = 0;
     float internalTempc = intTemperatureRead();
-    Log.trace(F("Internal temperature of the ESP32 %F" CR), internalTempc);
+    THEENGS_LOG_TRACE(F("Internal temperature of the ESP32 %F" CR), internalTempc);
     // We switch OFF the actuator if the temperature of the ESP32 is more than MAX_TEMP_ACTUATOR two consecutive times, so as to avoid false single readings to trigger the relay OFF.
     if (internalTempc > MAX_TEMP_ACTUATOR && previousInternalTempc > MAX_TEMP_ACTUATOR) {
       if (digitalRead(ACTUATOR_ONOFF_GPIO) == ACTUATOR_ON) { // This could be with the previous condition, but it is better to trigger the digitalRead only if the previous condition is met to avoid the digitalRead
-        Log.error(F("[ActuatorONOFF] OverTemperature detected ( %F > %F ) switching OFF Actuator" CR), internalTempc, MAX_TEMP_ACTUATOR);
+        THEENGS_LOG_ERROR(F("[ActuatorONOFF] OverTemperature detected ( %F > %F ) switching OFF Actuator" CR), internalTempc, MAX_TEMP_ACTUATOR);
         ActuatorTrigger();
 #      ifdef LED_ACTUATOR_ONOFF
         ledManager.setMode(LED_ACTUATOR_ONOFF, 0, LEDManager::Mode::STATIC, LED_ERROR_COLOR, -1);
@@ -151,8 +151,8 @@ void setupONOFF() {
 #  ifdef ESP32
   ONOFFConfig_init();
   ONOFFConfig_load();
-  Log.notice(F("Target state on restart: %T" CR), ONOFFConfig.ONOFFState);
-  Log.notice(F("Use last state on restart: %T" CR), ONOFFConfig.useLastStateOnStart);
+  THEENGS_LOG_NOTICE(F("Target state on restart: %T" CR), ONOFFConfig.ONOFFState);
+  THEENGS_LOG_NOTICE(F("Use last state on restart: %T" CR), ONOFFConfig.useLastStateOnStart);
 #  endif
   pinMode(ACTUATOR_ONOFF_GPIO, OUTPUT);
 #  ifdef ACTUATOR_ONOFF_DEFAULT
@@ -165,18 +165,18 @@ void setupONOFF() {
   }
 #  endif
   updatePowerIndicator();
-  Log.trace(F("actuatorONOFF setup done" CR));
+  THEENGS_LOG_TRACE(F("actuatorONOFF setup done" CR));
 }
 
 #  if jsonReceiving
 void XtoONOFF(const char* topicOri, JsonObject& ONOFFdata) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoONOFF)) {
-    Log.trace(F("MQTTtoONOFF json data analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoONOFF json data analysis" CR));
     int boolSWITCHTYPE = ONOFFdata["cmd"] | 99;
     int gpio = ONOFFdata["gpio"] | ACTUATOR_ONOFF_GPIO;
     if (boolSWITCHTYPE != 99) {
-      Log.notice(F("MQTTtoONOFF boolSWITCHTYPE ok: %d" CR), boolSWITCHTYPE);
-      Log.notice(F("GPIO number: %d" CR), gpio);
+      THEENGS_LOG_NOTICE(F("MQTTtoONOFF boolSWITCHTYPE ok: %d" CR), boolSWITCHTYPE);
+      THEENGS_LOG_NOTICE(F("GPIO number: %d" CR), gpio);
       pinMode(gpio, OUTPUT);
       digitalWrite(gpio, boolSWITCHTYPE);
 #    ifdef LED_ACTUATOR_ONOFF
@@ -196,30 +196,30 @@ void XtoONOFF(const char* topicOri, JsonObject& ONOFFdata) {
       stateONOFFMeasures();
     } else {
       if (ONOFFdata["cmd"] == "high_pulse") {
-        Log.notice(F("MQTTtoONOFF high_pulse ok" CR));
-        Log.notice(F("GPIO number: %d" CR), gpio);
+        THEENGS_LOG_NOTICE(F("MQTTtoONOFF high_pulse ok" CR));
+        THEENGS_LOG_NOTICE(F("GPIO number: %d" CR), gpio);
         int pulselength = ONOFFdata["pulse_length"] | 500;
-        Log.notice(F("Pulse length: %d ms" CR), pulselength);
+        THEENGS_LOG_NOTICE(F("Pulse length: %d ms" CR), pulselength);
         pinMode(gpio, OUTPUT);
         digitalWrite(gpio, HIGH);
         delay(pulselength);
         digitalWrite(gpio, LOW);
       } else if (ONOFFdata["cmd"] == "low_pulse") {
-        Log.notice(F("MQTTtoONOFF low_pulse ok" CR));
-        Log.notice(F("GPIO number: %d" CR), gpio);
+        THEENGS_LOG_NOTICE(F("MQTTtoONOFF low_pulse ok" CR));
+        THEENGS_LOG_NOTICE(F("GPIO number: %d" CR), gpio);
         int pulselength = ONOFFdata["pulse_length"] | 500;
-        Log.notice(F("Pulse length: %d ms" CR), pulselength);
+        THEENGS_LOG_NOTICE(F("Pulse length: %d ms" CR), pulselength);
         pinMode(gpio, OUTPUT);
         digitalWrite(gpio, LOW);
         delay(pulselength);
         digitalWrite(gpio, HIGH);
       } else {
-        Log.error(F("MQTTtoONOFF failed json read" CR));
+        THEENGS_LOG_ERROR(F("MQTTtoONOFF failed json read" CR));
       }
     }
   }
   if (cmpToMainTopic(topicOri, subjectMQTTtoONOFFset)) {
-    Log.trace(F("MQTTtoONOFF json set" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoONOFF json set" CR));
     /*
      * Configuration modifications priorities:
      *  First `init=true` and `load=true` commands are executed (if both are present, INIT prevails on LOAD)
@@ -244,13 +244,13 @@ void XtoONOFF(const char* topicOri, JsonObject& ONOFFdata) {
 #  if simpleReceiving
 void XtoONOFF(const char* topicOri, const char* datacallback) {
   if ((cmpToMainTopic(topicOri, subjectMQTTtoONOFF))) {
-    Log.trace(F("MQTTtoONOFF" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoONOFF" CR));
     char* endptr = NULL;
     long gpio = strtol(datacallback, &endptr, 10);
     if (datacallback == endptr)
       gpio = ACTUATOR_ONOFF_GPIO;
 
-    Log.notice(F("GPIO number: %d" CR), gpio);
+    THEENGS_LOG_NOTICE(F("GPIO number: %d" CR), gpio);
     pinMode(gpio, OUTPUT);
 
     bool ON = false;
@@ -278,11 +278,11 @@ void XtoONOFF(const char* topicOri, const char* datacallback) {
 #  ifdef MAX_CURRENT_ACTUATOR
 void overLimitCurrent(float RN8209current) {
   static float RN8209previousCurrent = 0;
-  Log.trace(F("RN8209 Current %F" CR), RN8209current);
+  THEENGS_LOG_TRACE(F("RN8209 Current %F" CR), RN8209current);
   // We switch OFF the actuator if the current of the RN8209 is more than MAX_CURRENT_ACTUATOR.
   if (RN8209current > MAX_CURRENT_ACTUATOR && RN8209previousCurrent > MAX_CURRENT_ACTUATOR) {
     if (digitalRead(ACTUATOR_ONOFF_GPIO) == ACTUATOR_ON) { // This could be with the previous condition, but it is better to trigger the digitalRead only if the previous condition is met to avoid the digitalRead
-      Log.error(F("[ActuatorONOFF] OverCurrent detected ( %F > %F ) switching OFF Actuator" CR), RN8209current, MAX_CURRENT_ACTUATOR);
+      THEENGS_LOG_ERROR(F("[ActuatorONOFF] OverCurrent detected ( %F > %F ) switching OFF Actuator" CR), RN8209current, MAX_CURRENT_ACTUATOR);
       ActuatorTrigger();
 #    ifdef LED_ACTUATOR_ONOFF
       ledManager.setMode(LED_ACTUATOR_ONOFF, 0, LEDManager::Mode::STATIC, LED_ERROR_COLOR, -1);
@@ -302,7 +302,7 @@ void overLimitCurrent(float RN8209current) {}
 */
 void ActuatorTrigger() {
   uint8_t level = !digitalRead(ACTUATOR_ONOFF_GPIO);
-  Log.trace(F("Actuator triggered %d" CR), level);
+  THEENGS_LOG_TRACE(F("Actuator triggered %d" CR), level);
   digitalWrite(ACTUATOR_ONOFF_GPIO, level);
 #  ifdef LED_ACTUATOR_ONOFF
   if (level == ACTUATOR_ON) {
diff --git a/main/actuatorPWM.cpp b/main/actuatorPWM.cpp
index 3db3eab..f8348e3 100644
--- a/main/actuatorPWM.cpp
+++ b/main/actuatorPWM.cpp
@@ -135,7 +135,7 @@ void setupPWM() {
     calibrationGamma[i] = PWM_DEFAULT_GAMMA;
   }
 
-  Log.trace(F("actuatorPWM setup done " CR));
+  THEENGS_LOG_TRACE(F("actuatorPWM setup done " CR));
 }
 
 // This applies a power curve to the input to try to make the inputs
@@ -186,7 +186,7 @@ void PWMLoop() {
 #  else
     analogWrite(channelPins[i], dutyCycle);
 #  endif
-    //Log.notice(F("Setting channel %d : %d" CR),i,dutyCycle);
+    //THEENGS_LOG_NOTICE(F("Setting channel %d : %d" CR),i,dutyCycle);
   }
 }
 
@@ -197,7 +197,7 @@ boolean PWMtoX() {
 #  if jsonReceiving
 void XtoPWM(const char* topicOri, JsonObject& jsonData) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoPWMset)) {
-    Log.trace(F("MQTTtoPWM JSON analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoPWM JSON analysis" CR));
     // Parse the target value for each channel
     int modifiedChannelBits = 0;
     for (int i = 0; i < kNumChannels; ++i) {
diff --git a/main/actuatorSomfy.cpp b/main/actuatorSomfy.cpp
index 81b9091..e2e5293 100644
--- a/main/actuatorSomfy.cpp
+++ b/main/actuatorSomfy.cpp
@@ -45,29 +45,29 @@ void setupSomfy() {
 
 #  if defined(ESP32)
   if (!EEPROM.begin(max(4, SOMFY_REMOTE_NUM * 2))) {
-    Log.error(F("failed to initialise EEPROM" CR));
+    THEENGS_LOG_ERROR(F("failed to initialise EEPROM" CR));
   }
 #  elif defined(ESP8266)
   EEPROM.begin(max(4, SOMFY_REMOTE_NUM * 2));
 #  endif
 
-  Log.trace(F("actuatorSomfy setup done " CR));
+  THEENGS_LOG_TRACE(F("actuatorSomfy setup done " CR));
 }
 
 #  if jsonReceiving
 void XtoSomfy(const char* topicOri, JsonObject& jsonData) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoSomfy)) {
-    Log.trace(F("MQTTtoSomfy json data analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoSomfy json data analysis" CR));
     float txFrequency = jsonData["frequency"] | RFConfig.frequency;
 #    ifdef ZradioCC1101 // set Receive off and Transmitt on
     disableCurrentReceiver();
     ELECHOUSE_cc1101.SetTx(txFrequency);
-    Log.notice(F("Transmit frequency: %F" CR), txFrequency);
+    THEENGS_LOG_NOTICE(F("Transmit frequency: %F" CR), txFrequency);
 #    endif
 
     const int remoteIndex = jsonData["remote"];
     if (remoteIndex >= SOMFY_REMOTE_NUM) {
-      Log.warning(F("actuatorSomfy remote does not exist" CR));
+      THEENGS_LOG_WARNING(F("actuatorSomfy remote does not exist" CR));
       return;
     }
     const String commandData = jsonData["command"];
diff --git a/main/blufi.cpp b/main/blufi.cpp
index 5dabe29..198e537 100644
--- a/main/blufi.cpp
+++ b/main/blufi.cpp
@@ -107,7 +107,7 @@ void receivingCommandTask(void* pvParameters) {
   JsonObject jsonBlufi = json.to<JsonObject>();
   auto error = deserializeJson(json, taskData->data, taskData->data_len);
   if (error) {
-    Log.error(F("deserialize config failed: %s, buffer capacity: %u" CR), error.c_str(), json.capacity());
+    THEENGS_LOG_ERROR(F("deserialize config failed: %s, buffer capacity: %u" CR), error.c_str(), json.capacity());
   } else {
     if (jsonBlufi.containsKey("target") && jsonBlufi["target"].is<char*>()) {
       char topic[(parameters_size) * 2 + jsonBlufi["target"].size() + 1];
@@ -117,7 +117,7 @@ void receivingCommandTask(void* pvParameters) {
       serializeJson(jsonBlufi, jsonStr);
       receivingDATA(topic, jsonStr);
     } else {
-      Log.notice(F("No target found in the received command using SYS target, default index and save command" CR));
+      THEENGS_LOG_NOTICE(F("No target found in the received command using SYS target, default index and save command" CR));
       if (!json.containsKey("cnt_index")) {
         json["cnt_index"] = CNT_DEFAULT_INDEX;
         json["save_cnt"] = true;
@@ -169,7 +169,7 @@ void sendCustomDataNotification(const char* message) {
 #  ifdef BT_CONNECTION_TIMEOUT_MS
 void connection_timeout_callback(void* arg) {
   if (omg_blufi_ble_connected) {
-    Log.notice(F("BluFi connection timeout reached. Disconnecting." CR));
+    THEENGS_LOG_NOTICE(F("BluFi connection timeout reached. Disconnecting." CR));
     esp_blufi_disconnect();
     omg_blufi_ble_connected = false;
   }
@@ -187,7 +187,7 @@ void restart_connection_timer() {
   esp_timer_stop(connection_timer); // Stop the timer if it's running
   esp_err_t ret = esp_timer_start_once(connection_timer, BT_CONNECTION_TIMEOUT_MS * 1000);
   if (ret != ESP_OK) {
-    Log.error(F("Failed to start connection timer: %d" CR), ret);
+    THEENGS_LOG_ERROR(F("Failed to start connection timer: %d" CR), ret);
   }
 }
 
@@ -203,7 +203,7 @@ void stop_connection_timer() {}
 
 void set_blufi_mfg_data () {
   if (!NimBLEDevice::isInitialized() || !NimBLEDevice::getAdvertising()->isAdvertising()) {
-    Log.notice(F("Unable to set advertising data" CR));
+    THEENGS_LOG_NOTICE(F("Unable to set advertising data" CR));
     return;
   }
   ble_hs_adv_fields fields;
@@ -222,9 +222,9 @@ void set_blufi_mfg_data () {
   fields.mfg_data_len = sizeof(omg_blufi_mfg_data);
   auto rc = ble_gap_adv_set_fields(&fields);
   if (rc != 0) {
-    Log.error(F("Failed to set BLE advertising fields: %d" CR), rc);
+    THEENGS_LOG_ERROR(F("Failed to set BLE advertising fields: %d" CR), rc);
   } else {
-    Log.trace(F("BLE advertising fields set successfully" CR));
+    THEENGS_LOG_TRACE(F("BLE advertising fields set successfully" CR));
   }
 }
 
@@ -240,12 +240,12 @@ static void example_event_callback(esp_blufi_cb_event_t event, esp_blufi_cb_para
 
   switch (event) {
     case ESP_BLUFI_EVENT_INIT_FINISH: {
-      Log.trace(F("BLUFI init finish" CR));
+      THEENGS_LOG_TRACE(F("BLUFI init finish" CR));
       start_blufi_advertising();
       break;
     }
     case ESP_BLUFI_EVENT_DEINIT_FINISH:
-      Log.trace(F("BLUFI deinit finish" CR));
+      THEENGS_LOG_TRACE(F("BLUFI deinit finish" CR));
       NimBLEDevice::deinit(true);
       if (connection_timer != nullptr) {
         esp_timer_delete(connection_timer);
@@ -253,7 +253,7 @@ static void example_event_callback(esp_blufi_cb_event_t event, esp_blufi_cb_para
       }
       break;
     case ESP_BLUFI_EVENT_BLE_CONNECT:
-      Log.trace(F("BLUFI BLE connect" CR));
+      THEENGS_LOG_TRACE(F("BLUFI BLE connect" CR));
       gatewayState = GatewayState::ONBOARDING;
       omg_blufi_ble_connected = true;
       restart_connection_timer();
@@ -265,7 +265,7 @@ static void example_event_callback(esp_blufi_cb_event_t event, esp_blufi_cb_para
       blufi_security_init();
       break;
     case ESP_BLUFI_EVENT_BLE_DISCONNECT:
-      Log.trace(F("BLUFI BLE disconnect" CR));
+      THEENGS_LOG_TRACE(F("BLUFI BLE disconnect" CR));
       omg_blufi_ble_connected = false;
       stop_connection_timer();
       if (mqtt && mqtt->connected()) {
@@ -284,23 +284,23 @@ static void example_event_callback(esp_blufi_cb_event_t event, esp_blufi_cb_para
       start_blufi_advertising();
       break;
     case ESP_BLUFI_EVENT_REQ_CONNECT_TO_AP:
-      Log.trace(F("BLUFI request wifi connect to AP" CR));
+      THEENGS_LOG_TRACE(F("BLUFI request wifi connect to AP" CR));
       WiFi.begin((char*)gl_sta_ssid, (char*)gl_sta_passwd);
       gl_sta_is_connecting = true;
       break;
     case ESP_BLUFI_EVENT_REQ_DISCONNECT_FROM_AP:
-      Log.trace(F("BLUFI request wifi disconnect from AP\n" CR));
+      THEENGS_LOG_TRACE(F("BLUFI request wifi disconnect from AP\n" CR));
       WiFi.disconnect();
       break;
     case ESP_BLUFI_EVENT_REPORT_ERROR:
-      Log.trace(F("BLUFI report error, error code %d\n" CR), param->report_error.state);
+      THEENGS_LOG_TRACE(F("BLUFI report error, error code %d\n" CR), param->report_error.state);
       esp_blufi_send_error_info(param->report_error.state);
       break;
     case ESP_BLUFI_EVENT_GET_WIFI_STATUS: {
       esp_blufi_extra_info_t info;
-      Log.trace(F("BLUFI get wifi status" CR));
+      THEENGS_LOG_TRACE(F("BLUFI get wifi status" CR));
       if (gl_sta_ssid_len > 0 && gl_sta_ssid[0] != '\0') {
-        Log.trace(F("SSID exists" CR));
+        THEENGS_LOG_TRACE(F("SSID exists" CR));
         memset(&info, 0, sizeof(esp_blufi_extra_info_t));
         if (memcmp(gl_sta_bssid, "\0\0\0\0\0\0", 6) != 0) {
           memcpy(info.sta_bssid, gl_sta_bssid, 6);
@@ -318,25 +318,25 @@ static void example_event_callback(esp_blufi_cb_event_t event, esp_blufi_cb_para
       break;
     }
     case ESP_BLUFI_EVENT_RECV_SLAVE_DISCONNECT_BLE:
-      Log.trace(F("BLUFI recv slave disconnect a ble connection" CR));
+      THEENGS_LOG_TRACE(F("BLUFI recv slave disconnect a ble connection" CR));
       esp_blufi_disconnect();
       break;
     case ESP_BLUFI_EVENT_RECV_STA_SSID:
       strncpy((char*)gl_sta_ssid, (char*)param->sta_ssid.ssid, param->sta_ssid.ssid_len);
       gl_sta_ssid[param->sta_ssid.ssid_len] = '\0';
-      Log.notice(F("Recv STA SSID %s" CR), gl_sta_ssid);
+      THEENGS_LOG_NOTICE(F("Recv STA SSID %s" CR), gl_sta_ssid);
       break;
     case ESP_BLUFI_EVENT_RECV_STA_PASSWD:
       strncpy((char*)gl_sta_passwd, (char*)param->sta_passwd.passwd, param->sta_passwd.passwd_len);
       gl_sta_passwd[param->sta_passwd.passwd_len] = '\0';
-      Log.notice(F("Recv STA PASSWORD" CR));
+      THEENGS_LOG_NOTICE(F("Recv STA PASSWORD" CR));
       break;
     case ESP_BLUFI_EVENT_GET_WIFI_LIST: {
       WiFi.scanNetworks(true);
       break;
     }
     case ESP_BLUFI_EVENT_RECV_CUSTOM_DATA: {
-      Log.notice(F("Recv Custom Data %" PRIu32 CR), param->custom_data.data_len);
+      THEENGS_LOG_NOTICE(F("Recv Custom Data %" PRIu32 CR), param->custom_data.data_len);
       esp_log_buffer_hex("Custom Data", param->custom_data.data, param->custom_data.data_len);
       createReceivingCommandTask(param->custom_data.data, param->custom_data.data_len);
       break;
@@ -384,23 +384,23 @@ void wifi_event_handler(arduino_event_id_t event) {
       if (omg_blufi_ble_connected == true) {
         esp_blufi_send_wifi_conn_report(WIFI_MODE_STA, ESP_BLUFI_STA_CONN_SUCCESS, 0, &info);
       }
-      Log.notice(F("Connected to SSID: %s" CR), gl_sta_ssid);
+      THEENGS_LOG_NOTICE(F("Connected to SSID: %s" CR), gl_sta_ssid);
       break;
     }
     case ARDUINO_EVENT_WIFI_SCAN_DONE: {
       uint16_t apCount = WiFi.scanComplete();
       if (apCount == 0) {
-        Log.error(F("No AP found" CR));
+        THEENGS_LOG_ERROR(F("No AP found" CR));
         break;
       }
-      Log.trace(F("AP found, count: %d" CR), apCount);
+      THEENGS_LOG_TRACE(F("AP found, count: %d" CR), apCount);
       esp_blufi_ap_record_t* blufi_ap_list = (esp_blufi_ap_record_t*)malloc(apCount * sizeof(esp_blufi_ap_record_t));
       if (!blufi_ap_list) {
-        Log.error(F("Failed to allocate memory for AP list" CR));
+        THEENGS_LOG_ERROR(F("Failed to allocate memory for AP list" CR));
         break;
       }
       for (int i = 0; i < apCount; ++i) {
-        Log.notice(F("%d: %s, Ch:%d (%ddBm)" CR), i + 1, WiFi.SSID(i).c_str(), WiFi.channel(i), WiFi.RSSI(i));
+        THEENGS_LOG_NOTICE(F("%d: %s, Ch:%d (%ddBm)" CR), i + 1, WiFi.SSID(i).c_str(), WiFi.channel(i), WiFi.RSSI(i));
         blufi_ap_list[i].rssi = WiFi.RSSI(i);
         size_t ssidLength = strlen(WiFi.SSID(i).c_str());
         if (ssidLength > sizeof(blufi_ap_list[i].ssid) - 1) {
@@ -411,7 +411,7 @@ void wifi_event_handler(arduino_event_id_t event) {
       }
       if (omg_blufi_ble_connected == true) {
         if (esp_blufi_send_wifi_list(apCount, blufi_ap_list) != ESP_OK) {
-          Log.error(F("Failed to send WiFi list" CR));
+          THEENGS_LOG_ERROR(F("Failed to send WiFi list" CR));
         }
       }
       free(blufi_ap_list);
@@ -445,7 +445,7 @@ bool startBlufi() {
 
   ret = esp_blufi_register_callbacks(&example_callbacks);
   if (ret) {
-    Log.error(F("%s blufi register failed, error code = %x" CR), __func__, ret);
+    THEENGS_LOG_ERROR(F("%s blufi register failed, error code = %x" CR), __func__, ret);
     return false;
   }
 
@@ -459,7 +459,7 @@ bool startBlufi() {
   char advName[17] = {0};
   // Check length of Gateway_Short_Name
   if (strlen(Gateway_Short_Name) > 3) {
-    Log.error(F("Gateway_Short_Name is too long, max 3 characters" CR));
+    THEENGS_LOG_ERROR(F("Gateway_Short_Name is too long, max 3 characters" CR));
     return false;
   }
   snprintf(advName, sizeof(advName), Gateway_Short_Name "_%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
@@ -473,7 +473,7 @@ bool startBlufi() {
   pCommandCharacteristic = pNimBLEOtaSvc->getCharacteristic(NimBLEUUID((uint16_t)0x8022));
   pRecvFwCharacteristic = pNimBLEOtaSvc->getCharacteristic(NimBLEUUID((uint16_t)0x8020));
   ble_gatts_start();
-  Log.notice(F("BLUFI started" CR));
+  THEENGS_LOG_NOTICE(F("BLUFI started" CR));
   return esp_blufi_profile_init() == ESP_OK;
 }
 
@@ -487,10 +487,10 @@ bool stopBlufi() {
   ble_gap_adv_stop();
   result = esp_blufi_profile_deinit();
   if (result != ESP_OK) {
-    Log.error(F("Failed to deinit blufi profile: %d" CR), result);
+    THEENGS_LOG_ERROR(F("Failed to deinit blufi profile: %d" CR), result);
     return false;
   }
-  Log.notice(F("BLUFI stopped" CR));
+  THEENGS_LOG_NOTICE(F("BLUFI stopped" CR));
   return true;
 }
 
diff --git a/main/blufiSec.cpp b/main/blufiSec.cpp
index e81f37c..0ac90c1 100644
--- a/main/blufiSec.cpp
+++ b/main/blufiSec.cpp
@@ -8,6 +8,7 @@
 
 #  include <ArduinoLog.h>
 
+#  include "User_config.h"
 #  include "esp_blufi_api.h"
 #  include "esp_crc.h"
 #  include "esp_random.h"
@@ -52,7 +53,7 @@ extern "C" void btc_blufi_report_error(esp_blufi_error_state_t state);
 
 void blufi_dh_negotiate_data_handler(uint8_t* data, int len, uint8_t** output_data, int* output_len, bool* need_free) {
   if (data == NULL || len < 3) {
-    Log.error(F("BLUFI Invalid data format" CR));
+    THEENGS_LOG_ERROR(F("BLUFI Invalid data format" CR));
     btc_blufi_report_error(ESP_BLUFI_DATA_FORMAT_ERROR);
     return;
   }
@@ -61,7 +62,7 @@ void blufi_dh_negotiate_data_handler(uint8_t* data, int len, uint8_t** output_da
   uint8_t type = data[0];
 
   if (blufi_sec == NULL) {
-    Log.error(F("BLUFI Security is not initialized" CR));
+    THEENGS_LOG_ERROR(F("BLUFI Security is not initialized" CR));
     btc_blufi_report_error(ESP_BLUFI_INIT_SECURITY_ERROR);
     return;
   }
@@ -77,19 +78,19 @@ void blufi_dh_negotiate_data_handler(uint8_t* data, int len, uint8_t** output_da
       if (blufi_sec->dh_param == NULL) {
         blufi_sec->dh_param_len = 0; /* Reset length to avoid using unallocated memory */
         btc_blufi_report_error(ESP_BLUFI_DH_MALLOC_ERROR);
-        Log.error(F("%s, malloc failed\n" CR), __func__);
+        THEENGS_LOG_ERROR(F("%s, malloc failed\n" CR), __func__);
         return;
       }
       break;
     case SEC_TYPE_DH_PARAM_DATA: {
       if (blufi_sec->dh_param == NULL) {
-        Log.error(F("%s, blufi_sec->dh_param == NULL" CR), __func__);
+        THEENGS_LOG_ERROR(F("%s, blufi_sec->dh_param == NULL" CR), __func__);
         btc_blufi_report_error(ESP_BLUFI_DH_PARAM_ERROR);
         return;
       }
 
       if (len < (blufi_sec->dh_param_len + 1)) {
-        Log.error(F("%s, invalid dh param len" CR), __func__);
+        THEENGS_LOG_ERROR(F("%s, invalid dh param len" CR), __func__);
         btc_blufi_report_error(ESP_BLUFI_DH_PARAM_ERROR);
         return;
       }
@@ -98,7 +99,7 @@ void blufi_dh_negotiate_data_handler(uint8_t* data, int len, uint8_t** output_da
       memcpy(blufi_sec->dh_param, &data[1], blufi_sec->dh_param_len);
       ret = mbedtls_dhm_read_params(&blufi_sec->dhm, &param, &param[blufi_sec->dh_param_len]);
       if (ret) {
-        Log.error(F("%s read param failed %d" CR), __func__, ret);
+        THEENGS_LOG_ERROR(F("%s read param failed %d" CR), __func__, ret);
         btc_blufi_report_error(ESP_BLUFI_READ_PARAM_ERROR);
         return;
       }
@@ -108,14 +109,14 @@ void blufi_dh_negotiate_data_handler(uint8_t* data, int len, uint8_t** output_da
       const int dhm_len = mbedtls_dhm_get_len(&blufi_sec->dhm);
 
       if (dhm_len > DH_SELF_PUB_KEY_LEN) {
-        Log.error(F("%s dhm len not support %d" CR), __func__, dhm_len);
+        THEENGS_LOG_ERROR(F("%s dhm len not support %d" CR), __func__, dhm_len);
         btc_blufi_report_error(ESP_BLUFI_DH_PARAM_ERROR);
         return;
       }
 
       ret = mbedtls_dhm_make_public(&blufi_sec->dhm, dhm_len, blufi_sec->self_public_key, DH_SELF_PUB_KEY_LEN, myrand, NULL);
       if (ret) {
-        Log.error(F("%s make public failed %d" CR), __func__, ret);
+        THEENGS_LOG_ERROR(F("%s make public failed %d" CR), __func__, ret);
         btc_blufi_report_error(ESP_BLUFI_MAKE_PUBLIC_ERROR);
         return;
       }
@@ -126,7 +127,7 @@ void blufi_dh_negotiate_data_handler(uint8_t* data, int len, uint8_t** output_da
                                     &blufi_sec->share_len,
                                     myrand, NULL);
       if (ret) {
-        Log.error(F("%s mbedtls_dhm_calc_secret failed %d" CR), __func__, ret);
+        THEENGS_LOG_ERROR(F("%s mbedtls_dhm_calc_secret failed %d" CR), __func__, ret);
         btc_blufi_report_error(ESP_BLUFI_DH_PARAM_ERROR);
         return;
       }
@@ -134,7 +135,7 @@ void blufi_dh_negotiate_data_handler(uint8_t* data, int len, uint8_t** output_da
       ret = mbedtls_md5(blufi_sec->share_key, blufi_sec->share_len, blufi_sec->psk);
 
       if (ret) {
-        Log.error(F("%s mbedtls_md5 failed %d" CR), __func__, ret);
+        THEENGS_LOG_ERROR(F("%s mbedtls_md5 failed %d" CR), __func__, ret);
         btc_blufi_report_error(ESP_BLUFI_CALC_MD5_ERROR);
         return;
       }
diff --git a/main/boardM5.cpp b/main/boardM5.cpp
index 15cc0e8..b1808c5 100644
--- a/main/boardM5.cpp
+++ b/main/boardM5.cpp
@@ -64,7 +64,7 @@ void setBrightness(int brightness) {
 }
 
 void setupM5() {
-  Log.notice(F("Setup M5" CR));
+  THEENGS_LOG_NOTICE(F("Setup M5" CR));
   pinMode(SLEEP_BUTTON, INPUT);
   // M5 stack 320*240
   // M5StickC 160*80
@@ -76,11 +76,11 @@ void setupM5() {
   Log.begin(LOG_LEVEL_LCD, &M5.Lcd); // Log on LCD following LOG_LEVEL_LCD
 #  endif
 
-  Log.notice(F("Setup M5 end" CR));
+  THEENGS_LOG_NOTICE(F("Setup M5 end" CR));
 }
 
 void sleepScreen() {
-  Log.trace(F("Screen going to sleep" CR));
+  THEENGS_LOG_TRACE(F("Screen going to sleep" CR));
 #  if defined(ZboardM5STACK)
   M5.begin(false, false, false); // M5.lcd.sleep() provokes a reset of the ESP
 #  endif
@@ -91,7 +91,7 @@ void sleepScreen() {
 }
 
 void wakeScreen(int brightness) {
-  Log.trace(F("Screen wake up" CR));
+  THEENGS_LOG_TRACE(F("Screen wake up" CR));
   M5.begin();
   M5.Lcd.setCursor(0, 0, (M5.Lcd.height() > 200) ? 4 : 2);
   M5.Lcd.setTextSize(1);
@@ -127,18 +127,18 @@ void loopM5() {
 
 void XtoM5(const char* topicOri, JsonObject& M5data) { // json object decoding
   if (cmpToMainTopic(topicOri, subjectMQTTtoM5set)) {
-    Log.trace(F("MQTTtoM5 json set" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoM5 json set" CR));
     // Log display set between M5 lcd (true) and serial monitor (false)
     if (M5data.containsKey("log-lcd")) {
       bool displayOnLCD = M5data["log-lcd"];
-      Log.notice(F("Set lcd log: %T" CR), displayOnLCD);
+      THEENGS_LOG_NOTICE(F("Set lcd log: %T" CR), displayOnLCD);
       logToLCD(displayOnLCD);
     }
   }
 }
 
 void displayIntro(int i, int X, int Y) {
-  Log.trace(F("Intro display on screen" CR));
+  THEENGS_LOG_TRACE(F("Intro display on screen" CR));
   drawLogo(i, X, Y, false, true, false, false, false, false);
   delay(50);
   drawLogo(i, X, Y, false, false, true, false, false, false);
diff --git a/main/boardTheengs.cpp b/main/boardTheengs.cpp
index 57a0ed5..f30aec9 100644
--- a/main/boardTheengs.cpp
+++ b/main/boardTheengs.cpp
@@ -63,7 +63,7 @@ void testDevice() {
 }
 
 void testLeds() {
-  Log.notice(F("LED Test" CR));
+  THEENGS_LOG_NOTICE(F("LED Test" CR));
   ledManager.setMode(0, 0, LEDManager::Mode::STATIC, LED_NETWORK_OK_COLOR, -1);
   delay(1000);
   ledManager.setMode(0, 1, LEDManager::Mode::STATIC, LED_NETWORK_OK_COLOR, -1);
@@ -71,25 +71,25 @@ void testLeds() {
   ledManager.setMode(0, 2, LEDManager::Mode::STATIC, LED_NETWORK_OK_COLOR, -1);
   delay(1000);
   ledManager.setMode(0, 3, LEDManager::Mode::STATIC, LED_NETWORK_OK_COLOR, -1);
-  Log.notice(F("LED Test Finished" CR));
+  THEENGS_LOG_NOTICE(F("LED Test Finished" CR));
 }
 
 void checkSerial() {
-  Log.notice(F("READY_FOR_SELFTEST" CR));
+  THEENGS_LOG_NOTICE(F("READY_FOR_SELFTEST" CR));
   unsigned long start = millis();
   while (millis() - start < 1000) {
     if (Serial.available() > 0) {
       String input = Serial.readStringUntil('\n');
       input.trim(); // Remove any extra whitespace
       if (input == "SELFTEST") {
-        Log.notice(F("SELFTEST Launched" CR));
+        THEENGS_LOG_NOTICE(F("SELFTEST Launched" CR));
         testLeds();
         // Print 20 times the test data
         for (int i = 0; i < 20; i++) {
           testDevice();
           delay(1000);
         }
-        Log.notice(F("SELFTEST Finished" CR));
+        THEENGS_LOG_NOTICE(F("SELFTEST Finished" CR));
         // Restart
         ESPRestart(9);
       }
diff --git a/main/commonRF.cpp b/main/commonRF.cpp
index 69fbba6..1f5b05c 100644
--- a/main/commonRF.cpp
+++ b/main/commonRF.cpp
@@ -52,12 +52,12 @@ void initCC1101() {
     ELECHOUSE_cc1101.setSpiPin(RF_MODULE_SCK, RF_MODULE_MISO, RF_MODULE_MOSI, RF_MODULE_CS);
 #    endif
     if (ELECHOUSE_cc1101.getCC1101()) {
-      Log.notice(F("C1101 spi Connection OK" CR));
+      THEENGS_LOG_NOTICE(F("C1101 spi Connection OK" CR));
       ELECHOUSE_cc1101.Init();
       ELECHOUSE_cc1101.SetRx(RFConfig.frequency);
       break;
     } else {
-      Log.error(F("C1101 spi Connection Error" CR));
+      THEENGS_LOG_ERROR(F("C1101 spi Connection Error" CR));
       delay(delayMS);
     }
     // truncated exponential backoff
@@ -106,14 +106,14 @@ bool validReceiver(int receiver) {
       return true;
 #    endif
     default:
-      Log.error(F("ERROR: stored receiver %d not available" CR), receiver);
+      THEENGS_LOG_ERROR(F("ERROR: stored receiver %d not available" CR), receiver);
   }
   return false;
 }
 #  endif
 
 void disableCurrentReceiver() {
-  Log.trace(F("disableCurrentReceiver: %d" CR), currentReceiver);
+  THEENGS_LOG_TRACE(F("disableCurrentReceiver: %d" CR), currentReceiver);
   switch (currentReceiver) {
     case ACTIVE_NONE:
       break;
@@ -138,12 +138,12 @@ void disableCurrentReceiver() {
       break;
 #  endif
     default:
-      Log.error(F("ERROR: unsupported receiver %d" CR), RFConfig.activeReceiver);
+      THEENGS_LOG_ERROR(F("ERROR: unsupported receiver %d" CR), RFConfig.activeReceiver);
   }
 }
 
 void enableActiveReceiver() {
-  Log.trace(F("enableActiveReceiver: %d" CR), RFConfig.activeReceiver);
+  THEENGS_LOG_TRACE(F("enableActiveReceiver: %d" CR), RFConfig.activeReceiver);
   switch (RFConfig.activeReceiver) {
 #  ifdef ZgatewayPilight
     case ACTIVE_PILIGHT:
@@ -174,10 +174,10 @@ void enableActiveReceiver() {
       break;
 #  endif
     case ACTIVE_RECERROR:
-      Log.error(F("ERROR: no receiver selected" CR));
+      THEENGS_LOG_ERROR(F("ERROR: no receiver selected" CR));
       break;
     default:
-      Log.error(F("ERROR: unsupported receiver %d" CR), RFConfig.activeReceiver);
+      THEENGS_LOG_ERROR(F("ERROR: unsupported receiver %d" CR), RFConfig.activeReceiver);
   }
 }
 
@@ -215,17 +215,17 @@ void RFConfig_fromJson(JsonObject& RFdata) {
   bool success = false;
   if (RFdata.containsKey("frequency") && validFrequency(RFdata["frequency"])) {
     Config_update(RFdata, "frequency", RFConfig.frequency);
-    Log.notice(F("RF Receive mhz: %F" CR), RFConfig.frequency);
+    THEENGS_LOG_NOTICE(F("RF Receive mhz: %F" CR), RFConfig.frequency);
     success = true;
   }
   if (RFdata.containsKey("active")) {
-    Log.notice(F("RF receiver active: %d" CR), RFConfig.activeReceiver);
+    THEENGS_LOG_NOTICE(F("RF receiver active: %d" CR), RFConfig.activeReceiver);
     Config_update(RFdata, "active", RFConfig.activeReceiver);
     success = true;
   }
 #  ifdef ZgatewayRTL_433
   if (RFdata.containsKey("rssithreshold")) {
-    Log.notice(F("RTL_433 RSSI Threshold : %d " CR), RFConfig.rssiThreshold);
+    THEENGS_LOG_NOTICE(F("RTL_433 RSSI Threshold : %d " CR), RFConfig.rssiThreshold);
     Config_update(RFdata, "rssithreshold", RFConfig.rssiThreshold);
     rtl_433.setRSSIThreshold(RFConfig.rssiThreshold);
     success = true;
@@ -233,18 +233,18 @@ void RFConfig_fromJson(JsonObject& RFdata) {
 #    if defined(RF_SX1276) || defined(RF_SX1278)
   if (RFdata.containsKey("ookthreshold")) {
     Config_update(RFdata, "ookthreshold", RFConfig.newOokThreshold);
-    Log.notice(F("RTL_433 ookThreshold %d" CR), RFConfig.newOokThreshold);
+    THEENGS_LOG_NOTICE(F("RTL_433 ookThreshold %d" CR), RFConfig.newOokThreshold);
     rtl_433.setOOKThreshold(RFConfig.newOokThreshold);
     success = true;
   }
 #    endif
   if (RFdata.containsKey("status")) {
-    Log.notice(F("RF get status:" CR));
+    THEENGS_LOG_NOTICE(F("RF get status:" CR));
     rtl_433.getStatus();
     success = true;
   }
   if (!success) {
-    Log.error(F("MQTTtoRF Fail json" CR));
+    THEENGS_LOG_ERROR(F("MQTTtoRF Fail json" CR));
   }
 #  endif
   disableCurrentReceiver();
@@ -255,11 +255,11 @@ void RFConfig_fromJson(JsonObject& RFdata) {
     preferences.begin(Gateway_Short_Name, false);
     if (preferences.isKey("RFConfig")) {
       int result = preferences.remove("RFConfig");
-      Log.notice(F("RF config erase result: %d" CR), result);
+      THEENGS_LOG_NOTICE(F("RF config erase result: %d" CR), result);
       preferences.end();
       return; // Erase prevails on save, so skipping save
     } else {
-      Log.notice(F("RF config not found" CR));
+      THEENGS_LOG_NOTICE(F("RF config not found" CR));
       preferences.end();
     }
   }
@@ -279,7 +279,7 @@ void RFConfig_fromJson(JsonObject& RFdata) {
     preferences.begin(Gateway_Short_Name, false);
     int result = preferences.putString("RFConfig", conf);
     preferences.end();
-    Log.notice(F("RF Config_save: %s, result: %d" CR), conf.c_str(), result);
+    THEENGS_LOG_NOTICE(F("RF Config_save: %s, result: %d" CR), conf.c_str(), result);
   }
 #  endif
 }
@@ -299,19 +299,19 @@ void RFConfig_load() {
     auto error = deserializeJson(jsonBuffer, preferences.getString("RFConfig", "{}"));
     preferences.end();
     if (error) {
-      Log.error(F("RF Config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+      THEENGS_LOG_ERROR(F("RF Config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
       return;
     }
     if (jsonBuffer.isNull()) {
-      Log.warning(F("RF Config is null" CR));
+      THEENGS_LOG_WARNING(F("RF Config is null" CR));
       return;
     }
     JsonObject jo = jsonBuffer.as<JsonObject>();
     RFConfig_fromJson(jo);
-    Log.notice(F("RF Config loaded" CR));
+    THEENGS_LOG_NOTICE(F("RF Config loaded" CR));
   } else {
     preferences.end();
-    Log.notice(F("RF Config not found using default" CR));
+    THEENGS_LOG_NOTICE(F("RF Config not found using default" CR));
     enableActiveReceiver();
   }
 #  else
@@ -321,7 +321,7 @@ void RFConfig_load() {
 
 void XtoRFset(const char* topicOri, JsonObject& RFdata) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoRFset)) {
-    Log.trace(F("MQTTtoRF json set" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoRF json set" CR));
 
     /*
      * Configuration modifications priorities:
diff --git a/main/config_RF.h b/main/config_RF.h
index 19e211e..44602d4 100644
--- a/main/config_RF.h
+++ b/main/config_RF.h
@@ -132,7 +132,7 @@ const char parameters[51][4][24] = {
     {"wind_speed_m_s", "Wind speed", "m/s", "wind_speed"}};
 #  endif
 #  ifdef RTL_433_DISCOVERY_LOGGING
-#    define DISCOVERY_TRACE_LOG(...) Log.trace(__VA_ARGS__)
+#    define DISCOVERY_TRACE_LOG(...) THEENGS_LOG_TRACE(__VA_ARGS__)
 #  else
 #    define DISCOVERY_TRACE_LOG(...)
 #  endif
diff --git a/main/config_WebContent.h b/main/config_WebContent.h
index 25fe830..4c6ad58 100644
--- a/main/config_WebContent.h
+++ b/main/config_WebContent.h
@@ -114,7 +114,21 @@ const char config_mqtt_body[] = body_header "<fieldset class=\"set1\"><legend><s
 #ifndef ESPWifiManualSetup
 const char config_gateway_body[] = body_header "<fieldset class=\"set1\"><legend><span><b>Gateway Configuration</b></span></legend><form method='post' action='cg'><p><b>Gateway Password (8 characters min)</b><br><input id='gp' name='gp' type='password' placeholder=\"********\"  minlength='8'></p><br><button name='save' type='submit' class='button bgrn'>Save</button></form></fieldset>" body_footer_config_menu;
 #endif
-const char config_logging_body[] = body_header "<fieldset class=\"set1\"><legend><span><b>OpenMQTTGateway Logging</b></span></legend><form method='get' action='lo'><p><b>Log Level</b><br><select id='lo'><option %s value='0'>Silent</option><option %s value='1'>Fatal</option><option %s value='2'>Error</option><option %s value='3'>Warning</option><option %s value='4'>Notice</option><option %s value='5'>Trace</option><option %s value='6'>Verbose</option></select></p><br><button name='save' type='submit' class='button bgrn'>Save</button></form></fieldset>" body_footer_config_menu;
+const char config_logging_body[] = body_header
+    "<fieldset class=\"set1\"><legend><span><b>OpenMQTTGateway Logging</b></span></legend><form method='get' action='lo'><p><b>Log Level</b><br><select id='lo'><option %s value='0'>Silent</option><option %s value='1'>Fatal</option><option %s value='2'>Error</option>"
+#if LOG_LEVEL >= LOG_LEVEL_WARNING
+    "<option %s value='3'>Warning</option>"
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_NOTICE
+    "<option %s value='4'>Notice</option>"
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_TRACE
+    "<option %s value='5'>Trace</option>"
+#endif
+#if LOG_LEVEL >= LOG_LEVEL_VERBOSE
+    "<option %s value='6'>Verbose</option>"
+#endif
+    "</select></p><br><button name='save' type='submit' class='button bgrn'>Save</button></form></fieldset>" body_footer_config_menu;
 
 const char config_webui_body[] = body_header "<fieldset class=\"set1\"><legend><span><b>Configure WebUI</b></span></legend><form method='get' action='wu'><p><b>Display Metric</b><br><input id='dm' type='checkbox' %s></p><p><b>Secure WebUI</b><br><input id='sw' type='checkbox' %s></p><br><button name='save' type='submit' class='button bgrn'>Save</button></form></fieldset>" body_footer_config_menu;
 
diff --git a/main/config_WebUI.h b/main/config_WebUI.h
index 5ba02a4..8b3b115 100644
--- a/main/config_WebUI.h
+++ b/main/config_WebUI.h
@@ -53,9 +53,9 @@
 #endif
 
 #ifdef WEBUI_TRACE_LOGGING
-#  define WEBUI_TRACE_LOG(...) Log.trace(__VA_ARGS__)
+#  define WEBUI_TRACE_LOG(...) THEENGS_LOG_TRACE(__VA_ARGS__)
 #else
-#  define WEBUI_TRACE_LOG(...)
+#  define WEBUI_TRACE_LOG(...) ((void)0)
 #endif
 
 #ifndef WEBUI_AUTH
diff --git a/main/displaySSD1306.cpp b/main/displaySSD1306.cpp
index 84b82f9..7ea675a 100644
--- a/main/displaySSD1306.cpp
+++ b/main/displaySSD1306.cpp
@@ -113,15 +113,15 @@ module setup, for use in Arduino setup
 void setupSSD1306() {
   SSD1306Config_init();
   SSD1306Config_load();
-  Log.trace(F("Setup SSD1306 Display" CR));
-  Log.trace(F("displaySSD1306 command topic: %s" CR), subjectMQTTtoSSD1306set);
-  Log.trace(F("displaySSD1306 log-oled: %T" CR), logToOLEDDisplay);
-  Log.trace(F("displaySSD1306 json-oled: %T" CR), jsonDisplay);
-  Log.trace(F("displaySSD1306 DISPLAY_PAGE_INTERVAL: %d" CR), DISPLAY_PAGE_INTERVAL);
-  Log.trace(F("displaySSD1306 DISPLAY_IDLE_LOGO: %T" CR), idlelogo);
-  Log.trace(F("displaySSD1306 DISPLAY_FLIP: %T" CR), displayFlip);
+  THEENGS_LOG_TRACE(F("Setup SSD1306 Display" CR));
+  THEENGS_LOG_TRACE(F("displaySSD1306 command topic: %s" CR), subjectMQTTtoSSD1306set);
+  THEENGS_LOG_TRACE(F("displaySSD1306 log-oled: %T" CR), logToOLEDDisplay);
+  THEENGS_LOG_TRACE(F("displaySSD1306 json-oled: %T" CR), jsonDisplay);
+  THEENGS_LOG_TRACE(F("displaySSD1306 DISPLAY_PAGE_INTERVAL: %d" CR), DISPLAY_PAGE_INTERVAL);
+  THEENGS_LOG_TRACE(F("displaySSD1306 DISPLAY_IDLE_LOGO: %T" CR), idlelogo);
+  THEENGS_LOG_TRACE(F("displaySSD1306 DISPLAY_FLIP: %T" CR), displayFlip);
   Oled.begin();
-  Log.notice(F("Setup SSD1306 Display end" CR));
+  THEENGS_LOG_NOTICE(F("Setup SSD1306 Display end" CR));
 
 #  if LOG_TO_OLED
   Log.begin(LOG_LEVEL_OLED, &Oled); // Log on OLED following LOG_LEVEL_OLED
@@ -156,7 +156,7 @@ void loopSSD1306() {
   */
 
 #  ifdef DISPLAY_BLANKING
-  // Log.trace(F("touchAverage %d, touchCurrentReading %d, touchThreshold %d" CR), touchAverage, touchCurrentReading, touchThreshold);
+  // THEENGS_LOG_TRACE(F("touchAverage %d, touchCurrentReading %d, touchThreshold %d" CR), touchAverage, touchCurrentReading, touchThreshold);
   touchTotal = touchTotal - touchReadings[touchIndex];
   touchCurrentReading = touchRead(DISPLAY_BLANKING_TOUCH_GPIO);
   touchReadings[touchIndex] = touchCurrentReading;
@@ -177,7 +177,7 @@ void loopSSD1306() {
   if (jsonDisplay && displayState) {
     if (uptime() >= nextDisplayPage && uxSemaphoreGetCount(semaphoreOLEDOperation) && currentWebUIMessage && newSSD1306Message) {
       if (!Oled.displayPage(currentWebUIMessage)) {
-        Log.warning(F("[ssd1306] displayPage failed: %s" CR), currentWebUIMessage->title);
+        THEENGS_LOG_WARNING(F("[ssd1306] displayPage failed: %s" CR), currentWebUIMessage->title);
       }
       nextDisplayPage = uptime() + DISPLAY_PAGE_INTERVAL;
       logoDisplayed = false;
@@ -203,21 +203,21 @@ Handler for mqtt commands sent to the module
 void XtoSSD1306(const char* topicOri, JsonObject& SSD1306data) { // json object decoding
   bool success = false;
   if (cmpToMainTopic(topicOri, subjectMQTTtoSSD1306set)) {
-    Log.trace(F("MQTTtoSSD1306 json set" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoSSD1306 json set" CR));
     // properties
     if (SSD1306data.containsKey("onstate")) {
       displayState = SSD1306data["onstate"].as<bool>();
-      Log.notice(F("Set display state: %T" CR), displayState);
+      THEENGS_LOG_NOTICE(F("Set display state: %T" CR), displayState);
       success = true;
     }
     if (SSD1306data.containsKey("brightness")) {
       displayBrightness = SSD1306data["brightness"].as<int>();
-      Log.notice(F("Set brightness: %d" CR), displayBrightness);
+      THEENGS_LOG_NOTICE(F("Set brightness: %d" CR), displayBrightness);
       success = true;
     }
     if (SSD1306data.containsKey("log-oled")) {
       logToOLEDDisplay = SSD1306data["log-oled"].as<bool>();
-      Log.notice(F("Set OLED log: %T" CR), logToOLEDDisplay);
+      THEENGS_LOG_NOTICE(F("Set OLED log: %T" CR), logToOLEDDisplay);
       logToOLED(logToOLEDDisplay);
       if (logToOLEDDisplay) {
         jsonDisplay = false;
@@ -229,7 +229,7 @@ void XtoSSD1306(const char* topicOri, JsonObject& SSD1306data) { // json object
         logToOLEDDisplay = false;
         logToOLED(logToOLEDDisplay);
       }
-      Log.notice(F("Set json-oled: %T" CR), jsonDisplay);
+      THEENGS_LOG_NOTICE(F("Set json-oled: %T" CR), jsonDisplay);
       success = true;
     }
     if (SSD1306data.containsKey("idlelogo")) {
@@ -238,7 +238,7 @@ void XtoSSD1306(const char* topicOri, JsonObject& SSD1306data) { // json object
     }
     if (SSD1306data.containsKey("display-flip")) {
       displayFlip = SSD1306data["display-flip"].as<bool>();
-      Log.notice(F("Set display-flip: %T" CR), displayFlip);
+      THEENGS_LOG_NOTICE(F("Set display-flip: %T" CR), displayFlip);
       success = true;
     }
     // save, load, init, erase
@@ -248,13 +248,13 @@ void XtoSSD1306(const char* topicOri, JsonObject& SSD1306data) { // json object
     } else if (SSD1306data.containsKey("load") && SSD1306data["load"]) {
       success = SSD1306Config_load();
       if (success) {
-        Log.notice(F("SSD1306 config loaded" CR));
+        THEENGS_LOG_NOTICE(F("SSD1306 config loaded" CR));
       }
     } else if (SSD1306data.containsKey("init") && SSD1306data["init"]) {
       SSD1306Config_init();
       success = true;
       if (success) {
-        Log.notice(F("SSD1306 config initialised" CR));
+        THEENGS_LOG_NOTICE(F("SSD1306 config initialised" CR));
       }
     } else if (SSD1306data.containsKey("erase") && SSD1306data["erase"]) {
       // Erase config from NVS (non-volatile storage)
@@ -264,13 +264,13 @@ void XtoSSD1306(const char* topicOri, JsonObject& SSD1306data) { // json object
       }
       preferences.end();
       if (success) {
-        Log.notice(F("SSD1306 config erased" CR));
+        THEENGS_LOG_NOTICE(F("SSD1306 config erased" CR));
       }
     }
     if (success) {
       stateSSD1306Display();
     } else {
-      Log.error(F("[ SSD1306 ] XtoSSD1306 Fail json" CR), SSD1306data);
+      THEENGS_LOG_ERROR(F("[ SSD1306 ] XtoSSD1306 Fail json" CR), SSD1306data);
     }
   }
 }
@@ -290,7 +290,7 @@ void SSD1306Config_save() {
   preferences.begin(Gateway_Short_Name, false);
   int result = preferences.putString("SSD1306Config", conf);
   preferences.end();
-  Log.notice(F("SSD1306 Config_save: %s, result: %d" CR), conf.c_str(), result);
+  THEENGS_LOG_NOTICE(F("SSD1306 Config_save: %s, result: %d" CR), conf.c_str(), result);
 }
 
 void SSD1306Config_init() {
@@ -300,7 +300,7 @@ void SSD1306Config_init() {
   jsonDisplay = JSON_TO_OLED;
   idlelogo = DISPLAY_IDLE_LOGO;
   displayFlip = DISPLAY_FLIP;
-  Log.notice(F("SSD1306 config initialised" CR));
+  THEENGS_LOG_NOTICE(F("SSD1306 config initialised" CR));
 }
 
 bool SSD1306Config_load() {
@@ -310,11 +310,11 @@ bool SSD1306Config_load() {
     auto error = deserializeJson(jsonBuffer, preferences.getString("SSD1306Config", "{}"));
     preferences.end();
     if (error) {
-      Log.error(F("SSD1306 config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+      THEENGS_LOG_ERROR(F("SSD1306 config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
       return false;
     }
     if (jsonBuffer.isNull()) {
-      Log.warning(F("SSD1306 config is null" CR));
+      THEENGS_LOG_WARNING(F("SSD1306 config is null" CR));
       return false;
     }
     JsonObject jo = jsonBuffer.as<JsonObject>();
@@ -324,11 +324,11 @@ bool SSD1306Config_load() {
     jsonDisplay = jo["json-oled"].as<bool>();
     idlelogo = jo["idlelogo"].as<bool>();
     displayFlip = jo["display-flip"].as<bool>();
-    Log.notice(F("Saved SSD1306 config loaded" CR));
+    THEENGS_LOG_NOTICE(F("Saved SSD1306 config loaded" CR));
     return true;
   } else {
     preferences.end();
-    Log.notice(F("No SSD1306 config to load" CR));
+    THEENGS_LOG_NOTICE(F("No SSD1306 config to load" CR));
     return false;
   }
 }
diff --git a/main/gateway2G.cpp b/main/gateway2G.cpp
index 60700a1..fc9385d 100644
--- a/main/gateway2G.cpp
+++ b/main/gateway2G.cpp
@@ -45,28 +45,28 @@ int unreadSMSNum = 0;
 SMSmessage sms;
 
 void setup2G() {
-  Log.notice(F("_2G_TX_GPIO: %d " CR), _2G_TX_GPIO);
-  Log.notice(F("_2G_RX_GPIO: %d " CR), _2G_RX_GPIO);
+  THEENGS_LOG_NOTICE(F("_2G_TX_GPIO: %d " CR), _2G_TX_GPIO);
+  THEENGS_LOG_NOTICE(F("_2G_RX_GPIO: %d " CR), _2G_RX_GPIO);
   setupGSM(false);
-  Log.trace(F("gateway2G setup done " CR));
+  THEENGS_LOG_TRACE(F("gateway2G setup done " CR));
 }
 
 void setupGSM(bool deleteSMS) {
-  Log.trace(F("Init 2G module: %d" CR), _2G_PWR_GPIO);
+  THEENGS_LOG_TRACE(F("Init 2G module: %d" CR), _2G_PWR_GPIO);
   delay(1000);
   // Power-cycle the module to reset it.
   A6l.powerCycle(_2G_PWR_GPIO);
-  Log.notice(F("waiting for network connection at bd: %d" CR), _2G_MODULE_BAUDRATE);
+  THEENGS_LOG_NOTICE(F("waiting for network connection at bd: %d" CR), _2G_MODULE_BAUDRATE);
   A6l.blockUntilReady(_2G_MODULE_BAUDRATE);
-  Log.notice(F("A6/A7 gsm ready" CR));
+  THEENGS_LOG_NOTICE(F("A6/A7 gsm ready" CR));
   signalStrengthAnalysis();
   delay(1000);
   // deleting all sms
   if (deleteSMS) {
     if (A6l.deleteSMS(1, 4) == A6_OK) {
-      Log.notice(F("delete SMS OK" CR));
+      THEENGS_LOG_NOTICE(F("delete SMS OK" CR));
     } else {
-      Log.error(F("delete SMS KO" CR));
+      THEENGS_LOG_ERROR(F("delete SMS KO" CR));
     }
   }
 }
@@ -74,9 +74,9 @@ void setupGSM(bool deleteSMS) {
 void signalStrengthAnalysis() {
   int signalStrength = 0;
   signalStrength = A6l.getSignalStrength();
-  Log.trace(F("Signal strength: %d" CR), signalStrength);
+  THEENGS_LOG_TRACE(F("Signal strength: %d" CR), signalStrength);
   if (signalStrength < _2G_MIN_SIGNAL || signalStrength > _2G_MAX_SIGNAL) {
-    Log.trace(F("Signal too low restart the module" CR));
+    THEENGS_LOG_TRACE(F("Signal too low restart the module" CR));
     setupGSM(false); // if we are below or above a threshold signal we relaunch the setup of GSM module
   }
 }
@@ -84,17 +84,17 @@ void signalStrengthAnalysis() {
 bool _2GtoX() {
   // Get the memory locations of unread SMS messages.
   unreadSMSNum = A6l.getUnreadSMSLocs(unreadSMSLocs, 512);
-  Log.trace(F("Creating SMS  buffer" CR));
+  THEENGS_LOG_TRACE(F("Creating SMS  buffer" CR));
   StaticJsonDocument<JSON_MSG_BUFFER> SMSdataBuffer;
   JsonObject SMSdata = SMSdataBuffer.to<JsonObject>();
   for (int i = 0; i < unreadSMSNum; i++) {
-    Log.notice(F("New  message at index: %d" CR), unreadSMSNum);
+    THEENGS_LOG_NOTICE(F("New  message at index: %d" CR), unreadSMSNum);
     sms = A6l.readSMS(unreadSMSLocs[i]);
     SMSdata["message"] = (const char*)sms.message.c_str();
     SMSdata["date"] = (const char*)sms.date.c_str();
     SMSdata["phone"] = (const char*)sms.number.c_str();
     A6l.deleteSMS(unreadSMSLocs[i]); // we delete the SMS received
-    Log.trace(F("Adv data 2GtoMQTT" CR));
+    THEENGS_LOG_TRACE(F("Adv data 2GtoMQTT" CR));
     SMSdata["origin"] = subject2GtoMQTT;
     return enqueueJsonObject(SMSdata);
   }
@@ -106,26 +106,26 @@ void Xto2G(const char* topicOri, const char* datacallback) {
   String topic = topicOri;
 
   if (cmpToMainTopic(topicOri, subjectMQTTto2G)) {
-    Log.trace(F("MQTTto2G data analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTto2G data analysis" CR));
     // 2G DATA ANALYSIS
     String phone_number = "";
     int pos0 = topic.lastIndexOf(_2GPhoneKey);
     if (pos0 != -1) {
       pos0 = pos0 + strlen(_2GPhoneKey);
       phone_number = topic.substring(pos0);
-      Log.notice(F("MQTTto2G phone: %s" CR), (char*)phone_number.c_str());
-      Log.notice(F("MQTTto2G sms: %s" CR), (char*)data.c_str());
+      THEENGS_LOG_NOTICE(F("MQTTto2G phone: %s" CR), (char*)phone_number.c_str());
+      THEENGS_LOG_NOTICE(F("MQTTto2G sms: %s" CR), (char*)data.c_str());
       if (A6l.sendSMS(phone_number, data) == A6_OK) {
-        Log.notice(F("SMS OK" CR));
+        THEENGS_LOG_NOTICE(F("SMS OK" CR));
         // Acknowledgement to the GTW2G topic
         pub(subjectGTW2GtoMQTT, "SMS OK"); // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
       } else {
-        Log.error(F("SMS KO" CR));
+        THEENGS_LOG_ERROR(F("SMS KO" CR));
         // Acknowledgement to the GTW2G topic
         pub(subjectGTW2GtoMQTT, "SMS KO"); // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
       }
     } else {
-      Log.error(F("MQTTto2G Fail reading phone number" CR));
+      THEENGS_LOG_ERROR(F("MQTTto2G Fail reading phone number" CR));
     }
   }
 }
@@ -136,20 +136,20 @@ void Xto2G(const char* topicOri, JsonObject& SMSdata) {
   if (cmpToMainTopic(topicOri, subjectMQTTto2G)) {
     const char* sms = SMSdata["message"];
     const char* phone = SMSdata["phone"];
-    Log.trace(F("MQTTto2G json data analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTto2G json data analysis" CR));
     if (sms && phone) {
-      Log.notice(F("MQTTto2G phone: %s" CR), phone);
-      Log.notice(F("MQTTto2G sms: %s" CR), sms);
+      THEENGS_LOG_NOTICE(F("MQTTto2G phone: %s" CR), phone);
+      THEENGS_LOG_NOTICE(F("MQTTto2G sms: %s" CR), sms);
       if (A6l.sendSMS(String(phone), String(sms)) == A6_OK) {
-        Log.notice(F("SMS OK" CR));
+        THEENGS_LOG_NOTICE(F("SMS OK" CR));
         // Acknowledgement to the GTW2G topic
         pub(subjectGTW2GtoMQTT, "SMS OK"); // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
       } else {
-        Log.error(F("SMS KO" CR));
+        THEENGS_LOG_ERROR(F("SMS KO" CR));
         pub(subjectGTW2GtoMQTT, "SMS KO"); // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
       }
     } else {
-      Log.error(F("MQTTto2G failed json read" CR));
+      THEENGS_LOG_ERROR(F("MQTTto2G failed json read" CR));
     }
   }
 }
diff --git a/main/gatewayBLEConnect.cpp b/main/gatewayBLEConnect.cpp
index d030e27..15e1cc2 100644
--- a/main/gatewayBLEConnect.cpp
+++ b/main/gatewayBLEConnect.cpp
@@ -13,19 +13,19 @@ NimBLERemoteCharacteristic* zBLEConnect::getCharacteristic(const NimBLEUUID& ser
                                                            const NimBLEUUID& characteristic) {
   BLERemoteCharacteristic* pRemoteCharacteristic = nullptr;
   if (!m_pClient) {
-    Log.error(F("No BLE client" CR));
+    THEENGS_LOG_ERROR(F("No BLE client" CR));
   } else if (!m_pClient->isConnected() && !m_pClient->connect()) {
-    Log.error(F("Connect to: %s failed" CR), m_pClient->getPeerAddress().toString().c_str());
+    THEENGS_LOG_ERROR(F("Connect to: %s failed" CR), m_pClient->getPeerAddress().toString().c_str());
   } else {
     BLERemoteService* pRemoteService = m_pClient->getService(service);
     if (!pRemoteService) {
-      Log.notice(F("Failed to find service UUID: %s" CR), service.toString().c_str());
+      THEENGS_LOG_NOTICE(F("Failed to find service UUID: %s" CR), service.toString().c_str());
     } else {
-      Log.trace(F("Found service: %s" CR), service.toString().c_str());
-      Log.trace(F("Client isConnected, freeHeap: %d" CR), ESP.getFreeHeap());
+      THEENGS_LOG_TRACE(F("Found service: %s" CR), service.toString().c_str());
+      THEENGS_LOG_TRACE(F("Client isConnected, freeHeap: %d" CR), ESP.getFreeHeap());
       pRemoteCharacteristic = pRemoteService->getCharacteristic(characteristic);
       if (!pRemoteCharacteristic) {
-        Log.notice(F("Failed to find characteristic UUID: %s" CR), characteristic.toString().c_str());
+        THEENGS_LOG_NOTICE(F("Failed to find characteristic UUID: %s" CR), characteristic.toString().c_str());
       }
     }
   }
@@ -40,7 +40,7 @@ bool zBLEConnect::writeData(BLEAction* action) {
       case BLE_VAL_HEX: {
         int len = action->value.length();
         if (len % 2) {
-          Log.error(F("Invalid HEX value length" CR));
+          THEENGS_LOG_ERROR(F("Invalid HEX value length" CR));
           return false;
         }
 
@@ -87,11 +87,11 @@ bool zBLEConnect::processActions(std::vector<BLEAction>& actions) {
         BLEdata["characteristic"] = it.characteristic.toString();
 
         if (it.write) {
-          Log.trace(F("processing BLE write" CR));
+          THEENGS_LOG_TRACE(F("processing BLE write" CR));
           BLEdata["write"] = std::string(it.value);
           result = writeData(&it);
         } else {
-          Log.trace(F("processing BLE read" CR));
+          THEENGS_LOG_TRACE(F("processing BLE read" CR));
           result = readData(&it);
           if (result) {
             switch (it.value_type) {
@@ -135,10 +135,10 @@ void LYWSD03MMC_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pD
     return; // unexpected notification
   }
   if (!BTProcessLock) {
-    Log.trace(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
+    THEENGS_LOG_TRACE(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
 
     if (length == 5) {
-      Log.trace(F("Device identified creating BLE buffer" CR));
+      THEENGS_LOG_TRACE(F("Device identified creating BLE buffer" CR));
       DynamicJsonDocument BLEdataBuffer(JSON_MSG_BUFFER);
       JsonObject BLEdata = BLEdataBuffer.to<JsonObject>();
       auto mac_addr = m_pClient->getPeerAddress().toString();
@@ -152,7 +152,7 @@ void LYWSD03MMC_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pD
         }
       }
       BLEdata["id"] = mac_addr;
-      Log.trace(F("Device identified in CB: %s" CR), mac_addr);
+      THEENGS_LOG_TRACE(F("Device identified in CB: %s" CR), mac_addr);
       BLEdata["tempc"] = (float)((pData[0] | (pData[1] << 8)) * 0.01);
       BLEdata["tempf"] = (float)(convertTemp_CtoF((pData[0] | (pData[1] << 8)) * 0.01));
       BLEdata["hum"] = (float)(pData[2]);
@@ -161,11 +161,11 @@ void LYWSD03MMC_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pD
       buildTopicFromId(BLEdata, subjectBTtoMQTT);
       enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
     } else {
-      Log.notice(F("Invalid notification data" CR));
+      THEENGS_LOG_NOTICE(F("Invalid notification data" CR));
       return;
     }
   } else {
-    Log.trace(F("Callback process canceled by BTProcessLock" CR));
+    THEENGS_LOG_TRACE(F("Callback process canceled by BTProcessLock" CR));
   }
 
   xTaskNotifyGive(m_taskHandle);
@@ -177,7 +177,7 @@ void LYWSD03MMC_connect::publishData() {
   NimBLERemoteCharacteristic* pChar = getCharacteristic(serviceUUID, charUUID);
 
   if (pChar && pChar->canNotify()) {
-    Log.trace(F("Registering notification" CR));
+    THEENGS_LOG_TRACE(F("Registering notification" CR));
     if (pChar->subscribe(true, std::bind(&LYWSD03MMC_connect::notifyCB, this,
                                          std::placeholders::_1, std::placeholders::_2,
                                          std::placeholders::_3, std::placeholders::_4))) {
@@ -186,7 +186,7 @@ void LYWSD03MMC_connect::publishData() {
         m_taskHandle = nullptr;
       }
     } else {
-      Log.notice(F("Failed registering notification" CR));
+      THEENGS_LOG_NOTICE(F("Failed registering notification" CR));
     }
   }
 }
@@ -198,7 +198,7 @@ void DT24_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, s
   }
 
   if (!BTProcessLock) {
-    Log.trace(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
+    THEENGS_LOG_TRACE(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
     if (length == 20) {
       m_data.assign(pData, pData + length);
       return;
@@ -208,13 +208,13 @@ void DT24_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, s
       // DT24-BLE data format
       // https://github.com/NiceLabs/atorch-console/blob/master/docs/protocol-design.md#dc-meter-report
       // Data comes as two packets ( 20 and 16 ), and am only processing first
-      Log.trace(F("Device identified creating BLE buffer" CR));
+      THEENGS_LOG_TRACE(F("Device identified creating BLE buffer" CR));
       DynamicJsonDocument BLEdataBuffer(JSON_MSG_BUFFER);
       JsonObject BLEdata = BLEdataBuffer.to<JsonObject>();
       auto mac_address = m_pClient->getPeerAddress().toString();
       BLEdata["model"] = "DT24";
       BLEdata["id"] = mac_address;
-      Log.trace(F("Device identified in CB: %s" CR), mac_address);
+      THEENGS_LOG_TRACE(F("Device identified in CB: %s" CR), mac_address);
       BLEdata["volt"] = (float)(((m_data[4] * 256 * 256) + (m_data[5] * 256) + m_data[6]) / 10.0);
       BLEdata["current"] = (float)(((m_data[7] * 256 * 256) + (m_data[8] * 256) + m_data[9]) / 1000.0);
       BLEdata["power"] = (float)(((m_data[10] * 256 * 256) + (m_data[11] * 256) + m_data[12]) / 10.0);
@@ -225,11 +225,11 @@ void DT24_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, s
       buildTopicFromId(BLEdata, subjectBTtoMQTT);
       enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
     } else {
-      Log.notice(F("Invalid notification data" CR));
+      THEENGS_LOG_NOTICE(F("Invalid notification data" CR));
       return;
     }
   } else {
-    Log.trace(F("Callback process canceled by BTProcessLock" CR));
+    THEENGS_LOG_TRACE(F("Callback process canceled by BTProcessLock" CR));
   }
 
   xTaskNotifyGive(m_taskHandle);
@@ -241,7 +241,7 @@ void DT24_connect::publishData() {
   NimBLERemoteCharacteristic* pChar = getCharacteristic(serviceUUID, charUUID);
 
   if (pChar && pChar->canNotify()) {
-    Log.trace(F("Registering notification" CR));
+    THEENGS_LOG_TRACE(F("Registering notification" CR));
     if (pChar->subscribe(true, std::bind(&DT24_connect::notifyCB, this,
                                          std::placeholders::_1, std::placeholders::_2,
                                          std::placeholders::_3, std::placeholders::_4))) {
@@ -250,7 +250,7 @@ void DT24_connect::publishData() {
         m_taskHandle = nullptr;
       }
     } else {
-      Log.notice(F("Failed registering notification" CR));
+      THEENGS_LOG_NOTICE(F("Failed registering notification" CR));
     }
   }
 }
@@ -262,9 +262,9 @@ void BM2_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, si
   }
 
   if (!BTProcessLock) {
-    Log.trace(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
+    THEENGS_LOG_TRACE(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
     if (length == 16) {
-      Log.trace(F("Device identified creating BLE buffer" CR));
+      THEENGS_LOG_TRACE(F("Device identified creating BLE buffer" CR));
       DynamicJsonDocument BLEdataBuffer(JSON_MSG_BUFFER);
       JsonObject BLEdata = BLEdataBuffer.to<JsonObject>();
       BLEdata["model"] = "BM2 Battery Monitor";
@@ -296,17 +296,17 @@ void BM2_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, si
       mbedtls_aes_free(&aes);
       float volt = ((output[2] | (output[1] << 8)) >> 4) / 100.0f;
       BLEdata["volt"] = volt;
-      Log.trace(F("volt: %F" CR), volt);
+      THEENGS_LOG_TRACE(F("volt: %F" CR), volt);
       // to avoid the BM2 device tracker going offline because of the voltage MQTT message without an RSSI value
       BLEdata["rssi"] = -60;
       buildTopicFromId(BLEdata, subjectBTtoMQTT);
       enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
     } else {
-      Log.notice(F("Invalid notification data" CR));
+      THEENGS_LOG_NOTICE(F("Invalid notification data" CR));
       return;
     }
   } else {
-    Log.trace(F("Callback process canceled by BTProcessLock" CR));
+    THEENGS_LOG_TRACE(F("Callback process canceled by BTProcessLock" CR));
   }
 
   xTaskNotifyGive(m_taskHandle);
@@ -318,7 +318,7 @@ void BM2_connect::publishData() {
   NimBLERemoteCharacteristic* pChar = getCharacteristic(serviceUUID, charUUID);
 
   if (pChar && pChar->canNotify()) {
-    Log.trace(F("Registering notification" CR));
+    THEENGS_LOG_TRACE(F("Registering notification" CR));
     if (pChar->subscribe(true, std::bind(&BM2_connect::notifyCB, this,
                                          std::placeholders::_1, std::placeholders::_2,
                                          std::placeholders::_3, std::placeholders::_4))) {
@@ -327,7 +327,7 @@ void BM2_connect::publishData() {
         m_taskHandle = nullptr;
       }
     } else {
-      Log.notice(F("Failed registering notification" CR));
+      THEENGS_LOG_NOTICE(F("Failed registering notification" CR));
     }
   }
 }
@@ -340,7 +340,7 @@ void HHCCJCY01HHCC_connect::publishData() {
   NimBLERemoteCharacteristic* pChar = getCharacteristic(serviceUUID, charUUID);
 
   if (pChar) {
-    Log.trace(F("Read mode" CR));
+    THEENGS_LOG_TRACE(F("Read mode" CR));
     uint8_t buf[2] = {0xA0, 0x1F};
     pChar->writeValue(buf, 2, true);
     int batteryValue = -1;
@@ -358,10 +358,10 @@ void HHCCJCY01HHCC_connect::publishData() {
       buildTopicFromId(BLEdata, subjectBTtoMQTT);
       enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
     } else {
-      Log.notice(F("Failed getting characteristic" CR));
+      THEENGS_LOG_NOTICE(F("Failed getting characteristic" CR));
     }
   } else {
-    Log.notice(F("Failed getting characteristic" CR));
+    THEENGS_LOG_NOTICE(F("Failed getting characteristic" CR));
   }
 }
 
@@ -371,16 +371,16 @@ void XMWSDJ04MMC_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* p
     return; // unexpected notification
   }
   if (!BTProcessLock) {
-    Log.trace(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
+    THEENGS_LOG_TRACE(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
 
     if (length == 6) {
-      Log.trace(F("Device identified creating BLE buffer" CR));
+      THEENGS_LOG_TRACE(F("Device identified creating BLE buffer" CR));
       DynamicJsonDocument BLEdataBuffer(JSON_MSG_BUFFER);
       JsonObject BLEdata = BLEdataBuffer.to<JsonObject>();
       auto mac_address = m_pClient->getPeerAddress().toString();
       BLEdata["model"] = "XMWSDJ04MMC";
       BLEdata["id"] = mac_address;
-      Log.trace(F("Device identified in CB: %s" CR), mac_address);
+      THEENGS_LOG_TRACE(F("Device identified in CB: %s" CR), mac_address);
       BLEdata["tempc"] = (float)((pData[0] | (pData[1] << 8)) * 0.1);
       BLEdata["tempf"] = (float)(convertTemp_CtoF((pData[0] | (pData[1] << 8)) * 0.1));
       BLEdata["hum"] = (float)((pData[2] | (pData[3] << 8)) * 0.1);
@@ -389,11 +389,11 @@ void XMWSDJ04MMC_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* p
       buildTopicFromId(BLEdata, subjectBTtoMQTT);
       enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
     } else {
-      Log.notice(F("Invalid notification data" CR));
+      THEENGS_LOG_NOTICE(F("Invalid notification data" CR));
       return;
     }
   } else {
-    Log.trace(F("Callback process canceled by BTProcessLock" CR));
+    THEENGS_LOG_TRACE(F("Callback process canceled by BTProcessLock" CR));
   }
 
   xTaskNotifyGive(m_taskHandle);
@@ -405,7 +405,7 @@ void XMWSDJ04MMC_connect::publishData() {
   NimBLERemoteCharacteristic* pChar = getCharacteristic(serviceUUID, charUUID);
 
   if (pChar && pChar->canNotify()) {
-    Log.trace(F("Registering notification" CR));
+    THEENGS_LOG_TRACE(F("Registering notification" CR));
     if (pChar->subscribe(true, std::bind(&XMWSDJ04MMC_connect::notifyCB, this,
                                          std::placeholders::_1, std::placeholders::_2,
                                          std::placeholders::_3, std::placeholders::_4))) {
@@ -414,7 +414,7 @@ void XMWSDJ04MMC_connect::publishData() {
         m_taskHandle = nullptr;
       }
     } else {
-      Log.notice(F("Failed registering notification" CR));
+      THEENGS_LOG_NOTICE(F("Failed registering notification" CR));
     }
   }
 }
@@ -425,16 +425,16 @@ void SBS1_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, s
     return; // unexpected notification
   }
   if (!BTProcessLock) {
-    Log.trace(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
+    THEENGS_LOG_TRACE(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
 
     if (length) {
       m_notifyVal = *pData;
     } else {
-      Log.notice(F("Invalid notification data" CR));
+      THEENGS_LOG_NOTICE(F("Invalid notification data" CR));
       return;
     }
   } else {
-    Log.trace(F("Callback process canceled by BTProcessLock" CR));
+    THEENGS_LOG_TRACE(F("Callback process canceled by BTProcessLock" CR));
   }
 
   xTaskNotifyGive(m_taskHandle);
@@ -458,7 +458,7 @@ bool SBS1_connect::processActions(std::vector<BLEAction>& actions) {
         NimBLERemoteCharacteristic* pNotifyChar = getCharacteristic(serviceUUID, notifyCharUUID);
 
         if (it.write && pChar && pNotifyChar) {
-          Log.trace(F("processing Switchbot %s" CR), it.value.c_str());
+          THEENGS_LOG_TRACE(F("processing Switchbot %s" CR), it.value.c_str());
           if (pNotifyChar->subscribe(true,
                                      std::bind(&SBS1_connect::notifyCB,
                                                this, std::placeholders::_1, std::placeholders::_2,
@@ -508,16 +508,16 @@ void SBBT_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, s
     return; // unexpected notification
   }
   if (!BTProcessLock) {
-    Log.trace(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
+    THEENGS_LOG_TRACE(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
 
     if (length) {
       m_notifyVal = *pData;
     } else {
-      Log.notice(F("Invalid notification data" CR));
+      THEENGS_LOG_NOTICE(F("Invalid notification data" CR));
       return;
     }
   } else {
-    Log.trace(F("Callback process canceled by BTProcessLock" CR));
+    THEENGS_LOG_TRACE(F("Callback process canceled by BTProcessLock" CR));
   }
 
   xTaskNotifyGive(m_taskHandle);
@@ -544,7 +544,7 @@ bool SBBT_connect::processActions(std::vector<BLEAction>& actions) {
           value = std::stoi(it.value);
         }
         if (it.write && pChar && pNotifyChar) {
-          Log.trace(F("processing Switchbot %s" CR), it.value.c_str());
+          THEENGS_LOG_TRACE(F("processing Switchbot %s" CR), it.value.c_str());
           if (pNotifyChar->subscribe(true,
                                      std::bind(&SBBT_connect::notifyCB,
                                                this, std::placeholders::_1, std::placeholders::_2,
@@ -614,16 +614,16 @@ void SBCU_connect::notifyCB(NimBLERemoteCharacteristic* pChar, uint8_t* pData, s
     return; // unexpected notification
   }
   if (!BTProcessLock) {
-    Log.trace(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
+    THEENGS_LOG_TRACE(F("Callback from %s characteristic" CR), pChar->getUUID().toString().c_str());
 
     if (length) {
       m_notifyVal = *pData;
     } else {
-      Log.notice(F("Invalid notification data" CR));
+      THEENGS_LOG_NOTICE(F("Invalid notification data" CR));
       return;
     }
   } else {
-    Log.trace(F("Callback process canceled by BTProcessLock" CR));
+    THEENGS_LOG_TRACE(F("Callback process canceled by BTProcessLock" CR));
   }
 
   xTaskNotifyGive(m_taskHandle);
@@ -649,7 +649,7 @@ bool SBCU_connect::processActions(std::vector<BLEAction>& actions) {
           value = std::stoi(it.value);
         }
         if (it.write && pChar && pNotifyChar) {
-          Log.trace(F("processing Switchbot %s" CR), it.value.c_str());
+          THEENGS_LOG_TRACE(F("processing Switchbot %s" CR), it.value.c_str());
           if (pNotifyChar->subscribe(true,
                                      std::bind(&SBCU_connect::notifyCB,
                                                this, std::placeholders::_1, std::placeholders::_2,
diff --git a/main/gatewayBT.cpp b/main/gatewayBT.cpp
index a8b42e4..f4c467f 100644
--- a/main/gatewayBT.cpp
+++ b/main/gatewayBT.cpp
@@ -158,7 +158,7 @@ String stateBTMeasures(bool start) {
 #  endif
 
   if (start) {
-    Log.notice(F("BT sys: "));
+    THEENGS_LOG_NOTICE(F("BT sys: "));
     serializeJsonPretty(jsonBuffer, Serial);
     Serial.println();
     return ""; // Do not try to erase/write/send config at startup
@@ -262,12 +262,12 @@ void BTConfig_fromJson(JsonObject& BTdata, bool startup = false) {
     preferences.begin(Gateway_Short_Name, false);
     if (preferences.isKey("BTConfig")) {
       int result = preferences.remove("BTConfig");
-      Log.notice(F("BT config erase result: %d" CR), result);
+      THEENGS_LOG_NOTICE(F("BT config erase result: %d" CR), result);
       preferences.end();
       return; // Erase prevails on save, so skipping save
     } else {
       preferences.end();
-      Log.notice(F("BT config not found" CR));
+      THEENGS_LOG_NOTICE(F("BT config not found" CR));
     }
   }
 
@@ -302,7 +302,7 @@ void BTConfig_fromJson(JsonObject& BTdata, bool startup = false) {
     preferences.begin(Gateway_Short_Name, false);
     int result = preferences.putString("BTConfig", conf);
     preferences.end();
-    Log.notice(F("BT config save: %s, result: %d" CR), conf.c_str(), result);
+    THEENGS_LOG_NOTICE(F("BT config save: %s, result: %d" CR), conf.c_str(), result);
   }
 }
 
@@ -312,21 +312,21 @@ void BTConfig_load() {
   if (preferences.isKey("BTConfig")) {
     auto error = deserializeJson(jsonBuffer, preferences.getString("BTConfig", "{}"));
     preferences.end();
-    Log.notice(F("BT config loaded" CR));
+    THEENGS_LOG_NOTICE(F("BT config loaded" CR));
     if (error) {
-      Log.error(F("BT config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+      THEENGS_LOG_ERROR(F("BT config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
       return;
     }
     if (jsonBuffer.isNull()) {
-      Log.warning(F("BT config is null" CR));
+      THEENGS_LOG_WARNING(F("BT config is null" CR));
       return;
     }
     JsonObject jo = jsonBuffer.as<JsonObject>();
     BTConfig_fromJson(jo, true); // Never send MQTT message with config
-    Log.notice(F("BT config loaded" CR));
+    THEENGS_LOG_NOTICE(F("BT config loaded" CR));
   } else {
     preferences.end();
-    Log.notice(F("BT config not found" CR));
+    THEENGS_LOG_NOTICE(F("BT config not found" CR));
   }
 }
 
@@ -338,7 +338,7 @@ void createOrUpdateDevice(const char* mac, uint8_t flags, int model, int mac_typ
 
 BLEdevice* getDeviceByMac(const char* mac); // Declared here to avoid pre-compilation issue (misplaced auto declaration by pio)
 BLEdevice* getDeviceByMac(const char* mac) {
-  Log.trace(F("getDeviceByMac %s" CR), mac);
+  THEENGS_LOG_TRACE(F("getDeviceByMac %s" CR), mac);
 
   for (vector<BLEdevice*>::iterator it = devices.begin(); it != devices.end(); ++it) {
     if ((strcmp((*it)->macAdr, mac) == 0)) {
@@ -349,7 +349,7 @@ BLEdevice* getDeviceByMac(const char* mac) {
 }
 
 bool updateWorB(JsonObject& BTdata, bool isWhite) {
-  Log.trace(F("update WorB" CR));
+  THEENGS_LOG_TRACE(F("update WorB" CR));
   const char* jsonKey = isWhite ? "white-list" : "black-list";
 
   int size = BTdata[jsonKey].size();
@@ -367,12 +367,12 @@ bool updateWorB(JsonObject& BTdata, bool isWhite) {
 
 void createOrUpdateDevice(const char* mac, uint8_t flags, int model, int mac_type, const char* name) {
   if (xSemaphoreTake(semaphoreCreateOrUpdateDevice, pdMS_TO_TICKS(30000)) == pdFALSE) {
-    Log.error(F("Semaphore NOT taken" CR));
+    THEENGS_LOG_ERROR(F("Semaphore NOT taken" CR));
     return;
   }
   BLEdevice* device = getDeviceByMac(mac);
   if (device == &NO_BT_DEVICE_FOUND) {
-    Log.trace(F("add %s" CR), mac);
+    THEENGS_LOG_TRACE(F("add %s" CR), mac);
     //new device
     device = new BLEdevice();
     strcpy(device->macAdr, mac);
@@ -383,7 +383,7 @@ void createOrUpdateDevice(const char* mac, uint8_t flags, int model, int mac_typ
     device->macType = mac_type;
     // Check name length
     if (strlen(name) > 20) {
-      Log.warning(F("Name too long, truncating" CR));
+      THEENGS_LOG_WARNING(F("Name too long, truncating" CR));
       strncpy(device->name, name, 20);
       device->name[19] = '\0';
     } else {
@@ -394,7 +394,7 @@ void createOrUpdateDevice(const char* mac, uint8_t flags, int model, int mac_typ
     devices.push_back(device);
     newDevices++;
   } else {
-    Log.trace(F("update %s" CR), mac);
+    THEENGS_LOG_TRACE(F("update %s" CR), mac);
     device->lastUpdate = millis();
     device->macType = mac_type;
 
@@ -475,14 +475,14 @@ void dumpDevices() {
 #  if LOG_LEVEL > LOG_LEVEL_NOTICE
   for (vector<BLEdevice*>::iterator it = devices.begin(); it != devices.end(); ++it) {
     BLEdevice* p = *it;
-    Log.trace(F("macAdr %s" CR), p->macAdr);
-    Log.trace(F("macType %d" CR), p->macType);
-    Log.trace(F("isDisc %d" CR), p->isDisc);
-    Log.trace(F("isWhtL %d" CR), p->isWhtL);
-    Log.trace(F("isBlkL %d" CR), p->isBlkL);
-    Log.trace(F("connect %d" CR), p->connect);
-    Log.trace(F("sensorModel_id %d" CR), p->sensorModel_id);
-    Log.trace(F("LastUpdate %u" CR), p->lastUpdate);
+    THEENGS_LOG_TRACE(F("macAdr %s" CR), p->macAdr);
+    THEENGS_LOG_TRACE(F("macType %d" CR), p->macType);
+    THEENGS_LOG_TRACE(F("isDisc %d" CR), p->isDisc);
+    THEENGS_LOG_TRACE(F("isWhtL %d" CR), p->isWhtL);
+    THEENGS_LOG_TRACE(F("isBlkL %d" CR), p->isBlkL);
+    THEENGS_LOG_TRACE(F("connect %d" CR), p->connect);
+    THEENGS_LOG_TRACE(F("sensorModel_id %d" CR), p->sensorModel_id);
+    THEENGS_LOG_TRACE(F("LastUpdate %u" CR), p->lastUpdate);
   }
 #  endif
 }
@@ -495,7 +495,7 @@ void strupp(char* beg) {
 #  ifdef ZmqttDiscovery
 void DT24Discovery(const char* mac, const char* sensorModel_id) {
 #    define DT24parametersCount 7
-  Log.trace(F("DT24Discovery" CR));
+  THEENGS_LOG_TRACE(F("DT24Discovery" CR));
   const char* DT24sensor[DT24parametersCount][9] = {
       {HASS_TYPE_SENSOR, "volt", mac, HASS_CLASS_VOLTAGE, jsonVolt, "", "", HASS_UNIT_VOLT, stateClassMeasurement},
       {HASS_TYPE_SENSOR, "amp", mac, HASS_CLASS_CURRENT, jsonCurrent, "", "", HASS_UNIT_AMP, stateClassMeasurement},
@@ -512,7 +512,7 @@ void DT24Discovery(const char* mac, const char* sensorModel_id) {
 
 void BM2Discovery(const char* mac, const char* sensorModel_id) {
 #    define BM2parametersCount 2
-  Log.trace(F("BM2Discovery" CR));
+  THEENGS_LOG_TRACE(F("BM2Discovery" CR));
   const char* BM2sensor[BM2parametersCount][9] = {
       {HASS_TYPE_SENSOR, "volt", mac, HASS_CLASS_VOLTAGE, jsonVoltBM2, "", "", HASS_UNIT_VOLT, stateClassMeasurement}, // We use a json definition that retrieve only data from the BM2 decoder, as this sensor also advertize volt as an iBeacon
       {HASS_TYPE_SENSOR, "batt", mac, HASS_CLASS_BATTERY, jsonBatt, "", "", HASS_UNIT_PERCENT, stateClassMeasurement}
@@ -524,7 +524,7 @@ void BM2Discovery(const char* mac, const char* sensorModel_id) {
 
 void LYWSD03MMCDiscovery(const char* mac, const char* sensorModel) {
 #    define LYWSD03MMCparametersCount 4
-  Log.trace(F("LYWSD03MMCDiscovery" CR));
+  THEENGS_LOG_TRACE(F("LYWSD03MMCDiscovery" CR));
   const char* LYWSD03MMCsensor[LYWSD03MMCparametersCount][9] = {
       {HASS_TYPE_SENSOR, "batt", mac, HASS_CLASS_BATTERY, jsonBatt, "", "", HASS_UNIT_PERCENT, stateClassMeasurement},
       {HASS_TYPE_SENSOR, "volt", mac, "", jsonVolt, "", "", HASS_UNIT_VOLT, stateClassMeasurement},
@@ -538,7 +538,7 @@ void LYWSD03MMCDiscovery(const char* mac, const char* sensorModel) {
 
 void MHO_C401Discovery(const char* mac, const char* sensorModel) {
 #    define MHO_C401parametersCount 4
-  Log.trace(F("MHO_C401Discovery" CR));
+  THEENGS_LOG_TRACE(F("MHO_C401Discovery" CR));
   const char* MHO_C401sensor[MHO_C401parametersCount][9] = {
       {HASS_TYPE_SENSOR, "batt", mac, HASS_CLASS_BATTERY, jsonBatt, "", "", HASS_UNIT_PERCENT, stateClassMeasurement},
       {HASS_TYPE_SENSOR, "volt", mac, "", jsonVolt, "", "", HASS_UNIT_VOLT, stateClassMeasurement},
@@ -552,7 +552,7 @@ void MHO_C401Discovery(const char* mac, const char* sensorModel) {
 
 void HHCCJCY01HHCCDiscovery(const char* mac, const char* sensorModel) {
 #    define HHCCJCY01HHCCparametersCount 5
-  Log.trace(F("HHCCJCY01HHCCDiscovery" CR));
+  THEENGS_LOG_TRACE(F("HHCCJCY01HHCCDiscovery" CR));
   const char* HHCCJCY01HHCCsensor[HHCCJCY01HHCCparametersCount][9] = {
       {HASS_TYPE_SENSOR, "batt", mac, HASS_CLASS_BATTERY, jsonBatt, "", "", HASS_UNIT_PERCENT, stateClassMeasurement},
       {HASS_TYPE_SENSOR, "temp", mac, HASS_CLASS_TEMPERATURE, jsonTempc, "", "", HASS_UNIT_CELSIUS, stateClassMeasurement},
@@ -567,7 +567,7 @@ void HHCCJCY01HHCCDiscovery(const char* mac, const char* sensorModel) {
 
 void XMWSDJ04MMCDiscovery(const char* mac, const char* sensorModel) {
 #    define XMWSDJ04MMCparametersCount 4
-  Log.trace(F("XMWSDJ04MMCDiscovery" CR));
+  THEENGS_LOG_TRACE(F("XMWSDJ04MMCDiscovery" CR));
   const char* XMWSDJ04MMCsensor[XMWSDJ04MMCparametersCount][9] = {
       {HASS_TYPE_SENSOR, "batt", mac, HASS_CLASS_BATTERY, jsonBatt, "", "", HASS_UNIT_PERCENT, stateClassMeasurement},
       {HASS_TYPE_SENSOR, "volt", mac, "", jsonVolt, "", "", HASS_UNIT_VOLT, stateClassMeasurement},
@@ -601,7 +601,7 @@ class ScanCallbacks : public NimBLEScanCallbacks {
   void onResult(const NimBLEAdvertisedDevice* advertisedDevice) {
     NimBLEAdvertisedDevice* ad = new NimBLEAdvertisedDevice(*advertisedDevice);
     if (xQueueSend(BLEQueue, &ad, 0) != pdTRUE) {
-      Log.error(F("BLEQueue full" CR));
+      THEENGS_LOG_ERROR(F("BLEQueue full" CR));
       delete (ad);
     }
   }
@@ -612,7 +612,7 @@ std::string convertServiceData(std::string deviceServiceData) {
   char spr[2 * serviceDataLength + 1];
   for (int i = 0; i < serviceDataLength; i++) sprintf(spr + 2 * i, "%.2x", (unsigned char)deviceServiceData[i]);
   spr[2 * serviceDataLength] = 0;
-  Log.trace(F("Converted service data (%d) to %s" CR), serviceDataLength, spr);
+  THEENGS_LOG_TRACE(F("Converted service data (%d) to %s" CR), serviceDataLength, spr);
   return spr;
 }
 
@@ -624,7 +624,7 @@ bool checkIfIsTracker(char ch) {
     data = 10 + (ch - 'a');
 
   if (((data >> 3) & 0x01) == 1) {
-    Log.trace(F("Is Device Tracker" CR));
+    THEENGS_LOG_TRACE(F("Is Device Tracker" CR));
     return true;
   } else {
     return false;
@@ -639,17 +639,17 @@ void procBLETask(void* pvParameters) {
     // Feed the watchdog
     //esp_task_wdt_reset();
     if (!BTProcessLock) {
-      Log.trace(F("Creating BLE buffer" CR));
+      THEENGS_LOG_TRACE(F("Creating BLE buffer" CR));
       StaticJsonDocument<JSON_MSG_BUFFER> BLEdataBuffer;
       JsonObject BLEdata = BLEdataBuffer.to<JsonObject>();
       BLEdata["id"] = advertisedDevice->getAddress().toString();
       BLEdata["mac_type"] = advertisedDevice->getAddress().getType();
       BLEdata["adv_type"] = advertisedDevice->getAdvType();
-      Log.notice(F("BT Device detected: %s" CR), BLEdata["id"].as<const char*>());
+      THEENGS_LOG_NOTICE(F("BT Device detected: %s" CR), BLEdata["id"].as<const char*>());
       BLEdevice* device = getDeviceByMac(BLEdata["id"].as<const char*>());
 
       if (BTConfig.filterConnectable && device->connect) {
-        Log.notice(F("Filtered connectable device" CR));
+        THEENGS_LOG_NOTICE(F("Filtered connectable device" CR));
         delete (advertisedDevice);
         continue;
       }
@@ -669,15 +669,15 @@ void procBLETask(void* pvParameters) {
         }
         if (advertisedDevice->haveServiceData()) {
           int serviceDataCount = advertisedDevice->getServiceDataCount();
-          Log.trace(F("Get services data number: %d" CR), serviceDataCount);
+          THEENGS_LOG_TRACE(F("Get services data number: %d" CR), serviceDataCount);
           for (int j = 0; j < serviceDataCount; j++) {
             StaticJsonDocument<JSON_MSG_BUFFER> BLEdataBufferTemp;
             JsonObject BLEdataTemp = BLEdataBufferTemp.to<JsonObject>();
             BLEdataBufferTemp = BLEdataBuffer;
             std::string service_data = convertServiceData(advertisedDevice->getServiceData(j));
-            Log.trace(F("Service data: %s" CR), service_data.c_str());
+            THEENGS_LOG_TRACE(F("Service data: %s" CR), service_data.c_str());
             std::string serviceDatauuid = advertisedDevice->getServiceDataUUID(j).toString();
-            Log.trace(F("Service data UUID: %s" CR), (char*)serviceDatauuid.c_str());
+            THEENGS_LOG_TRACE(F("Service data UUID: %s" CR), (char*)serviceDatauuid.c_str());
             BLEdataTemp["servicedata"] = (char*)service_data.c_str();
             BLEdataTemp["servicedatauuid"] = (char*)serviceDatauuid.c_str();
             PublishDeviceData(BLEdataTemp);
@@ -686,7 +686,7 @@ void procBLETask(void* pvParameters) {
           PublishDeviceData(BLEdata);
         }
       } else {
-        Log.trace(F("Filtered MAC device" CR));
+        THEENGS_LOG_TRACE(F("Filtered MAC device" CR));
       }
       updateDevicesStatus();
     }
@@ -703,7 +703,7 @@ void BLEscan() {
   while (uxQueueMessagesWaiting(BLEQueue) || queueLength != 0) { // the criteria on queueLength could be adjusted to parallelize the scan and the queue processing
     delay(1); // Wait for queue to empty, a yield here instead of the delay cause the WDT to trigger
   }
-  Log.notice(F("Scan begin" CR));
+  THEENGS_LOG_NOTICE(F("Scan begin" CR));
   BLEScan* pBLEScan = BLEDevice::getScan();
   pBLEScan->setScanCallbacks(&scanCallbacks);
   if ((millis() > (timeBetweenActive + BTConfig.intervalActiveScan) || BTConfig.intervalActiveScan == BTConfig.BLEinterval) && !BTConfig.forcePassiveScan) {
@@ -717,8 +717,8 @@ void BLEscan() {
   NimBLEScanResults foundDevices = pBLEScan->getResults(BTConfig.scanDuration, false);
   if (foundDevices.getCount())
     scanCount++;
-  Log.notice(F("Found %d devices, scan number %d end" CR), foundDevices.getCount(), scanCount);
-  Log.trace(F("Process BLE stack free: %u" CR), uxTaskGetStackHighWaterMark(xProcBLETaskHandle));
+  THEENGS_LOG_NOTICE(F("Found %d devices, scan number %d end" CR), foundDevices.getCount(), scanCount);
+  THEENGS_LOG_TRACE(F("Process BLE stack free: %u" CR), uxTaskGetStackHighWaterMark(xProcBLETaskHandle));
 }
 
 /**
@@ -727,12 +727,12 @@ void BLEscan() {
 #  if BLEDecoder
 void BLEconnect() {
   if (!BTProcessLock) {
-    Log.notice(F("BLE Connect begin" CR));
+    THEENGS_LOG_NOTICE(F("BLE Connect begin" CR));
     do {
       for (vector<BLEdevice*>::iterator it = devices.begin(); it != devices.end(); ++it) {
         BLEdevice* p = *it;
         if (p->connect) {
-          Log.trace(F("Model to connect found: %s" CR), p->macAdr);
+          THEENGS_LOG_TRACE(F("Model to connect found: %s" CR), p->macAdr);
           NimBLEAddress addr((const char*)p->macAdr, p->macType);
           if (p->sensorModel_id == BLEconectable::id::LYWSD03MMC ||
               p->sensorModel_id == BLEconectable::id::MHO_C401) {
@@ -794,7 +794,7 @@ void BLEconnect() {
         }
       }
     } while (BLEactions.size() > 0);
-    Log.notice(F("BLE Connect end" CR));
+    THEENGS_LOG_NOTICE(F("BLE Connect end" CR));
   }
 }
 #  else
@@ -805,14 +805,14 @@ void stopProcessing(bool deinit) {
   if (BTConfig.enabled) {
     BTProcessLock = true;
     // We stop the scan
-    Log.notice(F("Stopping BLE scan" CR));
+    THEENGS_LOG_NOTICE(F("Stopping BLE scan" CR));
     BLEScan* pBLEScan = BLEDevice::getScan();
     if (pBLEScan->isScanning()) {
       pBLEScan->stop();
     }
 
     if (xSemaphoreTake(semaphoreBLEOperation, pdMS_TO_TICKS(5000)) == pdTRUE) {
-      Log.notice(F("Stopping BLE tasks" CR));
+      THEENGS_LOG_NOTICE(F("Stopping BLE tasks" CR));
       //Suspending, deleting tasks and stopping BT to free memory
       vTaskSuspend(xCoreTaskHandle);
       vTaskDelete(xCoreTaskHandle);
@@ -824,7 +824,7 @@ void stopProcessing(bool deinit) {
     if (deinit)
       BLEDevice::deinit(true);
   }
-  Log.notice(F("BLE gateway stopped, free heap: %d" CR), ESP.getFreeHeap());
+  THEENGS_LOG_NOTICE(F("BLE gateway stopped, free heap: %d" CR), ESP.getFreeHeap());
 }
 
 void coreTask(void* pvParameters) {
@@ -838,10 +838,10 @@ void coreTask(void* pvParameters) {
           BLEconnect();
         }
         //dumpDevices();
-        Log.trace(F("CoreTask stack free: %u" CR), uxTaskGetStackHighWaterMark(xCoreTaskHandle));
+        THEENGS_LOG_TRACE(F("CoreTask stack free: %u" CR), uxTaskGetStackHighWaterMark(xCoreTaskHandle));
         xSemaphoreGive(semaphoreBLEOperation);
       } else {
-        Log.error(F("Failed to start scan - BLE busy" CR));
+        THEENGS_LOG_ERROR(F("Failed to start scan - BLE busy" CR));
       }
       if (SYSConfig.powerMode > 0) {
         int scan = atomic_exchange_explicit(&forceBTScan, 0, ::memory_order_seq_cst); // is this enough, it will wait the full deepsleep...
@@ -891,18 +891,18 @@ void setupBTTasksAndBLE() {
 void setupBT() {
   BTConfig_init();
   BTConfig_load();
-  Log.notice(F("BLE scans interval: %d" CR), BTConfig.BLEinterval);
-  Log.notice(F("BLE connects interval: %d" CR), BTConfig.intervalConnect);
-  Log.notice(F("BLE scan duration: %d" CR), BTConfig.scanDuration);
-  Log.notice(F("Publishing only BLE sensors: %T" CR), BTConfig.pubOnlySensors);
-  Log.notice(F("Publishing random MAC devices: %T" CR), BTConfig.pubRandomMACs);
-  Log.notice(F("Adaptive BLE scan: %T" CR), BTConfig.adaptiveScan);
-  Log.notice(F("Active BLE scan interval: %d" CR), BTConfig.intervalActiveScan);
-  Log.notice(F("minrssi: %d" CR), -abs(BTConfig.minRssi));
-  Log.notice(F("Presence Away Timer: %d" CR), BTConfig.presenceAwayTimer);
-  Log.notice(F("Moving Timer: %d" CR), BTConfig.movingTimer);
-  Log.notice(F("Force passive scan: %T" CR), BTConfig.forcePassiveScan);
-  Log.notice(F("Enabled BLE: %T" CR), BTConfig.enabled);
+  THEENGS_LOG_NOTICE(F("BLE scans interval: %d" CR), BTConfig.BLEinterval);
+  THEENGS_LOG_NOTICE(F("BLE connects interval: %d" CR), BTConfig.intervalConnect);
+  THEENGS_LOG_NOTICE(F("BLE scan duration: %d" CR), BTConfig.scanDuration);
+  THEENGS_LOG_NOTICE(F("Publishing only BLE sensors: %T" CR), BTConfig.pubOnlySensors);
+  THEENGS_LOG_NOTICE(F("Publishing random MAC devices: %T" CR), BTConfig.pubRandomMACs);
+  THEENGS_LOG_NOTICE(F("Adaptive BLE scan: %T" CR), BTConfig.adaptiveScan);
+  THEENGS_LOG_NOTICE(F("Active BLE scan interval: %d" CR), BTConfig.intervalActiveScan);
+  THEENGS_LOG_NOTICE(F("minrssi: %d" CR), -abs(BTConfig.minRssi));
+  THEENGS_LOG_NOTICE(F("Presence Away Timer: %d" CR), BTConfig.presenceAwayTimer);
+  THEENGS_LOG_NOTICE(F("Moving Timer: %d" CR), BTConfig.movingTimer);
+  THEENGS_LOG_NOTICE(F("Force passive scan: %T" CR), BTConfig.forcePassiveScan);
+  THEENGS_LOG_NOTICE(F("Enabled BLE: %T" CR), BTConfig.enabled);
 
   atomic_init(&forceBTScan, 0); // in theory, we don't need this
 
@@ -915,9 +915,9 @@ void setupBT() {
   BLEQueue = xQueueCreate(QueueSize, sizeof(NimBLEAdvertisedDevice*));
   if (BTConfig.enabled) {
     setupBTTasksAndBLE();
-    Log.notice(F("gatewayBT multicore ESP32 setup done" CR));
+    THEENGS_LOG_NOTICE(F("gatewayBT multicore ESP32 setup done" CR));
   } else {
-    Log.notice(F("gatewayBT multicore ESP32 setup disabled" CR));
+    THEENGS_LOG_NOTICE(F("gatewayBT multicore ESP32 setup disabled" CR));
   }
 }
 
@@ -936,7 +936,7 @@ void launchBTDiscovery(bool overrideDiscovery) {
   if (!overrideDiscovery && newDevices == 0)
     return;
   if (xSemaphoreTake(semaphoreCreateOrUpdateDevice, pdMS_TO_TICKS(QueueSemaphoreTimeOutTask)) == pdFALSE) {
-    Log.error(F("Semaphore NOT taken" CR));
+    THEENGS_LOG_ERROR(F("Semaphore NOT taken" CR));
     return;
   }
   newDevices = 0;
@@ -944,15 +944,15 @@ void launchBTDiscovery(bool overrideDiscovery) {
   xSemaphoreGive(semaphoreCreateOrUpdateDevice);
   for (vector<BLEdevice*>::iterator it = localDevices.begin(); it != localDevices.end(); ++it) {
     BLEdevice* p = *it;
-    Log.trace(F("Device mac %s" CR), p->macAdr);
+    THEENGS_LOG_TRACE(F("Device mac %s" CR), p->macAdr);
     // Do not launch discovery for the devices already discovered (unless we have overrideDiscovery) or that are not unique by their MAC Address (iBeacon, GAEN and Microsoft CDP)
     if (overrideDiscovery || !isDiscovered(p)) {
       String macWOdots = String(p->macAdr);
       macWOdots.replace(":", "");
       if (p->sensorModel_id >= 0) {
-        Log.trace(F("Looking for Model_id: %d" CR), p->sensorModel_id);
+        THEENGS_LOG_TRACE(F("Looking for Model_id: %d" CR), p->sensorModel_id);
         std::string properties = decoder.getTheengProperties(p->sensorModel_id);
-        Log.trace(F("properties: %s" CR), properties.c_str());
+        THEENGS_LOG_TRACE(F("properties: %s" CR), properties.c_str());
         std::string brand = decoder.getTheengAttribute(p->sensorModel_id, "brand");
         std::string model = decoder.getTheengAttribute(p->sensorModel_id, "model");
 #    if ForceDeviceName
@@ -1003,17 +1003,17 @@ void launchBTDiscovery(bool overrideDiscovery) {
               if (jsonBuffer.overflowed()) {
                 // This should not happen if JSON_MSG_BUFFER is large enough for
                 // the Theengs json properties
-                Log.error(F("JSON deserialization of Theengs properties overflowed (error %s), buffer capacity: %u. Program might crash. Properties json: %s" CR),
+                THEENGS_LOG_ERROR(F("JSON deserialization of Theengs properties overflowed (error %s), buffer capacity: %u. Program might crash. Properties json: %s" CR),
                           error.c_str(), jsonBuffer.capacity(), properties.c_str());
               } else {
-                Log.error(F("JSON deserialization of Theengs properties errored: %" CR),
+                THEENGS_LOG_ERROR(F("JSON deserialization of Theengs properties errored: %" CR),
                           error.c_str());
               }
             }
             for (JsonPair prop : jsonBuffer["properties"].as<JsonObject>()) {
-              Log.trace(F("Key: %s"), prop.key().c_str());
-              Log.trace(F("Unit: %s"), prop.value()["unit"].as<const char*>());
-              Log.trace(F("Name: %s"), prop.value()["name"].as<const char*>());
+              THEENGS_LOG_TRACE(F("Key: %s"), prop.key().c_str());
+              THEENGS_LOG_TRACE(F("Unit: %s"), prop.value()["unit"].as<const char*>());
+              THEENGS_LOG_TRACE(F("Name: %s"), prop.value()["name"].as<const char*>());
               String entity_name = String(model_id.c_str()) + "-" + String(prop.key().c_str());
               String unique_id = macWOdots + "-" + String(prop.key().c_str());
               String value_template = "{{ value_json." + String(prop.key().c_str()) + " | is_defined }}";
@@ -1155,13 +1155,13 @@ void launchBTDiscovery(bool overrideDiscovery) {
               HHCCJCY01HHCCDiscovery(macWOdots.c_str(), "HHCCJCY01HHCC");
             }
           } else {
-            Log.trace(F("Device UNKNOWN_MODEL %s" CR), p->macAdr);
+            THEENGS_LOG_TRACE(F("Device UNKNOWN_MODEL %s" CR), p->macAdr);
           }
         }
       }
       p->isDisc = true; // we don't need the semaphore and all the search magic via createOrUpdateDevice
     } else {
-      Log.trace(F("Device already discovered or that doesn't require discovery %s" CR), p->macAdr);
+      THEENGS_LOG_TRACE(F("Device already discovered or that doesn't require discovery %s" CR), p->macAdr);
     }
   }
 }
@@ -1195,18 +1195,18 @@ void reverseBytes(uint8_t* data, size_t length) {
 void process_bledata(JsonObject& BLEdata) {
   yield(); // Necessary to let the loop run in case of connectivity issues
   if (!BLEdata.containsKey("id")) {
-    Log.error(F("No mac address in the payload" CR));
+    THEENGS_LOG_ERROR(F("No mac address in the payload" CR));
     return;
   }
   const char* mac = BLEdata["id"].as<const char*>();
-  Log.trace(F("Processing BLE data %s" CR), BLEdata["id"].as<const char*>());
+  THEENGS_LOG_TRACE(F("Processing BLE data %s" CR), BLEdata["id"].as<const char*>());
   int model_id = BTConfig.extDecoderEnable ? -1 : decoder.decodeBLEJson(BLEdata);
   int mac_type = BLEdata["mac_type"].as<int>();
 
 #    if BLEDecryptor
   if (BLEdata["encr"] && (BLEdata["encr"].as<int>() > 0 && BLEdata["encr"].as<int>() <= 3)) {
     // Decrypting Encrypted BLE Data PVVX, BTHome or Victron
-    Log.trace(F("[BLEDecryptor] Decrypt ENCR:%d ModelID:%s Payload:%s" CR), BLEdata["encr"].as<int>(), BLEdata["model_id"].as<const char*>(), BLEdata["cipher"].as<const char*>());
+    THEENGS_LOG_TRACE(F("[BLEDecryptor] Decrypt ENCR:%d ModelID:%s Payload:%s" CR), BLEdata["encr"].as<int>(), BLEdata["model_id"].as<const char*>(), BLEdata["cipher"].as<const char*>());
 
     // MAC address
     String macWOdots = BLEdata["id"].as<String>(); // Mac Address without dots
@@ -1214,7 +1214,7 @@ void process_bledata(JsonObject& BLEdata) {
     unsigned char macAddress[6];
     int maclen = hexToBytes(macWOdots, macAddress, 6);
     if (maclen != 6) {
-      Log.error(F("[BLEDecryptor] Invalid MAC Address length %d" CR), maclen);
+      THEENGS_LOG_ERROR(F("[BLEDecryptor] Invalid MAC Address length %d" CR), maclen);
       return;
     }
 
@@ -1222,15 +1222,15 @@ void process_bledata(JsonObject& BLEdata) {
     unsigned char bleaeskey[16];
     int bleaeskeylength = 0;
     if (ble_aes_keys.containsKey(macWOdots)) {
-      Log.trace(F("[BLEDecryptor] Custom AES key %s" CR), ble_aes_keys[macWOdots].as<const char*>());
+      THEENGS_LOG_TRACE(F("[BLEDecryptor] Custom AES key %s" CR), ble_aes_keys[macWOdots].as<const char*>());
       bleaeskeylength = hexToBytes(ble_aes_keys[macWOdots], bleaeskey, 16);
     } else {
-      Log.trace(F("[BLEDecryptor] Default AES key" CR));
+      THEENGS_LOG_TRACE(F("[BLEDecryptor] Default AES key" CR));
       bleaeskeylength = hexToBytes(ble_aes, bleaeskey, 16);
     }
     // Check AES Key
     if (bleaeskeylength != 16) {
-      Log.error(F("[BLEDecryptor] Invalid key length %d" CR), bleaeskeylength);
+      THEENGS_LOG_ERROR(F("[BLEDecryptor] Invalid key length %d" CR), bleaeskeylength);
       return;
     }
 
@@ -1255,13 +1255,13 @@ void process_bledata(JsonObject& BLEdata) {
       unsigned char ctr[1]; // 1 byte : counter
       int ctrlen = hexToBytes(BLEdata["ctr"].as<String>(), ctr, 1);
       if (ctrlen != 1) {
-        Log.error(F("[BLEDecryptor] Invalid counter length %d" CR), ctrlen);
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Invalid counter length %d" CR), ctrlen);
         return;
       }
       nonce[10] = ctr[0];
       aad[0] = 0x11;
       aadLength = 1;
-      Log.trace(F("[BLEDecryptor] PVVX nonce %s" CR), NimBLEUtils::dataToHexString(nonce, noncelength).c_str());
+      THEENGS_LOG_TRACE(F("[BLEDecryptor] PVVX nonce %s" CR), NimBLEUtils::dataToHexString(nonce, noncelength).c_str());
 
     } else if (BLEdata["encr"].as<int>() == 2) { // BTHome V2 Encrypted
       noncelength = 13; // 13 bytes
@@ -1272,25 +1272,25 @@ void process_bledata(JsonObject& BLEdata) {
       unsigned char ctr[4]; // Counter
       int ctrlen = hexToBytes(BLEdata["ctr"].as<String>(), ctr, 4);
       if (ctrlen != 4) {
-        Log.error(F("[BLEDecryptor] Invalid counter length %d" CR), ctrlen);
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Invalid counter length %d" CR), ctrlen);
         return;
       }
       memcpy(&nonce[9], ctr, 4);
       aad[0] = 0x00;
       aadLength = 0;
-      Log.trace(F("[BLEDecryptor] BTHomeV2 nonce %s" CR), NimBLEUtils::dataToHexString(nonce, noncelength).c_str());
+      THEENGS_LOG_TRACE(F("[BLEDecryptor] BTHomeV2 nonce %s" CR), NimBLEUtils::dataToHexString(nonce, noncelength).c_str());
 
     } else if (BLEdata["encr"].as<int>() == 3) {
       nonce[16] = {0}; // Victron has a 16 byte zero padded nonce with IV bytes 6,7
       unsigned char iv[2];
       int ivlen = hexToBytes(BLEdata["ctr"].as<String>(), iv, 2);
       if (ivlen != 2) {
-        Log.error(F("[BLEDecryptor] Invalid iv length %d" CR), ivlen);
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Invalid iv length %d" CR), ivlen);
         return;
       }
       memcpy(nonce, iv, 2);
       memset(nonce + 2, 0, 14); // 14 bytes: zero padding
-      Log.trace(F("[BLEDecryptor] Victron nonce %s" CR), NimBLEUtils::dataToHexString(nonce, 16).c_str());
+      THEENGS_LOG_TRACE(F("[BLEDecryptor] Victron nonce %s" CR), NimBLEUtils::dataToHexString(nonce, 16).c_str());
     } else {
       return; // No match
     }
@@ -1308,7 +1308,7 @@ void process_bledata(JsonObject& BLEdata) {
       mbedtls_ccm_context ctx;
       mbedtls_ccm_init(&ctx);
       if (mbedtls_ccm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, bleaeskey, 128) != 0) {
-        Log.error(F("[BLEDecryptor] Failed to set AES key to mbedtls" CR));
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Failed to set AES key to mbedtls" CR));
         return;
       }
 
@@ -1316,7 +1316,7 @@ void process_bledata(JsonObject& BLEdata) {
       unsigned char mic[4];
       int miclen = hexToBytes(BLEdata["mic"].as<String>(), mic, 4);
       if (miclen != 4) {
-        Log.error(F("[BLEDecryptor] Invalid MIC length %d" CR), miclen);
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Invalid MIC length %d" CR), miclen);
         return;
       }
 
@@ -1332,16 +1332,16 @@ void process_bledata(JsonObject& BLEdata) {
       mbedtls_ccm_free(&ctx);
 
       if (ret == 0) {
-        Log.notice(F("[BLEDecryptor] Decryption successful" CR));
+        THEENGS_LOG_NOTICE(F("[BLEDecryptor] Decryption successful" CR));
       } else if (ret == MBEDTLS_ERR_CCM_AUTH_FAILED) {
         if (ble_aes_keys.containsKey(macWOdots)) {
-          Log.error(F("[BLEDecryptor] Decryption failed for %s with key %s" CR), macWOdots.c_str(), ble_aes_keys[macWOdots].as<const char*>());
+          THEENGS_LOG_ERROR(F("[BLEDecryptor] Decryption failed for %s with key %s" CR), macWOdots.c_str(), ble_aes_keys[macWOdots].as<const char*>());
         } else {
-          Log.error(F("[BLEDecryptor] Decryption failed for %s with default key" CR), macWOdots.c_str());
+          THEENGS_LOG_ERROR(F("[BLEDecryptor] Decryption failed for %s with default key" CR), macWOdots.c_str());
         }
         return;
       } else {
-        Log.error(F("[BLEDecryptor] Decryption failed with error: %X" CR), ret);
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Decryption failed with error: %X" CR), ret);
         return;
       }
 
@@ -1359,7 +1359,7 @@ void process_bledata(JsonObject& BLEdata) {
       } else {
         return;
       }
-      Log.trace(F("[BLEDecryptor] Decrypted servicedata %s" CR), BLEdata["servicedata"].as<const char*>());
+      THEENGS_LOG_TRACE(F("[BLEDecryptor] Decrypted servicedata %s" CR), BLEdata["servicedata"].as<const char*>());
 
     } else if (BLEdata["encr"].as<int>() == 3) {
       // Decrypt Victron Energy encrypted advertisements.
@@ -1381,12 +1381,12 @@ void process_bledata(JsonObject& BLEdata) {
       mbedtls_aes_free(&ctx);
 
       if (ret == 0) {
-        Log.notice(F("[BLEDecryptor] Victron Decryption successful" CR));
+        THEENGS_LOG_NOTICE(F("[BLEDecryptor] Victron Decryption successful" CR));
       } else if (ret == MBEDTLS_ERR_CCM_AUTH_FAILED) {
-        Log.error(F("[BLEDecryptor] Victron Authentication failed." CR));
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Victron Authentication failed." CR));
         return;
       } else {
-        Log.error(F("[BLEDecryptor] Victron decryption failed with error: %X" CR), ret);
+        THEENGS_LOG_ERROR(F("[BLEDecryptor] Victron decryption failed with error: %X" CR), ret);
         return;
       }
 
@@ -1398,14 +1398,14 @@ void process_bledata(JsonObject& BLEdata) {
       manufacturerdata[8] = 0xff; // Replace byte 8 with "ff" to indicate decrypted data
       memcpy(&manufacturerdata[10], decrypted, ciphertextlen); // Append the decrypted payload to the manufacturer data
       BLEdata["manufacturerdata"] = NimBLEUtils::dataToHexString(manufacturerdata, 10 + ciphertextlen); // Rebuild manufacturerdata
-      Log.trace(F("[BLEDecryptor] Victron decrypted manufacturerdata %s" CR), BLEdata["manufacturerdata"].as<const char*>());
+      THEENGS_LOG_TRACE(F("[BLEDecryptor] Victron decrypted manufacturerdata %s" CR), BLEdata["manufacturerdata"].as<const char*>());
     }
 
     // Print before and after decoder post decryption
     // serializeJsonPretty(BLEdata, Serial);
     model_id = BTConfig.extDecoderEnable ? -1 : decoder.decodeBLEJson(BLEdata);
     // serializeJsonPretty(BLEdata, Serial);
-    Log.trace(F("[BLEDecryptor] Decrypted model_id %d" CR), model_id);
+    THEENGS_LOG_TRACE(F("[BLEDecryptor] Decrypted model_id %d" CR), model_id);
 
     // Remove the cipher fields from BLEdata
     BLEdata.remove("encr");
@@ -1422,13 +1422,13 @@ void process_bledata(JsonObject& BLEdata) {
       BLEdata.remove("track");
     }
     BLEdata["type"] = "RMAC";
-    Log.trace(F("Potential RMAC (prmac) converted to RMAC" CR));
+    THEENGS_LOG_TRACE(F("Potential RMAC (prmac) converted to RMAC" CR));
   }
   const char* deviceName = BLEdata["name"] | "";
 
   if ((BLEdata["type"].as<string>()).compare("RMAC") != 0 && model_id != TheengsDecoder::BLE_ID_NUM::IBEACON) { // Do not store in memory the random mac devices and iBeacons
     if (model_id >= 0) { // Broadcaster devices
-      Log.trace(F("Decoder found device: %s" CR), BLEdata["model_id"].as<const char*>());
+      THEENGS_LOG_TRACE(F("Decoder found device: %s" CR), BLEdata["model_id"].as<const char*>());
       if (model_id == TheengsDecoder::BLE_ID_NUM::HHCCJCY01HHCC || model_id == TheengsDecoder::BLE_ID_NUM::BM2) { // Device that broadcast and can be connected
         createOrUpdateDevice(mac, device_flags_connect, model_id, mac_type, deviceName);
       } else {
@@ -1439,7 +1439,7 @@ void process_bledata(JsonObject& BLEdata) {
               BTConfig.BLEinterval = MinTimeBtwScan;
               BTConfig.intervalActiveScan = MinTimeBtwScan;
               BTConfig.scanDuration = MinScanDuration;
-              Log.notice(F("Active and continuous scanning required, parameters adapted" CR));
+              THEENGS_LOG_NOTICE(F("Active and continuous scanning required, parameters adapted" CR));
               stateBTMeasures(false);
             }
           } else if (BLEdata.containsKey("cont") && BTConfig.BLEinterval != MinTimeBtwScan) {
@@ -1448,7 +1448,7 @@ void process_bledata(JsonObject& BLEdata) {
               if ((BLEdata["type"].as<string>()).compare("CTMO") == 0) {
                 BTConfig.scanDuration = MinScanDuration;
               }
-              Log.notice(F("Passive continuous scanning required, parameters adapted" CR));
+              THEENGS_LOG_NOTICE(F("Passive continuous scanning required, parameters adapted" CR));
               stateBTMeasures(false);
             }
           }
@@ -1467,23 +1467,23 @@ void process_bledata(JsonObject& BLEdata) {
           model_id = BLEconectable::id::XMWSDJ04MMC;
 
         if (model_id > 0) {
-          Log.trace(F("Connectable device found: %s" CR), name.c_str());
+          THEENGS_LOG_TRACE(F("Connectable device found: %s" CR), name.c_str());
           createOrUpdateDevice(mac, device_flags_connect, model_id, mac_type, deviceName);
         }
       } else if (BTConfig.extDecoderEnable && model_id < 0 && BLEdata.containsKey("servicedata")) {
         const char* service_data = (const char*)(BLEdata["servicedata"] | "");
         if (strstr(service_data, "209800") != NULL) {
           model_id = TheengsDecoder::BLE_ID_NUM::HHCCJCY01HHCC;
-          Log.trace(F("Connectable device found: HHCCJCY01HHCC" CR));
+          THEENGS_LOG_TRACE(F("Connectable device found: HHCCJCY01HHCC" CR));
           createOrUpdateDevice(mac, device_flags_connect, model_id, mac_type, deviceName);
         }
       }
     }
   } else {
-    Log.trace(F("Random MAC or iBeacon device filtered" CR));
+    THEENGS_LOG_TRACE(F("Random MAC or iBeacon device filtered" CR));
   }
   if (!BTConfig.extDecoderEnable && model_id < 0) {
-    Log.trace(F("No eligible device found " CR));
+    THEENGS_LOG_TRACE(F("No eligible device found " CR));
   }
 }
 void PublishDeviceData(JsonObject& BLEdata) {
@@ -1492,7 +1492,7 @@ void PublishDeviceData(JsonObject& BLEdata) {
     process_bledata(BLEdata);
     // If the device is a random MAC and pubRandomMACs is false we don't publish this payload
     if (!BTConfig.pubRandomMACs && (BLEdata["type"].as<string>()).compare("RMAC") == 0) {
-      Log.trace(F("Random MAC, device filtered" CR));
+      THEENGS_LOG_TRACE(F("Random MAC, device filtered" CR));
       return;
     }
     // If pubAdvData is false we don't publish the adv data
@@ -1517,7 +1517,7 @@ void PublishDeviceData(JsonObject& BLEdata) {
         BLEdata["id"] = BLEdata["uuid"].as<std::string>();
       }
       String topic = String(mqtt_topic) + BTConfig.presenceTopic + String(gateway_name);
-      Log.trace(F("Pub HA Presence %s" CR), topic.c_str());
+      THEENGS_LOG_TRACE(F("Pub HA Presence %s" CR), topic.c_str());
       BLEdata["topic"] = topic;
       enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
     }
@@ -1527,7 +1527,7 @@ void PublishDeviceData(JsonObject& BLEdata) {
       buildTopicFromId(BLEdata, subjectBTtoMQTT);
       enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
     } else {
-      Log.notice(F("Not a sensor device filtered" CR));
+      THEENGS_LOG_NOTICE(F("Not a sensor device filtered" CR));
       return;
     }
 
@@ -1552,7 +1552,7 @@ void PublishDeviceData(JsonObject& BLEdata) {
     }
 #    endif
   } else {
-    Log.notice(F("Low rssi, device filtered" CR));
+    THEENGS_LOG_NOTICE(F("Low rssi, device filtered" CR));
     return;
   }
 }
@@ -1571,7 +1571,7 @@ void PublishDeviceData(JsonObject& BLEdata) {
     buildTopicFromId(BLEdata, subjectBTtoMQTT);
     enqueueJsonObject(BLEdata, QueueSemaphoreTimeOutTask);
   } else {
-    Log.notice(F("Low rssi, device filtered" CR));
+    THEENGS_LOG_NOTICE(F("Low rssi, device filtered" CR));
     return;
   }
 }
@@ -1579,11 +1579,11 @@ void PublishDeviceData(JsonObject& BLEdata) {
 
 void hass_presence(JsonObject& HomePresence) {
   int BLErssi = HomePresence["rssi"];
-  Log.trace(F("BLErssi %d" CR), BLErssi);
+  THEENGS_LOG_TRACE(F("BLErssi %d" CR), BLErssi);
   int txPower = HomePresence["txpower"] | 0;
   if (txPower >= 0)
     txPower = -59; //if tx power is not found we set a default calibration value
-  Log.trace(F("TxPower: %d" CR), txPower);
+  THEENGS_LOG_TRACE(F("TxPower: %d" CR), txPower);
   double ratio = BLErssi * 1.0 / txPower;
   double distance;
   if (ratio < 1.0) {
@@ -1592,17 +1592,17 @@ void hass_presence(JsonObject& HomePresence) {
     distance = (0.89976) * pow(ratio, 7.7095) + 0.111;
   }
   HomePresence["distance"] = distance;
-  Log.trace(F("Ble distance %D" CR), distance);
+  THEENGS_LOG_TRACE(F("Ble distance %D" CR), distance);
 }
 
 void BTforceScan() {
   if (!BTProcessLock) {
     BLEscan();
-    Log.trace(F("Scan done" CR));
+    THEENGS_LOG_TRACE(F("Scan done" CR));
     if (BTConfig.bleConnect)
       BLEconnect();
   } else {
-    Log.trace(F("Cannot launch scan due to other process running" CR));
+    THEENGS_LOG_TRACE(F("Cannot launch scan due to other process running" CR));
   }
 }
 
@@ -1635,7 +1635,7 @@ void immediateBTAction(void* pvParameters) {
         std::swap(BLEactions, act_swap);
         xSemaphoreGive(semaphoreCreateOrUpdateDevice);
       } else {
-        Log.error(F("CreateOrUpdate Semaphore NOT taken" CR));
+        THEENGS_LOG_ERROR(F("CreateOrUpdate Semaphore NOT taken" CR));
       }
 
       // If we stopped the scheduled connect for this action, do the scheduled now
@@ -1645,7 +1645,7 @@ void immediateBTAction(void* pvParameters) {
       }
       xSemaphoreGive(semaphoreBLEOperation);
     } else {
-      Log.error(F("BLE busy - immediateBTAction not sent" CR));
+      THEENGS_LOG_ERROR(F("BLE busy - immediateBTAction not sent" CR));
       gatewayState = GatewayState::ERROR;
       StaticJsonDocument<JSON_MSG_BUFFER> BLEdataBuffer;
       JsonObject BLEdata = BLEdataBuffer.to<JsonObject>();
@@ -1675,7 +1675,7 @@ void startBTActionTask() {
 #  if BLEDecoder
 void KnownBTActions(JsonObject& BTdata) {
   if (!BTdata.containsKey("id")) {
-    Log.error(F("BLE mac address missing" CR));
+    THEENGS_LOG_ERROR(F("BLE mac address missing" CR));
     gatewayState = GatewayState::ERROR;
     return;
   }
@@ -1728,7 +1728,7 @@ void KnownBTActions(JsonObject& BTdata) {
       BLEactions.push_back(action);
       startBTActionTask();
     } else {
-      Log.error(F("BLE action not recognized" CR));
+      THEENGS_LOG_ERROR(F("BLE action not recognized" CR));
       gatewayState = GatewayState::ERROR;
     }
   }
@@ -1751,12 +1751,12 @@ void XtoBTAction(JsonObject& BTdata) {
     else if (vt == "FLOAT")
       action.value_type = BLE_VAL_FLOAT;
     else if (vt != "STRING") {
-      Log.error(F("BLE value type invalid %s" CR), vt.c_str());
+      THEENGS_LOG_ERROR(F("BLE value type invalid %s" CR), vt.c_str());
       return;
     }
   }
 
-  Log.trace(F("BLE ACTION TTL = %u" CR), action.ttl);
+  THEENGS_LOG_TRACE(F("BLE ACTION TTL = %u" CR), action.ttl);
   action.complete = false;
   if (BTdata.containsKey("ble_write_address") &&
       BTdata.containsKey("ble_write_service") &&
@@ -1768,7 +1768,7 @@ void XtoBTAction(JsonObject& BTdata) {
     std::string val = BTdata["ble_write_value"].as<std::string>(); // Fix #1694
     action.value = val;
     action.write = true;
-    Log.trace(F("BLE ACTION Write" CR));
+    THEENGS_LOG_TRACE(F("BLE ACTION Write" CR));
   } else if (BTdata.containsKey("ble_read_address") &&
              BTdata.containsKey("ble_read_service") &&
              BTdata.containsKey("ble_read_char")) {
@@ -1776,7 +1776,7 @@ void XtoBTAction(JsonObject& BTdata) {
     action.service = NimBLEUUID((const char*)BTdata["ble_read_service"]);
     action.characteristic = NimBLEUUID((const char*)BTdata["ble_read_char"]);
     action.write = false;
-    Log.trace(F("BLE ACTION Read" CR));
+    THEENGS_LOG_TRACE(F("BLE ACTION Read" CR));
   } else {
     return;
   }
@@ -1791,7 +1791,7 @@ void XtoBTAction(JsonObject& BTdata) {
 
 void XtoBT(const char* topicOri, JsonObject& BTdata) { // json object decoding
   if (cmpToMainTopic(topicOri, subjectMQTTtoBTset)) {
-    Log.trace(F("MQTTtoBT json set" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoBT json set" CR));
 
     // Black list & white list set
     bool WorBupdated;
@@ -1807,7 +1807,7 @@ void XtoBT(const char* topicOri, JsonObject& BTdata) { // json object decoding
 
     // Force scan now
     if (BTdata.containsKey("interval") && BTdata["interval"] == 0) {
-      Log.notice(F("BLE forced scan" CR));
+      THEENGS_LOG_NOTICE(F("BLE forced scan" CR));
       atomic_store_explicit(&forceBTScan, 1, ::memory_order_seq_cst); // ask the other core to do the scan for us
     }
 
@@ -1834,7 +1834,7 @@ void XtoBT(const char* topicOri, JsonObject& BTdata) { // json object decoding
       XtoBTAction(BTdata);
       xSemaphoreGive(semaphoreBLEOperation);
     } else {
-      Log.error(F("BLE busy - BTActions not sent" CR));
+      THEENGS_LOG_ERROR(F("BLE busy - BTActions not sent" CR));
       gatewayState = GatewayState::ERROR;
     }
   } else if (strstr(topicOri, subjectTrackerSync) != NULL) {
@@ -1842,7 +1842,7 @@ void XtoBT(const char* topicOri, JsonObject& BTdata) { // json object decoding
       BLEdevice* device = getDeviceByMac(BTdata["trackerid"].as<const char*>());
       if (device != &NO_BT_DEVICE_FOUND && device->lastUpdate != 0) {
         device->lastUpdate = 0;
-        Log.notice(F("Tracker %s disassociated by gateway %s" CR), BTdata["trackerid"].as<const char*>(), BTdata["gatewayid"].as<const char*>());
+        THEENGS_LOG_NOTICE(F("Tracker %s disassociated by gateway %s" CR), BTdata["trackerid"].as<const char*>(), BTdata["gatewayid"].as<const char*>());
       }
     }
   }
diff --git a/main/gatewayGFSunInverter.cpp b/main/gatewayGFSunInverter.cpp
index 50dcc15..11f5a49 100644
--- a/main/gatewayGFSunInverter.cpp
+++ b/main/gatewayGFSunInverter.cpp
@@ -39,17 +39,17 @@ void GFSunInverterDataHandler(GfSun2000Data data) {
   JsonObject jdata = jdataBuffer.to<JsonObject>();
 
   jdata["device_id"] = (char*)data.deviceID;
-  Log.trace(F("Device ID     : %s\n" CR), data.deviceID);
+  THEENGS_LOG_TRACE(F("Device ID     : %s\n" CR), data.deviceID);
   jdata["ac_voltage"] = data.ACVoltage;
-  Log.trace(F("AC Voltage    : %.1f\tV\n" CR), data.ACVoltage);
+  THEENGS_LOG_TRACE(F("AC Voltage    : %.1f\tV\n" CR), data.ACVoltage);
   jdata["dc_voltage"] = data.DCVoltage;
-  Log.trace(F("DC Voltage    : %.1f\tV\n" CR), data.DCVoltage);
+  THEENGS_LOG_TRACE(F("DC Voltage    : %.1f\tV\n" CR), data.DCVoltage);
   jdata["power"] = data.averagePower;
-  Log.trace(F("Output Power  : %.1f\tW (5min avg)\n" CR), data.averagePower);
+  THEENGS_LOG_TRACE(F("Output Power  : %.1f\tW (5min avg)\n" CR), data.averagePower);
   jdata["c_energy"] = data.customEnergyCounter;
-  Log.trace(F("Custom Energy : %.1f\tkW/h (can be reseted)\n" CR), data.customEnergyCounter);
+  THEENGS_LOG_TRACE(F("Custom Energy : %.1f\tkW/h (can be reseted)\n" CR), data.customEnergyCounter);
   jdata["t_energy"] = data.totalEnergyCounter;
-  Log.trace(F("Total Energy  : %.1f\tkW/h\n" CR), data.totalEnergyCounter);
+  THEENGS_LOG_TRACE(F("Total Energy  : %.1f\tkW/h\n" CR), data.totalEnergyCounter);
 
 #  ifdef GFSUNINVERTER_DEVEL
   StaticJsonDocument<JSON_MSG_BUFFER> jregisterBuffer;
@@ -57,7 +57,7 @@ void GFSunInverterDataHandler(GfSun2000Data data) {
   char buffer[4];
   std::map<int16_t, int16_t>::iterator itr;
   for (itr = data.modbusRegistry.begin(); itr != data.modbusRegistry.end(); ++itr) {
-    Log.notice("%d: %d\n", itr->first, itr->second);
+    THEENGS_LOG_NOTICE("%d: %d\n", itr->first, itr->second);
     sprintf(buffer, "%d", itr->first);
     jregister[buffer] = itr->second;
   }
@@ -70,7 +70,7 @@ void GFSunInverterDataHandler(GfSun2000Data data) {
 void GFSunInverterErrorHandler(int errorId, char* errorMessage) {
   char buffer[50];
   sprintf(buffer, "Error response: %02X - %s\n", errorId, errorMessage);
-  Log.error(buffer);
+  THEENGS_LOG_ERROR(buffer);
   StaticJsonDocument<JSON_MSG_BUFFER> jdataBuffer;
   JsonObject jdata = jdataBuffer.to<JsonObject>();
   jdata["status"] = "error";
@@ -84,7 +84,7 @@ void setupGFSunInverter() {
   GF.setup(Serial2);
   GF.setDataHandler(GFSunInverterDataHandler);
   GF.setErrorHandler(GFSunInverterErrorHandler);
-  Log.trace(F("gatewayGFSunInverter setup done " CR));
+  THEENGS_LOG_TRACE(F("gatewayGFSunInverter setup done " CR));
 }
 
 void ZgatewayGFSunInverterMQTT() {
diff --git a/main/gatewayIR.cpp b/main/gatewayIR.cpp
index c5d7aea..81d544b 100644
--- a/main/gatewayIR.cpp
+++ b/main/gatewayIR.cpp
@@ -99,22 +99,22 @@ void setupIR() {
 
   irrecv.enableIRIn(); // Start the receiver
 
-  Log.notice(F("IR_EMITTER_GPIO: %d " CR), IR_EMITTER_GPIO);
-  Log.notice(F("IR_RECEIVER_GPIO: %d " CR), IR_RECEIVER_GPIO);
-  Log.trace(F("gatewayIR setup done " CR));
+  THEENGS_LOG_NOTICE(F("IR_EMITTER_GPIO: %d " CR), IR_EMITTER_GPIO);
+  THEENGS_LOG_NOTICE(F("IR_RECEIVER_GPIO: %d " CR), IR_RECEIVER_GPIO);
+  THEENGS_LOG_TRACE(F("gatewayIR setup done " CR));
 }
 
 void IRtoX() {
   decode_results results;
 
   if (irrecv.decode(&results)) {
-    Log.trace(F("Creating IR buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating IR buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> IRdataBuffer;
     JsonObject IRdata = IRdataBuffer.to<JsonObject>();
 
-    Log.trace(F("Rcv. IR" CR));
+    THEENGS_LOG_TRACE(F("Rcv. IR" CR));
 #  ifdef ESP32
-    Log.trace(F("IR Task running on core :%d" CR), xPortGetCoreID());
+    THEENGS_LOG_TRACE(F("IR Task running on core :%d" CR), xPortGetCoreID());
 #  endif
     IRdata["value"] = uint64_t(results.value);
     IRdata["protocol"] = (int)(results.decode_type);
@@ -140,21 +140,21 @@ void IRtoX() {
       rawsend[i] = results.rawbuf[i];
     }
     irsend.sendRaw(rawsend, results.rawlen, RawFrequency);
-    Log.trace(F("raw redirected" CR));
+    THEENGS_LOG_TRACE(F("raw redirected" CR));
 #  endif
     irrecv.resume(); // Receive the next value
     uint64_t MQTTvalue = IRdata["value"].as<uint64_t>();
     //trc(MQTTvalue);
     if ((pubIRunknownPrtcl == false && IRdata["protocol"].as<int>() == -1)) { // don't publish unknown IR protocol
-      Log.notice(F("--no pub unknwn prt--" CR));
+      THEENGS_LOG_NOTICE(F("--no pub unknwn prt--" CR));
     } else if (!isAduplicateSignal(MQTTvalue) && MQTTvalue != 0) { // conditions to avoid duplications of IR -->MQTT
-      Log.trace(F("Adv data IRtoMQTT" CR));
+      THEENGS_LOG_TRACE(F("Adv data IRtoMQTT" CR));
       IRdata["origin"] = subjectIRtoMQTT;
       enqueueJsonObject(IRdata);
-      Log.trace(F("Store val: %D" CR), MQTTvalue);
+      THEENGS_LOG_TRACE(F("Store val: %D" CR), MQTTvalue);
       storeSignalValue(MQTTvalue);
       if (repeatIRwMQTT) {
-        Log.trace(F("Pub. IR for rpt" CR));
+        THEENGS_LOG_TRACE(F("Pub. IR for rpt" CR));
         pubMQTT(subjectForwardMQTTtoIR, MQTTvalue);
       }
     }
@@ -166,16 +166,16 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  if jsonReceiving
 void XtoIR(const char* topicOri, JsonObject& IRdata) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoIR)) {
-    Log.trace(F("MQTTtoIR json" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoIR json" CR));
     uint64_t data = IRdata["value"];
     const char* raw = IRdata["raw"];
     const char* hex = IRdata["hex"];
     if (hex) { // we privilegiate the hex usage over the value one (less risk of error)
-      Log.trace(F("hex: %s" CR), hex);
+      THEENGS_LOG_TRACE(F("hex: %s" CR), hex);
       data = getUInt64fromHex(hex);
     }
     if (data != 0 || raw) {
-      Log.trace(F("MQTTtoIR value || raw  detected" CR));
+      THEENGS_LOG_TRACE(F("MQTTtoIR value || raw  detected" CR));
       irrecv.disableIRIn();
       bool signalSent = false;
       const char* protocol_name = IRdata["protocol_name"];
@@ -183,7 +183,7 @@ void XtoIR(const char* topicOri, JsonObject& IRdata) {
       uint16_t valueRPT = IRdata["repeat"] | repeatIRwNumber;
 
       if (raw) {
-        Log.trace(F("Raw: %s" CR), raw);
+        THEENGS_LOG_TRACE(F("Raw: %s" CR), raw);
         unsigned int s = strlen(raw);
         //number of "," value count
         int count = 0;
@@ -194,7 +194,7 @@ void XtoIR(const char* topicOri, JsonObject& IRdata) {
         }
 #    ifdef IR_GC
         if (strcmp(protocol_name, "GC") == 0) { // sending GC data from https://irdb.globalcache.com
-          Log.trace(F("GC" CR));
+          THEENGS_LOG_TRACE(F("GC" CR));
           //buffer allocation from char datacallback
           uint16_t GC[count + 1];
           String value = "";
@@ -215,7 +215,7 @@ void XtoIR(const char* topicOri, JsonObject& IRdata) {
 #    endif
 #    ifdef IR_RAW
         if (strcmp(protocol_name, "Raw") == 0) { // sending Raw data
-          Log.trace(F("Raw" CR));
+          THEENGS_LOG_TRACE(F("Raw" CR));
           //buffer allocation from char datacallback
           uint16_t Raw[count + 1];
           String value = "";
@@ -235,24 +235,24 @@ void XtoIR(const char* topicOri, JsonObject& IRdata) {
         }
 #    endif
       } else if (protocol_name && (strcmp(protocol_name, "NEC") != 0)) {
-        Log.trace(F("Using Identified Protocol: %s  bits: %d repeat: %d" CR), protocol_name, valueBITS, valueRPT);
+        THEENGS_LOG_TRACE(F("Using Identified Protocol: %s  bits: %d repeat: %d" CR), protocol_name, valueBITS, valueRPT);
         signalSent = sendIdentifiedProtocol(protocol_name, data, hex, valueBITS, valueRPT);
       } else {
-        Log.trace(F("Using NEC protocol" CR));
-        Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+        THEENGS_LOG_TRACE(F("Using NEC protocol" CR));
+        THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
         if (valueBITS == 0)
           valueBITS = NEC_BITS;
         irsend.sendNEC(data, valueBITS, valueRPT);
         signalSent = true;
       }
       if (signalSent) { // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
-        Log.notice(F("MQTTtoIR OK" CR));
+        THEENGS_LOG_NOTICE(F("MQTTtoIR OK" CR));
         IRdata["origin"] = subjectGTWIRtoMQTT;
         enqueueJsonObject(IRdata);
       }
       irrecv.enableIRIn(); // ReStart the IR receiver (if not restarted it is not able to receive data)
     } else {
-      Log.error(F("MQTTtoIR failed json read" CR));
+      THEENGS_LOG_ERROR(F("MQTTtoIR failed json read" CR));
     }
   }
 }
@@ -268,12 +268,12 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
       ptr += 2;
     }
     for (int i = 0; i < valueBITS; i++) {
-      Log.trace(F("%x"), dataarray[i]);
+      THEENGS_LOG_TRACE(F("%x"), dataarray[i]);
     }
   }
 #  ifdef IR_WHYNTER
   if (strcmp(protocol_name, "WHYNTER") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = WHYNTER_BITS;
     irsend.sendWhynter(data, valueBITS, valueRPT);
@@ -282,7 +282,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_LG
   if (strcmp(protocol_name, "LG") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = LG_BITS;
     irsend.sendLG(data, valueBITS, valueRPT);
@@ -291,7 +291,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SONY
   if (strcmp(protocol_name, "SONY") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = SONY_20_BITS;
     irsend.sendSony(data, valueBITS, valueRPT);
@@ -300,7 +300,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DISH
   if (strcmp(protocol_name, "DISH") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = DISH_BITS;
     irsend.sendDISH(data, valueBITS, valueRPT);
@@ -309,7 +309,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_RC5
   if (strcmp(protocol_name, "RC5") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = RC5_BITS;
     irsend.sendRC5(data, valueBITS, valueRPT);
@@ -318,7 +318,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_RC6
   if (strcmp(protocol_name, "RC6") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = RC6_MODE0_BITS;
     irsend.sendRC6(data, valueBITS, valueRPT);
@@ -327,7 +327,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SHARP
   if (strcmp(protocol_name, "SHARP") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = SHARP_BITS;
     irsend.sendSharpRaw(data, valueBITS, valueRPT);
@@ -336,7 +336,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SAMSUNG
   if (strcmp(protocol_name, "SAMSUNG") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = SAMSUNG_BITS;
     irsend.sendSAMSUNG(data, valueBITS, valueRPT);
@@ -345,7 +345,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_JVC
   if (strcmp(protocol_name, "JVC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = JVC_BITS;
     irsend.sendJVC(data, valueBITS, valueRPT);
@@ -354,7 +354,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_PANASONIC
   if (strcmp(protocol_name, "PANASONIC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = PANASONIC_BITS;
     irsend.sendPanasonic(PanasonicAddress, data, valueBITS, valueRPT);
@@ -364,8 +364,8 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 
 #  ifdef IR_COOLIX
   if (strcmp(protocol_name, "COOLIX") == 0) {
-    Log.trace(F("Sending %s:" CR), protocol_name);
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_TRACE(F("Sending %s:" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kCoolixBits;
     if (valueRPT == repeatIRwNumber)
@@ -376,8 +376,8 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_RCMM
   if (strcmp(protocol_name, "RCMM") == 0) {
-    Log.trace(F("Sending %s:" CR), protocol_name);
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_TRACE(F("Sending %s:" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kRCMMBits;
     irsend.sendRCMM(data, valueBITS, valueRPT);
@@ -386,7 +386,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DENON
   if (strcmp(protocol_name, "DENON") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = DENON_BITS;
     irsend.sendDenon(data, valueBITS, valueRPT);
@@ -395,7 +395,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_GICABLE
   if (strcmp(protocol_name, "GICABLE") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kGicableBits;
     if (valueRPT == repeatIRwNumber)
@@ -406,7 +406,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SHERWOOD
   if (strcmp(protocol_name, "SHERWOOD") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kSherwoodBits;
     if (valueRPT == repeatIRwNumber)
@@ -417,7 +417,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MITSUBISHI
   if (strcmp(protocol_name, "MITSUBISHI") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMitsubishiBits;
     if (valueRPT == repeatIRwNumber)
@@ -428,7 +428,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_NIKAI
   if (strcmp(protocol_name, "NIKAI") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kNikaiBits;
     irsend.sendNikai(data, valueBITS, valueRPT);
@@ -437,7 +437,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MIDEA
   if (strcmp(protocol_name, "MIDEA") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMideaBits;
     if (valueRPT == repeatIRwNumber)
@@ -448,7 +448,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MAGIQUEST
   if (strcmp(protocol_name, "MAGIQUEST") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMagiquestBits;
     irsend.sendMagiQuest(data, valueBITS, valueRPT);
@@ -457,7 +457,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_LASERTAG
   if (strcmp(protocol_name, "LASERTAG") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kLasertagBits;
     if (valueRPT == repeatIRwNumber)
@@ -468,7 +468,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_CARRIER_AC
   if (strcmp(protocol_name, "CARRIER_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kCarrierAcBits;
     if (valueRPT == repeatIRwNumber)
@@ -479,7 +479,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MITSUBISHI2
   if (strcmp(protocol_name, "MITSUBISHI2") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMitsubishiBits;
     if (valueRPT == repeatIRwNumber)
@@ -490,7 +490,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_AIWA_RC_T501
   if (strcmp(protocol_name, "AIWA_RC_T501") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kAiwaRcT501Bits;
     if (valueRPT == repeatIRwNumber)
@@ -501,7 +501,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DAIKIN
   if (strcmp(protocol_name, "DAIKIN") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDaikinStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -512,7 +512,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_KELVINATOR
   if (strcmp(protocol_name, "KELVINATOR") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kKelvinatorStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -523,7 +523,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MITSUBISHI_AC
   if (strcmp(protocol_name, "MITSUBISHI_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMitsubishiACStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -534,7 +534,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SANYO
   if (strcmp(protocol_name, "SANYOLC7461") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kSanyoLC7461Bits;
     irsend.sendSanyoLC7461(data, valueBITS, valueRPT);
@@ -543,7 +543,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_GREE
   if (strcmp(protocol_name, "GREE") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kGreeStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -554,7 +554,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_ARGO
   if (strcmp(protocol_name, "ARGO") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kArgoStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -565,7 +565,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TROTEC
   if (strcmp(protocol_name, "TROTEC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kTrotecStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -576,7 +576,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TOSHIBA_AC
   if (strcmp(protocol_name, "TOSHIBA_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kToshibaACBits;
     if (valueRPT == repeatIRwNumber)
@@ -595,7 +595,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HAIER_AC
   if (strcmp(protocol_name, "HAIER_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHaierACStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -606,7 +606,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC
   if (strcmp(protocol_name, "HITACHI_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHitachiAcStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -617,7 +617,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC1
   if (strcmp(protocol_name, "HITACHI_AC1") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHitachiAc1StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -628,7 +628,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC2
   if (strcmp(protocol_name, "HITACHI_AC2") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHitachiAc2StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -639,7 +639,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HAIER_AC_YRW02
   if (strcmp(protocol_name, "HAIER_AC_YRW02") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHaierACYRW02StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -650,7 +650,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_WHIRLPOOL_AC
   if (strcmp(protocol_name, "WHIRLPOOL_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kWhirlpoolAcStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -661,7 +661,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SAMSUNG_AC
   if (strcmp(protocol_name, "SAMSUNG_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kSamsungAcStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -672,7 +672,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_LUTRON
   if (strcmp(protocol_name, "LUTRON") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kLutronBits;
     irsend.sendLutron(data, valueBITS, valueRPT);
@@ -681,7 +681,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_ELECTRA_AC
   if (strcmp(protocol_name, "ELECTRA_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kElectraAcStateLength;
     irsend.sendElectraAC(dataarray, valueBITS, valueRPT);
@@ -690,7 +690,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_PANASONIC_AC
   if (strcmp(protocol_name, "PANASONIC_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kPanasonicAcStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -701,7 +701,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_PIONEER
   if (strcmp(protocol_name, "PIONEER") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kPioneerBits;
     irsend.sendPioneer(data, valueBITS, valueRPT);
@@ -710,7 +710,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_LG2
   if (strcmp(protocol_name, "LG2") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kLgBits;
     irsend.sendLG2(data, valueBITS, valueRPT);
@@ -725,7 +725,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DAIKIN2
   if (strcmp(protocol_name, "DAIKIN2") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDaikin2StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -736,7 +736,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_VESTEL_AC
   if (strcmp(protocol_name, "VESTEL_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kVestelAcBits;
     irsend.sendVestelAc(data, valueBITS, valueRPT);
@@ -745,7 +745,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SAMSUNG36
   if (strcmp(protocol_name, "SAMSUNG36") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kSamsung36Bits;
     irsend.sendSamsung36(data, valueBITS, valueRPT);
@@ -754,7 +754,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TCL112AC
   if (strcmp(protocol_name, "TCL112AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kTcl112AcStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -765,7 +765,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TECO
   if (strcmp(protocol_name, "TECO") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kTecoBits;
     irsend.sendTeco(data, valueBITS, valueRPT);
@@ -774,7 +774,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_LEGOPF
   if (strcmp(protocol_name, "LEGOPF") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kLegoPfBits;
     if (valueRPT == repeatIRwNumber)
@@ -785,7 +785,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MITSUBISHIHEAVY88
   if (strcmp(protocol_name, "MITSUBISHIHEAVY88") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMitsubishiHeavy88StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -796,7 +796,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MITSUBISHIHEAVY152
   if (strcmp(protocol_name, "MITSUBISHIHEAVY152") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMitsubishiHeavy152StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -807,7 +807,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DAIKIN216
   if (strcmp(protocol_name, "DAIKIN216") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDaikin216StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -818,7 +818,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SHARP_AC
   if (strcmp(protocol_name, "SHARP_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kSharpAcStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -829,7 +829,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_GOODWEATHER
   if (strcmp(protocol_name, "GOODWEATHER_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kGoodweatherBits;
     if (valueRPT == repeatIRwNumber)
@@ -840,7 +840,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_INAX
   if (strcmp(protocol_name, "INAX") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kInaxBits;
     if (valueRPT == repeatIRwNumber)
@@ -851,7 +851,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DAIKIN160
   if (strcmp(protocol_name, "DAIKIN160") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDaikin160StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -862,7 +862,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_NEOCLIMA
   if (strcmp(protocol_name, "NEOCLIMA") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kNeoclimaStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -873,7 +873,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DAIKIN176
   if (strcmp(protocol_name, "DAIKIN176") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDaikin176StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -884,7 +884,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DAIKIN128
   if (strcmp(protocol_name, "DAIKIN128") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDaikin128StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -895,7 +895,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_AMCOR
   if (strcmp(protocol_name, "AMCOR") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kAmcorStateLength;
     if (valueRPT == repeatIRwNumber)
@@ -906,7 +906,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DAIKIN152
   if (strcmp(protocol_name, "DAIKIN152") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDaikin152StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -917,7 +917,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MITSUBISHI136
   if (strcmp(protocol_name, "MITSUBISHI136") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMitsubishi136StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -928,7 +928,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MITSUBISHI112
   if (strcmp(protocol_name, "MITSUBISHI112") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kMitsubishi112StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -939,7 +939,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC424
   if (strcmp(protocol_name, "HITACHI_AC424") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHitachiAc424StateLength;
     if (valueRPT == repeatIRwNumber)
@@ -950,7 +950,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SONY_38K
   if (strcmp(protocol_name, "SONY_38K") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, (uint16_t)(kSonyMinRepeat + 1));
     if (valueBITS == 0)
@@ -961,7 +961,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_EPSON
   if (strcmp(protocol_name, "EPSON") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kEpsonMinRepeat);
     if (valueBITS == 0)
@@ -972,7 +972,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SYMPHONY
   if (strcmp(protocol_name, "SYMPHONY") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kSymphonyDefaultRepeat);
     if (valueBITS == 0)
@@ -983,18 +983,18 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC3
   if (strcmp(protocol_name, "HITACHI_AC3") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kHitachiAcDefaultRepeat);
     if (valueBITS == 0)
-      Log.error(F("For this protocol you should have a BIT number as there is no default one defined" CR));
+      THEENGS_LOG_ERROR(F("For this protocol you should have a BIT number as there is no default one defined" CR));
     irsend.sendHitachiAc3(dataarray, valueBITS, valueRPT);
     return true;
   }
 #  endif
 #  ifdef IR_DAIKIN64
   if (strcmp(protocol_name, "DAIKIN64") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kDaikin64DefaultRepeat);
     if (valueBITS == 0)
@@ -1005,7 +1005,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_AIRWELL
   if (strcmp(protocol_name, "AIRWELL") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kAirwellMinRepeats);
     if (valueBITS == 0)
@@ -1016,7 +1016,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DELONGHI_AC
   if (strcmp(protocol_name, "DELONGHI_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kDelonghiAcDefaultRepeat);
     if (valueBITS == 0)
@@ -1027,7 +1027,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_DOSHISHA
   if (strcmp(protocol_name, "DOSHISHA") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kDoshishaBits;
     irsend.sendDoshisha(data, valueBITS, valueRPT);
@@ -1036,7 +1036,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_CARRIER_AC40
   if (strcmp(protocol_name, "CARRIER_AC40") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kCarrierAc40MinRepeat);
     if (valueBITS == 0)
@@ -1047,7 +1047,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_CARRIER_AC64
   if (strcmp(protocol_name, "CARRIER_AC64") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kCarrierAc64MinRepeat);
     if (valueBITS == 0)
@@ -1058,7 +1058,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC344
   if (strcmp(protocol_name, "HITACHI_AC344") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHitachiAc344StateLength;
     irsend.sendHitachiAc344(dataarray, valueBITS, valueRPT);
@@ -1067,7 +1067,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_CORONA_AC
   if (strcmp(protocol_name, "CORONA_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kCoronaAcStateLength;
     irsend.sendCoronaAc(dataarray, valueBITS, valueRPT);
@@ -1076,7 +1076,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MIDEA24
   if (strcmp(protocol_name, "MIDEA24") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kMidea24MinRepeat);
     if (valueBITS == 0)
@@ -1087,7 +1087,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_ZEPEAL
   if (strcmp(protocol_name, "EPEAL") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kZepealMinRepeat);
     if (valueBITS == 0)
@@ -1098,7 +1098,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SANYO_AC
   if (strcmp(protocol_name, "SANYO_AC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kSanyoAcStateLength;
     irsend.sendSanyoAc(dataarray, valueBITS, valueRPT);
@@ -1107,7 +1107,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_VOLTAS
   if (strcmp(protocol_name, "VOLTAS") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kVoltasStateLength;
     irsend.sendVoltas(dataarray, valueBITS, valueRPT);
@@ -1116,7 +1116,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_METZ
   if (strcmp(protocol_name, "METZ") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kMetzMinRepeat);
     if (valueBITS == 0)
@@ -1127,7 +1127,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TRANSCOLD
   if (strcmp(protocol_name, "TRANSCOLD") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kTranscoldDefaultRepeat);
     if (valueBITS == 0)
@@ -1138,7 +1138,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TECHNIBEL_AC
   if (strcmp(protocol_name, "TECHNIBELAC") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kTechnibelAcDefaultRepeat);
     if (valueBITS == 0)
@@ -1149,7 +1149,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MIRAGE
   if (strcmp(protocol_name, "MIRAGE") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kMirageMinRepeat);
     if (valueBITS == 0)
@@ -1160,7 +1160,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_ELITESCREENS
   if (strcmp(protocol_name, "ELITESCREENS") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kEliteScreensDefaultRepeat);
     if (valueBITS == 0)
@@ -1171,7 +1171,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_PANASONIC_AC32
   if (strcmp(protocol_name, "PANASONIC_AC32") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kPioneerBits;
     irsend.sendPanasonicAC32(data, valueBITS, valueRPT);
@@ -1180,7 +1180,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_MILESTAG2
   if (strcmp(protocol_name, "MILESTAG2") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueRPT == repeatIRwNumber)
       valueRPT = std::max(valueRPT, kMilesMinRepeat);
     if (valueBITS == 0)
@@ -1191,7 +1191,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_ECOCLIM
   if (strcmp(protocol_name, "ECOCLIM") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kEcoclimBits;
     irsend.sendEcoclim(data, valueBITS, valueRPT);
@@ -1200,7 +1200,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_XMP
   if (strcmp(protocol_name, "XMP") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kXmpBits;
     irsend.sendXmp(data, valueBITS, valueRPT);
@@ -1209,7 +1209,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_KELON168
   if (strcmp(protocol_name, "KELON168") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kKelon168Bits;
     irsend.sendKelon168(dataarray, valueBITS, valueRPT);
@@ -1218,7 +1218,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TEKNOPOINT
   if (strcmp(protocol_name, "TEKNOPOINT") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kTeknopointBits;
     irsend.sendTeknopoint(dataarray, valueBITS, valueRPT);
@@ -1227,7 +1227,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HAIER_AC176
   if (strcmp(protocol_name, "HAIER_AC176") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHaierAC176Bits;
     irsend.sendHaierAC176(dataarray, valueBITS, valueRPT);
@@ -1236,7 +1236,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_BOSE
   if (strcmp(protocol_name, "BOSE") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kBoseBits;
     irsend.sendBose(data, valueBITS, valueRPT);
@@ -1245,7 +1245,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_SANYO_AC88
   if (strcmp(protocol_name, "SANYO_AC88") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kSanyoAc88Bits;
     irsend.sendSanyoAc88(dataarray, valueBITS, valueRPT);
@@ -1254,7 +1254,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_TROTEC_3550
   if (strcmp(protocol_name, "TROTEC_3550") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kTrotecBits;
     irsend.sendTrotec3550(dataarray, valueBITS, valueRPT);
@@ -1263,7 +1263,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_ARRIS
   if (strcmp(protocol_name, "ARRIS") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kArrisBits;
     irsend.sendArris(data, valueBITS, valueRPT);
@@ -1272,7 +1272,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_RHOSS
   if (strcmp(protocol_name, "RHOSS") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kRhossBits;
     irsend.sendRhoss(dataarray, valueBITS, valueRPT);
@@ -1281,7 +1281,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_AIRTON
   if (strcmp(protocol_name, "AIRTON") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kAirtonBits;
     irsend.sendAirton(data, valueBITS, valueRPT);
@@ -1290,7 +1290,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_COOLIX48
   if (strcmp(protocol_name, "COOLIX48") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kCoolix48Bits;
     irsend.sendCoolix48(data, valueBITS, valueRPT);
@@ -1299,7 +1299,7 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC264
   if (strcmp(protocol_name, "HITACHI_AC264") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHitachiAc264Bits;
     irsend.sendHitachiAc264(dataarray, valueBITS, valueRPT);
@@ -1308,14 +1308,14 @@ bool sendIdentifiedProtocol(const char* protocol_name, uint64_t data, const char
 #  endif
 #  ifdef IR_HITACHI_AC296
   if (strcmp(protocol_name, "HITACHI_AC296") == 0) {
-    Log.notice(F("Sending IR signal with %s" CR), protocol_name);
+    THEENGS_LOG_NOTICE(F("Sending IR signal with %s" CR), protocol_name);
     if (valueBITS == 0)
       valueBITS = kHitachiAc296Bits;
     irsend.sendHitachiAc296(dataarray, valueBITS, valueRPT);
     return true;
   }
 #  endif
-  Log.warning(F("Unknown IR protocol" CR));
+  THEENGS_LOG_WARNING(F("Unknown IR protocol" CR));
   return false;
 }
 #endif
diff --git a/main/gatewayLORA.cpp b/main/gatewayLORA.cpp
index 56b4c05..b37763e 100644
--- a/main/gatewayLORA.cpp
+++ b/main/gatewayLORA.cpp
@@ -67,7 +67,7 @@ static LORAdevice NO_LORA_DEVICE_FOUND = {{0},
 
 LORAdevice* getDeviceById(const char* id); // Declared here to avoid pre-compilation issue (misplaced auto declaration by pio)
 LORAdevice* getDeviceById(const char* id) {
-  Log.trace(F("getDeviceById %s" CR), id);
+  THEENGS_LOG_TRACE(F("getDeviceById %s" CR), id);
 
   for (std::vector<LORAdevice*>::iterator it = LORAdevices.begin(); it != LORAdevices.end(); ++it) {
     if ((strcmp((*it)->uniqueId, id) == 0)) {
@@ -80,34 +80,34 @@ LORAdevice* getDeviceById(const char* id) {
 void dumpLORADevices() {
   for (std::vector<LORAdevice*>::iterator it = LORAdevices.begin(); it != LORAdevices.end(); ++it) {
     LORAdevice* p = *it;
-    Log.trace(F("uniqueId %s" CR), p->uniqueId);
-    Log.trace(F("modelName %s" CR), p->modelName);
-    Log.trace(F("isDisc %d" CR), p->isDisc);
+    THEENGS_LOG_TRACE(F("uniqueId %s" CR), p->uniqueId);
+    THEENGS_LOG_TRACE(F("modelName %s" CR), p->modelName);
+    THEENGS_LOG_TRACE(F("isDisc %d" CR), p->isDisc);
   }
 }
 
 void createOrUpdateDeviceLORA(const char* id, const char* model, uint8_t flags) {
   if (xSemaphoreTake(semaphorecreateOrUpdateDeviceLORA, pdMS_TO_TICKS(30000)) == pdFALSE) {
-    Log.error(F("[LORA] semaphorecreateOrUpdateDeviceLORA Semaphore NOT taken" CR));
+    THEENGS_LOG_ERROR(F("[LORA] semaphorecreateOrUpdateDeviceLORA Semaphore NOT taken" CR));
     return;
   }
 
   LORAdevice* device = getDeviceById(id);
   if (device == &NO_LORA_DEVICE_FOUND) {
-    Log.trace(F("add %s" CR), id);
+    THEENGS_LOG_TRACE(F("add %s" CR), id);
     //new device
     device = new LORAdevice();
     if (strlcpy(device->uniqueId, id, uniqueIdSize) > uniqueIdSize) {
-      Log.warning(F("[LORA] Device id %s exceeds available space" CR), id); // Remove from production release ?
+      THEENGS_LOG_WARNING(F("[LORA] Device id %s exceeds available space" CR), id); // Remove from production release ?
     };
     if (strlcpy(device->modelName, model, modelNameSize) > modelNameSize) {
-      Log.warning(F("[LORA] Device model %s exceeds available space" CR), id); // Remove from production release ?
+      THEENGS_LOG_WARNING(F("[LORA] Device model %s exceeds available space" CR), id); // Remove from production release ?
     };
     device->isDisc = flags & device_flags_isDisc;
     LORAdevices.push_back(device);
     newLORADevices++;
   } else {
-    Log.trace(F("update %s" CR), id);
+    THEENGS_LOG_TRACE(F("update %s" CR), id);
 
     if (flags & device_flags_isDisc) {
       device->isDisc = true;
@@ -123,7 +123,7 @@ void launchLORADiscovery(bool overrideDiscovery) {
   if (!overrideDiscovery && newLORADevices == 0)
     return;
   if (xSemaphoreTake(semaphorecreateOrUpdateDeviceLORA, pdMS_TO_TICKS(QueueSemaphoreTimeOutLoop)) == pdFALSE) {
-    Log.error(F("[LORA] semaphorecreateOrUpdateDeviceLORA Semaphore NOT taken" CR));
+    THEENGS_LOG_ERROR(F("[LORA] semaphorecreateOrUpdateDeviceLORA Semaphore NOT taken" CR));
     return;
   }
   newLORADevices = 0;
@@ -131,7 +131,7 @@ void launchLORADiscovery(bool overrideDiscovery) {
   xSemaphoreGive(semaphorecreateOrUpdateDeviceLORA);
   for (std::vector<LORAdevice*>::iterator it = localDevices.begin(); it != localDevices.end(); ++it) {
     LORAdevice* pdevice = *it;
-    Log.trace(F("Device id %s" CR), pdevice->uniqueId);
+    THEENGS_LOG_TRACE(F("Device id %s" CR), pdevice->uniqueId);
     // Do not launch discovery for the LORAdevices already discovered (unless we have overrideDiscovery) or that are not unique by their MAC Address (Ibeacon, GAEN and Microsoft Cdp)
     if (overrideDiscovery || !isDiscovered(pdevice)) {
       size_t numRows = sizeof(LORAparameters) / sizeof(LORAparameters[0]);
@@ -140,7 +140,7 @@ void launchLORADiscovery(bool overrideDiscovery) {
           // Remove the key from the unique id to extract the device id
           String idWoKey = pdevice->uniqueId;
           idWoKey.remove(idWoKey.length() - (strlen(LORAparameters[i][0]) + 1));
-          Log.trace(F("idWoKey %s" CR), idWoKey.c_str());
+          THEENGS_LOG_TRACE(F("idWoKey %s" CR), idWoKey.c_str());
           String value_template = "{{ value_json." + String(LORAparameters[i][0]) + " | is_defined }}";
 
           String topic = idWoKey;
@@ -161,10 +161,10 @@ void launchLORADiscovery(bool overrideDiscovery) {
         }
       }
       if (!pdevice->isDisc) {
-        Log.trace(F("Device id %s was not discovered" CR), pdevice->uniqueId); // Remove from production release ?
+        THEENGS_LOG_TRACE(F("Device id %s was not discovered" CR), pdevice->uniqueId); // Remove from production release ?
       }
     } else {
-      Log.trace(F("Device already discovered or that doesn't require discovery %s" CR), pdevice->uniqueId);
+      THEENGS_LOG_TRACE(F("Device already discovered or that doesn't require discovery %s" CR), pdevice->uniqueId);
     }
   }
 }
@@ -298,21 +298,21 @@ void LORAConfig_load() {
   if (preferences.isKey("LORAConfig")) {
     auto error = deserializeJson(jsonBuffer, preferences.getString("LORAConfig", "{}"));
     preferences.end();
-    Log.notice(F("LORA Config loaded" CR));
+    THEENGS_LOG_NOTICE(F("LORA Config loaded" CR));
     if (error) {
-      Log.error(F("LORA Config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+      THEENGS_LOG_ERROR(F("LORA Config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
       return;
     }
     if (jsonBuffer.isNull()) {
-      Log.warning(F("LORA Config is null" CR));
+      THEENGS_LOG_WARNING(F("LORA Config is null" CR));
       return;
     }
     JsonObject jo = jsonBuffer.as<JsonObject>();
     LORAConfig_fromJson(jo);
-    Log.notice(F("LORA Config loaded" CR));
+    THEENGS_LOG_NOTICE(F("LORA Config loaded" CR));
   } else {
     preferences.end();
-    Log.notice(F("LORA Config not found" CR));
+    THEENGS_LOG_NOTICE(F("LORA Config not found" CR));
   }
 }
 
@@ -332,7 +332,7 @@ void LORAConfig_fromJson(JsonObject& LORAdata) {
   if (LORAdata.containsKey("syncword")) {
     String syncWordStr = LORAdata["syncword"].as<String>();
     LORAConfig.syncWord = hexStringToByte(syncWordStr);
-    Log.notice(F("Config syncword changed: %d" CR), LORAConfig.syncWord);
+    THEENGS_LOG_NOTICE(F("Config syncword changed: %d" CR), LORAConfig.syncWord);
   }
   Config_update(LORAdata, "enablecrc", LORAConfig.crc);
   Config_update(LORAdata, "invertiq", LORAConfig.invertIQ);
@@ -352,11 +352,11 @@ void LORAConfig_fromJson(JsonObject& LORAdata) {
     preferences.begin(Gateway_Short_Name, false);
     if (preferences.isKey("LORAConfig")) {
       int result = preferences.remove("LORAConfig");
-      Log.notice(F("LORA config erase result: %d" CR), result);
+      THEENGS_LOG_NOTICE(F("LORA config erase result: %d" CR), result);
       preferences.end();
       return; // Erase prevails on save, so skipping save
     } else {
-      Log.notice(F("LORA config not found" CR));
+      THEENGS_LOG_NOTICE(F("LORA config not found" CR));
       preferences.end();
     }
   }
@@ -370,7 +370,7 @@ void LORAConfig_fromJson(JsonObject& LORAdata) {
     jo["codingrate"] = LORAConfig.codingRateDenominator;
     jo["preamblelength"] = LORAConfig.preambleLength;
     if (LORAConfig.syncWord < 0 || LORAConfig.syncWord > 255) {
-      Log.error(F("Invalid syncWord value: %d" CR), LORAConfig.syncWord);
+      THEENGS_LOG_ERROR(F("Invalid syncWord value: %d" CR), LORAConfig.syncWord);
     } else {
       char syncWordHex[5];
       snprintf(syncWordHex, sizeof(syncWordHex), "0x%02X", LORAConfig.syncWord);
@@ -385,7 +385,7 @@ void LORAConfig_fromJson(JsonObject& LORAdata) {
     preferences.begin(Gateway_Short_Name, false);
     int result = preferences.putString("LORAConfig", conf);
     preferences.end();
-    Log.notice(F("LORA Config_save: %s, result: %d" CR), conf.c_str(), result);
+    THEENGS_LOG_NOTICE(F("LORA Config_save: %s, result: %d" CR), conf.c_str(), result);
   }
 }
 
@@ -396,7 +396,7 @@ void setupLORA() {
   semaphorecreateOrUpdateDeviceLORA = xSemaphoreCreateBinary();
   xSemaphoreGive(semaphorecreateOrUpdateDeviceLORA);
 #  endif
-  Log.notice(F("LORA Frequency: %d" CR), LORAConfig.frequency);
+  THEENGS_LOG_NOTICE(F("LORA Frequency: %d" CR), LORAConfig.frequency);
 #  ifdef ESP8266
   SPI.begin();
 #  else
@@ -406,17 +406,17 @@ void setupLORA() {
   LoRa.setPins(LORA_SS, LORA_RST, LORA_DI0);
 
   if (!LoRa.begin(LORAConfig.frequency)) {
-    Log.error(F("gatewayLORA setup failed!" CR));
+    THEENGS_LOG_ERROR(F("gatewayLORA setup failed!" CR));
     while (1);
   }
   LoRa.receive();
-  Log.notice(F("LORA_SCK: %d" CR), LORA_SCK);
-  Log.notice(F("LORA_MISO: %d" CR), LORA_MISO);
-  Log.notice(F("LORA_MOSI: %d" CR), LORA_MOSI);
-  Log.notice(F("LORA_SS: %d" CR), LORA_SS);
-  Log.notice(F("LORA_RST: %d" CR), LORA_RST);
-  Log.notice(F("LORA_DI0: %d" CR), LORA_DI0);
-  Log.trace(F("gatewayLORA setup done" CR));
+  THEENGS_LOG_NOTICE(F("LORA_SCK: %d" CR), LORA_SCK);
+  THEENGS_LOG_NOTICE(F("LORA_MISO: %d" CR), LORA_MISO);
+  THEENGS_LOG_NOTICE(F("LORA_MOSI: %d" CR), LORA_MOSI);
+  THEENGS_LOG_NOTICE(F("LORA_SS: %d" CR), LORA_SS);
+  THEENGS_LOG_NOTICE(F("LORA_RST: %d" CR), LORA_RST);
+  THEENGS_LOG_NOTICE(F("LORA_DI0: %d" CR), LORA_DI0);
+  THEENGS_LOG_TRACE(F("gatewayLORA setup done" CR));
 }
 
 void LORAtoX() {
@@ -424,7 +424,7 @@ void LORAtoX() {
   if (packetSize) {
     StaticJsonDocument<JSON_MSG_BUFFER> LORAdataBuffer;
     JsonObject LORAdata = LORAdataBuffer.to<JsonObject>();
-    Log.trace(F("Rcv. LORA" CR));
+    THEENGS_LOG_TRACE(F("Rcv. LORA" CR));
 #  ifdef ESP32
     String taskMessage = "LORA Task running on core ";
     taskMessage = taskMessage + xPortGetCoreID();
@@ -446,7 +446,7 @@ void LORAtoX() {
       _WiPhonetoX(packet, LORAdata);
     } else if (binary) {
       if (LORAConfig.onlyKnown) {
-        Log.trace(F("Ignoring non identifiable packet" CR));
+        THEENGS_LOG_TRACE(F("Ignoring non identifiable packet" CR));
         return;
       }
       // We have non-ascii data: create hex string of the data
@@ -461,11 +461,11 @@ void LORAtoX() {
       std::string packetStrStd = (char*)packet;
       auto result = deserializeJson(LORAdataBuffer, packetStrStd);
       if (result) {
-        Log.notice(F("LORA packet deserialization failed, not a json, sending raw message" CR));
+        THEENGS_LOG_NOTICE(F("LORA packet deserialization failed, not a json, sending raw message" CR));
         LORAdata = LORAdataBuffer.to<JsonObject>();
         LORAdata["message"] = (char*)packet;
       } else {
-        Log.trace(F("LORA packet deserialization OK" CR));
+        THEENGS_LOG_TRACE(F("LORA packet deserialization OK" CR));
       }
     }
 
@@ -491,7 +491,7 @@ void LORAtoX() {
 
     enqueueJsonObject(LORAdata);
     if (repeatLORAwMQTT) {
-      Log.trace(F("Pub LORA for rpt" CR));
+      THEENGS_LOG_TRACE(F("Pub LORA for rpt" CR));
       LORAdata["origin"] = subjectMQTTtoLORA;
       enqueueJsonObject(LORAdata);
     }
@@ -501,7 +501,7 @@ void LORAtoX() {
 #  if jsonReceiving
 void XtoLORA(const char* topicOri, JsonObject& LORAdata) { // json object decoding
   if (cmpToMainTopic(topicOri, subjectMQTTtoLORA)) {
-    Log.trace(F("MQTTtoLORA json" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoLORA json" CR));
     const char* message = LORAdata["message"];
     const char* hex = LORAdata["hex"];
     LORAConfig_fromJson(LORAdata);
@@ -521,16 +521,16 @@ void XtoLORA(const char* topicOri, JsonObject& LORAdata) { // json object decodi
       }
 
       LoRa.endPacket();
-      Log.trace(F("MQTTtoLORA OK" CR));
+      THEENGS_LOG_TRACE(F("MQTTtoLORA OK" CR));
       // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
       LORAdata["origin"] = subjectGTWLORAtoMQTT;
       enqueueJsonObject(LORAdata);
     } else {
-      Log.error(F("MQTTtoLORA Fail json" CR));
+      THEENGS_LOG_ERROR(F("MQTTtoLORA Fail json" CR));
     }
   }
   if (cmpToMainTopic(topicOri, subjectMQTTtoLORAset)) {
-    Log.trace(F("MQTTtoLORA json set" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoLORA json set" CR));
     /*
      * Configuration modifications priorities:
      *  First `init=true` and `load=true` commands are executed (if both are present, INIT prevails on LOAD)
@@ -557,7 +557,7 @@ void XtoLORA(const char* topicOri, const char* LORAarray) { // json object decod
     LoRa.beginPacket();
     LoRa.print(LORAarray);
     LoRa.endPacket();
-    Log.notice(F("MQTTtoLORA OK" CR));
+    THEENGS_LOG_NOTICE(F("MQTTtoLORA OK" CR));
     // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
     pub(subjectGTWLORAtoMQTT, LORAarray);
   }
@@ -574,7 +574,7 @@ String stateLORAMeasures() {
   LORAdata["codingrate"] = LORAConfig.codingRateDenominator;
   LORAdata["preamblelength"] = LORAConfig.preambleLength;
   if (LORAConfig.syncWord < 0 || LORAConfig.syncWord > 255) {
-    Log.error(F("Invalid syncWord value: %d" CR), LORAConfig.syncWord);
+    THEENGS_LOG_ERROR(F("Invalid syncWord value: %d" CR), LORAConfig.syncWord);
   } else {
     char syncWordHex[5];
     snprintf(syncWordHex, sizeof(syncWordHex), "0x%02X", LORAConfig.syncWord);
diff --git a/main/gatewayPilight.cpp b/main/gatewayPilight.cpp
index cbd97ae..ef9f2cd 100644
--- a/main/gatewayPilight.cpp
+++ b/main/gatewayPilight.cpp
@@ -57,7 +57,7 @@ void enableActiveReceiver();
 void pilightCallback(const String& protocol, const String& message, int status,
                      size_t repeats, const String& deviceID) {
   if (status == VALID) {
-    Log.trace(F("Creating RF PiLight buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating RF PiLight buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> RFPiLightdataBuffer;
     JsonObject RFPiLightdata = RFPiLightdataBuffer.to<JsonObject>();
     StaticJsonDocument<JSON_MSG_BUFFER> jsonBuffer2;
@@ -66,7 +66,7 @@ void pilightCallback(const String& protocol, const String& message, int status,
     if (message.length() > 0) {
       auto error = deserializeJson(jsonBuffer2, message);
       if (error) {
-        Log.error(F("deserializeJson() failed: %s" CR), error.c_str());
+        THEENGS_LOG_ERROR(F("deserializeJson() failed: %s" CR), error.c_str());
         return;
       }
       RFPiLightdata["message"] = msg;
@@ -98,7 +98,7 @@ void pilightCallback(const String& protocol, const String& message, int status,
     RFPiLightdata["origin"] = subjectPilighttoMQTT;
     enqueueJsonObject(RFPiLightdata);
     if (repeatPilightwMQTT) {
-      Log.trace(F("Pub Pilight for rpt" CR));
+      THEENGS_LOG_TRACE(F("Pub Pilight for rpt" CR));
       RFPiLightdata["origin"] = subjectMQTTtoPilight;
       enqueueJsonObject(RFPiLightdata);
     }
@@ -110,7 +110,7 @@ void pilightRawCallback(const uint16_t* pulses, size_t length) {
   uint16_t pulse;
 
   if (!pilightRawEnabled) {
-    Log.trace(F("Pilight RAW not enabled" CR));
+    THEENGS_LOG_TRACE(F("Pilight RAW not enabled" CR));
     return;
   }
 
@@ -128,13 +128,13 @@ void pilightRawCallback(const uint16_t* pulses, size_t length) {
 #  endif
 
 void savePilightConfig() {
-  Log.trace(F("saving Pilight config" CR));
+  THEENGS_LOG_TRACE(F("saving Pilight config" CR));
   DynamicJsonDocument json(4096);
   deserializeJson(json, rf.enabledProtocols());
 
   File configFile = SPIFFS.open("/pilight.json", "w");
   if (!configFile) {
-    Log.error(F("failed to open config file for writing" CR));
+    THEENGS_LOG_ERROR(F("failed to open config file for writing" CR));
   }
 
   serializeJsonPretty(json, Serial);
@@ -143,14 +143,14 @@ void savePilightConfig() {
 }
 
 void loadPilightConfig() {
-  Log.trace(F("reading Pilight config file" CR));
+  THEENGS_LOG_TRACE(F("reading Pilight config file" CR));
   File configFile = SPIFFS.open("/pilight.json", "r");
   if (configFile) {
-    Log.trace(F("opened Pilight config file" CR));
+    THEENGS_LOG_TRACE(F("opened Pilight config file" CR));
     DynamicJsonDocument json(configFile.size() * 4);
     auto error = deserializeJson(json, configFile);
     if (error) {
-      Log.error(F("deserialize config failed: %s, buffer capacity: %u" CR), error.c_str(), json.capacity());
+      THEENGS_LOG_ERROR(F("deserialize config failed: %s, buffer capacity: %u" CR), error.c_str(), json.capacity());
     }
     serializeJson(json, Serial);
     if (!json.isNull()) {
@@ -158,7 +158,7 @@ void loadPilightConfig() {
       serializeJson(json, rflimit);
       rf.limitProtocols(rflimit);
     } else {
-      Log.warning(F("failed to load json config" CR));
+      THEENGS_LOG_WARNING(F("failed to load json config" CR));
     }
     configFile.close();
   }
@@ -184,16 +184,16 @@ void XtoPilight(const char* topicOri, JsonObject& Pilightdata) {
       success = true;
     }
     if (Pilightdata.containsKey("enabled")) {
-      Log.notice(F("PiLight protocols enabled: %s" CR), rf.enabledProtocols().c_str());
+      THEENGS_LOG_NOTICE(F("PiLight protocols enabled: %s" CR), rf.enabledProtocols().c_str());
       success = true;
     }
     if (Pilightdata.containsKey("available")) {
-      Log.notice(F("PiLight protocols available: %s" CR), rf.availableProtocols().c_str());
+      THEENGS_LOG_NOTICE(F("PiLight protocols available: %s" CR), rf.availableProtocols().c_str());
       success = true;
     }
 #  ifdef Pilight_rawEnabled
     if (Pilightdata.containsKey("rawEnabled")) {
-      Log.notice(F("Setting PiLight raw output enabled: %T" CR), (bool)Pilightdata["rawEnabled"]);
+      THEENGS_LOG_NOTICE(F("Setting PiLight raw output enabled: %T" CR), (bool)Pilightdata["rawEnabled"]);
       pilightRawEnabled = (bool)Pilightdata["rawEnabled"];
       if (currentReceiver == ACTIVE_PILIGHT) {
         disablePilightReceive();
@@ -210,13 +210,13 @@ void XtoPilight(const char* topicOri, JsonObject& Pilightdata) {
       enqueueJsonObject(Pilightdata);
     } else {
       pub(subjectGTWPilighttoMQTT, "{\"Status\": \"Error\"}"); // Fail feedback
-      Log.error(F("MQTTtoPilightProtocol Fail json" CR));
+      THEENGS_LOG_ERROR(F("MQTTtoPilightProtocol Fail json" CR));
     }
   } else if (cmpToMainTopic(topicOri, subjectMQTTtoPilight)) {
     const char* message = Pilightdata["message"];
-    Log.notice(F("MQTTtoPilight message: %s" CR), message);
+    THEENGS_LOG_NOTICE(F("MQTTtoPilight message: %s" CR), message);
     const char* protocol = Pilightdata["protocol"];
-    Log.notice(F("MQTTtoPilight protocol: %s" CR), protocol);
+    THEENGS_LOG_NOTICE(F("MQTTtoPilight protocol: %s" CR), protocol);
     const char* raw = Pilightdata["raw"];
     float txFrequency = Pilightdata["frequency"] | RFConfig.frequency;
     bool success = false;
@@ -224,7 +224,7 @@ void XtoPilight(const char* topicOri, JsonObject& Pilightdata) {
     initCC1101();
 #  ifdef ZradioCC1101 // set Receive off and Transmitt on
     ELECHOUSE_cc1101.SetTx(txFrequency);
-    Log.notice(F("Transmit frequency: %F" CR), txFrequency);
+    THEENGS_LOG_NOTICE(F("Transmit frequency: %F" CR), txFrequency);
 #  endif
     pinMode(RF_EMITTER_GPIO, OUTPUT);
     if (raw) {
@@ -233,10 +233,10 @@ void XtoPilight(const char* topicOri, JsonObject& Pilightdata) {
       if (repeats < 0) {
         switch (repeats) {
           case ESPiLight::ERROR_INVALID_PULSETRAIN_MSG_R:
-            Log.trace(F("'r' not found in string, or has no data" CR));
+            THEENGS_LOG_TRACE(F("'r' not found in string, or has no data" CR));
             break;
           case ESPiLight::ERROR_INVALID_PULSETRAIN_MSG_END:
-            Log.trace(F("';' or '@' not found in data string" CR));
+            THEENGS_LOG_TRACE(F("';' or '@' not found in data string" CR));
             break;
         }
         repeats = 10;
@@ -244,73 +244,73 @@ void XtoPilight(const char* topicOri, JsonObject& Pilightdata) {
       int msgLength = rf.stringToPulseTrain(raw, codes, MAXPULSESTREAMLENGTH);
       if (msgLength > 0) {
         rf.sendPulseTrain(codes, msgLength, repeats);
-        Log.notice(F("MQTTtoPilight raw ok" CR));
+        THEENGS_LOG_NOTICE(F("MQTTtoPilight raw ok" CR));
         success = true;
       } else {
-        Log.trace(F("MQTTtoPilight raw KO" CR));
+        THEENGS_LOG_TRACE(F("MQTTtoPilight raw KO" CR));
         switch (msgLength) {
           case ESPiLight::ERROR_INVALID_PULSETRAIN_MSG_C:
-            Log.trace(F("'c' not found in string, or has no data" CR));
+            THEENGS_LOG_TRACE(F("'c' not found in string, or has no data" CR));
             break;
           case ESPiLight::ERROR_INVALID_PULSETRAIN_MSG_P:
-            Log.trace(F("'p' not found in string, or has no data" CR));
+            THEENGS_LOG_TRACE(F("'p' not found in string, or has no data" CR));
             break;
           case ESPiLight::ERROR_INVALID_PULSETRAIN_MSG_END:
-            Log.trace(F("';' or '@' not found in data string" CR));
+            THEENGS_LOG_TRACE(F("';' or '@' not found in data string" CR));
             break;
           case ESPiLight::ERROR_INVALID_PULSETRAIN_MSG_TYPE:
-            Log.trace(F("pulse type not defined" CR));
+            THEENGS_LOG_TRACE(F("pulse type not defined" CR));
             break;
         }
-        Log.error(F("Invalid JSON: raw data malformed" CR));
+        THEENGS_LOG_ERROR(F("Invalid JSON: raw data malformed" CR));
       }
     }
     if (message && protocol) {
-      Log.trace(F("MQTTtoPilight msg & protocol ok" CR));
+      THEENGS_LOG_TRACE(F("MQTTtoPilight msg & protocol ok" CR));
       int msgLength = rf.send(protocol, message);
       if (msgLength > 0) {
-        Log.trace(F("Adv data XtoPilight push state via PilighttoMQTT" CR));
+        THEENGS_LOG_TRACE(F("Adv data XtoPilight push state via PilighttoMQTT" CR));
         // Acknowledgement
         pub(subjectGTWPilighttoMQTT, message);
         success = true;
       } else {
         switch (msgLength) {
           case ESPiLight::ERROR_UNAVAILABLE_PROTOCOL:
-            Log.error(F("protocol is not available" CR));
+            THEENGS_LOG_ERROR(F("protocol is not available" CR));
             break;
           case ESPiLight::ERROR_INVALID_PILIGHT_MSG:
-            Log.error(F("message is invalid" CR));
+            THEENGS_LOG_ERROR(F("message is invalid" CR));
             break;
           case ESPiLight::ERROR_INVALID_JSON:
-            Log.error(F("message is not a proper json object" CR));
+            THEENGS_LOG_ERROR(F("message is not a proper json object" CR));
             break;
           case ESPiLight::ERROR_NO_OUTPUT_PIN:
-            Log.error(F("no transmitter pin" CR));
+            THEENGS_LOG_ERROR(F("no transmitter pin" CR));
             break;
           default:
-            Log.error(F("Invalid JSON: can't read message/protocol" CR));
+            THEENGS_LOG_ERROR(F("Invalid JSON: can't read message/protocol" CR));
         }
       }
     }
     if (!success) {
       pub(subjectGTWPilighttoMQTT, "{\"Status\": \"Error\"}"); // Fail feedback
-      Log.error(F("MQTTtoPilight Fail json" CR));
+      THEENGS_LOG_ERROR(F("MQTTtoPilight Fail json" CR));
     }
     enableActiveReceiver();
   }
 }
 
 extern void disablePilightReceive() {
-  Log.trace(F("disablePilightReceive" CR));
+  THEENGS_LOG_TRACE(F("disablePilightReceive" CR));
   rf.initReceiver(-1);
   rf.disableReceiver();
 };
 
 extern void enablePilightReceive() {
-  Log.notice(F("Switching to Pilight Receiver: %F" CR), RFConfig.frequency);
-  Log.notice(F("RF_EMITTER_GPIO: %d " CR), RF_EMITTER_GPIO);
-  Log.notice(F("RF_RECEIVER_GPIO: %d " CR), RF_RECEIVER_GPIO);
-  Log.trace(F("gatewayPilight command topic: %s%s%s" CR), mqtt_topic, gateway_name, subjectMQTTtoPilight);
+  THEENGS_LOG_NOTICE(F("Switching to Pilight Receiver: %F" CR), RFConfig.frequency);
+  THEENGS_LOG_NOTICE(F("RF_EMITTER_GPIO: %d " CR), RF_EMITTER_GPIO);
+  THEENGS_LOG_NOTICE(F("RF_RECEIVER_GPIO: %d " CR), RF_RECEIVER_GPIO);
+  THEENGS_LOG_TRACE(F("gatewayPilight command topic: %s%s%s" CR), mqtt_topic, gateway_name, subjectMQTTtoPilight);
 
   initCC1101();
 
@@ -324,6 +324,6 @@ extern void enablePilightReceive() {
   pinMode(RF_EMITTER_GPIO, OUTPUT); // Set this here, because if this is the RX pin it was reset to INPUT by Serial.end();
   rf.enableReceiver();
   loadPilightConfig();
-  Log.trace(F("gatewayPilight setup done " CR));
+  THEENGS_LOG_TRACE(F("gatewayPilight setup done " CR));
 };
 #endif
diff --git a/main/gatewayRF.cpp b/main/gatewayRF.cpp
index c06a37c..54c113b 100644
--- a/main/gatewayRF.cpp
+++ b/main/gatewayRF.cpp
@@ -136,7 +136,7 @@ void announceGatewayTriggerTypeToHASS(uint64_t MQTTvalue) {
 #    else
   String discovery_topic = String(subjectRFtoMQTT);
 #    endif
-  Log.trace(F("[RF] Entity Discovered, create HA Discovery CFG" CR));
+  THEENGS_LOG_TRACE(F("[RF] Entity Discovered, create HA Discovery CFG" CR));
   announceGatewayTrigger(
       discovery_topic.c_str(), // topic
       "Received", // type
@@ -174,9 +174,9 @@ void RFtoX() {
     StaticJsonDocument<JSON_MSG_BUFFER> RFdataBuffer;
     JsonObject RFdata = RFdataBuffer.to<JsonObject>();
 #  ifdef ESP32
-    Log.trace(F("[RF] Rcv. RF - Task running on core :%d" CR), xPortGetCoreID());
+    THEENGS_LOG_TRACE(F("[RF] Rcv. RF - Task running on core :%d" CR), xPortGetCoreID());
 #  else
-    Log.trace(F("[RF] Rcv. RF" CR));
+    THEENGS_LOG_TRACE(F("[RF] Rcv. RF" CR));
 #  endif
     uint64_t MQTTvalue = mySwitch.getReceivedValue();
     int length = mySwitch.getReceivedBitlength();
@@ -214,15 +214,15 @@ void RFtoX() {
       RFdata["origin"] = subjectRFtoMQTT;
       enqueueJsonObject(RFdata);
       // Casting "receivedSignal[o].value" to (unsigned long) because ArduinoLog doesn't support uint64_t for ESP's
-      Log.trace(F("[RF] Store val: %u" CR), (unsigned long)MQTTvalue);
+      THEENGS_LOG_TRACE(F("[RF] Store val: %u" CR), (unsigned long)MQTTvalue);
       storeSignalValue(MQTTvalue);
       if (repeatRFwMQTT) {
-        Log.trace(F("[RF] Pub RF for rpt" CR));
+        THEENGS_LOG_TRACE(F("[RF] Pub RF for rpt" CR));
         RFdata["origin"] = subjectMQTTtoRF;
         enqueueJsonObject(RFdata);
       }
     } else {
-      Log.trace(F("[RF] RF signal received but already managed" CR));
+      THEENGS_LOG_TRACE(F("[RF] RF signal received but already managed" CR));
     }
   }
   // else {
@@ -254,7 +254,7 @@ void XtoRF(const char* topicOri, const char* datacallback) {
 #    ifdef ZradioCC1101 // set Receive off and Transmitt on
   disableCurrentReceiver();
   ELECHOUSE_cc1101.SetTx(RFConfig.frequency);
-  Log.notice(F("[RF] Transmit frequency: %F" CR), RFConfig.frequency);
+  THEENGS_LOG_NOTICE(F("[RF] Transmit frequency: %F" CR), RFConfig.frequency);
 #    endif
   mySwitch.disableReceive();
   mySwitch.enableTransmit(RF_EMITTER_GPIO);
@@ -284,20 +284,20 @@ void XtoRF(const char* topicOri, const char* datacallback) {
   }
 
   if ((cmpToMainTopic(topicOri, subjectMQTTtoRF)) && (valuePRT == 0) && (valuePLSL == 0) && (valueBITS == 0)) {
-    Log.trace(F("[RF] MQTTtoRF dflt" CR));
+    THEENGS_LOG_TRACE(F("[RF] MQTTtoRF dflt" CR));
     mySwitch.setProtocol(1, 350);
     mySwitch.send(data, 24);
     // Acknowledgement to the GTWRF topic
     pub(subjectGTWRFtoMQTT, datacallback);
   } else if ((valuePRT != 0) || (valuePLSL != 0) || (valueBITS != 0)) {
-    Log.trace(F("[RF] MQTTtoRF usr par." CR));
+    THEENGS_LOG_TRACE(F("[RF] MQTTtoRF usr par." CR));
     if (valuePRT == 0)
       valuePRT = 1;
     if (valuePLSL == 0)
       valuePLSL = 350;
     if (valueBITS == 0)
       valueBITS = 24;
-    Log.notice(F("[RF] Protocol: %d, Pulse Lgth: %d, Bits nb: %d" CR), valuePRT, valuePLSL, valueBITS);
+    THEENGS_LOG_NOTICE(F("[RF] Protocol: %d, Pulse Lgth: %d, Bits nb: %d" CR), valuePRT, valuePLSL, valueBITS);
     mySwitch.setProtocol(valuePRT, valuePLSL);
     mySwitch.send(data, valueBITS);
     // Acknowledgement to the GTWRF topic
@@ -335,29 +335,29 @@ void XtoRF(const char* topicOri, const char* datacallback) {
  */
 void XtoRF(const char* topicOri, JsonObject& RFdata) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoRF)) {
-    Log.trace(F("[RF] MQTTtoRF json" CR));
+    THEENGS_LOG_TRACE(F("[RF] MQTTtoRF json" CR));
     uint64_t data = RFdata["value"];
     if (data != 0) {
       int valuePRT = RFdata["protocol"] | 1;
       int valuePLSL = RFdata["delay"] | 350;
       int valueBITS = RFdata["length"] | 24;
       int valueRPT = RFdata["repeat"] | RF_EMITTER_REPEAT;
-      Log.notice(F("[RF] Protocol:%d, Pulse Lgth: %d, Bits nb: %d" CR), valuePRT, valuePLSL, valueBITS);
+      THEENGS_LOG_NOTICE(F("[RF] Protocol:%d, Pulse Lgth: %d, Bits nb: %d" CR), valuePRT, valuePLSL, valueBITS);
       disableCurrentReceiver();
 #    ifdef ZradioCC1101
       initCC1101();
       int txPower = RFdata["txpower"] | RF_CC1101_TXPOWER;
       ELECHOUSE_cc1101.setPA((int)txPower);
-      Log.notice(F("[RF] CC1101 TX Power: %d" CR), txPower);
+      THEENGS_LOG_NOTICE(F("[RF] CC1101 TX Power: %d" CR), txPower);
       float txFrequency = RFdata["frequency"] | RFConfig.frequency;
       ELECHOUSE_cc1101.SetTx(txFrequency);
-      Log.notice(F("[RF] Transmit frequency: %F" CR), txFrequency);
+      THEENGS_LOG_NOTICE(F("[RF] Transmit frequency: %F" CR), txFrequency);
 #    endif
       mySwitch.enableTransmit(RF_EMITTER_GPIO);
       mySwitch.setRepeatTransmit(valueRPT);
       mySwitch.setProtocol(valuePRT, valuePLSL);
       mySwitch.send(data, valueBITS);
-      Log.notice(F("[RF] MQTTtoRF OK" CR));
+      THEENGS_LOG_NOTICE(F("[RF] MQTTtoRF OK" CR));
       // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
       RFdata["origin"] = subjectGTWRFtoMQTT;
       enqueueJsonObject(RFdata);
@@ -380,7 +380,7 @@ void XtoRF(const char* topicOri, JsonObject& RFdata) {
  * @note THIS SEEMS LIKE A DEAD CODE. THE FUNCTION IS NOT CALLED ANYWHERE.
  */
 void disableRFReceive() {
-  Log.trace(F("[RF] disable RFReceive %d" CR), RF_RECEIVER_GPIO);
+  THEENGS_LOG_TRACE(F("[RF] disable RFReceive %d" CR), RF_RECEIVER_GPIO);
   mySwitch.disableReceive();
 }
 
@@ -401,7 +401,7 @@ void enableRFReceive(
     float rfFrequency = RFConfig.frequency,
     int rfReceiverGPIO = RF_RECEIVER_GPIO,
     int rfEmitterGPIO = RF_EMITTER_GPIO) {
-  Log.notice(F("[RF] Enable RF Receiver: %fMhz, RF_EMITTER_GPIO: %d, RF_RECEIVER_GPIO: %d" CR), rfFrequency, rfEmitterGPIO, rfReceiverGPIO);
+  THEENGS_LOG_NOTICE(F("[RF] Enable RF Receiver: %fMhz, RF_EMITTER_GPIO: %d, RF_RECEIVER_GPIO: %d" CR), rfFrequency, rfEmitterGPIO, rfReceiverGPIO);
 
 #  ifdef RF_DISABLE_TRANSMIT
   mySwitch.disableTransmit();
@@ -412,7 +412,7 @@ void enableRFReceive(
   mySwitch.setRepeatTransmit(rfEmitterGPIO);
   mySwitch.enableReceive(rfReceiverGPIO);
 
-  Log.trace(F("[RF] Setup command topic: %s%s%s\n Setup done" CR), (const char*)mqtt_topic, (const char*)gateway_name, (const char*)subjectMQTTtoRF);
+  THEENGS_LOG_TRACE(F("[RF] Setup command topic: %s%s%s\n Setup done" CR), (const char*)mqtt_topic, (const char*)gateway_name, (const char*)subjectMQTTtoRF);
 }
 
 #endif
diff --git a/main/gatewayRF2.cpp b/main/gatewayRF2.cpp
index 2b2832d..e2286f7 100644
--- a/main/gatewayRF2.cpp
+++ b/main/gatewayRF2.cpp
@@ -68,7 +68,7 @@ extern String getUniqueId(String name, String sufix);
 
 //Register for autodiscover in Home Assistant
 void RF2toMQTTdiscovery(JsonObject& data) {
-  Log.trace(F("switchRF2Discovery" CR));
+  THEENGS_LOG_TRACE(F("switchRF2Discovery" CR));
   String payloadonstr;
   String payloadoffstr;
 
@@ -95,7 +95,7 @@ void RF2toMQTTdiscovery(JsonObject& data) {
   // component type,name,availability topic,device class,value template,payload
   // on, payload off, unit of measurement
 
-  Log.trace(F("CreateDiscoverySwitch: %s" CR), switchRF[1]);
+  THEENGS_LOG_TRACE(F("CreateDiscoverySwitch: %s" CR), switchRF[1]);
 
   // As RF2 433Mhz switches do not render their state, no state topic should be
   // provided in the discovery. This will cause the switch to be in optimistic
@@ -117,7 +117,7 @@ void RF2toX() {
     JsonObject RF2data = RF2dataBuffer.to<JsonObject>();
     rf2rd.hasNewData = false;
 
-    Log.trace(F("Rcv. RF2" CR));
+    THEENGS_LOG_TRACE(F("Rcv. RF2" CR));
     RF2data["unit"] = (int)rf2rd.unit;
     RF2data["groupBit"] = (int)rf2rd.groupBit;
     RF2data["period"] = (int)rf2rd.period;
@@ -149,10 +149,10 @@ void XtoRF2(const char* topicOri, const char* datacallback) {
   initCC1101();
   int txPower = RF_CC1101_TXPOWER;
   ELECHOUSE_cc1101.setPA((int)txPower);
-  Log.notice(F("[RF] CC1101 TX Power: %d" CR), txPower);
+  THEENGS_LOG_NOTICE(F("[RF] CC1101 TX Power: %d" CR), txPower);
   float txFrequency = RFConfig.frequency;
   ELECHOUSE_cc1101.SetTx(txFrequency);
-  Log.notice(F("[RF] Transmit frequency: %F" CR), txFrequency);
+  THEENGS_LOG_NOTICE(F("[RF] Transmit frequency: %F" CR), txFrequency);
 #    endif
 
   // RF DATA ANALYSIS
@@ -172,35 +172,35 @@ void XtoRF2(const char* topicOri, const char* datacallback) {
   if (pos != -1) {
     pos = pos + +strlen(RF2codeKey);
     valueCODE = (topic.substring(pos, pos + 8)).toInt();
-    Log.notice(F("RF2 code: %l" CR), valueCODE);
+    THEENGS_LOG_NOTICE(F("RF2 code: %l" CR), valueCODE);
   }
   int pos2 = topic.lastIndexOf(RF2periodKey);
   if (pos2 != -1) {
     pos2 = pos2 + strlen(RF2periodKey);
     valuePERIOD = (topic.substring(pos2, pos2 + 3)).toInt();
-    Log.notice(F("RF2 Period: %d" CR), valuePERIOD);
+    THEENGS_LOG_NOTICE(F("RF2 Period: %d" CR), valuePERIOD);
   }
   int pos3 = topic.lastIndexOf(RF2unitKey);
   if (pos3 != -1) {
     pos3 = pos3 + strlen(RF2unitKey);
     valueUNIT = (topic.substring(pos3, topic.indexOf("/", pos3))).toInt();
-    Log.notice(F("Unit: %d" CR), valueUNIT);
+    THEENGS_LOG_NOTICE(F("Unit: %d" CR), valueUNIT);
   }
   int pos4 = topic.lastIndexOf(RF2groupKey);
   if (pos4 != -1) {
     pos4 = pos4 + strlen(RF2groupKey);
     valueGROUP = (topic.substring(pos4, pos4 + 1)).toInt();
-    Log.notice(F("RF2 Group: %d" CR), valueGROUP);
+    THEENGS_LOG_NOTICE(F("RF2 Group: %d" CR), valueGROUP);
   }
   int pos5 = topic.lastIndexOf(RF2dimKey);
   if (pos5 != -1) {
     isDimCommand = true;
     valueDIM = atoi(datacallback);
-    Log.notice(F("RF2 Dim: %d" CR), valueDIM);
+    THEENGS_LOG_NOTICE(F("RF2 Dim: %d" CR), valueDIM);
   }
 
   if ((topic == subjectMQTTtoRF2) || (valueCODE != 0) || (valueUNIT != -1) || (valuePERIOD != 0)) {
-    Log.trace(F("MQTTtoRF2" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoRF2" CR));
     if (valueCODE == 0)
       valueCODE = 8233378;
     if (valueUNIT == -1)
@@ -208,9 +208,9 @@ void XtoRF2(const char* topicOri, const char* datacallback) {
     if (valuePERIOD == 0)
       valuePERIOD = 272;
     NewRemoteReceiver::disable();
-    Log.trace(F("Creating transmitter" CR));
+    THEENGS_LOG_TRACE(F("Creating transmitter" CR));
     NewRemoteTransmitter transmitter(valueCODE, RF_EMITTER_GPIO, valuePERIOD, RF2_EMITTER_REPEAT);
-    Log.trace(F("Sending data" CR));
+    THEENGS_LOG_TRACE(F("Sending data" CR));
     if (valueGROUP) {
       if (isDimCommand) {
         transmitter.sendGroupDim(valueDIM);
@@ -224,7 +224,7 @@ void XtoRF2(const char* topicOri, const char* datacallback) {
         transmitter.sendUnit(valueUNIT, boolSWITCHTYPE);
       }
     }
-    Log.trace(F("Data sent" CR));
+    THEENGS_LOG_TRACE(F("Data sent" CR));
     NewRemoteReceiver::enable();
 
     // Publish state change back to MQTT
@@ -242,7 +242,7 @@ void XtoRF2(const char* topicOri, const char* datacallback) {
     MQTTswitchType = String(boolSWITCHTYPE);
     MQTTdimLevel = String(valueDIM);
     String MQTTRF2string;
-    Log.trace(F("Adv data XtoRF2 push state via RF2toMQTT" CR));
+    THEENGS_LOG_TRACE(F("Adv data XtoRF2 push state via RF2toMQTT" CR));
     if (isDimCommand) {
       MQTTRF2string = subjectRF2toMQTT + String("/") + RF2codeKey + MQTTAddress + String("/") + RF2unitKey + MQTTunit + String("/") + RF2groupKey + MQTTgroupBit + String("/") + RF2dimKey + String("/") + RF2periodKey + MQTTperiod;
       pub((char*)MQTTRF2string.c_str(), (char*)MQTTdimLevel.c_str());
@@ -262,7 +262,7 @@ void XtoRF2(const char* topicOri, const char* datacallback) {
 void XtoRF2(const char* topicOri, JsonObject& RF2data) { // json object decoding
 
   if (cmpToMainTopic(topicOri, subjectMQTTtoRF2)) {
-    Log.trace(F("MQTTtoRF2 json" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoRF2 json" CR));
     int boolSWITCHTYPE = RF2data["switchType"] | 99;
     bool success = false;
     if (boolSWITCHTYPE != 99) {
@@ -272,12 +272,12 @@ void XtoRF2(const char* topicOri, JsonObject& RF2data) { // json object decoding
       initCC1101();
       int txPower = RF2data["txpower"] | RF_CC1101_TXPOWER;
       ELECHOUSE_cc1101.setPA((int)txPower);
-      Log.notice(F("[RF] CC1101 TX Power: %d" CR), txPower);
+      THEENGS_LOG_NOTICE(F("[RF] CC1101 TX Power: %d" CR), txPower);
       float txFrequency = RF2data["frequency"] | RFConfig.frequency;
       ELECHOUSE_cc1101.SetTx(txFrequency);
-      Log.notice(F("[RF] Transmit frequency: %F" CR), txFrequency);
+      THEENGS_LOG_NOTICE(F("[RF] Transmit frequency: %F" CR), txFrequency);
 #    endif
-      Log.trace(F("MQTTtoRF2 switch type ok" CR));
+      THEENGS_LOG_TRACE(F("MQTTtoRF2 switch type ok" CR));
       bool isDimCommand = boolSWITCHTYPE == 2;
       unsigned long valueCODE = RF2data["address"];
       int valueUNIT = RF2data["unit"] | -1;
@@ -285,7 +285,7 @@ void XtoRF2(const char* topicOri, JsonObject& RF2data) { // json object decoding
       int valueGROUP = RF2data["group"];
       int valueDIM = RF2data["dim"] | -1;
       if ((valueCODE != 0) || (valueUNIT != -1) || (valuePERIOD != 0)) {
-        Log.trace(F("MQTTtoRF2" CR));
+        THEENGS_LOG_TRACE(F("MQTTtoRF2" CR));
         if (valueCODE == 0)
           valueCODE = 8233378;
         if (valueUNIT == -1)
@@ -293,7 +293,7 @@ void XtoRF2(const char* topicOri, JsonObject& RF2data) { // json object decoding
         if (valuePERIOD == 0)
           valuePERIOD = 272;
         NewRemoteTransmitter transmitter(valueCODE, RF_EMITTER_GPIO, valuePERIOD, RF2_EMITTER_REPEAT);
-        Log.trace(F("Sending" CR));
+        THEENGS_LOG_TRACE(F("Sending" CR));
         if (valueGROUP) {
           if (isDimCommand) {
             transmitter.sendGroupDim(valueDIM);
@@ -307,7 +307,7 @@ void XtoRF2(const char* topicOri, JsonObject& RF2data) { // json object decoding
             transmitter.sendUnit(valueUNIT, boolSWITCHTYPE);
           }
         }
-        Log.notice(F("MQTTtoRF2 OK" CR));
+        THEENGS_LOG_NOTICE(F("MQTTtoRF2 OK" CR));
 
         success = true;
       }
@@ -318,7 +318,7 @@ void XtoRF2(const char* topicOri, JsonObject& RF2data) { // json object decoding
       enqueueJsonObject(RF2data);
     } else {
       pub(subjectGTWRF2toMQTT, "{\"Status\": \"Error\"}"); // Fail feedback
-      Log.error(F("MQTTtoRF2 failed json read" CR));
+      THEENGS_LOG_ERROR(F("MQTTtoRF2 failed json read" CR));
     }
     enableActiveReceiver();
   }
@@ -326,20 +326,20 @@ void XtoRF2(const char* topicOri, JsonObject& RF2data) { // json object decoding
 #  endif
 
 void disableRF2Receive() {
-  Log.trace(F("disableRF2Receive" CR));
+  THEENGS_LOG_TRACE(F("disableRF2Receive" CR));
   NewRemoteReceiver::disable();
 }
 
 void enableRF2Receive() {
-  Log.trace(F("enableRF2Receive" CR));
+  THEENGS_LOG_TRACE(F("enableRF2Receive" CR));
   NewRemoteReceiver::init(RF_RECEIVER_GPIO, 2, rf2Callback);
 
-  Log.notice(F("RF_EMITTER_GPIO: %d " CR), RF_EMITTER_GPIO);
-  Log.notice(F("RF_RECEIVER_GPIO: %d " CR), RF_RECEIVER_GPIO);
-  Log.trace(F("gatewayRF2 command topic: %s%s%s" CR), mqtt_topic, gateway_name, subjectMQTTtoRF2);
+  THEENGS_LOG_NOTICE(F("RF_EMITTER_GPIO: %d " CR), RF_EMITTER_GPIO);
+  THEENGS_LOG_NOTICE(F("RF_RECEIVER_GPIO: %d " CR), RF_RECEIVER_GPIO);
+  THEENGS_LOG_TRACE(F("gatewayRF2 command topic: %s%s%s" CR), mqtt_topic, gateway_name, subjectMQTTtoRF2);
   pinMode(RF_EMITTER_GPIO, OUTPUT);
   digitalWrite(RF_EMITTER_GPIO, LOW);
-  Log.trace(F("gatewayRF2 setup done " CR));
+  THEENGS_LOG_TRACE(F("gatewayRF2 setup done " CR));
 }
 
 #endif
diff --git a/main/gatewayRFM69.cpp b/main/gatewayRFM69.cpp
index 0c53728..e4d1f76 100644
--- a/main/gatewayRFM69.cpp
+++ b/main/gatewayRFM69.cpp
@@ -77,7 +77,7 @@ void eeprom_setup() {
   pGC = (struct _GLOBAL_CONFIG*)EEPROM.getDataPtr();
   // if checksum bad init GC else use GC values
   if (gc_checksum() != pGC->checksum) {
-    Log.trace(F("Factory reset" CR));
+    THEENGS_LOG_TRACE(F("Factory reset" CR));
     memset(pGC, 0, sizeof(*pGC));
     strcpy_P(pGC->encryptkey, ENCRYPTKEY);
     strcpy_P(pGC->rfmapname, RFM69AP_NAME);
@@ -103,7 +103,7 @@ void setupRFM69(void) {
 
   // Initialize radio
   if (!radio.initialize(pGC->rfmfrequency, pGC->nodeid, pGC->networkid)) {
-    Log.error(F("gatewayRFM69 initialization failed" CR));
+    THEENGS_LOG_ERROR(F("gatewayRFM69 initialization failed" CR));
   }
 
   if (GC_IS_RFM69HCW) {
@@ -131,12 +131,12 @@ void setupRFM69(void) {
       freq = -1;
       break;
   }
-  Log.notice(F("gatewayRFM69 Listening and transmitting at: %d" CR), freq);
+  THEENGS_LOG_NOTICE(F("gatewayRFM69 Listening and transmitting at: %d" CR), freq);
 
   size_t len = snprintf_P(RadioConfig, sizeof(RadioConfig), JSONtemplate,
                           freq, GC_IS_RFM69HCW, pGC->networkid, GC_POWER_LEVEL);
   if (len >= sizeof(RadioConfig)) {
-    Log.trace(F("\n\n*** RFM69 config truncated ***\n" CR));
+    THEENGS_LOG_TRACE(F("\n\n*** RFM69 config truncated ***\n" CR));
   }
 }
 
@@ -161,7 +161,7 @@ bool RFM69toX(void) {
     }
     //updateClients(senderId, rssi, (const char *)data);
 
-    Log.trace(F("Data received: %s" CR), (const char*)data);
+    THEENGS_LOG_TRACE(F("Data received: %s" CR), (const char*)data);
 
     char buff[sizeof(subjectRFM69toMQTT) + 4];
     sprintf(buff, "%s/%d", subjectRFM69toMQTT, SENDERID);
@@ -180,7 +180,7 @@ bool RFM69toX(void) {
 #  if simpleReceiving
 void XtoRFM69(const char* topicOri, const char* datacallback) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoRFM69)) {
-    Log.trace(F("MQTTtoRFM69 data analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoRFM69 data analysis" CR));
     char data[RF69_MAX_DATA_LEN + 1];
     memcpy(data, (void*)datacallback, RF69_MAX_DATA_LEN);
     data[RF69_MAX_DATA_LEN] = '\0';
@@ -192,16 +192,16 @@ void XtoRFM69(const char* topicOri, const char* datacallback) {
     if (pos != -1) {
       pos = pos + +strlen(RFM69receiverKey);
       valueRCV = (topic.substring(pos, pos + 3)).toInt();
-      Log.notice(F("RFM69 receiver ID: %d" CR), valueRCV);
+      THEENGS_LOG_NOTICE(F("RFM69 receiver ID: %d" CR), valueRCV);
     }
     if (radio.sendWithRetry(valueRCV, data, strlen(data), 10)) {
-      Log.notice(F(" OK " CR));
+      THEENGS_LOG_NOTICE(F(" OK " CR));
       // Acknowledgement to the GTWRF topic
       char buff[sizeof(subjectGTWRFM69toMQTT) + 4];
       sprintf(buff, "%s/%d", subjectGTWRFM69toMQTT, radio.SENDERID);
       pub(buff, data);
     } else {
-      Log.error(F("RFM69 sending failed" CR));
+      THEENGS_LOG_ERROR(F("RFM69 sending failed" CR));
     }
   }
 }
@@ -210,21 +210,21 @@ void XtoRFM69(const char* topicOri, const char* datacallback) {
 void XtoRFM69(const char* topicOri, JsonObject& RFM69data) {
   if (cmpToMainTopic(topicOri, subjectMQTTtoRFM69)) {
     const char* data = RFM69data["data"];
-    Log.trace(F("MQTTtoRFM69 json data analysis" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoRFM69 json data analysis" CR));
     if (data) {
-      Log.trace(F("MQTTtoRFM69 data ok" CR));
+      THEENGS_LOG_TRACE(F("MQTTtoRFM69 data ok" CR));
       int valueRCV = RFM69data["receiverid"] | defaultRFM69ReceiverId; //default receiver id value
-      Log.notice(F("RFM69 receiver ID: %d" CR), valueRCV);
+      THEENGS_LOG_NOTICE(F("RFM69 receiver ID: %d" CR), valueRCV);
       if (radio.sendWithRetry(valueRCV, data, strlen(data), 10)) {
-        Log.notice(F(" OK " CR));
+        THEENGS_LOG_NOTICE(F(" OK " CR));
         // Acknowledgement to the GTWRF topic
         RFM69data["origin"] = subjectGTWRFM69toMQTT;
         enqueueJsonObject(RFM69data);
       } else {
-        Log.error(F("MQTTtoRFM69 sending failed" CR));
+        THEENGS_LOG_ERROR(F("MQTTtoRFM69 sending failed" CR));
       }
     } else {
-      Log.error(F("MQTTtoRFM69 failed json read" CR));
+      THEENGS_LOG_ERROR(F("MQTTtoRFM69 failed json read" CR));
     }
   }
 }
diff --git a/main/gatewayRTL_433.cpp b/main/gatewayRTL_433.cpp
index eba456b..b9eacd8 100644
--- a/main/gatewayRTL_433.cpp
+++ b/main/gatewayRTL_433.cpp
@@ -76,7 +76,7 @@ void dumpRTL_433Devices() {
 
 void createOrUpdateDeviceRTL_433(const char* id, const char* model, const char* type, uint8_t flags) {
   if (xSemaphoreTake(semaphorecreateOrUpdateDeviceRTL_433, pdMS_TO_TICKS(30000)) == pdFALSE) {
-    Log.error(F("[rtl_433] semaphorecreateOrUpdateDeviceRTL_433 Semaphore NOT taken" CR));
+    THEENGS_LOG_ERROR(F("[rtl_433] semaphorecreateOrUpdateDeviceRTL_433 Semaphore NOT taken" CR));
     return;
   }
 
@@ -86,13 +86,13 @@ void createOrUpdateDeviceRTL_433(const char* id, const char* model, const char*
     //new device
     device = new RTL_433device();
     if (strlcpy(device->uniqueId, id, uniqueIdSize) > uniqueIdSize) {
-      Log.warning(F("[rtl_433] Device id %s exceeds available space" CR), id); // Remove from production release ?
+      THEENGS_LOG_WARNING(F("[rtl_433] Device id %s exceeds available space" CR), id); // Remove from production release ?
     };
     if (strlcpy(device->modelName, model, modelNameSize) > modelNameSize) {
-      Log.warning(F("[rtl_433] Device model %s exceeds available space" CR), model); // Remove from production release ?
+      THEENGS_LOG_WARNING(F("[rtl_433] Device model %s exceeds available space" CR), model); // Remove from production release ?
     };
     if (strlcpy(device->type, type, typeSize) > typeSize) {
-      Log.warning(F("[rtl_433] Device type %s exceeds available space" CR), type); // Remove from production release ?
+      THEENGS_LOG_WARNING(F("[rtl_433] Device type %s exceeds available space" CR), type); // Remove from production release ?
     }
     DISCOVERY_TRACE_LOG(F("[rtl_433] Device type is %s." CR), device->type); // Remove from production release ?
     device->isDisc = flags & device_flags_isDisc;
@@ -115,7 +115,7 @@ void launchRTL_433Discovery(bool overrideDiscovery) {
   if (!overrideDiscovery && newRTL_433Devices == 0)
     return;
   if (xSemaphoreTake(semaphorecreateOrUpdateDeviceRTL_433, pdMS_TO_TICKS(QueueSemaphoreTimeOutLoop)) == pdFALSE) {
-    Log.error(F("[rtl_433] semaphorecreateOrUpdateDeviceRTL_433 Semaphore NOT taken" CR));
+    THEENGS_LOG_ERROR(F("[rtl_433] semaphorecreateOrUpdateDeviceRTL_433 Semaphore NOT taken" CR));
     return;
   }
   newRTL_433Devices = 0;
@@ -131,7 +131,7 @@ void launchRTL_433Discovery(bool overrideDiscovery) {
         char deviceKeyParameter[25];
         memcpy(deviceKeyParameter, &pdevice->uniqueId[strlen(pdevice->uniqueId) - strlen(parameters[i][0])], strlen(parameters[i][0]));
         deviceKeyParameter[strlen(parameters[i][0])] = '\0';
-        Log.trace(F("deviceKeyParameter: %s" CR), deviceKeyParameter);
+        THEENGS_LOG_TRACE(F("deviceKeyParameter: %s" CR), deviceKeyParameter);
 
         if (strcmp(deviceKeyParameter, parameters[i][0]) == 0) {
           // Remove the key from the unique id to extract the device id
@@ -269,7 +269,7 @@ void rtl_433_Callback(char* message) {
   JsonObject RFrtl_433_ESPdata = jsonBuffer2.to<JsonObject>();
   auto error = deserializeJson(jsonBuffer2, message);
   if (error) {
-    Log.error(F("[rtl_433] deserializeJson() failed: %s" CR), error.c_str());
+    THEENGS_LOG_ERROR(F("[rtl_433] deserializeJson() failed: %s" CR), error.c_str());
     return;
   }
 
@@ -308,7 +308,7 @@ void rtl_433_Callback(char* message) {
     storeSignalValue(MQTTvalue);
   }
 #  ifdef MEMORY_DEBUG
-  Log.trace(F("Post rtl_433_Callback: %d" CR), ESP.getFreeHeap());
+  THEENGS_LOG_TRACE(F("Post rtl_433_Callback: %d" CR), ESP.getFreeHeap());
 #  endif
 }
 
@@ -318,8 +318,8 @@ void setupRTL_433() {
   semaphorecreateOrUpdateDeviceRTL_433 = xSemaphoreCreateBinary();
   xSemaphoreGive(semaphorecreateOrUpdateDeviceRTL_433);
 #  endif
-  Log.trace(F("gatewayRTL_433 command topic: %s%s%s" CR), mqtt_topic, gateway_name, subjectMQTTtoRFset);
-  Log.notice(F("gatewayRTL_433 setup done " CR));
+  THEENGS_LOG_TRACE(F("gatewayRTL_433 command topic: %s%s%s" CR), mqtt_topic, gateway_name, subjectMQTTtoRFset);
+  THEENGS_LOG_NOTICE(F("gatewayRTL_433 setup done " CR));
 }
 
 void RTL_433Loop() {
@@ -327,13 +327,13 @@ void RTL_433Loop() {
 }
 
 extern void enableRTLreceive() {
-  Log.notice(F("Enable RTL_433 Receiver: %FMhz" CR), RFConfig.frequency);
+  THEENGS_LOG_NOTICE(F("Enable RTL_433 Receiver: %FMhz" CR), RFConfig.frequency);
   rtl_433.initReceiver(RF_MODULE_RECEIVER_GPIO, RFConfig.frequency);
   rtl_433.enableReceiver();
 }
 
 extern void disableRTLreceive() {
-  Log.trace(F("disableRTLreceive" CR));
+  THEENGS_LOG_TRACE(F("disableRTLreceive" CR));
   rtl_433.disableReceiver();
 }
 
diff --git a/main/gatewaySERIAL.cpp b/main/gatewaySERIAL.cpp
index 12d1685..bcf304d 100644
--- a/main/gatewaySERIAL.cpp
+++ b/main/gatewaySERIAL.cpp
@@ -86,7 +86,7 @@ void setupSERIAL() {
   Serial.swap(); // swap UART0 ports from (GPIO1,GPIO3) to (GPIO15,GPIO13)
 #      endif
   SERIALStream = &Serial;
-  Log.notice(F("SERIAL HW UART0" CR));
+  THEENGS_LOG_NOTICE(F("SERIAL HW UART0" CR));
 
 #    elif SERIAL_UART == 1 // init UART1
   Serial1.end(); // stop if already initialized
@@ -96,7 +96,7 @@ void setupSERIAL() {
   Serial1.begin(SERIALBaud, SERIAL_8N1);
 #      endif
   SERIALStream = &Serial1;
-  Log.notice(F("SERIAL HW UART1" CR));
+  THEENGS_LOG_NOTICE(F("SERIAL HW UART1" CR));
 
 #    elif SERIAL_UART == 2 // init UART2
   Serial2.end(); // stop if already initialized
@@ -106,13 +106,13 @@ void setupSERIAL() {
   Serial2.begin(SERIALBaud, SERIAL_8N1);
 #      endif
   SERIALStream = &Serial2;
-  Log.notice(F("SERIAL HW UART2" CR));
+  THEENGS_LOG_NOTICE(F("SERIAL HW UART2" CR));
 
 #    elif SERIAL_UART == 3 // init UART3
   Serial3.end(); // stop if already initialized
   Serial3.begin(SERIALBaud, SERIAL_8N1);
   SERIALStream = &Serial3;
-  Log.notice(F("SERIAL HW UART3" CR));
+  THEENGS_LOG_NOTICE(F("SERIAL HW UART3" CR));
 #    endif
 
 #  else // Software serial
@@ -122,14 +122,14 @@ void setupSERIAL() {
   SERIALSoftSerial.begin(SERIALBaud);
   SERIALStream = &SERIALSoftSerial; // get stream of serial
 
-  Log.notice(F("SERIAL_RX_GPIO: %d" CR), SERIAL_RX_GPIO);
-  Log.notice(F("SERIAL_TX_GPIO: %d" CR), SERIAL_TX_GPIO);
+  THEENGS_LOG_NOTICE(F("SERIAL_RX_GPIO: %d" CR), SERIAL_RX_GPIO);
+  THEENGS_LOG_NOTICE(F("SERIAL_TX_GPIO: %d" CR), SERIAL_TX_GPIO);
 #  endif
 
 #  ifdef ESP32
   serialSemaphore = xSemaphoreCreateMutex();
   if (serialSemaphore == NULL) {
-    Log.error(F("Failed to create serialSemaphore" CR));
+    THEENGS_LOG_ERROR(F("Failed to create serialSemaphore" CR));
   }
 #  endif
 
@@ -137,8 +137,8 @@ void setupSERIAL() {
   while (SERIALStream->available() > 0)
     SERIALStream->read();
 
-  Log.notice(F("SERIALBaud: %d" CR), SERIALBaud);
-  Log.trace(F("gatewaySERIAL setup done" CR));
+  THEENGS_LOG_NOTICE(F("SERIALBaud: %d" CR), SERIALBaud);
+  THEENGS_LOG_TRACE(F("gatewaySERIAL setup done" CR));
 }
 
 #  if SERIALtoMQTTmode == 0 // Convert received data to single MQTT topic
@@ -146,7 +146,7 @@ void SERIALtoX() {
   // Send all SERIAL output (up to SERIALInPost char revieved) as MQTT message
   //This function is Blocking, but there should only ever be a few bytes, usually an ACK or a NACK.
   if (SERIALStream->available()) {
-    Log.trace(F("SERIALtoMQTT" CR));
+    THEENGS_LOG_TRACE(F("SERIALtoMQTT" CR));
     static char SERIALdata[MAX_INPUT];
     static unsigned int input_pos = 0;
     static char inChar;
@@ -161,7 +161,7 @@ void SERIALtoX() {
     input_pos = 0;
 
     char* output = SERIALdata + sizeof(SERIALPre) - 1;
-    Log.notice(F("SERIAL data: %s" CR), output);
+    THEENGS_LOG_NOTICE(F("SERIAL data: %s" CR), output);
     pub(subjectSERIALtoMQTT, output);
   }
 }
@@ -173,10 +173,10 @@ void sendHeartbeat() {
     SERIALStream->print("{\"type\":\"heartbeat\"}");
     SERIALStream->print(SERIALPost);
     SERIALStream->flush();
-    Log.notice(F("Sent Serial heartbeat" CR));
+    THEENGS_LOG_NOTICE(F("Sent Serial heartbeat" CR));
     SEMAPHORE_SERIAL_GIVE;
   } else {
-    Log.error(F("Failed to take serialSemaphore" CR));
+    THEENGS_LOG_ERROR(F("Failed to take serialSemaphore" CR));
   }
 }
 
@@ -186,10 +186,10 @@ void sendHeartbeatAck() {
     SERIALStream->print("{\"type\":\"heartbeat_ack\"}");
     SERIALStream->print(SERIALPost);
     SERIALStream->flush();
-    Log.notice(F("Sent heartbeat ack" CR));
+    THEENGS_LOG_NOTICE(F("Sent heartbeat ack" CR));
     SEMAPHORE_SERIAL_GIVE;
   } else {
-    Log.error(F("Failed to take serialSemaphore" CR));
+    THEENGS_LOG_ERROR(F("Failed to take serialSemaphore" CR));
   }
 }
 
@@ -210,7 +210,7 @@ void SERIALtoX() {
       // No ack received, increase the interval (with a maximum limit)
       unsigned long newHeartbeatInterval = heartbeatInterval * 1.25;
       heartbeatInterval = min(newHeartbeatInterval, maxHeartbeatInterval);
-      Log.warning(F("No heartbeat ack received. Increasing interval to %lu ms" CR), heartbeatInterval);
+      THEENGS_LOG_WARNING(F("No heartbeat ack received. Increasing interval to %lu ms" CR), heartbeatInterval);
       receiverReady = false;
     } else {
       // Ack received, reset the interval
@@ -245,10 +245,10 @@ void SERIALtoX() {
         } else if (SERIALdata.containsKey("type") && strcmp(SERIALdata["type"], "heartbeat_ack") == 0) {
           lastHeartbeatAckReceived = now;
           receiverReady = true;
-          Log.notice(F("Heartbeat ack received" CR));
+          THEENGS_LOG_NOTICE(F("Heartbeat ack received" CR));
         } else {
           // Process normal messages
-          Log.notice(F("SERIAL msg received: %s" CR), jsonString.c_str());
+          THEENGS_LOG_NOTICE(F("SERIAL msg received: %s" CR), jsonString.c_str());
 #    if jsonPublishing
           if (SERIALdata.containsKey("target")) {
             receivingDATA("", jsonString.c_str());
@@ -276,18 +276,18 @@ void SERIALtoX() {
         }
       } else {
         // Print error to serial log
-        Log.error(F("Error in SERIALJSONtoMQTT, deserializeJson() returned %s" CR), err.c_str());
+        THEENGS_LOG_ERROR(F("Error in SERIALJSONtoMQTT, deserializeJson() returned %s" CR), err.c_str());
       }
 
       // Clear the buffer for the next message
       buffer = "";
     } else if (buffer.endsWith(SERIALPost)) {
       // If the buffer ends with the postfix but does not start with the prefix, clear it
-      Log.error(F("Buffer error, clearing buffer. Partial content: %s" CR), buffer.c_str());
+      THEENGS_LOG_ERROR(F("Buffer error, clearing buffer. Partial content: %s" CR), buffer.c_str());
       buffer = "";
     } else if (buffer.length() > JSON_MSG_BUFFER) {
       // If the buffer gets too large without finding a complete message, clear it
-      Log.error(F("Buffer overflow, clearing buffer. Partial content: %s" CR), buffer.c_str());
+      THEENGS_LOG_ERROR(F("Buffer overflow, clearing buffer. Partial content: %s" CR), buffer.c_str());
       buffer = "";
       isOverflow = true;
     }
@@ -302,7 +302,7 @@ void sendMQTTfromNestedJson(JsonVariant obj, char* topic, int level, int maxLeve
     for (JsonPair pair : obj.as<JsonObject>()) {
       // check if new key still fits in topic cstring
       const char* key = pair.key().c_str();
-      Log.trace(F("level=%d, key='%s'" CR), level, pair.key().c_str());
+      THEENGS_LOG_TRACE(F("level=%d, key='%s'" CR), level, pair.key().c_str());
       if (topicLength + 2 + strlen(key) <= mqtt_topic_max_size) {
         // add new level to existing topic cstring
         topic[topicLength] = '/'; // add slash
@@ -315,7 +315,7 @@ void sendMQTTfromNestedJson(JsonVariant obj, char* topic, int level, int maxLeve
         // restore topic
         topic[topicLength] = '\0';
       } else {
-        Log.error(F("Nested key '%s' at level %d does not fit within max topic length of %d, skipping"),
+        THEENGS_LOG_ERROR(F("Nested key '%s' at level %d does not fit within max topic length of %d, skipping"),
                   key, level, mqtt_topic_max_size);
       }
     }
@@ -324,7 +324,7 @@ void sendMQTTfromNestedJson(JsonVariant obj, char* topic, int level, int maxLeve
     // output value at current json level
     char output[MAX_INPUT + 1];
     serializeJson(obj, output, MAX_INPUT);
-    Log.notice(F("level=%d, topic=%s, value: %s\n"), level, topic, output);
+    THEENGS_LOG_NOTICE(F("level=%d, topic=%s, value: %s\n"), level, topic, output);
 
     // send MQTT message
     pub(topic, &output[0]);
@@ -338,7 +338,7 @@ bool XtoSERIAL(const char* topicOri, JsonObject& SERIALdata) {
     if (receiverReady && (cmpToMainTopic(topicOri, subjectMQTTtoSERIAL) ||
                           (SYSConfig.serial && SERIALdata.containsKey("origin") && SERIALdata["origin"].is<const char*>()) ||
                           (SYSConfig.serial && SERIALdata.containsKey("topic") && SERIALdata["topic"].is<const char*>()))) {
-      Log.trace(F("XtoSERIAL" CR));
+      THEENGS_LOG_TRACE(F("XtoSERIAL" CR));
       // Prepare the data string
       std::string data;
       if (SYSConfig.serial ||
@@ -358,13 +358,13 @@ bool XtoSERIAL(const char* topicOri, JsonObject& SERIALdata) {
       SERIALStream->print(postfix);
       SERIALStream->flush();
 
-      Log.notice(F("[ OMG->SERIAL ] data sent: %s" CR), data.c_str());
+      THEENGS_LOG_NOTICE(F("[ OMG->SERIAL ] data sent: %s" CR), data.c_str());
       res = true;
       delay(100);
     }
     SEMAPHORE_SERIAL_GIVE;
   } else {
-    Log.error(F("Failed to take serialSemaphore" CR));
+    THEENGS_LOG_ERROR(F("Failed to take serialSemaphore" CR));
   }
   return res;
 }
diff --git a/main/gatewaySRFB.cpp b/main/gatewaySRFB.cpp
index 548a9af..88e6d33 100644
--- a/main/gatewaySRFB.cpp
+++ b/main/gatewaySRFB.cpp
@@ -43,8 +43,8 @@ void _rfbDecode();
 void _rfbAck();
 
 void setupSRFB() {
-  Log.trace(F("gatewaySRFB setup done " CR));
-  Log.trace(F("Serial Baud: %l" CR), SERIAL_BAUD);
+  THEENGS_LOG_TRACE(F("gatewaySRFB setup done " CR));
+  THEENGS_LOG_TRACE(F("Serial Baud: %l" CR), SERIAL_BAUD);
 }
 
 void _rfbSend(byte* message) {
@@ -62,7 +62,7 @@ void _rfbSend(byte* message) {
 void _rfbSend(byte* message, int times) {
   char buffer[RF_MESSAGE_SIZE];
   TheengsUtils::_rawToHex(message, buffer, RF_MESSAGE_SIZE);
-  Log.notice(F("[RFBRIDGE] Sending MESSAGE" CR));
+  THEENGS_LOG_NOTICE(F("[RFBRIDGE] Sending MESSAGE" CR));
 
   for (int i = 0; i < times; i++) {
     if (i > 0) {
@@ -108,7 +108,7 @@ void _rfbDecode() {
   if (action == RF_CODE_RFIN) {
     TheengsUtils::_rawToHex(&_uartbuf[1], buffer, RF_MESSAGE_SIZE);
 
-    Log.trace(F("Creating SRFB buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating SRFB buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> SRFBdataBuffer;
     JsonObject SRFBdata = SRFBdataBuffer.to<JsonObject>();
     SRFBdata["raw"] = String(buffer).substring(0, 18);
@@ -126,13 +126,13 @@ void _rfbDecode() {
     SRFBdata["value"] = (unsigned long)MQTTvalue;
 
     if (!isAduplicateSignal(MQTTvalue) && MQTTvalue != 0) { // conditions to avoid duplications of RF -->MQTT
-      Log.trace(F("Adv data SRFBtoMQTT" CR));
+      THEENGS_LOG_TRACE(F("Adv data SRFBtoMQTT" CR));
       SRFBdata["origin"] = subjectSRFBtoMQTT;
       enqueueJsonObject(SRFBdata);
-      Log.trace(F("Store val: %lu" CR), MQTTvalue);
+      THEENGS_LOG_TRACE(F("Store val: %lu" CR), MQTTvalue);
       storeSignalValue(MQTTvalue);
       if (repeatSRFBwMQTT) {
-        Log.trace(F("Publish SRFB for rpt" CR));
+        THEENGS_LOG_TRACE(F("Publish SRFB for rpt" CR));
         SRFBdata["origin"] = subjectMQTTtoSRFB;
         enqueueJsonObject(SRFBdata);
       }
@@ -142,7 +142,7 @@ void _rfbDecode() {
 }
 
 void _rfbAck() {
-  Log.trace(F("[RFBRIDGE] Sending ACK\n" CR));
+  THEENGS_LOG_TRACE(F("[RFBRIDGE] Sending ACK\n" CR));
   Serial.println();
   Serial.write(RF_CODE_START);
   Serial.write(RF_CODE_ACK);
@@ -166,31 +166,31 @@ void XtoSRFB(const char* topicOri, const char* datacallback) {
     if (pos != -1) {
       pos = pos + +strlen(SRFBRptKey);
       valueRPT = (topic.substring(pos, pos + 1)).toInt();
-      Log.notice(F("SRFB Repeat: %d" CR), valueRPT);
+      THEENGS_LOG_NOTICE(F("SRFB Repeat: %d" CR), valueRPT);
     }
 
     int pos2 = topic.lastIndexOf(SRFBminipulselengthKey);
     if (pos2 != -1) {
       pos2 = pos2 + strlen(SRFBminipulselengthKey);
       valueMiniPLSL = (topic.substring(pos2, pos2 + 3)).toInt();
-      Log.notice(F("RF Mini Pulse Lgth: %d" CR), valueMiniPLSL);
+      THEENGS_LOG_NOTICE(F("RF Mini Pulse Lgth: %d" CR), valueMiniPLSL);
     }
 
     int pos3 = topic.lastIndexOf(SRFBmaxipulselengthKey);
     if (pos3 != -1) {
       pos3 = pos3 + strlen(SRFBmaxipulselengthKey);
       valueMaxiPLSL = (topic.substring(pos3, pos3 + 2)).toInt();
-      Log.notice(F("RF Maxi Pulse Lgth: %d" CR), valueMaxiPLSL);
+      THEENGS_LOG_NOTICE(F("RF Maxi Pulse Lgth: %d" CR), valueMaxiPLSL);
     }
 
     int pos4 = topic.lastIndexOf(SRFBsyncKey);
     if (pos4 != -1) {
       pos4 = pos4 + strlen(SRFBsyncKey);
       valueSYNC = (topic.substring(pos4, pos4 + 2)).toInt();
-      Log.notice(F("RF sync: %d" CR), valueSYNC);
+      THEENGS_LOG_NOTICE(F("RF sync: %d" CR), valueSYNC);
     }
 
-    Log.trace(F("MQTTtoSRFB prts" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoSRFB prts" CR));
     if (valueRPT == 0)
       valueRPT = 1;
     if (valueMiniPLSL == 0)
@@ -234,7 +234,7 @@ void XtoSRFB(const char* topicOri, const char* datacallback) {
     if (pos != -1) {
       pos = pos + +strlen(SRFBRptKey);
       valueRPT = (topic.substring(pos, pos + 1)).toInt();
-      Log.notice(F("SRFB Repeat: %d" CR), valueRPT);
+      THEENGS_LOG_NOTICE(F("SRFB Repeat: %d" CR), valueRPT);
     }
     if (valueRPT == 0)
       valueRPT = 1;
@@ -253,16 +253,16 @@ void XtoSRFB(const char* topicOri, JsonObject& SRFBdata) {
   const char* raw = SRFBdata["raw"];
   int valueRPT = SRFBdata["repeat"] | 1;
   if (cmpToMainTopic(topicOri, subjectMQTTtoSRFB)) {
-    Log.trace(F("MQTTtoSRFB json" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoSRFB json" CR));
     if (raw) { // send raw in priority when defined in the json
-      Log.trace(F("MQTTtoSRFB raw ok" CR));
+      THEENGS_LOG_TRACE(F("MQTTtoSRFB raw ok" CR));
       byte message_b[RF_MESSAGE_SIZE];
       TheengsUtils::_hexToRaw(raw, message_b, RF_MESSAGE_SIZE);
       _rfbSend(message_b, valueRPT);
     } else {
       unsigned long data = SRFBdata["value"];
       if (data != 0) {
-        Log.notice(F("MQTTtoSRFB data ok" CR));
+        THEENGS_LOG_NOTICE(F("MQTTtoSRFB data ok" CR));
         int valueMiniPLSL = SRFBdata["val_Tlow"];
         int valueMaxiPLSL = SRFBdata["val_Thigh"];
         int valueSYNC = SRFBdata["delay"];
@@ -276,10 +276,10 @@ void XtoSRFB(const char* topicOri, JsonObject& SRFBdata) {
         if (valueSYNC == 0)
           valueSYNC = 9500;
 
-        Log.notice(F("SRFB Repeat: %d" CR), valueRPT);
-        Log.notice(F("RF Mini Pulse Lgth: %d" CR), valueMiniPLSL);
-        Log.notice(F("RF Maxi Pulse Lgth: %d" CR), valueMaxiPLSL);
-        Log.notice(F("RF sync: %d" CR), valueSYNC);
+        THEENGS_LOG_NOTICE(F("SRFB Repeat: %d" CR), valueRPT);
+        THEENGS_LOG_NOTICE(F("RF Mini Pulse Lgth: %d" CR), valueMiniPLSL);
+        THEENGS_LOG_NOTICE(F("RF Maxi Pulse Lgth: %d" CR), valueMaxiPLSL);
+        THEENGS_LOG_NOTICE(F("RF sync: %d" CR), valueSYNC);
 
         byte hex_valueMiniPLSL[2];
         hex_valueMiniPLSL[0] = (int)((valueMiniPLSL >> 8) & 0xFF);
@@ -305,12 +305,12 @@ void XtoSRFB(const char* topicOri, JsonObject& SRFBdata) {
         memcpy(message_b + 4, hex_valueMaxiPLSL, 2);
         memcpy(message_b + 6, hex_data, 3);
 
-        Log.notice(F("MQTTtoSRFB OK" CR));
+        THEENGS_LOG_NOTICE(F("MQTTtoSRFB OK" CR));
         _rfbSend(message_b, valueRPT);
         SRFBdata["origin"] = subjectGTWSRFBtoMQTT;
         enqueueJsonObject(SRFBdata); // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
       } else {
-        Log.error(F("MQTTtoSRFB error decoding value" CR));
+        THEENGS_LOG_ERROR(F("MQTTtoSRFB error decoding value" CR));
       }
     }
   }
diff --git a/main/gatewayWeatherStation.cpp b/main/gatewayWeatherStation.cpp
index 6520b0d..bf139bb 100644
--- a/main/gatewayWeatherStation.cpp
+++ b/main/gatewayWeatherStation.cpp
@@ -45,10 +45,10 @@ void PairedDeviceAdded(byte newID) {
 }
 
 void setupWeatherStation() {
-  Log.notice(F("RF_WS_RECEIVER_GPIO %d" CR), RF_WS_RECEIVER_GPIO);
+  THEENGS_LOG_NOTICE(F("RF_WS_RECEIVER_GPIO %d" CR), RF_WS_RECEIVER_GPIO);
   wsdr.begin();
   wsdr.pair(NULL, PairedDeviceAdded);
-  Log.trace(F("gatewayWeatherStation setup done " CR));
+  THEENGS_LOG_TRACE(F("gatewayWeatherStation setup done " CR));
 }
 
 void sendWindSpeedData(byte id, float wind_speed, byte battery_status) {
@@ -61,7 +61,7 @@ void sendWindSpeedData(byte id, float wind_speed, byte battery_status) {
     RFdata["battery"] = bitRead(battery_status, 0) == 0 ? "OK" : "Low";
     RFdata["origin"] = subjectRFtoMQTT;
     enqueueJsonObject(RFdata);
-    Log.trace(F("Store wind speed val: %lu" CR), MQTTvalue);
+    THEENGS_LOG_TRACE(F("Store wind speed val: %lu" CR), MQTTvalue);
     storeSignalValue(MQTTvalue);
   }
 }
@@ -76,7 +76,7 @@ void sendRainData(byte id, float rain_volume, byte battery_status) {
     RFdata["battery"] = bitRead(battery_status, 1) == 0 ? "OK" : "Low";
     RFdata["origin"] = subjectRFtoMQTT;
     enqueueJsonObject(RFdata);
-    Log.trace(F("Store rain_volume: %lu" CR), MQTTvalue);
+    THEENGS_LOG_TRACE(F("Store rain_volume: %lu" CR), MQTTvalue);
     storeSignalValue(MQTTvalue);
   }
 }
@@ -92,7 +92,7 @@ void sendWindData(byte id, int wind_direction, float wind_gust, byte battery_sta
     RFdata["battery"] = bitRead(battery_status, 0) == 0 ? "OK" : "Low";
     RFdata["origin"] = subjectRFtoMQTT;
     enqueueJsonObject(RFdata);
-    Log.trace(F("Store wind data val: %lu" CR), MQTTvalue);
+    THEENGS_LOG_TRACE(F("Store wind data val: %lu" CR), MQTTvalue);
     storeSignalValue(MQTTvalue);
   }
 }
@@ -109,7 +109,7 @@ void sendTemperatureData(byte id, float temperature, int humidity, byte battery_
     RFdata["battery"] = bitRead(battery_status, 0) == 0 ? "OK" : "Low";
     RFdata["origin"] = subjectRFtoMQTT;
     enqueueJsonObject(RFdata);
-    Log.trace(F("Store temp val: %lu" CR), MQTTvalue);
+    THEENGS_LOG_TRACE(F("Store temp val: %lu" CR), MQTTvalue);
     storeSignalValue(MQTTvalue);
   }
 }
@@ -118,22 +118,22 @@ void ZgatewayWeatherStationtoX() {
   char newData = wsdr.readData();
   switch (newData) {
     case 'T':
-      Log.trace(F("Temperature" CR));
+      THEENGS_LOG_TRACE(F("Temperature" CR));
       sendTemperatureData(wsdr.sensorID(), wsdr.readTemperature(), wsdr.readHumidity(), wsdr.batteryStatus());
       break;
 
     case 'S':
-      Log.trace(F("Wind speed" CR));
+      THEENGS_LOG_TRACE(F("Wind speed" CR));
       sendWindSpeedData(wsdr.sensorID(), wsdr.readWindSpeed(), wsdr.batteryStatus());
       break;
 
     case 'G':
-      Log.trace(F("Wind direction" CR));
+      THEENGS_LOG_TRACE(F("Wind direction" CR));
       sendWindData(wsdr.sensorID(), wsdr.readWindDirection(), wsdr.readWindGust(), wsdr.batteryStatus());
       break;
 
     case 'R':
-      Log.trace(F("Rain volume" CR));
+      THEENGS_LOG_TRACE(F("Rain volume" CR));
       sendRainData(wsdr.sensorID(), wsdr.readRainVolume(), wsdr.batteryStatus());
       break;
 
diff --git a/main/main.cpp b/main/main.cpp
index cbbeb4a..812f4f9 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -432,7 +432,7 @@ bool jsonDispatch(JsonObject& data) {
 #endif
     gatewayState = previousGatewayState; // restore the previous state
   } else {
-    Log.error(F("No origin or topic in JSON filtered" CR));
+    THEENGS_LOG_ERROR(F("No origin or topic in JSON filtered" CR));
     gatewayState = GatewayState::ERROR;
   }
   return res;
@@ -442,22 +442,22 @@ bool jsonDispatch(JsonObject& data) {
 bool enqueueJsonObject(const StaticJsonDocument<JSON_MSG_BUFFER>& jsonDoc, int timeout) {
   receivedMessages++;
   if (jsonDoc.size() == 0) {
-    Log.error(F("Empty JSON, skipping" CR));
+    THEENGS_LOG_ERROR(F("Empty JSON, skipping" CR));
     gatewayState = GatewayState::ERROR;
     return true;
   }
   if (queueLength >= QueueSize) {
-    Log.warning(F("%d Doc(s) in queue, doc blocked" CR), queueLength);
+    THEENGS_LOG_WARNING(F("%d Doc(s) in queue, doc blocked" CR), queueLength);
     blockedMessages++;
     return false;
   }
-  Log.trace(F("Enqueue JSON" CR));
+  THEENGS_LOG_TRACE(F("Enqueue JSON" CR));
   std::string jsonString;
   serializeJson(jsonDoc, jsonString);
 #ifdef ESP32
   // Semaphore check before enqueueing a document
   if (xSemaphoreTake(xQueueMutex, pdMS_TO_TICKS(timeout)) == pdFALSE) {
-    Log.error(F("xQueueMutex not taken" CR));
+    THEENGS_LOG_ERROR(F("xQueueMutex not taken" CR));
     gatewayState = GatewayState::ERROR;
     blockedMessages++;
     return false;
@@ -467,7 +467,7 @@ bool enqueueJsonObject(const StaticJsonDocument<JSON_MSG_BUFFER>& jsonDoc, int t
 #ifdef ESP32
   xSemaphoreGive(xQueueMutex);
 #endif
-  Log.trace(F("Queue length: %d" CR), jsonQueue.size());
+  THEENGS_LOG_TRACE(F("Queue length: %d" CR), jsonQueue.size());
   return true;
 }
 
@@ -502,7 +502,7 @@ std::string generateHash(const std::string& input) {
 */
 void buildTopicFromId(JsonObject& Jsondata, const char* origin) {
   if (!Jsondata.containsKey("id")) {
-    Log.error(F("No id in Jsondata" CR));
+    THEENGS_LOG_ERROR(F("No id in Jsondata" CR));
     gatewayState = GatewayState::ERROR;
     return;
   }
@@ -520,7 +520,7 @@ void buildTopicFromId(JsonObject& Jsondata, const char* origin) {
     if (Jsondata.containsKey("uuid")) {
       topic = Jsondata["uuid"].as<std::string>();
     } else {
-      Log.error(F("No uuid in Jsondata" CR));
+      THEENGS_LOG_ERROR(F("No uuid in Jsondata" CR));
       gatewayState = GatewayState::ERROR;
     }
   }
@@ -533,7 +533,7 @@ void buildTopicFromId(JsonObject& Jsondata, const char* origin) {
 
   Jsondata["origin"] = topic;
 
-  Log.trace(F("Origin: %s" CR), Jsondata["origin"].as<const char*>());
+  THEENGS_LOG_TRACE(F("Origin: %s" CR), Jsondata["origin"].as<const char*>());
 }
 
 // Empty the documents queue
@@ -545,12 +545,12 @@ void emptyQueue() {
   if (queueLength <= 0) {
     return;
   }
-  Log.trace(F("Dequeue JSON" CR));
+  THEENGS_LOG_TRACE(F("Dequeue JSON" CR));
   DynamicJsonDocument jsonBuffer(JSON_MSG_BUFFER_MAX);
   JsonObject obj = jsonBuffer.to<JsonObject>();
 #ifdef ESP32
   if (xSemaphoreTake(xQueueMutex, pdMS_TO_TICKS(QueueSemaphoreTimeOutTask)) == pdFALSE) {
-    Log.error(F("xQueueMutex not taken" CR));
+    THEENGS_LOG_ERROR(F("xQueueMutex not taken" CR));
     gatewayState = GatewayState::ERROR;
     return;
   }
@@ -561,7 +561,7 @@ void emptyQueue() {
   xSemaphoreGive(xQueueMutex);
 #endif
   if (error) {
-    Log.error(F("deserialize jsonQueue.front() failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+    THEENGS_LOG_ERROR(F("deserialize jsonQueue.front() failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
     gatewayState = GatewayState::ERROR;
   } else {
     if (jsonDispatch(obj))
@@ -595,7 +595,7 @@ bool pub(JsonObject& data) {
     data.remove("retain");
   }
   if (data.size() == 0) {
-    Log.error(F("Empty JSON, not published" CR));
+    THEENGS_LOG_ERROR(F("Empty JSON, not published" CR));
     gatewayState = GatewayState::ERROR;
     return res;
   }
@@ -617,7 +617,7 @@ bool pub(JsonObject& data) {
     }
 
   } else {
-    Log.error(F("No topic or origin in JSON, not published" CR));
+    THEENGS_LOG_ERROR(F("No topic or origin in JSON, not published" CR));
     gatewayState = GatewayState::ERROR;
     return res;
   }
@@ -644,7 +644,7 @@ bool pub(JsonObject& data) {
 #endif
 
 #if simplePublishing
-  Log.trace(F("simplePub - ON" CR));
+  THEENGS_LOG_TRACE(F("simplePub - ON" CR));
   // Loop through all the key-value pairs in obj
   for (JsonPair p : data) {
 #  if defined(ESP8266)
@@ -701,22 +701,22 @@ bool pubMQTT(const char* topic, const char* payload, bool retainFlag) {
   if (SYSConfig.mqtt && !SYSConfig.offline) {
 #ifdef ESP32
     if (xSemaphoreTake(xMqttMutex, pdMS_TO_TICKS(QueueSemaphoreTimeOutTask)) == pdFALSE) {
-      Log.error(F("xMqttMutex not taken" CR));
+      THEENGS_LOG_ERROR(F("xMqttMutex not taken" CR));
       gatewayState = GatewayState::ERROR;
       return res;
     }
 #endif
     if (mqtt && mqtt->connected()) {
-      Log.notice(F("[ OMG->MQTT ] topic: %s msg: %s " CR), topic, payload);
+      THEENGS_LOG_NOTICE(F("[ OMG->MQTT ] topic: %s msg: %s " CR), topic, payload);
       res = mqtt->publish(topic, payload, 0, retainFlag);
     } else {
-      Log.warning(F("MQTT not connected, aborting the publication" CR));
+      THEENGS_LOG_WARNING(F("MQTT not connected, aborting the publication" CR));
     }
 #ifdef ESP32
     xSemaphoreGive(xMqttMutex);
 #endif
   } else {
-    Log.notice(F("[ OMG->MQTT deactivated or offline] topic: %s msg: %s " CR), topic, payload);
+    THEENGS_LOG_NOTICE(F("[ OMG->MQTT deactivated or offline] topic: %s msg: %s " CR), topic, payload);
   }
   return res;
 }
@@ -870,7 +870,7 @@ void SYSConfig_save() {
   preferences.begin(Gateway_Short_Name, false);
   int result = preferences.putString("SYSConfig", conf);
   preferences.end();
-  Log.notice(F("SYS Config_save: %s, result: %d" CR), conf.c_str(), result);
+  THEENGS_LOG_NOTICE(F("SYS Config_save: %s, result: %d" CR), conf.c_str(), result);
 }
 #else // Function not available for ESP8266
 void SYSConfig_save() {}
@@ -902,20 +902,20 @@ void SYSConfig_load() {
     auto error = deserializeJson(jsonBuffer, preferences.getString("SYSConfig", "{}"));
     preferences.end();
     if (error) {
-      Log.error(F("SYS config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+      THEENGS_LOG_ERROR(F("SYS config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
       gatewayState = GatewayState::ERROR;
       return;
     }
     if (jsonBuffer.isNull()) {
-      Log.warning(F("SYS config is null" CR));
+      THEENGS_LOG_WARNING(F("SYS config is null" CR));
       return;
     }
     JsonObject jo = jsonBuffer.as<JsonObject>();
     SYSConfig_fromJson(jo);
-    Log.notice(F("SYS config loaded" CR));
+    THEENGS_LOG_NOTICE(F("SYS config loaded" CR));
   } else {
     preferences.end();
-    Log.notice(F("SYS config not found" CR));
+    THEENGS_LOG_NOTICE(F("SYS config not found" CR));
   }
 }
 #else // Function not available for ESP8266
@@ -924,21 +924,21 @@ void SYSConfig_load() {}
 
 #if defined(MDNS_SD)
 std::pair<String, uint16_t> discoverMQTTbroker() {
-  Log.trace(F("Browsing for MQTT service" CR));
+  THEENGS_LOG_TRACE(F("Browsing for MQTT service" CR));
   int n = MDNS.queryService("mqtt", "tcp");
   if (n == 0) {
-    Log.warning(F("no services found" CR));
+    THEENGS_LOG_WARNING(F("no services found" CR));
   } else {
-    Log.trace(F("%d service(s) found" CR), n);
+    THEENGS_LOG_TRACE(F("%d service(s) found" CR), n);
     for (int i = 0; i < n; ++i) {
-      Log.trace(F("Service %d %s found" CR), i, MDNS.hostname(i).c_str());
-      Log.trace(F("IP %s Port %d" CR), MDNS.IP(i).toString().c_str(), MDNS.port(i));
+      THEENGS_LOG_TRACE(F("Service %d %s found" CR), i, MDNS.hostname(i).c_str());
+      THEENGS_LOG_TRACE(F("IP %s Port %d" CR), MDNS.IP(i).toString().c_str(), MDNS.port(i));
     }
     if (n == 1) {
-      Log.trace(F("One MQTT server found setting parameters" CR));
+      THEENGS_LOG_TRACE(F("One MQTT server found setting parameters" CR));
       return {MDNS.IP(0).toString(), uint16_t(MDNS.port(0))};
     } else {
-      Log.warning(F("Several MQTT servers found, please deactivate mDNS and set your default server" CR));
+      THEENGS_LOG_WARNING(F("Several MQTT servers found, please deactivate mDNS and set your default server" CR));
     }
   }
   return {"", 0};
@@ -947,7 +947,7 @@ std::pair<String, uint16_t> discoverMQTTbroker() {
 
 #if MQTT_BROKER_MODE
 void setupMQTT() {
-  Log.notice(F("Reconfiguring MQTT broker..." CR));
+  THEENGS_LOG_NOTICE(F("Reconfiguring MQTT broker..." CR));
 
   mqtt.reset(new MQTTServer());
   mqtt->begin();
@@ -966,7 +966,7 @@ struct ss_cnt_parameters_backup {
 static std::unique_ptr<ss_cnt_parameters_backup> cnt_parameters_backup;
 
 void setupMQTT() {
-  Log.notice(F("Reconfiguring MQTT client..." CR));
+  THEENGS_LOG_NOTICE(F("Reconfiguring MQTT client..." CR));
 
   const auto& parameters = cnt_parameters_array[cnt_index];
 
@@ -988,7 +988,7 @@ void setupMQTT() {
   }
 
 #  if defined(MDNS_SD)
-  Log.trace(F("Connecting to MQTT by mDNS without MQTT hostname" CR));
+  THEENGS_LOG_TRACE(F("Connecting to MQTT by mDNS without MQTT hostname" CR));
   const auto discovered_broker = discoverMQTTbroker();
   const auto broker_host = discovered_broker.first.c_str();
   const auto broker_port = discovered_broker.second;
@@ -997,8 +997,8 @@ void setupMQTT() {
   const auto broker_port = String(parameters.mqtt_port).toInt();
 #  endif
 
-  Log.trace(F("Mqtt server: %s" CR), broker_host);
-  Log.trace(F("Port: %u" CR), broker_port);
+  THEENGS_LOG_TRACE(F("Mqtt server: %s" CR), broker_host);
+  THEENGS_LOG_TRACE(F("Port: %u" CR), broker_port);
 
   mqtt.reset(new PicoMQTT::Client(*eClient, broker_host, broker_port, gateway_name,
                                   parameters.mqtt_user, parameters.mqtt_pass,
@@ -1037,10 +1037,10 @@ void setupMQTT() {
         start_reconnection_window_millis = current_millis;
       }
       reconnection_count++; // Increment reconnection count
-      Log.trace(F("MQTT connection count: %d" CR), reconnection_count);
+      THEENGS_LOG_TRACE(F("MQTT connection count: %d" CR), reconnection_count);
       if (reconnection_count > reconnection_threshold && SYSConfig.mqtt) {
         // Detected instability in MQTT connection
-        Log.warning(F("MQTT connection instability detected: %d reconnections in the last %d seconds" CR), reconnection_count, reconnection_window_millis / 1000);
+        THEENGS_LOG_WARNING(F("MQTT connection instability detected: %d reconnections in the last %d seconds" CR), reconnection_count, reconnection_window_millis / 1000);
         // Stop xtoMQTT to see if it helps and still enables to receive data
         SYSConfig.mqtt = false;
       }
@@ -1051,7 +1051,7 @@ void setupMQTT() {
 #  endif
     ProcessLock = false; // Release the loop process
     displayPrint("MQTT connected");
-    Log.notice(F("Connected to broker" CR));
+    THEENGS_LOG_NOTICE(F("Connected to broker" CR));
     gatewayState = GatewayState::BROKER_CONNECTED;
     failure_number_mqtt = 0;
     // Once connected, publish an announcement...
@@ -1059,7 +1059,7 @@ void setupMQTT() {
 
     if (cnt_parameters_backup) {
       // this was the first attempt to connect to a new server and it succeeded
-      Log.notice(F("MQTT connection parameters %d successful" CR), cnt_index);
+      THEENGS_LOG_NOTICE(F("MQTT connection parameters %d successful" CR), cnt_index);
       cnt_parameters_array[cnt_index].validConnection = true;
       readCntParameters(cnt_index);
 
@@ -1081,22 +1081,22 @@ void setupMQTT() {
     }
     failure_number_mqtt++; // we count the failure
     gatewayState = GatewayState::BROKER_DISCONNECTED;
-    Log.warning(F("failure_number_mqtt: %d" CR), failure_number_mqtt);
+    THEENGS_LOG_WARNING(F("failure_number_mqtt: %d" CR), failure_number_mqtt);
 
     const auto& parameters = cnt_parameters_array[cnt_index];
 
     if (parameters.isConnectionSecure) {
       WiFiClientSecure* client = static_cast<WiFiClientSecure*>(eClient.get());
 #  if defined(ESP32)
-      Log.warning(F("failed, ssl error code=%d" CR), client->lastError(nullptr, 0));
+      THEENGS_LOG_WARNING(F("failed, ssl error code=%d" CR), client->lastError(nullptr, 0));
 #  elif defined(ESP8266)
-      Log.warning(F("failed, ssl error code=%d" CR), client->getLastSSLError());
+      THEENGS_LOG_WARNING(F("failed, ssl error code=%d" CR), client->getLastSSLError());
 #  endif
     }
 
     if (cnt_parameters_backup) {
       // this was the first attempt to connect to a new server and it failed, revert to old settings
-      Log.error(F("MQTT connection failed, reverting to previous settings" CR));
+      THEENGS_LOG_ERROR(F("MQTT connection failed, reverting to previous settings" CR));
       gatewayState = GatewayState::ERROR;
       cnt_parameters_array[cnt_index] = cnt_parameters_backup->parameters;
       cnt_index = cnt_parameters_backup->cnt_index;
@@ -1117,11 +1117,11 @@ void setupMQTT() {
           cnt_index = 0;
         }
         if (cnt_parameters_array[cnt_index].validConnection) {
-          Log.notice(F("Connection %d valid, switching" CR), cnt_index);
+          THEENGS_LOG_NOTICE(F("Connection %d valid, switching" CR), cnt_index);
           saveConfig();
           break;
         } else {
-          Log.notice(F("Connection %d not valid" CR), cnt_index);
+          THEENGS_LOG_NOTICE(F("Connection %d not valid" CR), cnt_index);
         }
       }
 #  endif
@@ -1134,7 +1134,7 @@ void setupMQTT() {
           && ((millis_since_last_ota = millis() - last_ota_activity_millis) < ota_timeout_millis)) {
         // ... We consider that OTA might be still active, and we sleep for a while, and giving
         // OTA chance to proceed (ArduinoOTA.handle())
-        Log.warning(F("OTA might be still active (activity %d ms ago)" CR), millis_since_last_ota);
+        THEENGS_LOG_WARNING(F("OTA might be still active (activity %d ms ago)" CR), millis_since_last_ota);
         ArduinoOTA.handle();
         delay(100);
       }
@@ -1169,14 +1169,14 @@ void setESPWifiProtocolTxPower() {
   //https://www.letscontrolit.com/forum/viewtopic.php?t=671&start=20
 #  if WifiGMode == true
   if (esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G) != ESP_OK) {
-    Log.error(F("Failed to change WifiMode." CR));
+    THEENGS_LOG_ERROR(F("Failed to change WifiMode." CR));
     gatewayState = GatewayState::ERROR;
   }
 #  endif
 
 #  if WifiGMode == false
   if (esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N) != ESP_OK) {
-    Log.error(F("Failed to change WifiMode." CR));
+    THEENGS_LOG_ERROR(F("Failed to change WifiMode." CR));
     gatewayState = GatewayState::ERROR;
   }
 #  endif
@@ -1186,23 +1186,23 @@ void setESPWifiProtocolTxPower() {
   err = esp_wifi_get_protocol(WIFI_IF_STA, &getprotocol);
 
   if (err != ESP_OK) {
-    Log.notice(F("Could not get protocol!" CR));
+    THEENGS_LOG_NOTICE(F("Could not get protocol!" CR));
   }
   if (getprotocol & WIFI_PROTOCOL_11N) {
-    Log.notice(F("WiFi_Protocol_11n" CR));
+    THEENGS_LOG_NOTICE(F("WiFi_Protocol_11n" CR));
   }
   if (getprotocol & WIFI_PROTOCOL_11G) {
-    Log.notice(F("WiFi_Protocol_11g" CR));
+    THEENGS_LOG_NOTICE(F("WiFi_Protocol_11g" CR));
   }
   if (getprotocol & WIFI_PROTOCOL_11B) {
-    Log.notice(F("WiFi_Protocol_11b" CR));
+    THEENGS_LOG_NOTICE(F("WiFi_Protocol_11b" CR));
   }
 
 #  ifdef WifiPower
-  Log.notice(F("Requested WiFi power level: %i" CR), WifiPower);
+  THEENGS_LOG_NOTICE(F("Requested WiFi power level: %i" CR), WifiPower);
   WiFi.setTxPower(WifiPower);
 #  endif
-  Log.notice(F("Operating WiFi power level: %i" CR), WiFi.getTxPower());
+  THEENGS_LOG_NOTICE(F("Operating WiFi power level: %i" CR), WiFi.getTxPower());
 }
 #endif
 
@@ -1210,31 +1210,31 @@ void setESPWifiProtocolTxPower() {
 void setESPWifiProtocolTxPower() {
 #  if WifiGMode == true
   if (!wifi_set_phy_mode(PHY_MODE_11G)) {
-    Log.error(F("Failed to change WifiMode." CR));
+    THEENGS_LOG_ERROR(F("Failed to change WifiMode." CR));
     gatewayState = GatewayState::ERROR;
   }
 #  endif
 
 #  if WifiGMode == false
   if (!wifi_set_phy_mode(PHY_MODE_11N)) {
-    Log.error(F("Failed to change WifiMode." CR));
+    THEENGS_LOG_ERROR(F("Failed to change WifiMode." CR));
     gatewayState = GatewayState::ERROR;
   }
 #  endif
 
   phy_mode_t getprotocol = wifi_get_phy_mode();
   if (getprotocol == PHY_MODE_11N) {
-    Log.notice(F("WiFi_Protocol_11n" CR));
+    THEENGS_LOG_NOTICE(F("WiFi_Protocol_11n" CR));
   }
   if (getprotocol == PHY_MODE_11G) {
-    Log.notice(F("WiFi_Protocol_11g" CR));
+    THEENGS_LOG_NOTICE(F("WiFi_Protocol_11g" CR));
   }
   if (getprotocol == PHY_MODE_11B) {
-    Log.notice(F("WiFi_Protocol_11b" CR));
+    THEENGS_LOG_NOTICE(F("WiFi_Protocol_11b" CR));
   }
 
 #  ifdef WifiPower
-  Log.notice(F("Requested WiFi power level: %i dBm" CR), WifiPower);
+  THEENGS_LOG_NOTICE(F("Requested WiFi power level: %i dBm" CR), WifiPower);
 
   int i_dBm = int(WifiPower * 4.0f);
 
@@ -1335,7 +1335,7 @@ void setup() {
   //Launch serial for debugging purposes
   Serial.begin(SERIAL_BAUD);
   Log.begin(LOG_LEVEL, &Serial);
-  Log.notice(F(CR "************* WELCOME TO OpenMQTTGateway **************" CR));
+  THEENGS_LOG_NOTICE(F(CR "************* WELCOME TO OpenMQTTGateway **************" CR));
 #if defined(TRIGGER_GPIO) && !defined(ESPWifiManualSetup)
   pinMode(TRIGGER_GPIO, INPUT_PULLUP);
   checkButton();
@@ -1383,22 +1383,22 @@ void setup() {
 #  endif
 #endif
 
-  Log.notice(F("OpenMQTTGateway Version: " OMG_VERSION CR));
+  THEENGS_LOG_NOTICE(F("OpenMQTTGateway Version: " OMG_VERSION CR));
 
 #ifdef ESP32_EXT0_WAKE_PIN
-  Log.notice(F("Setting EXT0 Wakeup for deep sleep." CR));
+  THEENGS_LOG_NOTICE(F("Setting EXT0 Wakeup for deep sleep." CR));
   gpio_num_t wake_pin0 = static_cast<gpio_num_t>(ESP32_EXT0_WAKE_PIN);
   if (esp_sleep_enable_ext0_wakeup(wake_pin0, ESP32_EXT0_WAKE_PIN_STATE) != ESP_OK) {
-    Log.error(F("Failed to set deep sleep EXT0 Wakeup." CR));
+    THEENGS_LOG_ERROR(F("Failed to set deep sleep EXT0 Wakeup." CR));
     gatewayState = GatewayState::ERROR;
   }
 #endif
 #ifdef ESP32_EXT1_WAKE_PIN
-  Log.notice(F("Setting EXT1 Wakeup for deep sleep." CR));
+  THEENGS_LOG_NOTICE(F("Setting EXT1 Wakeup for deep sleep." CR));
   uint64_t wake_pin_bitmask = 1ULL << ESP32_EXT1_WAKE_PIN; // Adjust this line if multiple pins are used.
   esp_sleep_ext1_wakeup_mode_t wake_state1 = static_cast<esp_sleep_ext1_wakeup_mode_t>(ESP32_EXT1_WAKE_PIN_STATE);
   if (esp_sleep_enable_ext1_wakeup(wake_pin_bitmask, wake_state1) != ESP_OK) {
-    Log.error(F("Failed to set deep sleep EXT1 Wakeup." CR));
+    THEENGS_LOG_ERROR(F("Failed to set deep sleep EXT1 Wakeup." CR));
     gatewayState = GatewayState::ERROR;
   }
 #endif
@@ -1429,7 +1429,7 @@ void setup() {
 #else
   WiFi.mode(WIFI_STA);
   if (loadConfigFromFlash()) { // Config present
-    Log.notice(F("Config loaded from flash" CR));
+    THEENGS_LOG_NOTICE(F("Config loaded from flash" CR));
 #  ifdef ESP32_ETHERNET
     setup_ethernet_esp32();
 #  endif
@@ -1446,26 +1446,26 @@ void setup() {
     checkSerial();
 #  endif
 
-    Log.notice(F("No config in flash, launching wifi manager" CR));
+    THEENGS_LOG_NOTICE(F("No config in flash, launching wifi manager" CR));
     // In failSafeMode we don't want to setup wifi manager as it has already been done before
     if (!failSafeMode) setupWiFiManager();
   }
 
 #endif
-  Log.trace(F("OpenMQTTGateway mac: %s" CR), WiFi.macAddress().c_str());
-  Log.trace(F("OpenMQTTGateway ip: %s" CR), WiFi.localIP().toString().c_str());
-  Log.trace(F("OpenMQTTGateway index %d" CR), cnt_index);
-  Log.trace(F("OpenMQTTGateway mqtt topic: %s" CR), mqtt_topic);
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway mac: %s" CR), WiFi.macAddress().c_str());
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway ip: %s" CR), WiFi.localIP().toString().c_str());
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway index %d" CR), cnt_index);
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway mqtt topic: %s" CR), mqtt_topic);
 #ifdef ZmqttDiscovery
-  Log.trace(F("OpenMQTTGateway mqtt discovery prefix: %s" CR), discovery_prefix);
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway mqtt discovery prefix: %s" CR), discovery_prefix);
 #endif
-  Log.trace(F("OpenMQTTGateway gateway name: %s" CR), gateway_name);
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway gateway name: %s" CR), gateway_name);
 #if !MQTT_BROKER_MODE
-  Log.trace(F("OpenMQTTGateway mqtt server: %s" CR), cnt_parameters_array[cnt_index].mqtt_server);
-  Log.trace(F("OpenMQTTGateway mqtt port: %s" CR), cnt_parameters_array[cnt_index].mqtt_port);
-  Log.trace(F("OpenMQTTGateway mqtt user: %s" CR), cnt_parameters_array[cnt_index].mqtt_user);
-  Log.trace(F("OpenMQTTGateway secure connection: %s" CR), cnt_parameters_array[cnt_index].isConnectionSecure ? "true" : "false");
-  Log.trace(F("OpenMQTTGateway validate cert: %s" CR), cnt_parameters_array[cnt_index].isCertValidate ? "true" : "false");
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway mqtt server: %s" CR), cnt_parameters_array[cnt_index].mqtt_server);
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway mqtt port: %s" CR), cnt_parameters_array[cnt_index].mqtt_port);
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway mqtt user: %s" CR), cnt_parameters_array[cnt_index].mqtt_user);
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway secure connection: %s" CR), cnt_parameters_array[cnt_index].isConnectionSecure ? "true" : "false");
+  THEENGS_LOG_TRACE(F("OpenMQTTGateway validate cert: %s" CR), cnt_parameters_array[cnt_index].isCertValidate ? "true" : "false");
 #endif
 
   setOTA();
@@ -1611,12 +1611,12 @@ void setup() {
   setupRTL_433();
   modules.add(ZgatewayRTL_433);
 #endif
-  Log.trace(F("mqtt_max_payload_size: %d" CR), mqtt_max_payload_size);
-  SYSConfig.offline ? Log.notice(F("Offline enabled" CR)) : Log.notice(F("Offline disabled" CR));
+  THEENGS_LOG_TRACE(F("mqtt_max_payload_size: %d" CR), mqtt_max_payload_size);
+  SYSConfig.offline ? THEENGS_LOG_NOTICE(F("Offline enabled" CR)) : THEENGS_LOG_NOTICE(F("Offline disabled" CR));
   char jsonChar[100];
   serializeJson(modules, jsonChar, measureJson(modules) + 1);
-  Log.notice(F("OpenMQTTGateway modules: %s" CR), jsonChar);
-  Log.notice(F("************** Setup OpenMQTTGateway end **************" CR));
+  THEENGS_LOG_NOTICE(F("OpenMQTTGateway modules: %s" CR), jsonChar);
+  THEENGS_LOG_NOTICE(F("************** Setup OpenMQTTGateway end **************" CR));
 }
 
 // Bypass for ESP not reconnecting automaticaly the second time https://github.com/espressif/arduino-esp32/issues/2501
@@ -1624,7 +1624,7 @@ bool wifi_reconnect_bypass() {
 #if defined(ESP32) && defined(USE_BLUFI)
   extern bool omg_blufi_ble_connected;
   if (omg_blufi_ble_connected) {
-    Log.notice(F("BLUFI is connected, bypassing wifi reconnect" CR));
+    THEENGS_LOG_NOTICE(F("BLUFI is connected, bypassing wifi reconnect" CR));
     gatewayState = GatewayState::ONBOARDING;
     return true;
   }
@@ -1635,7 +1635,7 @@ bool wifi_reconnect_bypass() {
 #else
   while (WiFi.waitForConnectResult() != WL_CONNECTED && wifi_autoreconnect_cnt < maxConnectionRetryNetwork) {
 #endif
-    Log.notice(F("Attempting Wifi connection with saved AP: %d" CR), wifi_autoreconnect_cnt);
+    THEENGS_LOG_NOTICE(F("Attempting Wifi connection with saved AP: %d" CR), wifi_autoreconnect_cnt);
 
     WiFi.begin();
 #if defined(WifiGMode) || defined(WifiPower)
@@ -1662,7 +1662,7 @@ void setOTA() {
   ArduinoOTA.setPassword(ota_pass);
 
   ArduinoOTA.onStart([]() {
-    Log.trace(F("Start OTA, lock other functions" CR));
+    THEENGS_LOG_TRACE(F("Start OTA, lock other functions" CR));
     last_ota_activity_millis = millis();
 #ifdef ESP32
     ProcessLock = true;
@@ -1673,13 +1673,13 @@ void setOTA() {
     lpDisplayPrint("OTA in progress");
   });
   ArduinoOTA.onEnd([]() {
-    Log.trace(F("\nOTA done" CR));
+    THEENGS_LOG_TRACE(F("\nOTA done" CR));
     last_ota_activity_millis = 0;
     lpDisplayPrint("OTA done");
     ESPRestart(6);
   });
   ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
-    Log.trace(F("Progress: %u%%\r" CR), (progress / (total / 100)));
+    THEENGS_LOG_TRACE(F("Progress: %u%%\r" CR), (progress / (total / 100)));
     gatewayState = GatewayState::LOCAL_OTA_IN_PROGRESS;
     last_ota_activity_millis = millis();
   });
@@ -1688,15 +1688,15 @@ void setOTA() {
     Serial.printf("Error[%u]: ", error);
     gatewayState = GatewayState::ERROR;
     if (error == OTA_AUTH_ERROR)
-      Log.error(F("Auth Failed" CR));
+      THEENGS_LOG_ERROR(F("Auth Failed" CR));
     else if (error == OTA_BEGIN_ERROR)
-      Log.error(F("Begin Failed" CR));
+      THEENGS_LOG_ERROR(F("Begin Failed" CR));
     else if (error == OTA_CONNECT_ERROR)
-      Log.error(F("Connect Failed" CR));
+      THEENGS_LOG_ERROR(F("Connect Failed" CR));
     else if (error == OTA_RECEIVE_ERROR)
-      Log.error(F("Receive Failed" CR));
+      THEENGS_LOG_ERROR(F("Receive Failed" CR));
     else if (error == OTA_END_ERROR)
-      Log.error(F("End Failed" CR));
+      THEENGS_LOG_ERROR(F("End Failed" CR));
     ESPRestart(6);
   });
   ArduinoOTA.begin();
@@ -1706,27 +1706,27 @@ void setOTA() {
 void setupTLS(int index) {
   configTime(0, 0, NTP_SERVER);
   WiFiClientSecure* sClient = static_cast<WiFiClientSecure*>(eClient.get());
-  Log.notice(F("cnt index used: %d" CR), index);
+  THEENGS_LOG_NOTICE(F("cnt index used: %d" CR), index);
   if (!cnt_parameters_array[index].isCertValidate) {
-    Log.notice(F("Disabling cert validation" CR));
+    THEENGS_LOG_NOTICE(F("Disabling cert validation" CR));
     sClient->setInsecure();
   } else {
-    Log.notice(F("Enabling cert validation" CR));
+    THEENGS_LOG_NOTICE(F("Enabling cert validation" CR));
 #  if defined(ESP32)
     if (cnt_parameters_array[index].server_cert.length() > MIN_CERT_LENGTH) {
       sClient->setCACert(cnt_parameters_array[index].server_cert.c_str());
-      Log.notice(F("Server cert found from cert array" CR));
+      THEENGS_LOG_NOTICE(F("Server cert found from cert array" CR));
     } else if (strlen(ss_server_cert) > MIN_CERT_LENGTH) {
       sClient->setCACert(ss_server_cert);
-      Log.notice(F("Server cert found from ss_server_cert" CR));
+      THEENGS_LOG_NOTICE(F("Server cert found from ss_server_cert" CR));
     } else {
-      Log.error(F("No server cert found" CR));
+      THEENGS_LOG_ERROR(F("No server cert found" CR));
       gatewayState = GatewayState::ERROR;
     }
 
 #    if AWS_IOT
     if (strcmp(cnt_parameters_array[index].mqtt_port, "443") == 0) {
-      Log.notice(F("Using ALPN" CR));
+      THEENGS_LOG_NOTICE(F("Using ALPN" CR));
       static const char* alpnProtocols[] = ALPN_PROTOCOLS;
       sClient->setAlpnProtocols(alpnProtocols);
     }
@@ -1734,22 +1734,22 @@ void setupTLS(int index) {
 #    if MQTT_SECURE_SIGNED_CLIENT
     if (cnt_parameters_array[index].client_cert.length() > MIN_CERT_LENGTH) {
       sClient->setCertificate(cnt_parameters_array[index].client_cert.c_str());
-      Log.notice(F("Client cert found from cert array" CR));
+      THEENGS_LOG_NOTICE(F("Client cert found from cert array" CR));
     } else if (strlen(ss_client_cert) > MIN_CERT_LENGTH) {
       sClient->setCertificate(ss_client_cert);
-      Log.notice(F("Client cert found from ss_client_cert" CR));
+      THEENGS_LOG_NOTICE(F("Client cert found from ss_client_cert" CR));
     } else {
-      Log.error(F("No client cert found" CR));
+      THEENGS_LOG_ERROR(F("No client cert found" CR));
       gatewayState = GatewayState::ERROR;
     }
     if (cnt_parameters_array[index].client_key.length() > MIN_CERT_LENGTH) {
       sClient->setPrivateKey(cnt_parameters_array[index].client_key.c_str());
-      Log.notice(F("Client key found from cert array" CR));
+      THEENGS_LOG_NOTICE(F("Client key found from cert array" CR));
     } else if (strlen(ss_client_key) > MIN_CERT_LENGTH) {
       sClient->setPrivateKey(ss_client_key);
-      Log.notice(F("Client key found from ss_client_key" CR));
+      THEENGS_LOG_NOTICE(F("Client key found from ss_client_key" CR));
     } else {
-      Log.error(F("No client key found" CR));
+      THEENGS_LOG_ERROR(F("No client key found" CR));
       gatewayState = GatewayState::ERROR;
     }
 #    endif
@@ -1790,7 +1790,7 @@ void ESPRestart(byte reason) {
 #ifdef SecondaryModule
   // Erase the secondary module config
   String restartCmdStr = "{\"cmd\":\"" + String(restartCmd) + "\"}";
-  Log.notice(F("Restarting secondary module : %s" CR), restartCmdStr.c_str());
+  THEENGS_LOG_NOTICE(F("Restarting secondary module : %s" CR), restartCmdStr.c_str());
   receivingDATA(subjectMQTTtoSYSsetSecondaryModule, restartCmdStr.c_str());
   delay(2000);
 #endif
@@ -1805,7 +1805,7 @@ void ESPRestart(byte reason) {
   while (!jsonQueue.empty()) {
     jsonQueue.pop();
   }
-  Log.warning(F("Rebooting for reason code %d" CR), reason);
+  THEENGS_LOG_WARNING(F("Rebooting for reason code %d" CR), reason);
 #if defined(ESP32)
   ESP.restart();
 #elif defined(ESP8266)
@@ -1817,10 +1817,10 @@ void ESPRestart(byte reason) {
 void setupWiFiFromBuild() {
   WiFi.mode(WIFI_STA);
   wifiMulti.addAP(wifi_ssid, wifi_password);
-  Log.trace(F("Connecting to %s" CR), wifi_ssid);
+  THEENGS_LOG_TRACE(F("Connecting to %s" CR), wifi_ssid);
 #  ifdef wifi_ssid1
   wifiMulti.addAP(wifi_ssid1, wifi_password1);
-  Log.trace(F("Connecting to %s" CR), wifi_ssid1);
+  THEENGS_LOG_TRACE(F("Connecting to %s" CR), wifi_ssid1);
 #  endif
   delay(10);
 
@@ -1837,7 +1837,7 @@ void setupWiFiFromBuild() {
   dns_adress.fromString(NET_DNS);
 
   if (!WiFi.config(ip_adress, gateway_adress, subnet_adress, dns_adress)) {
-    Log.error(F("Wifi STA Failed to configure" CR));
+    THEENGS_LOG_ERROR(F("Wifi STA Failed to configure" CR));
     gatewayState = GatewayState::ERROR;
   }
 
@@ -1845,7 +1845,7 @@ void setupWiFiFromBuild() {
 
   while (wifiMulti.run() != WL_CONNECTED) {
     delay(500);
-    Log.trace(F("." CR));
+    THEENGS_LOG_TRACE(F("." CR));
     failure_number_ntwk++;
 #  if defined(ESP32) && defined(ZgatewayBT)
     if (SYSConfig.powerMode) {
@@ -1863,7 +1863,7 @@ void setupWiFiFromBuild() {
     }
 #  endif
   }
-  Log.notice(F("WiFi ok with manual config credentials" CR));
+  THEENGS_LOG_NOTICE(F("WiFi ok with manual config credentials" CR));
   displayPrint("Wifi connected");
 }
 
@@ -1877,7 +1877,7 @@ bool shouldSaveConfig = false;
 
 //callback notifying us of the need to save config
 void saveConfigCallback() {
-  Log.trace(F("Should save config" CR));
+  THEENGS_LOG_TRACE(F("Should save config" CR));
   shouldSaveConfig = true;
 }
 
@@ -1889,10 +1889,10 @@ void blockingWaitForReset() {
   if (digitalRead(TRIGGER_GPIO) == LOW) {
     delay(50);
     if (digitalRead(TRIGGER_GPIO) == LOW) {
-      Log.trace(F("Trigger button Pressed" CR));
+      THEENGS_LOG_TRACE(F("Trigger button Pressed" CR));
       delay(3000); // reset delay hold
       if (digitalRead(TRIGGER_GPIO) == LOW) {
-        Log.notice(F("Button Held" CR));
+        THEENGS_LOG_NOTICE(F("Button Held" CR));
 // Switching off the relay during reset or failsafe operations
 #    ifdef ZactuatorONOFF
         extern void ActuatorTrigger();
@@ -1905,15 +1905,15 @@ void blockingWaitForReset() {
         // Checking if the flash has already been erased to identify if we erase it or go into failsafe mode
         // going to failsafe mode is done by doing a long button press from a state where the flash has already been erased
         if (SPIFFS.begin()) {
-          Log.trace(F("mounted file system" CR));
+          THEENGS_LOG_TRACE(F("mounted file system" CR));
           if (SPIFFS.exists("/config.json")) {
-            Log.notice(F("Erasing ESP Config, restarting" CR));
+            THEENGS_LOG_NOTICE(F("Erasing ESP Config, restarting" CR));
             eraseConfig();
           }
         }
         delay(30000);
         if (digitalRead(TRIGGER_GPIO) == LOW) {
-          Log.notice(F("Going into failsafe mode without peripherals" CR));
+          THEENGS_LOG_NOTICE(F("Going into failsafe mode without peripherals" CR));
           // Failsafe mode enable to connect to Wifi or change the firmware without the peripherals setup
           failSafeMode = true;
           setupWiFiManager();
@@ -1944,7 +1944,7 @@ void checkButton() {}
 #  endif
 
 void saveConfig() {
-  Log.trace(F("saving configs" CR));
+  THEENGS_LOG_TRACE(F("saving configs" CR));
 
   int totalSize = 512;
 #  if !MQTT_BROKER_MODE
@@ -1958,7 +1958,7 @@ void saveConfig() {
   }
 #  endif
 
-  Log.notice(F("Total size: %d" CR), totalSize);
+  THEENGS_LOG_NOTICE(F("Total size: %d" CR), totalSize);
 
   DynamicJsonDocument json(512 + totalSize);
 
@@ -2035,7 +2035,7 @@ void saveConfig() {
 
   File configFile = SPIFFS.open("/config.json", "w");
   if (!configFile) {
-    Log.error(F("failed to open config file for writing" CR));
+    THEENGS_LOG_ERROR(F("failed to open config file for writing" CR));
     gatewayState = GatewayState::ERROR;
   }
 
@@ -2044,31 +2044,31 @@ void saveConfig() {
 }
 
 bool loadConfigFromFlash() {
-  Log.trace(F("mounting FS..." CR));
+  THEENGS_LOG_TRACE(F("mounting FS..." CR));
   bool result = false;
 
   if (SPIFFS.begin()) {
-    Log.trace(F("mounted file system" CR));
+    THEENGS_LOG_TRACE(F("mounted file system" CR));
   } else {
-    Log.warning(F("failed to mount FS -> formating" CR));
+    THEENGS_LOG_WARNING(F("failed to mount FS -> formating" CR));
     SPIFFS.format();
     if (SPIFFS.begin())
-      Log.trace(F("mounted file system after formating" CR));
+      THEENGS_LOG_TRACE(F("mounted file system after formating" CR));
   }
   if (SPIFFS.exists("/config.json")) {
     //file exists, reading and loading
-    Log.trace(F("reading config file" CR));
+    THEENGS_LOG_TRACE(F("reading config file" CR));
     File configFile = SPIFFS.open("/config.json", "r");
     if (configFile) {
-      Log.trace(F("opened config file" CR));
+      THEENGS_LOG_TRACE(F("opened config file" CR));
       DynamicJsonDocument json(configFile.size() * 2);
       auto error = deserializeJson(json, configFile);
       if (error) {
-        Log.error(F("deserialize config failed: %s, buffer capacity: %u" CR), error.c_str(), json.capacity());
+        THEENGS_LOG_ERROR(F("deserialize config failed: %s, buffer capacity: %u" CR), error.c_str(), json.capacity());
         gatewayState = GatewayState::ERROR;
       }
       if (!json.isNull()) {
-        Log.trace(F("\nparsed json, size: %u" CR), json.memoryUsage());
+        THEENGS_LOG_TRACE(F("\nparsed json, size: %u" CR), json.memoryUsage());
         // Print json to serial port
         //serializeJsonPretty(json, Serial);
 
@@ -2106,9 +2106,9 @@ bool loadConfigFromFlash() {
             // Compare the hash with the expected hash
             if (hash == GITHUB_OTA_SERVER_CERT_HASH) {
               // Do nothing
-              Log.warning(F("Old Github OTA server detected, skipping" CR));
+              THEENGS_LOG_WARNING(F("Old Github OTA server detected, skipping" CR));
             } else {
-              Log.notice(F("OTA server cert hash: %s" CR), hash.c_str());
+              THEENGS_LOG_NOTICE(F("OTA server cert hash: %s" CR), hash.c_str());
               cnt_parameters_array[i].ota_server_cert = json["ota_server_cert"].as<const char*>();
             }
 #    else
@@ -2151,7 +2151,7 @@ bool loadConfigFromFlash() {
             cnt_parameters_array[i].validConnection = json[key].as<bool>();
           } else if (i == CNT_DEFAULT_INDEX) {
             // For backward compatibility, if valid_cnt is not found, we assume the connection is valid for CNT_DEFAULT_INDEX
-            Log.warning(F("valid_cnt not found, assuming connection is valid" CR));
+            THEENGS_LOG_WARNING(F("valid_cnt not found, assuming connection is valid" CR));
             cnt_parameters_array[i].validConnection = true;
           }
         }
@@ -2182,21 +2182,21 @@ bool loadConfigFromFlash() {
 #  if BLEDecryptor
         if (json.containsKey("ble_aes")) {
           strcpy(ble_aes, json["ble_aes"]);
-          Log.trace(F("loaded default BLE AES key %s" CR), ble_aes);
+          THEENGS_LOG_TRACE(F("loaded default BLE AES key %s" CR), ble_aes);
         }        
         if (json.containsKey("ble_aes_keys")) {
           ble_aes_keys = json["ble_aes_keys"];
-          Log.trace(F("loaded %d custom BLE AES keys" CR), ble_aes_keys.size());
+          THEENGS_LOG_TRACE(F("loaded %d custom BLE AES keys" CR), ble_aes_keys.size());
         }        
 #  endif
         result = true;
       } else {
-        Log.warning(F("failed to load json config" CR));
+        THEENGS_LOG_WARNING(F("failed to load json config" CR));
       }
       configFile.close();
     }
   } else {
-    Log.notice(F("No config file found defining default values" CR));
+    THEENGS_LOG_NOTICE(F("No config file found defining default values" CR));
 #  ifdef USE_MAC_AS_GATEWAY_NAME
     String s = WiFi.macAddress();
     sprintf(gateway_name, "%.2s%.2s%.2s%.2s%.2s%.2s",
@@ -2218,7 +2218,7 @@ void setupWiFiManager() {
   String s = WiFi.macAddress();
   snprintf(WifiManager_ssid, MAC_NAME_MAX_LEN, "%s_%.2s%.2s", Gateway_Short_Name, s.c_str(), s.c_str() + 3);
   strcpy(ota_hostname, WifiManager_ssid);
-  Log.notice(F("OTA Hostname: %s.local" CR), ota_hostname);
+  THEENGS_LOG_NOTICE(F("OTA Hostname: %s.local" CR), ota_hostname);
 #  endif
 
   wifiManager.setDebugOutput(WM_DEBUG);
@@ -2257,7 +2257,7 @@ void setupWiFiManager() {
 
 //set static IP
 #  ifdef NetworkAdvancedSetup
-  Log.trace(F("Adv wifi cfg" CR));
+  THEENGS_LOG_TRACE(F("Adv wifi cfg" CR));
   IPAddress ip_adress;
   IPAddress gateway_adress;
   IPAddress subnet_adress;
@@ -2293,7 +2293,7 @@ void setupWiFiManager() {
   wifiManager.setMinimumSignalQuality(MinimumWifiSignalQuality);
 
   if (SPIFFS.begin()) {
-    Log.trace(F("mounted file system" CR));
+    THEENGS_LOG_TRACE(F("mounted file system" CR));
     // Check if the config file exists and prevent the portal from showing if yes
     // Showing the portal if the config file exist would enable access to the configuration data and to the ESP update page
     // This is a security risk if an attacker has access to the gateway password
@@ -2308,13 +2308,13 @@ void setupWiFiManager() {
 
   if (!SYSConfig.offline && !wifi_reconnect_bypass()) // if we didn't connect with saved credential we start Wifimanager web portal
   {
-    Log.notice(F("Connect your phone to WIFI AP: %s with PWD: %s" CR), WifiManager_ssid, ota_pass);
+    THEENGS_LOG_NOTICE(F("Connect your phone to WIFI AP: %s with PWD: %s" CR), WifiManager_ssid, ota_pass);
     gatewayState = GatewayState::ONBOARDING;
     //fetches ssid and pass and tries to connect
     //if it does not connect it starts an access point with the specified name
     //and goes into a blocking loop awaiting configuration
     if (!wifiManager.autoConnect(WifiManager_ssid, ota_pass)) {
-      Log.warning(F("failed to connect and hit timeout" CR));
+      THEENGS_LOG_WARNING(F("failed to connect and hit timeout" CR));
       delay(3000);
 
 #  ifdef ESP32
@@ -2407,22 +2407,22 @@ void setup_ethernet_esp32() {
   subnet.fromString(NET_MASK);
   Dns.fromString(NET_DNS);
 
-  Log.trace(F("Adv eth cfg" CR));
+  THEENGS_LOG_TRACE(F("Adv eth cfg" CR));
   ETH.config(ip, gateway, subnet, Dns);
   ethBeginSuccess = ETH.begin();
 #    else
-  Log.notice(F("Spl eth cfg" CR));
+  THEENGS_LOG_NOTICE(F("Spl eth cfg" CR));
   ethBeginSuccess = ETH.begin();
 #    endif
   if (ethBeginSuccess) {
-    Log.notice(F("Ethernet started" CR));
+    THEENGS_LOG_NOTICE(F("Ethernet started" CR));
     while (!ethConnected && failure_number_ntwk <= maxConnectionRetryNetwork) {
       delay(500);
-      Log.notice(F("." CR));
+      THEENGS_LOG_NOTICE(F("." CR));
       failure_number_ntwk++;
     }
   } else {
-    Log.error(F("Ethernet not started" CR));
+    THEENGS_LOG_ERROR(F("Ethernet not started" CR));
     gatewayState = GatewayState::ERROR;
   }
 }
@@ -2430,25 +2430,25 @@ void setup_ethernet_esp32() {
 void WiFiEvent(WiFiEvent_t event) {
   switch (event) {
     case ARDUINO_EVENT_ETH_START:
-      Log.trace(F("Ethernet Started" CR));
+      THEENGS_LOG_TRACE(F("Ethernet Started" CR));
       ETH.setHostname(gateway_name);
       break;
     case ARDUINO_EVENT_ETH_CONNECTED:
-      Log.notice(F("Ethernet Connected" CR));
+      THEENGS_LOG_NOTICE(F("Ethernet Connected" CR));
       break;
     case ARDUINO_EVENT_ETH_GOT_IP:
-      Log.notice(F("OpenMQTTGateway Ethernet MAC: %s" CR), ETH.macAddress().c_str());
-      Log.notice(F("OpenMQTTGateway Ethernet IP: %s" CR), ETH.localIP().toString().c_str());
-      Log.notice(F("OpenMQTTGateway Ethernet link speed: %d Mbps" CR), ETH.linkSpeed());
+      THEENGS_LOG_NOTICE(F("OpenMQTTGateway Ethernet MAC: %s" CR), ETH.macAddress().c_str());
+      THEENGS_LOG_NOTICE(F("OpenMQTTGateway Ethernet IP: %s" CR), ETH.localIP().toString().c_str());
+      THEENGS_LOG_NOTICE(F("OpenMQTTGateway Ethernet link speed: %d Mbps" CR), ETH.linkSpeed());
       gatewayState = GatewayState::NTWK_CONNECTED;
       ethConnected = true;
       break;
     case ARDUINO_EVENT_ETH_DISCONNECTED:
-      Log.warning(F("Ethernet Disconnected" CR));
+      THEENGS_LOG_WARNING(F("Ethernet Disconnected" CR));
       ethConnected = false;
       break;
     case ARDUINO_EVENT_ETH_STOP:
-      Log.warning(F("Ethernet Stopped" CR));
+      THEENGS_LOG_WARNING(F("Ethernet Stopped" CR));
       ethConnected = false;
       break;
     default:
@@ -2466,14 +2466,14 @@ void WiFiEvent(WiFiEvent_t event) {
 void sleep() {
   if (SYSConfig.powerMode < PowerMode::INTERVAL)
     return;
-  Log.notice(F("Entering deep sleep" CR));
+  THEENGS_LOG_NOTICE(F("Entering deep sleep" CR));
   gatewayState = GatewayState::SLEEPING;
   delay(250); // To allow the LEDs to switch off and MQTT message to be sent
 #  if defined(ZboardM5STACK) || defined(ZboardM5STICKC) || defined(ZboardM5STICKCP) || defined(ZboardM5TOUGH)
   sleepScreen();
   esp_sleep_enable_ext0_wakeup((gpio_num_t)SLEEP_BUTTON, LOW);
 #  endif
-  Log.trace(F("Deactivating ESP32 components" CR));
+  THEENGS_LOG_TRACE(F("Deactivating ESP32 components" CR));
 #  ifdef ZgatewayBT
   stopProcessing(true);
   ProcessLock = true;
@@ -2484,15 +2484,15 @@ void sleep() {
 #  pragma GCC diagnostic pop
   esp_wifi_stop();
 #  ifdef ESP32_EXT0_WAKE_PIN
-  Log.notice(F("Entering deep sleep, EXT0 Wakeup by pin : %l." CR), ESP32_EXT0_WAKE_PIN);
+  THEENGS_LOG_NOTICE(F("Entering deep sleep, EXT0 Wakeup by pin : %l." CR), ESP32_EXT0_WAKE_PIN);
 #  endif
 #  ifdef ESP32_EXT1_WAKE_PIN
-  Log.notice(F("Entering deep sleep, EXT1 Wakeup by pin : %l." CR), ESP32_EXT1_WAKE_PIN);
+  THEENGS_LOG_NOTICE(F("Entering deep sleep, EXT1 Wakeup by pin : %l." CR), ESP32_EXT1_WAKE_PIN);
 #  endif
   if (SYSConfig.powerMode == PowerMode::ACTION) {
     esp_deep_sleep_start();
   } else if (SYSConfig.powerMode == PowerMode::INTERVAL) {
-    Log.notice(F("Entering deep sleep for %l us." CR), DEEP_SLEEP_IN_US);
+    THEENGS_LOG_NOTICE(F("Entering deep sleep for %l us." CR), DEEP_SLEEP_IN_US);
     esp_deep_sleep(DEEP_SLEEP_IN_US);
   }
 }
@@ -2568,7 +2568,7 @@ void loop() {
 #endif
     }
   } else if (!SYSConfig.offline && !SYSConfig.serial) { // disconnected from network
-    Log.warning(F("Network disconnected" CR));
+    THEENGS_LOG_WARNING(F("Network disconnected" CR));
     gatewayState = GatewayState::NTWK_DISCONNECTED;
     if (!wifi_reconnect_bypass()) {
       sleep();
@@ -2580,7 +2580,7 @@ void loop() {
 #if defined(ESP32) && defined(USE_BLUFI)
   if (SYSConfig.blufi) {
     if (gatewayState != previousGatewayState) {
-      Log.notice(F("Gateway state changed to: %d" CR), gatewayState);
+      THEENGS_LOG_NOTICE(F("Gateway state changed to: %d" CR), gatewayState);
       previousGatewayState = gatewayState;
       set_blufi_mfg_data();
     }
@@ -2712,11 +2712,11 @@ void loop() {
 #endif
 #ifdef Zgateway2G
     if (_2GtoX())
-      Log.trace(F("2GtoMQTT OK" CR));
+      THEENGS_LOG_TRACE(F("2GtoMQTT OK" CR));
 #endif
 #ifdef ZgatewayRFM69
     if (RFM69toX())
-      Log.trace(F("RFM69toMQTT OK" CR));
+      THEENGS_LOG_TRACE(F("RFM69toMQTT OK" CR));
 #endif
 #ifdef ZactuatorFASTLED
     FASTLEDLoop();
@@ -2783,11 +2783,11 @@ void eraseConfig() {
 #ifdef SecondaryModule
   // Erase the secondary module config
   String eraseCmdStr = "{\"cmd\":\"" + String(eraseCmd) + "\"}";
-  Log.notice(F("Erasing secondary module config: %s" CR), eraseCmdStr.c_str());
+  THEENGS_LOG_NOTICE(F("Erasing secondary module config: %s" CR), eraseCmdStr.c_str());
   receivingDATA(subjectMQTTtoSYSsetSecondaryModule, eraseCmdStr.c_str());
   delay(2000);
 #endif
-  Log.trace(F("Formatting requested, result: %d" CR), SPIFFS.format());
+  THEENGS_LOG_TRACE(F("Formatting requested, result: %d" CR), SPIFFS.format());
 
 #if defined(ESP8266)
   WiFi.disconnect(true);
@@ -2822,7 +2822,7 @@ String stateMeasures() {
 #ifdef ZgatewayRTL_433
   // Some RTL_433 decoders have memory leak, this is a temporary workaround
   if (freeMem < MinimumMemory) {
-    Log.error(F("Not enough memory %d, restarting" CR), freeMem);
+    THEENGS_LOG_ERROR(F("Not enough memory %d, restarting" CR), freeMem);
     gatewayState = GatewayState::ERROR;
     ESPRestart(8);
   }
@@ -2901,7 +2901,7 @@ String stateMeasures() {
 
   String output;
   serializeJson(SYSdata, output);
-  Log.notice(F("SYS json: %s" CR), output.c_str());
+  THEENGS_LOG_NOTICE(F("SYS json: %s" CR), output.c_str());
   return output;
 }
 
@@ -2913,16 +2913,16 @@ void storeSignalValue(uint64_t MQTTvalue) {
   unsigned long now = millis();
   // find oldest value of the buffer
   int o = getMin();
-  Log.trace(F("Min ind: %d" CR), o);
+  THEENGS_LOG_TRACE(F("Min ind: %d" CR), o);
   // replace it by the new one
   receivedSignal[o].value = MQTTvalue;
   receivedSignal[o].time = now;
 
   // Casting "receivedSignal[o].value" to (unsigned long) because ArduinoLog doesn't support uint64_t for ESP's
-  Log.trace(F("store code : %u / %u" CR), (unsigned long)receivedSignal[o].value, receivedSignal[o].time);
-  Log.trace(F("Col: val/timestamp" CR));
+  THEENGS_LOG_TRACE(F("store code : %u / %u" CR), (unsigned long)receivedSignal[o].value, receivedSignal[o].time);
+  THEENGS_LOG_TRACE(F("Col: val/timestamp" CR));
   for (int i = 0; i < struct_size; i++) {
-    Log.trace(F("mem code : %u / %u" CR), (unsigned long)receivedSignal[i].value, receivedSignal[i].time);
+    THEENGS_LOG_TRACE(F("mem code : %u / %u" CR), (unsigned long)receivedSignal[i].value, receivedSignal[i].time);
   }
 }
 
@@ -2945,12 +2945,12 @@ int getMin() {
  * Check if signal values from RF, IR, SRFB or Weather stations are duplicates
  */
 bool isAduplicateSignal(uint64_t value) {
-  Log.trace(F("isAdupl?" CR));
+  THEENGS_LOG_TRACE(F("isAdupl?" CR));
   for (int i = 0; i < struct_size; i++) {
     if (receivedSignal[i].value == value) {
       unsigned long now = millis();
       if (now - receivedSignal[i].time < time_avoid_duplicate) { // change
-        Log.trace(F("no pub. dupl" CR));
+        THEENGS_LOG_TRACE(F("no pub. dupl" CR));
         return true;
       }
     }
@@ -2965,17 +2965,17 @@ void receivingDATA(const char* topicOri, const char* datacallback) {
   JsonObject jsondata = jsonBuffer.to<JsonObject>();
   DeserializationError error = deserializeJson(jsonBuffer, datacallback);
   if (error || jsondata.isNull()) {
-    Log.error(F("deserialize MQTT data failed: %s" CR), error.c_str());
+    THEENGS_LOG_ERROR(F("deserialize MQTT data failed: %s" CR), error.c_str());
     gatewayState = GatewayState::ERROR;
     return;
   }
   if (topicOri == nullptr || strcmp(topicOri, "") == 0) {
     if (jsondata.containsKey("target") && jsondata["target"].is<const char*>()) {
       strTopicOri = jsondata["target"].as<const char*>();
-      Log.trace(F("BUS Msg target: %s" CR), strTopicOri.c_str());
+      THEENGS_LOG_TRACE(F("BUS Msg target: %s" CR), strTopicOri.c_str());
     } else if (jsondata.containsKey("origin") && jsondata["origin"].is<const char*>()) {
       strTopicOri = jsondata["origin"].as<const char*>();
-      Log.trace(F("BUS Msg origin: %s" CR), strTopicOri.c_str());
+      THEENGS_LOG_TRACE(F("BUS Msg origin: %s" CR), strTopicOri.c_str());
     }
   } else {
 #if defined(SecondaryModule) // Redirect certain commands to Serial
@@ -2995,7 +2995,7 @@ void receivingDATA(const char* topicOri, const char* datacallback) {
       jsondata["target"] = subjectMQTTtoSYSsetSecondaryModule;
     }
 #endif
-    Log.trace(F("MQTT Msg topic: %s" CR), strTopicOri.c_str());
+    THEENGS_LOG_TRACE(F("MQTT Msg topic: %s" CR), strTopicOri.c_str());
   }
 
 #if defined(ZgatewayRF) || defined(ZgatewayIR) || defined(ZgatewaySRFB) || defined(ZgatewayWeatherStation)
@@ -3011,7 +3011,7 @@ void receivingDATA(const char* topicOri, const char* datacallback) {
     // log the received json
     String buffer = "";
     serializeJson(jsondata, buffer);
-    //Log.notice(F("[ MQTT->OMG ]: %s" CR), buffer.c_str());
+    //THEENGS_LOG_NOTICE(F("[ MQTT->OMG ]: %s" CR), buffer.c_str());
 
 #ifdef ZgatewayPilight // ZgatewayPilight is only defined with json publishing due to its numerous parameters
     extern void XtoPilight(const char* topicOri, JsonObject& RFdata);
@@ -3122,7 +3122,7 @@ String latestVersion;
  * Only available for ESP32
  */
 bool checkForUpdates() {
-  Log.notice(F("Update check, free heap: %d"), ESP.getFreeHeap());
+  THEENGS_LOG_NOTICE(F("Update check, free heap: %d"), ESP.getFreeHeap());
   HTTPClient http;
   http.setTimeout((GeneralTimeOut - 1) * 1000); // -1 to avoid WDT
   http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
@@ -3130,12 +3130,12 @@ bool checkForUpdates() {
   std::string ota_cert;
 #      if !MQTT_BROKER_MODE
   if (cnt_parameters_array[cnt_index].ota_server_cert.length() > MIN_CERT_LENGTH) {
-    Log.notice(F("Using memory cert" CR));
+    THEENGS_LOG_NOTICE(F("Using memory cert" CR));
     ota_cert = cnt_parameters_array[cnt_index].ota_server_cert;
   } else
 #      endif
   {
-    Log.notice(F("Using config cert" CR));
+    THEENGS_LOG_NOTICE(F("Using config cert" CR));
     ota_cert = OTAserver_cert;
   }
 
@@ -3148,17 +3148,17 @@ bool checkForUpdates() {
     String payload = http.getString();
     auto error = deserializeJson(jsonBuffer, payload);
     if (error) {
-      Log.error(F("Deserialize MQTT data failed: %s" CR), error.c_str());
+      THEENGS_LOG_ERROR(F("Deserialize MQTT data failed: %s" CR), error.c_str());
       gatewayState = GatewayState::ERROR;
     }
-    Log.trace(F("HttpCode %d" CR), httpCode);
-    Log.trace(F("Payload %s" CR), payload.c_str());
+    THEENGS_LOG_TRACE(F("HttpCode %d" CR), httpCode);
+    THEENGS_LOG_TRACE(F("Payload %s" CR), payload.c_str());
   } else {
-    Log.error(F("Error on HTTP request"));
+    THEENGS_LOG_ERROR(F("Error on HTTP request"));
     gatewayState = GatewayState::ERROR;
   }
   http.end(); //Free the resources
-  Log.notice(F("Update check done, free heap: %d"), ESP.getFreeHeap());
+  THEENGS_LOG_NOTICE(F("Update check done, free heap: %d"), ESP.getFreeHeap());
   if (jsondata.containsKey("latest_version")) {
     jsondata["installed_version"] = OMG_VERSION;
     jsondata["entity_picture"] = ENTITY_PICTURE;
@@ -3169,10 +3169,10 @@ bool checkForUpdates() {
     jsondata["retain"] = true;
     enqueueJsonObject(jsondata);
 
-    Log.trace(F("Update file found on server" CR));
+    THEENGS_LOG_TRACE(F("Update file found on server" CR));
     return true;
   } else {
-    Log.trace(F("No update file found on server" CR));
+    THEENGS_LOG_TRACE(F("No update file found on server" CR));
     return false;
   }
 }
@@ -3194,7 +3194,7 @@ void MQTTHttpsFWUpdate(const char* topicOri, JsonObject& HttpsFwUpdateData) {
       String systemUrl;
       if (url) {
         if (!strstr((url + (strlen(url) - 5)), ".bin")) {
-          Log.error(F("Invalid firmware extension" CR));
+          THEENGS_LOG_ERROR(F("Invalid firmware extension" CR));
           gatewayState = GatewayState::ERROR;
           return;
         }
@@ -3202,12 +3202,12 @@ void MQTTHttpsFWUpdate(const char* topicOri, JsonObject& HttpsFwUpdateData) {
         const char* pwd = HttpsFwUpdateData["password"];
         if (pwd) {
           if (strcmp(pwd, ota_pass) != 0) {
-            Log.error(F("Invalid OTA password" CR));
+            THEENGS_LOG_ERROR(F("Invalid OTA password" CR));
             gatewayState = GatewayState::ERROR;
             return;
           }
         } else {
-          Log.error(F("No password sent" CR));
+          THEENGS_LOG_ERROR(F("No password sent" CR));
           gatewayState = GatewayState::ERROR;
           return;
         }
@@ -3216,18 +3216,18 @@ void MQTTHttpsFWUpdate(const char* topicOri, JsonObject& HttpsFwUpdateData) {
       } else if (strcmp(version, "latest") == 0) {
         systemUrl = RELEASE_LINK + latestVersion + "/" + ENV_NAME + "-firmware.bin";
         url = systemUrl.c_str();
-        Log.notice(F("Using system OTA url with latest version %s" CR), url);
+        THEENGS_LOG_NOTICE(F("Using system OTA url with latest version %s" CR), url);
       } else if (strcmp(version, "dev") == 0) {
         systemUrl = String(RELEASE_LINK_DEV) + ENV_NAME + "-firmware.bin";
         url = systemUrl.c_str();
-        Log.notice(F("Using system OTA url with dev version %s" CR), url);
+        THEENGS_LOG_NOTICE(F("Using system OTA url with dev version %s" CR), url);
       } else if (version[0] == 'v') {
         systemUrl = String(RELEASE_LINK) + version + "/" + ENV_NAME + "-firmware.bin";
         url = systemUrl.c_str();
-        Log.notice(F("Using system OTA url with defined version %s" CR), url);
+        THEENGS_LOG_NOTICE(F("Using system OTA url with defined version %s" CR), url);
 #  endif
       } else {
-        Log.error(F("Invalid URL" CR));
+        THEENGS_LOG_ERROR(F("Invalid URL" CR));
         gatewayState = GatewayState::ERROR;
         return;
       }
@@ -3237,7 +3237,7 @@ void MQTTHttpsFWUpdate(const char* topicOri, JsonObject& HttpsFwUpdateData) {
       stopProcessing(true);
 #    endif
 #  endif
-      Log.warning(F("Starting firmware update with %d freeHeap" CR), ESP.getFreeHeap());
+      THEENGS_LOG_WARNING(F("Starting firmware update with %d freeHeap" CR), ESP.getFreeHeap());
       gatewayState = GatewayState::REMOTE_OTA_IN_PROGRESS;
 
       StaticJsonDocument<JSON_MSG_BUFFER> jsondata;
@@ -3246,23 +3246,23 @@ void MQTTHttpsFWUpdate(const char* topicOri, JsonObject& HttpsFwUpdateData) {
       enqueueJsonObject(jsondata);
 
       std::string ota_cert = TheengsUtils::processCert(HttpsFwUpdateData["ota_server_cert"] | "");
-      Log.notice(F("OTA cert: %s" CR), ota_cert.c_str());
+      THEENGS_LOG_NOTICE(F("OTA cert: %s" CR), ota_cert.c_str());
       if (ota_cert.length() < MIN_CERT_LENGTH && !strstr(url, "http:")) {
 #  if !MQTT_BROKER_MODE
         if (cnt_parameters_array[cnt_index].ota_server_cert.length() > MIN_CERT_LENGTH) {
-          Log.notice(F("Using memory cert" CR));
+          THEENGS_LOG_NOTICE(F("Using memory cert" CR));
           ota_cert = cnt_parameters_array[cnt_index].ota_server_cert.c_str();
         } else
 #  endif
         {
-          Log.notice(F("Using config cert" CR));
+          THEENGS_LOG_NOTICE(F("Using config cert" CR));
           ota_cert = OTAserver_cert;
         }
       }
 
       t_httpUpdate_return result = HTTP_UPDATE_FAILED;
       if (strstr(url, "http:")) {
-        Log.notice(F("Http update" CR));
+        THEENGS_LOG_NOTICE(F("Http update" CR));
         WiFiClient update_client;
 #  ifdef ESP32
         httpUpdate.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
@@ -3302,19 +3302,19 @@ void MQTTHttpsFWUpdate(const char* topicOri, JsonObject& HttpsFwUpdateData) {
       switch (result) {
         case HTTP_UPDATE_FAILED:
 #  ifdef ESP32
-          Log.error(F("HTTP_UPDATE_FAILED Error (%d): %s\n" CR), httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
+          THEENGS_LOG_ERROR(F("HTTP_UPDATE_FAILED Error (%d): %s\n" CR), httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
 #  elif ESP8266
-          Log.error(F("HTTP_UPDATE_FAILED Error (%d): %s\n" CR), ESPhttpUpdate.getLastError(), ESPhttpUpdate.getLastErrorString().c_str());
+          THEENGS_LOG_ERROR(F("HTTP_UPDATE_FAILED Error (%d): %s\n" CR), ESPhttpUpdate.getLastError(), ESPhttpUpdate.getLastErrorString().c_str());
 #  endif
           gatewayState = GatewayState::ERROR;
           break;
 
         case HTTP_UPDATE_NO_UPDATES:
-          Log.notice(F("HTTP_UPDATE_NO_UPDATES" CR));
+          THEENGS_LOG_NOTICE(F("HTTP_UPDATE_NO_UPDATES" CR));
           break;
 
         case HTTP_UPDATE_OK:
-          Log.notice(F("HTTP_UPDATE_OK" CR));
+          THEENGS_LOG_NOTICE(F("HTTP_UPDATE_OK" CR));
           jsondata["release_summary"] = "Update success !";
           jsondata["installed_version"] = latestVersion;
           jsondata["origin"] = subjectRLStoMQTT;
@@ -3342,7 +3342,7 @@ void MQTTHttpsFWUpdate(const char* topicOri, JsonObject& HttpsFwUpdateData) {
 */
 void readCntParameters(int index) {
   if (index < 0 || index > 2) {
-    Log.warning(F("Invalid cnt index" CR));
+    THEENGS_LOG_WARNING(F("Invalid cnt index" CR));
     return;
   }
   StaticJsonDocument<JSON_MSG_BUFFER> jsonBuffer;
@@ -3376,10 +3376,10 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
   if (cmpToMainTopic(topicOri, subjectMQTTtoSYSset)) {
     bool restartESP = false;
     bool publishState = false;
-    Log.trace(F("MQTTtoSYS json" CR));
+    THEENGS_LOG_TRACE(F("MQTTtoSYS json" CR));
     if (SYSdata.containsKey("cmd")) {
       const char* cmd = SYSdata["cmd"];
-      Log.notice(F("Command: %s" CR), cmd);
+      THEENGS_LOG_NOTICE(F("Command: %s" CR), cmd);
       if (strstr(cmd, restartCmd) != NULL) { //restart
         ESPRestart(5);
       } else if (strstr(cmd, eraseCmd) != NULL) { //erase and restart
@@ -3397,10 +3397,10 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
         extern void updatePowerIndicator();
         updatePowerIndicator();
 #  endif
-        Log.notice(F("RGB brightness: %d" CR), SYSConfig.rgbbrightness);
+        THEENGS_LOG_NOTICE(F("RGB brightness: %d" CR), SYSConfig.rgbbrightness);
         publishState = true;
       } else {
-        Log.warning(F("RGB brightness value invalid - ignoring command" CR));
+        THEENGS_LOG_WARNING(F("RGB brightness value invalid - ignoring command" CR));
       }
     }
 #endif
@@ -3416,7 +3416,7 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
       // NOTE: There's no need to disconnect MQTT manually
       WiFi.disconnect(true);
 
-      Log.warning(F("Attempting connection to new AP %s" CR), (const char*)SYSdata["wifi_ssid"]);
+      THEENGS_LOG_WARNING(F("Attempting connection to new AP %s" CR), (const char*)SYSdata["wifi_ssid"]);
       WiFi.begin((const char*)SYSdata["wifi_ssid"], (const char*)SYSdata["wifi_pass"]);
 #if defined(WifiGMode) || defined(WifiPower)
       setESPWifiProtocolTxPower();
@@ -3424,7 +3424,7 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
       WiFi.waitForConnectResult(WiFi_TimeOut * 1000);
 
       if (WiFi.status() != WL_CONNECTED) {
-        Log.warning(F("Failed to connect to new AP; falling back" CR));
+        THEENGS_LOG_WARNING(F("Failed to connect to new AP; falling back" CR));
         WiFi.disconnect(true);
         WiFi.begin(prev_ssid.c_str(), prev_pass.c_str());
 #if defined(WifiGMode) || defined(WifiPower)
@@ -3467,7 +3467,7 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
         strncpy(ble_aes, SYSdata["ble_aes"], parameters_size);
       }
       if (SYSdata.containsKey("ble_aes_keys")) {
-        Log.warning(F("Contains ble_aes_keys" CR));
+        THEENGS_LOG_WARNING(F("Contains ble_aes_keys" CR));
         ble_aes_keys = SYSdata["ble_aes_keys"];
       } else {
         // If no keys are passed clear the object.
@@ -3499,7 +3499,7 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
 
     if (SYSdata.containsKey("cnt_index") && SYSdata["cnt_index"].is<int>()) {
       if (SYSdata["cnt_index"].as<int>() < 0 || SYSdata["cnt_index"].as<int>() > 2) {
-        Log.warning(F("Invalid cnt index provided - ignoring command" CR));
+        THEENGS_LOG_WARNING(F("Invalid cnt index provided - ignoring command" CR));
         return;
       }
 
@@ -3511,7 +3511,7 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
       cnt_index = SYSdata["cnt_index"].as<int>();
       cnt_parameters_backup->parameters = cnt_parameters_array[cnt_index];
 
-      Log.notice(F("MQTT cnt index %d" CR), cnt_index);
+      THEENGS_LOG_NOTICE(F("MQTT cnt index %d" CR), cnt_index);
 
       if (SYSdata.containsKey("mqtt_user") && SYSdata["mqtt_user"].is<const char*>() && SYSdata.containsKey("mqtt_pass") && SYSdata["mqtt_pass"].is<const char*>()) {
         strcpy(cnt_parameters_array[cnt_index].mqtt_user, SYSdata["mqtt_user"]);
@@ -3542,22 +3542,22 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
       // Copy the certs to the memory
       if (SYSdata.containsKey("mqtt_server_cert") && SYSdata["mqtt_server_cert"].is<const char*>()) {
         cnt_parameters_array[cnt_index].server_cert = TheengsUtils::processCert(SYSdata["mqtt_server_cert"].as<const char*>());
-        Log.trace(F("Assigning server cert %s" CR), generateHash(cnt_parameters_array[cnt_index].server_cert).c_str());
+        THEENGS_LOG_TRACE(F("Assigning server cert %s" CR), generateHash(cnt_parameters_array[cnt_index].server_cert).c_str());
         cnt_parameters_array[cnt_index].validConnection = false;
       }
       if (SYSdata.containsKey("mqtt_client_cert") && SYSdata["mqtt_client_cert"].is<const char*>()) {
         cnt_parameters_array[cnt_index].client_cert = TheengsUtils::processCert(SYSdata["mqtt_client_cert"].as<const char*>());
-        Log.trace(F("Assigning client cert %s" CR), generateHash(cnt_parameters_array[cnt_index].client_cert).c_str());
+        THEENGS_LOG_TRACE(F("Assigning client cert %s" CR), generateHash(cnt_parameters_array[cnt_index].client_cert).c_str());
         cnt_parameters_array[cnt_index].validConnection = false;
       }
       if (SYSdata.containsKey("mqtt_client_key") && SYSdata["mqtt_client_key"].is<const char*>()) {
         cnt_parameters_array[cnt_index].client_key = TheengsUtils::processCert(SYSdata["mqtt_client_key"].as<const char*>());
-        Log.trace(F("Assigning client key %s" CR), generateHash(cnt_parameters_array[cnt_index].client_key).c_str());
+        THEENGS_LOG_TRACE(F("Assigning client key %s" CR), generateHash(cnt_parameters_array[cnt_index].client_key).c_str());
         cnt_parameters_array[cnt_index].validConnection = false;
       }
       if (SYSdata.containsKey("ota_server_cert") && SYSdata["ota_server_cert"].is<const char*>()) {
         cnt_parameters_array[cnt_index].ota_server_cert = TheengsUtils::processCert(SYSdata["ota_server_cert"].as<const char*>());
-        Log.trace(F("Assigning OTA server cert %s" CR), generateHash(cnt_parameters_array[cnt_index].ota_server_cert).c_str());
+        THEENGS_LOG_TRACE(F("Assigning OTA server cert %s" CR), generateHash(cnt_parameters_array[cnt_index].ota_server_cert).c_str());
       }
 
       // Read the memory certs hash to MQTT
@@ -3587,15 +3587,15 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
 
     if (SYSdata.containsKey("mqtt") && SYSdata["mqtt"].is<bool>()) {
       SYSConfig.mqtt = SYSdata["mqtt"];
-      Log.notice(F("xtomqtt: %T" CR), SYSConfig.mqtt);
+      THEENGS_LOG_NOTICE(F("xtomqtt: %T" CR), SYSConfig.mqtt);
     }
     if (SYSdata.containsKey("serial") && SYSdata["serial"].is<bool>()) {
       SYSConfig.serial = SYSdata["serial"];
-      Log.notice(F("SERIAL: %T" CR), SYSConfig.serial);
+      THEENGS_LOG_NOTICE(F("SERIAL: %T" CR), SYSConfig.serial);
     }
     if (SYSdata.containsKey("offline") && SYSdata["offline"].is<bool>()) {
       SYSConfig.offline = SYSdata["offline"];
-      Log.notice(F("offline: %T" CR), SYSConfig.offline);
+      THEENGS_LOG_NOTICE(F("offline: %T" CR), SYSConfig.offline);
       if (SYSConfig.offline) {
         gatewayState = GatewayState::OFFLINE;
 // Disconnect MQTT
@@ -3611,7 +3611,7 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
     }
     if (SYSdata.containsKey("powermode") && SYSdata["powermode"].is<int>()) {
       SYSConfig.powerMode = SYSdata["powermode"];
-      Log.notice(F("Power mode: %d" CR), SYSConfig.powerMode);
+      THEENGS_LOG_NOTICE(F("Power mode: %d" CR), SYSConfig.powerMode);
     }
 #if USE_BLUFI
     if (SYSdata.containsKey("blufi") && SYSdata["blufi"].is<bool>()) {
@@ -3624,7 +3624,7 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
       if (res)
         SYSConfig.blufi = SYSdata["blufi"];
       publishState = true;
-      Log.notice(F("Blufi: %T" CR), SYSConfig.blufi);
+      THEENGS_LOG_NOTICE(F("Blufi: %T" CR), SYSConfig.blufi);
     }
 #endif
     if (SYSdata.containsKey("disc")) {
@@ -3638,9 +3638,9 @@ void XtoSYS(const char* topicOri, JsonObject& SYSdata) { // json object decoding
           pubMqttDiscovery();
         }
       } else {
-        Log.warning(F("Discovery command not a boolean" CR));
+        THEENGS_LOG_WARNING(F("Discovery command not a boolean" CR));
       }
-      Log.notice(F("Discovery state: %T" CR), SYSConfig.discovery);
+      THEENGS_LOG_NOTICE(F("Discovery state: %T" CR), SYSConfig.discovery);
     }
     if (SYSdata.containsKey("save") && SYSdata["save"].as<bool>()) {
       SYSConfig_save();
diff --git a/main/mqttDiscovery.cpp b/main/mqttDiscovery.cpp
index 4151d4e..6a249e9 100644
--- a/main/mqttDiscovery.cpp
+++ b/main/mqttDiscovery.cpp
@@ -298,7 +298,7 @@ void announceGatewayTrigger(const char* triggerTopic,
      */
     sensor["info_topic"] = state_topic;
   } else {
-    Log.error(F("[RF] Error: topic is mandatory for device trigger Discovery" CR));
+    THEENGS_LOG_ERROR(F("[RF] Error: topic is mandatory for device trigger Discovery" CR));
     return;
   }
 
@@ -389,7 +389,7 @@ void announceGatewayTrigger(const char* triggerTopic,
    */
 
   String topic_to_publish = String(discovery_prefix) + "/device_automation/" + String(unique_id) + "/" + object_id + "/config";
-  Log.trace(F("Announce Gatewy Trigger  %s" CR), topic_to_publish.c_str());
+  THEENGS_LOG_TRACE(F("Announce Gatewy Trigger  %s" CR), topic_to_publish.c_str());
   sensor["topic"] = topic_to_publish;
   sensor["retain"] = true;
   enqueueJsonObject(sensor);
@@ -667,7 +667,7 @@ void createDiscovery(const char* sensor_type,
   sensor["dev"] = device; // device
 
   String topic = String(discovery_prefix) + "/" + String(sensor_type) + "/" + String(unique_id) + "/config";
-  Log.trace(F("Announce Device %s on  %s" CR), String(sensor_type).c_str(), topic.c_str());
+  THEENGS_LOG_TRACE(F("Announce Device %s on  %s" CR), String(sensor_type).c_str(), topic.c_str());
   sensor["topic"] = topic;
   sensor["retain"] = true;
   enqueueJsonObject(sensor);
@@ -678,7 +678,7 @@ void eraseTopic(const char* sensor_type, const char* unique_id) {
     return;
   }
   String topic = String(discovery_prefix) + "/" + String(sensor_type) + "/" + String(unique_id) + "/config";
-  Log.trace(F("Erase entity discovery %s on  %s" CR), String(sensor_type).c_str(), topic.c_str());
+  THEENGS_LOG_TRACE(F("Erase entity discovery %s on  %s" CR), String(sensor_type).c_str(), topic.c_str());
   pubMQTT((char*)topic.c_str(), "", true);
 }
 
@@ -706,7 +706,7 @@ void btScanParametersDiscovery() {
 #  endif
 
 void pubMqttDiscovery() {
-  Log.trace(F("omgStatusDiscovery" CR));
+  THEENGS_LOG_TRACE(F("omgStatusDiscovery" CR));
 
   // System sensors and controls - using extended 13-column format with macros
   const char* systemEntities[][13] = {
@@ -815,7 +815,7 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "BME: Altitude", "bme-altim", "", jsonAltim, "", "", HASS_UNIT_METER, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "BME: Altitude (ft)", "bme-altift", "", jsonAltif, "", "", HASS_UNIT_FT, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("bme280Discovery" CR));
+  THEENGS_LOG_TRACE(F("bme280Discovery" CR));
   createDiscoveryFromList(nullptr, BMEsensor, 5, nullptr, nullptr, nullptr,
                           true, BMETOPIC, will_Topic, nullptr);
 #  endif
@@ -826,13 +826,13 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "HTU: Temperature", "htu-temp", HASS_CLASS_TEMPERATURE, jsonTempc, "", "", HASS_UNIT_CELSIUS, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "HTU: Humidity", "htu-hum", HASS_CLASS_HUMIDITY, jsonHum, "", "", HASS_UNIT_PERCENT, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("htu21Discovery" CR));
+  THEENGS_LOG_TRACE(F("htu21Discovery" CR));
   createDiscoveryFromList(nullptr, HTUsensor, 2, nullptr, nullptr, nullptr,
                           true, HTUTOPIC, will_Topic, nullptr);
 #  endif
 
 #  ifdef ZsensorLM75
-  Log.trace(F("LM75Discovery" CR));
+  THEENGS_LOG_TRACE(F("LM75Discovery" CR));
   const char* LM75sensor[][13] = {
       {HASS_TYPE_SENSOR, "LM75: Temperature", "lm75-temp", HASS_CLASS_TEMPERATURE, jsonTempc, "", "", HASS_UNIT_CELSIUS, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
@@ -846,7 +846,7 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "AHT: Temperature", "aht-temp", HASS_CLASS_TEMPERATURE, jsonTempc, "", "", HASS_UNIT_CELSIUS, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "AHT: Humidity", "aht-hum", HASS_CLASS_HUMIDITY, jsonHum, "", "", HASS_UNIT_PERCENT, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("AHTx0Discovery" CR));
+  THEENGS_LOG_TRACE(F("AHTx0Discovery" CR));
   createDiscoveryFromList(nullptr, AHTsensor, 2, nullptr, nullptr, nullptr,
                           true, AHTTOPIC, will_Topic, nullptr);
 #  endif
@@ -857,14 +857,14 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "DHT: Temperature", "dht-temp", HASS_CLASS_TEMPERATURE, jsonTempc, "", "", HASS_UNIT_CELSIUS, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "DHT: Humidity", "dht-hum", HASS_CLASS_HUMIDITY, jsonHum, "", "", HASS_UNIT_PERCENT, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("DHTDiscovery" CR));
+  THEENGS_LOG_TRACE(F("DHTDiscovery" CR));
   createDiscoveryFromList(nullptr, DHTsensor, 2, nullptr, nullptr, nullptr,
                           true, DHTTOPIC, will_Topic, nullptr);
 #  endif
 
 #  ifdef ZsensorADC
 #    include "config_ADC.h"
-  Log.trace(F("ADCDiscovery" CR));
+  THEENGS_LOG_TRACE(F("ADCDiscovery" CR));
   const char* ADCsensor[][13] = {
       {HASS_TYPE_SENSOR, "ADC", "adc", "", jsonAdc, "", "", "", stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
@@ -879,7 +879,7 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "BH1750: ftCd", "BH1750-ftcd", HASS_CLASS_IRRADIANCE, jsonFtcd, "", "", "", stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "BH1750: wattsm2", "BH1750-wm2", HASS_CLASS_IRRADIANCE, jsonWm2, "", "", HASS_UNIT_WM2, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("BH1750Discovery" CR));
+  THEENGS_LOG_TRACE(F("BH1750Discovery" CR));
   createDiscoveryFromList(nullptr, BH1750sensor, 3, nullptr, nullptr, nullptr,
                           true, subjectBH1750toMQTT, will_Topic, nullptr);
 #  endif
@@ -890,7 +890,7 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "MQ2: gas", "MQ2-gas", HASS_CLASS_GAS, jsonVal, "", "", HASS_UNIT_PPM, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_BINARY_SENSOR, "MQ2", "", HASS_CLASS_GAS, jsonPresence, "true", "false", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("MQ2Discovery" CR));
+  THEENGS_LOG_TRACE(F("MQ2Discovery" CR));
   createDiscoveryFromList(nullptr, MQ2sensor, 2, nullptr, nullptr, nullptr,
                           true, subjectMQ2toMQTT, will_Topic, nullptr);
 #  endif
@@ -902,7 +902,7 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "TEMT6000: ftCd", "TEMT6000-ftcd", HASS_CLASS_IRRADIANCE, jsonFtcd, "", "", "", stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "TEMT6000: wattsm2", "TEMT6000-wm2", HASS_CLASS_IRRADIANCE, jsonWm2, "", "", HASS_UNIT_WM2, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("TEMT6000Discovery" CR));
+  THEENGS_LOG_TRACE(F("TEMT6000Discovery" CR));
   createDiscoveryFromList(nullptr, TEMT6000sensor, 3, nullptr, nullptr, nullptr,
                           true, subjectTEMT6000toMQTT, will_Topic, nullptr);
 #  endif
@@ -914,14 +914,14 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "TSL2561: ftCd", "TSL2561-ftcd", HASS_CLASS_IRRADIANCE, jsonFtcd, "", "", "", stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "TSL2561: wattsm2", "TSL2561-wm2", HASS_CLASS_IRRADIANCE, jsonWm2, "", "", HASS_UNIT_WM2, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("TSL2561Discovery" CR));
+  THEENGS_LOG_TRACE(F("TSL2561Discovery" CR));
   createDiscoveryFromList(nullptr, TSL2561sensor, 3, nullptr, nullptr, nullptr,
                           true, subjectTSL12561toMQTT, will_Topic, nullptr);
 #  endif
 
 #  ifdef ZsensorHCSR501
 #    include "config_HCSR501.h"
-  Log.trace(F("HCSR501Discovery" CR));
+  THEENGS_LOG_TRACE(F("HCSR501Discovery" CR));
   const char* HCSR501sensor[][13] = {
       {HASS_TYPE_BINARY_SENSOR, "hcsr501", "", HASS_CLASS_MOTION, jsonPresence, "true", "false", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -931,7 +931,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZsensorGPIOInput
 #    include "config_GPIOInput.h"
-  Log.trace(F("GPIOInputDiscovery" CR));
+  THEENGS_LOG_TRACE(F("GPIOInputDiscovery" CR));
   const char* GPIOInputsensor[][13] = {
       {HASS_TYPE_BINARY_SENSOR, "GPIOInput", "", "", jsonGpio, INPUT_GPIO_ON_VALUE, INPUT_GPIO_OFF_VALUE, "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -946,7 +946,7 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "INA226: current", "INA226-current", HASS_CLASS_CURRENT, jsonCurrent, "", "", HASS_UNIT_AMP, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_SENSOR, "INA226: power", "INA226-power", HASS_CLASS_POWER, jsonPower, "", "", HASS_UNIT_WATT, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("INA226Discovery" CR));
+  THEENGS_LOG_TRACE(F("INA226Discovery" CR));
   createDiscoveryFromList(nullptr, INA226sensor, 3, nullptr, nullptr, nullptr,
                           true, subjectINA226toMQTT, will_Topic, nullptr);
 #  endif
@@ -959,7 +959,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZactuatorONOFF
 #    include "config_ONOFF.h"
-  Log.trace(F("actuatorONOFFDiscovery" CR));
+  THEENGS_LOG_TRACE(F("actuatorONOFFDiscovery" CR));
   const char* actuatorONOFF[][13] = {
       {HASS_TYPE_SWITCH, "actuatorONOFF", "actuatorONOFF", "", "{{ value_json.cmd }}", "{\"cmd\":1}", "{\"cmd\":0}", "", stateClassNone, "0", "1", nullptr, subjectMQTTtoONOFF}};
 
@@ -975,14 +975,14 @@ void pubMqttDiscovery() {
       {HASS_TYPE_SENSOR, "NRG: power", "power", HASS_CLASS_POWER, jsonPower, "", "", HASS_UNIT_WATT, stateClassMeasurement, nullptr, nullptr, nullptr, nullptr},
       {HASS_TYPE_BINARY_SENSOR, "NRG: inUse", "inUse", HASS_CLASS_POWER, jsonInuseRN8209, "on", "off", "", stateClassMeasurement, nullptr, nullptr, nullptr, nullptr}};
 
-  Log.trace(F("RN8209Discovery" CR));
+  THEENGS_LOG_TRACE(F("RN8209Discovery" CR));
   createDiscoveryFromList(nullptr, RN8209sensor, 4, nullptr, nullptr, nullptr,
                           true, subjectRN8209toMQTT, will_Topic, nullptr);
 #  endif
 
 // Gateway sensors for various modules
 #  if defined(ZgatewayRF) && defined(RF_on_HAS_as_MQTTSensor)
-  Log.trace(F("gatewayRFDiscovery" CR));
+  THEENGS_LOG_TRACE(F("gatewayRFDiscovery" CR));
   const char* gatewayRF[][13] = {
       {HASS_TYPE_SENSOR, "gatewayRF", "", "", jsonVal, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -998,7 +998,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZgatewayRF2
 #    include "config_RF.h"
-  Log.trace(F("gatewayRF2Discovery" CR));
+  THEENGS_LOG_TRACE(F("gatewayRF2Discovery" CR));
   const char* gatewayRF2[][13] = {
       {HASS_TYPE_SENSOR, "gatewayRF2", "", "", jsonAddress, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -1014,7 +1014,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZgatewayRFM69
 #    include "config_RFM69.h"
-  Log.trace(F("gatewayRFM69Discovery" CR));
+  THEENGS_LOG_TRACE(F("gatewayRFM69Discovery" CR));
   const char* gatewayRFM69[][13] = {
       {HASS_TYPE_SENSOR, "gatewayRFM69", "", "", jsonVal, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -1024,7 +1024,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZgatewayLORA
 #    include "config_LORA.h"
-  Log.trace(F("gatewayLORADiscovery" CR));
+  THEENGS_LOG_TRACE(F("gatewayLORADiscovery" CR));
   const char* gatewayLORA[][13] = {
       {HASS_TYPE_SENSOR, "gatewayLORA", "", "", jsonMsg, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -1043,7 +1043,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZgatewaySRFB
 #    include "config_SRFB.h"
-  Log.trace(F("gatewaySRFBDiscovery" CR));
+  THEENGS_LOG_TRACE(F("gatewaySRFBDiscovery" CR));
   const char* gatewaySRFB[][13] = {
       {HASS_TYPE_SENSOR, "gatewaySRFB", "", "", jsonVal, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -1053,7 +1053,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZgatewayPilight
 #    include "config_RF.h"
-  Log.trace(F("gatewayPilightDiscovery" CR));
+  THEENGS_LOG_TRACE(F("gatewayPilightDiscovery" CR));
   const char* gatewayPilight[][13] = {
       {HASS_TYPE_SENSOR, "gatewayPilight", "", "", jsonMsg, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -1069,7 +1069,7 @@ void pubMqttDiscovery() {
 
 #  ifdef ZgatewayIR
 #    include "config_IR.h"
-  Log.trace(F("gatewayIRDiscovery" CR));
+  THEENGS_LOG_TRACE(F("gatewayIRDiscovery" CR));
   const char* gatewayIR[][13] = {
       {HASS_TYPE_SENSOR, "gatewayIR", "", "", jsonVal, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
@@ -1079,7 +1079,7 @@ void pubMqttDiscovery() {
 
 #  ifdef Zgateway2G
 #    include "config_2G.h"
-  Log.trace(F("gateway2GDiscovery" CR));
+  THEENGS_LOG_TRACE(F("gateway2GDiscovery" CR));
   const char* gateway2G[][13] = {
       {HASS_TYPE_SENSOR, "gateway2G", "", "", jsonMsg, "", "", "", stateClassNone, nullptr, nullptr, nullptr, nullptr}};
 
diff --git a/main/sensorADC.cpp b/main/sensorADC.cpp
index 35da9cd..3369872 100644
--- a/main/sensorADC.cpp
+++ b/main/sensorADC.cpp
@@ -42,7 +42,7 @@ static int persistedadc = -1024; // so that the first reading will always be pub
 unsigned long timeadc = 0;
 unsigned long timeadcpub = 0;
 void setupADC() {
-  Log.notice(F("ADC_GPIO: %d" CR), ADC_GPIO);
+  THEENGS_LOG_NOTICE(F("ADC_GPIO: %d" CR), ADC_GPIO);
 }
 
 void MeasureADC() {
@@ -61,11 +61,11 @@ void MeasureADC() {
       val = sum_val / NumberOfReadingsADC;
     }
     if (isnan(val)) {
-      Log.error(F("Failed to read from ADC !" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from ADC !" CR));
     } else {
       if (val >= persistedadc + ThresholdReadingADC || val <= persistedadc - ThresholdReadingADC || (MinTimeInSecBetweenPublishingADC > 0 && millis() - timeadcpub > (MinTimeInSecBetweenPublishingADC * 1000UL))) {
         timeadcpub = millis();
-        Log.trace(F("Creating ADC buffer" CR));
+        THEENGS_LOG_TRACE(F("Creating ADC buffer" CR));
         StaticJsonDocument<JSON_MSG_BUFFER> ADCdataBuffer;
         JsonObject ADCdata = ADCdataBuffer.to<JsonObject>();
         ADCdata["adc"] = (int)val;
diff --git a/main/sensorAHTx0.cpp b/main/sensorAHTx0.cpp
index 70e0806..c46531e 100644
--- a/main/sensorAHTx0.cpp
+++ b/main/sensorAHTx0.cpp
@@ -53,23 +53,23 @@ Adafruit_AHTX0 ahtSensor;
 
 void setupZsensorAHTx0() {
   delay(10); // Gives the Sensor enough time to turn on
-  Log.notice(F("AHTx0 Initialized - begin()" CR));
+  THEENGS_LOG_NOTICE(F("AHTx0 Initialized - begin()" CR));
 
 #  if defined(ESP32)
   Wire.begin(AHT_I2C_SDA, AHT_I2C_SCL);
   if (!ahtSensor.begin(&Wire)) {
-    Log.error(F("Failed to initialize AHTx0 sensor!" CR));
+    THEENGS_LOG_ERROR(F("Failed to initialize AHTx0 sensor!" CR));
   }
 #  else
   if (!ahtSensor.begin()) {
-    Log.error(F("Failed to initialize AHTx0 sensor!" CR));
+    THEENGS_LOG_ERROR(F("Failed to initialize AHTx0 sensor!" CR));
   }
 #  endif
 }
 
 void MeasureAHTTempHum() {
   if (millis() > (timeAHTx0 + TimeBetweenReadingAHTx0)) {
-    Log.trace(F("Read AHTx0 Sensor" CR));
+    THEENGS_LOG_TRACE(F("Read AHTx0 Sensor" CR));
 
     timeAHTx0 = millis();
     static float persisted_aht_tempc;
@@ -78,15 +78,15 @@ void MeasureAHTTempHum() {
     sensors_event_t ahtTempC, ahtHum;
     if (!ahtSensor.getEvent(&ahtHum, &ahtTempC)) // get sensor data
     {
-      Log.error(F("Failed to read from sensor AHTx0!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from sensor AHTx0!" CR));
       return;
     }
 
     // Check if reads failed and exit early (to try again).
     if (isnan(ahtTempC.temperature) || isnan(ahtHum.relative_humidity)) {
-      Log.error(F("Failed to read from sensor AHTx0!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from sensor AHTx0!" CR));
     } else {
-      Log.notice(F("Creating AHTx0 buffer" CR));
+      THEENGS_LOG_NOTICE(F("Creating AHTx0 buffer" CR));
       StaticJsonDocument<JSON_MSG_BUFFER> AHTx0dataBuffer;
       JsonObject AHTx0data = AHTx0dataBuffer.to<JsonObject>();
       // Generate Temperature in degrees C
@@ -95,14 +95,14 @@ void MeasureAHTTempHum() {
         AHTx0data["tempc"] = (float)ahtTempC.temperature;
         AHTx0data["tempf"] = (float)ahtTempF;
       } else {
-        Log.notice(F("Same Temp. Don't send it" CR));
+        THEENGS_LOG_NOTICE(F("Same Temp. Don't send it" CR));
       }
 
       // Generate Humidity in percent
       if (ahtHum.relative_humidity != persisted_aht_hum || AHTx0_always) {
         AHTx0data["hum"] = (float)ahtHum.relative_humidity;
       } else {
-        Log.notice(F("Same Humidity. Don't send it" CR));
+        THEENGS_LOG_NOTICE(F("Same Humidity. Don't send it" CR));
       }
       AHTx0data["origin"] = AHTTOPIC;
       enqueueJsonObject(AHTx0data);
diff --git a/main/sensorBH1750.cpp b/main/sensorBH1750.cpp
index 548a45e..a6ad869 100644
--- a/main/sensorBH1750.cpp
+++ b/main/sensorBH1750.cpp
@@ -49,7 +49,7 @@ static unsigned long timebh1750 = 0;
 static int BH1750_i2c_addr = BH1750_I2C_ADDR;
 
 void setupZsensorBH1750() {
-  Log.notice(F("Setup BH1750 on adress: %H" CR), BH1750_i2c_addr);
+  THEENGS_LOG_NOTICE(F("Setup BH1750 on adress: %H" CR), BH1750_i2c_addr);
   Wire.begin();
   Wire.beginTransmission(BH1750_i2c_addr);
   Wire.write(0x10); // Set resolution to 1 Lux
@@ -59,7 +59,7 @@ void setupZsensorBH1750() {
 
 void MeasureLightIntensity() {
   if (millis() > (timebh1750 + TimeBetweenReadingBH1750)) { //retrieving value of Lux, FtCd and Wattsm2 from BH1750
-    Log.trace(F("Creating BH1750 buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating BH1750 buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> BH1750dataBuffer;
     JsonObject BH1750data = BH1750dataBuffer.to<JsonObject>();
 
@@ -75,7 +75,7 @@ void MeasureLightIntensity() {
     // Check if reads failed and exit early (to try again).
     Wire.requestFrom(BH1750_i2c_addr, 2);
     if (Wire.available() != 2) {
-      Log.error(F("Failed to read from LightSensor BH1750!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from LightSensor BH1750!" CR));
     } else {
       i = Wire.read();
       i <<= 8;
@@ -90,21 +90,21 @@ void MeasureLightIntensity() {
       if (Lux != persistedll || bh1750_always) {
         BH1750data["lux"] = (unsigned int)Lux;
       } else {
-        Log.trace(F("Same lux don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same lux don't send it" CR));
       }
 
       // Generate FtCd
       if (ftcd != persistedlf || bh1750_always) {
         BH1750data["ftcd"] = (unsigned int)ftcd;
       } else {
-        Log.trace(F("Same ftcd don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same ftcd don't send it" CR));
       }
 
       // Generate Watts/m2
       if (Wattsm2 != persistedlw || bh1750_always) {
         BH1750data["wattsm2"] = (unsigned int)Wattsm2;
       } else {
-        Log.trace(F("Same wattsm2 don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same wattsm2 don't send it" CR));
       }
       BH1750data["origin"] = subjectBH1750toMQTT;
       enqueueJsonObject(BH1750data);
diff --git a/main/sensorBME280.cpp b/main/sensorBME280.cpp
index 7763b51..aad8612 100644
--- a/main/sensorBME280.cpp
+++ b/main/sensorBME280.cpp
@@ -58,7 +58,7 @@ void setupZsensorBME280() {
 
   mySensor.settings.commInterface = I2C_MODE;
   mySensor.settings.I2CAddress = BME280_i2c_addr;
-  Log.notice(F("Setup BME280/BMP280 on address: %X" CR), BME280_i2c_addr);
+  THEENGS_LOG_NOTICE(F("Setup BME280/BMP280 on address: %X" CR), BME280_i2c_addr);
   //***Operation settings*****************************//
 
   // runMode Setting - Values:
@@ -117,11 +117,11 @@ void setupZsensorBME280() {
 
   int ret = mySensor.begin();
   if (ret == 0x60) {
-    Log.notice(F("Bosch BME280 successfully initialized: %X" CR), ret);
+    THEENGS_LOG_NOTICE(F("Bosch BME280 successfully initialized: %X" CR), ret);
   } else if (ret == 0x58) {
-    Log.notice(F("Bosch BMP280 successfully initialized: %X" CR), ret);
+    THEENGS_LOG_NOTICE(F("Bosch BMP280 successfully initialized: %X" CR), ret);
   } else {
-    Log.notice(F("Bosch BME280/BMP280 failed: %X" CR), ret);
+    THEENGS_LOG_NOTICE(F("Bosch BME280/BMP280 failed: %X" CR), ret);
   }
 }
 
@@ -144,52 +144,52 @@ void MeasureTempHumAndPressure() {
 
     // Check if reads failed and exit early (to try again).
     if (isnan(BmeTempC) || isnan(BmeTempF) || isnan(BmeHum) || isnan(BmePa) || isnan(BmeAltiM) || isnan(BmeAltiFt)) {
-      Log.error(F("Failed to read from BME280/BMP280!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from BME280/BMP280!" CR));
     } else {
-      Log.trace(F("Creating BME280/BMP280 buffer" CR));
+      THEENGS_LOG_TRACE(F("Creating BME280/BMP280 buffer" CR));
       StaticJsonDocument<JSON_MSG_BUFFER> BME280dataBuffer;
       JsonObject BME280data = BME280dataBuffer.to<JsonObject>();
       // Generate Temperature in degrees C
       if (BmeTempC != persisted_bme_tempc || bme280_always) {
         BME280data["tempc"] = (float)BmeTempC;
       } else {
-        Log.trace(F("Same Degrees C don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same Degrees C don't send it" CR));
       }
 
       // Generate Temperature in degrees F
       if (BmeTempF != persisted_bme_tempf || bme280_always) {
         BME280data["tempf"] = (float)BmeTempF;
       } else {
-        Log.trace(F("Same Degrees F don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same Degrees F don't send it" CR));
       }
 
       // Generate Humidity in percent
       if (BmeHum != persisted_bme_hum || bme280_always) {
         BME280data["hum"] = (float)BmeHum;
       } else {
-        Log.trace(F("Same Humidity don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same Humidity don't send it" CR));
       }
 
       // Generate Pressure in Pa
       if (BmePa != persisted_bme_pa || bme280_always) {
         BME280data["pa"] = (float)BmePa;
       } else {
-        Log.trace(F("Same Pressure don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same Pressure don't send it" CR));
       }
 
       // Generate Altitude in Meter
       if (BmeAltiM != persisted_bme_altim || bme280_always) {
-        Log.trace(F("Sending Altitude Meter to MQTT" CR));
+        THEENGS_LOG_TRACE(F("Sending Altitude Meter to MQTT" CR));
         BME280data["altim"] = (float)BmeAltiM;
       } else {
-        Log.trace(F("Same Altitude Meter don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same Altitude Meter don't send it" CR));
       }
 
       // Generate Altitude in Feet
       if (BmeAltiFt != persisted_bme_altift || bme280_always) {
         BME280data["altift"] = (float)BmeAltiFt;
       } else {
-        Log.trace(F("Same Altitude Feet don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same Altitude Feet don't send it" CR));
       }
       BME280data["origin"] = BMETOPIC;
       enqueueJsonObject(BME280data);
diff --git a/main/sensorC37_YL83_HMRD.cpp b/main/sensorC37_YL83_HMRD.cpp
index 4e6c306..2f85cd6 100644
--- a/main/sensorC37_YL83_HMRD.cpp
+++ b/main/sensorC37_YL83_HMRD.cpp
@@ -34,14 +34,14 @@ unsigned int persisteddigital = 0;
 
 void setupZsensorC37_YL83_HMRD() {
   pinMode(C37_YL83_HMRD_Digital_GPIO, INPUT);
-  Log.trace(F("C37_YL83_HMRD: digital configured pin: %d" CR), C37_YL83_HMRD_Digital_GPIO);
+  THEENGS_LOG_TRACE(F("C37_YL83_HMRD: digital configured pin: %d" CR), C37_YL83_HMRD_Digital_GPIO);
 
   pinMode(C37_YL83_HMRD_Analog_GPIO, INPUT);
-  Log.trace(F("C37_YL83_HMRD: Analog configured pin: %d" CR), C37_YL83_HMRD_Analog_GPIO);
+  THEENGS_LOG_TRACE(F("C37_YL83_HMRD: Analog configured pin: %d" CR), C37_YL83_HMRD_Analog_GPIO);
 
 #  ifdef C37_YL83_HMRD_Analog_RESOLUTION
   analogReadResolution(C37_YL83_HMRD_Analog_RESOLUTION);
-  Log.trace(F("C37_YL83_HMRD: resolution: %d" CR), C37_YL83_HMRD_Analog_RESOLUTION);
+  THEENGS_LOG_TRACE(F("C37_YL83_HMRD: resolution: %d" CR), C37_YL83_HMRD_Analog_RESOLUTION);
 #  endif
 }
 
@@ -54,18 +54,18 @@ void MeasureC37_YL83_HMRDWater() {
     int sensorDigitalValue = digitalRead(C37_YL83_HMRD_Digital_GPIO); // Read the analog value from sensor
     int sensorAnalogValue = analogRead(C37_YL83_HMRD_Analog_GPIO);
 
-    Log.trace(F("Creating C37_YL83_HMRD buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating C37_YL83_HMRD buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> C37_YL83_HMRDdataBuffer;
     JsonObject C37_YL83_HMRDdata = C37_YL83_HMRDdataBuffer.to<JsonObject>();
     if (sensorDigitalValue != persisteddigital || C37_YL83_HMRD_ALWAYS) {
       C37_YL83_HMRDdata["detected"] = (sensorDigitalValue == 1 ? "false" : "true");
     } else {
-      Log.trace(F("Same digital don't send it" CR));
+      THEENGS_LOG_TRACE(F("Same digital don't send it" CR));
     }
     if (sensorAnalogValue != persistedanalog || C37_YL83_HMRD_ALWAYS) {
       C37_YL83_HMRDdata["reading"] = sensorAnalogValue;
     } else {
-      Log.trace(F("Same analog don't send it" CR));
+      THEENGS_LOG_TRACE(F("Same analog don't send it" CR));
     }
     if (C37_YL83_HMRDdata.size() > 0) {
       C37_YL83_HMRDdata["origin"] = C37_YL83_HMRD_TOPIC;
diff --git a/main/sensorDHT.cpp b/main/sensorDHT.cpp
index 8b027a9..475ce85 100644
--- a/main/sensorDHT.cpp
+++ b/main/sensorDHT.cpp
@@ -42,7 +42,7 @@ DHT dht(DHT_RECEIVER_GPIO, DHT_SENSOR_TYPE);
 unsigned long timedht = 0;
 
 void setupDHT() {
-  Log.notice(F("Reading DHT on pin: %d" CR), DHT_RECEIVER_GPIO);
+  THEENGS_LOG_NOTICE(F("Reading DHT on pin: %d" CR), DHT_RECEIVER_GPIO);
 }
 
 void MeasureTempAndHum() {
@@ -55,21 +55,21 @@ void MeasureTempAndHum() {
     float t = dht.readTemperature();
     // Check if any reads failed and exit early (to try again).
     if (isnan(h) || isnan(t)) {
-      Log.error(F("Failed to read from DHT sensor!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from DHT sensor!" CR));
     } else {
-      Log.trace(F("Creating DHT buffer" CR));
+      THEENGS_LOG_TRACE(F("Creating DHT buffer" CR));
       StaticJsonDocument<JSON_MSG_BUFFER> DHTdataBuffer;
       JsonObject DHTdata = DHTdataBuffer.to<JsonObject>();
       if (h != persistedh || dht_always) {
         DHTdata["hum"] = (float)h;
       } else {
-        Log.trace(F("Same hum don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same hum don't send it" CR));
       }
       if (t != persistedt || dht_always) {
         DHTdata["tempc"] = (float)t;
         DHTdata["tempf"] = dht.convertCtoF(t);
       } else {
-        Log.trace(F("Same temp don't send it" CR));
+        THEENGS_LOG_TRACE(F("Same temp don't send it" CR));
       }
       DHTdata["origin"] = DHTTOPIC;
       enqueueJsonObject(DHTdata);
diff --git a/main/sensorDS1820.cpp b/main/sensorDS1820.cpp
index fd02e03..a1bd79a 100644
--- a/main/sensorDS1820.cpp
+++ b/main/sensorDS1820.cpp
@@ -51,14 +51,14 @@ extern void createDiscovery(const char* sensor_type,
                             const char* state_class, const char* state_off, const char* state_on, const char* enum_options, const char* command_template);
 
 void setupZsensorDS1820() {
-  Log.trace(F("DS1820: configured pin: %d for 1-wire bus" CR), DS1820_OWBUS_GPIO);
+  THEENGS_LOG_TRACE(F("DS1820: configured pin: %d for 1-wire bus" CR), DS1820_OWBUS_GPIO);
   ds1820.begin();
 
   // Search the OneWire bus for all devices
   uint8_t numDevicesOnBus = ds1820.getDeviceCount();
 
   // locate device(s) on 1-wire bus
-  Log.notice(F("DS1820: Found %d devices" CR), numDevicesOnBus);
+  THEENGS_LOG_NOTICE(F("DS1820: Found %d devices" CR), numDevicesOnBus);
 
   // Cycle though all of the devices on the OneWire bus
   for (int deviceIndex = 0; deviceIndex < numDevicesOnBus && ds1820_count < OW_MAX_SENSORS; deviceIndex++) {
@@ -91,7 +91,7 @@ void setupZsensorDS1820() {
         ds1820.setResolution(ds1820_address, DS1820_RESOLUTION);
       }
       ds1820_resolution[ds1820_count] = ds1820.getResolution(ds1820_address);
-      Log.trace(F("DS1820: Device %d, Type: %s, Address: %s, Resolution: %d" CR),
+      THEENGS_LOG_TRACE(F("DS1820: Device %d, Type: %s, Address: %s, Resolution: %d" CR),
                 ds1820_count,
                 (char*)ds1820_type[ds1820_count].c_str(),
                 (char*)ds1820_addr[ds1820_count].c_str(),
@@ -101,7 +101,7 @@ void setupZsensorDS1820() {
   }
 
   if (ds1820.getDS18Count() == 0) {
-    Log.error(F("DS1820: Failed to enumerate sensors on 1-wire bus. Check your GPIO assignment!" CR));
+    THEENGS_LOG_ERROR(F("DS1820: Failed to enumerate sensors on 1-wire bus. Check your GPIO assignment!" CR));
   }
 
   // make requestTemperatures() non-blocking
@@ -143,7 +143,7 @@ void MeasureDS1820Temp() {
   // trigger temperature conversion some time before actually
   // calling getTempC() to make reading temperatures non-blocking
   if (!triggeredConversion && ((millis() - timeDS1820) > (DS1820_INTERVAL_SEC * 1000UL - DS1820_CONV_TIME))) {
-    Log.trace(F("DS1820: Trigger temperature conversion..." CR));
+    THEENGS_LOG_TRACE(F("DS1820: Trigger temperature conversion..." CR));
     ds1820.requestTemperatures();
     triggeredConversion = true;
   } else if (triggeredConversion && ((millis() - timeDS1820) > DS1820_INTERVAL_SEC * 1000UL)) {
@@ -151,16 +151,16 @@ void MeasureDS1820Temp() {
     triggeredConversion = false;
 
     if (ds1820_count < 1) {
-      Log.error(F("DS1820: Failed to identify any temperature sensors on 1-wire bus during setup!" CR));
+      THEENGS_LOG_ERROR(F("DS1820: Failed to identify any temperature sensors on 1-wire bus during setup!" CR));
     } else {
-      Log.trace(F("DS1820: Reading temperature(s) from %d sensor(s)..." CR), ds1820_count);
+      THEENGS_LOG_TRACE(F("DS1820: Reading temperature(s) from %d sensor(s)..." CR), ds1820_count);
       StaticJsonDocument<JSON_MSG_BUFFER> DS1820dataBuffer;
       JsonObject DS1820data = DS1820dataBuffer.to<JsonObject>();
 
       for (uint8_t i = 0; i < ds1820_count; i++) {
         current_temp[i] = round(ds1820.getTempC(ds1820_devices[i]) * 10) / 10.0;
         if (current_temp[i] == -127) {
-          Log.error(F("DS1820: Device %s currently disconnected!" CR), (char*)ds1820_addr[i].c_str());
+          THEENGS_LOG_ERROR(F("DS1820: Device %s currently disconnected!" CR), (char*)ds1820_addr[i].c_str());
         } else if (DS1820_ALWAYS || current_temp[i] != persisted_temp[i]) {
           DS1820data["tempf"] = (float)DallasTemperature::toFahrenheit(current_temp[i]);
           DS1820data["tempc"] = (float)current_temp[i];
@@ -176,7 +176,7 @@ void MeasureDS1820Temp() {
           if (SYSConfig.powerMode > 0)
             ready_to_sleep = true;
         } else {
-          Log.trace(F("DS1820: Temperature for device %s didn't change, don't publish it." CR), (char*)ds1820_addr[i].c_str());
+          THEENGS_LOG_TRACE(F("DS1820: Temperature for device %s didn't change, don't publish it." CR), (char*)ds1820_addr[i].c_str());
         }
         persisted_temp[i] = current_temp[i];
       }
diff --git a/main/sensorGPIOInput.cpp b/main/sensorGPIOInput.cpp
index 48de507..b74f1be 100644
--- a/main/sensorGPIOInput.cpp
+++ b/main/sensorGPIOInput.cpp
@@ -43,7 +43,7 @@ int InputState = 3; // Set to 3 so that it reads on startup
 int previousInputState = 3;
 
 void setupGPIOInput() {
-  Log.notice(F("Reading GPIO at pin: %d" CR), INPUT_GPIO);
+  THEENGS_LOG_NOTICE(F("Reading GPIO at pin: %d" CR), INPUT_GPIO);
   pinMode(INPUT_GPIO, GPIO_INPUT_TYPE); // declare GPIOInput pin as input_pullup to prevent floating. Pin will be high when not connected to ground
 }
 
@@ -69,7 +69,7 @@ void MeasureGPIOInput() {
       if (resetTime == 0) {
         resetTime = millis();
       } else if ((millis() - resetTime) > 3000) {
-        Log.trace(F("Button Held" CR));
+        THEENGS_LOG_TRACE(F("Button Held" CR));
         gatewayState = GatewayState::WAITING_ONBOARDING;
 // Switching off the relay during reset or failsafe operations
 #    ifdef ZactuatorONOFF
@@ -78,7 +78,7 @@ void MeasureGPIOInput() {
           ActuatorTrigger();
         }
 #    endif
-        Log.notice(F("Erasing ESP Config, restarting" CR));
+        THEENGS_LOG_NOTICE(F("Erasing ESP Config, restarting" CR));
         eraseConfig();
       }
     } else {
@@ -87,7 +87,7 @@ void MeasureGPIOInput() {
 #  endif
     // if the Input state has changed:
     if (reading != InputState) {
-      Log.trace(F("Creating GPIOInput buffer" CR));
+      THEENGS_LOG_TRACE(F("Creating GPIOInput buffer" CR));
       StaticJsonDocument<JSON_MSG_BUFFER> GPIOdataBuffer;
       JsonObject GPIOdata = GPIOdataBuffer.to<JsonObject>();
       if (InputState == HIGH) {
diff --git a/main/sensorGPIOKeyCode.cpp b/main/sensorGPIOKeyCode.cpp
index bb4027a..1f654b0 100644
--- a/main/sensorGPIOKeyCode.cpp
+++ b/main/sensorGPIOKeyCode.cpp
@@ -62,14 +62,14 @@ void MeasureGPIOKeyCode() {
       InputStateGPIOKeyCode = reading;
       sprintf(hex, "%02x", InputStateGPIOKeyCode);
       hex[2] = 0;
-      Log.notice(F("GPIOKeyCode %H" CR), hex);
+      THEENGS_LOG_NOTICE(F("GPIOKeyCode %H" CR), hex);
       pub(subjectGPIOKeyCodetoMQTT, hex);
       lastLatchStateGPIOKeyCode = latch;
     }
 
     if (latch != lastLatchStateGPIOKeyCode) {
       lastLatchStateGPIOKeyCode = latch;
-      Log.notice(F("GPIOKeyCode latch %d" CR), latch);
+      THEENGS_LOG_NOTICE(F("GPIOKeyCode latch %d" CR), latch);
       if (latch == 0)
         pub(subjectGPIOKeyCodeStatetoMQTT, "done");
     }
diff --git a/main/sensorHCSR04.cpp b/main/sensorHCSR04.cpp
index 267b3c5..51ba6f1 100644
--- a/main/sensorHCSR04.cpp
+++ b/main/sensorHCSR04.cpp
@@ -36,8 +36,8 @@
 unsigned long timeHCSR04 = 0;
 
 void setupHCSR04() {
-  Log.notice(F("HCSR04 trigger pin: %d" CR), HCSR04_TRI_GPIO);
-  Log.notice(F("HCSR04 echo pin: %d" CR), HCSR04_ECH_GPIO);
+  THEENGS_LOG_NOTICE(F("HCSR04 trigger pin: %d" CR), HCSR04_TRI_GPIO);
+  THEENGS_LOG_NOTICE(F("HCSR04 echo pin: %d" CR), HCSR04_ECH_GPIO);
   pinMode(HCSR04_TRI_GPIO, OUTPUT); // declare HC SR-04 trigger GPIO as output
   pinMode(HCSR04_ECH_GPIO, INPUT); // declare HC SR-04 echo GPIO as input
 }
@@ -45,7 +45,7 @@ void setupHCSR04() {
 void MeasureDistance() {
   if (millis() > (timeHCSR04 + TimeBetweenReadingHCSR04)) {
     timeHCSR04 = millis();
-    Log.trace(F("Creating HCSR04 buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating HCSR04 buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> HCSR04dataBuffer;
     JsonObject HCSR04data = HCSR04dataBuffer.to<JsonObject>();
     digitalWrite(HCSR04_TRI_GPIO, LOW);
@@ -55,20 +55,20 @@ void MeasureDistance() {
     digitalWrite(HCSR04_TRI_GPIO, LOW);
     unsigned long duration = pulseIn(HCSR04_ECH_GPIO, HIGH);
     if (isnan(duration)) {
-      Log.error(F("Failed to read from HC SR04 sensor!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from HC SR04 sensor!" CR));
     } else {
       static unsigned int distance = 99999;
       unsigned int d = duration / 58.2;
       HCSR04data["distance"] = (int)d;
       if (d > distance) {
         HCSR04data["direction"] = "away";
-        Log.trace(F("HC SR04 Distance changed" CR));
+        THEENGS_LOG_TRACE(F("HC SR04 Distance changed" CR));
       } else if (d < distance) {
         HCSR04data["direction"] = "towards";
-        Log.trace(F("HC SR04 Distance changed" CR));
+        THEENGS_LOG_TRACE(F("HC SR04 Distance changed" CR));
       } else if (HCSR04_always) {
         HCSR04data["direction"] = "static";
-        Log.trace(F("HC SR04 Distance hasn't changed" CR));
+        THEENGS_LOG_TRACE(F("HC SR04 Distance hasn't changed" CR));
       }
       distance = d;
       enqueueJsonObject(HCSR04data);
diff --git a/main/sensorHCSR501.cpp b/main/sensorHCSR501.cpp
index 3e03ea9..10e7fc8 100644
--- a/main/sensorHCSR501.cpp
+++ b/main/sensorHCSR501.cpp
@@ -33,7 +33,7 @@
 #  include "config_HCSR501.h"
 
 void setupHCSR501() {
-  Log.notice(F("HCSR501 pin: %d" CR), HCSR501_GPIO);
+  THEENGS_LOG_NOTICE(F("HCSR501 pin: %d" CR), HCSR501_GPIO);
   pinMode(HCSR501_GPIO, INPUT); // declare HC SR-501 GPIO as input
 #  ifdef HCSR501_LED_NOTIFY_GPIO
   pinMode(HCSR501_LED_NOTIFY_GPIO, OUTPUT);
diff --git a/main/sensorHTU21.cpp b/main/sensorHTU21.cpp
index 76ab2b1..b37c72a 100644
--- a/main/sensorHTU21.cpp
+++ b/main/sensorHTU21.cpp
@@ -53,7 +53,7 @@ HTU21D htuSensor;
 
 void setupZsensorHTU21() {
   delay(10); // Gives the Sensor enough time to turn on
-  Log.notice(F("HTU21 Initialized - begin()" CR));
+  THEENGS_LOG_NOTICE(F("HTU21 Initialized - begin()" CR));
 
 #  if defined(ESP32)
   Wire.begin(I2C_SDA, I2C_SCL);
@@ -65,7 +65,7 @@ void setupZsensorHTU21() {
 
 void MeasureTempHum() {
   if (millis() > (timehtu21 + TimeBetweenReadinghtu21)) {
-    Log.trace(F("Read HTU21 Sensor" CR));
+    THEENGS_LOG_TRACE(F("Read HTU21 Sensor" CR));
 
     timehtu21 = millis();
     static float persisted_htu_tempc;
@@ -75,15 +75,15 @@ void MeasureTempHum() {
     float HtuHum = htuSensor.readHumidity();
 
     if (HtuTempC >= 998 || HtuHum >= 998) {
-      Log.error(F("Failed to read from sensor HTU21!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from sensor HTU21!" CR));
       return;
     }
 
     // Check if reads failed and exit early (to try again).
     if (isnan(HtuTempC) || isnan(HtuHum)) {
-      Log.error(F("Failed to read from sensor HTU21!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from sensor HTU21!" CR));
     } else {
-      Log.notice(F("Creating HTU21 buffer" CR));
+      THEENGS_LOG_NOTICE(F("Creating HTU21 buffer" CR));
       StaticJsonDocument<JSON_MSG_BUFFER> HTU21dataBuffer;
       JsonObject HTU21data = HTU21dataBuffer.to<JsonObject>();
       // Generate Temperature in degrees C
@@ -92,14 +92,14 @@ void MeasureTempHum() {
         HTU21data["tempc"] = (float)HtuTempC;
         HTU21data["tempf"] = (float)HtuTempF;
       } else {
-        Log.notice(F("Same Temp. Don't send it" CR));
+        THEENGS_LOG_NOTICE(F("Same Temp. Don't send it" CR));
       }
 
       // Generate Humidity in percent
       if (HtuHum != persisted_htu_hum || htu21_always) {
         HTU21data["hum"] = (float)HtuHum;
       } else {
-        Log.notice(F("Same Humidity. Don't send it" CR));
+        THEENGS_LOG_NOTICE(F("Same Humidity. Don't send it" CR));
       }
       HTU21data["origin"] = HTUTOPIC;
       enqueueJsonObject(HTU21data);
diff --git a/main/sensorINA226.cpp b/main/sensorINA226.cpp
index 6332ff7..b63a5d9 100644
--- a/main/sensorINA226.cpp
+++ b/main/sensorINA226.cpp
@@ -58,11 +58,11 @@ void setupINA226() {
 void MeasureINA226() {
   if (millis() > (timeINA226 + TimeBetweenReadingINA226)) { //retrieving value of temperature and humidity of the box from DHT every xUL
     timeINA226 = millis();
-    Log.trace(F("Creating INA226 buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating INA226 buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> INA226dataBuffer;
     JsonObject INA226data = INA226dataBuffer.to<JsonObject>();
     // Topic on which we will send data
-    Log.trace(F("Retrieving electrical data" CR));
+    THEENGS_LOG_TRACE(F("Retrieving electrical data" CR));
     // Bus Spannung, read-only, 16Bit, 0...40.96V max., LSB 1.25mV
     float volt = readRegister(0x02) * 0.00125;
     // Seite 24: Shunt Spannung +- 81,92mV mit 16 Bit, LSB 2,5uV
diff --git a/main/sensorLM75.cpp b/main/sensorLM75.cpp
index f9b5cd2..f406828 100644
--- a/main/sensorLM75.cpp
+++ b/main/sensorLM75.cpp
@@ -53,7 +53,7 @@ Generic_LM75 lm75Sensor;
 
 void setupZsensorLM75() {
   delay(10); // Gives the Sensor enough time to turn on
-  Log.notice(F("LM75 Initialized - begin()" CR));
+  THEENGS_LOG_NOTICE(F("LM75 Initialized - begin()" CR));
 
 #  if defined(ESP32)
   Wire.begin(I2C_SDA, I2C_SCL);
@@ -64,7 +64,7 @@ void setupZsensorLM75() {
 
 void MeasureTemp() {
   if (millis() > (timelm75 + TimeBetweenReadinglm75)) {
-    Log.trace(F("Read LM75 Sensor" CR));
+    THEENGS_LOG_TRACE(F("Read LM75 Sensor" CR));
 
     timelm75 = millis();
     static float persisted_lm75_tempc;
@@ -72,15 +72,15 @@ void MeasureTemp() {
     float lm75TempC = lm75Sensor.readTemperatureC();
 
     if (lm75TempC >= 998) {
-      Log.error(F("Failed to read from sensor LM75!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from sensor LM75!" CR));
       return;
     }
 
     // Check if reads failed and exit early (to try again).
     if (isnan(lm75TempC)) {
-      Log.error(F("Failed to read from sensor HLM75!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from sensor HLM75!" CR));
     } else {
-      Log.notice(F("Creating LM75 buffer" CR));
+      THEENGS_LOG_NOTICE(F("Creating LM75 buffer" CR));
       StaticJsonDocument<JSON_MSG_BUFFER> LM75dataBuffer;
       JsonObject LM75data = LM75dataBuffer.to<JsonObject>();
       // Generate Temperature in degrees C
@@ -91,7 +91,7 @@ void MeasureTemp() {
         LM75data["origin"] = LM75TOPIC;
         enqueueJsonObject(LM75data);
       } else {
-        Log.notice(F("Same Temp. Don't send it" CR));
+        THEENGS_LOG_NOTICE(F("Same Temp. Don't send it" CR));
       }
     }
     persisted_lm75_tempc = lm75TempC;
diff --git a/main/sensorMQ2.cpp b/main/sensorMQ2.cpp
index b71e68a..99b7bce 100644
--- a/main/sensorMQ2.cpp
+++ b/main/sensorMQ2.cpp
@@ -45,10 +45,10 @@
 unsigned long timemq2 = 0;
 
 void setupZsensorMQ2() {
-  Log.notice(F("Setup MQ2 detection on pin: %d" CR), MQ2SENSORDETECTPIN);
+  THEENGS_LOG_NOTICE(F("Setup MQ2 detection on pin: %d" CR), MQ2SENSORDETECTPIN);
   pinMode(MQ2SENSORDETECTPIN, INPUT); // declare GPIOInput pin as input_pullup to prevent floating. Pin will be high when not connected to ground
 
-  Log.notice(F("Starting MQ2 calibration on pin: %d" CR), MQ2SENSORADCPIN);
+  THEENGS_LOG_NOTICE(F("Starting MQ2 calibration on pin: %d" CR), MQ2SENSORADCPIN);
 
   //Simple calibrate
   float sensorValue;
@@ -57,14 +57,14 @@ void setupZsensorMQ2() {
   }
   delay(1000);
 
-  Log.trace(F("MQ2 Initialized." CR));
+  THEENGS_LOG_TRACE(F("MQ2 Initialized." CR));
 }
 
 void MeasureGasMQ2() {
   if (millis() > (timemq2 + TimeBetweenReadingmq2)) {
     timemq2 = millis();
 
-    Log.trace(F("Creating MQ2 buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating MQ2 buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> MQ2dataBuffer;
     JsonObject MQ2data = MQ2dataBuffer.to<JsonObject>();
 
diff --git a/main/sensorRN8209.cpp b/main/sensorRN8209.cpp
index ba7ea01..f1063a5 100644
--- a/main/sensorRN8209.cpp
+++ b/main/sensorRN8209.cpp
@@ -119,7 +119,7 @@ void setupRN8209() {
   init_8209c_interface();
   xTaskCreate(rn8209_loop, "rn8209_loop", RN8209_TASK_STACK_SIZE_OVERRIDE, NULL, 10, &rn8209TaskHandle);
   //esp_task_wdt_add(rn8209TaskHandle);
-  Log.trace(F("sensorRN8209 setup done " CR));
+  THEENGS_LOG_TRACE(F("sensorRN8209 setup done " CR));
 }
 
 #endif // ZsensorRN8209
\ No newline at end of file
diff --git a/main/sensorSHTC3.cpp b/main/sensorSHTC3.cpp
index 5ee7b42..2e9c628 100644
--- a/main/sensorSHTC3.cpp
+++ b/main/sensorSHTC3.cpp
@@ -15,16 +15,16 @@ void errorDecoder(SHTC3_Status_TypeDef message) // The errorDecoder function pri
 {
   switch (message) {
     case SHTC3_Status_Nominal:
-      Log.notice(F("Nominal"));
+      THEENGS_LOG_NOTICE(F("Nominal"));
       break;
     case SHTC3_Status_Error:
-      Log.error(F("Error"));
+      THEENGS_LOG_ERROR(F("Error"));
       break;
     case SHTC3_Status_CRC_Fail:
-      Log.error(F("CRC Fail"));
+      THEENGS_LOG_ERROR(F("CRC Fail"));
       break;
     default:
-      Log.error(F("Unknown return code"));
+      THEENGS_LOG_ERROR(F("Unknown return code"));
       break;
   }
 }
@@ -46,21 +46,21 @@ void MeasureTempAndHum() {
       float h = mySHTC3.toPercent();
       // Check if any reads failed and exit early (to try again).
       if (isnan(h) || isnan(t)) {
-        Log.error(F("Failed to read from SHTC3 sensor!" CR));
+        THEENGS_LOG_ERROR(F("Failed to read from SHTC3 sensor!" CR));
       } else {
-        Log.trace(F("Creating SHTC3 buffer" CR));
+        THEENGS_LOG_TRACE(F("Creating SHTC3 buffer" CR));
         StaticJsonDocument<JSON_MSG_BUFFER> SHTC3dataBuffer;
         JsonObject SHTC3data = SHTC3dataBuffer.to<JsonObject>();
         if (h != persistedh || shtc3_always) {
           SHTC3data["hum"] = (float)h;
         } else {
-          Log.trace(F("Same hum don't send it" CR));
+          THEENGS_LOG_TRACE(F("Same hum don't send it" CR));
         }
         if (t != persistedt || shtc3_always) {
           SHTC3data["tempc"] = (float)t;
           SHTC3data["tempf"] = mySHTC3.toDegF();
         } else {
-          Log.trace(F("Same temp don't send it" CR));
+          THEENGS_LOG_TRACE(F("Same temp don't send it" CR));
         }
         SHTC3data["origin"] = SHTC3TOPIC;
         enqueueJsonObject(SHTC3data);
@@ -69,7 +69,7 @@ void MeasureTempAndHum() {
       persistedt = t;
     } else {
       errorDecoder(mySHTC3.lastStatus);
-      Log.error(F("Failed to read from SHTC3 sensor!" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from SHTC3 sensor!" CR));
     }
   }
 }
diff --git a/main/sensorTEMT6000.cpp b/main/sensorTEMT6000.cpp
index 1aecc29..5bf7f5b 100644
--- a/main/sensorTEMT6000.cpp
+++ b/main/sensorTEMT6000.cpp
@@ -47,7 +47,7 @@
 static unsigned long timetemt6000 = 0;
 
 void setupZsensorTEMT6000() {
-  Log.notice(F("Setup TEMT6000 on pin: %i" CR), TEMT6000LIGHTSENSORPIN);
+  THEENGS_LOG_NOTICE(F("Setup TEMT6000 on pin: %i" CR), TEMT6000LIGHTSENSORPIN);
   pinMode(TEMT6000LIGHTSENSORPIN, INPUT);
 }
 
@@ -56,7 +56,7 @@ void MeasureLightIntensityTEMT6000() {
     static uint32_t persisted_lux;
     timetemt6000 = millis();
 
-    Log.trace(F("Creating TEMT6000 buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating TEMT6000 buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> TEMT6000dataBuffer;
     JsonObject TEMT6000data = TEMT6000dataBuffer.to<JsonObject>();
 
@@ -74,7 +74,7 @@ void MeasureLightIntensityTEMT6000() {
       TEMT6000data["origin"] = subjectTEMT6000toMQTT;
       enqueueJsonObject(TEMT6000data);
     } else {
-      Log.trace(F("Same lux value, do not send" CR));
+      THEENGS_LOG_TRACE(F("Same lux value, do not send" CR));
     }
   }
 }
diff --git a/main/sensorTSL2561.cpp b/main/sensorTSL2561.cpp
index 412c692..2c6e8fe 100644
--- a/main/sensorTSL2561.cpp
+++ b/main/sensorTSL2561.cpp
@@ -57,24 +57,24 @@ Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 1234
 void displaySensorDetails(void) {
   sensor_t sensor;
   tsl.getSensor(&sensor);
-  Log.trace(F("------------------------------------" CR));
-  Log.trace(("Sensor: %s" CR), sensor.name);
-  Log.trace(("Driver Ver: %s" CR), sensor.version);
-  Log.trace(("Unique ID: %s" CR), sensor.sensor_id);
-  Log.trace(("Max Value: %s lux" CR), sensor.max_value);
-  Log.trace(("Min Value: %s lux" CR), sensor.min_value);
-  Log.trace(("Resolution: %s lux" CR), sensor.resolution);
-  Log.trace(F("------------------------------------" CR));
+  THEENGS_LOG_TRACE(F("------------------------------------" CR));
+  THEENGS_LOG_TRACE(("Sensor: %s" CR), sensor.name);
+  THEENGS_LOG_TRACE(("Driver Ver: %s" CR), sensor.version);
+  THEENGS_LOG_TRACE(("Unique ID: %s" CR), sensor.sensor_id);
+  THEENGS_LOG_TRACE(("Max Value: %s lux" CR), sensor.max_value);
+  THEENGS_LOG_TRACE(("Min Value: %s lux" CR), sensor.min_value);
+  THEENGS_LOG_TRACE(("Resolution: %s lux" CR), sensor.resolution);
+  THEENGS_LOG_TRACE(F("------------------------------------" CR));
   delay(500);
 }
 
 void setupZsensorTSL2561() {
-  Log.notice(F("Setup TSL2561 on adress: %H" CR), TSL2561_ADDR_FLOAT);
+  THEENGS_LOG_NOTICE(F("Setup TSL2561 on adress: %H" CR), TSL2561_ADDR_FLOAT);
   Wire.begin();
   Wire.beginTransmission(TSL2561_ADDR_FLOAT);
 
   if (!tsl.begin()) {
-    Log.error(F("No TSL2561 detected" CR));
+    THEENGS_LOG_ERROR(F("No TSL2561 detected" CR));
   }
 
   // enable auto ranging
@@ -86,7 +86,7 @@ void setupZsensorTSL2561() {
   // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);  /* medium resolution and speed   */
   tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_402MS);
 
-  Log.trace(F("TSL2561 Initialized. Printing detials now." CR));
+  THEENGS_LOG_TRACE(F("TSL2561 Initialized. Printing detials now." CR));
   displaySensorDetails();
 }
 
@@ -95,7 +95,7 @@ void MeasureLightIntensityTSL2561() {
     static uint32_t persisted_lux;
     timetsl2561 = millis();
 
-    Log.trace(F("Creating TSL2561 buffer" CR));
+    THEENGS_LOG_TRACE(F("Creating TSL2561 buffer" CR));
     StaticJsonDocument<JSON_MSG_BUFFER> TSL2561dataBuffer;
     JsonObject TSL2561data = TSL2561dataBuffer.to<JsonObject>();
 
@@ -113,10 +113,10 @@ void MeasureLightIntensityTSL2561() {
         TSL2561data["origin"] = subjectTSL12561toMQTT;
         enqueueJsonObject(TSL2561data);
       } else {
-        Log.trace(F("Same lux value, do not send" CR));
+        THEENGS_LOG_TRACE(F("Same lux value, do not send" CR));
       }
     } else {
-      Log.error(F("Failed to read from TSL2561" CR));
+      THEENGS_LOG_ERROR(F("Failed to read from TSL2561" CR));
     }
   }
 }
diff --git a/main/sensorTouch.cpp b/main/sensorTouch.cpp
index a31bc15..7a2f12b 100644
--- a/main/sensorTouch.cpp
+++ b/main/sensorTouch.cpp
@@ -82,7 +82,7 @@ void setupTouch() {
   status[9].pin = TOUCH_GPIO_9;
 #  endif
   for (int i = 0; i < TOUCH_SENSORS; i++) {
-    Log.notice(F("TOUCH_GPIO_%d: %d" CR), i, status[i].pin);
+    THEENGS_LOG_NOTICE(F("TOUCH_GPIO_%d: %d" CR), i, status[i].pin);
   }
   touchTimeRead = millis() - TOUCH_TIME_BETWEEN_READINGS; // so we get a first reading at the beginning
 }
diff --git a/main/webUI.cpp b/main/webUI.cpp
index 3176a5c..c024490 100644
--- a/main/webUI.cpp
+++ b/main/webUI.cpp
@@ -429,7 +429,7 @@ void handleRoot() {
         server.send(200, "application/json", "{t}{s}Uptime:{m}" + String(uptime()) + "{e}</table>");
       }
     } else if (server.hasArg("rst")) { // TODO: This should redirect to the RST page
-      Log.warning(F("[WebUI] Restart" CR));
+      THEENGS_LOG_WARNING(F("[WebUI] Restart" CR));
       char jsonChar[100];
       serializeJson(modules, jsonChar, measureJson(modules) + 1);
       char buffer[WEB_TEMPLATE_BUFFER_MAX_SIZE];
@@ -660,7 +660,7 @@ void handleWI() {
       }
       if (update) {
         String topic = String(mqtt_topic) + String(gateway_name) + String(subjectMQTTtoSYSset);
-        Log.warning(F("[WebUI] Save WiFi and Restart" CR));
+        THEENGS_LOG_WARNING(F("[WebUI] Save WiFi and Restart" CR));
         char jsonChar[100];
         serializeJson(modules, jsonChar, measureJson(modules) + 1);
         char buffer[WEB_TEMPLATE_BUFFER_MAX_SIZE];
@@ -680,7 +680,7 @@ void handleWI() {
         XtoSYS((char*)topic.c_str(), WEBtoSYS);
         return;
       } else {
-        Log.warning(F("[WebUI] No changes" CR));
+        THEENGS_LOG_WARNING(F("[WebUI] No changes" CR));
       }
     }
   }
@@ -762,7 +762,7 @@ void handleMQ() {
       WEBtoSYS["mqtt_secure"] = server.hasArg("sc");
 
       if (!update) {
-        Log.warning(F("[WebUI] clearing" CR));
+        THEENGS_LOG_WARNING(F("[WebUI] clearing" CR));
         for (JsonObject::iterator it = WEBtoSYS.begin(); it != WEBtoSYS.end(); ++it) {
           WEBtoSYS.remove(it);
         }
@@ -793,7 +793,7 @@ void handleMQ() {
 
 #  ifndef ESPWifiManualSetup
       if (update) {
-        Log.warning(F("[WebUI] Save MQTT and Reconnect" CR));
+        THEENGS_LOG_WARNING(F("[WebUI] Save MQTT and Reconnect" CR));
         WEBtoSYS["cnt_index"] = CNT_DEFAULT_INDEX;
         WEBtoSYS["save_cnt"] = true;
         char jsonChar[100];
@@ -816,7 +816,7 @@ void handleMQ() {
         XtoSYS((char*)topic.c_str(), WEBtoSYS);
         return;
       } else {
-        Log.warning(F("[WebUI] No changes" CR));
+        THEENGS_LOG_WARNING(F("[WebUI] No changes" CR));
       }
 #  endif
     }
@@ -878,7 +878,7 @@ void handleCG() {
   }
 
   if (update) {
-    Log.warning(F("[WebUI] Save Password and Restart" CR));
+    THEENGS_LOG_WARNING(F("[WebUI] Save Password and Restart" CR));
 
     char jsonChar[100];
     serializeJson(modules, jsonChar, measureJson(modules) + 1);
@@ -899,7 +899,7 @@ void handleCG() {
     String topic = String(mqtt_topic) + String(gateway_name) + String(subjectMQTTtoSYSset);
     XtoSYS((char*)topic.c_str(), WEBtoSYS);
   } else {
-    Log.warning(F("[WebUI] No changes" CR));
+    THEENGS_LOG_WARNING(F("[WebUI] No changes" CR));
   }
 
   char jsonChar[100];
@@ -1004,11 +1004,11 @@ void handleBL() {
       }
 
       if (update) {
-        Log.warning(F("[BLE] Save Config" CR));
+        THEENGS_LOG_WARNING(F("[BLE] Save Config" CR));
         String topic = String(mqtt_topic) + String(gateway_name) + String(subjectMQTTtoSYSset);
         XtoSYS((char*)topic.c_str(), WEBtoSYS);
       } else {
-        Log.warning(F("[BLE] No changes" CR));
+        THEENGS_LOG_WARNING(F("[BLE] No changes" CR));
       }
     }
   }
@@ -1134,11 +1134,11 @@ void handleLA() {
         update = true;
       }
       if (update) {
-        Log.notice(F("[WebUI] Save data" CR));
+        THEENGS_LOG_NOTICE(F("[WebUI] Save data" CR));
         WEBtoLORA["save"] = true;
         LORAConfig_fromJson(WEBtoLORA);
         stateLORAMeasures();
-        Log.trace(F("[WebUI] LORAConfig end" CR));
+        THEENGS_LOG_TRACE(F("[WebUI] LORAConfig end" CR));
       }
     }
   }
@@ -1278,7 +1278,7 @@ void handleRF() {
           WEBtoRF["frequency"] = RFConfig.frequency;
           update = true;
         } else {
-          Log.warning(F("[WebUI] Invalid Frequency" CR));
+          THEENGS_LOG_WARNING(F("[WebUI] Invalid Frequency" CR));
         }
       }
       if (server.hasArg("ar")) {
@@ -1288,7 +1288,7 @@ void handleRF() {
           WEBtoRF["activereceiver"] = RFConfig.activeReceiver;
           update = true;
         } else {
-          Log.warning(F("[WebUI] Invalid Active Receiver" CR));
+          THEENGS_LOG_WARNING(F("[WebUI] Invalid Active Receiver" CR));
         }
       }
       if (server.hasArg("oo")) {
@@ -1302,11 +1302,11 @@ void handleRF() {
         update = true;
       }
       if (update) {
-        Log.notice(F("[WebUI] Save data" CR));
+        THEENGS_LOG_NOTICE(F("[WebUI] Save data" CR));
         WEBtoRF["save"] = true;
         RFConfig_fromJson(WEBtoRF);
         stateRFMeasures();
-        Log.trace(F("[WebUI] RFConfig end" CR));
+        THEENGS_LOG_TRACE(F("[WebUI] RFConfig end" CR));
       }
     }
   }
@@ -1345,7 +1345,7 @@ void handleRT() {
   if (server.hasArg("non")) {
     char jsonChar[100];
     serializeJson(modules, jsonChar, measureJson(modules) + 1);
-    Log.warning(F("[WebUI] Erase and Restart" CR));
+    THEENGS_LOG_WARNING(F("[WebUI] Erase and Restart" CR));
 
     char buffer[WEB_TEMPLATE_BUFFER_MAX_SIZE];
 
@@ -1456,7 +1456,7 @@ void handleTK() {
     } else {
       WEBUI_TRACE_LOG(F("handleTK: uptime: %u, uptime: %u, ok: %T" CR), server.arg("uptime").toInt(), uptime(), server.arg("uptime").toInt() + 600 > uptime());
       WEBUI_TRACE_LOG(F("handleTK: RT: %d, RT: %d, ok: %T " CR), server.arg("RT").toInt(), requestToken, server.arg("RT").toInt() == requestToken);
-      Log.error(F("[WebUI] Invalid Token Response: RT: %T, uptime: %T" CR), server.arg("RT").toInt() == requestToken, server.arg("uptime").toInt() + 600 > uptime());
+      THEENGS_LOG_ERROR(F("[WebUI] Invalid Token Response: RT: %T, uptime: %T" CR), server.arg("RT").toInt() == requestToken, server.arg("uptime").toInt() + 600 > uptime());
       server.send(500, "text/html", "Internal ERROR - Invalid Token");
     }
   }
@@ -1520,7 +1520,7 @@ void handleIN() {
     // WEBUI_TRACE_LOG(F("[WebUI] informationDisplay after %s" CR), informationDisplay.c_str());
 
     if (informationDisplay.length() > WEB_TEMPLATE_BUFFER_MAX_SIZE) {
-      Log.warning(F("[WebUI] informationDisplay content length ( %d ) greater than WEB_TEMPLATE_BUFFER_MAX_SIZE.  Display truncated" CR), informationDisplay.length());
+      THEENGS_LOG_WARNING(F("[WebUI] informationDisplay content length ( %d ) greater than WEB_TEMPLATE_BUFFER_MAX_SIZE.  Display truncated" CR), informationDisplay.length());
     }
 
     char buffer[WEB_TEMPLATE_BUFFER_MAX_SIZE];
@@ -1578,7 +1578,7 @@ void handleUP() {
 
         String output;
         serializeJson(WEBtoSYS, output);
-        Log.notice(F("[WebUI] XtoSYSupdate %s" CR), output.c_str());
+        THEENGS_LOG_NOTICE(F("[WebUI] XtoSYSupdate %s" CR), output.c_str());
       }
 
       String topic = String(mqtt_topic) + String(gateway_name) + String(subjectMQTTtoSYSupdate);
@@ -1594,7 +1594,7 @@ void handleUP() {
 
           String output;
           serializeJson(WEBtoSYS, output);
-          Log.notice(F("[WebUI] XtoSYSupdate %s" CR), output.c_str());
+          THEENGS_LOG_NOTICE(F("[WebUI] XtoSYSupdate %s" CR), output.c_str());
         }
 
         String topic = String(mqtt_topic) + String(gateway_name) + String(subjectMQTTtoSYSupdate);
@@ -1660,7 +1660,7 @@ void handleCS() {
         WEBUI_TRACE_LOG(F("[WebUI] handleCS inject MQTT Command topic: '%s', command: '%s'" CR), cmdTopic.c_str(), command.c_str());
         receivingDATA(cmdTopic.c_str(), command.c_str());
       } else {
-        Log.warning(F("[WebUI] Missing command: '%s', command: '%s'" CR), cmdTopic.c_str(), command.c_str());
+        THEENGS_LOG_WARNING(F("[WebUI] Missing command: '%s', command: '%s'" CR), cmdTopic.c_str(), command.c_str());
       }
     }
 
@@ -1718,7 +1718,7 @@ void notFound() {
       path += ".html";
     } else {
 #  endif
-      Log.warning(F("[WebUI] notFound: uri: %s, args: %d, method: %d" CR), server.uri(), server.args(), server.method());
+      THEENGS_LOG_WARNING(F("[WebUI] notFound: uri: %s, args: %d, method: %d" CR), server.uri(), server.args(), server.method());
       server.send(404, "text/plain", "Not found");
       return;
 #  ifdef WEBUI_DEVELOPMENT
@@ -1787,11 +1787,11 @@ void WebUISetup() {
 
   Log.begin(LOG_LEVEL, &WebLog);
 
-  Log.trace(F("[WebUI] displayMetric %T" CR), displayMetric);
-  Log.trace(F("[WebUI] WebUI Secure %T" CR), webUISecure);
-  Log.notice(F("OpenMQTTGateway URL: http://%s/" CR), WiFi.localIP().toString().c_str());
+  THEENGS_LOG_TRACE(F("[WebUI] displayMetric %T" CR), displayMetric);
+  THEENGS_LOG_TRACE(F("[WebUI] WebUI Secure %T" CR), webUISecure);
+  THEENGS_LOG_NOTICE(F("OpenMQTTGateway URL: http://%s/" CR), WiFi.localIP().toString().c_str());
   displayPrint("URL: http://", (char*)WiFi.localIP().toString().c_str());
-  Log.notice(F("webUI setup done" CR));
+  THEENGS_LOG_NOTICE(F("webUI setup done" CR));
 }
 
 unsigned long nextWebUIMessage = uptime() + DISPLAY_WEBUI_INTERVAL;
@@ -1821,25 +1821,25 @@ void XtoWebUI(const char* topicOri, JsonObject& WebUIdata) { // json object deco
     // properties
     if (WebUIdata.containsKey("displayMetric")) {
       displayMetric = WebUIdata["displayMetric"].as<bool>();
-      Log.notice(F("Set displayMetric: %T" CR), displayMetric);
+      THEENGS_LOG_NOTICE(F("Set displayMetric: %T" CR), displayMetric);
       success = true;
     }
     // save, load, init, erase
     if (WebUIdata.containsKey("save") && WebUIdata["save"]) {
       success = WebUIConfig_save();
       if (success) {
-        Log.notice(F("WebUI config saved" CR));
+        THEENGS_LOG_NOTICE(F("WebUI config saved" CR));
       }
     } else if (WebUIdata.containsKey("load") && WebUIdata["load"]) {
       success = WebUIConfig_load();
       if (success) {
-        Log.notice(F("WebUI config loaded" CR));
+        THEENGS_LOG_NOTICE(F("WebUI config loaded" CR));
       }
     } else if (WebUIdata.containsKey("init") && WebUIdata["init"]) {
       WebUIConfig_init();
       success = true;
       if (success) {
-        Log.notice(F("WebUI config initialised" CR));
+        THEENGS_LOG_NOTICE(F("WebUI config initialised" CR));
       }
     } else if (WebUIdata.containsKey("erase") && WebUIdata["erase"]) {
       // Erase config from NVS (non-volatile storage)
@@ -1847,13 +1847,13 @@ void XtoWebUI(const char* topicOri, JsonObject& WebUIdata) { // json object deco
       success = preferences.remove("WebUIConfig");
       preferences.end();
       if (success) {
-        Log.notice(F("WebUI config erased" CR));
+        THEENGS_LOG_NOTICE(F("WebUI config erased" CR));
       }
     }
     if (success) {
       stateWebUIStatus();
     } else {
-      Log.error(F("[ WebUI ] XtoWebUI Fail json" CR), WebUIdata);
+      THEENGS_LOG_ERROR(F("[ WebUI ] XtoWebUI Fail json" CR), WebUIdata);
     }
   }
 }
@@ -1886,14 +1886,14 @@ bool WebUIConfig_save() {
   preferences.begin(Gateway_Short_Name, false);
   int result = preferences.putString("WebUIConfig", conf);
   preferences.end();
-  Log.trace(F("[WebUI] WebUIConfig_save: %s, result: %d" CR), conf.c_str(), result);
+  THEENGS_LOG_TRACE(F("[WebUI] WebUIConfig_save: %s, result: %d" CR), conf.c_str(), result);
   return true;
 }
 
 void WebUIConfig_init() {
   displayMetric = DISPLAY_METRIC;
   webUISecure = WEBUI_AUTH;
-  Log.notice(F("WebUI config initialised" CR));
+  THEENGS_LOG_NOTICE(F("WebUI config initialised" CR));
 }
 
 bool WebUIConfig_load() {
@@ -1903,11 +1903,11 @@ bool WebUIConfig_load() {
     auto error = deserializeJson(jsonBuffer, preferences.getString("WebUIConfig", "{}"));
     preferences.end();
     if (error) {
-      Log.error(F("WebUI config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
+      THEENGS_LOG_ERROR(F("WebUI config deserialization failed: %s, buffer capacity: %u" CR), error.c_str(), jsonBuffer.capacity());
       return false;
     }
     if (jsonBuffer.isNull()) {
-      Log.warning(F("WebUI config is null" CR));
+      THEENGS_LOG_WARNING(F("WebUI config is null" CR));
       return false;
     }
     JsonObject jo = jsonBuffer.as<JsonObject>();
@@ -1916,7 +1916,7 @@ bool WebUIConfig_load() {
     return true;
   } else {
     preferences.end();
-    Log.notice(F("No WebUI config to load" CR));
+    THEENGS_LOG_NOTICE(F("No WebUI config to load" CR));
     return false;
   }
 }
@@ -1977,10 +1977,10 @@ void webUIPubPrint(const char* topicori, JsonObject& data) {
           // Queue completed message
 
           if (xQueueSend(webUIQueue, (void*)&message, 0) != pdTRUE) {
-            Log.warning(F("[ WebUI ] ERROR: webUIQueue full, discarding %s" CR), message->title);
+            THEENGS_LOG_WARNING(F("[ WebUI ] ERROR: webUIQueue full, discarding %s" CR), message->title);
             free(message);
           } else {
-            // Log.notice(F("[ WebUI ] Queued %s" CR), message->title);
+            // THEENGS_LOG_NOTICE(F("[ WebUI ] Queued %s" CR), message->title);
           }
           break;
         }
@@ -2067,13 +2067,13 @@ void webUIPubPrint(const char* topicori, JsonObject& data) {
             // Queue completed message
 
             if (xQueueSend(webUIQueue, (void*)&message, 0) != pdTRUE) {
-              Log.warning(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
+              THEENGS_LOG_WARNING(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
               free(message);
             } else {
-              // Log.notice(F("[ WebUI ] Queued %s" CR), message->title);
+              // THEENGS_LOG_NOTICE(F("[ WebUI ] Queued %s" CR), message->title);
             }
           } else {
-            Log.error(F("[ WebUI ] rtl_433 not displaying %s" CR), message->title);
+            THEENGS_LOG_ERROR(F("[ WebUI ] rtl_433 not displaying %s" CR), message->title);
             free(message);
           }
           break;
@@ -2133,10 +2133,10 @@ void webUIPubPrint(const char* topicori, JsonObject& data) {
           // Queue completed message
 
           if (xQueueSend(webUIQueue, (void*)&message, 0) != pdTRUE) {
-            Log.warning(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
+            THEENGS_LOG_WARNING(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
             free(message);
           } else {
-            // Log.notice(F("[ WebUI ] Queued %s" CR), message->title);
+            // THEENGS_LOG_NOTICE(F("[ WebUI ] Queued %s" CR), message->title);
           }
           break;
         }
@@ -2461,10 +2461,10 @@ void webUIPubPrint(const char* topicori, JsonObject& data) {
               line4.toCharArray(message->line4, WEBUI_TEXT_WIDTH);
 
               if (xQueueSend(webUIQueue, (void*)&message, 0) != pdTRUE) {
-                Log.warning(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
+                THEENGS_LOG_WARNING(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
                 free(message);
               } else {
-                // Log.notice(F("[ WebUI ] Queued %s" CR), message->title);
+                // THEENGS_LOG_NOTICE(F("[ WebUI ] Queued %s" CR), message->title);
               }
             } else {
               WEBUI_TRACE_LOG(F("[ WebUI ] incomplete messaage %s" CR), topicori);
@@ -2519,10 +2519,10 @@ void webUIPubPrint(const char* topicori, JsonObject& data) {
           // Queue completed message
 
           if (xQueueSend(webUIQueue, (void*)&message, 0) != pdTRUE) {
-            Log.warning(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
+            THEENGS_LOG_WARNING(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
             free(message);
           } else {
-            // Log.notice(F("[ WebUI ] Queued %s" CR), message->title);
+            // THEENGS_LOG_NOTICE(F("[ WebUI ] Queued %s" CR), message->title);
           }
           break;
         }
@@ -2571,23 +2571,23 @@ void webUIPubPrint(const char* topicori, JsonObject& data) {
           // Queue completed message
 
           if (xQueueSend(webUIQueue, (void*)&message, 0) != pdTRUE) {
-            Log.warning(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
+            THEENGS_LOG_WARNING(F("[ WebUI ] webUIQueue full, discarding signal %s" CR), message->title);
             free(message);
           } else {
-            // Log.notice(F("[ WebUI ] Queued %s" CR), message->title);
+            // THEENGS_LOG_NOTICE(F("[ WebUI ] Queued %s" CR), message->title);
           }
           break;
         }
 #  endif
         default:
-          Log.verbose(F("[ WebUI ] unhandled topic %s" CR), message->title);
+          THEENGS_LOG_VERBOSE(F("[ WebUI ] unhandled topic %s" CR), message->title);
           free(message);
       }
     } else {
-      Log.error(F("[ WebUI ] insufficent memory " CR));
+      THEENGS_LOG_ERROR(F("[ WebUI ] insufficent memory " CR));
     }
   } else {
-    Log.error(F("[ WebUI ] not initalized " CR));
+    THEENGS_LOG_ERROR(F("[ WebUI ] not initalized " CR));
   }
 }