0.2.0

This adds a hint that you 'need' to set "hass/state" as a topic if you want zigbee2mqtt to resend the cached values on restarts.

.eslintrc.json

@@ -1,17 +1,21 @@
 {
     "env": {
+        "mocha": true,
+        "es6": true,
         "node": true
     },
     "extends": ["eslint:recommended", "google"],
     "parserOptions": {
-        "ecmaFeatures": {
-            "experimentalObjectRestSpread": true
-        },
+        "ecmaVersion": 2018,
         "sourceType": "module"
     },
     "rules": {
         "require-jsdoc": "off",
         "indent": ["error", 4],
-        "max-len": ["error", { "code": 120 }]
-    }
+        "max-len": ["error", { "code": 120 }],
+        "mocha/no-exclusive-tests": "error"
+    },
+    "plugins": [
+        "mocha"
+    ]
 }

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,11 @@
+Unsupported device
+First check: https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices
+
+
+Bug report
+- First make sure your on the latest version of zigbee2mqtt.
+- Make sure you are running the latest CC253X firmware from https://github.com/koenkk/z-stack-firmware.
+- Provide a clear description of the problem.
+- If applicable, provide steps how to reproduce the problem.
+- Provide a log with `log_level` set to `debug`, see https://github.com/Koenkk/zigbee2mqtt/wiki/Configuration
+- DON'T copy logs directly here, post a link to https://hastebin.com/ or https://pastebin.com/.

.gitignore

@@ -60,4 +60,7 @@ typings/
 # data
 data/database.db
 data/config.json
-data/log*.txt
+data/log*.txt
+data/state.json
+data/log
+data-backup/

.travis.yml

@@ -6,16 +6,17 @@ services:
   - docker
 
 node_js:
-  - "8"
+  - "10"
 
 install:
   - npm install
 
-script:
+before_script:
+  - npm test
   - npm run verify-homeassistant-mapping
   - npm run eslint
 
-after_success:
+script:
   - ".travis/docker.sh"
   - ".travis/wiki.sh"
   - ".travis/trigger-downstream.sh"

.travis/docker.sh

