matterbridge-zigbee2mqtt 2.4.5-dev.1 → 2.4.5-dev.3

package/CHANGELOG.md

@@ -12,7 +12,7 @@ All notable changes to this project will be documented in this file.
 
 ### Fixed
 
-- [endpoint]: Fix thermostat bug.
+- [endpoint]: Fix thermostat bug (thanks https://github.com/robvanoostenrijk).
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="./yellow-button.png" alt="Buy me a coffee" width="120">

package/dist/entity.js

@@ -135,6 +135,12 @@ export class ZigbeeEntity extends EventEmitter {
                         this.updateAttributeIfChanged(this.bridgedDevice, undefined, WindowCovering.Cluster.id, 'targetPositionLiftPercent100ths', position);
                     }
                 }
+                if (key === 'current_heating_setpoint' && 'system_mode' in payload && payload['system_mode'] === 'heat' && isValidNumber(value)) {
+                    this.updateAttributeIfChanged(this.bridgedDevice, undefined, Thermostat.Cluster.id, 'occupiedHeatingSetpoint', value * 100);
+                }
+                if (key === 'current_heating_setpoint' && 'system_mode' in payload && payload['system_mode'] === 'cool' && isValidNumber(value)) {
+                    this.updateAttributeIfChanged(this.bridgedDevice, undefined, Thermostat.Cluster.id, 'occupiedCoolingSetpoint', value * 100);
+                }
                 if (key === 'color_temp' && 'color_mode' in payload && payload['color_mode'] === 'color_temp') {
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds);
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'colorTemperatureMireds', Math.max(147, Math.min(500, typeof value === 'number' ? value : 0)));
@@ -173,12 +179,18 @@ export class ZigbeeEntity extends EventEmitter {
         });
     }
     destroy() {
+        this.removeAllListeners();
         if (this.colorTimeout)
             clearTimeout(this.colorTimeout);
         this.colorTimeout = undefined;
         if (this.thermostatTimeout)
             clearTimeout(this.thermostatTimeout);
         this.thermostatTimeout = undefined;
+        this.device = undefined;
+        this.group = undefined;
+        this.bridgedDevice = undefined;
+        this.mutableDevice.clear();
+        this.propertyMap.clear();
     }
     addBridgedDeviceBasicInformation() {
         if (!this.bridgedDevice)
@@ -431,6 +443,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
         zigbeeGroup.bridgedDevice.addRequiredClusterServers();
         if (!zigbeeGroup.bridgedDevice || !zigbeeGroup.verifyMutableDevice(zigbeeGroup.bridgedDevice))
             return zigbeeGroup;
+        zigbeeGroup.mutableDevice.clear();
         zigbeeGroup.logPropertyMap();
         if (isSwitch || isLight) {
             if (isSwitch && !isLight)
@@ -559,7 +572,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
             zigbeeGroup.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'occupiedCoolingSetpoint', (newValue, oldValue) => {
                 zigbeeGroup.bridgedDevice?.log.info(`Thermostat occupiedCoolingSetpoint changed from ${oldValue / 100} to ${newValue / 100}`);
                 zigbeeGroup.bridgedDevice?.log.info(`Setting thermostat occupiedCoolingSetpoint to ${newValue / 100}`);
-                zigbeeGroup.publishCommand('CurrentCoolingSetpoint', group.friendly_name, { current_cooling_setpoint: Math.round(newValue / 100) });
+                zigbeeGroup.publishCommand('CurrentCoolingSetpoint', group.friendly_name, { current_heating_setpoint: Math.round(newValue / 100) });
                 zigbeeGroup.publishCommand('OccupiedCoolingSetpoint', group.friendly_name, { occupied_cooling_setpoint: Math.round(newValue / 100) });
                 zigbeeGroup.noUpdate = true;
                 zigbeeGroup.thermostatTimeout = setTimeout(() => {
@@ -588,10 +601,11 @@ export const z2ms = [
     { type: 'cover', name: 'position', property: 'position', deviceType: coverDevice, cluster: WindowCovering.Cluster.id, attribute: 'currentPositionLiftPercent100ths' },
     { type: 'lock', name: 'state', property: 'state', deviceType: doorLockDevice, cluster: DoorLock.Cluster.id, attribute: 'lockState', converter: (value) => { return value === 'LOCK' ? DoorLock.LockState.Locked : DoorLock.LockState.Unlocked; } },
     { type: 'climate', name: 'local_temperature', property: 'local_temperature', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'localTemperature', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
-    { type: 'climate', name: 'current_heating_setpoint', property: 'current_heating_setpoint', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'occupiedHeatingSetpoint', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
-    { type: 'climate', name: 'current_cooling_setpoint', property: 'current_cooling_setpoint', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'occupiedCoolingSetpoint', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
+    { type: 'climate', name: 'current_heating_setpoint', property: 'current_heating_setpoint', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'occupiedHeatingSetpoint' },
     { type: 'climate', name: 'occupied_heating_setpoint', property: 'occupied_heating_setpoint', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'occupiedHeatingSetpoint', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
     { type: 'climate', name: 'occupied_cooling_setpoint', property: 'occupied_cooling_setpoint', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'occupiedCoolingSetpoint', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
+    { type: 'climate', name: 'unoccupied_heating_setpoint', property: 'unoccupied_heating_setpoint', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'occupiedHeatingSetpoint', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
+    { type: 'climate', name: 'unoccupied_cooling_setpoint', property: 'unoccupied_cooling_setpoint', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'occupiedCoolingSetpoint', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
     { type: 'climate', name: 'running_state', property: 'running_state', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'thermostatRunningMode', valueLookup: ['idle', '', '', 'cool', 'heat'] },
     { type: 'climate', name: 'system_mode', property: 'system_mode', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'systemMode', valueLookup: ['off', 'auto', '', 'cool', 'heat'] },
     { type: '', name: 'min_temperature_limit', property: 'min_temperature_limit', deviceType: thermostatDevice, cluster: Thermostat.Cluster.id, attribute: 'minHeatSetpointLimit', converter: (value) => { return Math.max(-5000, Math.min(5000, value * 100)); } },
@@ -920,25 +934,28 @@ export class ZigbeeDevice extends ZigbeeEntity {
             }
         }
         if (mainEndpoint.clusterServersIds.includes(Thermostat.Cluster.id)) {
-            const heat = zigbeeDevice.propertyMap.get('occupied_heating_setpoint') || zigbeeDevice.propertyMap.get('current_heating_setpoint');
-            const cool = zigbeeDevice.propertyMap.get('occupied_cooling_setpoint') || zigbeeDevice.propertyMap.get('current_cooling_setpoint');
+            const system_mode = zigbeeDevice.propertyMap.get('system_mode');
+            const system_mode_values = system_mode?.values;
+            const heat = zigbeeDevice.propertyMap.get('occupied_heating_setpoint') || zigbeeDevice.propertyMap.get('unoccupied_heating_setpoint');
+            const cool = zigbeeDevice.propertyMap.get('occupied_cooling_setpoint') || zigbeeDevice.propertyMap.get('unoccupied_cooling_setpoint');
             const minHeating = heat && heat.value_min !== undefined && !isNaN(heat.value_min) ? heat.value_min : 0;
             const maxHeating = heat && heat.value_max !== undefined && !isNaN(heat.value_max) ? heat.value_max : 50;
             const minCooling = cool && cool.value_min !== undefined && !isNaN(cool.value_min) ? cool.value_min : 0;
             const maxCooling = cool && cool.value_max !== undefined && !isNaN(cool.value_max) ? cool.value_max : 50;
-            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} Thermostat cluster with heating ${CYAN}${heat ? 'supported' : 'not supported'}${db} cooling ${CYAN}${cool ? 'supported' : 'not supported'}${db} ` +
+            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} Thermostat cluster with heating ${CYAN}${heat ? 'supported' : '(un)occupied not supported'}${db} cooling ${CYAN}${cool ? 'supported' : '(un)occupied not supported'}${db} ` +
+                `system_mode ${CYAN}${system_mode_values ?? 'not supported'}${db} ` +
                 `minHeating ${CYAN}${minHeating}${db} maxHeating ${CYAN}${maxHeating}${db} minCooling ${CYAN}${minCooling}${db} maxCooling ${CYAN}${maxCooling}${db}`);
-            if (heat && !cool) {
+            if ((heat && !cool) || (!system_mode_values?.includes('auto') && system_mode_values?.includes('heat'))) {
                 zigbeeDevice.propertyMap.delete('running_state');
                 zigbeeDevice.bridgedDevice.createDefaultHeatingThermostatClusterServer(undefined, undefined, minHeating, maxHeating);
                 mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(Thermostat.Cluster.id), 1);
             }
-            else if (!heat && cool) {
+            else if ((!heat && cool) || (!system_mode_values?.includes('auto') && system_mode_values?.includes('cool'))) {
                 zigbeeDevice.propertyMap.delete('running_state');
                 zigbeeDevice.bridgedDevice.createDefaultCoolingThermostatClusterServer(undefined, undefined, minCooling, maxCooling);
                 mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(Thermostat.Cluster.id), 1);
             }
-            else if (heat && cool) {
+            else {
                 zigbeeDevice.bridgedDevice.createDefaultThermostatClusterServer(undefined, undefined, undefined, undefined, minHeating, maxHeating, minCooling, maxCooling);
                 mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(Thermostat.Cluster.id), 1);
             }
@@ -1169,23 +1186,19 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     const setpoint = Math.round(t / 100 + request.amount / 10);
                     if (zigbeeDevice.propertyMap.has('current_heating_setpoint')) {
                         zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
-                        zigbeeDevice.log.debug('Command setpointRaiseLower sent:', debugStringify({ current_heating_setpoint: setpoint }));
                     }
                     else if (zigbeeDevice.propertyMap.has('occupied_heating_setpoint')) {
                         zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { occupied_heating_setpoint: setpoint });
-                        zigbeeDevice.log.debug('Command setpointRaiseLower sent:', debugStringify({ occupied_heating_setpoint: setpoint }));
                     }
                 }
                 if (request.mode === Thermostat.SetpointRaiseLowerMode.Cool || request.mode === Thermostat.SetpointRaiseLowerMode.Both) {
                     const t = zigbeeDevice.bridgedDevice?.getAttribute(ThermostatCluster.id, 'occupiedCoolingSetpoint', zigbeeDevice.log);
                     const setpoint = Math.round(t / 100 + request.amount / 10);
-                    if (zigbeeDevice.propertyMap.has('current_cooling_setpoint')) {
-                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_cooling_setpoint: setpoint });
-                        zigbeeDevice.log.debug('Command setpointRaiseLower sent:', debugStringify({ current_cooling_setpoint: setpoint }));
+                    if (zigbeeDevice.propertyMap.has('current_heating_setpoint')) {
+                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
                     }
                     else if (zigbeeDevice.propertyMap.has('occupied_cooling_setpoint')) {
                         zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { occupied_cooling_setpoint: setpoint });
-                        zigbeeDevice.log.debug('Command setpointRaiseLower sent:', debugStringify({ occupied_cooling_setpoint: setpoint }));
                     }
                 }
             });
@@ -1213,8 +1226,8 @@ export class ZigbeeDevice extends ZigbeeEntity {
             if (zigbeeDevice.bridgedDevice.hasAttributeServer(ThermostatCluster.id, 'occupiedCoolingSetpoint'))
                 zigbeeDevice.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'occupiedCoolingSetpoint', async (value) => {
                     zigbeeDevice.log.debug(`Subscribe occupiedCoolingSetpoint called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} with:`, value);
-                    if (zigbeeDevice.propertyMap.has('current_cooling_setpoint'))
-                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_cooling_setpoint: Math.round(value / 100) });
+                    if (zigbeeDevice.propertyMap.has('current_heating_setpoint'))
+                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_heating_setpoint: Math.round(value / 100) });
                     else if (zigbeeDevice.propertyMap.has('occupied_cooling_setpoint'))
                         zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { occupied_cooling_setpoint: Math.round(value / 100) });
                     zigbeeDevice.noUpdate = true;

package/dist/platform.js

@@ -223,7 +223,7 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         this.z2m.on('device_interview', async (friendly_name, ieee_address, status, supported) => {
             this.log.info(`zigbee2MQTT sent device_interview device: ${friendly_name} ieee_address: ${ieee_address} status: ${status} supported: ${supported}`);
             if (status === 'successful' && supported) {
-                if (!this.validateDeviceWhiteBlackList(friendly_name))
+                if (!this.validateDevice(friendly_name))
                     return;
                 this.log.info(`Registering device: ${friendly_name}`);
                 const bridgedDevice = this.z2mBridgeDevices?.find((device) => device.friendly_name === friendly_name);
@@ -243,7 +243,7 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         });
         this.z2m.on('group_add', async (friendly_name, id, status) => {
             this.log.info(`zigbee2MQTT sent group_add friendly_name: ${friendly_name} id ${id} status ${status}`);
-            if (!this.validateDeviceWhiteBlackList(friendly_name))
+            if (!this.validateDevice(friendly_name))
                 return;
             this.log.info(`Registering group: ${friendly_name}`);
             const bridgedGroup = this.z2mBridgeGroups?.find((group) => group.friendly_name === friendly_name);
@@ -479,6 +479,7 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         if (entity) {
             this.log.info(`Removing device: ${friendly_name}`);
             await this.unregisterDevice(entity.bridgedDevice);
+            entity.destroy();
             this.zigbeeEntities = this.zigbeeEntities.filter((entity) => entity.entityName !== friendly_name);
             this.bridgedDevices = this.bridgedDevices.filter((device) => device.deviceName !== friendly_name);
         }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.4.5-dev.1",
+  "version": "2.4.5-dev.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-zigbee2mqtt",
-      "version": "2.4.5-dev.1",
+      "version": "2.4.5-dev.3",
       "license": "Apache-2.0",
       "dependencies": {
         "moment": "2.30.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.4.5-dev.1",
+  "version": "2.4.5-dev.3",
   "description": "Matterbridge zigbee2mqtt plugin",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",