zigbee-herdsman-converters 25.10.0 → 25.11.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [25.11.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v25.10.0...v25.11.0) (2025-08-28)
+
+
+### Features
+
+* **add:** AE 287 C ([#9864](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9864)) ([5f927fd](https://github.com/Koenkk/zigbee-herdsman-converters/commit/5f927fd292fbba0953c5a637002d7ffe952489bb))
+* **add:** Drivent ([#9874](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9874)) ([c8dcb6f](https://github.com/Koenkk/zigbee-herdsman-converters/commit/c8dcb6f2bedef654698bd2840beaaf79005d596d))
+* **add:** m5NanoC6 ([#9866](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9866)) ([95ca5db](https://github.com/Koenkk/zigbee-herdsman-converters/commit/95ca5db499581c2687ec830e1f98fa5a2ae3e055))
+* Bosch `BSP-FZ2` (Plug compact II): Support reset of energy meter and lower min value change on electricityMeter reporting ([#9865](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9865)) ([0615f2d](https://github.com/Koenkk/zigbee-herdsman-converters/commit/0615f2d6999ab011ef22b7ee9414ae1181b6df24))
+* Onokom: various improvements ([#9869](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9869)) ([15acfc4](https://github.com/Koenkk/zigbee-herdsman-converters/commit/15acfc4f8e148e5b09546541608e2c1822ee8ec4))
+
+
+### Bug Fixes
+
+* Create inovelliMMWave modern extend to relocate mmWave commands and support future expansion ([#9870](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9870)) ([a88b08c](https://github.com/Koenkk/zigbee-herdsman-converters/commit/a88b08ca0093d38d9bffeeecd9ad55b5cfbc793f))
+* **detect:** Detect `_TZ3000_fawk5xjv` and `_TZ3000_ok0ggpk7` as a Detect _TZ3000_fawk5xjv and _TZ3000_ok0ggpk7 as a TS0003_switch_3_gang_with_backlight ([#9861](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9861)) ([1b539d2](https://github.com/Koenkk/zigbee-herdsman-converters/commit/1b539d2a9309432fcaf34236feddc523e56027a0))
+* **detect:** Detect `_TZE200_jfw0a4aa` as ZG-102ZM and `_TZE200_hdih4foa` as ZG-204ZH ([#9872](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9872)) ([8437961](https://github.com/Koenkk/zigbee-herdsman-converters/commit/8437961b762ce769cd10fadd0dd2a731aac2a5ed))
+* **detect:** Detect `_TZE284_1lvln0x6` as iHsenso_TS0601_human_presence https://github.com/Koenkk/zigbee2mqtt/issues/28398 ([b60f84f](https://github.com/Koenkk/zigbee-herdsman-converters/commit/b60f84fd14036c12a380f6f04e2b91681c2d5ec0))
+* **detect:** Detect `lumi.light.agl002` as Aqara T2_E26 https://github.com/Koenkk/zigbee2mqtt/issues/26182 ([e221d02](https://github.com/Koenkk/zigbee-herdsman-converters/commit/e221d023ec8d188c4f25ba3b19bdd87c0154b3a0))
+* **ignore:** Bosch `BMCT-SLZ` (Light/shutter control unit II): Only expose attributes compatible with the selected switch type ([#9862](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9862)) ([7eecc4e](https://github.com/Koenkk/zigbee-herdsman-converters/commit/7eecc4e751812a27ce65f38565199dcd63cac809))
+
 ## [25.10.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v25.9.0...v25.10.0) (2025-08-27)
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"bosch.d.ts","sourceRoot":"","sources":["../../src/devices/bosch.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,oBAAoB,EAAyC,MAAM,cAAc,CAAC;AAk3C/F,eAAO,MAAM,WAAW,EAAE,oBAAoB,EAwoC7C,CAAC"}
+{"version":3,"file":"bosch.d.ts","sourceRoot":"","sources":["../../src/devices/bosch.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,oBAAoB,EAA6C,MAAM,cAAc,CAAC;AA44CnG,eAAO,MAAM,WAAW,EAAE,oBAAoB,EAmsC7C,CAAC"}

package/dist/devices/bosch.js

@@ -891,7 +891,12 @@ const boschExtend = {
                         }
                     }
                     if (data.switchType !== undefined) {
-                        result.switch_type = Object.keys(stateSwitchType).find((key) => stateSwitchType[key] === msg.data.switchType);
+                        const switchType = msg.data.switchType;
+                        result.switch_type = Object.keys(stateSwitchType).find((key) => stateSwitchType[key] === switchType);
+                        if (switchType !== meta.device.meta.switchType) {
+                            meta.device.meta.switchType = switchType;
+                            meta.deviceExposesChanged();
+                        }
                     }
                     if (data.switchMode !== undefined) {
                         const property = utils.postfixWithEndpointName("switch_mode", msg, model, meta);
@@ -964,8 +969,23 @@ const boschExtend = {
                         return { state: { device_mode: value } };
                     }
                     if (key === "switch_type") {
-                        const index = utils.getFromLookup(value, stateSwitchType);
-                        await entity.write("boschSpecific", { switchType: index });
+                        const applyDefaultForSwitchModeAndChildLock = async (endpoint) => {
+                            const switchModeDefault = utils.getFromLookup("coupled", stateSwitchMode);
+                            const childLockDefault = utils.getFromLookup("OFF", stateOffOn);
+                            await endpoint.write("boschSpecific", {
+                                switchMode: switchModeDefault,
+                                childLock: childLockDefault,
+                            });
+                            await endpoint.read("boschSpecific", ["switchMode", "childLock"]);
+                        };
+                        const switchType = utils.getFromLookup(value, stateSwitchType);
+                        await entity.write("boschSpecific", { switchType: switchType });
+                        await entity.read("boschSpecific", ["switchType"]);
+                        await applyDefaultForSwitchModeAndChildLock(entity);
+                        const leftEndpoint = meta.device.getEndpoint(2);
+                        await applyDefaultForSwitchModeAndChildLock(leftEndpoint);
+                        const rightEndpoint = meta.device.getEndpoint(3);
+                        await applyDefaultForSwitchModeAndChildLock(rightEndpoint);
                         return { state: { switch_type: value } };
                     }
                     if (key === "switch_mode") {
@@ -1878,7 +1898,17 @@ exports.definitions = [
         model: "BSP-FZ2",
         vendor: "Bosch",
         description: "Plug compact EU",
-        extend: [m.onOff(), m.electricityMeter({ voltage: false, current: false })],
+        extend: [
+            m.onOff(),
+            m.electricityMeter({
+                voltage: false,
+                current: false,
+                power: { change: 1 },
+                energy: { change: 1 },
+            }),
+            boschExtend.seMeteringCluster(),
+            boschExtend.resetEnergyReading(),
+        ],
         ota: true,
         whiteLabel: [
             { vendor: "Bosch", model: "BSP-EZ2", description: "Plug compact FR", fingerprint: [{ modelID: "RBSH-SP-ZB-FR" }] },
@@ -2100,106 +2130,119 @@ exports.definitions = [
                 only_short_press_decoupled: 0x02,
                 only_long_press_decoupled: 0x03,
             };
-            const commonExposes = [
-                e.enum("switch_type", ea.ALL, Object.keys(stateSwitchType)).withDescription("Module controlled by a rocker switch or a button"),
-                e.action([
-                    "press_released_left",
-                    "press_released_right",
-                    "hold_left",
-                    "hold_right",
-                    "hold_released_left",
-                    "hold_released_right",
-                    "opened_left",
-                    "opened_right",
-                    "closed_left",
-                    "closed_right",
-                ]),
-                e.action_duration(),
-            ];
-            const lightExposes = [
-                e.switch().withEndpoint("left"),
-                e.switch().withEndpoint("right"),
-                e.power_on_behavior().withEndpoint("left"),
-                e.power_on_behavior().withEndpoint("right"),
-                e
-                    .enum("switch_mode", ea.ALL, Object.keys(stateSwitchMode))
-                    .withEndpoint("left")
-                    .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that not all options may work depending on your switch type."),
-                e
-                    .enum("switch_mode", ea.ALL, Object.keys(stateSwitchMode))
-                    .withEndpoint("right")
-                    .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that not all options may work depending on your switch type."),
-                e
-                    .binary("auto_off_enabled", ea.ALL, "ON", "OFF")
-                    .withEndpoint("left")
-                    .withDescription("Enable/Disable the automatic turn-off feature"),
-                e
+            const commonExposes = (switchType) => {
+                const exposeList = [];
+                exposeList.push(e.enum("switch_type", ea.ALL, Object.keys(stateSwitchType)).withDescription("Module controlled by a rocker switch or a button"));
+                if (switchType !== "none") {
+                    let supportedActionTypes;
+                    switch (switchType) {
+                        case "button":
+                        case "button_key_change":
+                            supportedActionTypes = [
+                                "press_released_left",
+                                "press_released_right",
+                                "hold_left",
+                                "hold_right",
+                                "hold_released_left",
+                                "hold_released_right",
+                            ];
+                            break;
+                        case "rocker_switch":
+                        case "rocker_switch_key_change":
+                            supportedActionTypes = ["opened_left", "opened_right", "closed_left", "closed_right"];
+                            break;
+                    }
+                    exposeList.push(e.action(supportedActionTypes), e.action_duration());
+                }
+                return exposeList;
+            };
+            const lightExposes = (endpoint, switchType) => {
+                const exposeList = [];
+                exposeList.push(e.switch().withEndpoint(endpoint), e.power_on_behavior().withEndpoint(endpoint), e
                     .binary("auto_off_enabled", ea.ALL, "ON", "OFF")
-                    .withEndpoint("right")
-                    .withDescription("Enable/Disable the automatic turn-off feature"),
-                e
+                    .withEndpoint(endpoint)
+                    .withDescription("Enable/Disable the automatic turn-off feature"), e
                     .numeric("auto_off_time", ea.ALL)
                     .withValueMin(0)
                     .withValueMax(720)
                     .withValueStep(1)
                     .withUnit("min")
                     .withDescription("Turn off the output after the specified amount of time. Only in action when the automatic turn-off is enabled.")
-                    .withEndpoint("left"),
-                e
-                    .numeric("auto_off_time", ea.ALL)
-                    .withValueMin(0)
-                    .withValueMax(720)
-                    .withValueStep(1)
-                    .withUnit("min")
-                    .withDescription("Turn off the output after the specified amount of time. Only in action when the automatic turn-off is enabled.")
-                    .withEndpoint("right"),
-                e.binary("child_lock", ea.ALL, "ON", "OFF").withEndpoint("left").withDescription("Enable/Disable child lock"),
-                e.binary("child_lock", ea.ALL, "ON", "OFF").withEndpoint("right").withDescription("Enable/Disable child lock"),
-            ];
-            const coverExposes = [
-                e.cover_position(),
-                e.enum("motor_state", ea.STATE, Object.keys(stateMotor)).withDescription("Current shutter motor state"),
-                e.binary("child_lock", ea.ALL, "ON", "OFF").withDescription("Enable/Disable child lock"),
-                e
-                    .enum("switch_mode", ea.ALL, Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled" || switchMode === "only_long_press_decoupled"))
-                    .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that not all options may work depending on your switch type."),
-                e
+                    .withEndpoint(endpoint));
+                if (switchType !== "none") {
+                    let supportedSwitchModes;
+                    switch (switchType) {
+                        case "button":
+                        case "button_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode);
+                            break;
+                        case "rocker_switch":
+                        case "rocker_switch_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled" || switchMode === "decoupled");
+                            break;
+                    }
+                    exposeList.push(e
+                        .enum("switch_mode", ea.ALL, supportedSwitchModes)
+                        .withEndpoint(endpoint)
+                        .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that the available options depend on the used switch type."), e.binary("child_lock", ea.ALL, "ON", "OFF").withEndpoint(endpoint).withDescription("Enable/Disable child lock"));
+                }
+                return exposeList;
+            };
+            const coverExposes = (switchType) => {
+                const exposeList = [];
+                exposeList.push(e.cover_position(), e.enum("motor_state", ea.STATE, Object.keys(stateMotor)).withDescription("Current shutter motor state"), e
                     .numeric("calibration_closing_time", ea.ALL)
                     .withUnit("s")
                     .withDescription("Calibrate shutter closing time")
                     .withValueMin(1)
                     .withValueMax(90)
-                    .withValueStep(0.1),
-                e
+                    .withValueStep(0.1), e
                     .numeric("calibration_opening_time", ea.ALL)
                     .withUnit("s")
                     .withDescription("Calibrate shutter opening time")
                     .withValueMin(1)
                     .withValueMax(90)
-                    .withValueStep(0.1),
-                e
+                    .withValueStep(0.1), e
                     .numeric("calibration_button_hold_time", ea.ALL)
                     .withUnit("s")
                     .withDescription("Time to hold for long press")
                     .withValueMin(0.1)
                     .withValueMax(2)
-                    .withValueStep(0.1),
-                e
+                    .withValueStep(0.1), e
                     .numeric("calibration_motor_start_delay", ea.ALL)
                     .withUnit("s")
                     .withDescription("Delay between command and motor start")
                     .withValueMin(0)
                     .withValueMax(20)
-                    .withValueStep(0.1),
-            ];
+                    .withValueStep(0.1));
+                if (switchType !== "none") {
+                    let supportedSwitchModes;
+                    switch (switchType) {
+                        case "button":
+                        case "button_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled" || switchMode === "only_long_press_decoupled");
+                            break;
+                        case "rocker_switch":
+                        case "rocker_switch_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled");
+                            break;
+                    }
+                    exposeList.push(e
+                        .enum("switch_mode", ea.ALL, supportedSwitchModes)
+                        .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that the available options depend on the used switch type."), e.binary("child_lock", ea.ALL, "ON", "OFF").withDescription("Enable/Disable child lock"));
+                }
+                return exposeList;
+            };
             if (!utils.isDummyDevice(device)) {
                 const deviceModeKey = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "deviceMode");
                 const deviceMode = Object.keys(stateDeviceMode).find((key) => stateDeviceMode[key] === deviceModeKey);
+                const switchTypeKey = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "switchType");
+                const switchType = Object.keys(stateSwitchType).find((key) => stateSwitchType[key] === switchTypeKey);
                 if (deviceMode === "light") {
-                    return [...commonExposes, ...lightExposes];
+                    return [...commonExposes(switchType), ...lightExposes("left", switchType), ...lightExposes("right", switchType)];
                 }
                 if (deviceMode === "shutter") {
-                    return [...commonExposes, ...coverExposes];
+                    return [...commonExposes(switchType), ...coverExposes(switchType)];
                 }
             }
             return [e.enum("device_mode", ea.ALL, Object.keys(stateDeviceMode)).withDescription("Device mode")];