1.11.0

Gledopto GL-C-007S

Add support for Gledopto GL-C-007S
Zigbee LED controller RGBW plus model

azure-pipelines.yaml

@@ -16,7 +16,7 @@ steps:
   inputs:
     versionSpec: '10.x'
   displayName: 'Install Node.js'
-- bash: npm install
+- bash: npm ci
   displayName: 'Install dependencies'
 
 # Verify
@@ -30,7 +30,7 @@ steps:
   displayName: Docker install
   condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'))
   inputs:
-    dockerVersion: 19.03.2
+    dockerVersion: 19.03.5
     releaseType: stable
 - task: Docker@2
   displayName: Docker registry login
@@ -41,7 +41,7 @@ steps:
 - bash: |
     sudo wget -O /usr/local/bin/buildx https://github.com/docker/buildx/releases/download/v0.3.1/buildx-v0.3.1.linux-amd64
     sudo chmod a+x /usr/local/bin/buildx
-    docker run --rm --privileged hypriot/qemu-register
+    docker run --rm --privileged hypriot/qemu-register:v2.7.0
     buildx create --use
     buildx ls
   displayName: 'Docker setup'

docker/Dockerfile

@@ -1,21 +1,30 @@
-FROM node:10-alpine
+FROM node:12-alpine as base
 
-# Copy files
-ADD . /app
-RUN cp /app/data/configuration.yaml /app
-RUN cp /app/docker/run.sh /app
-RUN chmod +x /app/run.sh
 WORKDIR /app
+RUN apk add --no-cache tzdata eudev
+
+COPY package.json .
+
+# Dependencies
+FROM base as dependencies
+
+COPY npm-shrinkwrap.json .
+
+RUN apk add --no-cache --virtual .buildtools make gcc g++ python linux-headers git && \
+    npm ci --production && \
+    apk del .buildtools
+
+# Release
+FROM base as release
+
+COPY --from=dependencies /app/node_modules ./node_modules
+COPY lib ./lib
+COPY index.js docker/run.sh data/configuration.yaml ./
+
+RUN chmod +x /app/run.sh
+RUN mkdir /app/data
 
-# Write .hash.json
 ARG COMMIT
 RUN echo "{\"hash\": \"$COMMIT\"}" > .hash.json
 
-# Install dependencies
-RUN apk add --update --no-cache tzdata udev eudev && \
-    apk add --update --no-cache --virtual .buildtools make gcc g++ python linux-headers udev git && \
-    npm install --unsafe-perm --production && \
-    apk del .buildtools
-
-# Entrypoint
 ENTRYPOINT ["./run.sh"]

lib/controller.js

@@ -1,5 +1,6 @@
 const MQTT = require('./mqtt');
 const Zigbee = require('./zigbee');
+const EventBus = require('./eventBus');
 const State = require('./state');
 const logger = require('./util/logger');
 const settings = require('./util/settings');
@@ -20,11 +21,13 @@ const ExtensionDeviceAvailability = require('./extension/deviceAvailability');
 const ExtensionDeviceBind = require('./extension/deviceBind');
 const ExtensionDeviceReport = require('./extension/deviceReport');
 const ExtensionDeviceEvent = require('./extension/deviceEvent');
