zigbee-herdsman-converters 23.46.1-dev.0 → 23.47.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [23.47.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v23.46.0...v23.47.0) (2025-05-20)
+
+
+### Features
+
+* **add:** 067797 ([#9366](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9366)) ([7fee57d](https://github.com/Koenkk/zigbee-herdsman-converters/commit/7fee57d383149b4f14ab0d67a22d6752eb157284))
+* **add:** 5717 ([#9364](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9364)) ([59c942e](https://github.com/Koenkk/zigbee-herdsman-converters/commit/59c942eddc399ff1401355f929ebb7b2afaeb5b9))
+* **add:** ZC-LP01 ([#9365](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9365)) ([71a98bb](https://github.com/Koenkk/zigbee-herdsman-converters/commit/71a98bb62566bb8265de411d9389f7674d5d8de4))
+* SONOFF S60ZBTPF and S60ZBTPG: expose more features ([#9263](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9263)) ([6f82625](https://github.com/Koenkk/zigbee-herdsman-converters/commit/6f82625178c8eb41e0aecc22b1e72fa24ff8c77d))
+
+
+### Bug Fixes
+
+* **detect:** Detect `_TZE204_tdhnhhiy` as Tuya TS0601_switch_8 https://github.com/Koenkk/zigbee2mqtt/issues/27454 ([9bb691a](https://github.com/Koenkk/zigbee-herdsman-converters/commit/9bb691a4841d2543db2334a755d2b7467efd97ed))
+* **detect:** Detect `_TZE284_6ycgarab` as Tuya ZSS-QY-SSD-A-EN https://github.com/Koenkk/zigbee-herdsman-converters/issues/9289 ([64e063a](https://github.com/Koenkk/zigbee-herdsman-converters/commit/64e063a6226089ae4c8c984abdbee9dd720444fa))
+* Fix RADION TriTech ZB typo https://github.com/Koenkk/zigbee2mqtt/discussions/27455 ([6edb338](https://github.com/Koenkk/zigbee-herdsman-converters/commit/6edb33873930a6bf67aa00b2f69aa96cdd37e9fc))
+* Tuya MG-ZG01W: simplify integration ([#9363](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9363)) ([a60a23f](https://github.com/Koenkk/zigbee-herdsman-converters/commit/a60a23fc36ed62fd1b56694980e206960ef62bb3))
+
 ## [23.46.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v23.45.0...v23.46.0) (2025-05-18)
 
 

package/dist/devices/sonoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sonoff.d.ts","sourceRoot":"","sources":["../../src/devices/sonoff.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,oBAAoB,EAA8C,MAAM,cAAc,CAAC;AAyoBpG,eAAO,MAAM,WAAW,EAAE,oBAAoB,EAsoC7C,CAAC"}
+{"version":3,"file":"sonoff.d.ts","sourceRoot":"","sources":["../../src/devices/sonoff.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,oBAAoB,EAA8C,MAAM,cAAc,CAAC;AA88BpG,eAAO,MAAM,WAAW,EAAE,oBAAoB,EAwtC7C,CAAC"}

package/dist/devices/sonoff.js

@@ -86,6 +86,13 @@ const sonoffExtend = {
             deviceWorkMode: { ID: 0x0018, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
             detachRelayMode2: { ID: 0x0019, type: zigbee_herdsman_1.Zcl.DataType.BITMAP8 },
             lackWaterCloseValveTimeout: { ID: 0x5011, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+            acCurrentCurrentValue: { ID: 0x7004, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+            acCurrentVoltageValue: { ID: 0x7005, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+            acCurrentPowerValue: { ID: 0x7006, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+            outlet_control_protect: { ID: 0x7007, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+            energyToday: { ID: 0x7009, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+            energyMonth: { ID: 0x700a, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+            energyYesterday: { ID: 0x700b, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
         },
         commands: {
             protocolData: { ID: 0x01, parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.LIST_UINT8 }] },
@@ -600,6 +607,265 @@ const sonoffExtend = {
             isModernExtend: true,
         };
     },
+    overloadProtection: (powerMaxLimit, currentMaxLimit) => {
+        const clusterName = "customClusterEwelink";
+        const exposes = e
+            .composite("overload_protection", "overload_protection", ea.ALL)
+            .withDescription("Over load protection, max power and max current are required,other is optional")
+            .withFeature(e
+            .numeric("max_power", ea.SET)
+            .withDescription("max power")
+            .withUnit("W")
+            .withValueMin(0.1)
+            .withValueMax(powerMaxLimit)
+            .withValueStep(0.1))
+            .withFeature(e.binary("enable_min_power", ea.SET, "ENABLE", "DISABLE").withDescription("Enable/disable lower limit of power overload protection."))
+            .withFeature(e
+            .numeric("min_power", ea.SET)
+            .withDescription("Lower limit of power overload protection")
+            .withUnit("W")
+            .withValueMin(0.1)
+            .withValueMax(powerMaxLimit)
+            .withValueStep(0.1))
+            .withFeature(e
+            .binary("enable_max_voltage", ea.SET, "ENABLE", "DISABLE")
+            .withDescription("Enable/disable upper limit of voltage overload protection.."))
+            .withFeature(e
+            .numeric("max_voltage", ea.SET)
+            .withDescription("Upper limit of voltage overload protection.")
+            .withUnit("V")
+            .withValueMin(165)
+            .withValueMax(277)
+            .withValueStep(1))
+            .withFeature(e
+            .binary("enable_min_voltage", ea.SET, "ENABLE", "DISABLE")
+            .withDescription("Enable/disable lower limit of voltage overload protection."))
+            .withFeature(e
+            .numeric("min_voltage", ea.SET)
+            .withDescription("Lower limit of voltage overload protection.")
+            .withUnit("V")
+            .withValueMin(165)
+            .withValueMax(277)
+            .withValueStep(1))
+            .withFeature(e
+            .numeric("max_current", ea.SET)
+            .withDescription("Upper limit of current overload protection.")
+            .withUnit("A")
+            .withValueMin(0.1)
+            .withValueMax(currentMaxLimit)
+            .withValueStep(0.1))
+            .withFeature(e
+            .binary("enable_min_current", ea.SET, "ENABLE", "DISABLE")
+            .withDescription("Enable/disable lower limit of current overload protection."))
+            .withFeature(e
+            .numeric("min_current", ea.SET)
+            .withDescription("Lower limit of current overload protection.")
+            .withUnit("A")
+            .withValueMin(0.1)
+            .withValueMax(currentMaxLimit)
+            .withValueStep(0.1));
+        const fromZigbee = [
+            {
+                cluster: "customClusterEwelink",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const attributeKey = 0x7003; // attr
+                    if (attributeKey in msg.data) {
+                        //     "enable_max_voltage": "ENABLE",
+                        //     "enable_min_current": "ENABLE",
+                        //     "enable_min_power": "ENABLE",
+                        //     "enable_min_voltage": "ENABLE",
+                        //     "max_current": 23,
+                        //     "max_power": 23,
+                        //     "max_voltage": 23,
+                        //     "min_current": 23,
+                        //     "min_power": 23,
+                        //     "min_voltage": 23
+                        //   }: value:
+                        logger_1.logger.debug("attr_value is:", JSON.stringify(msg.data[attributeKey]));
+                        const buffer = Buffer.from(msg.data[attributeKey], "binary");
+                        const hexString = buffer.toString("hex").toUpperCase();
+                        console.log(`Hex: ${hexString}`);
+                        let index = 0;
+                        let enableMaxVoltageBuffer = "DISABLE";
+                        let enableMinCurrentBuffer = "DISABLE";
+                        let enableMinPowerBuffer = "DISABLE";
+                        let enableMinVoltageBuffer = "DISABLE";
+                        const tag = buffer[index++];
+                        const len = buffer[index++];
+                        if (buffer[index++] === 3) {
+                            enableMinCurrentBuffer = "ENABLE";
+                        }
+                        const voltage_set_flag = buffer[index++];
+                        if (voltage_set_flag & 0x01) {
+                            enableMaxVoltageBuffer = "ENABLE";
+                        }
+                        if (voltage_set_flag & 0x02) {
+                            enableMinVoltageBuffer = "ENABLE";
+                        }
+                        if (buffer[index++] === 3) {
+                            enableMinPowerBuffer = "ENABLE";
+                        }
+                        let minCurrentBuffer = 0;
+                        let maxVoltageBuffer = 0;
+                        let minVoltageBuffer = 0;
+                        let maxPowerBuffer = 0;
+                        let minPowerBuffer = 0;
+                        let maxCurrentBuffer = buffer[index++];
+                        maxCurrentBuffer |= buffer[index++] << 8;
+                        maxCurrentBuffer |= buffer[index++] << 16;
+                        maxCurrentBuffer |= buffer[index++] << 24;
+                        maxCurrentBuffer /= 1000;
+                        if (enableMinCurrentBuffer === "ENABLE") {
+                            minCurrentBuffer = buffer[index++];
+                            minCurrentBuffer |= buffer[index++] << 8;
+                            minCurrentBuffer |= buffer[index++] << 16;
+                            minCurrentBuffer |= buffer[index++] << 24;
+                            minCurrentBuffer /= 1000;
+                        }
+                        if (enableMaxVoltageBuffer === "ENABLE") {
+                            for (let i = 0; i < 4; i++) {
+                                logger_1.logger.debug("max voltage is:", JSON.stringify(buffer[index + i]));
+                            }
+                            logger_1.logger.debug("index is", JSON.stringify(index));
+                            maxVoltageBuffer = buffer[index++];
+                            maxVoltageBuffer |= buffer[index++] << 8;
+                            maxVoltageBuffer |= buffer[index++] << 16;
+                            maxVoltageBuffer |= buffer[index++] << 24;
+                            maxVoltageBuffer /= 1000;
+                        }
+                        if (enableMinVoltageBuffer === "ENABLE") {
+                            minVoltageBuffer = buffer[index++];
+                            minVoltageBuffer |= buffer[index++] << 8;
+                            minVoltageBuffer |= buffer[index++] << 16;
+                            minVoltageBuffer |= buffer[index++] << 24;
+                            minVoltageBuffer /= 1000;
+                        }
+                        maxPowerBuffer = buffer[index++];
+                        maxPowerBuffer |= buffer[index++] << 8;
+                        maxPowerBuffer |= buffer[index++] << 16;
+                        maxPowerBuffer |= buffer[index++] << 24;
+                        maxPowerBuffer /= 1000;
+                        if (enableMinPowerBuffer === "ENABLE") {
+                            minPowerBuffer = buffer[index++];
+                            minPowerBuffer |= buffer[index++] << 8;
+                            minPowerBuffer |= buffer[index++] << 16;
+                            minPowerBuffer |= buffer[index++] << 24;
+                            minPowerBuffer /= 1000;
+                        }
+                        return {
+                            overload_protection: {
+                                enable_max_voltage: enableMaxVoltageBuffer,
+                                enable_min_current: enableMinCurrentBuffer,
+                                enable_min_power: enableMinPowerBuffer,
+                                enable_min_voltage: enableMinPowerBuffer,
+                                max_current: maxCurrentBuffer,
+                                max_power: maxPowerBuffer,
+                                max_voltage: maxVoltageBuffer,
+                                min_current: minCurrentBuffer,
+                                min_power: minPowerBuffer,
+                                min_voltage: minVoltageBuffer,
+                            },
+                        };
+                    }
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["overload_protection"],
+                convertSet: async (entity, key, value, meta) => {
+                    logger_1.logger.debug("value:", JSON.stringify(value, null, 2)); // 将 value 转换为格式化的 JSON 字符串
+                    const maxC = 1000 * value["max_current"];
+                    const minC = 1000 * value["min_current"];
+                    const maxV = 1000 * value["max_voltage"];
+                    const minV = 1000 * value["min_voltage"];
+                    const maxP = 1000 * value["max_power"];
+                    const minP = 1000 * value["min_power"];
+                    const enMinC = value["enable_min_current"];
+                    const enMaxV = value["enable_max_voltage"];
+                    const enMinV = value["enable_min_voltage"];
+                    const enMinP = value["enable_min_power"];
+                    const params = { maxC, minC, maxV, minV, maxP, minP, enMinC, enMaxV, enMinV, enMinP };
+                    logger_1.logger.debug("value:", JSON.stringify(params));
+                    const payloadValue = [];
+                    let index = 0;
+                    const length = 0;
+                    payloadValue[index++] = 0;
+                    payloadValue[index++] = 0x04;
+                    payloadValue[index++] = 27;
+                    payloadValue[index++] = 1;
+                    payloadValue[index++] = 0;
+                    payloadValue[index++] = 1;
+                    payloadValue[index++] = maxC & 0xff;
+                    payloadValue[index++] = (maxC >> 8) & 0xff;
+                    payloadValue[index++] = (maxC >> 16) & 0xff;
+                    payloadValue[index++] = (maxC >> 24) & 0xff;
+                    if (enMinC === "ENABLE") {
+                        payloadValue[3] |= 2;
+                        payloadValue[index++] = minC & 0xff;
+                        payloadValue[index++] = (minC >> 8) & 0xff;
+                        payloadValue[index++] = (minC >> 16) & 0xff;
+                        payloadValue[index++] = (minC >> 24) & 0xff;
+                    }
+                    if (enMaxV === "ENABLE") {
+                        payloadValue[4] |= 1;
+                        payloadValue[index++] = maxV & 0xff;
+                        payloadValue[index++] = (maxV >> 8) & 0xff;
+                        payloadValue[index++] = (maxV >> 16) & 0xff;
+                        payloadValue[index++] = (maxV >> 24) & 0xff;
+                    }
+                    if (enMinV === "ENABLE") {
+                        payloadValue[4] |= 2;
+                        payloadValue[index++] = minV & 0xff;
+                        payloadValue[index++] = (minV >> 8) & 0xff;
+                        payloadValue[index++] = (minV >> 16) & 0xff;
+                        payloadValue[index++] = (minV >> 24) & 0xff;
+                    }
+                    payloadValue[index++] = maxP & 0xff;
+                    payloadValue[index++] = (maxP >> 8) & 0xff;
+                    payloadValue[index++] = (maxP >> 16) & 0xff;
+                    payloadValue[index++] = (maxP >> 24) & 0xff;
+                    if (enMinP === "ENABLE") {
+                        payloadValue[5] |= 2;
+                        payloadValue[index++] = minP & 0xff;
+                        payloadValue[index++] = (minP >> 8) & 0xff;
+                        payloadValue[index++] = (minP >> 16) & 0xff;
+                        payloadValue[index++] = (minP >> 24) & 0xff;
+                    }
+                    payloadValue[0] = index - 1;
+                    payloadValue[2] = payloadValue[0] - 2;
+                    if (payloadValue[3] === 3) {
+                        if (minC >= maxC) {
+                            throw new Error("Invalid input: maximum current must be greater than the minimum current ");
+                        }
+                    }
+                    if (payloadValue[4] === 3) {
+                        if (minV >= maxV) {
+                            throw new Error("Invalid input: maximum voltage must be greater than the minimum voltage ");
+                        }
+                    }
+                    if (payloadValue[5] === 3) {
+                        if (minP >= maxP) {
+                            throw new Error("Invalid input: maximum power must be greater than the minimum power ");
+                        }
+                    }
+                    const payload = { [0x7003]: { value: payloadValue, type: 0x42 } };
+                    await entity.write("customClusterEwelink", payload, defaultResponseOptions);
+                    return { state: { [key]: value } };
+                },
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("customClusterEwelink", [0x7003], defaultResponseOptions);
+                },
+            },
+        ];
+        return {
+            exposes: [exposes],
+            toZigbee,
+            fromZigbee,
+            isModernExtend: true,
+        };
+    },
 };
 exports.definitions = [
     {
@@ -1469,18 +1735,96 @@ exports.definitions = [
         },
     },
     {
-        zigbeeModel: ["S60ZBTPF"],
+        zigbeeModel: ["S60ZBTPF", "S60ZBTPG"],
         model: "S60ZBTPF",
         vendor: "SONOFF",
         description: "Zigbee smart plug",
-        extend: [m.onOff(), m.electricityMeter()],
-    },
-    {
-        zigbeeModel: ["S60ZBTPG"],
-        model: "S60ZBTPG",
-        vendor: "SONOFF",
-        description: "Zigbee smart plug",
-        extend: [m.onOff()],
+        whiteLabel: [{ vendor: "SONOFF", model: "S60ZBTPG", fingerprint: [{ modelID: "S60ZBTPG" }] }],
+        extend: [
+            m.onOff({
+                powerOnBehavior: true,
+                skipDuplicateTransaction: true,
+                configureReporting: true,
+            }),
+            // m.electricityMeter({current: {divisor: 100}, voltage: {divisor: 100}, power: {divisor: 1}, energy: {divisor: 1000}}),
+            sonoffExtend.addCustomClusterEwelink(),
+            m.numeric({
+                name: "current",
+                cluster: "customClusterEwelink",
+                attribute: "acCurrentCurrentValue",
+                description: "Current",
+                unit: "A",
+                scale: 1000,
+                access: "STATE_GET",
+            }),
+            m.numeric({
+                name: "voltage",
+                cluster: "customClusterEwelink",
+                attribute: "acCurrentVoltageValue",
+                description: "Voltage",
+                unit: "V",
+                scale: 1000,
+                access: "STATE_GET",
+            }),
+            m.numeric({
+                name: "power",
+                cluster: "customClusterEwelink",
+                attribute: "acCurrentPowerValue",
+                description: "Active power",
+                unit: "W",
+                scale: 1000,
+                access: "STATE_GET",
+            }),
+            m.numeric({
+                name: "energy_yesterday",
+                cluster: "customClusterEwelink",
+                attribute: "energyYesterday",
+                description: "Electricity consumption for the yesterday",
+                unit: "kWh",
+                scale: 1000,
+                access: "STATE_GET",
+            }),
+            m.numeric({
+                name: "energy_today",
+                cluster: "customClusterEwelink",
+                attribute: "energyToday",
+                description: "Electricity consumption for the day",
+                unit: "kWh",
+                scale: 1000,
+                access: "STATE_GET",
+            }),
+            m.numeric({
+                name: "energy_month",
+                cluster: "customClusterEwelink",
+                attribute: "energyMonth",
+                description: "Electricity consumption for the month",
+                unit: "kWh",
+                scale: 1000,
+                access: "STATE_GET",
+            }),
+            sonoffExtend.inchingControlSet(),
+            m.binary({
+                name: "outlet_control_protect",
+                cluster: "customClusterEwelink",
+                attribute: "outlet_control_protect",
+                description: "Outlet overload protection Settings",
+                valueOff: [false, 0],
+                valueOn: [true, 1],
+            }),
+            sonoffExtend.overloadProtection(4000, 17),
+        ],
+        ota: true,
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "customClusterEwelink"]);
+            await reporting.onOff(endpoint, { min: 1, max: 1800, change: 0 });
+            await endpoint.read("customClusterEwelink", ["acCurrentCurrentValue", "acCurrentVoltageValue", "acCurrentPowerValue", 0x7003, "outlet_control_protect"], defaultResponseOptions);
+            await endpoint.configureReporting("customClusterEwelink", [
+                { attribute: "energyMonth", minimumReportInterval: 60, maximumReportInterval: 3600, reportableChange: 50 },
+                { attribute: "energyYesterday", minimumReportInterval: 60, maximumReportInterval: 3600, reportableChange: 50 },
+                { attribute: "energyToday", minimumReportInterval: 60, maximumReportInterval: 3600, reportableChange: 50 },
+            ]);
+        },
     },
     {
         zigbeeModel: ["SWV"],