diff --git a/arduino/beken-72xx/libraries/WiFi/WiFi.cpp b/arduino/beken-72xx/libraries/WiFi/WiFi.cpp
index 24d6d4a..6091204 100644
--- a/arduino/beken-72xx/libraries/WiFi/WiFi.cpp
+++ b/arduino/beken-72xx/libraries/WiFi/WiFi.cpp
@@ -14,17 +14,17 @@ WiFiClass::~WiFiClass() {
 void WiFiClass::dataInitialize() {
 	if (data.statusIp)
 		return;
-	LT_D_WG("Init data struct");
+	LT_DM(WIFI, "Data init");
 	data.configSta	   = zalloc(sizeof(network_InitTypeDef_st));
 	data.configAp	   = zalloc(sizeof(network_InitTypeDef_ap_st));
 	data.statusIp	   = malloc(sizeof(IPStatusTypedef));
 	data.statusLink	   = malloc(sizeof(LinkStatusTypeDef));
 	STA_CFG->dhcp_mode = DHCP_CLIENT;
-	LT_D_WG("data status = %p", data.configSta);
+	LT_DM(WIFI, "Data = %p", data.configSta);
 }
 
 void WiFiClass::dataFree() {
-	LT_D_WG("Free data struct");
+	LT_DM(WIFI, "Data free");
 	free(data.configSta);
 	free(data.configAp);
 	free(data.statusIp);
diff --git a/arduino/beken-72xx/libraries/WiFi/WiFiAP.cpp b/arduino/beken-72xx/libraries/WiFi/WiFiAP.cpp
index 55fef2f..28fac2a 100644
--- a/arduino/beken-72xx/libraries/WiFi/WiFiAP.cpp
+++ b/arduino/beken-72xx/libraries/WiFi/WiFiAP.cpp
@@ -35,7 +35,7 @@ bool WiFiClass::softAP(const char *ssid, const char *passphrase, int channel, bo
 		LT_E("SoftAP failed; ret=%d", ret);
 		return false;
 	}
-	LT_D_WG("Start OK");
+	LT_DM(WIFI, "AP start OK");
 	return true;
 }
 
diff --git a/arduino/beken-72xx/libraries/WiFi/WiFiEvents.cpp b/arduino/beken-72xx/libraries/WiFi/WiFiEvents.cpp
index 0c7885e..5836c1e 100644
--- a/arduino/beken-72xx/libraries/WiFi/WiFiEvents.cpp
+++ b/arduino/beken-72xx/libraries/WiFi/WiFiEvents.cpp
@@ -50,7 +50,7 @@ void wifiEventHandler(rw_evt_type event) {
 	if (!pWiFi)
 		return; // failsafe
 
-	LT_D_WG("WiFi event %u", event);
+	LT_DM(WIFI, "BK event %u", event);
 
 	if (event <= RW_EVT_STA_GOT_IP)
 		pWiFi->data.lastStaEvent = event;
diff --git a/arduino/beken-72xx/libraries/WiFi/WiFiGeneric.cpp b/arduino/beken-72xx/libraries/WiFi/WiFiGeneric.cpp
index e2e5cd0..0e6c522 100644
--- a/arduino/beken-72xx/libraries/WiFi/WiFiGeneric.cpp
+++ b/arduino/beken-72xx/libraries/WiFi/WiFiGeneric.cpp
@@ -7,35 +7,35 @@ bool WiFiClass::modePriv(WiFiMode mode, WiFiModeAction sta, WiFiModeAction ap) {
 	startWifiTask();
 
 	if (!__bk_rf_is_init) {
-		LT_D_WG("Initializing func&app");
+		LT_DM(WIFI, "Initializing func&app");
 		func_init_extended();
 		app_pre_start();
 		// wait for the init_thread to finish its job
 		while (xTaskGetHandle("init_thread")) {
-			LT_V_WG("Waiting for init_thread");
+			LT_VM(WIFI, "Waiting for init_thread");
 			delay(10);
 		}
-		LT_D_WG("Success");
+		LT_DM(WIFI, "Init OK");
 		__bk_rf_is_init = true;
 	}
 
 	LT_HEAP_I();
 
 	if (mode) {
-		LT_D_WG("Wakeup RF");
+		LT_DM(WIFI, "Wakeup RF");
 		uint32_t reg = 1; // this is only checked for being true-ish
 		sddev_control(SCTRL_DEV_NAME, CMD_RF_HOLD_BIT_SET, &reg);
 	}
 
 	if (sta == WLMODE_ENABLE) {
-		LT_D_WG("Enabling STA");
+		LT_DM(WIFI, "Enabling STA");
 		bk_wlan_sta_init(NULL);
 #if CFG_WPA_CTRL_IFACE
 		wlan_sta_enable();
 #endif
 		wifiEventSendArduino(ARDUINO_EVENT_WIFI_STA_START);
 	} else if (sta == WLMODE_DISABLE) {
-		LT_D_WG("Disabling STA");
+		LT_DM(WIFI, "Disabling STA");
 		bk_wlan_stop(BK_STATION);
 		wifiEventSendArduino(ARDUINO_EVENT_WIFI_STA_STOP);
 	}
@@ -43,7 +43,7 @@ bool WiFiClass::modePriv(WiFiMode mode, WiFiModeAction sta, WiFiModeAction ap) {
 	LT_HEAP_I();
 
 	if (ap == WLMODE_ENABLE) {
-		LT_D_WG("Enabling AP");
+		LT_DM(WIFI, "Enabling AP");
 		bk_wlan_ap_init(NULL);
 #if CFG_WPA_CTRL_IFACE
 		wlan_ap_enable();
@@ -52,7 +52,7 @@ bool WiFiClass::modePriv(WiFiMode mode, WiFiModeAction sta, WiFiModeAction ap) {
 #endif
 		wifiEventSendArduino(ARDUINO_EVENT_WIFI_AP_START);
 	} else if (ap == WLMODE_DISABLE) {
-		LT_D_WG("Disabling AP");
+		LT_DM(WIFI, "Disabling AP");
 		bk_wlan_stop(BK_SOFT_AP);
 		wifiEventSendArduino(ARDUINO_EVENT_WIFI_AP_STOP);
 	}
diff --git a/arduino/beken-72xx/libraries/WiFi/WiFiSTA.cpp b/arduino/beken-72xx/libraries/WiFi/WiFiSTA.cpp
index e1b7c20..798fdc5 100644
--- a/arduino/beken-72xx/libraries/WiFi/WiFiSTA.cpp
+++ b/arduino/beken-72xx/libraries/WiFi/WiFiSTA.cpp
@@ -70,12 +70,12 @@ bool WiFiClass::reconnect(const uint8_t *bssid) {
 	}
 
 	if (bssid) {
-		LT_D_WG("Connecting to " MACSTR, MAC2STR(bssid));
+		LT_IM(WIFI, "Connecting to " MACSTR, MAC2STR(bssid));
 	} else {
-		LT_D_WG("Connecting to %s", STA_CFG->wifi_ssid);
+		LT_IM(WIFI, "Connecting to %s", STA_CFG->wifi_ssid);
 	}
 
-	LT_D_WG("data status = %p", data.configSta);
+	LT_DM(WIFI, "Data = %p", data.configSta);
 
 	STA_CFG->wifi_mode			 = BK_STATION;
 	STA_CFG->wifi_retry_interval = 100;
@@ -85,19 +85,19 @@ bool WiFiClass::reconnect(const uint8_t *bssid) {
 		memset(STA_CFG->wifi_bssid, 0x00, 6);
 
 	if (STA_CFG->dhcp_mode == DHCP_DISABLE) {
-		LT_D_WG("Static IP: %s / %s / %s", STA_CFG->local_ip_addr, STA_CFG->net_mask, STA_CFG->gateway_ip_addr);
-		LT_D_WG("Static DNS: %s", STA_CFG->dns_server_ip_addr);
+		LT_DM(WIFI, "Static IP: %s / %s / %s", STA_CFG->local_ip_addr, STA_CFG->net_mask, STA_CFG->gateway_ip_addr);
+		LT_DM(WIFI, "Static DNS: %s", STA_CFG->dns_server_ip_addr);
 	} else {
-		LT_D_WG("Using DHCP");
+		LT_DM(WIFI, "Using DHCP");
 	}
 
-	LT_D_WG("Starting WiFi...");
+	LT_DM(WIFI, "Starting WiFi...");
 
 	__wrap_bk_printf_disable();
 	bk_wlan_start_sta(STA_CFG);
 	__wrap_bk_printf_enable();
 
-	LT_D_WG("Start OK");
+	LT_DM(WIFI, "Start OK");
 	return true;
 
 error:
@@ -108,7 +108,7 @@ bool WiFiClass::disconnect(bool wifiOff) {
 #if LT_DEBUG_WIFI
 	memset(LINK_STATUS, 0x00, sizeof(LinkStatusTypeDef));
 	bk_wlan_get_link_status(LINK_STATUS);
-	LT_D_WG("Disconnecting from %s (wifiOff=%d)", LINK_STATUS ? LINK_STATUS->ssid : NULL, wifiOff);
+	LT_DM(WIFI, "Disconnecting from %s (wifiOff=%d)", LINK_STATUS ? LINK_STATUS->ssid : NULL, wifiOff);
 #endif
 	bk_wlan_connection_loss();
 	if (wifiOff)
diff --git a/arduino/beken-72xx/libraries/WiFi/WiFiScan.cpp b/arduino/beken-72xx/libraries/WiFi/WiFiScan.cpp
index 1f2eff2..df2dce9 100644
--- a/arduino/beken-72xx/libraries/WiFi/WiFiScan.cpp
+++ b/arduino/beken-72xx/libraries/WiFi/WiFiScan.cpp
@@ -20,7 +20,7 @@ static void scanHandler(void *ctx, uint8_t param) {
 		LT_E("Failed to get scan result");
 		goto end;
 	}
-	LT_D_WG("Found %d APs", result.ApNum);
+	LT_DM(WIFI, "Found %d APs", result.ApNum);
 
 	cls->scanAlloc(result.ApNum);
 	if (!scan->ap) {
diff --git a/arduino/libretuya/api/WiFi/WiFiGeneric.cpp b/arduino/libretuya/api/WiFi/WiFiGeneric.cpp
index 8b586de..0ad5c1b 100644
--- a/arduino/libretuya/api/WiFi/WiFiGeneric.cpp
+++ b/arduino/libretuya/api/WiFi/WiFiGeneric.cpp
@@ -7,7 +7,7 @@ bool WiFiClass::mode(WiFiMode mode) {
 	pWiFi = this;
 
 	WiFiMode currentMode = getMode();
-	LT_D_WG("Mode changing %u -> %u", currentMode, mode);
+	LT_DM(WIFI, "Mode changing %u -> %u", currentMode, mode);
 	if (mode == currentMode)
 		return true;
 
diff --git a/arduino/libretuya/core/LibreTuyaConfig.h b/arduino/libretuya/core/LibreTuyaConfig.h
index a8fa9eb..93cd596 100644
--- a/arduino/libretuya/core/LibreTuyaConfig.h
+++ b/arduino/libretuya/core/LibreTuyaConfig.h
@@ -76,20 +76,12 @@
 #define LT_DEBUG_WIFI 0
 #endif
 
-#ifndef LT_DEBUG_WIFI_CLIENT
-#define LT_DEBUG_WIFI_CLIENT 0
+#ifndef LT_DEBUG_CLIENT
+#define LT_DEBUG_CLIENT 0
 #endif
 
-#ifndef LT_DEBUG_WIFI_SERVER
-#define LT_DEBUG_WIFI_SERVER 0
-#endif
-
-#ifndef LT_DEBUG_WIFI_STA
-#define LT_DEBUG_WIFI_STA 0
-#endif
-
-#ifndef LT_DEBUG_WIFI_AP
-#define LT_DEBUG_WIFI_AP 0
+#ifndef LT_DEBUG_SERVER
+#define LT_DEBUG_SERVER 0
 #endif
 
 #ifndef LT_DEBUG_SSL
diff --git a/arduino/libretuya/core/lt_logger.h b/arduino/libretuya/core/lt_logger.h
index 3f85dec..dd0d2c0 100644
--- a/arduino/libretuya/core/lt_logger.h
+++ b/arduino/libretuya/core/lt_logger.h
@@ -7,9 +7,21 @@
 
 #if LT_LOGGER_CALLER
 #define LT_LOG(level, caller, line, ...) lt_log(level, caller, line, __VA_ARGS__)
+#define LT_LOGM(level, module, caller, line, ...)                                                                      \
+	do {                                                                                                               \
+		if (LT_DEBUG_##module) {                                                                                       \
+			lt_log(level, caller, line, #module ": " __VA_ARGS__);                                                     \
+		}                                                                                                              \
+	} while (0)
 void lt_log(const uint8_t level, const char *caller, const unsigned short line, const char *format, ...);
 #else
 #define LT_LOG(level, caller, line, ...) lt_log(level, __VA_ARGS__)
+#define LT_LOGM(level, module, caller, line, ...)                                                                      \
+	do {                                                                                                               \
+		if (LT_DEBUG_##module) {                                                                                       \
+			lt_log(level, #module ": " __VA_ARGS__);                                                                   \
+		}                                                                                                              \
+	} while (0)
 void lt_log(const uint8_t level, const char *format, ...);
 #endif
 
@@ -26,41 +38,55 @@ void lt_log_set_port(uint8_t port);
 void lt_log_disable();
 
 #if LT_LEVEL_TRACE >= LT_LOGLEVEL
-#define LT_T(...) LT_LOG(LT_LEVEL_TRACE, __FUNCTION__, __LINE__, __VA_ARGS__)
-#define LT_V(...) LT_LOG(LT_LEVEL_TRACE, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_T(...)		   LT_LOG(LT_LEVEL_TRACE, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_V(...)		   LT_LOG(LT_LEVEL_TRACE, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_TM(module, ...) LT_LOGM(LT_LEVEL_TRACE, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_VM(module, ...) LT_LOGM(LT_LEVEL_TRACE, module, __FUNCTION__, __LINE__, __VA_ARGS__)
 #else
 #define LT_T(...)
 #define LT_V(...)
+#define LT_TM(...)
+#define LT_VM(...)
 #endif
 
 #if LT_LEVEL_DEBUG >= LT_LOGLEVEL
-#define LT_D(...) LT_LOG(LT_LEVEL_DEBUG, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_D(...)		   LT_LOG(LT_LEVEL_DEBUG, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_DM(module, ...) LT_LOGM(LT_LEVEL_DEBUG, module, __FUNCTION__, __LINE__, __VA_ARGS__)
 #else
 #define LT_D(...)
+#define LT_DM(...)
 #endif
 
 #if LT_LEVEL_INFO >= LT_LOGLEVEL
-#define LT_I(...) LT_LOG(LT_LEVEL_INFO, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_I(...)		   LT_LOG(LT_LEVEL_INFO, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_IM(module, ...) LT_LOGM(LT_LEVEL_INFO, module, __FUNCTION__, __LINE__, __VA_ARGS__)
 #else
 #define LT_I(...)
+#define LT_IM(...)
 #endif
 
 #if LT_LEVEL_WARN >= LT_LOGLEVEL
-#define LT_W(...) LT_LOG(LT_LEVEL_WARN, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_W(...)		   LT_LOG(LT_LEVEL_WARN, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_WM(module, ...) LT_LOGM(LT_LEVEL_WARN, module, __FUNCTION__, __LINE__, __VA_ARGS__)
 #else
 #define LT_W(...)
+#define LT_WM(...)
 #endif
 
 #if LT_LEVEL_ERROR >= LT_LOGLEVEL
-#define LT_E(...) LT_LOG(LT_LEVEL_ERROR, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_E(...)		   LT_LOG(LT_LEVEL_ERROR, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_EM(module, ...) LT_LOGM(LT_LEVEL_ERROR, module, __FUNCTION__, __LINE__, __VA_ARGS__)
 #else
 #define LT_E(...)
+#define LT_EM(...)
 #endif
 
 #if LT_LEVEL_FATAL >= LT_LOGLEVEL
-#define LT_F(...) LT_LOG(LT_LEVEL_FATAL, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_F(...)		   LT_LOG(LT_LEVEL_FATAL, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_FM(module, ...) LT_LOGM(LT_LEVEL_FATAL, module, __FUNCTION__, __LINE__, __VA_ARGS__)
 #else
 #define LT_F(...)
+#define LT_FM(...)
 #endif
 
 #if LT_LOG_HEAP
@@ -96,20 +122,6 @@ void lt_log_disable();
 #define ets_printf(...)		LT_I(__VA_ARGS__)
 #define ETS_PRINTF(...)		LT_I(__VA_ARGS__)
 
-#define LT_T_MOD(module, ...)                                                                                          \
-	do {                                                                                                               \
-		if (module) {                                                                                                  \
-			LT_T(__VA_ARGS__);                                                                                         \
-		}                                                                                                              \
-	} while (0)
-
-#define LT_D_MOD(module, ...)                                                                                          \
-	do {                                                                                                               \
-		if (module) {                                                                                                  \
-			LT_D(__VA_ARGS__);                                                                                         \
-		}                                                                                                              \
-	} while (0)
-
 #define LT_RET(ret)                                                                                                    \
 	LT_E("ret=%d", ret);                                                                                               \
 	return ret;
@@ -155,43 +167,3 @@ void lt_log_disable();
 #else
 #define LT_ERRNO()
 #endif
-
-// WiFi.cpp
-#define LT_T_WG(...) LT_T_MOD(LT_DEBUG_WIFI, __VA_ARGS__)
-#define LT_V_WG(...) LT_T_MOD(LT_DEBUG_WIFI, __VA_ARGS__)
-#define LT_D_WG(...) LT_D_MOD(LT_DEBUG_WIFI, __VA_ARGS__)
-
-// WiFiClient.cpp
-#define LT_T_WC(...) LT_T_MOD(LT_DEBUG_WIFI_CLIENT, __VA_ARGS__)
-#define LT_V_WC(...) LT_T_MOD(LT_DEBUG_WIFI_CLIENT, __VA_ARGS__)
-#define LT_D_WC(...) LT_D_MOD(LT_DEBUG_WIFI_CLIENT, __VA_ARGS__)
-
-// WiFiServer.cpp
-#define LT_T_WS(...) LT_T_MOD(LT_DEBUG_WIFI_SERVER, __VA_ARGS__)
-#define LT_V_WS(...) LT_T_MOD(LT_DEBUG_WIFI_SERVER, __VA_ARGS__)
-#define LT_D_WS(...) LT_D_MOD(LT_DEBUG_WIFI_SERVER, __VA_ARGS__)
-
-// WiFiSTA.cpp
-#define LT_T_WSTA(...) LT_T_MOD(LT_DEBUG_WIFI_STA, __VA_ARGS__)
-#define LT_V_WSTA(...) LT_T_MOD(LT_DEBUG_WIFI_STA, __VA_ARGS__)
-#define LT_D_WSTA(...) LT_D_MOD(LT_DEBUG_WIFI_STA, __VA_ARGS__)
-
-// WiFiAP.cpp
-#define LT_T_WAP(...) LT_T_MOD(LT_DEBUG_WIFI_AP, __VA_ARGS__)
-#define LT_V_WAP(...) LT_T_MOD(LT_DEBUG_WIFI_AP, __VA_ARGS__)
-#define LT_D_WAP(...) LT_D_MOD(LT_DEBUG_WIFI_AP, __VA_ARGS__)
-
-// WiFiClientSecure.cpp & implementations
-#define LT_T_SSL(...) LT_T_MOD(LT_DEBUG_SSL, __VA_ARGS__)
-#define LT_V_SSL(...) LT_T_MOD(LT_DEBUG_SSL, __VA_ARGS__)
-#define LT_D_SSL(...) LT_D_MOD(LT_DEBUG_SSL, __VA_ARGS__)
-
-// Update.cpp
-#define LT_T_OTA(...) LT_T_MOD(LT_DEBUG_OTA, __VA_ARGS__)
-#define LT_V_OTA(...) LT_T_MOD(LT_DEBUG_OTA, __VA_ARGS__)
-#define LT_D_OTA(...) LT_D_MOD(LT_DEBUG_OTA, __VA_ARGS__)
-
-// mDNS.cpp
-#define LT_T_MDNS(...) LT_T_MOD(LT_DEBUG_MDNS, __VA_ARGS__)
-#define LT_V_MDNS(...) LT_T_MOD(LT_DEBUG_MDNS, __VA_ARGS__)
-#define LT_D_MDNS(...) LT_D_MOD(LT_DEBUG_MDNS, __VA_ARGS__)
diff --git a/arduino/libretuya/libraries/NetUtils/lwip/LwIPClient.cpp b/arduino/libretuya/libraries/NetUtils/lwip/LwIPClient.cpp
index c5f3cd1..07205e5 100644
--- a/arduino/libretuya/libraries/NetUtils/lwip/LwIPClient.cpp
+++ b/arduino/libretuya/libraries/NetUtils/lwip/LwIPClient.cpp
@@ -37,7 +37,7 @@ class SocketHandle {
 };
 
 LwIPClient::LwIPClient() {
-	LT_V_WC("LwIPClient()");
+	LT_VM(CLIENT, "LwIPClient()");
 	_connected = false;
 	_sock	   = NULL;
 	_rxBuffer  = NULL;
@@ -45,7 +45,7 @@ LwIPClient::LwIPClient() {
 }
 
 LwIPClient::LwIPClient(int sock) {
-	LT_V_WC("LwIPClient(%d)", sock);
+	LT_VM(CLIENT, "LwIPClient(%d)", sock);
 	_connected = true;
 	_sock	   = std::make_shared<SocketHandle>(sock);
 	_rxBuffer  = std::make_shared<LwIPRxBuffer>(sock);
@@ -53,7 +53,7 @@ LwIPClient::LwIPClient(int sock) {
 }
 
 LwIPClient::~LwIPClient() {
-	LT_V_WC("~LwIPClient()");
+	LT_VM(CLIENT, "~LwIPClient()");
 	stop();
 }
 
@@ -89,7 +89,7 @@ int LwIPClient::connect(IPAddress ip, uint16_t port, int32_t timeout) {
 		stop();
 	int sock = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 	if (sock < 0) {
-		LT_D_WC("socket failed");
+		LT_DM(CLIENT, "socket failed");
 		return -1;
 	}
 
@@ -223,7 +223,7 @@ size_t LwIPClient::write(const uint8_t *buf, size_t size) {
 			}
 		}
 	}
-	LT_D_WC("wrote %d bytes", written);
+	LT_DM(CLIENT, "wrote %d bytes", written);
 	return written;
 }
 
@@ -306,7 +306,7 @@ void LwIPClient::flush() {
 }
 
 void LwIPClient::stop() {
-	LT_V_WC("Stopping TCP");
+	LT_VM(CLIENT, "Stopping TCP");
 	_connected = false;
 	_sock	   = NULL;
 	_rxBuffer  = NULL;
diff --git a/arduino/libretuya/libraries/NetUtils/lwip/LwIPRxBuffer.cpp b/arduino/libretuya/libraries/NetUtils/lwip/LwIPRxBuffer.cpp
index 8d60aed..b1bc7ec 100644
--- a/arduino/libretuya/libraries/NetUtils/lwip/LwIPRxBuffer.cpp
+++ b/arduino/libretuya/libraries/NetUtils/lwip/LwIPRxBuffer.cpp
@@ -14,13 +14,13 @@ extern "C" {
 
 size_t LwIPRxBuffer::r_available() {
 	if (_sock < 0) {
-		LT_D_WC("_sock < 0");
+		LT_DM(CLIENT, "_sock < 0");
 		return 0;
 	}
 	int count = 0; // must be of same size as in lwip_ioctl()
 	int res	  = lwip_ioctl(_sock, FIONREAD, &count);
 	if (res < 0) {
-		LT_D_WC("lwip_ioctl()=%d, errno=%d", res, errno);
+		LT_DM(CLIENT, "lwip_ioctl()=%d, errno=%d", res, errno);
 		_failed = true;
 		return 0;
 	}
diff --git a/arduino/libretuya/libraries/NetUtils/lwip/LwIPServer.cpp b/arduino/libretuya/libraries/NetUtils/lwip/LwIPServer.cpp
index aa5f56d..14526f8 100644
--- a/arduino/libretuya/libraries/NetUtils/lwip/LwIPServer.cpp
+++ b/arduino/libretuya/libraries/NetUtils/lwip/LwIPServer.cpp
@@ -99,7 +99,7 @@ WiFiClient LwIPServer::accept() {
 				// and receive data, so LwIP still sees a connected client that sends nothing. At least
 				// that's what I understand. And any loop that doesn't call delay() seems to block the TCP
 				// stack completely and prevents it from even being pinged.
-				LT_D_WS("Got client");
+				LT_DM(SERVER, "Got client");
 				delay(5);
 				return WiFiClient(sock);
 			}
diff --git a/arduino/libretuya/libraries/NetUtils/ssl/MbedTLSClient.cpp b/arduino/libretuya/libraries/NetUtils/ssl/MbedTLSClient.cpp
index eeaa661..fe82315 100644
--- a/arduino/libretuya/libraries/NetUtils/ssl/MbedTLSClient.cpp
+++ b/arduino/libretuya/libraries/NetUtils/ssl/MbedTLSClient.cpp
@@ -22,12 +22,12 @@ MbedTLSClient::MbedTLSClient(int sock) : WiFiClient(sock) {
 }
 
 MbedTLSClient::~MbedTLSClient() {
-	LT_V_WC("~MbedTLSClient()");
+	LT_VM(CLIENT, "~MbedTLSClient()");
 	stop();
 }
 
 void MbedTLSClient::stop() {
-	LT_V_SSL("Stopping SSL");
+	LT_VM(SSL, "Stopping SSL");
 
 	if (_sslCfg.ca_chain) {
 		mbedtls_x509_crt_free(&_caCert);
@@ -121,7 +121,7 @@ int MbedTLSClient::connect(
 
 	char *uid = "lt-ssl"; // TODO
 
-	LT_V_SSL("Init SSL");
+	LT_VM(SSL, "Init SSL");
 	init();
 	LT_HEAP_I();
 
@@ -185,13 +185,13 @@ int MbedTLSClient::connect(
 	if (!_insecure && clientCert && clientKey) {
 		mbedtls_x509_crt_init(&_clientCert);
 		mbedtls_pk_init(&_clientKey);
-		LT_V_SSL("Loading client cert");
+		LT_VM(SSL, "Loading client cert");
 		ret = mbedtls_x509_crt_parse(&_clientCert, (const unsigned char *)clientCert, strlen(clientCert) + 1);
 		if (ret < 0) {
 			mbedtls_x509_crt_free(&_clientCert);
 			LT_RET(ret);
 		}
-		LT_V_SSL("Loading private key");
+		LT_VM(SSL, "Loading private key");
 		ret = mbedtls_pk_parse_key(&_clientKey, (const unsigned char *)clientKey, strlen(clientKey) + 1, NULL, 0);
 		if (ret < 0) {
 			mbedtls_x509_crt_free(&_clientCert);
@@ -200,7 +200,7 @@ int MbedTLSClient::connect(
 		mbedtls_ssl_conf_own_cert(&_sslCfg, &_clientCert, &_clientKey);
 	}
 
-	LT_V_SSL("Setting TLS hostname");
+	LT_VM(SSL, "Setting TLS hostname");
 	ret = mbedtls_ssl_set_hostname(&_sslCtx, host);
 	LT_RET_NZ(ret);
 
@@ -214,7 +214,7 @@ int MbedTLSClient::connect(
 
 	LT_HEAP_I();
 
-	LT_V_SSL("SSL handshake");
+	LT_VM(SSL, "SSL handshake");
 	if (_handshakeTimeout == 0)
 		_handshakeTimeout = timeout;
 	unsigned long start = millis();
@@ -232,20 +232,21 @@ int MbedTLSClient::connect(
 	LT_HEAP_I();
 
 	if (clientCert && clientKey) {
-		LT_D_SSL(
+		LT_DM(
+			SSL,
 			"Protocol %s, ciphersuite %s",
 			mbedtls_ssl_get_version(&_sslCtx),
 			mbedtls_ssl_get_ciphersuite(&_sslCtx)
 		);
 		ret = mbedtls_ssl_get_record_expansion(&_sslCtx);
 		if (ret >= 0)
-			LT_D_SSL("Record expansion: %d", ret);
+			LT_DM(SSL, "Record expansion: %d", ret);
 		else {
 			LT_W("Record expansion unknown");
 		}
 	}
 
-	LT_V_SSL("Verifying certificate");
+	LT_VM(SSL, "Verifying certificate");
 	ret = mbedtls_ssl_get_verify_result(&_sslCtx);
 	if (ret) {
 		char buf[512];
@@ -417,7 +418,7 @@ bool MbedTLSClient::verify(const char *fingerprint, const char *domainName) {
 		return false;
 
 	if (memcmp(fpLocal, fpRemote, 32)) {
-		LT_D_SSL("Fingerprints don't match");
+		LT_DM(SSL, "Fingerprints don't match");
 		return false;
 	}
 
diff --git a/arduino/libretuya/libraries/Update/Update.cpp b/arduino/libretuya/libraries/Update/Update.cpp
index da74810..af0c861 100644
--- a/arduino/libretuya/libraries/Update/Update.cpp
+++ b/arduino/libretuya/libraries/Update/Update.cpp
@@ -18,7 +18,7 @@ bool UpdateClass::begin(size_t size, int command, int unused2, uint8_t unused3,
 		return false;
 	cleanup();
 
-	LT_D_OTA("begin(%u, ...) / OTA curr: %u, trgt: %u", size, LT.otaGetRunning(), LT.otaGetTarget());
+	LT_DM(OTA, "begin(%u, ...) / OTA curr: %u, trgt: %u", size, LT.otaGetRunning(), LT.otaGetTarget());
 
 	ctx	 = uf2_ctx_init(LT.otaGetTarget(), FAMILY);
 	info = uf2_info_init();
@@ -72,7 +72,7 @@ size_t UpdateClass::write(uint8_t *data, size_t len) {
 		// 0 if not running
 		return 0;
 
-	LT_D_OTA("write(%u) / buf %u/512", len, bufSize());
+	LT_VM(OTA, "write(%u) / buf %u/512", len, bufSize());
 
 	/* while (buf == bufPos && len >= UF2_BLOCK_SIZE) {
 		// buffer empty and entire block is in data
@@ -145,7 +145,7 @@ size_t UpdateClass::writeStream(Stream &data) {
 size_t UpdateClass::tryWriteData(uint8_t *data, size_t len) {
 	uf2_block_t *block = NULL;
 
-	LT_V_OTA("Writing %u to buffer (%u/512)", len, bufSize());
+	LT_VM(OTA, "Writing %u to buffer (%u/512)", len, bufSize());
 
 	if (len == UF2_BLOCK_SIZE) {
 		// data has a complete block
@@ -185,7 +185,7 @@ size_t UpdateClass::tryWriteData(uint8_t *data, size_t len) {
 				bytesTotal = block->block_count * UF2_BLOCK_SIZE;
 			} else if (bytesTotal != block->block_count * UF2_BLOCK_SIZE) {
 				// given update size does not match the block count
-				LT_D_OTA("Image size wrong; got %u, calculated %u", bytesTotal, block->block_count * UF2_BLOCK_SIZE);
+				LT_DM(OTA, "Image size wrong; got %u, calculated %u", bytesTotal, block->block_count * UF2_BLOCK_SIZE);
 				return errorArd(UPDATE_ERROR_SIZE);
 			}
 		} else {
diff --git a/arduino/libretuya/libraries/Update/UpdateUtil.cpp b/arduino/libretuya/libraries/Update/UpdateUtil.cpp
index d9d8b76..88df3a6 100644
--- a/arduino/libretuya/libraries/Update/UpdateUtil.cpp
+++ b/arduino/libretuya/libraries/Update/UpdateUtil.cpp
@@ -53,7 +53,7 @@ void UpdateClass::cleanup() {
  */
 bool UpdateClass::errorUf2(uf2_err_t err) {
 	if (err)
-		LT_D_OTA("[%4d] errorUf2(%d)", ctx ? ctx->seq : 0, err);
+		LT_DM(OTA, "[%4d] errorUf2(%d)", ctx ? ctx->seq : 0, err);
 	if (err <= UF2_ERR_IGNORE)
 		return false;
 	cleanup();
@@ -70,7 +70,7 @@ bool UpdateClass::errorUf2(uf2_err_t err) {
  */
 bool UpdateClass::errorArd(uint8_t err) {
 	if (err)
-		LT_D_OTA("[%4d] errorArd(%d)", ctx ? ctx->seq : 0, err);
+		LT_DM(OTA, "[%4d] errorArd(%d)", ctx ? ctx->seq : 0, err);
 	cleanup();
 	errUf2 = UF2_ERR_OK;
 	errArd = err;
@@ -81,7 +81,7 @@ bool UpdateClass::errorArd(uint8_t err) {
  * @brief Abort the update with UPDATE_ERROR_ABORT reason.
  */
 void UpdateClass::abort() {
-	LT_D_OTA("Aborting update");
+	LT_DM(OTA, "Aborting update");
 	errorArd(UPDATE_ERROR_ABORT);
 }
 
diff --git a/arduino/libretuya/libraries/mDNS/LwIPmDNS.cpp b/arduino/libretuya/libraries/mDNS/LwIPmDNS.cpp
index ef242bd..1302501 100644
--- a/arduino/libretuya/libraries/mDNS/LwIPmDNS.cpp
+++ b/arduino/libretuya/libraries/mDNS/LwIPmDNS.cpp
@@ -32,11 +32,11 @@ static void mdnsTxtCallback(struct mdns_service *service, void *userdata) {
 }
 
 static void mdnsStatusCallback(struct netif *netif, uint8_t result) {
-	LT_D_MDNS("mdns status: netif %u, status %u", netif->num, result);
+	LT_DM(MDNS, "Status: netif %u, status %u", netif->num, result);
 }
 
 bool mDNS::begin(const char *hostname) {
-	LT_D_MDNS("Starting mDNS (%s)", hostname);
+	LT_DM(MDNS, "Starting (%s)", hostname);
 	mdns_resp_register_name_result_cb(mdnsStatusCallback);
 	mdns_resp_init();
 	uint8_t enabled = 0;
@@ -46,9 +46,9 @@ bool mDNS::begin(const char *hostname) {
 		if (!netif_is_up(netif))
 			continue;
 
-		LT_D_MDNS("Adding netif %u", netif->num);
+		LT_DM(MDNS, "Adding netif %u", netif->num);
 		if ((netif->flags & NETIF_FLAG_IGMP) == 0) {
-			LT_D_MDNS("Enabling IGMP");
+			LT_DM(MDNS, "Enabling IGMP");
 			netif->flags |= NETIF_FLAG_IGMP;
 			igmp_start(netif);
 		}
@@ -57,7 +57,7 @@ bool mDNS::begin(const char *hostname) {
 		if (ret == ERR_OK)
 			enabled++;
 		else
-			LT_D_MDNS("Cannot add mDNS netif %u; ret=%d, errno=%d", netif->num, ret, errno);
+			LT_DM(MDNS, "Cannot add netif %u; ret=%d, errno=%d", netif->num, ret, errno);
 	}
 	return enabled > 0;
 }
@@ -78,7 +78,7 @@ bool mDNS::addServiceImpl(const char *name, const char *service, uint8_t proto,
 		if (netif_is_up(netif)) {
 			// register TXT callback;
 			// pass service index as userdata parameter
-			LT_D_MDNS("mDNS add service: netif %u / %s / %s / %u / %u", netif->num, name, service, proto, port);
+			LT_DM(MDNS, "Add service: netif %u / %s / %s / %u / %u", netif->num, name, service, proto, port);
 			mdns_resp_add_service(
 				netif,
 				name,
diff --git a/arduino/realtek-ambz/libraries/WiFi/WiFiGeneric.cpp b/arduino/realtek-ambz/libraries/WiFi/WiFiGeneric.cpp
index d5de81f..6c0dc20 100644
--- a/arduino/realtek-ambz/libraries/WiFi/WiFiGeneric.cpp
+++ b/arduino/realtek-ambz/libraries/WiFi/WiFiGeneric.cpp
@@ -23,7 +23,7 @@ bool WiFiClass::modePriv(WiFiMode mode, WiFiModeAction sta, WiFiModeAction ap) {
 	LT_HEAP_I();
 	if (getMode()) {
 		// stop wifi to change mode
-		LT_D_WG("Stopping WiFi to change mode");
+		LT_DM(WIFI, "Stopping WiFi to change mode");
 		if (wifi_off() != RTW_SUCCESS)
 			goto error;
 		vTaskDelay(20);
@@ -72,12 +72,14 @@ WiFiStatus WiFiClass::status() {
 }
 
 bool WiFiClass::setSleep(bool enable) {
-	LT_D_WG("WiFi sleep mode %u", enable);
-	if (enable)
+	LT_DM(WIFI, "WiFi sleep mode %u", enable);
+	if (enable) {
 		if (wifi_enable_powersave() != RTW_SUCCESS)
 			return false;
-		else if (wifi_disable_powersave() != RTW_SUCCESS)
+	} else {
+		if (wifi_disable_powersave() != RTW_SUCCESS)
 			return false;
+	}
 	data.sleep = enable;
 	return true;
 }