@@ -17,7 +17,7 @@ build_and_push() {
 # Only update Docker images for:
 # - dev branch
 # - version release
-if [ "$TRAVIS_PULL_REQUEST" = "false" ] && [ ! -z ${TRAVIS_TAG+x} ]
+if [ "$TRAVIS_PULL_REQUEST" = "false" ] && [ ! -z ${TRAVIS_TAG+x} ] && [ ! "$TRAVIS_TAG" = "" ]
 then
   echo "Updating docker images for master branch!"
   login

.travis/trigger-downstream.sh

@@ -20,11 +20,11 @@ function travis_trigger() {
           "https://api.travis-ci.org/repo/${org}%2F${repo}/requests"
 }
 
-# Only trigger downstream if on master branch and not pull request
-if [ "$TRAVIS_BRANCH" = "master" -a "$TRAVIS_PULL_REQUEST" = "false" ]
+# Only trigger downstream if on dev branch and not pull request
+if [ "$TRAVIS_BRANCH" = "dev" -a "$TRAVIS_PULL_REQUEST" = "false" ]
 then
   echo "Triggering build of downstream projects!"
   travis_trigger "danielwelch" "hassio-zigbee2mqtt" "master"
 else
-  echo "Not triggering build of downstream projects, triggered by pull request or not on master branch"
+  echo "Not triggering build of downstream projects, triggered by pull request or not on dev branch"
 fi

README.md

@@ -24,6 +24,11 @@ Zigbee2mqtt integrates well with (almost) every home automation solution because
 - [Hassio](https://www.home-assistant.io/hassio/): Using [the official addon](https://github.com/danielwelch/hassio-zigbee2mqtt) from [danielwelch](https://github.com/danielwelch)
 - Generic install or Hassbian: Using instructions [here](https://github.com/Koenkk/zigbee2mqtt/wiki/Integrating-with-Home-Assistant)
 
+<img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/2734836/47615848-b8dd8700-dabd-11e8-9d77-175002dd8987.png">
+
+### [Domoticz](https://www.domoticz.com/)
+- Integration implemented in [domoticz-zigbee2mqtt-plugin](https://github.com/stas-demydiuk/domoticz-zigbee2mqtt-plugin)
+
 ## Architecture 
 ![Architecture](architecture.png)
 
@@ -39,6 +44,6 @@ If you need assistance you can check [opened issues](https://github.com/Koenkk/z
 * [AndrewLinden](https://github.com/AndrewLinden)
 * [oskarn97](https://github.com/oskarn97)
 * [dgomes](https://github.com/dgomes)
-* [Koenkk](https://github.com/Koenk)
+* [Koenkk](https://github.com/Koenkk)
 * [kirovilya](https://github.com/kirovilya)
 * [ciotlosm](https://github.com/ciotlosm)

docker/Dockerfile.amd64

@@ -1,4 +1,4 @@
-FROM alpine:3.7
+FROM alpine:3.8
 
 # Copy files
 ADD . /app
@@ -12,7 +12,7 @@ ARG COMMIT
 RUN echo "{\"hash\": \"$COMMIT\"}" > .hash.json
 
 # Install dependencies
-RUN apk add --update --no-cache make gcc g++ python linux-headers udev nodejs git && \
+RUN apk add --update --no-cache make gcc g++ python linux-headers udev nodejs=8.11.4-r0 npm=8.11.4-r0 git && \
     npm install --unsafe-perm && \
     apk del make gcc g++ python linux-headers udev git
 

docker/Dockerfile.arm32v6

@@ -1,4 +1,4 @@
-FROM arm32v6/alpine:3.7
+FROM arm32v6/alpine:3.8
 
 # Setup cross-build
 ENV QEMU_EXECVE 1
@@ -14,7 +14,7 @@ ADD . /app
 RUN [ "qemu-arm-static", "/bin/sh", "-c", \
       "cp /app/data/configuration.yaml /app && \
        cp /app/docker/run.sh /app && chmod +x /app/run.sh && \
-       apk add --update --no-cache make gcc g++ python linux-headers udev nodejs git && \
+       apk add --update --no-cache make gcc g++ python linux-headers udev nodejs=8.11.4-r0 npm=8.11.4-r0 git && \
        npm install --unsafe-perm && \
        apk del make gcc g++ python linux-headers udev git"]
 

docker/Dockerfile.arm64v8

@@ -1,4 +1,4 @@
-FROM arm64v8/alpine:3.7
+FROM arm64v8/alpine:3.8
 
 # Setup cross-build
 ENV QEMU_EXECVE 1
@@ -14,7 +14,7 @@ ADD . /app
 RUN [ "qemu-aarch64-static", "/bin/sh", "-c", \
       "cp /app/data/configuration.yaml /app && \
        cp /app/docker/run.sh /app && chmod +x /app/run.sh && \
-       apk add --update --no-cache make gcc g++ python linux-headers udev nodejs git && \
+       apk add --update --no-cache make gcc g++ python linux-headers udev nodejs=8.11.4-r0 npm=8.11.4-r0 git && \
        npm install --unsafe-perm && \
        apk del make gcc g++ python linux-headers udev git"]
 

index.js

@@ -1,5 +1,12 @@
-const Controller = require('./lib/controller');
+const semver = require('semver');
+const engines = require('./package.json').engines;
 
+const version = engines.node;
+if (!semver.satisfies(process.version, version)) {
+    console.log(`\t\tZigbee2mqtt requires node version ${version}, you are running ${process.version}!\n`); // eslint-disable-line
+}
+
+const Controller = require('./lib/controller');
 const controller = new Controller();
 controller.start();
 

lib/controller.js

@@ -1,17 +1,17 @@
 const MQTT = require('./mqtt');
 const Zigbee = require('./zigbee');
+const State = require('./state');
 const logger = require('./util/logger');
 const settings = require('./util/settings');
+const ExtensionNetworkMap = require('./extension/networkMap');
+const ExtensionSoftReset = require('./extension/softReset');
+const ExtensionRouterPollXiaomi = require('./extension/routerPollXiaomi');
+const ExtensionDevicePublish = require('./extension/devicePublish');
 const zigbeeShepherdConverters = require('zigbee-shepherd-converters');
 const homeassistant = require('./homeassistant');
-const objectAssignDeep = require(`object-assign-deep`);
+const objectAssignDeep = require('object-assign-deep');
 
 const mqttConfigRegex = new RegExp(`${settings.get().mqtt.base_topic}/bridge/config/\\w+`, 'g');
-const mqttDeviceRegex = new RegExp(`${settings.get().mqtt.base_topic}/[\\w\\s\\d]+/set`, 'g');
-const mqttDevicePrefixRegex = new RegExp(`${settings.get().mqtt.base_topic}/[\\w\\s\\d]+/[\\w\\s\\d]+/set`, 'g');
-
-const pollInterval = 60 * 1000; // seconds * 1000.
-const softResetTimeout = 3600 * 1000; // seconds * 1000.
 
 const allowedLogLevels = ['error', 'warn', 'info', 'debug'];
 
@@ -30,17 +30,19 @@ if (settings.get().homeassistant && !cacheState) {
 
 class Controller {
     constructor() {
-        this.zigbee = new Zigbee();
-        this.mqtt = new MQTT();
-        this.stateCache = {};
-        this.configured = [];
         this.handleZigbeeMessage = this.handleZigbeeMessage.bind(this);
         this.handleMQTTMessage = this.handleMQTTMessage.bind(this);
+
+        this.zigbee = new Zigbee(this.handleZigbeeMessage);
+        this.mqtt = new MQTT();
+        this.state = new State();
+        this.configured = [];
+        this.extensions = [];
     }
 
     start() {
         this.startupLogVersion(() => {
-            this.zigbee.start(this.handleZigbeeMessage, (error) => {
+            this.zigbee.start((error) => {
                 if (error) {
                     logger.error('Failed to start', error);
                 } else {
@@ -57,17 +59,12 @@ class Controller {
                         logger.warn('`permit_join` set to  `true` in configuration.yaml.');
                         logger.warn('Allowing new devices to join.');
                         logger.warn('Set `permit_join` to `false` once you joined all devices.');
-                        this.zigbee.permitJoin(true);
                     }
 
-                    // Start timers.
-                    this.pollTimer(true);
-                    this.softResetTimeout(true);
+                    this.zigbee.permitJoin(settings.get().permit_join);
 
                     // Connect to MQTT broker
                     const subscriptions = [
-                        `${settings.get().mqtt.base_topic}/+/set`,
-                        `${settings.get().mqtt.base_topic}/+/+/set`,
                         `${settings.get().mqtt.base_topic}/bridge/config/+`,
                     ];
 
@@ -93,73 +90,39 @@ class Controller {
             });
         }
 
+        // Initialize extensions.
+        this.extensions = [
+            new ExtensionDevicePublish(this.zigbee, this.mqtt, this.state, this.mqttPublishDeviceState),
+            new ExtensionNetworkMap(this.zigbee, this.mqtt, this.state, this.mqttPublishDeviceState),
+            new ExtensionSoftReset(this.zigbee, this.mqtt, this.state, this.mqttPublishDeviceState),
+            new ExtensionRouterPollXiaomi(this.zigbee, this.mqtt, this.state, this.mqttPublishDeviceState),
+        ];
+
         // Resend all cached states.
         this.sendAllCachedStates();
     }
 
     sendAllCachedStates() {
         this.zigbee.getAllClients().forEach((device) => {
-            if (this.stateCache.hasOwnProperty(device.ieeeAddr)) {
-                this.mqttPublishDeviceState(device.ieeeAddr, this.stateCache[device.ieeeAddr], false);
+            if (this.state.exists(device.ieeeAddr)) {
+                this.mqttPublishDeviceState(device, this.state.get(device.ieeeAddr), false);
             }
         });
     }
 
-    softResetTimeout(start) {
-        if (this._softResetTimer) {
-            clearTimeout(this._softResetTimer);
-            this._softResetTimer = null;
-        }
-
-        if (start) {
-            this._softResetTimer = setTimeout(() => {
-                this.zigbee.softReset((error) => {
-                    if (error) {
-                        logger.warn('Soft reset error', error);
-                        this.zigbee.stop((error) => {
-                            logger.warn('Zigbee stopped');
-                            this.zigbee.start(this.handleZigbeeMessage, (error) => {
-                                if (error) {
-                                    logger.error('Failed to restart!');
-                                }
-                            });
-                        });
-                    } else {
-                        logger.warn('Soft resetted zigbee');
-                    }
-
-                    this.softResetTimeout(true);
-                });
-            }, softResetTimeout);
-        }
-    }
-
-    pollTimer(start) {
-        // Some routers need polling to prevent them from sleeping.
-        if (start && !this._pollTimer) {
-            this._pollTimer = setInterval(() => {
-                const devices = this.zigbee.getAllClients().filter((d) => {
-                    const power = d.powerSource ? d.powerSource.toLowerCase().split(' ')[0] : 'unknown';
-                    return power !== 'battery' && power !== 'unknown' && d.type === 'Router';
-                });
-
-                devices.forEach((d) => this.zigbee.ping(d.ieeeAddr));
-            }, pollInterval);
-        } else if (!start && this._pollTimer) {
-            clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-        }
-    }
-
     stop(callback) {
+        this.extensions.filter((e) => e.stop).forEach((e) => e.stop());
+        this.state.save();
         this.mqtt.disconnect();
-        this.pollTimer(false);
-        this.softResetTimeout(false);
         this.zigbee.stop(callback);
     }
 
     configureDevice(device) {
+        let friendlyName = 'unknown';
         const ieeeAddr = device.ieeeAddr;
+        if (settings.getDevice(ieeeAddr)) {
+            friendlyName = settings.getDevice(ieeeAddr).friendly_name;
+        }
         if (ieeeAddr && device.modelId && !this.configured.includes(ieeeAddr)) {
             const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
 
@@ -167,9 +130,9 @@ class Controller {
             if (mappedModel && mappedModel.configure) {
                 mappedModel.configure(ieeeAddr, this.zigbee.shepherd, this.zigbee.getCoordinator(), (ok, msg) => {
                     if (ok) {
-                        logger.info(`Succesfully configured ${ieeeAddr}`);
+                        logger.info(`Succesfully configured ${friendlyName} ${ieeeAddr}`);
                     } else {
-                        logger.error(`Failed to configure ${ieeeAddr}`);
+                        logger.error(`Failed to configure ${friendlyName} ${ieeeAddr}`);
                     }
                 });
             }
@@ -204,11 +167,36 @@ class Controller {
             `${friendlyDevice.vendor} ${friendlyDevice.description} (${type})`;
     }
 
-    handleZigbeeMessage(message) {
-        // Zigbee message receieved, reset soft reset timeout.
-        this.softResetTimeout(true);
+    getDeviceInfoForMqtt(device) {
+        const {type, ieeeAddr, nwkAddr, manufId, manufName, powerSource, modelId, status} = device;
+        const deviceSettings = settings.getDevice(device.ieeeAddr);
+
+        return {
+            ieeeAddr,
+            friendlyName: deviceSettings.friendly_name || '',
+            type,
+            nwkAddr,
+            manufId,
+            manufName,
+            powerSource,
+            modelId,
+            status,
+        };
+    }
+
+    handleZigbeeMessage(message) {
+        // Call extensions.
+        this.extensions.filter((e) => e.handleZigbeeMessage).forEach((e) => e.handleZigbeeMessage(message));
+
+        // Log the message.
+        let logMessage = `Received zigbee message of type '${message.type}' ` +
+                         `with data '${JSON.stringify(message.data)}'`;
+        if (message.endpoints && message.endpoints[0].device) {
+            const device = message.endpoints[0].device;
+            logMessage += ` of device '${device.modelId}' (${device.ieeeAddr})`;
+        }
+        logger.debug(logMessage);
 
-        logger.debug('Recieved zigbee message with data', JSON.stringify(message.data));
         if (message.type == 'devInterview' && !settings.getDevice(message.data)) {
             logger.info('Connecting with device...');
             this.mqtt.log('pairing', 'connecting with device');
@@ -282,10 +270,14 @@ class Controller {
         if (!converters.length) {
             if (cid) {
                 logger.warn(
-                    `No converter available for '${mappedModel.model}' with cid '${cid}' and type '${message.type}'`
+                    `No converter available for '${mappedModel.model}' with cid '${cid}', ` +
+                    `type '${message.type}' and data '${JSON.stringify(message.data)}'`
                 );
             } else if (cmdId) {
-                logger.warn(`No converter available for '${mappedModel.model}' with cmd '${cmdId}'`);
+                logger.warn(
+                    `No converter available for '${mappedModel.model}' with cmd '${cmdId}' ` +
+                    `and data '${JSON.stringify(message.data)}'`
+                );
             }
 
             logger.warn(`Please see: https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices.`);
@@ -308,7 +300,12 @@ class Controller {
                     }
                 });
 
-                this.mqttPublishDeviceState(device.ieeeAddr, payload, cache);
+                // Add device linkquality.
+                if (message.hasOwnProperty('linkquality')) {
+                    payload.linkquality = message.linkquality;
+                }
+
+                this.mqttPublishDeviceState(device, payload, cache);
             };
 
             const payload = converter.convert(mappedModel, message, publish, settings.getDevice(device.ieeeAddr));
@@ -320,12 +317,15 @@ class Controller {
     }
 
     handleMQTTMessage(topic, message) {
-        logger.debug(`Recieved mqtt message on topic '${topic}' with data '${message}'`);
+        logger.debug(`Received MQTT message on '${topic}' with data '${message}'`);
+
+        // Find extensions that can handle MQTT messages and get results
+        const results = this.extensions
+            .filter((e) => e.handleMQTTMessage)
+            .map((e) => e.handleMQTTMessage(topic, message));
 
         if (topic.match(mqttConfigRegex)) {
             this.handleMQTTMessageConfig(topic, message);
-        } else if (topic.match(mqttDeviceRegex) || topic.match(mqttDevicePrefixRegex)) {
-            this.handleMQTTMessageDevice(topic, message, topic.match(mqttDevicePrefixRegex));
         } else if (topic === 'hass/status') {
             if (message.toString().toLowerCase() === 'online') {
                 const timer = setTimeout(() => {
@@ -333,13 +333,13 @@ class Controller {
                     clearTimeout(timer);
                 }, 20000);
             }
-        } else {
-            logger.warn(`Cannot handle MQTT message with topic '${topic}' and message '${message}'`);
+        } else if (!results.includes(true)) {
+            logger.warn(`Cannot handle MQTT message on '${topic}' with data '${message}'`);
         }
     }
 
     handleMQTTMessageConfig(topic, message) {
-        const option = topic.split('/')[3];
+        const option = topic.split('/').slice(-1)[0];
 
         if (option === 'permit_join') {
             this.zigbee.permitJoin(message.toString().toLowerCase() === 'true');
@@ -384,6 +384,9 @@ class Controller {
                 // Remove from configuration.yaml
                 settings.removeDevice(deviceID);
 
+                // Remove from state
+                this.state.remove(deviceID);
+
                 logger.info(`Successfully removed ${deviceID}`);
                 this.mqtt.log('device_removed', message);
             };
@@ -400,129 +403,74 @@ class Controller {
             } else {
                 cleanup();
             }
+        } else if (option === 'rename') {
+            const invalid = `Invalid rename message format expected {old: 'friendly_name', new: 'new_name} ` +
+                            `got ${message.toString()}`;
+
+            let json = null;
+            try {
+                json = JSON.parse(message.toString());
+            } catch (e) {
+                logger.error(invalid);
+                return;
+            }
+
+            // Validate message
+            if (!json.new || !json.old) {
+                logger.error(invalid);
+                return;
+            }
+
+            if (settings.changeFriendlyName(json.old, json.new)) {
+                logger.info(`Successfully renamed - ${json.old} to ${json.new} `);
+            } else {
+                logger.error(`Failed to renamed - ${json.old} to ${json.new}`);
+                return;
+            }
+
+            // Homeassistant rediscover
+            if (settings.get().homeassistant) {
+                const ID = settings.getIDByFriendlyName(json.new);
+                const device = this.zigbee.getDevice(ID);
+                const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
+                if (mappedModel) {
+                    homeassistant.discover(device.ieeeAddr, mappedModel.model, this.mqtt, true);
+                }
+            }
         } else {
             logger.warn(`Cannot handle MQTT config option '${option}' with message '${message}'`);
         }
     }
 
-    handleMQTTMessageDevice(topic, message, withPrefix) {
-        const friendlyName = topic.split('/')[1];
-        const topicPrefix = withPrefix ? topic.split('/')[2] : '';
+    mqttPublishDeviceState(device, payload, cache) {
+        const deviceID = device.ieeeAddr;
+        const appSettings = settings.get();
+        let messagePayload = {...payload};
 
-        // Map friendlyName to deviceID.
-        const deviceID = settings.getIDByFriendlyName(friendlyName);
-
-        if (!deviceID) {
-            logger.error(`Cannot handle '${topic}' because deviceID of '${friendlyName}' cannot be found`);
-            return;
-        }
-
-        // Convert the MQTT message to a Zigbee message.
-        let json = null;
-        try {
-            json = JSON.parse(message);
-        } catch (e) {
-            // Cannot be parsed to JSON, assume state message.
-            json = {state: message.toString()};
-        }
-
-        // Find ep for this device
-        const device = this.zigbee.getDevice(deviceID);
-        if (!device) {
-            logger.error(`Failed to find device with deviceID ${deviceID}`);
-            return;
-        }
-
-        const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
-        if (!mappedModel) {
-            logger.warn(`Device with modelID '${device.modelId}' is not supported.`);
-            logger.warn(`Please see: https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices`);
-            return;
-        }
-
-        const ep = mappedModel.ep && mappedModel.ep[topicPrefix] ? mappedModel.ep[topicPrefix] : null;
-        const published = [];
-
-        Object.keys(json).forEach((key) => {
-            // Find converter for this key.
-            const converter = mappedModel.toZigbee.find((c) => c.key === key);
-
-            if (!converter) {
-                logger.error(`No converter available for '${key}' (${json[key]})`);
-                return;
-            }
-
-            const message = converter.convert(json[key], json);
-
-            if (!message) {
-                return;
-            }
-
-            const callback = (error) => {
-                // Devices do not report when they go off, this ensures state (on/off) is always in sync.
-                if (!error && key.startsWith('state')) {
-                    const msg = {};
-                    const _key = topicPrefix ? `${key}_${topicPrefix}` : key;
-                    msg[_key] = json[key];
-                    this.mqttPublishDeviceState(deviceID, msg, true);
-                }
-            };
-
-            this.zigbee.publish(deviceID, message.cid, message.cmd, message.zclData, ep, callback);
-
-            published.push({message: message, converter: converter});
-        });
-
-        /**
-         * After publishing a command to a zigbee device we want to monitor the changed attribute(s) so that
-         * everything stays in sync.
-         */
-        published.forEach((p) => {
-            let counter = 0;
-            let secondsToMonitor = 1;
-
-            // In case of a transition we need to monitor for the whole transition time.
-            if (p.message.zclData.hasOwnProperty('transtime')) {
-                // Note that: transtime 10 = 0.1 seconds, 100 = 1 seconds, etc.
-                secondsToMonitor = (p.message.zclData.transtime / 10) + 1;
-            }
-
-            const timer = setInterval(() => {
-                counter++;
-
-                // Doing a 'read' will result in the device sending a zigbee message with the current attribute value.
-                // which will be handled by this.handleZigbeeMessage.
-                p.converter.attr.forEach((attribute) => {
-                    this.zigbee.read(deviceID, p.message.cid, attribute, ep, () => null);
-                });
-
-                if (counter >= secondsToMonitor) {
-                    clearTimeout(timer);
-                }
-            }, 1000);
-        });
-    }
-
-    mqttPublishDeviceState(deviceID, payload, cache) {
         if (cacheState) {
             // Add cached state to payload
-            if (this.stateCache[deviceID]) {
-                payload = objectAssignDeep.noMutate(this.stateCache[deviceID], payload);
+            if (this.state.exists(deviceID)) {
+                messagePayload = objectAssignDeep.noMutate(this.state.get(deviceID), payload);
             }
 
             // Update state cache with new state.
             if (cache) {
-                this.stateCache[deviceID] = payload;
+                this.state.set(deviceID, messagePayload);
             }
         }
 
         const deviceSettings = settings.getDevice(deviceID);
+        const friendlyName = deviceSettings ? deviceSettings.friendly_name : deviceID;
         const options = {
-            retain: deviceSettings.retain,
-            qos: deviceSettings.qos ? deviceSettings.qos : 0,
+            retain: deviceSettings ? deviceSettings.retain : false,
+            qos: deviceSettings && deviceSettings.qos ? deviceSettings.qos : 0,
         };
 
-        this.mqtt.publish(deviceSettings.friendly_name, JSON.stringify(payload), options);
+        if (appSettings.mqtt.include_device_information) {
+            messagePayload.device = this.getDeviceInfoForMqtt(device);
+        }
+
+        this.mqtt.publish(friendlyName, JSON.stringify(messagePayload), options);
     }
 
     startupLogVersion(callback) {

lib/extension/devicePublish.js

@@ -0,0 +1,149 @@
+
+const settings = require('../util/settings');
+const zigbeeShepherdConverters = require('zigbee-shepherd-converters');
+const Queue = require('queue');
+const logger = require('../util/logger');
+const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/.+/(set|get)$`);
+const postfixes = ['left', 'right', 'center', 'bottom_left', 'bottom_right', 'top_left', 'top_right'];
+
+class DevicePublish {
+    constructor(zigbee, mqtt, state, mqttPublishDeviceState) {
+        this.zigbee = zigbee;
+        this.mqtt = mqtt;
+        this.state = state;
+
+        // TODO -> remove this; move to publish device state method to mqtt.js
+        this.mqttPublishDeviceState = mqttPublishDeviceState;
+
+        /**
+         * Setup command queue.
+         * The command queue ensures that only 1 command is executed at a time.
+         * When executing multiple commands at the same time, some commands may fail.
+         */
+        this.queue = new Queue();
+        this.queue.concurrency = 1;
+        this.queue.autostart = true;
+
+        // Subscribe to topics.
+        const maxDepth = 20;
+        for (let step = 1; step < maxDepth; step++) {
+            const topic = `${settings.get().mqtt.base_topic}/${'+/'.repeat(step)}`;
+            this.mqtt.subscribe(`${topic}set`);
+            this.mqtt.subscribe(`${topic}get`);
+        }
+    }
+
+    stop() {
+        this.queue.stop();
+    }
+
+    parseTopic(topic) {
+        if (!topic.match(topicRegex)) {
+            return null;
+        }
+
+        // Remove base from topic
+        topic = topic.replace(`${settings.get().mqtt.base_topic}/`, '');
+
+        // Parse type from topic
+        const type = topic.substr(topic.lastIndexOf('/') + 1, topic.length);
+
+        // Remove type from topic
+        topic = topic.replace(`/${type}`, '');
+
+        // Check if we have to deal with a postfix.
+        let postfix = null;
+        if (postfixes.find((p) => topic.endsWith(p))) {
+            postfix = topic.substr(topic.lastIndexOf('/') + 1, topic.length);
+
+            // Remove postfix from topic
+            topic = topic.replace(`/${postfix}`, '');
+        }
+
+        const deviceID = topic;
+
+        return {type: type, deviceID: deviceID, postfix: postfix};
+    }
+
+    handleMQTTMessage(topic, message) {
+        topic = this.parseTopic(topic);
+
+        if (!topic) {
+            return false;
+        }
+
+        // Map friendlyName to ieeeAddr if possible.
+        const ieeeAddr = settings.getIeeAddrByFriendlyName(topic.deviceID) || topic.deviceID;
+
+        // Get device
+        const device = this.zigbee.getDevice(ieeeAddr);
+        if (!device) {
+            logger.error(`Failed to find device with ieeAddr: '${ieeeAddr}'`);
+            return;
+        }
+
+        // Map device to a model
+        const model = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
+        if (!model) {
+            logger.warn(`Device with modelID '${device.modelId}' is not supported.`);
+            logger.warn(`Please see: https://github.com/Koenkk/zigbee2mqtt/wiki/How-to-support-new-devices`);
+            return;
+        }
+
+        // Convert the MQTT message to a Zigbee message.
+        let json = null;
+        try {
+            json = JSON.parse(message);
+        } catch (e) {
+            // Cannot be parsed to JSON, assume state message.
+            json = {state: message.toString()};
+        }
+
+        // Determine endpoint to publish to.
+        const endpoint = model.hasOwnProperty('ep') && model.ep.hasOwnProperty(topic.postfix) ?
+            model.ep[topic.postfix] : null;
+
+        // For each key in the JSON message find the matching converter.
+        Object.keys(json).forEach((key) => {
+            const converter = model.toZigbee.find((c) => c.key === key);
+            if (!converter) {
+                logger.error(`No converter available for '${key}' (${json[key]})`);
+                return;
+            }
+
+            // Converter didn't return a result, skip
+            const converted = converter.convert(json[key], json, topic.type);
+            if (!converted) {
+                return;
+            }
+
+            // Add job to queue
+            this.queue.push((queueCallback) => {
+                this.zigbee.publish(
+                    ieeeAddr,
+                    converted.cid,
+                    converted.cmd,
+                    converted.cmdType,
+                    converted.zclData,
+                    converted.cfg,
+                    endpoint,
+                    (error, rsp) => {
+                        // Devices do not report when they go off, this ensures state (on/off) is always in sync.
+                        if (topic.type === 'set' && !error && (key.startsWith('state') || key === 'brightness')) {
+                            const msg = {};
+                            const _key = topic.postfix ? `state_${topic.postfix}` : 'state';
+                            msg[_key] = key === 'brightness' ? 'ON' : json['state'];
+                            this.mqttPublishDeviceState(device, msg, true);
+                        }
+
+                        queueCallback();
+                    }
+                );
+            });
+        });
+
+        return true;
+    }
+}
+
+module.exports = DevicePublish;

lib/extension/networkMap.js

@@ -0,0 +1,89 @@
+
+const settings = require('../util/settings');
+const zigbeeShepherdConverters = require('zigbee-shepherd-converters');
+
+class NetworkMap {
+    constructor(zigbee, mqtt, state) {
+        this.zigbee = zigbee;
+        this.mqtt = mqtt;
+        this.state = state;
+
+        // Subscribe to topic.
+        this.topic = `${settings.get().mqtt.base_topic}/bridge/networkmap`;
+        this.mqtt.subscribe(this.topic);
+
+        // Set supported formats
+        this.supportedFormats = {
+            'raw': this.raw,
+            'graphviz': this.graphviz,
+        };
+    }
+
+    handleMQTTMessage(topic, message) {
+        message = message.toString();
+
+        if (topic === this.topic && this.supportedFormats.hasOwnProperty(message)) {
+            this.zigbee.networkScan((result)=> {
+                const converted = this.supportedFormats[message](this.zigbee, result);
+                this.mqtt.publish(`bridge/networkmap/${message}`, converted, {});
+            });
+
+            return true;
+        }
+
+        return false;
+    }
+
+    raw(zigbee, topology) {
+        return JSON.stringify(topology);
+    }
+
+    graphviz(zigbee, topology) {
+        let text = 'digraph G {\nnode[shape=record];\n';
+        const lqiDevices = new Map(topology.map((d) => [d.ieeeAddr, d]));
+
+        zigbee.getDevices().forEach((device) => {
+            const labels = [];
+            const friendlyDevice = settings.getDevice(device.ieeeAddr);
+            const friendlyName = friendlyDevice ? friendlyDevice.friendly_name : device.ieeeAddr;
+
+            // Add friendly name
+            labels.push(friendlyName);
+
+            // Add the device type
+            labels.push(device.type);
+
+            // Add the device model
+            const mappedModel = zigbeeShepherdConverters.findByZigbeeModel(device.modelId);
+            if (mappedModel) {
+                labels.push(`${mappedModel.vendor} ${mappedModel.description} (${mappedModel.model})`);
+            } else {
+                // This model is not supported by zigbee-shepherd-converters, add zigbee model information, if available
+                const zigbeeModel = [device.manufName, device.modelId].filter((a) => a).join(' ');
+                labels.push(zigbeeModel ? zigbeeModel : 'No model information available');
+            }
+
+            // Add the device status (online/offline)
+            labels.push(device.status);
+
+            // Add the device with its labels to the graph as a node.
+            text += `  "${device.ieeeAddr}" [label="{${labels.join('|')}}"];\n`;
+
+            /**
+             * Add an edge between the device and its parent to the graph
+             * NOTE: There are situations where a device is NOT in the topology, this can be e.g.
+             * due to not responded to the lqi scan. In that case we do not add an edge for this device.
+             */
+            const lqiDevice = lqiDevices.get(device.ieeeAddr);
+            if (lqiDevice != undefined) {
+                text += `  "${device.ieeeAddr}" -> "${lqiDevice.parent}" [label="${lqiDevice.lqi}"]\n`;
+            }
+        });
+
+        text += '}';
+
+        return text.replace(/\0/g, '');
+    }
+}
+
+module.exports = NetworkMap;

lib/extension/routerPollXiaomi.js

@@ -0,0 +1,40 @@
+const utils = require('../util/utils');
+const interval = utils.secondsToMilliseconds(60);
+
+/**
+ * This extensions polls Xiaomi Zigbee routers to keep them awake.
+ */
+class RouterPollXiaomi {
+    constructor(zigbee, mqtt, state) {
+        this.zigbee = zigbee;
+        this.timer = null;
+
+        this.startTimer();
+    }
+
+    startTimer() {
+        this.clearTimer();
+        this.timer = setInterval(() => this.handleInterval(), interval);
+    }
+
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+
+    stop() {
+        this.clearTimer();
+    }
+
+    handleInterval() {
+        this.zigbee.getAllClients()
+            .filter((d) => utils.isXiaomiDevice(d)) // Filter Xiaomi devices
+            .filter((d) => d.type === 'Router') // Filter routers
+            .filter((d) => d.powerSource && d.powerSource !== 'Battery') // Remove battery powered devices
+            .forEach((d) => this.zigbee.ping(d.ieeeAddr)); // Ping devices.
+    }
+}
+
+module.exports = RouterPollXiaomi;

lib/extension/softReset.js

@@ -0,0 +1,66 @@
+const settings = require('../util/settings');
+const logger = require('../util/logger');
+const utils = require('../util/utils');
+
+/**
+ * This extensions soft resets the ZNP after a certain timeout.
+ */
+class SoftReset {
+    constructor(zigbee, mqtt, state) {
+        this.zigbee = zigbee;
+        this.timer = null;
+        this.timeout = utils.secondsToMilliseconds(settings.get().advanced.soft_reset_timeout);
+
+        if (this.timeout === 0) {
+            logger.debug(`Soft reset timeout disabled`);
+        } else {
+            logger.debug(`Soft reset timeout set to ${utils.millisecondsToSeconds(this.timeout)} seconds`);
+        }
+
+        this.resetTimer();
+    }
+
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+
+    resetTimer() {
+        if (this.timeout === 0) {
+            return;
+        }
+
+        this.clearTimer();
+        this.timer = setTimeout(() => this.handleTimeout(), this.timeout);
+    }
+
+    handleTimeout() {
+        logger.warn('Soft reset timeout triggered');
+
+        this.zigbee.softReset((error) => {
+            if (error) {
+                logger.warn('Soft reset failed, trying stop/start');
+                this.zigbee.stop((error) => {
+                    logger.warn('Zigbee stopped');
+                    this.zigbee.start((error) => {
+                        if (error) {
+                            logger.error('Failed to restart!');
+                        }
+                    });
+                });
+            } else {
+                logger.warn('Soft resetted ZNP due to timeout');
+            }
+
+            this.resetTimer();
+        });
+    }
+
+    handleZigbeeMessage(message) {
+        this.resetTimer();
+    }
+}
+
+module.exports = SoftReset;

lib/homeassistant.js

@@ -10,7 +10,18 @@ const configurations = {
             payload_off: false,
             value_template: '{{ value_json.occupancy }}',
             device_class: 'motion',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
+        },
+    },
+    'binary_sensor_presence': {
+        type: 'binary_sensor',
+        object_id: 'presence',
+        discovery_payload: {
+            payload_on: true,
+            payload_off: false,
+            value_template: '{{ value_json.presence }}',
+            device_class: 'presence',
+            json_attributes: ['battery', 'voltage', 'action'],
         },
     },
     'binary_sensor_contact': {
@@ -21,7 +32,7 @@ const configurations = {
             payload_off: true,
             value_template: '{{ value_json.contact }}',
             device_class: 'door',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
         },
     },
     'binary_sensor_water_leak': {
@@ -32,7 +43,7 @@ const configurations = {
             payload_off: false,
             value_template: '{{ value_json.water_leak }}',
             device_class: 'moisture',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
         },
     },
     'binary_sensor_smoke': {
@@ -43,7 +54,18 @@ const configurations = {
             payload_off: false,
             value_template: '{{ value_json.smoke }}',
             device_class: 'smoke',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
+        },
+    },
+    'binary_sensor_gas': {
+        type: 'binary_sensor',
+        object_id: 'gas',
+        discovery_payload: {
+            payload_on: true,
+            payload_off: false,
+            value_template: '{{ value_json.gas }}',
+            device_class: 'gas',
+            json_attributes: ['linkquality', 'sensitivity'],
         },
     },
     'binary_sensor_router': {
@@ -54,7 +76,7 @@ const configurations = {
             payload_off: false,
             value_template: '{{ value_json.state }}',
             device_class: 'connectivity',
-            json_attributes: ['description', 'type', 'rssi'],
+            json_attributes: ['linkquality', 'description', 'type', 'rssi'],
         },
     },
 
@@ -64,9 +86,9 @@ const configurations = {
         object_id: 'illuminance',
         discovery_payload: {
             unit_of_measurement: 'lx',
-            icon: 'mdi:theme-light-dark',
+            device_class: 'illuminance',
             value_template: '{{ value_json.illuminance }}',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
         },
     },
     'sensor_humidity': {
@@ -74,9 +96,9 @@ const configurations = {
         object_id: 'humidity',
         discovery_payload: {
             unit_of_measurement: '%',
-            icon: 'mdi:water-percent',
+            device_class: 'humidity',
             value_template: '{{ value_json.humidity }}',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
         },
     },
     'sensor_temperature': {
@@ -84,19 +106,19 @@ const configurations = {
         object_id: 'temperature',
         discovery_payload: {
             unit_of_measurement: '°C',
-            icon: 'mdi:temperature-celsius',
+            device_class: 'temperature',
             value_template: '{{ value_json.temperature }}',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
         },
     },
     'sensor_pressure': {
         type: 'sensor',
         object_id: 'pressure',
         discovery_payload: {
-            unit_of_measurement: 'Pa',
-            icon: 'mdi:speedometer',
+            unit_of_measurement: 'hPa',
+            device_class: 'pressure',
             value_template: '{{ value_json.pressure }}',
-            json_attributes: ['battery', 'voltage'],
+            json_attributes: ['linkquality', 'battery', 'voltage'],
         },
     },
     'sensor_click': {
@@ -105,7 +127,8 @@ const configurations = {
         discovery_payload: {
             icon: 'mdi:toggle-switch',
             value_template: '{{ value_json.click }}',
-            json_attributes: ['battery', 'voltage', 'action', 'duration'],
+            json_attributes: ['linkquality', 'battery', 'voltage', 'action', 'duration'],
+            force_update: true,
         },
     },
     'sensor_power': {
@@ -115,16 +138,20 @@ const configurations = {
             unit_of_measurement: 'Watt',
             icon: 'mdi:flash',
             value_template: '{{ value_json.power }}',
-            json_attributes: ['voltage', 'temperature', 'consumption', 'current', 'power_factor'],
+            json_attributes: ['linkquality', 'voltage', 'temperature', 'consumption', 'current', 'power_factor'],
         },
     },
     'sensor_action': {
         type: 'sensor',
         object_id: 'action',
         discovery_payload: {
-            icon: 'mdi:cube',
+            icon: 'mdi:gesture-double-tap',
             value_template: '{{ value_json.action }}',
-            json_attributes: ['battery', 'voltage', 'angle', 'side', 'from_side', 'to_side'],
+            json_attributes: [
+                'linkquality', 'battery', 'voltage', 'angle', 'side', 'from_side', 'to_side', 'brightness',
+                'angle_x_absolute', 'angle_y_absolute', 'angle_z', 'angle_y', 'angle_x', 'unknown_data',
+            ],
+            force_update: true,
         },
     },
     'sensor_brightness': {
@@ -134,7 +161,16 @@ const configurations = {
             unit_of_measurement: 'brightness',
             icon: 'mdi:brightness-5',
             value_template: '{{ value_json.brightness }}',
-            json_attributes: [],
+            json_attributes: ['linkquality'],
+        },
+    },
+    'sensor_lock': {
+        type: 'sensor',
+        object_id: 'lock',
+        discovery_payload: {
+            icon: 'mdi:lock',
+            value_template: '{{ value_json.inserted }}',
+            json_attributes: ['linkquality', 'forgotten', 'keyerror'],
         },
     },
 
@@ -191,28 +227,21 @@ const configurations = {
             command_topic: true,
         },
     },
-    'switch_left': {
+};
+
+const switchWithPostfix = (postfix) => {
+    return {
         type: 'switch',
-        object_id: 'switch_left',
+        object_id: `switch_${postfix}`,
         discovery_payload: {
             payload_off: 'OFF',
             payload_on: 'ON',
-            value_template: '{{ value_json.state_left }}',
+            value_template: `{{ value_json.state_${postfix} }}`,
             command_topic: true,
-            command_topic_prefix: 'left',
+            command_topic_prefix: postfix,
+            json_attributes: ['linkquality', `button_${postfix}`],
         },
-    },
-    'switch_right': {
-        type: 'switch',
-        object_id: 'switch_right',
-        discovery_payload: {
-            payload_off: 'OFF',
-            payload_on: 'ON',
-            value_template: '{{ value_json.state_right }}',
-            command_topic: true,
-            command_topic_prefix: 'right',
-        },
-    },
+    };
 };
 
 // Map homeassitant configurations to devices.
@@ -223,7 +252,7 @@ const mapping = {
     'WXKG03LM': [configurations.sensor_click],
     'WXKG02LM': [configurations.sensor_click],
     'QBKG04LM': [configurations.switch],
-    'QBKG03LM': [configurations.switch_left, configurations.switch_right],
+    'QBKG03LM': [switchWithPostfix('left'), switchWithPostfix('right')],
     'WSDCGQ01LM': [configurations.sensor_temperature, configurations.sensor_humidity],
     'WSDCGQ11LM': [configurations.sensor_temperature, configurations.sensor_humidity, configurations.sensor_pressure],
     'RTCGQ01LM': [configurations.binary_sensor_occupancy],
@@ -240,12 +269,14 @@ const mapping = {
     'LED1537R6': [configurations.light_brightness_colortemp],
     'LED1650R5': [configurations.light_brightness],
     'LED1536G5': [configurations.light_brightness_colortemp],
+    '7299760PH': [configurations.light_brightness_xy],
     '7146060PH': [configurations.light_brightness_colortemp_xy],
     'F7C033': [configurations.light_brightness],
     'JTYJ-GD-01LM/BW': [configurations.binary_sensor_smoke],
     'PLUG EDP RE:DY': [configurations.switch, configurations.sensor_power],
     'CC2530.ROUTER': [configurations.binary_sensor_router],
     'AA70155': [configurations.light_brightness_colortemp],
+    '4058075816718': [configurations.light_brightness_colortemp_xy],
     'AA69697': [configurations.light_brightness_colortemp_xy],
     'HALIGHTDIMWWE27': [configurations.light_brightness],
     'AB3257001NJ': [configurations.switch],
@@ -280,7 +311,7 @@ const mapping = {
     'SL 110 W': [configurations.light_brightness],
     'AA68199': [configurations.light_brightness_colortemp],
     'QBKG11LM': [configurations.switch, configurations.sensor_power],
-    'QBKG12LM': [configurations.switch_left, configurations.switch_right, configurations.sensor_power],
+    'QBKG12LM': [switchWithPostfix('left'), switchWithPostfix('right'), configurations.sensor_power],
     'K2RGBW01': [configurations.light_brightness_colortemp_xy],
     '9290011370': [configurations.light_brightness],
     'DNCKATSW001': [configurations.switch],
@@ -288,6 +319,67 @@ const mapping = {
     'NL08-0800': [configurations.light_brightness],
     '915005106701': [configurations.light_brightness_colortemp_xy],
     'AB32840': [configurations.light_brightness_colortemp],
+    '8718696485880': [configurations.light_brightness_colortemp_xy],
+    '8718696598283': [configurations.light_brightness_colortemp],
+    '8718696695203': [configurations.light_brightness_colortemp],
+    '73693': [configurations.light_brightness_colortemp_xy],
+    '324131092621': [configurations.sensor_action],
+    '9290012607': [
+        configurations.binary_sensor_occupancy, configurations.sensor_temperature,
+        configurations.sensor_illuminance,
+    ],
+    'GL-C-008': [configurations.light_brightness_colortemp_xy],
+    'STSS-MULT-001': [configurations.binary_sensor_contact],
+    'E11-G23/E11-G33': [configurations.light_brightness],
+    'AC03645': [configurations.light_brightness_colortemp_xy],
+    'AC03641': [configurations.light_brightness],
+    'FB56+ZSW05HG1.2': [configurations.switch],
+    '72922-A': [configurations.switch],
+    'AC03642': [configurations.light_brightness_colortemp],
+    'DNCKATSW002': [switchWithPostfix('left'), switchWithPostfix('right')],
+    'DNCKATSW003': [switchWithPostfix('left'), switchWithPostfix('right'), switchWithPostfix('center')],
+    'DNCKATSW004': [
+        switchWithPostfix('bottom_left'), switchWithPostfix('bottom_right'),
+        switchWithPostfix('top_left'), switchWithPostfix('top_right'),
+    ],
+    'BY 165': [configurations.light_brightness],
+    'ZLED-2709': [configurations.light_brightness],
+    '8718696548738': [configurations.light_brightness_colortemp],
+    '4052899926110': [configurations.light_brightness_colortemp_xy],
+    'Z01-CIA19NAE26': [configurations.light_brightness],
+    'E11-N1EA': [configurations.light_brightness_colortemp_xy],
+    '74283': [configurations.light_brightness],
+    'JTQJ-BF-01LM/BW': [configurations.binary_sensor_gas],
+    '50045': [configurations.light_brightness],
+    'AV2010/22': [configurations.binary_sensor_occupancy],
+    '3210-L': [configurations.switch],
+    '7299355PH': [configurations.light_brightness_xy],
+    '45857GE': [configurations.light_brightness],
+    'A6121': [configurations.sensor_lock],
+    '433714': [configurations.light_brightness],
+    '3261030P7': [configurations.light_brightness_colortemp],
+    'DJT11LM': [configurations.sensor_action],
+    'E1603': [configurations.switch],
+    '7199960PH': [configurations.light_brightness_xy],
+    '74696': [configurations.light_brightness],
+    'AB35996': [configurations.light_brightness_colortemp_xy],
+    'AB401130055': [configurations.light_brightness_colortemp],
+    '74282': [configurations.light_brightness_colortemp],
+    'RS 128 T': [configurations.light_brightness_colortemp],
+    '53170161': [configurations.light_brightness_colortemp],
+    '4058075036147': [configurations.light_brightness_colortemp_xy],
+    'KS-SM001': [configurations.switch],
+    'MG-AUWS01': [switchWithPostfix('left'), switchWithPostfix('right')],
+    '9290002579A': [configurations.light_brightness_colortemp_xy],
+    '4256251-RZHAC': [configurations.switch, configurations.sensor_power],
+    'STS-PRS-251': [configurations.binary_sensor_presence],
+    '4058075816794': [configurations.light_brightness_colortemp],
+    '4052899926158': [configurations.light_brightness],
+    '4058075036185': [configurations.light_brightness_colortemp_xy],
+    '50049': [configurations.light_brightness_xy],
+    '915005733701': [configurations.light_brightness_colortemp_xy],
+    'RB 285 C': [configurations.light_brightness_colortemp_xy],
+    '3216331P5': [configurations.light_brightness_colortemp],
 };
 
 // A map of all discoverd devices
@@ -304,7 +396,7 @@ function discover(deviceID, model, mqtt, force) {
 
     mapping[model].forEach((config) => {
         const topic = `${config.type}/${deviceID}/${config.object_id}/config`;
-        const payload = config.discovery_payload;
+        const payload = {...config.discovery_payload};
         payload.state_topic = `${settings.get().mqtt.base_topic}/${friendlyName}`;
         payload.availability_topic = `${settings.get().mqtt.base_topic}/bridge/state`;
 

lib/mqtt.js

@@ -12,12 +12,29 @@ class MQTT {
         const mqttSettings = settings.get().mqtt;
         logger.info(`Connecting to MQTT server at ${mqttSettings.server}`);
 
-        const options = {};
+        const options = {
+            will: {
+                topic: this.prefixTopic('bridge/state'),
+                payload: 'offline',
+                retain: true,
+            },
+        };
+
         if (mqttSettings.user && mqttSettings.password) {
             options.username = mqttSettings.user;
             options.password = mqttSettings.password;
         }
 
+        if (mqttSettings.client_id) {
+            logger.debug(`Using MQTT client ID: '${mqttSettings.client_id}'`);
+            options.clientId = mqttSettings.client_id;
+        }
+
+        if (mqttSettings.hasOwnProperty('reject_unauthorized') && !mqttSettings.reject_unauthorized) {
+            logger.debug(`MQTT reject_unauthorized set false, ignoring certificate warnings.`);
+            options.rejectUnauthorized = false;
+        }
+
         this.client = mqtt.connect(mqttSettings.server, options);
 
         // Register callbacks.
@@ -53,7 +70,11 @@ class MQTT {
     handleConnect() {
         logger.info('Connected to MQTT server');
         this.publish('bridge/state', 'online', {retain: true, qos: 0});
-        this.subscriptions.forEach((topic) => this.client.subscribe(topic));
+        this.subscriptions.forEach((topic) => this.subscribe(topic));
+    }
+
+    subscribe(topic) {
+        this.client.subscribe(topic);
     }
 
     handleMessage(topic, message) {
@@ -63,8 +84,7 @@ class MQTT {
     }
 
     publish(topic, payload, options, callback, baseTopic) {
-        baseTopic = baseTopic ? baseTopic : settings.get().mqtt.base_topic;
-        topic = `${baseTopic}/${topic}`;
+        topic = this.prefixTopic(topic, baseTopic);
 
         if (!this.client || this.client.reconnecting) {
             logger.error(`Not connected to MQTT server!`);
@@ -76,6 +96,11 @@ class MQTT {
         this.client.publish(topic, payload, options, callback);
     }
 
+    prefixTopic(topic, baseTopic) {
+        baseTopic = baseTopic ? baseTopic : settings.get().mqtt.base_topic;
+        return `${baseTopic}/${topic}`;
+    }
+
     log(type, message) {
         const payload = {type: type, message: message};
         this.publish('bridge/log', JSON.stringify(payload), {retain: false});

lib/state.js

@@ -0,0 +1,55 @@
+const logger = require('./util/logger');
+const data = require('./util/data');
+const fs = require('fs');
+
+const saveInterval = 1000 * 60 * 5; // 5 minutes
+
+class State {
+    constructor() {
+        this.state = {};
+        this.file = data.joinPath('state.json');
+        this._load();
+
+        // Save the state on every interval
+        this.timer = setInterval(() => this.save(), saveInterval);
+    }
+
+    _load() {
+        if (fs.existsSync(this.file)) {
+            try {
+                this.state = JSON.parse(fs.readFileSync(this.file, 'utf8'));
+                logger.debug(`Loaded state from file ${this.file}`);
+            } catch (e) {
+                logger.debug(`Failed to load state from file ${this.file} (corrupt file?)`);
+            }
+        } else {
+            logger.debug(`Can't load state from file ${this.file} (doesn't exsist)`);
+        }
+    }
+
+    save() {
+        logger.debug(`Saving state to file ${this.file}`);
+        const json = JSON.stringify(this.state, null, 4);
+        fs.writeFileSync(this.file, json, 'utf8');
+    }
+
+    exists(ID) {
+        return this.state.hasOwnProperty(ID);
+    }
+
+    get(ID) {
+        return this.state[ID];
+    }
+
+    set(ID, state) {
+        this.state[ID] = state;
+    }
+
+    remove(ID) {
+        if (this.exists(ID)) {
+            delete this.state[ID];
+        }
+    }
+}
+
+module.exports = State;

lib/util/data.js

@@ -11,4 +11,5 @@ if (process.env.ZIGBEE2MQTT_DATA) {
 
 module.exports = {
     joinPath: (file) => path.join(dataPath, file),
+    getPath: () => dataPath,
 };

lib/util/logger.js

@@ -1,37 +1,62 @@
 const winston = require('winston');
-const data = require('./data');
+const moment = require('moment');
 const settings = require('./settings');
+const path = require('path');
+const fs = require('fs');
+const fx = require('mkdir-recursive');
+const rimraf = require('rimraf');
 
-let logLevel = '';
-if (process.env.DEBUG) {
-    logLevel = 'debug';
-} else if (settings.get().advanced && settings.get().advanced.log_level) {
-    logLevel = settings.get().advanced.log_level;
-} else {
-    logLevel = winston.level.info;
-}
+// Determine the log level.
+const level = settings.get().advanced.log_level;
 
+// Directoy 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);
+
+// Make sure that log directoy exsists
+fx.mkdirSync(directory);
+
+// Create logger
 const logger = new (winston.Logger)({
     transports: [
         new (winston.transports.File)({
-            filename: data.joinPath('log.txt'),
+            filename: path.join(directory, 'log.txt'),
             json: false,
-            level: logLevel,
-            maxFiles: 3,
+            level: level,
+            maxFiles: 3, // Keep last 3 files
             maxsize: 10000000, // 10MB
+            timestamp: () => new Date().toLocaleString(),
         }),
         new (winston.transports.Console)({
             timestamp: () => new Date().toLocaleString(),
             formatter: function(options) {
-                return options.timestamp() + ' ' +
-                        winston.config.colorize(options.level, options.level.toUpperCase()) + ' ' +
-                        (options.message ? options.message : '') +
-                        (options.meta && Object.keys(options.meta).length ? '\n\t'+ JSON.stringify(options.meta) : '' );
+                return winston.config.colorize(options.level, '  zigbee2mqtt:' + options.level.toLowerCase()) + ' ' +
+                    options.timestamp() + ' ' + (options.message ? options.message : '') +
+                    (options.meta && Object.keys(options.meta).length ? '\n\t'+ JSON.stringify(options.meta) : '' );
             },
         }),
     ],
 });
 
-logger.transports.console.level = logLevel;
+logger.info(`Logging to directory: '${directory}'`);
+
+logger.transports.console.level = level;
+
+// Cleanup any old log directory.
+if (settings.get().advanced.log_directory.includes('%TIMESTAMP%')) {
+    const rootDirectory = path.join(directory, '..');
+
+    let directories = fs.readdirSync(rootDirectory).map((d) => {
+        d = path.join(rootDirectory, d);
+        return {path: d, birth: fs.statSync(d).birthtimeMs};
+    });
+
+    directories.sort((a, b) => b.birth - a.birth);
+    directories = directories.slice(10, directories.length);
+    directories.forEach((dir) => {
+        logger.debug(`Removing old log directory '${dir.path}'`);
+        rimraf.sync(dir.path);
+    });
+}
 
 module.exports = logger;

lib/util/settings.js

@@ -2,6 +2,17 @@ const yaml = require('js-yaml');
 const fs = require('fs');
 const data = require('./data');
 const file = data.joinPath('configuration.yaml');
+const objectAssignDeep = require(`object-assign-deep`);
+const path = require('path');
+
+const defaults = {
+    permit_join: false,
+    advanced: {
+        log_directory: path.join(data.getPath(), 'log', '%TIMESTAMP%'),
+        log_level: process.env.DEBUG ? 'debug' : 'info',
+        soft_reset_timeout: 0,
+    },
+};
 
 let settings = read();
 
@@ -44,11 +55,25 @@ function getIDByFriendlyName(friendlyName) {
     );
 }
 
+function changeFriendlyName(old, new_) {
+    const ID = getIDByFriendlyName(old);
+
+    if (!ID) {
+        return false;
+    }
+
+    settings.devices[ID].friendly_name = new_;
+    writeRead();
+    return true;
+}
+
 module.exports = {
-    get: () => settings,
+    get: () => objectAssignDeep.noMutate(defaults, settings),
     write: () => write(),
     getDevice: (id) => settings.devices ? settings.devices[id] : null,
     addDevice: (id) => addDevice(id),
     removeDevice: (id) => removeDevice(id),
     getIDByFriendlyName: (friendlyName) => getIDByFriendlyName(friendlyName),
+    changeFriendlyName: (old, new_) => changeFriendlyName(old, new_),
+    getIeeAddrByFriendlyName: (friendlyName) => getIDByFriendlyName(friendlyName),
 };

lib/util/utils.js

@@ -0,0 +1,8 @@
+// Xiaomi uses 4151 and 4447 (lumi.plug) as manufacturer ID.
+const xiaomiManufacturerID = [4151, 4447];
+
+module.exports = {
+    millisecondsToSeconds: (milliseconds) => milliseconds / 1000,
+    secondsToMilliseconds: (seconds) => seconds * 1000,
+    isXiaomiDevice: (device) => xiaomiManufacturerID.includes(device.manufId),
+};

lib/zigbee.js

@@ -3,6 +3,7 @@ const logger = require('./util/logger');
 const settings = require('./util/settings');
 const data = require('./util/data');
 const zclPacket = require('zcl-packet');
+const utils = require('./util/utils');
 
 const advancedSettings = settings.get().advanced;
 
@@ -13,7 +14,7 @@ const shepherdSettings = {
     },
     dbPath: data.joinPath('database.db'),
     sp: {
-        baudrate: advancedSettings && advancedSettings.baudrate ? advancedSettings.baudrate : 115200,
+        baudRate: advancedSettings && advancedSettings.baudrate ? advancedSettings.baudrate : 115200,
         rtscts: advancedSettings && (typeof(advancedSettings.rtscts) === 'boolean') ? advancedSettings.rtscts : true,
     },
 };
@@ -21,13 +22,14 @@ const shepherdSettings = {
 logger.debug(`Using zigbee-shepherd with settings: '${JSON.stringify(shepherdSettings)}'`);
 
 class Zigbee {
-    constructor() {
+    constructor(onMessage) {
+        this.onMessage = onMessage;
         this.handleReady = this.handleReady.bind(this);
         this.handleMessage = this.handleMessage.bind(this);
         this.handleError = this.handleError.bind(this);
     }
 
-    start(onMessage, callback) {
+    start(callback) {
         logger.info(`Starting zigbee-shepherd`);
 
         this.shepherd = new ZShepherd(settings.get().serial.port, shepherdSettings);
@@ -47,13 +49,13 @@ class Zigbee {
                             );
                             callback(error);
                         } else {
-                            logger.info('zigbee-shepherd started');
+                            this._logStartupInfo();
                             callback(null);
                         }
                     });
                 }, 60 * 1000);
             } else {
-                logger.info('zigbee-shepherd started');
+                this._logStartupInfo();
                 callback(null);
             }
         });
@@ -62,8 +64,12 @@ class Zigbee {
         this.shepherd.on('ready', this.handleReady);
         this.shepherd.on('ind', this.handleMessage);
         this.shepherd.on('error', this.handleError);
+    }
 
-        this.onMessage = onMessage;
+    _logStartupInfo() {
+        logger.info('zigbee-shepherd started');
+        logger.info(`Coordinator firmware version: '${this.shepherd.info().firmware.revision}'`);
+        logger.debug(`zigbee-shepherd info: ${JSON.stringify(this.shepherd.info())}`);
     }
 
     softReset(callback) {
@@ -78,12 +84,11 @@ class Zigbee {
     }
 
     handleReady() {
-        // Set all Xiaomi devices (manufId === 4151) to be online, so shepherd won't try
-        // to query info from devices (which would fail because they go tosleep).
-        // Xiaomi lumi.plug has manufId === 4447 and can be in the sleep mode too
+        // Set all Xiaomi devices to be online, so shepherd won't try
+        // to query info from devices (which would fail because they go to sleep).
         const devices = this.getAllClients();
         devices.forEach((d) => {
-            if ((d.manufId === 4151) || (d.manufId === 4447)) {
+            if (utils.isXiaomiDevice(d)) {
                 const device = this.shepherd.find(d.ieeeAddr, 1);
                 if (device) {
                     device.getDevice().update({
@@ -94,6 +99,11 @@ class Zigbee {
             }
         });
 
+        // Check if we have to turn off the led
+        if (settings.get().serial.disable_led) {
+            this.shepherd.controller.request('UTIL', 'ledControl', {ledid: 3, mode: 0});
+        }
+
         logger.info('zigbee-shepherd ready');
     }
 
@@ -117,7 +127,7 @@ class Zigbee {
     }
 
     getAllClients() {
-        return this.shepherd.list().filter((device) => device.type !== 'Coordinator');
+        return this.getDevices().filter((device) => device.type !== 'Coordinator');
     }
 
     removeDevice(deviceID, callback) {
@@ -143,11 +153,16 @@ class Zigbee {
     }
 
     ping(deviceID) {
+        let friendlyName = 'unknown';
         const device = this.shepherd._findDevByAddr(deviceID);
+        const ieeeAddr = device.ieeeAddr;
+        if (settings.getDevice(ieeeAddr)) {
+            friendlyName = settings.getDevice(ieeeAddr).friendly_name;
+        }
 
         if (device) {
             // Note: checkOnline has the callback argument but does not call callback
-            logger.debug(`Check online ${deviceID}`);
+            logger.debug(`Check online ${friendlyName} ${deviceID}`);
             this.shepherd.controller.checkOnline(device);
         }
     }
@@ -158,34 +173,59 @@ class Zigbee {
         }
     }
 
-    getDevice(deviceID) {
-        return this.shepherd.list().find((d) => d.ieeeAddr === deviceID);
+    getDevices() {
+        return this.shepherd.list();
+    }
+
+    getDevice(ieeeAddr) {
+        return this.getDevices().find((d) => d.ieeeAddr === ieeeAddr);
     }
 
     getCoordinator() {
-        const device = this.shepherd.list().find((d) => d.type === 'Coordinator');
+        const device = this.getDevices().find((d) => d.type === 'Coordinator');
         return this.shepherd.find(device.ieeeAddr, 1);
     }
 
-    publish(deviceID, cid, cmd, zclData, ep, callback) {
-        const device = this._findDevice(deviceID, ep);
+    publish(ieeAddr, cid, cmd, cmdType, zclData, cfg, ep, callback) {
+        const device = this._findDevice(ieeAddr, ep);
         if (!device) {
-            logger.error(`Zigbee cannot publish message to device because '${deviceID}' not known by zigbee-shepherd`);
+            logger.error(`Zigbee cannot publish message to device because '${ieeAddr}' not known by zigbee-shepherd`);
             return;
         }
 
-        logger.info(`Zigbee publish to '${deviceID}', ${cid} - ${cmd} - ${JSON.stringify(zclData)} - ${ep}`);
-        device.functional(cid, cmd, zclData, callback);
+        logger.info(
+            `Zigbee publish to '${ieeAddr}', ${cid} - ${cmd} - ` +
+            `${JSON.stringify(zclData)} - ${JSON.stringify(cfg)} - ${ep}`
+        );
+
+        const callback_ = (error, rsp) => {
+            if (error) {
+                logger.error(
+                    `Zigbee publish to '${ieeAddr}', ${cid} - ${cmd} - ${JSON.stringify(zclData)} ` +
+                    `- ${JSON.stringify(cfg)} - ${ep} ` +
+                    `failed with error ${error}`);
+            }
+
+            callback(error, rsp);
+
+            // TODO: Send read reponse back to MQTT.
+        };
+
+        if (cmdType === 'functional') {
+            device.functional(cid, cmd, zclData, cfg, callback_);
+        } else if (cmdType === 'foundation') {
+            device.foundation(cid, cmd, zclData, cfg, callback_);
+        } else {
+            logger.error(`Unknown zigbee publish cmdType ${cmdType}`);
+        }
     }
 
-    read(deviceID, cid, attr, ep, callback) {
-        const device = this._findDevice(deviceID, ep);
-        if (!device) {
-            logger.error(`Zigbee cannot read attribute from device because '${deviceID}' not known by zigbee-shepherd`);
-            return;
-        }
-
-        device.read(cid, attr, callback);
+    networkScan(callback) {
+        logger.info('Starting network scan...');
+        this.shepherd.lqiScan().then((result) => {
+            logger.info('Network scan completed');
+            callback(result);
+        });
     }
 
     registerOnAfIncomingMsg(ieeeAddr, ep) {

package.json

@@ -1,12 +1,15 @@
 {
   "name": "zigbee2mqtt",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Zigbee to MQTT bridge using zigbee-shepherd",
   "main": "index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Koenkk/zigbee2mqtt.git"
   },
+  "engines": {
+    "node": ">=8.11 10"
+  },
   "keywords": [
     "xiaomi",
     "tradfri",
@@ -17,10 +20,12 @@
     "cc2531"
   ],
   "scripts": {
-    "start": "node index.js",
+    "coverage": "nyc --all report --reporter=text mocha --recursive --timeout=3000",
     "docgen": "node support/docgen.js",
-    "verify-homeassistant-mapping": "node support/verify-homeassistant-mapping.js",
-    "eslint": "node_modules/.bin/eslint ."
+    "eslint": "node_modules/.bin/eslint .",
+    "start": "node index.js",
+    "test": "mocha --recursive",
+    "verify-homeassistant-mapping": "node support/verify-homeassistant-mapping.js"
   },
   "author": "Koen Kanters",
   "license": "GPL-3.0",
@@ -29,18 +34,29 @@
   },
   "homepage": "https://github.com/Koenkk/zigbee2mqtt/wiki",
   "dependencies": {
-    "object-assign-deep": "*",
-    "mqtt": "*",
-    "winston": "2.4.2",
-    "zigbee-shepherd": "git+https://github.com/Koenkk/zigbee-shepherd.git",
-    "zigbee-shepherd-converters": "*",
-    "json2yaml": "*",
-    "zcl-packet": "git+https://github.com/Koenkk/zcl-packet.git",
+    "git-last-commit": "*",
     "js-yaml": "*",
-    "git-last-commit": "*"
+    "json2yaml": "*",
+    "mkdir-recursive": "*",
+    "moment": "*",
+    "mqtt": "*",
+    "object-assign-deep": "*",
+    "queue": "*",
+    "rimraf": "*",
+    "winston": "2.4.2",
+    "zcl-packet": "git+https://github.com/Koenkk/zcl-packet.git#fbd8c936bbd4be0597ad3e934be0ca722b0128a6",
+    "zigbee-shepherd": "git+https://github.com/Koenkk/zigbee-shepherd.git#c3fdef2c30267573aa5821a0f2c51f21a700eff2",
+    "zigbee-shepherd-converters": "5.0.1"
   },
   "devDependencies": {
+    "chai": "*",
+    "chai-spies": "*",
     "eslint": "*",
-    "eslint-config-google": "*"
+    "eslint-config-google": "*",
+    "eslint-plugin-mocha": "*",
+    "mocha": "*",
+    "nyc": "*",
+    "proxyquire": "*",
+    "sinon": "*"
   }
 }

support/docgen.js

@@ -63,7 +63,10 @@ text += '  will_message:\n';
 text += `    topic: 'hass/status'\n`;
 text += `    payload: 'offline'\n`;
 text += '```';
+text += '\n\n'
 
+text += 'Zigbee2mqtt is expecting Home Assistant to send it\'s birth/will messages to `hass/status`.'
+text += 'Be sure to add this to your `configuration.yaml` if you want zigbee2mqtt to resend the cached values when Home Assistant restarts'
 text += '\n\n'
 
 text += 'To respond to button clicks (e.g. WXKG01LM) you can use the following Home Assistant configuration:\n'

test/data.test.js

@@ -0,0 +1,23 @@
+/* global describe, it */
+
+const chai = require('chai');
+const proxyquire = require('proxyquire').noPreserveCache();
+const data = () => proxyquire('../lib/util/data.js', {});
+const path = require('path');
+
+describe('Data', () => {
+    describe('Get path', () => {
+        it('Should return correct path', () => {
+            const expected = path.normalize(path.join(__dirname, '..', 'data'));
+            const actual = data().getPath();
+            chai.assert.strictEqual(actual, expected);
+        });
+
+        it('Should return correct path when ZIGBEE2MQTT_DATA set', () => {
+            const expected = path.join('var', 'zigbee2mqtt');
+            process.env.ZIGBEE2MQTT_DATA = expected;
+            const actual = data().getPath();
+            chai.assert.strictEqual(actual, expected);
+        });
+    });
+});

test/devicePublish.test.js

@@ -0,0 +1,165 @@
+/* global describe, it */
+
+const chai = require('chai');
+const sinon = require('sinon');
+const DevicePublish = require('../lib/extension/devicePublish');
+const settings = require('../lib/util/settings');
+
+const mqtt = {
+    subscribe: (topic) => {},
+};
+
+describe('DevicePublish', () => {
+    let devicePublish;
+
+    beforeEach(() => {
+        devicePublish = new DevicePublish(null, mqtt, null, null);
+    });
+
+    describe('Parse topic', () => {
+        it('Should handle non-valid topics', () => {
+            const topic = 'zigbee2mqtt1/my_device_id/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed, null);
+        });
+
+        it('Should handle non-valid topics', () => {
+            const topic = 'zigbee2mqtt1/my_device_id/sett';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed, null);
+        });
+
+        it('Should handle non-valid topics', () => {
+            const topic = 'zigbee2mqtt/my_device_id/write';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed, null);
+        });
+
+        it('Should handle non-valid topics', () => {
+            const topic = 'zigbee2mqtt/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed, null);
+        });
+
+        it('Should handle non-valid topics', () => {
+            const topic = 'set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed, null);
+        });
+
+        it('Should parse set topic', () => {
+            const topic = 'zigbee2mqtt/my_device_id/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, 'my_device_id');
+            chai.assert.strictEqual(parsed.postfix, null);
+        });
+
+        it('Should parse get topic', () => {
+            const topic = 'zigbee2mqtt/my_device_id2/get';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'get');
+            chai.assert.strictEqual(parsed.deviceID, 'my_device_id2');
+            chai.assert.strictEqual(parsed.postfix, null);
+        });
+
+        it('Should parse topic with when base topic has multiple slashes', () => {
+            const stub = sinon.stub(settings, 'get').callsFake(() => {
+                return {
+                    mqtt: {
+                        base_topic: 'zigbee2mqtt/at/my/home',
+                    },
+                };
+            });
+
+            const topic = 'zigbee2mqtt/at/my/home/my_device_id2/get';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'get');
+            chai.assert.strictEqual(parsed.deviceID, 'my_device_id2');
+            chai.assert.strictEqual(parsed.postfix, null);
+            stub.restore();
+        });
+
+        it('Should parse topic with when deviceID has multiple slashes', () => {
+            const topic = 'zigbee2mqtt/floor0/basement/my_device_id2/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, 'floor0/basement/my_device_id2');
+            chai.assert.strictEqual(parsed.postfix, null);
+        });
+
+        it('Should parse topic with when base and deviceID have multiple slashes', () => {
+            const stub = sinon.stub(settings, 'get').callsFake(() => {
+                return {
+                    mqtt: {
+                        base_topic: 'zigbee2mqtt/at/my/basement',
+                    },
+                };
+            });
+
+            const topic = 'zigbee2mqtt/at/my/basement/floor0/basement/my_device_id2/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, 'floor0/basement/my_device_id2');
+            chai.assert.strictEqual(parsed.postfix, null);
+            stub.restore();
+        });
+
+        it('Should parse set with ieeAddr topic', () => {
+            const topic = 'zigbee2mqtt/0x12345689/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, '0x12345689');
+            chai.assert.strictEqual(parsed.postfix, null);
+        });
+
+        it('Should parse set with postfix topic', () => {
+            const topic = 'zigbee2mqtt/0x12345689/left/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, '0x12345689');
+            chai.assert.strictEqual(parsed.postfix, 'left');
+        });
+
+        it('Should parse set with postfix topic', () => {
+            const topic = 'zigbee2mqtt/0x12345689/right/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, '0x12345689');
+            chai.assert.strictEqual(parsed.postfix, 'right');
+        });
+
+        it('Should parse set with postfix topic', () => {
+            const topic = 'zigbee2mqtt/0x12345689/bottom_left/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, '0x12345689');
+            chai.assert.strictEqual(parsed.postfix, 'bottom_left');
+        });
+
+        it('Shouldnt parse set with invalid postfix topic', () => {
+            const topic = 'zigbee2mqtt/0x12345689/invalid/set';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'set');
+            chai.assert.strictEqual(parsed.deviceID, '0x12345689/invalid');
+            chai.assert.strictEqual(parsed.postfix, null);
+        });
+
+        it('Should parse set with and slashes in base and deviceID postfix topic', () => {
+            const stub = sinon.stub(settings, 'get').callsFake(() => {
+                return {
+                    mqtt: {
+                        base_topic: 'zigbee2mqtt/at/my/home',
+                    },
+                };
+            });
+
+            const topic = 'zigbee2mqtt/at/my/home/my/device/in/basement/sensor/bottom_left/get';
+            const parsed = devicePublish.parseTopic(topic);
+            chai.assert.strictEqual(parsed.type, 'get');
+            chai.assert.strictEqual(parsed.deviceID, 'my/device/in/basement/sensor');
+            chai.assert.strictEqual(parsed.postfix, 'bottom_left');
+            stub.restore();
+        });
+    });
+});

update.sh

@@ -0,0 +1,24 @@
+#!/bin/bash -e
+
+echo "Stopping zigbee2mqtt..."
+sudo systemctl stop zigbee2mqtt
+
+echo "Creating backup of configuration..."
+cp -R data data-backup
+
+echo "Updating..."
+git checkout HEAD -- npm-shrinkwrap.json
+git pull
+
+echo "Installing dependencies..."
+rm -rf node_modules
+npm install
+
+echo "Restore configuration..."
+cp -R data-backup/* data
+rm -rf data-backup
+
+echo "Starting zigbee2mqtt..."
+sudo systemctl start zigbee2mqtt
+
+echo "Done!"