+const ExtensionOTAUpdate = require('./extension/otaUpdate');
 
 class Controller {
     constructor() {
         this.zigbee = new Zigbee();
         this.mqtt = new MQTT();
+        this.eventBus = new EventBus();
         this.state = new State();
 
         this.publishEntityState = this.publishEntityState.bind(this);
@@ -32,39 +35,42 @@ class Controller {
 
         // Initialize extensions.
         this.extensions = [
-            new ExtensionEntityPublish(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionDeviceReceive(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionDeviceGroupMembership(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionDeviceConfigure(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionNetworkMap(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionBridgeConfig(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionGroups(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionDeviceBind(this.zigbee, this.mqtt, this.state, this.publishEntityState),
-            new ExtensionDeviceEvent(this.zigbee, this.mqtt, this.state, this.publishEntityState),
+            new ExtensionEntityPublish(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionDeviceReceive(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionDeviceGroupMembership(
+                this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus,
+            ),
+            new ExtensionDeviceConfigure(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionNetworkMap(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionBridgeConfig(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionGroups(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionDeviceBind(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionDeviceEvent(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
+            new ExtensionOTAUpdate(this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus),
         ];
 
         if (settings.get().advanced.report) {
             this.extensions.push(new ExtensionDeviceReport(
-                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+                this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus,
             ));
         }
 
         if (settings.get().homeassistant) {
             this.extensions.push(new ExtensionHomeAssistant(
-                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+                this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus,
             ));
         }
 
         /* istanbul ignore next */
         if (settings.get().advanced.soft_reset_timeout !== 0) {
             this.extensions.push(new ExtensionSoftReset(
-                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+                this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus,
             ));
         }
 
         if (settings.get().advanced.availability_timeout) {
             this.extensions.push(new ExtensionDeviceAvailability(
-                this.zigbee, this.mqtt, this.state, this.publishEntityState,
+                this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus,
             ));
         }
     }
@@ -89,9 +95,10 @@ class Controller {
 
         // Start zigbee
         try {
+            await this.zigbee.start();
+            this.callExtensionMethod('onZigbeeStarted', []);
             this.zigbee.on('event', this.onZigbeeEvent.bind(this));
             this.zigbee.on('adapterDisconnected', this.onZigbeeAdapterDisconnected);
-            await this.zigbee.start();
         } catch (error) {
             logger.error('Failed to start zigbee');
             logger.error('Exiting...');
@@ -121,10 +128,7 @@ class Controller {
             logger.warn('Set `permit_join` to `false` once you joined all devices.');
         }
 
-        this.zigbee.permitJoin(settings.get().permit_join);
-
-        // Call extensions
-        this.callExtensionMethod('onZigbeeStarted', []);
+        await this.zigbee.permitJoin(settings.get().permit_join);
 
         // MQTT
         this.mqtt.on('message', this.onMQTTMessage.bind(this));
@@ -281,7 +285,10 @@ class Controller {
         }
 
         if (Object.entries(messagePayload).length) {
-            if (settings.get().experimental.output === 'json') {
+            if (settings.get().experimental.output === 'attribute_and_json') {
+                await this.mqtt.publish(entity.name, JSON.stringify(messagePayload), options);
+                await this.iteratePayloadAttributeOutput(`${entity.name}/`, messagePayload, options);
+            } else if (settings.get().experimental.output === 'json') {
                 await this.mqtt.publish(entity.name, JSON.stringify(messagePayload), options);
             } else {
                 /* istanbul ignore else */

lib/eventBus.js

@@ -0,0 +1,20 @@
+const events = require('events');
+const assert = require('assert');
+
+const allowedEvents = [
+    'deviceRemoved', // Device has been removed
+];
+
+class EventBus extends events.EventEmitter {
+    emit(event, data) {
+        assert(allowedEvents.includes(event), `Event '${event}' not supported`);
+        super.emit(event, data);
+    }
+
+    on(event, callback) {
+        assert(allowedEvents.includes(event), `Event '${event}' not supported`);
+        super.on(event, callback);
+    }
+}
+
+module.exports = EventBus;

lib/extension/baseExtension.js

@@ -6,12 +6,14 @@ class BaseExtension {
      * @param {MQTT} mqtt MQTT controller
      * @param {State} state State controller
      * @param {Function} publishEntityState Method to publish device state to MQTT.
+     * @param {EventBus} eventBus The event bus
      */
-    constructor(zigbee, mqtt, state, publishEntityState) {
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
         this.zigbee = zigbee;
         this.mqtt = mqtt;
         this.state = state;
         this.publishEntityState = publishEntityState;
+        this.eventBus = eventBus;
     }
 
     /**

lib/extension/bridgeConfig.js

@@ -10,8 +10,8 @@ const configRegex =
 const allowedLogLevels = ['error', 'warn', 'info', 'debug'];
 
 class BridgeConfig extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
 
         // Bind functions
         this.permitJoin = this.permitJoin.bind(this);
@@ -215,9 +215,10 @@ class BridgeConfig extends BaseExtension {
 
     _renameInternal(from, to) {
         try {
+            const isGroup = settings.getGroup(from) !== null;
             settings.changeFriendlyName(from, to);
             logger.info(`Successfully renamed - ${from} to ${to} `);
-            this.mqtt.log('device_renamed', {from, to});
+            this.mqtt.log(`${isGroup ? 'group' : 'device'}_renamed`, {from, to});
         } catch (error) {
             logger.error(`Failed to rename - ${from} to ${to}`);
         }
@@ -253,7 +254,10 @@ class BridgeConfig extends BaseExtension {
 
     removeGroup(topic, message) {
         const name = message;
-        settings.removeGroup(name);
+        const entity = this.zigbee.resolveEntity(message);
+        assert(entity && entity.type === 'group', `Group '${message}' does not exist`);
+        settings.removeGroup(message);
+        entity.group.removeFromDatabase();
         logger.info(`Removed group '${name}'`);
     }
 
@@ -279,10 +283,15 @@ class BridgeConfig extends BaseExtension {
 
         if (!entity) {
             logger.error(`Cannot ${lookup[action][2]}, device '${message}' does not exist`);
+
+            this.mqtt.log(`device_${lookup[action][0]}_failed`, message);
             return;
         }
 
         const cleanup = () => {
+            // Fire event
+            this.eventBus.emit('deviceRemoved', {device: entity.device});
+
             // Remove from configuration.yaml
             settings.removeDevice(entity.settings.ID);
 
@@ -306,6 +315,8 @@ class BridgeConfig extends BaseExtension {
             logger.error(`Failed to ${lookup[action][2]} ${entity.settings.friendlyName} (${error})`);
             // eslint-disable-next-line
             logger.error(`See https://www.zigbee2mqtt.io/information/mqtt_topics_and_message_structure.html#zigbee2mqttbridgeconfigremove for more info`);
+
+            this.mqtt.log(`device_${lookup[action][0]}_failed`, message);
         }
 
         if (action === 'ban') {
@@ -361,7 +372,7 @@ class BridgeConfig extends BaseExtension {
         const result = await this.zigbee.touchlinkFactoryReset();
 
         if (result) {
-            logger.info('Succesfully factory reset device through Touchlink');
+            logger.info('Successfully factory reset device through Touchlink');
         } else {
             logger.warn('Failed to factory reset device through Touchlink');
         }

lib/extension/deviceAvailability.js

@@ -6,10 +6,14 @@ const BaseExtension = require('./baseExtension');
 
 // Some EndDevices should be pinged
 // e.g. E11-G13 https://github.com/Koenkk/zigbee2mqtt/issues/775#issuecomment-453683846
-const forcedPingable = [
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === 'E11-G13'),
+const pingableModels = [
+    'E11-G13',
+    '53170161',
 ];
 
+const forcedPingable =
+    zigbeeHerdsmanConverters.devices.filter((d) => pingableModels.includes(d.model));
+
 const toZigbeeCandidates = ['state', 'brightness', 'color', 'color_temp'];
 
 const Hours25 = 1000 * 60 * 60 * 25;
@@ -18,8 +22,8 @@ const Hours25 = 1000 * 60 * 60 * 25;
  * This extensions pings devices to check if they are online.
  */
 class DeviceAvailability extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
 
         this.availability_timeout = settings.get().advanced.availability_timeout;
         this.timers = {};
@@ -37,13 +41,18 @@ class DeviceAvailability extends BaseExtension {
     }
 
     isAllowed(device) {
+        const ieeeAddr = device.ieeeAddr;
+
+        const deviceSettings = settings.getDevice(ieeeAddr);
+        const name = deviceSettings ? deviceSettings.friendly_name : null;
+
         // Whitelist is not empty and device is in it, enable availability
         if (this.whitelist.length > 0) {
-            return this.whitelist.includes(device.ieeeAddr);
+            return this.whitelist.includes(ieeeAddr) || (name && this.whitelist.includes(name));
         }
 
         // Device is on blacklist, disable availability
-        if (this.blacklist.includes(device.ieeeAddr)) {
+        if (this.blacklist.includes(ieeeAddr) || (name && this.blacklist.includes(name))) {
             return false;
         }
 

lib/extension/deviceBind.js

@@ -6,6 +6,9 @@ const BaseExtension = require('./baseExtension');
 
 const clusters = ['genScenes', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl', 'closuresWindowCovering'];
 
+// See zigbee-herdsman-converters devices.js
+const defaultBindGroup = {type: 'group_number', ID: 901};
+
 class DeviceBind extends BaseExtension {
     onMQTTConnected() {
         for (let step = 1; step < 20; step++) {
@@ -28,22 +31,26 @@ class DeviceBind extends BaseExtension {
         // Find source; can only be a device and target
         const source = this.zigbee.resolveEntity(sourceKey);
         assert(source != null && source.type === 'device', 'Source undefined or not a device');
-        const target = this.zigbee.resolveEntity(targetKey);
+        const target = targetKey === 'default_bind_group' ? defaultBindGroup : this.zigbee.resolveEntity(targetKey);
         assert(target != null, 'Target is unknown');
 
         const sourceName = source.settings.friendlyName;
-        const targetName = target.settings.friendlyName;
+        const targetName = targetKey === 'default_bind_group' ? targetKey : target.settings.friendlyName;
 
         // Find which clusters are supported by both the source and target.
         // Groups are assumed to support all clusters.
         for (const cluster of clusters) {
-            const targetValid = target.type === 'group' ||
+            const targetValid = target.type === 'group' || target.type === 'group_number' ||
                 target.device.type === 'Coordinator' || target.endpoint.supportsInputCluster(cluster);
 
             if (source.endpoint.supportsOutputCluster(cluster) && targetValid) {
                 logger.debug(`${type}ing cluster '${cluster}' from '${sourceName}' to '${targetName}'`);
                 try {
-                    const bindTarget = target.type === 'group' ? target.group : target.endpoint;
+                    let bindTarget = null;
+                    if (target.type === 'group') bindTarget = target.group;
+                    else if (target.type === 'group_number') bindTarget = target.ID;
+                    else bindTarget = target.endpoint;
+
                     if (type === 'bind') {
                         await source.endpoint.bind(cluster, bindTarget);
                     } else {
@@ -63,6 +70,10 @@ class DeviceBind extends BaseExtension {
                         `Failed to ${type} cluster '${cluster}' from '${sourceName}' to ` +
                         `'${targetName}' (${error})`,
                     );
+                    this.mqtt.log(
+                        `device_${type}_failed`,
+                        {from: sourceName, to: targetName, cluster},
+                    );
                 }
             }
         }

lib/extension/deviceConfigure.js

@@ -4,8 +4,8 @@ const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const BaseExtension = require('./baseExtension');
 
 class DeviceConfigure extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
 
         this.configuring = new Set();
         this.attempts = {};
@@ -13,15 +13,13 @@ class DeviceConfigure extends BaseExtension {
     }
 
     shouldConfigure(device, mappedDevice) {
-        if (!device) {
+        if (!device || !mappedDevice || !mappedDevice.configure) {
             return false;
         }
 
-        if (device.meta.hasOwnProperty('configured') && device.meta.configured === mappedDevice.meta.configureKey) {
-            return false;
-        }
-
-        if (!mappedDevice || !mappedDevice.configure) {
+        if (device.meta &&
+            device.meta.hasOwnProperty('configured') &&
+            device.meta.configured === mappedDevice.meta.configureKey) {
             return false;
         }
 
@@ -42,12 +40,17 @@ class DeviceConfigure extends BaseExtension {
         }
 
         const entity = this.zigbee.resolveEntity(message);
-        if (!entity || !entity.type === 'device') {
+        if (!entity || entity.type !== 'device') {
             logger.error(`Device '${message}' does not exist`);
             return;
         }
 
         const mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(entity.device.modelID);
+        if (!mappedDevice.configure) {
+            logger.warn(`Skipping configure of '${entity.name}', device does not require this.`);
+            return;
+        }
+
         this.configure(entity.device, mappedDevice, entity.settings, true);
     }
 
@@ -90,7 +93,7 @@ class DeviceConfigure extends BaseExtension {
         logger.info(`Configuring '${settingsDevice.friendlyName}'`);
         try {
             await mappedDevice.configure(device, this.coordinatorEndpoint);
-            logger.info(`Succesfully configured '${settingsDevice.friendlyName}'`);
+            logger.info(`Successfully configured '${settingsDevice.friendlyName}'`);
             // eslint-disable-next-line
             device.meta.configured = mappedDevice.meta.configureKey;
             device.save();

lib/extension/deviceEvent.js

@@ -21,6 +21,8 @@ class DeviceEvent extends BaseExtension {
     }
 
     callOnEvent(device, type, data, mappedDevice) {
+        zigbeeHerdsmanConverters.onEvent(type, data, device);
+
         if (!mappedDevice) {
             mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
         }

lib/extension/deviceGroupMembership.js

@@ -7,7 +7,10 @@ const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/device/
 
 class DeviceGroupMembership extends BaseExtension {
     onMQTTConnected() {
-        this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/device/+/get_group_membership`);
+        for (let step = 1; step < 20; step++) {
+            const topic = `${settings.get().mqtt.base_topic}/bridge/device/${'+/'.repeat(step)}get_group_membership`;
+            this.mqtt.subscribe(topic);
+        }
     }
 
     async onMQTTMessage(topic, message) {

lib/extension/deviceReceive.js

@@ -5,8 +5,8 @@ const debounce = require('debounce');
 const BaseExtension = require('./baseExtension');
 
 class DeviceReceive extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
         this.coordinator = null;
         this.elapsed = {};
         this.debouncers = {};
@@ -109,9 +109,7 @@ class DeviceReceive extends BaseExtension {
 
         // Check if there is an available converter
         if (!converters.length) {
-            // Don't log readRsp and raw as warn messages, they are not interesting most of the time.
-            const level = ['readResponse', 'raw'].includes(data.type) ? 'debug' : 'warn';
-            logger[level](
+            logger.debug(
                 `No converter available for '${mappedDevice.model}' with cluster '${data.cluster}' ` +
                 `and type '${data.type}' and data '${JSON.stringify(data.data)}'`,
             );
@@ -166,10 +164,11 @@ class DeviceReceive extends BaseExtension {
             }
         };
 
+        const meta = {device: data.device};
         let payload = {};
         converters.forEach((converter) => {
             const options = {...settings.get().device_options, ...settings.getDevice(data.device.ieeeAddr)};
-            const converted = converter.convert(mappedDevice, data, publish, options);
+            const converted = converter.convert(mappedDevice, data, publish, options, meta);
             if (converted) {
                 payload = {...payload, ...converted};
             }

lib/extension/deviceReport.js

@@ -1,6 +1,8 @@
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const logger = require('../util/logger');
 const CC2530Router = zigbeeHerdsmanConverters.devices.find((d) => d.model === 'CC2530.ROUTER');
+const BASICZBR3 = zigbeeHerdsmanConverters.devices.find((d) => d.model === 'BASICZBR3');
+const ZNLDP12LM = zigbeeHerdsmanConverters.devices.find((d) => d.model === 'ZNLDP12LM');
 const utils = require('../util/utils');
 const BaseExtension = require('./baseExtension');
 const debounce = require('debounce');
@@ -10,6 +12,8 @@ const defaultConfiguration = {
     minimumReportInterval: 3, maximumReportInterval: 300, reportableChange: 1,
 };
 
+const devicesNotSupportingReporting = [CC2530Router, BASICZBR3];
+
 const reportKey = 1;
 
 const clusters = {
@@ -54,29 +58,55 @@ const pollOnMessage = [
         // When the bound devices/members of group have the following manufacturerID
         manufacturerID: ZigbeeHerdsman.Zcl.ManufacturerCode.Philips,
     },
+    {
+        key: 2,
+        cluster: {
+            genOnOff: [
+                {type: 'commandOn', data: {}},
+                {type: 'commandOff', data: {}},
+                {type: 'commandOffWithEffect', data: {}},
+            ],
+            manuSpecificPhilips: [
+                {type: 'commandHueNotification', data: {button: 1}},
+                {type: 'commandHueNotification', data: {button: 4}},
+            ],
+        },
+        read: {cluster: 'genOnOff', attributes: ['onOff']},
+        manufacturerID: ZigbeeHerdsman.Zcl.ManufacturerCode.Philips,
+    },
 ];
 
 class DeviceReport extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
         this.configuring = new Set();
         this.failed = new Set();
         this.pollDebouncers = {};
     }
 
-    async setupReporting(device) {
+    shouldIgnoreClusterForDevice(cluster, mappedDevice) {
+        if (mappedDevice === ZNLDP12LM && cluster === 'closuresWindowCovering') {
+            // Device announces it but doesn't support it
+            // https://github.com/Koenkk/zigbee2mqtt/issues/2611
+            return true;
+        }
+
+        return false;
+    }
+
+    async setupReporting(device, mappedDevice) {
         if (this.configuring.has(device.ieeeAddr) || this.failed.has(device.ieeeAddr)) return;
         this.configuring.add(device.ieeeAddr);
 
         try {
-            for (const endpoint of device.endpoints) {
+            for (const ep of device.endpoints) {
                 for (const [cluster, configuration] of Object.entries(clusters)) {
-                    if (endpoint.supportsInputCluster(cluster)) {
-                        logger.debug(`Setup reporting for '${device.ieeeAddr}' - ${endpoint.ID} - ${cluster}`);
-                        await endpoint.bind(cluster, this.coordinatorEndpoint);
-                        await endpoint.configureReporting(cluster, configuration);
+                    if (ep.supportsInputCluster(cluster) && !this.shouldIgnoreClusterForDevice(cluster, mappedDevice)) {
+                        logger.debug(`Setup reporting for '${device.ieeeAddr}' - ${ep.ID} - ${cluster}`);
+                        await ep.bind(cluster, this.coordinatorEndpoint);
+                        await ep.configureReporting(cluster, configuration);
                         logger.info(
-                            `Succesfully setup reporting for '${device.ieeeAddr}' - ${endpoint.ID} - ${cluster}`,
+                            `Successfully setup reporting for '${device.ieeeAddr}' - ${ep.ID} - ${cluster}`,
                         );
                     }
                 }
@@ -109,7 +139,7 @@ class DeviceReport extends BaseExtension {
         if (device.meta.hasOwnProperty('reporting') && device.meta.reporting === reportKey) return false;
         if (!utils.isRouter(device) || utils.isBatteryPowered(device)) return false;
         // Gledopto devices don't support reporting.
-        if (mappedDevice === CC2530Router || mappedDevice.vendor === 'Gledopto') return false;
+        if (devicesNotSupportingReporting.includes(mappedDevice) || mappedDevice.vendor === 'Gledopto') return false;
         return true;
     }
 
@@ -119,14 +149,14 @@ class DeviceReport extends BaseExtension {
         for (const device of this.zigbee.getClients()) {
             const mappedDevice = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
             if (this.shouldSetupReporting(mappedDevice, device, null)) {
-                this.setupReporting(device);
+                this.setupReporting(device, mappedDevice);
             }
         }
     }
 
     onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
         if (this.shouldSetupReporting(mappedDevice, data.device, type)) {
-            this.setupReporting(data.device);
+            this.setupReporting(data.device, mappedDevice);
         }
 
         if (type === 'message') {

lib/extension/entityPublish.js

@@ -17,6 +17,8 @@ const groupConverters = [
     zigbeeHerdsmanConverters.toZigbeeConverters.ignore_transition,
     zigbeeHerdsmanConverters.toZigbeeConverters.cover_position_tilt,
     zigbeeHerdsmanConverters.toZigbeeConverters.thermostat_occupied_heating_setpoint,
+    zigbeeHerdsmanConverters.toZigbeeConverters.tint_scene,
+    zigbeeHerdsmanConverters.toZigbeeConverters.light_brightness_move,
 ];
 
 class EntityPublish extends BaseExtension {
@@ -166,7 +168,7 @@ class EntityPublish extends BaseExtension {
             };
 
             try {
-                if (topic.type === 'set' && converter && converter.convertSet) {
+                if (topic.type === 'set' && converter.convertSet) {
                     logger.debug(`Publishing '${topic.type}' '${key}' to '${entity.name}'`);
                     const result = await converter.convertSet(actualTarget, key, value, meta);
                     if (result && result.state) {
@@ -193,7 +195,7 @@ class EntityPublish extends BaseExtension {
                     ) {
                         setTimeout(() => converter.convertGet(actualTarget, key, meta), result.readAfterWriteTime);
                     }
-                } else if (topic.type === 'get' && converter && converter.convertGet) {
+                } else if (topic.type === 'get' && converter.convertGet) {
                     logger.debug(`Publishing get '${topic.type}' '${key}' to '${entity.name}'`);
                     await converter.convertGet(actualTarget, key, meta);
                 } else {

lib/extension/groups.js

@@ -6,8 +6,8 @@ const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/group/(
 const topicRegexRemoveAll = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/group/remove_all$`);
 
 class Groups extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
         this.onStateChange = this.onStateChange.bind(this);
     }
 
@@ -142,6 +142,9 @@ class Groups extends BaseExtension {
 
             if (!group || group.type !== 'group') {
                 logger.error(`Group '${topicMatch[1]}' does not exist`);
+                this.mqtt.log(
+                    `device_group_${type}_failed`,
+                    {friendly_name: message, group: topicMatch[1], error: 'group doesn\'t exists'});
                 return;
             }
         } else if (topic.match(topicRegexRemoveAll)) {
@@ -153,6 +156,9 @@ class Groups extends BaseExtension {
         const entity = this.zigbee.resolveEntity(message);
         if (!entity || !entity.type === 'device') {
             logger.error(`Device '${message}' does not exist`);
+            this.mqtt.log(
+                `device_group_${type}_failed`,
+                {friendly_name: message, group: topicMatch[1], error: 'entity doesn\'t exists'});
             return;
         }
 

lib/extension/homeassistant.js

@@ -26,6 +26,15 @@ const cfg = {
             device_class: 'presence',
         },
     },
+    'binary_sensor_tamper': {
+        type: 'binary_sensor',
+        object_id: 'tamper',
+        discovery_payload: {
+            payload_on: false,
+            payload_off: true,
+            value_template: '{{ value_json.tamper }}',
+        },
+    },
     'binary_sensor_contact': {
         type: 'binary_sensor',
         object_id: 'contact',
@@ -96,6 +105,15 @@ const cfg = {
             device_class: 'battery',
         },
     },
+    'binary_sensor_update_available': {
+        type: 'binary_sensor',
+        object_id: 'update_available',
+        discovery_payload: {
+            payload_on: true,
+            payload_off: false,
+            value_template: '{{ value_json.update_available}}',
+        },
+    },
     'binary_sensor_lock': {
         type: 'binary_sensor',
         object_id: 'lock',
@@ -122,11 +140,20 @@ const cfg = {
         type: 'sensor',
         object_id: 'illuminance',
         discovery_payload: {
-            unit_of_measurement: 'lx',
+            unit_of_measurement: '-',
             device_class: 'illuminance',
             value_template: '{{ value_json.illuminance }}',
         },
     },
+    'sensor_illuminance_lux': {
+        type: 'sensor',
+        object_id: 'illuminance',
+        discovery_payload: {
+            unit_of_measurement: 'lx',
+            device_class: 'illuminance',
+            value_template: '{{ value_json.illuminance_lux }}',
+        },
+    },
     'sensor_humidity': {
         type: 'sensor',
         object_id: 'humidity',
@@ -145,6 +172,15 @@ const cfg = {
             value_template: '{{ value_json.temperature }}',
         },
     },
+    'sensor_local_temperature': {
+        type: 'sensor',
+        object_id: 'local_temperature',
+        discovery_payload: {
+            unit_of_measurement: '°C',
+            device_class: 'temperature',
+            value_template: '{{ value_json.local_temperature }}',
+        },
+    },
     'sensor_pressure': {
         type: 'sensor',
         object_id: 'pressure',
@@ -227,7 +263,8 @@ const cfg = {
         type: 'sensor',
         object_id: 'linkquality',
         discovery_payload: {
-            unit_of_measurement: '-',
+            icon: 'mdi:signal',
+            unit_of_measurement: 'lqi',
             value_template: '{{ value_json.linkquality }}',
         },
     },
@@ -255,6 +292,15 @@ const cfg = {
             icon: 'mdi:view-array',
         },
     },
+    'sensor_consumption': {
+        type: 'sensor',
+        object_id: 'consumption',
+        discovery_payload: {
+            unit_of_measurement: 'kWh',
+            value_template: '{{ value_json.consumption }}',
+            icon: 'mdi:flash',
+        },
+    },
     'sensor_sensitivity': {
         type: 'sensor',
         object_id: 'sensitivity',
@@ -263,6 +309,14 @@ const cfg = {
             icon: 'mdi:filter-variant',
         },
     },
+    'sensor_strength': {
+        type: 'sensor',
+        object_id: 'strength',
+        discovery_payload: {
+            value_template: '{{ value_json.strength }}',
+            icon: 'mdi:weight',
+        },
+    },
 
     // Light
     'light_brightness_colorxy_white': {
@@ -276,6 +330,18 @@ const cfg = {
             command_topic: true,
         },
     },
+    'light_brightness_colortemp_colorxy_white': {
+        type: 'light',
+        object_id: 'light',
+        discovery_payload: {
+            brightness: true,
+            xy: true,
+            white_value: true,
+            schema: 'json',
+            command_topic: true,
+            color_temp: true,
+        },
+    },
     'light_brightness_colortemp_colorxy': {
         type: 'light',
         object_id: 'light',
@@ -297,6 +363,17 @@ const cfg = {
             command_topic: true,
         },
     },
+    'light_brightness_colortemp_colorhs': {
+        type: 'light',
+        object_id: 'light',
+        discovery_payload: {
+            brightness: true,
+            color_temp: true,
+            hs: true,
+            schema: 'json',
+            command_topic: true,
+        },
+    },
     'light_brightness_colortemp': {
         type: 'light',
         object_id: 'light',
@@ -373,6 +450,20 @@ const cfg = {
         discovery_payload: {
             command_topic: true,
             value_template: '{{ value_json.state }}',
+            state_locked: 'LOCK',
+            state_unlocked: 'UNLOCK',
+        },
+    },
+    'lock_keypad_lockout': {
+        type: 'lock',
+        object_id: 'keypad_lock',
+        discovery_payload: {
+            state_topic: true,
+            command_topic: true,
+            command_topic_postfix: 'keypad_lockout',
+            payload_unlock: '0',
+            payload_lock: '1',
+            value_template: '{{ value_json.keypad_lockout }}',
         },
     },
 
@@ -395,6 +486,8 @@ const cfg = {
                 temperature_state_template: `{{ value_json.${temperatureStateProperty} }}`,
                 temperature_command_topic: temperatureStateProperty,
                 temp_step: tempStep,
+                action_topic: true,
+                action_template: '{{ value_json.operation }}',
             },
         };
     },
@@ -433,7 +526,7 @@ const switchWithPostfix = (postfix) => {
 // Map homeassitant configurations to devices.
 const mapping = {
     'WXKG01LM': [cfg.sensor_click, cfg.sensor_battery],
-    'WXKG11LM': [cfg.sensor_click, cfg.sensor_battery],
+    'WXKG11LM': [cfg.sensor_click, cfg.sensor_battery, cfg.sensor_action],
     'WXKG12LM': [cfg.sensor_click, cfg.sensor_battery, cfg.sensor_action],
     // DEPRECATED; BREAKING_IMPROVEMENT: only use sensor_click for WXKG03LM (action hold -> click hold)
     'WXKG03LM': [cfg.sensor_click, cfg.sensor_battery, cfg.sensor_action],
@@ -466,6 +559,7 @@ const mapping = {
     'SWITCH EDP RE:DY': [cfg.switch],
     'CC2530.ROUTER': [cfg.binary_sensor_router],
     'AA70155': [cfg.light_brightness_colortemp],
+    'A9A19A60WESDZ02': [cfg.light_brightness_colortemp],
     '4058075816718': [cfg.light_brightness_colortemp_colorxy],
     'AA69697': [cfg.light_brightness_colortemp_colorxy],
     'HALIGHTDIMWWE27': [cfg.light_brightness],
@@ -481,6 +575,8 @@ const mapping = {
     '73742': [cfg.light_brightness_colortemp],
     '73740': [cfg.light_brightness_colortemp],
     '73739': [cfg.light_brightness_colortemp_colorxy],
+    '72569': [cfg.light_brightness_colortemp],
+    '72567': [cfg.light_brightness_colortemp],
     '22670': [cfg.light_brightness],
     'ICTC-G-1': [cfg.sensor_brightness, cfg.sensor_battery, cfg.sensor_action],
     'ICPSHC24-30EU-IL-1': [cfg.light_brightness],
@@ -515,26 +611,32 @@ const mapping = {
     'DNCKATSW001': [cfg.switch],
     'Z809A': [cfg.switch, cfg.sensor_power],
     'NL08-0800': [cfg.light_brightness],
+    '98425031': [cfg.light_brightness],
     '915005106701': [cfg.light_brightness_colortemp_colorxy],
+    'Aj_Zigbee_Led_Strip': [cfg.light_brightness_colortemp_colorxy],
     'AB32840': [cfg.light_brightness_colortemp],
     '8718696485880': [cfg.light_brightness_colortemp_colorxy],
     '8718696598283': [cfg.light_brightness_colortemp],
     '8718696695203': [cfg.light_brightness_colortemp],
     '73693': [cfg.light_brightness_colortemp_colorxy],
     '324131092621': [cfg.sensor_action, cfg.sensor_battery],
-    '9290012607': [cfg.binary_sensor_occupancy, cfg.sensor_temperature, cfg.sensor_illuminance, cfg.sensor_battery],
+    '9290012607': [
+        cfg.binary_sensor_occupancy, cfg.sensor_temperature, cfg.sensor_illuminance, cfg.sensor_illuminance_lux,
+        cfg.sensor_battery,
+    ],
     'GL-C-008': [cfg.light_brightness_colortemp_colorxy],
     'GL-C-009': [cfg.light_brightness],
     'STSS-MULT-001': [cfg.binary_sensor_contact, cfg.sensor_battery],
     'E11-G23/E11-G33': [cfg.light_brightness],
     'E1ACA4ABE38A': [cfg.light_brightness],
-    'AC03645': [cfg.light_brightness_colortemp_colorxy],
+    'AC03645': [cfg.light_brightness_colortemp_colorhs],
     'AC03641': [cfg.light_brightness],
     'AC03648': [cfg.light_brightness_colortemp],
     'FB56+ZSW05HG1.2': [cfg.switch],
     '72922-A': [cfg.switch],
     'AC03642': [cfg.light_brightness_colortemp],
     'AC08560': [cfg.light_brightness],
+    'AC10786-DIM': [cfg.light_brightness],
     'DNCKATSW002': [switchWithPostfix('left'), switchWithPostfix('right')],
     'DNCKATSW003': [switchWithPostfix('left'), switchWithPostfix('right'), switchWithPostfix('center')],
     'DNCKATSW004': [
@@ -545,13 +647,15 @@ const mapping = {
     'ZLED-2709': [cfg.light_brightness],
     '8718696548738': [cfg.light_brightness_colortemp],
     '915005587401': [cfg.light_brightness_colortemp],
+    '3435011P7': [cfg.light_brightness_colortemp],
     '4052899926110': [cfg.light_brightness_colortemp_colorxy],
     'Z01-CIA19NAE26': [cfg.light_brightness],
     'E11-N1EA': [cfg.light_brightness_colortemp_colorxy],
+    'E11-U2E': [cfg.light_brightness_colortemp_colorxy],
     '74283': [cfg.light_brightness],
     'JTQJ-BF-01LM/BW': [cfg.binary_sensor_gas, cfg.sensor_gas_density, cfg.sensor_sensitivity],
     '50043': [cfg.switch],
-    '50045': [cfg.light_brightness],
+    '50044/50045': [cfg.light_brightness],
     'AV2010/22': [cfg.binary_sensor_occupancy, cfg.sensor_battery],
     '3210-L': [cfg.switch, cfg.sensor_power, cfg.sensor_current, cfg.sensor_voltage],
     '3320-L': [cfg.binary_sensor_contact, cfg.sensor_temperature, cfg.sensor_battery],
@@ -562,7 +666,7 @@ const mapping = {
     '433714': [cfg.light_brightness],
     '3261030P7': [cfg.light_brightness_colortemp],
     '3216431P5': [cfg.light_brightness_colortemp],
-    'DJT11LM': [cfg.sensor_action, cfg.sensor_battery, cfg.sensor_sensitivity],
+    'DJT11LM': [cfg.sensor_action, cfg.sensor_battery, cfg.sensor_sensitivity, cfg.sensor_strength],
     'E1603/E1702': [cfg.switch],
     '7199960PH': [cfg.light_brightness_colorxy],
     '74696': [cfg.light_brightness],
@@ -592,7 +696,10 @@ const mapping = {
     'HS1SA-M': [cfg.binary_sensor_smoke, cfg.binary_sensor_battery_low],
     'Z01-A19NAE26': [cfg.light_brightness_colortemp],
     'Z01-A60EAE27': [cfg.light_brightness_colortemp],
-    'AC01353010G': [cfg.binary_sensor_occupancy, cfg.sensor_temperature, cfg.binary_sensor_battery_low],
+    'AC01353010G': [
+        cfg.binary_sensor_occupancy, cfg.binary_sensor_tamper,
+        cfg.sensor_temperature, cfg.binary_sensor_battery_low,
+    ],
     'SP 120': [cfg.switch, cfg.sensor_power],
     'SP 222': [cfg.switch],
     'RB 248 T': [cfg.light_brightness_colortemp],
@@ -603,18 +710,19 @@ const mapping = {
     '421786': [cfg.light_brightness],
     'ICZB-IW11D': [cfg.light_brightness],
     '3321-S': [cfg.binary_sensor_contact, cfg.sensor_temperature],
-    'ZPIR-8000': [cfg.binary_sensor_occupancy],
+    'ZPIR-8000': [cfg.binary_sensor_occupancy, cfg.sensor_battery],
     'ZCTS-808': [cfg.binary_sensor_contact, cfg.sensor_battery],
     'ZNLDP12LM': [cfg.light_brightness_colortemp],
     'D1821': [cfg.light_brightness_colortemp_colorxy],
     'ZNCLDJ11LM': [cfg.cover_position, cfg.sensor_cover],
     'LTFY004': [cfg.light_brightness_colorxy],
-    'GL-S-007Z': [cfg.light_brightness_colorxy_white],
+    'GL-S-007Z': [cfg.light_brightness_colortemp_colorxy],
     '3325-S': [cfg.sensor_temperature, cfg.binary_sensor_occupancy],
     '4713407': [cfg.light_brightness],
     '464800': [cfg.light_brightness_colortemp],
     '3261331P7': [cfg.light_brightness_colortemp],
     '4033930P7': [cfg.light_brightness_colortemp],
+    '4023330P7': [cfg.light_brightness_colortemp],
     'GL-B-008Z': [cfg.light_brightness_colortemp_colorxy],
     'AV2010/25': [cfg.switch, cfg.sensor_power],
     'E12-N14': [cfg.light_brightness],
@@ -628,11 +736,14 @@ const mapping = {
     'HGZB-20-DE': [cfg.switch],
     'D1531': [cfg.light_brightness],
     'D1532': [cfg.light_brightness],
+    'D1533': [cfg.light_brightness],
     'AV2010/32': [],
     'HGZB-07A': [cfg.light_brightness_colortemp_colorxy],
     'E1524/E1810': [cfg.sensor_action, cfg.sensor_battery],
     'GL-C-006': [cfg.light_brightness_colortemp],
     'GL-C-007': [cfg.light_brightness_colorxy_white],
+    'GL-C-007S': [cfg.light_brightness_colorxy_white],
+    'GL-C-007/GL-C-008': [cfg.light_brightness_colortemp_colorxy_white],
     '100.424.11': [cfg.light_brightness_colortemp],
     'AC0251100NJ/AC0251700NJ': [cfg.sensor_action, cfg.sensor_battery],
     '71831': [cfg.light_brightness_colortemp],
@@ -658,7 +769,8 @@ const mapping = {
     'RADON TriTech ZB': [
         cfg.binary_sensor_occupancy, cfg.sensor_temperature, cfg.sensor_battery, cfg.binary_sensor_battery_low,
     ],
-    'IM-Z3.0-DIM': [cfg.light_brightness],
+    '07005B': [cfg.light_brightness],
+    '07004D': [cfg.light_brightness_colortemp_colorxy],
     'E1746': [],
     'LED1836G9': [cfg.light_brightness],
     'YRD426NRSC': [cfg.lock, cfg.sensor_battery],
@@ -668,7 +780,7 @@ const mapping = {
     'RB 265': [cfg.light_brightness],
     '9290019758': [
         cfg.binary_sensor_occupancy, cfg.sensor_temperature,
-        cfg.sensor_illuminance, cfg.sensor_battery,
+        cfg.sensor_illuminance, cfg.sensor_illuminance_lux, cfg.sensor_battery,
     ],
     'HGZB-042': [switchWithPostfix('top'), switchWithPostfix('bottom')],
     'HGZB-42': [switchWithPostfix('top'), switchWithPostfix('bottom')],
@@ -685,7 +797,7 @@ const mapping = {
     '316GLEDRF': [cfg.light_brightness],
     'LVS-ZB500D': [cfg.light_brightness],
     'ST218': [],
-    'E1525': [cfg.binary_sensor_occupancy, cfg.sensor_battery],
+    'E1525/E1745': [cfg.binary_sensor_occupancy, cfg.sensor_battery],
     'ZYCT-202': [cfg.sensor_action],
     'GR-ZB01-W': [cfg.cover_position],
     '4090531P7': [cfg.light_brightness_colortemp_colorxy],
@@ -721,7 +833,7 @@ const mapping = {
         cfg.sensor_temperature, cfg.binary_sensor_contact,
         cfg.sensor_battery, cfg.binary_sensor_battery_low,
     ],
-    'IM6001-BTP01': [cfg.sensor_click, cfg.sensor_temperature],
+    'IM6001-BTP01': [cfg.sensor_click, cfg.sensor_temperature, cfg.sensor_battery],
     'AV2010/34': [cfg.sensor_click],
     'PP-WHT-US': [
         cfg.switch, cfg.sensor_power,
@@ -763,7 +875,11 @@ const mapping = {
     'BY 285 C': [cfg.light_brightness_colortemp_colorxy],
     'HS1RC-M': [cfg.sensor_action, cfg.sensor_battery],
     'SWO-WDS1PA': [cfg.binary_sensor_contact],
-    'LLKZMK11LM': [switchWithPostfix('l1'), switchWithPostfix('l2')],
+    'LLKZMK11LM': [
+        switchWithPostfix('l1'), switchWithPostfix('l2'),
+        cfg.sensor_power, cfg.sensor_temperature, cfg.sensor_consumption,
+    ],
+    'T18W3Z': [switchWithPostfix('l1'), switchWithPostfix('l2'), switchWithPostfix('l3')],
     'LVS-SM10ZW': [cfg.binary_sensor_contact, cfg.binary_sensor_battery_low],
     'HS2SK': [cfg.switch, cfg.sensor_power],
     '45853GE': [cfg.switch, cfg.sensor_power],
@@ -771,7 +887,7 @@ const mapping = {
     '9290011998B': [cfg.light_brightness_colortemp],
     '9290022167': [cfg.light_brightness_colortemp],
     '4096730U7': [cfg.light_brightness_colortemp],
-    'RB 278 T': [cfg.light_brightness],
+    'RB 278 T': [cfg.light_brightness_colortemp],
     '3315-G': [
         cfg.sensor_temperature, cfg.sensor_battery, cfg.binary_sensor_water_leak,
     ],
@@ -830,8 +946,9 @@ const mapping = {
     '7099860PH': [cfg.light_brightness_colorxy],
     'HV-GSCXZB269': [cfg.light_brightness_colortemp],
     '3216231P5': [cfg.light_brightness_colortemp],
-    'AC03647': [cfg.light_brightness_colortemp_colorxy],
+    'AC03647': [cfg.light_brightness_colortemp_colorhs],
     '12031': [cfg.cover_position],
+    'LS12128': [cfg.cover_position],
     '421792': [cfg.light_brightness_colortemp_colorxy],
     'HGZB-06A': [cfg.light_brightness_colortemp_colorxy],
     'LED1733G7': [cfg.light_brightness_colortemp],
@@ -847,6 +964,9 @@ const mapping = {
     'ZNMS13LM': [
         cfg.sensor_action, cfg.binary_sensor_lock, cfg.binary_sensor_lock_reverse,
     ],
+    'ZNMS11LM': [
+        cfg.sensor_action, cfg.binary_sensor_lock, cfg.binary_sensor_lock_reverse,
+    ],
     '12050': [cfg.switch, cfg.sensor_power],
     'ROB_200-004-0': [cfg.light_brightness],
     '4512700': [cfg.light_brightness],
@@ -868,7 +988,7 @@ const mapping = {
         switchWithPostfix('top_right'), switchWithPostfix('center_right'), switchWithPostfix('bottom_right'),
     ],
     '3306431P7': [cfg.light_brightness_colortemp],
-    'AC08559': [cfg.light_brightness_colortemp],
+    'AC08559': [cfg.light_brightness_colortemp_colorxy],
     'LVS-ZB15S': [cfg.switch],
     'LZL4BWHL01': [cfg.sensor_action],
     '2AJZ4KPKEY': [cfg.sensor_click, cfg.sensor_battery],
@@ -877,11 +997,18 @@ const mapping = {
     'ZM-CSW002-D': [switchWithPostfix('l1'), switchWithPostfix('l2'), cfg.sensor_power],
     'LVS-SN10ZW': [cfg.sensor_battery, cfg.binary_sensor_occupancy],
     'LVS-ZB15R': [cfg.switch],
-    'TH1123ZB': [cfg.thermostat()],
+    'TH1123ZB': [
+        cfg.thermostat(7, 30, 'occupied_heating_setpoint', 1.0), cfg.sensor_local_temperature,
+        cfg.lock_keypad_lockout, cfg.sensor_power,
+    ],
     'TH1124ZB': [cfg.thermostat()],
+    'TH1400ZB': [cfg.thermostat()],
+    'TH1500ZB': [cfg.thermostat()],
     'Zen-01-W': [cfg.thermostat()],
     '9290022166': [cfg.light_brightness_colortemp_colorxy],
     'PM-C140-ZB': [cfg.sensor_power, cfg.switch],
+    'PM-B530-ZB': [cfg.sensor_power, cfg.switch],
+    'PM-B430-ZB': [cfg.sensor_power, cfg.switch],
     'ptvo.switch': [
         switchWithPostfix('bottom_left'), switchWithPostfix('bottom_right'), switchWithPostfix('top_left'),
         switchWithPostfix('top_right'), switchWithPostfix('center'), cfg.sensor_click,
@@ -895,24 +1022,22 @@ const mapping = {
     'FL 130 C': [cfg.light_brightness_colortemp_colorxy],
     'BF 263': [cfg.light_brightness],
     'RF 263': [cfg.light_brightness],
-    'F-WTR-UK-V2': [
-        cfg.sensor_temperature, cfg.binary_sensor_water_leak, cfg.sensor_battery,
-    ],
     'HS1CG-M': [cfg.binary_sensor_gas],
     'HS1CG_M': [cfg.binary_sensor_gas],
     'LVS-SN10ZW_SN11': [cfg.sensor_battery, cfg.binary_sensor_occupancy],
     'B00TN589ZG': [cfg.light_brightness],
     'PSB19-SW27': [cfg.light_brightness],
-    'S1': [cfg.switch],
-    'S2': [switchWithPostfix('l1'), switchWithPostfix('l2')],
+    'S1': [cfg.switch, cfg.sensor_power],
+    'S2': [switchWithPostfix('l1'), switchWithPostfix('l2'), cfg.sensor_power],
     'ZWallRemote0': [cfg.sensor_click],
-    'D1': [cfg.light_brightness],
-    'J1': [cfg.cover_position_tilt],
+    'D1': [cfg.light_brightness, cfg.sensor_power],
+    'J1': [cfg.cover_position_tilt, cfg.sensor_power],
     '73741': [cfg.light_brightness_colortemp_colorxy],
     'ZA806SQ1TCF': [cfg.light_brightness_colortemp],
     'RF 265': [cfg.light_brightness],
     'ZNCZ03LM': [cfg.switch, cfg.sensor_power],
     '17436/30/P7': [cfg.light_brightness],
+    '17435/30/P7': [cfg.light_brightness_colorxy],
     '9290018187B': [cfg.light_brightness_colortemp_colorxy],
     '1741830P7': [cfg.light_brightness_colortemp_colorxy],
     'Z3-1BRL': [cfg.sensor_action, cfg.sensor_brightness],
@@ -927,7 +1052,7 @@ const mapping = {
     '2AJZ4KPBS': [cfg.sensor_battery, cfg.binary_sensor_occupancy, cfg.binary_sensor_battery_low],
     '2AJZ4KPDR': [cfg.sensor_battery, cfg.binary_sensor_contact, cfg.binary_sensor_battery_low],
     '6717-84': [cfg.switch],
-    'ICZB-KPD18S': [cfg.sensor_click],
+    'ICZB-KPD18S': [cfg.sensor_battery, cfg.sensor_click, cfg.sensor_action],
     '100.469.65': [cfg.light_brightness_colortemp],
     'E1757': [cfg.cover_position, cfg.sensor_battery],
     'E1926': [cfg.cover_position, cfg.sensor_battery],
@@ -940,6 +1065,7 @@ const mapping = {
     '8718699673147': [cfg.light_brightness],
     '3300-P': [cfg.sensor_temperature, cfg.binary_sensor_contact, cfg.sensor_battery],
     'GL-B-008ZS': [cfg.light_brightness_colortemp_colorxy],
+    'T1828': [cfg.light_brightness_colortemp],
     'T1829': [cfg.light_brightness_colortemp],
     '929002240401': [cfg.switch],
     'HGZB-20-UK': [cfg.switch],
@@ -959,12 +1085,12 @@ const mapping = {
     'ZNCLDJ12LM': [cfg.cover_position],
     '046677552343': [cfg.switch],
     '3115331PH': [cfg.light_brightness_colortemp_colorxy],
-    'ZWLD-100': [cfg.binary_sensor_water_leak, cfg.binary_sensor_battery_low],
+    'ZWLD-100': [cfg.binary_sensor_water_leak, cfg.binary_sensor_battery_low, cfg.sensor_battery],
     'GL-MC-001': [cfg.light_brightness_colortemp_colorxy],
     'YRD226/246 TSDB': [cfg.lock, cfg.sensor_battery],
     'T1820': [cfg.light_brightness_colortemp],
     'BASICZBR3': [cfg.switch],
-    'E1744': [cfg.sensor_action],
+    'E1744': [cfg.sensor_action, cfg.sensor_battery],
     'TS0201': [cfg.sensor_temperature, cfg.sensor_humidity, cfg.sensor_battery],
     'LH07321': [cfg.binary_sensor_water_leak, cfg.binary_sensor_battery_low],
     'GL-C-008S': [cfg.light_brightness_colortemp_colorxy],
@@ -972,10 +1098,13 @@ const mapping = {
     '8718699688882': [cfg.light_brightness],
     'LED1738G7': [cfg.light_brightness_colortemp],
     '9290022169': [cfg.light_brightness_colortemp],
-    'TERNCY-PP01': [cfg.sensor_temperature, cfg.binary_sensor_occupancy, cfg.sensor_illuminance, cfg.sensor_click],
+    'TERNCY-PP01': [
+        cfg.sensor_temperature, cfg.binary_sensor_occupancy, cfg.sensor_illuminance, cfg.sensor_illuminance_lux,
+        cfg.sensor_click,
+    ],
     'CR11S8UZ': [cfg.sensor_action],
     'RB 148 T': [cfg.light_brightness_colortemp],
-    'STS-OUT-US-2': [cfg.switch],
+    'STS-OUT-US-2': [cfg.switch, cfg.sensor_power],
     'UK7004240': [cfg.thermostat(), cfg.sensor_battery],
     'S31ZB': [cfg.switch],
     'SA-003-Zigbee': [cfg.switch],
@@ -987,7 +1116,7 @@ const mapping = {
     'TS0111': [cfg.switch],
     'TS0001': [cfg.switch],
     'TS0207': [cfg.binary_sensor_water_leak, cfg.sensor_battery],
-    'iL07_1': [cfg.binary_sensor_occupancy, cfg.binary_sensor_battery_low],
+    'iL07_1': [cfg.binary_sensor_occupancy, cfg.binary_sensor_tamper, cfg.binary_sensor_battery_low],
     'S31 Lite zb': [cfg.switch],
     'LH-992ZB': [cfg.binary_sensor_occupancy, cfg.binary_sensor_battery_low],
     '548727': [cfg.light_brightness_colortemp_colorxy],
@@ -995,9 +1124,10 @@ const mapping = {
     'TS0218': [cfg.sensor_action, cfg.sensor_battery],
     '404021': [cfg.switch],
     'Eco-Dim.07': [cfg.light_brightness],
-    'DYRuZ_rspm': [cfg.switch, cfg.sensor_action, cfg.sensor_power, cfg.sensor_current],
+    'DIYRuZ_rspm': [cfg.switch, cfg.sensor_action, cfg.sensor_power, cfg.sensor_current],
     'ZG9101SAC-HP-Switch': [cfg.switch],
     'ZNCZ04LM': [cfg.switch, cfg.sensor_power],
+    'ZNCZ12LM': [cfg.switch, cfg.sensor_power],
     'GL-S-007ZS': [cfg.light_brightness_colortemp_colorxy],
     '4058075816732': [cfg.light_brightness_colortemp_colorxy],
     'GL-B-007ZS': [cfg.light_brightness_colortemp_colorxy],
@@ -1005,7 +1135,7 @@ const mapping = {
     'WXCJKG11LM': [cfg.sensor_action, cfg.sensor_battery],
     'WXCJKG12LM': [cfg.sensor_action, cfg.sensor_battery],
     'WXCJKG13LM': [cfg.sensor_action, cfg.sensor_battery],
-    '9290022230': [cfg.sensor_action, cfg.sensor_battery],
+    '8718699693985': [cfg.sensor_action, cfg.sensor_battery],
     'GL-D-004ZS': [cfg.light_brightness_colortemp_colorxy],
     'AC10787': [cfg.light_brightness_colortemp],
     'F-APP-UK-V2': [cfg.switch],
@@ -1017,6 +1147,114 @@ const mapping = {
     'GDKES-01TZXD': [cfg.switch],
     'GDKES-02TZXD': [switchWithPostfix('left'), switchWithPostfix('right')],
     'GDKES-03TZXD': [switchWithPostfix('left'), switchWithPostfix('center'), switchWithPostfix('right')],
+    '6735/6736/6737': [cfg.switch, cfg.sensor_action],
+    '4034031P7': [cfg.light_brightness_colortemp],
+    '5900131C5': [cfg.light_brightness_colortemp],
+    'SZ-SRN12N': [],
+    'ML-ST-D200': [cfg.light_brightness],
+    '7099930PH': [cfg.light_brightness_colorxy],
+    '9GED18000-009': [cfg.lock, cfg.sensor_battery],
+    '9GED21500-005': [cfg.lock, cfg.sensor_battery],
+    'MP-841': [cfg.binary_sensor_occupancy, cfg.binary_sensor_battery_low],
+    'MCT-370 SMA': [cfg.binary_sensor_contact, cfg.binary_sensor_battery_low],
+    'RB 162': [cfg.light_brightness],
+    'SOHM-I1': [cfg.binary_sensor_contact, cfg.binary_sensor_battery_low],
+    'SWHM-I1': [cfg.binary_sensor_water_leak, cfg.binary_sensor_battery_low],
+    'SMHM-I1': [cfg.binary_sensor_occupancy, cfg.binary_sensor_battery_low],
+    'SKHMP30-I1': [cfg.switch, cfg.sensor_power],
+    '404028': [cfg.light_brightness_colortemp_colorxy],
+    '595UGR22': [cfg.light_brightness_colortemp],
+    '6ARCZABZH': [cfg.sensor_battery, cfg.sensor_action],
+    'ZK-EU-2U': [cfg.switch],
+    '511.202': [cfg.switch],
+    'SP 224': [cfg.switch],
+    '9290022411': [cfg.light_brightness],
+    'E1C-NB6': [cfg.switch],
+    'LVS-SC7': [cfg.sensor_action],
+    '1742930P7': [cfg.light_brightness_colortemp_colorxy],
+    'ZM-L03E-Z': [switchWithPostfix('left'), switchWithPostfix('center'), switchWithPostfix('right')],
+    'DL15S-1BZ': [cfg.switch],
+    'E1D-G73WNA': [cfg.binary_sensor_contact, cfg.binary_sensor_battery_low],
+    'WV704R0A0902': [cfg.thermostat()],
+    '067776': [cfg.cover_position],
+    '067773': [cfg.sensor_action, cfg.sensor_battery],
+    '067771': [cfg.switch],
+    '064873': [cfg.sensor_action],
+    'K4003C': [cfg.switch],
+    'STZB402': [
+        cfg.thermostat(5, 30, 'occupied_heating_setpoint', 0.5),
+        cfg.sensor_local_temperature,
+        cfg.lock_keypad_lockout,
+    ],
+    'SMT402': [
+        cfg.thermostat(5, 30, 'occupied_heating_setpoint', 0.5),
+        cfg.sensor_local_temperature,
+        cfg.lock_keypad_lockout,
+    ],
+    '046677551780': [cfg.light_brightness],
+    '798.15': [cfg.light_brightness],
+    '12126': [cfg.switch],
+    '067775': [cfg.switch, cfg.sensor_power],
+    '064888': [cfg.switch],
+    'gq8b1uv': [cfg.light_brightness],
+    'GZCGQ01LM': [cfg.sensor_battery, cfg.sensor_illuminance, cfg.sensor_illuminance_lux],
+    '9290018215': [cfg.light_brightness],
+    '1743230P7': [cfg.light_brightness_colortemp_colorxy],
+    '100.110.51': [cfg.light_brightness_colortemp],
+    'ZL1000100-CCT-US-V1A02': [cfg.light_brightness],
+    'HGZB-DLC4-N12B': [cfg.light_brightness_colortemp_colorxy],
+    'U86KCJ-ZP': [cfg.sensor_action],
+    'HS1HT': [cfg.sensor_temperature, cfg.sensor_humidity, cfg.sensor_battery],
+    'HS2ESK-E': [cfg.switch, cfg.sensor_power],
+    'B01M7Y8BP9': [cfg.sensor_action],
+    'GP-WOU019BBDWG': [cfg.switch, cfg.sensor_power],
+    'AV2010/21A': [cfg.binary_sensor_battery_low, cfg.binary_sensor_contact, cfg.binary_sensor_tamper],
+    'AL-PIR02': [cfg.binary_sensor_occupancy, cfg.binary_sensor_tamper, cfg.sensor_battery],
+    'MKS-CM-W5': [
+        switchWithPostfix('l1'), switchWithPostfix('l2'),
+        switchWithPostfix('l3'), switchWithPostfix('l4'),
+    ],
+    'STS-WTR-250': [cfg.binary_sensor_water_leak, cfg.sensor_battery],
+    'ZG2835RAC': [cfg.light_brightness],
+    'BW-IS2': [cfg.binary_sensor_contact, cfg.sensor_battery],
+    'BW-IS3': [cfg.binary_sensor_occupancy],
+    'SLR1b': [cfg.thermostat()],
+    'WPT1': [],
+    '4058075047853': [cfg.light_brightness_colortemp_colorxy],
+    'ROB_200-003-0': [cfg.switch],
+    '4512704': [cfg.switch],
+    'AV2010/24A': [cfg.binary_sensor_smoke, cfg.binary_sensor_battery_low, cfg.binary_sensor_tamper],
+    '902010/24': [cfg.binary_sensor_smoke, cfg.binary_sensor_battery_low, cfg.binary_sensor_tamper],
+    'ROB_200-014-0': [cfg.light_brightness],
+    '4090631P7': [cfg.light_brightness_colortemp_colorxy],
+    'SGMHM-I1': [cfg.binary_sensor_gas, cfg.binary_sensor_battery_low, cfg.binary_sensor_tamper],
+    'STHM-I1H': [cfg.sensor_humidity, cfg.sensor_temperature, cfg.sensor_battery],
+    'BDHM8E27W70-I1': [cfg.light_brightness_colortemp],
+    'M420': [cfg.sensor_battery],
+    '8718696167991': [cfg.light_brightness_colortemp_colorxy],
+    'GP-LBU019BBAWU': [cfg.light_brightness],
+    '371000001': [cfg.light_brightness_colortemp],
+    '10011725': [cfg.light_brightness_colortemp_colorxy],
+    '929002277501': [cfg.light_brightness],
+    'RS 230 C': [cfg.light_brightness_colortemp_colorxy],
+    'LED1903C5': [cfg.light_brightness_colortemp],
+    '1402755': [cfg.light_brightness],
+    '4503848C5': [cfg.light_brightness_colortemp],
+    '500.48': [cfg.light_brightness],
+    'TS0042': [cfg.sensor_action],
+    'RHK06': [cfg.binary_sensor_contact, cfg.sensor_battery],
+    'RHK07': [cfg.sensor_action, cfg.sensor_battery],
+    'RHK08': [cfg.sensor_temperature, cfg.sensor_humidity, cfg.sensor_battery],
+    'RHK09': [cfg.binary_sensor_occupancy, cfg.sensor_battery],
+    '07046L': [cfg.sensor_action],
+    '07045L': [cfg.binary_sensor_contact, cfg.binary_sensor_tamper, cfg.binary_sensor_battery_low],
+    '3402831P7': [cfg.light_brightness_colortemp],
+    'TERNCY-SD01': [cfg.sensor_click, cfg.sensor_battery],
+    '07048L': [cfg.switch, cfg.sensor_power],
+    'ICZB-KPD14S': [cfg.sensor_battery, cfg.sensor_click, cfg.sensor_action],
+    '73743': [cfg.sensor_action, cfg.sensor_battery],
+    'C4': [cfg.sensor_action],
+    'GL-D-003ZS': [cfg.light_brightness_colortemp_colorxy],
 };
 
 Object.keys(mapping).forEach((key) => {
@@ -1027,8 +1265,8 @@ Object.keys(mapping).forEach((key) => {
  * This extensions handles integration with HomeAssistant
  */
 class HomeAssistant extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
 
         // A map of all discoverd devices
         this.discovered = {};
@@ -1043,6 +1281,19 @@ class HomeAssistant extends BaseExtension {
 
         this.discoveryTopic = settings.get().advanced.homeassistant_discovery_topic;
         this.statusTopic = settings.get().advanced.homeassistant_status_topic;
+
+        this.eventBus.on('deviceRemoved', (data) => this.onDeviceRemoved(data.device));
+    }
+
+    onDeviceRemoved(device) {
+        const mappedModel = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
+        if (mappedModel) {
+            logger.info(`Clearing Home Assistant discovery topic for '${device.ieeeAddr}'`);
+            this.getConfigs(mappedModel).forEach((config) => {
+                const topic = this.getDiscoveryTopic(config, device);
+                this.mqtt.publish(topic, null, {retain: true, qos: 0}, this.discoveryTopic);
+            });
+        }
     }
 
     async onMQTTConnected() {
@@ -1052,26 +1303,34 @@ class HomeAssistant extends BaseExtension {
         for (const device of this.zigbee.getClients()) {
             const mappedModel = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID);
             if (mappedModel) {
-                this.discover(device.ieeeAddr, mappedModel, true);
+                this.discover(device, mappedModel, true);
             }
         }
     }
 
-    discover(entityID, mappedModel, force=false) {
+    getConfigs(mappedModel) {
+        const configs = mapping[mappedModel.model].slice();
+        if (mappedModel.hasOwnProperty('ota')) {
+            configs.push(cfg.binary_sensor_update_available);
+        }
+        return configs;
+    }
+
+    discover(device, mappedModel, force=false) {
         // Check if already discoverd and check if there are configs.
-        const discover = force || !this.discovered[entityID];
+        const discover = force || !this.discovered[device.ieeeAddr];
         if (!discover) {
             return;
         }
 
-        const entity = settings.getEntity(entityID);
+        const entity = settings.getEntity(device.ieeeAddr);
         if (!entity || (entity.type === 'device' && !mapping[mappedModel.model]) ||
             (entity.hasOwnProperty('homeassistant') && !entity.homeassistant)) {
             return;
         }
 
-        mapping[mappedModel.model].forEach((config) => {
-            const topic = `${config.type}/${entity.ID}/${config.object_id}/config`;
+        this.getConfigs(mappedModel).forEach((config) => {
+            const topic = this.getDiscoveryTopic(config, device);
             const payload = {...config.discovery_payload};
             const stateTopic = `${settings.get().mqtt.base_topic}/${entity.friendlyName}`;
 
@@ -1181,6 +1440,10 @@ class HomeAssistant extends BaseExtension {
                 payload.speed_command_topic = `${stateTopic}/set/fan_mode`;
             }
 
+            if (payload.action_topic) {
+                payload.action_topic = stateTopic;
+            }
+
             // Override configuration with user settings.
             if (entity.hasOwnProperty('homeassistant')) {
                 const add = (obj) => {
@@ -1207,7 +1470,7 @@ class HomeAssistant extends BaseExtension {
             this.mqtt.publish(topic, JSON.stringify(payload), {retain: true, qos: 0}, this.discoveryTopic);
         });
 
-        this.discovered[entityID] = true;
+        this.discovered[device.ieeeAddr] = true;
     }
 
     onMQTTMessage(topic, message) {
@@ -1232,10 +1495,14 @@ class HomeAssistant extends BaseExtension {
     onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
         const device = data.device;
         if (device && mappedDevice) {
-            this.discover(device.ieeeAddr, mappedDevice);
+            this.discover(device, mappedDevice);
         }
     }
 
+    getDiscoveryTopic(config, device) {
+        return `${config.type}/${device.ieeeAddr}/${config.object_id}/config`;
+    }
+
     // Only for homeassistant.test.js
     _getMapping() {
         return mapping;

lib/extension/networkMap.js

@@ -5,8 +5,8 @@ const logger = require('../util/logger');
 const BaseExtension = require('./baseExtension');
 
 class NetworkMap extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
 
         // Subscribe to topic.
         this.topic = `${settings.get().mqtt.base_topic}/bridge/networkmap`;

lib/extension/otaUpdate.js

@@ -0,0 +1,132 @@
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const assert = require('assert');
+const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/ota_update/.+$`);
+const BaseExtension = require('./baseExtension');
+const MINUTES_10 = 1000 * 60 * 10;
+
+class OTAUpdate extends BaseExtension {
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
+        this.inProgress = new Set();
+        this.lastChecked = {};
+    }
+
+    onMQTTConnected() {
+        this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/ota_update/check`);
+        this.mqtt.subscribe(`${settings.get().mqtt.base_topic}/bridge/ota_update/update`);
+    }
+
+    async onZigbeeEvent(type, data, mappedDevice, settingsDevice) {
+        if (data.type !== 'commandQueryNextImageRequest' || !mappedDevice.hasOwnProperty('ota')) return;
+
+        // When a device does a next image request, it will usually do it a few times after each other
+        // with only 10 - 60 seconds inbetween. It doesn' make sense to check for a new update
+        // each time.
+        const check = this.lastChecked.hasOwnProperty(data.device.ieeeAddr) ?
+            (Date.now() - this.lastChecked[data.device.ieeeAddr]) > MINUTES_10 : true;
+        if (!check || this.inProgress.has(data.device.ieeeAddr)) return;
+
+        this.lastChecked[data.device.ieeeAddr] = Date.now();
+        const available = await mappedDevice.ota.isUpdateAvailable(data.device, logger, data.data);
+        this.publishEntityState(data.device.ieeeAddr, {update_available: available});
+
+        if (available) {
+            const message = `Update available for '${settingsDevice.friendly_name}'`;
+            logger.info(message);
+            this.mqtt.log('ota_update', message, {status: 'available', device: settingsDevice.friendly_name});
+        }
+    }
+
+    async readSoftwareBuildIDAndDateCode(device, update) {
+        try {
+            const endpoint = device.endpoints.find((e) => e.supportsInputCluster('genBasic'));
+            const result = await endpoint.read('genBasic', ['dateCode', 'swBuildId']);
+
+            if (update) {
+                device.softwareBuildID = result.swBuildId;
+                device.dateCode = result.dateCode;
+                device.save();
+            }
+
+            return {softwareBuildID: result.swBuildId, dateCode: result.dateCode};
+        } catch (e) {
+            return null;
+        }
+    }
+
+    async onMQTTMessage(topic, message) {
+        if (!topic.match(topicRegex)) {
+            return null;
+        }
+
+        const device = this.zigbee.resolveEntity(message);
+        assert(device != null && device.type === 'device', 'Device not found or not a device');
+        if (!device.mapped || !device.mapped.ota) {
+            const message = `Device '${device.name}' does not support OTA updates`;
+            logger.error(message);
+            this.mqtt.log('ota_update', message, {status: `not_supported`, device: device.name});
+            return;
+        }
+
+        if (this.inProgress.has(device.device.ieeeAddr)) {
+            logger.error(`Update or check already in progress for '${device.name}', skipping...`);
+            return;
+        }
+        this.inProgress.add(device.device.ieeeAddr);
+
+        const type = topic.split('/')[3];
+        if (type === 'check') {
+            const message = `Checking if update available for '${device.name}'`;
+            logger.info(message);
+            this.mqtt.log('ota_update', message, {status: `checking_if_available`, device: device.name});
+            try {
+                const available = await device.mapped.ota.isUpdateAvailable(device.device, logger);
+                const message=(available ?
+                    `Update available for '${device.name}'` : `No update available for '${device.name}'`);
+                logger.info(message);
+                const meta = {status: available ? 'available' : 'not_available', device: device.name};
+                this.mqtt.log('ota_update', message, meta);
+                this.publishEntityState(device.device.ieeeAddr, {update_available: available});
+                this.lastChecked[device.device.ieeeAddr] = Date.now();
+            } catch (error) {
+                const message = `Failed to check if update available for '${device.name}' (${error.message})`;
+                logger.error(message);
+                this.mqtt.log('ota_update', message, {status: `check_failed`, device: device.name});
+            }
+        } else { // type === 'update'
+            const message = `Updating '${device.name}' to latest firmware`;
+            logger.info(message);
+            this.mqtt.log('ota_update', message, {status: `update_in_progress`, device: device.name});
+            try {
+                const onProgress = (progress, remaining) => {
+                    let message = `Update of '${device.name}' at ${progress}%`;
+                    if (remaining) {
+                        message += `, +- ${Math.round(remaining / 60)} minutes remaining`;
+                    }
+
+                    logger.info(message);
+                    this.mqtt.log('ota_update', message, {status: `update_progress`, device: device.name, progress});
+                };
+
+                const from_ = await this.readSoftwareBuildIDAndDateCode(device.device, false);
+                await device.mapped.ota.updateToLatest(device.device, logger, onProgress);
+                const to = await this.readSoftwareBuildIDAndDateCode(device.device, true);
+                const [fromS, toS] = [JSON.stringify(from_), JSON.stringify(to)];
+                const message = `Finished update of '${device.name}'` + (to ? `, from '${fromS}' to '${toS}'` : ``);
+                logger.info(message);
+                const meta = {status: `update_succeeded`, device: device.name, from: from_, to};
+                this.mqtt.log('ota_update', message, meta);
+                this.publishEntityState(device.device.ieeeAddr, {update_available: false});
+            } catch (error) {
+                const message = `Update of '${device.name}' failed (${error.message})`;
+                logger.error(message);
+                this.mqtt.log('ota_update', message, {status: `update_failed`, device: device.name});
+            }
+        }
+
+        this.inProgress.delete(device.device.ieeeAddr);
+    }
+}
+
+module.exports = OTAUpdate;

lib/extension/softReset.js

@@ -9,8 +9,8 @@ const BaseExtension = require('./baseExtension');
  * This extensions soft resets the ZNP after a certain timeout.
  */
 class SoftReset extends BaseExtension {
-    constructor(zigbee, mqtt, state, publishEntityState) {
-        super(zigbee, mqtt, state, publishEntityState);
+    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus);
         this.timer = null;
         this.timeout = utils.secondsToMilliseconds(settings.get().advanced.soft_reset_timeout);
     }

lib/mqtt.js

@@ -22,6 +22,11 @@ class MQTT extends events.EventEmitter {
             },
         };
 
+        if (mqttSettings.keepalive) {
+            logger.debug(`Using MQTT keepalive: ${mqttSettings.keepalive}`);
+            options.keepalive = mqttSettings.keepalive;
+        }
+
         if (mqttSettings.ca) {
             logger.debug(`MQTT SSL/TLS: Path to CA certificate = ${mqttSettings.ca}`);
             options.ca = fs.readFileSync(mqttSettings.ca);

lib/util/logger.js

@@ -6,6 +6,7 @@ const fs = require('fs');
 const fx = require('mkdir-recursive');
 const rimraf = require('rimraf');
 const colorizer = winston.format.colorize();
+const assert = require('assert');
 
 // What transports to enable
 const output = settings.get().advanced.log_output;
@@ -13,6 +14,7 @@ const output = settings.get().advanced.log_output;
 // Directory to log to
 const timestamp = moment(Date.now()).format('YYYY-MM-DD.HH-mm-ss');
 const directory = settings.get().advanced.log_directory.replace('%TIMESTAMP%', timestamp);
+const logFilename = settings.get().advanced.log_file.replace('%TIMESTAMP%', timestamp);
 
 // Make sure that log directoy exsists when not logging to stdout only
 if (output.includes('file')) {
@@ -21,6 +23,8 @@ if (output.includes('file')) {
 
 // Determine the log level.
 const level = settings.get().advanced.log_level;
+const validLevels = ['info', 'error', 'warn', 'debug'];
+assert(validLevels.includes(level), `'${level}' is not a valid log_level, use one of '${validLevels.join(', ')}'`);
 
 const levelWithCompensatedLength = {
     'info': 'info ',
@@ -52,9 +56,10 @@ const transportsToUse = [
 // NOTE: the initiation of the logger, even when not added as transport tries to create the logging directory
 if (output.includes('file')) {
     transportsToUse.push(new winston.transports.File({
-        filename: path.join(directory, 'log.txt'),
+        filename: path.join(directory, logFilename),
         json: false,
         level,
+        tailable: true,
         maxFiles: 3, // Keep last 3 files
         maxsize: 10000000, // 10MB
         format: winston.format.combine(
@@ -98,9 +103,9 @@ logger.setLevel = (level) => {
 // Print to user what logging is enabled
 if (output.includes('file')) {
     if (output.includes('console')) {
-        logger.info(`Logging to console and directory: '${directory}'`);
+        logger.info(`Logging to console and directory: '${directory}' filename: ${logFilename}`);
     } else {
-        logger.info(`Logging to directory: '${directory}'`);
+        logger.info(`Logging to directory: '${directory}' filename: ${logFilename}`);
     }
     logger.cleanup();
 } else if (output.includes('console')) {

lib/util/settings.js

@@ -1,6 +1,6 @@
 const data = require('./data');
 const utils = require('./utils');
-const file = data.joinPath('configuration.yaml');
+const file = process.env.ZIGBEE2MQTT_CONFIG || data.joinPath('configuration.yaml');
 const objectAssignDeep = require(`object-assign-deep`);
 const path = require('path');
 const yaml = require('./yaml');
@@ -39,12 +39,13 @@ const defaults = {
         },
     },
     experimental: {
-        // json or attribute
+        // json or attribute or attribute_and_json
         output: 'json',
     },
     advanced: {
         log_output: ['console', 'file'],
         log_directory: path.join(data.getPath(), 'log', '%TIMESTAMP%'),
+        log_file: 'log.txt',
         log_level: /* istanbul ignore next */ process.env.DEBUG ? 'debug' : 'info',
         soft_reset_timeout: 0,
         pan_id: 0x1a62,
@@ -121,6 +122,7 @@ const schema = {
             properties: {
                 base_topic: {type: 'string'},
                 server: {type: 'string'},
+                keepalive: {type: 'number'},
                 ca: {type: 'string'},
                 key: {type: 'string'},
                 cert: {type: 'string'},
@@ -157,6 +159,7 @@ const schema = {
                 log_level: {type: 'string', enum: ['info', 'warn', 'error', 'debug']},
                 log_output: {type: 'array', items: {type: 'string'}},
                 log_directory: {type: 'string'},
+                log_file: {type: 'string'},
                 baudrate: {type: 'number'},
                 rtscts: {type: 'boolean'},
                 soft_reset_timeout: {type: 'number', minimum: 0},
@@ -597,9 +600,15 @@ function changeFriendlyName(IDorName, newName) {
         throw new Error(`friendly_name '${newName}' is already in use`);
     }
 
-    const device = getDeviceThrowIfNotExists(IDorName);
     const settings = get();
-    settings.devices[device.ID].friendly_name = newName;
+    if (getDevice(IDorName)) {
+        settings.devices[getDevice(IDorName).ID].friendly_name = newName;
+    } else if (getGroup(IDorName)) {
+        settings.groups[getGroup(IDorName).ID].friendly_name = newName;
+    } else {
+        throw new Error(`Device or group '${IDorName}' does not exist`);
+    }
+
     write();
 }
 

lib/util/utils.js

@@ -28,9 +28,9 @@ function toLocalISOString(dDate) {
 }
 
 const postfixes = [
-    'left', 'right', 'center', 'bottom_left', 'bottom_right', 'l1', 'l2', 'default',
+    'left', 'right', 'center', 'bottom_left', 'bottom_right', 'l1', 'l2', 'l3', 'l4', 'default',
     'top_left', 'top_right', 'white', 'rgb', 'system', 'top', 'bottom', 'center_left', 'center_right',
-    'ep1', 'ep2',
+    'ep1', 'ep2', 'row_1', 'row_2', 'row_3', 'row_4', 'relay',
 ];
 
 function flatten(arr) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee2mqtt",
-  "version": "1.8.0",
+  "version": "1.11.0",
   "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
   "main": "index.js",
   "repository": {
@@ -45,8 +45,8 @@
     "rimraf": "*",
     "semver": "*",
     "winston": "*",
-    "zigbee-herdsman": "0.12.19",
-    "zigbee-herdsman-converters": "11.1.61"
+    "zigbee-herdsman": "0.12.55",
+    "zigbee-herdsman-converters": "12.0.32"
   },
   "devDependencies": {
     "eslint": "*",

scripts/install.sh

@@ -26,7 +26,7 @@ chown -R pi:pi /opt/zigbee2mqtt
 
 echo "Running install. This might take a while and can produce som expected errors"
 cd /opt/zigbee2mqtt || exit
-su pi -c "npm install"
+su pi -c "npm ci"
 
 echo "Creating service file zigbee2mqtt.service"
 service_path="/etc/systemd/system/zigbee2mqtt.service"
@@ -70,4 +70,4 @@ fi
 return 0
 }
 
-[[ "$_" == "$0" ]] && zigbee2mqtt-install-package 
+[[ "$_" == "$0" ]] && zigbee2mqtt-install-package

test/bridgeConfig.test.js

@@ -162,7 +162,7 @@ describe('Bridge config', () => {
         const payload = JSON.parse(MQTT.publish.mock.calls[0][1]);
         expect(payload.length).toStrictEqual(Object.values(zigbeeHerdsman.devices).length);
         expect(payload[0]).toStrictEqual({"ieeeAddr": "0x00124b00120144ae", "type": "Coordinator", "dateCode": "20190425", "friendly_name": "Coordinator", networkAddress: 0, softwareBuildID: "z-Stack", lastSeen: 100});
-        expect(payload[1]).toStrictEqual({"friendly_name": "bulb", "ieeeAddr": "0x000b57fffec6a5b2", "lastSeen": 1000, "manufacturerID": 4476, "model": "LED1545G12", "modelID": "TRADFRI bulb E27 WS opal 980lm", "networkAddress": 40369, "powerSource": "Mains (single phase)", "type": "Router"});
+        expect(payload[1]).toStrictEqual({"dateCode": null, "friendly_name": "bulb", "ieeeAddr": "0x000b57fffec6a5b2", "lastSeen": 1000, "manufacturerID": 4476, "model": "LED1545G12", "modelID": "TRADFRI bulb E27 WS opal 980lm", "networkAddress": 40369, "powerSource": "Mains (single phase)", "type": "Router"});
         Date.now = now;
     });
 
@@ -203,6 +203,20 @@ describe('Bridge config', () => {
         expect(settings.getDevice('bulb_color2')).toStrictEqual(bulb_color2);
     });
 
+    it('Should allow rename groups', async () => {
+        MQTT.publish.mockClear();
+        expect(settings.getGroup(1)).toStrictEqual({"ID": 1, devices: [], friendlyName: "group_1", "friendly_name": "group_1", optimistic: true, retain: false});
+        MQTT.events.message('zigbee2mqtt/bridge/config/rename', JSON.stringify({old: 'group_1', new: 'group_1_renamed'}));
+        await flushPromises();
+        expect(settings.getGroup(1)).toStrictEqual({"ID": 1, devices: [], friendlyName: "group_1_renamed", "friendly_name": "group_1_renamed", optimistic: true, retain: false});
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'zigbee2mqtt/bridge/log',
+            JSON.stringify({type: 'group_renamed', message: {from: 'group_1', to: 'group_1_renamed'}}),
+            {qos: 0, retain: false},
+            expect.any(Function)
+        );
+    });
+
     it('Should allow to rename last joined device', async () => {
         const device = zigbeeHerdsman.devices.bulb;
         const payload = {device};
@@ -267,10 +281,11 @@ describe('Bridge config', () => {
     });
 
     it('Should allow to remove groups', async () => {
-        settings.addGroup('to_be_removed')
-        MQTT.events.message('zigbee2mqtt/bridge/config/remove_group', 'to_be_removed');
+        const group = zigbeeHerdsman.groups.group_1;
+        MQTT.events.message('zigbee2mqtt/bridge/config/remove_group', 'group_1');
         await flushPromises();
         expect(settings.getGroup('to_be_removed')).toStrictEqual(null);
+        expect(group.removeFromDatabase).toHaveBeenCalledTimes(1);
     });
 
     it('Shouldnt allow add groups without id or friendly_name in json', async () => {
@@ -368,8 +383,9 @@ describe('Bridge config', () => {
         MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'bulb_color');
         await flushPromises();
         expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
         expect(settings.getDevice('bulb_color')).toStrictEqual({"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": false})
-        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
     });
 
     it('Should handle when ban fails', async () => {
@@ -381,8 +397,9 @@ describe('Bridge config', () => {
         MQTT.events.message('zigbee2mqtt/bridge/config/ban', 'bulb_color');
         await flushPromises();
         expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
         expect(settings.getDevice('bulb_color')).toStrictEqual({"ID": "0x000b57fffec6a5b3", "friendlyName": "bulb_color", "friendly_name": "bulb_color", "retain": false})
-        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
     });
 
     it('Should allow to touchlink factory reset (OK)', async () => {
@@ -392,7 +409,7 @@ describe('Bridge config', () => {
         MQTT.events.message('zigbee2mqtt/bridge/config/touchlink/factory_reset', '');
         await flushPromises();
         expect(zigbeeHerdsman.touchlinkFactoryReset).toHaveBeenCalledTimes(1);
-        expect(logger.info).toHaveBeenCalledWith('Succesfully factory reset device through Touchlink');
+        expect(logger.info).toHaveBeenCalledWith('Successfully factory reset device through Touchlink');
     });
 
     it('Should allow to touchlink factory reset (FAILS)', async () => {

test/controller.test.js

@@ -57,6 +57,7 @@ describe('Controller', () => {
         const configuration = {
             base_topic: "zigbee2mqtt",
             server: "mqtt://localhost",
+            keepalive: 30,
             ca, cert, key,
             password: 'pass',
             user: 'user1',
@@ -69,6 +70,7 @@ describe('Controller', () => {
         expect(MQTT.connect).toHaveBeenCalledTimes(1);
         const expected = {
             "will": {"payload": "offline", "retain": true, "topic": "zigbee2mqtt/bridge/state"},
+            keepalive: 30,
             ca: Buffer.from([99, 97]),
             key: Buffer.from([107, 101, 121]),
             cert: Buffer.from([99, 101, 114, 116]),
@@ -397,18 +399,32 @@ describe('Controller', () => {
         expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/dummy-2", 'no', {"qos": 0, "retain": true}, expect.any(Function));
     });
 
+    it('Publish entity state attribute_json output', async () => {
+        await controller.start();
+        settings.set(['experimental', 'output'], 'attribute_and_json');
+        MQTT.publish.mockClear();
+        await controller.publishEntityState('bulb', {state: 'ON', brightness: 200, color_temp: 370, linkquality: 99});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(5);
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/state", "ON", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/brightness", "200", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/color_temp", "370", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb/linkquality", "99", {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith("zigbee2mqtt/bulb", '{"state":"ON","brightness":200,"color_temp":370,"linkquality":99}', {"qos": 0, "retain": true}, expect.any(Function));
+    });
+
     it('Publish entity state with device information', async () => {
         await controller.start();
         settings.set(['mqtt', 'include_device_information'], true);
         MQTT.publish.mockClear();
         await controller.publishEntityState('bulb', {state: 'ON'});
         await flushPromises();
-        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bulb', '{"state":"ON","brightness":50,"color_temp":370,"linkquality":99,"device":{"friendlyName":"bulb","model":"LED1545G12","ieeeAddr":"0x000b57fffec6a5b2","networkAddress":40369,"type":"Router","manufacturerID":4476,"powerSource":"Mains (single phase)"}}', {"qos": 0, "retain": true}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/bulb', '{"state":"ON","brightness":50,"color_temp":370,"linkquality":99,"device":{"friendlyName":"bulb","model":"LED1545G12","ieeeAddr":"0x000b57fffec6a5b2","networkAddress":40369,"type":"Router","manufacturerID":4476,"powerSource":"Mains (single phase)","dateCode":null}}', {"qos": 0, "retain": true}, expect.any(Function));
 
         // Unsupported device should have model "unknown"
         await controller.publishEntityState('unsupported2', {state: 'ON'});
         await flushPromises();
-        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/unsupported2', '{"state":"ON","device":{"friendlyName":"unsupported2","model":"unknown","ieeeAddr":"0x0017880104e45529","networkAddress":6536,"type":"EndDevice","manufacturerID":0,"powerSource":"Battery"}}', {"qos": 0, "retain": false}, expect.any(Function));
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/unsupported2', '{"state":"ON","device":{"friendlyName":"unsupported2","model":"unknown","ieeeAddr":"0x0017880104e45529","networkAddress":6536,"type":"EndDevice","manufacturerID":0,"powerSource":"Battery","dateCode":null}}', {"qos": 0, "retain": false}, expect.any(Function));
     });
 
     it('Publish entity state no empty messages', async () => {

test/deviceAvailability.test.js

@@ -197,9 +197,23 @@ describe('Device availability', () => {
         expect(MQTT.publish.mock.calls.find((c) => c[0].includes('availability'))).toBeUndefined();
     });
 
-    it('Should not ping blacklisted devices', async () => {
+    it('Should not ping devices blacklisted by friendly name', async () => {
         const device = zigbeeHerdsman.devices.bulb_color;
-        settings.set(['advanced', 'availability_blacklist'], [device.ieeeAddr])
+        settings.set(['advanced', 'availability_blacklist'], ['bulb_color'])
+        await controller.stop();
+        await flushPromises();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        device.ping.mockClear();
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(device.ping).toHaveBeenCalledTimes(0);
+    });
+
+    it('Should not ping devices blacklisted by IEEE address', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['advanced', 'availability_blacklist'], [device.ieeeAddr]);
         await controller.stop();
         await flushPromises();
         controller = new Controller();
@@ -224,9 +238,23 @@ describe('Device availability', () => {
         expect(device.ping).toHaveBeenCalledTimes(1);
     });
 
-    it('Should ping whitelisted devices if availability_whitelist is set', async () => {
+    it('Should ping devices whitelisted by friendly name if availability_whitelist is set', async () => {
         const device = zigbeeHerdsman.devices.bulb_color;
-        settings.set(['advanced', 'availability_whitelist'], [device.ieeeAddr])
+        settings.set(['advanced', 'availability_whitelist'], ['bulb_color']);
+        await controller.stop();
+        await flushPromises();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        device.ping.mockClear();
+        jest.advanceTimersByTime(11 * 1000);
+        await flushPromises();
+        expect(device.ping).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should ping devices whitelisted by IEEE address if availability_whitelist is set', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        settings.set(['advanced', 'availability_whitelist'], [device.ieeeAddr]);
         await controller.stop();
         await flushPromises();
         controller = new Controller();

test/deviceBind.test.js

@@ -15,6 +15,7 @@ describe('Device bind', () => {
             endpoint.write.mockClear();
             endpoint.configureReporting.mockClear();
             endpoint.bind.mockClear();
+            endpoint.unbind.mockClear();
         }
     }
 
@@ -171,4 +172,24 @@ describe('Device bind', () => {
         expect(endpoint.bind).toHaveBeenCalledTimes(1);
         expect(endpoint.bind).toHaveBeenCalledWith("genOnOff", target);
     });
+
+    it('Should unbind from default_bind_group', async () => {
+        const device = zigbeeHerdsman.devices.remote;
+        const target = 'default_bind_group';
+        const endpoint = device.getEndpoint(1);
+        mockClear(device);
+        MQTT.events.message('zigbee2mqtt/bridge/unbind/remote', target);
+        await flushPromises();
+        expect(endpoint.unbind).toHaveBeenCalledTimes(3);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genOnOff", 901);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genLevelCtrl", 901);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genScenes", 901);
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'default_bind_group', cluster: 'genScenes'}});
+        expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'default_bind_group', cluster: 'genOnOff'}});
+        expect(MQTT.publish.mock.calls[2][0]).toStrictEqual('zigbee2mqtt/bridge/log');
+        expect(JSON.parse(MQTT.publish.mock.calls[2][1])).toStrictEqual({type: 'device_unbind', message: {from: 'remote', to: 'default_bind_group', cluster: 'genLevelCtrl'}});
+    });
 });

test/deviceConfigure.test.js

@@ -105,6 +105,12 @@ describe('Device configure', () => {
         expect(logger.error).toHaveBeenCalledWith(`Device 'remote_random_non_existing' does not exist`);
     });
 
+    it('Should skip reconfigure when device does not require this', async () => {
+        await MQTT.events.message('zigbee2mqtt/bridge/configure', 'bulb');
+        await flushPromises();
+        expect(logger.warn).toHaveBeenCalledWith(`Skipping configure of 'bulb', device does not require this.`)
+    });
+
     it('Should not configure when interviewing', async () => {
         const device = zigbeeHerdsman.devices.remote;
         delete device.meta.configured;

test/deviceEvent.test.js

@@ -15,6 +15,7 @@ const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const mockOnEvent = jest.fn();
 const mappedLivolo = zigbeeHerdsmanConverters.findByZigbeeModel(zigbeeHerdsman.devices.LIVOLO.modelID);
 mappedLivolo.onEvent = mockOnEvent;
+zigbeeHerdsmanConverters.onEvent = jest.fn();
 
 describe('Device event', () => {
     let controller;
@@ -27,6 +28,7 @@ describe('Device event', () => {
         controller = new Controller();
         await controller.start();
         mocksClear.forEach((m) => m.mockClear());
+        zigbeeHerdsmanConverters.onEvent.mockClear();
         await flushPromises();
     });
 
@@ -59,4 +61,15 @@ describe('Device event', () => {
         expect(call[1]).toStrictEqual({device})
         expect(call[2]).toBe(device);
     });
+
+    it('Should call index onEvent with zigbee event', async () => {
+        zigbeeHerdsmanConverters.onEvent.mockClear();
+        await zigbeeHerdsman.events.deviceAnnounce({device});
+        await flushPromises();
+        expect(zigbeeHerdsmanConverters.onEvent).toHaveBeenCalledTimes(1);
+        const call = zigbeeHerdsmanConverters.onEvent.mock.calls[0];
+        expect(call[0]).toBe('deviceAnnounce')
+        expect(call[1]).toStrictEqual({device})
+        expect(call[2]).toBe(device);
+    });
 });

test/deviceReceive.test.js

@@ -186,6 +186,25 @@ describe('Device receive', () => {
         expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
     });
 
+    it('WSDCGQ11LM pressure precision from non ZCL properties', async () => {
+        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
+        settings.set(['devices', device.ieeeAddr, 'temperature_precision'], 1);
+
+        MQTT.publish.mockClear();
+        let payload = {data: {"65281":{"1":2985,"4":5032,"5":9,"6":[0,1],"10":0,"100":2345,"101":4608,"102":91552}}, cluster: 'genBasic', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({"battery":91,"voltage":2985,"temperature":23.5,"humidity":46.08,"pressure":915.5,"linkquality":10});
+
+        MQTT.publish.mockClear();
+        payload = {data: {"16":9354,"20":-1,"measuredValue":915}, cluster: 'msPressureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({"battery":91,"voltage":2985,"temperature":23.5,"humidity":46.08,"pressure":935.4,"linkquality":10});
+    });
+
     it('Should handle a zigbee message with voltage 3010', async () => {
         const device = zigbeeHerdsman.devices.WXKG02LM;
         const data = {'65281': {'1': 3010}}
@@ -242,7 +261,7 @@ describe('Device receive', () => {
         await flushPromises();
         expect(MQTT.publish).toHaveBeenCalledTimes(1);
         expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/occupancy_sensor');
-        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({'battery': 100, 'illuminance': 381, 'voltage': 3045, linkquality: 10});
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({'battery': 100, 'illuminance': 381, "illuminance_lux": 381, 'voltage': 3045, linkquality: 10});
         expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
     });
 
@@ -385,29 +404,27 @@ describe('Device receive', () => {
         await zigbeeHerdsman.events.message(payload);
         await flushPromises();
         expect(MQTT.publish).toHaveBeenCalledTimes(0);
-        expect(logger.warn).toHaveBeenCalledWith('No converter available for \'ZNCZ02LM\' with cluster \'genBinaryOutput\' and type \'attributeReport\' and data \'{"inactiveText":"hello"}\'');
+        expect(logger.debug).toHaveBeenCalledWith('No converter available for \'ZNCZ02LM\' with cluster \'genBinaryOutput\' and type \'attributeReport\' and data \'{"inactiveText":"hello"}\'');
     });
 
-    it('Should not log when message is from supported device but has no converters is readResponse', async () => {
-        const device = zigbeeHerdsman.devices.ZNCZ02LM;
-        const data = {inactiveText: 'hello'};
-        const payload = {data, cluster: 'genBinaryOutput', device, endpoint: device.getEndpoint(1), type: 'readResponse', linkquality: 20};
-        await zigbeeHerdsman.events.message(payload);
-        await flushPromises();
-        expect(MQTT.publish).toHaveBeenCalledTimes(0);
-        expect(logger.warn).toBeCalledTimes(0);
-    });
+    it('Should report correct energy and power values for different versions of SP600', async () => {
+        // https://github.com/Koenkk/zigbee-herdsman-converters/issues/915, OLD and NEW use different date code
+        // divisor of OLD is not correct and therefore underreports by factor 10.
+        const data = {instantaneousDemand:496,currentSummDelivered:[0,6648]}
 
-    it('Should allow to calibrate temperature values', async () => {
-        const device = zigbeeHerdsman.devices.WSDCGQ11LM;
-        settings.set(['devices', device.ieeeAddr, 'temperature_calibration'], 2);
-        const data = {measuredValue: -85}
-        const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
-        await zigbeeHerdsman.events.message(payload);
+        const SP600_NEW = zigbeeHerdsman.devices.SP600_NEW;
+        await zigbeeHerdsman.events.message({data, cluster: 'seMetering', device: SP600_NEW, endpoint: SP600_NEW.getEndpoint(1), type: 'attributeReport', linkquality: 10});
         await flushPromises();
         expect(MQTT.publish).toHaveBeenCalledTimes(1);
-        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/weather_sensor');
-        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({temperature: 1.15, linkquality: 10});
-        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 1, "retain": false});
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/SP600_NEW');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({energy: 0.66, power: 49.6, linkquality: 10});
+
+        MQTT.publish.mockClear();
+        const SP600_OLD = zigbeeHerdsman.devices.SP600_OLD;
+        await zigbeeHerdsman.events.message({data, cluster: 'seMetering', device: SP600_OLD, endpoint: SP600_OLD.getEndpoint(1), type: 'attributeReport', linkquality: 10});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/SP600_OLD');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({energy: 6.648, power: 496, linkquality: 10});
     });
 });

test/deviceReport.test.js

@@ -8,6 +8,7 @@ zigbeeHerdsman.returnDevices.push('0x0017880104e45553');
 zigbeeHerdsman.returnDevices.push('0x0017880104e45559');
 zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b4');
 zigbeeHerdsman.returnDevices.push('0x000b57fffec6a5b7');
+zigbeeHerdsman.returnDevices.push('0x90fd9ffffe4b64ax');
 const MQTT = require('./stub/mqtt');
 const settings = require('../lib/util/settings');
 const Controller = require('../lib/controller');
@@ -197,4 +198,17 @@ describe('Device report', () => {
         // Should only call Hue bulb, not e.g. tradfri
         expect(zigbeeHerdsman.devices.bulb.getEndpoint(1).read).toHaveBeenCalledTimes(0);
     });
+
+    it('Should not configure reporting for the ZNLDP12LM closuresWindowCovering as it is ignored', async () => {
+        const device = zigbeeHerdsman.devices.ZNLDP12LM;
+        const coordinatorEndpoint = zigbeeHerdsman.devices.coordinator.getEndpoint(1);
+        const endpoint = device.getEndpoint(1);
+        delete device.meta.reporting;
+        await flushPromises();
+        expect(endpoint.bind).toHaveBeenCalledTimes(3);
+        expect(endpoint.bind).toHaveBeenCalledWith('genOnOff', coordinatorEndpoint);
+        expect(endpoint.bind).toHaveBeenCalledWith('genLevelCtrl', coordinatorEndpoint);
+        expect(endpoint.bind).toHaveBeenCalledWith('lightingColorCtrl', coordinatorEndpoint);
+        expect(endpoint.configureReporting).toHaveBeenCalledTimes(3);
+    });
 });

test/entityPublish.test.js

@@ -662,14 +662,16 @@ describe('Entity publish', () => {
     });
 
     it('Should allow to set color via hue and saturation', async () => {
-        const device = zigbeeHerdsman.devices.bulb_color_2;
+        const device = zigbeeHerdsman.devices.bulb_color;
         const endpoint = device.getEndpoint(1);
         const payload = {"color":{"hue":250, "saturation":50}};
-        await MQTT.events.message('zigbee2mqtt/bulb_color_2/set', JSON.stringify(payload));
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
         expect(endpoint.command.mock.calls[0]).toEqual(["lightingColorCtrl", "enhancedMoveToHueAndSaturation", {"direction": 0, "enhancehue": 45510.416666666664, "saturation": 127, "transtime": 0,}, {}]);
-        expect(MQTT.publish).toHaveBeenCalledTimes(0);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({"color":{"hue":250,"saturation":50}});
     });
 
     it('ZNCLDJ11LM open', async () => {
@@ -716,11 +718,21 @@ describe('Entity publish', () => {
     it('Should turn device on with on/off when transition is provided', async () => {
         const device = zigbeeHerdsman.devices.bulb_color;
         const endpoint = device.getEndpoint(1);
-        const payload = {state: 'ON', transition: 1};
+        const payload = {state: 'ON', transition: 3};
         await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "on", {}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 255, transtime: 30}, {}]);
+    });
+
+    it('Should turn device on with on/off with transition when transition 0 is provided', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {state: 'ON', transition: 0};
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 255, transtime: 0}, {}]);
     });
 
     it('Should turn device off with onOff on off with transition', async () => {
@@ -730,12 +742,44 @@ describe('Entity publish', () => {
         await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command.mock.calls[0]).toEqual(["genOnOff", "off", {}, {}]);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 10}, {}]);
         expect(MQTT.publish).toHaveBeenCalledTimes(1);
         expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/bulb_color');
         expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state: 'OFF'});
     });
 
+    it('When device is turned off and on with transition with report enabled it should restore correct brightness', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        // Set initial brightness in state
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness: 200}));
+        await flushPromises();
+        endpoint.command.mockClear();
+        MQTT.publish.mockClear();
+
+        // Turn off
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'OFF', transition: 3}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command.mock.calls[0]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 0, transtime: 30}, {}]);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0]).toEqual(["zigbee2mqtt/bulb_color", JSON.stringify({state: 'OFF', brightness: 200}), {"qos": 0, "retain": false}, expect.any(Function)]);
+
+        // Bulb reports brightness while decreasing brightness
+        await zigbeeHerdsman.events.message({data: {currentLevel: 1}, cluster: 'genLevelCtrl', device, endpoint, type: 'attributeReport', linkquality: 10});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(2);
+        expect(MQTT.publish.mock.calls[1]).toEqual(["zigbee2mqtt/bulb_color", JSON.stringify({state: 'OFF', brightness: 1, linkquality: 10}), {"qos": 0, "retain": false}, expect.any(Function)]);
+
+        // Turn on again
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({state: 'ON', transition: 3}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(2);
+        expect(endpoint.command.mock.calls[1]).toEqual(["genLevelCtrl", "moveToLevelWithOnOff", {level: 200, transtime: 30}, {}]);
+        expect(MQTT.publish).toHaveBeenCalledTimes(3);
+        expect(MQTT.publish.mock.calls[2]).toEqual(["zigbee2mqtt/bulb_color", JSON.stringify({state: 'ON', brightness: 200, linkquality: 10}), {"qos": 0, "retain": false}, expect.any(Function)]);
+    });
+
     it('Home Assistant: should set state', async () => {
         settings.set(['homeassistant'], true);
         const device = zigbeeHerdsman.devices.bulb_color;
@@ -846,13 +890,29 @@ describe('Entity publish', () => {
         expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
     });
 
+    it('Should publish brightness_move up to zigbee devices', async () => {
+        const endpoint = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness_move: -40}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "move", {"movemode": 1, "rate": 40}, {});
+    });
+
+    it('Should publish brightness_move down to zigbee devices', async () => {
+        const endpoint = zigbeeHerdsman.devices.bulb_color.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/bulb_color/set', JSON.stringify({brightness_move: 30}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("genLevelCtrl", "move", {"movemode": 0, "rate": 30}, {});
+    });
+
     it('HS2WD-E burglar warning', async () => {
         const endpoint = zigbeeHerdsman.devices.HS2WD.getEndpoint(1);
         const payload = {warning: {duration: 100, mode: 'burglar', strobe: true, level: 'high'}};
         await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 22, "warningduration": 100}, {});
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 22, "warningduration": 100}, {disableDefaultResponse: true});
     });
 
     it('HS2WD-E emergency warning', async () => {
@@ -861,7 +921,7 @@ describe('Entity publish', () => {
         await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 51, "warningduration": 10}, {});
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 51, "warningduration": 10}, {disableDefaultResponse: true});
     });
 
     it('HS2WD-E emergency without level', async () => {
@@ -870,7 +930,7 @@ describe('Entity publish', () => {
         await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 49, "warningduration": 10}, {});
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 49, "warningduration": 10}, {disableDefaultResponse: true});
     });
 
     it('HS2WD-E wrong payload (should use defaults)', async () => {
@@ -879,7 +939,7 @@ describe('Entity publish', () => {
         await MQTT.events.message('zigbee2mqtt/siren/set', JSON.stringify(payload));
         await flushPromises();
         expect(endpoint.command).toHaveBeenCalledTimes(1);
-        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 53, "warningduration": 10}, {});
+        expect(endpoint.command).toHaveBeenCalledWith("ssIasWd", "startWarning", {"startwarninginfo": 53, "warningduration": 10}, {disableDefaultResponse: true});
     });
 
     it('Shouldnt do anythign when device is not supported', async () => {
@@ -900,4 +960,45 @@ describe('Entity publish', () => {
         expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({position: 100});
         expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
     });
+
+    it('Should publish to MKS-CM-W5', async () => {
+        const device = zigbeeHerdsman.devices['MKS-CM-W5'];
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/MKS-CM-W5/l3/set', JSON.stringify({state: 'ON'}));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(1);
+        expect(endpoint.command).toHaveBeenCalledWith("manuSpecificTuyaDimmer", "setData", {data: [1,1], dp: 259, fn: 0, status: 0, transid: 16}, {disableDefaultResponse: true});
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/MKS-CM-W5');
+        expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({state_l3: 'ON'});
+        expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
+    });
+
+    it('Should publish separate genOnOff to GL-S-007ZS when setting state and brightness as bulb doesnt turn on with moveToLevelWithOnOff', async () => {
+        // https://github.com/Koenkk/zigbee2mqtt/issues/2757
+        jest.useFakeTimers();
+        const device = zigbeeHerdsman.devices['GL-S-007ZS'];
+        const endpoint = device.getEndpoint(1);
+        await MQTT.events.message('zigbee2mqtt/GL-S-007ZS/set', JSON.stringify({state: 'ON', brightness: 20}));
+        await flushPromises();
+        jest.runAllTimers();
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(2);
+        expect(endpoint.command.mock.calls[0]).toEqual([ 'genOnOff', 'on', {}, {} ]);
+        expect(endpoint.command.mock.calls[1]).toEqual([ 'genLevelCtrl', 'moveToLevelWithOnOff', { level: 20, transtime: 0 }, {} ]);
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+        expect(MQTT.publish.mock.calls[0]).toEqual([ 'zigbee2mqtt/GL-S-007ZS', '{"state":"ON","brightness":20}', { qos: 0, retain: false }, expect.any(Function)]);
+        jest.useRealTimers();
+    });
+
+    it('Should log as error when setting property with no defined converter', async () => {
+        const device = zigbeeHerdsman.devices.bulb_color;
+        const endpoint = device.getEndpoint(1);
+        const payload = {'brightness_move': 20};
+        logger.error.mockClear();
+        await MQTT.events.message('zigbee2mqtt/bulb_color/get', JSON.stringify(payload));
+        await flushPromises();
+        expect(endpoint.command).toHaveBeenCalledTimes(0);
+        expect(logger.error).toHaveBeenCalledWith("No converter available for 'get' 'brightness_move' (20)");
+    });
 });

test/homeassistant.test.js

@@ -5,7 +5,6 @@ const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
 const flushPromises = () => new Promise(setImmediate);
 const MQTT = require('./stub/mqtt');
 const Controller = require('../lib/controller');
-const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 describe('HomeAssistant extension', () => {
     beforeEach(async () => {
@@ -22,7 +21,7 @@ describe('HomeAssistant extension', () => {
     it('Should have mapping for all devices supported by zigbee-herdsman-converters', () => {
         const missing = [];
         const HomeAssistant = require('../lib/extension/homeassistant');
-        const ha = new HomeAssistant(null, null, null, null);
+        const ha = new HomeAssistant(null, null, null, null, {on: () => {}});
 
         require('zigbee-herdsman-converters').devices.forEach((d) => {
             if (!ha._getMapping()[d.model]) {
@@ -141,7 +140,8 @@ describe('HomeAssistant extension', () => {
         );
 
         payload = {
-            'unit_of_measurement': '-',
+            'icon': 'mdi:signal',
+            'unit_of_measurement': 'lqi',
             'value_template': '{{ value_json.linkquality }}',
             'state_topic': 'zigbee2mqtt/weather_sensor',
             'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
@@ -637,4 +637,86 @@ describe('HomeAssistant extension', () => {
             expect.any(Function),
         );
     });
+
+    it('Should clear discovery when device is removed', async () => {
+        controller = new Controller(false);
+        await controller.start();
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'weather_sensor');
+        await flushPromises();
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/temperature/config',
+            null,
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/humidity/config',
+            null,
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/pressure/config',
+            null,
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/battery/config',
+            null,
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/sensor/0x0017880104e45522/linkquality/config',
+            null,
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
+
+    it('Should not clear discovery when unsupported device is removed', async () => {
+        controller = new Controller(false);
+        await controller.start();
+        await flushPromises();
+        MQTT.publish.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'unsupported2');
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should discover update_available sensor when device supports it', async () => {
+        controller = new Controller(false);
+        await controller.start();
+        await flushPromises();
+        const payload = {
+            "payload_on":true,
+            "payload_off":false,
+            "value_template":"{{ value_json.update_available}}",
+            "state_topic":"zigbee2mqtt/bulb",
+            "json_attributes_topic":"zigbee2mqtt/bulb",
+            "name":"bulb_update_available",
+            "unique_id":"0x000b57fffec6a5b2_update_available_zigbee2mqtt",
+            "device":{
+                "identifiers":[
+                    "zigbee2mqtt_0x000b57fffec6a5b2"
+                ],
+                "name":"bulb",
+                'sw_version': this.version,
+                "model":"TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white (LED1545G12)",
+                "manufacturer":"IKEA"
+            },
+            "availability_topic":"zigbee2mqtt/bridge/state"
+        };
+
+        expect(MQTT.publish).toHaveBeenCalledWith(
+            'homeassistant/binary_sensor/0x000b57fffec6a5b2/update_available/config',
+            JSON.stringify(payload),
+            { retain: true, qos: 0 },
+            expect.any(Function),
+        );
+    });
 });

test/otaUpdate.test.js

@@ -0,0 +1,192 @@
+const data = require('./stub/data');
+const logger = require('./stub/logger');
+const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
+const MQTT = require('./stub/mqtt');
+const settings = require('../lib/util/settings');
+const Controller = require('../lib/controller');
+const flushPromises = () => new Promise(setImmediate);
+const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
+
+describe('OTA update', () => {
+    let controller;
+
+    mockClear = (mapped) => {
+        mapped.ota.updateToLatest = jest.fn();
+        mapped.ota.isUpdateAvailable = jest.fn();
+    }
+
+    beforeEach(async () => {
+        data.writeDefaultConfiguration();
+        settings._reRead();
+        data.writeEmptyState();
+        controller = new Controller();
+        await controller.start();
+        await flushPromises();
+        MQTT.publish.mockClear();
+    });
+
+    it('Should subscribe to nested topics', async () => {
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/ota_update/check');
+        expect(MQTT.subscribe).toHaveBeenCalledWith('zigbee2mqtt/bridge/ota_update/update');
+    });
+
+    it('Should OTA update a device', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.endpoints[0];
+        let count = 0;
+        endpoint.read.mockImplementation(() => {
+            count++;
+            return {swBuildId: count, dateCode: '2019010' + count}
+        });
+        const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID)
+        mockClear(mapped);
+        logger.info.mockClear();
+        logger.error.mockClear();
+        device.save.mockClear();
+        mapped.ota.updateToLatest.mockImplementationOnce((a, b, onUpdate) => {
+            onUpdate(0, null);
+            onUpdate(10, 3600);
+        });
+
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/update', 'bulb');
+        await flushPromises();
+        expect(logger.info).toHaveBeenCalledWith(`Updating 'bulb' to latest firmware`);
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledTimes(0);
+        expect(mapped.ota.updateToLatest).toHaveBeenCalledTimes(1);
+        expect(mapped.ota.updateToLatest).toHaveBeenCalledWith(device, logger, expect.any(Function));
+        expect(logger.info).toHaveBeenCalledWith(`Update of 'bulb' at 0%`);
+        expect(logger.info).toHaveBeenCalledWith(`Update of 'bulb' at 10%, +- 60 minutes remaining`);
+        expect(logger.info).toHaveBeenCalledWith(`Finished update of 'bulb', from '{"softwareBuildID":1,"dateCode":"20190101"}' to '{"softwareBuildID":2,"dateCode":"20190102"}'`);
+        expect(logger.error).toHaveBeenCalledTimes(0);
+        expect(device.save).toHaveBeenCalledTimes(1);
+        expect(device.dateCode).toBe('20190102');
+        expect(device.softwareBuildID).toBe(2);
+    });
+
+    it('Should handle when OTA update fails', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.endpoints[0];
+        endpoint.read.mockImplementation(() => {return {swBuildId: 1, dateCode: '2019010'}});
+        const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID)
+        mockClear(mapped);
+        logger.info.mockClear();
+        logger.error.mockClear();
+        device.save.mockClear();
+        mapped.ota.updateToLatest.mockImplementationOnce((a, b, onUpdate) => {
+            throw new Error('Update failed');
+        });
+
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/update', 'bulb');
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledTimes(1);
+        expect(logger.error).toHaveBeenCalledWith(`Update of 'bulb' failed (Update failed)`);
+    });
+
+    it('Should be able to check if OTA update is available', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID)
+        mockClear(mapped);
+
+        logger.info.mockClear();
+        mapped.ota.isUpdateAvailable.mockReturnValueOnce(false);
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/check', 'bulb');
+        await flushPromises();
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledTimes(1);
+        expect(mapped.ota.updateToLatest).toHaveBeenCalledTimes(0);
+        expect(logger.info).toHaveBeenCalledWith(`No update available for 'bulb'`);
+
+        logger.info.mockClear();
+        mapped.ota.isUpdateAvailable.mockReturnValueOnce(true);
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/check', 'bulb');
+        await flushPromises();
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledTimes(2);
+        expect(mapped.ota.updateToLatest).toHaveBeenCalledTimes(0);
+        expect(logger.info).toHaveBeenCalledWith(`Update available for 'bulb'`);
+    });
+
+    it('Should handle if OTA update check fails', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID)
+        mockClear(mapped);
+        logger.error.mockClear();
+        mapped.ota.isUpdateAvailable.mockImplementationOnce(() => {throw new Error('RF singals disturbed because of dogs barking')});
+
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/check', 'bulb');
+        await flushPromises();
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledTimes(1);
+        expect(mapped.ota.updateToLatest).toHaveBeenCalledTimes(0);
+        expect(logger.error).toHaveBeenCalledWith(`Failed to check if update available for 'bulb' (RF singals disturbed because of dogs barking)`);
+    });
+
+    it('Should not check for OTA when device does not support it', async () => {
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/check', 'bulb_color_2');
+        await flushPromises();
+        expect(logger.error).toHaveBeenCalledWith(`Device 'bulb_color_2' does not support OTA updates`);
+    });
+
+    it('Should refuse to check/update when already in progress', async () => {
+        jest.useFakeTimers();
+        const device = zigbeeHerdsman.devices.bulb;
+        const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID)
+        mockClear(mapped);
+
+        logger.info.mockClear();
+        mapped.ota.isUpdateAvailable.mockImplementationOnce(() => {
+            return new Promise((resolve, reject) => {setTimeout(() => resolve(), 99999)})
+        });
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/check', 'bulb');
+        await flushPromises();
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/check', 'bulb');
+        await flushPromises();
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledTimes(1);
+        expect(logger.error).toHaveBeenCalledWith(`Update or check already in progress for 'bulb', skipping...`);
+        jest.runAllTimers();
+        await flushPromises();
+    });
+
+    it('Shouldnt crash when read modelID after OTA update fails', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const endpoint = device.endpoints[0];
+        let count = 0;
+        endpoint.read.mockImplementation(() => {
+            if (count === 1) throw new Error('Failed!')
+            count++;
+            return {swBuildId: 1, dateCode: '2019010'}
+        });
+
+        const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID)
+        mockClear(mapped);
+        logger.info.mockClear();
+        MQTT.events.message('zigbee2mqtt/bridge/ota_update/update', 'bulb');
+        await flushPromises();
+        expect(logger.info).toHaveBeenCalledWith(`Finished update of 'bulb'`);
+    });
+
+    it('Should check for update when device requests it', async () => {
+        const device = zigbeeHerdsman.devices.bulb;
+        const data = {imageType: 12382};
+        const mapped = zigbeeHerdsmanConverters.findByZigbeeModel(device.modelID)
+        mockClear(mapped);
+        mapped.ota.isUpdateAvailable.mockReturnValueOnce(true);
+        const payload = {data, cluster: 'genOta', device, endpoint: device.getEndpoint(1), type: 'commandQueryNextImageRequest', linkquality: 10};
+        logger.info.mockClear();
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledTimes(1);
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledWith(device, logger, {"imageType": 12382});
+        expect(logger.info).toHaveBeenCalledWith(`Update available for 'bulb'`)
+
+        // Should not request again when device asks again after a short time
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(mapped.ota.isUpdateAvailable).toHaveBeenCalledTimes(1);
+
+        const extension = controller.extensions.find((e) => e.constructor.name === 'OTAUpdate');
+        extension.lastChecked = {};
+        logger.info.mockClear();
+        mapped.ota.isUpdateAvailable.mockReturnValueOnce(false);
+        await zigbeeHerdsman.events.message(payload);
+        await flushPromises();
+        expect(logger.info).not.toHaveBeenCalledWith(`Update available for 'bulb'`)
+    });
+});

test/settings.test.js

@@ -539,6 +539,21 @@ describe('Settings', () => {
         }).toThrowError(`friendly_name 'myname' is already in use`);
     });
 
+    it('Should throw when removing device which doesnt exist', async () => {
+        write(configurationFile, {
+            devices: {
+                '0x0017880104e45519': {friendly_name: 'myname', retain: false},
+                '0x0017880104e45511': {friendly_name: 'myname1', retain: false}
+            },
+        });
+
+        settings._reRead();
+
+        expect(() => {
+            settings.removeDevice('myname33');
+        }).toThrowError(`Device 'myname33' does not exist`);
+    });
+
     it('Shouldnt write to configuration.yaml when there are no changes in it', () => {
         const contentConfiguration = {devices: 'devices.yaml'};
         const contentDevices = {};

test/stub/data.js

@@ -132,6 +132,21 @@ function writeDefaultConfiguration() {
             },
             '0x90fd9ffffe4b64af': {
                 friendly_name: 'roller_shutter',
+            },
+            '0x90fd9ffffe4b64ax': {
+                friendly_name: 'ZNLDP12LM',
+            },
+            '0x90fd9ffffe4b64aa': {
+                friendly_name: 'SP600_OLD',
+            },
+            '0x90fd9ffffe4b64ab': {
+                friendly_name: 'SP600_NEW',
+            },
+            '0x90fd9ffffe4b64ac': {
+                friendly_name: 'MKS-CM-W5',
+            },
+            '0x0017880104e45526': {
+                friendly_name: 'GL-S-007ZS',
             }
         },
         groups: {

test/stub/zigbeeHerdsman.js

@@ -7,11 +7,13 @@ class Group {
         this.command = jest.fn();
         this.meta = {};
         this.members = members;
+        this.removeFromDatabase = jest.fn();
         this.hasMember = (endpoint) => this.members.includes(endpoint);
     }
 }
 
 const clusters = {
+    'genBasic': 0,
     'genScenes': 5,
     'genOnOff': 6,
     'genLevelCtrl': 8,
@@ -20,8 +22,9 @@ const clusters = {
 }
 
 class Endpoint {
-    constructor(ID, inputClusters, outputClusters, deviceIeeeAddress, binds=[]) {
+    constructor(ID, inputClusters, outputClusters, deviceIeeeAddress, binds=[], clusterValues={}) {
         this.deviceIeeeAddress = deviceIeeeAddress;
+        this.clusterValues = clusterValues;
         this.ID = ID;
         this.inputClusters = inputClusters;
         this.outputClusters = outputClusters;
@@ -33,7 +36,7 @@ class Endpoint {
         this.configureReporting = jest.fn();
         this.binds = binds;
         this.supportsInputCluster = (cluster) => {
-            assert(clusters[cluster], `Undefined '${cluster}'`);
+            assert(clusters[cluster] !== undefined, `Undefined '${cluster}'`);
             return this.inputClusters.includes(clusters[cluster]);
         }
 
@@ -60,13 +63,18 @@ class Endpoint {
         this.removeFromAllGroups = () => {
             Object.values(groups).forEach((g) => this.removeFromGroup(g))
         }
+
+        this.getClusterAttributeValue = (cluster, value) => {
+            return this.clusterValues[cluster][value];
+        }
     }
 }
 
 class Device {
-    constructor(type, ieeeAddr, networkAddress, manufacturerID, endpoints, interviewCompleted, powerSource = null, modelID = null, interviewing=false, manufacturerName) {
+    constructor(type, ieeeAddr, networkAddress, manufacturerID, endpoints, interviewCompleted, powerSource = null, modelID = null, interviewing=false, manufacturerName, dateCode= null) {
         this.type = type;
         this.ieeeAddr = ieeeAddr;
+        this.dateCode = dateCode;
         this.networkAddress = networkAddress;
         this.manufacturerID = manufacturerID;
         this.endpoints = endpoints;
@@ -113,7 +121,7 @@ const devices = {
     'E1743': new Device('Router', '0x0017880104e45540', 6540,4476, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'TRADFRI on/off switch'),
     'QBKG04LM': new Device('Router', '0x0017880104e45541', 6549,4151, [new Endpoint(1, [0], []), new Endpoint(2, [0, 6], [])], true, "Mains (single phase)", 'lumi.ctrl_neutral1'),
     'QBKG03LM':new Device('Router', '0x0017880104e45542', 6540,4151, [new Endpoint(1, [0], [], '0x0017880104e45542'), new Endpoint(2, [0, 6], [], '0x0017880104e45542'), new Endpoint(3, [0, 6], [], '0x0017880104e45542')], true, "Mains (single phase)", 'lumi.ctrl_neutral2'),
-    'GLEDOPTO1112': new Device('Router', '0x0017880104e45543', 6540,4151, [new Endpoint(11, [0], []), new Endpoint(13, [0], [])], true, "Mains (single phase)", 'GL-C-008'),
+    'GLEDOPTO1112': new Device('Router', '0x0017880104e45543', 6540, 4151, [new Endpoint(11, [0], [], '0x0017880104e45543'), new Endpoint(13, [0], [], '0x0017880104e45543')], true, "Mains (single phase)", 'GL-C-008'),
     'GLEDOPTO111213': new Device('Router', '0x0017880104e45544', 6540,4151, [new Endpoint(11, [0], []), new Endpoint(13, [0], []), new Endpoint(12, [0], [])], true, "Mains (single phase)", 'GL-C-008'),
     'HGZB04D': new Device('Router', '0x0017880104e45545', 6540,4151, [new Endpoint(1, [0], [])], true, "Mains (single phase)", 'FB56+ZSC05HG1.0'),
     'ZNCLDJ11LM': new Device('Router', '0x0017880104e45547', 6540,4151, [new Endpoint(1, [0], []), new Endpoint(2, [0], [])], true, "Mains (single phase)", 'lumi.curtain'),
@@ -129,6 +137,11 @@ const devices = {
     'LIVOLO': new Device('Router', '0x0017880104e45560', 6541,4152, [new Endpoint(6, [0, 6], [])], true, "Mains (single phase)", 'TI0001          '),
     'tradfri_remote': new Device('EndDevice', '0x90fd9ffffe4b64ae', 33906, 4476, [new Endpoint(1, [0], [0,3,4,6,8,5], '0x90fd9ffffe4b64ae')], true, "Battery", "TRADFRI remote control"),
     'roller_shutter': new Device('EndDevice', '0x90fd9ffffe4b64af', 33906, 4476, [new Endpoint(1, [0], [0,3,4,6,8,5], '0x90fd9ffffe4b64af')], true, "Battery", "SCM-R_00.00.03.15TC"),
+    'ZNLDP12LM': new Device('Router', '0x90fd9ffffe4b64ax', 33901, 4476, [new Endpoint(1, [0,4,3,5,10,258,13,19,6,1,1030,8,768,1027,1029,1026], [0,3,4,6,8,5], '0x90fd9ffffe4b64ax')], true, "Mains (single phase)", "lumi.light.aqcn02"),
+    'SP600_OLD': new Device('Router', '0x90fd9ffffe4b64aa', 33901, 4476, [new Endpoint(1, [0,4,3,5,10,258,13,19,6,1,1030,8,768,1027,1029,1026], [0,3,4,6,8,5], '0x90fd9ffffe4b64aa', [], {seMetering: {"multiplier":1,"divisor":10000}})], true, "Mains (single phase)", "SP600", false, 'Salus', '20160120'),
+    'SP600_NEW': new Device('Router', '0x90fd9ffffe4b64ab', 33901, 4476, [new Endpoint(1, [0,4,3,5,10,258,13,19,6,1,1030,8,768,1027,1029,1026], [0,3,4,6,8,5], '0x90fd9ffffe4b64aa', [], {seMetering: {"multiplier":1,"divisor":10000}})], true, "Mains (single phase)", "SP600", false, 'Salus', '20170220'),
+    'MKS-CM-W5': new Device('Router', '0x90fd9ffffe4b64ac', 33901, 4476, [new Endpoint(1, [0,4,3,5,10,258,13,19,6,1,1030,8,768,1027,1029,1026], [0,3,4,6,8,5], '0x90fd9ffffe4b64aa', [], {})], true, "Mains (single phase)", "qnazj70", false),
+    'GL-S-007ZS': new Device('Router', '0x0017880104e45526', 6540,4151, [new Endpoint(1, [0], [], '0x0017880104e45526')], true, "Mains (single phase)", 'GL-S-007ZS'),
 }
 
 const groups = {

update.sh

@@ -11,8 +11,7 @@ git checkout HEAD -- npm-shrinkwrap.json
 git pull
 
 echo "Installing dependencies..."
-rm -rf node_modules
-npm install
+npm ci
 
 echo "Restore configuration..."
 cp -R data-backup/* data