iobroker.zigbee 1.8.24 → 1.9.0

package/io-package.json

@@ -1,8 +1,60 @@
 {
   "common": {
     "name": "zigbee",
-    "version": "1.8.24",
+    "version": "1.9.0",
     "news": {
+      "1.9.0": {
+        "en": "up to new zhc\nupdate dependency",
+        "de": "bis zum neuen zhc\naktualisierung abhängigkeit",
+        "ru": "до нового жк\nобновление зависимости",
+        "pt": "até novo zhc\ndependência de atualização",
+        "nl": "♪\nvertaling:",
+        "fr": "jusqu'au nouveau zhc\nmettre à jour la dépendance",
+        "it": "fino a nuovo zhc\ndipendenza da aggiornamento",
+        "es": "hasta nuevo zhc\nactualización de la dependencia",
+        "pl": "do nowego żc\nzależności",
+        "uk": "до нового жк\nоновлення залежності",
+        "zh-cn": "新的忠诚\n更新"
+      },
+      "1.8.27": {
+        "en": "update dependency",
+        "de": "aktualisierung abhängigkeit",
+        "ru": "обновление зависимости",
+        "pt": "dependência de atualização",
+        "nl": "vertaling:",
+        "fr": "mettre à jour la dépendance",
+        "it": "dipendenza da aggiornamento",
+        "es": "actualización de la dependencia",
+        "pl": "zależności",
+        "uk": "оновлення залежності",
+        "zh-cn": "更新"
+      },
+      "1.8.26": {
+        "en": "corr toZigbee message\nadd deviceManager",
+        "de": "corr toZigbee Nachricht\nadd-Gerät Manager",
+        "ru": "corr toZigbee сообщение\nдобавить устройство менеджер",
+        "pt": "mensagem de corrija\nadicionar dispositivo Gerente",
+        "nl": "vertaling:\nvoeg Manager",
+        "fr": "corr toZigbee message\najouter le dispositif Manager",
+        "it": "corr aZigbee messaggio\naggiungere dispositivo Manager",
+        "es": "corr toZigbee message\nañadir dispositivo Manager",
+        "pl": "kor toZigbee message\ndodać manager",
+        "uk": "corr toZigbee повідомлення\nдодати пристрій Менеджер",
+        "zh-cn": "信\n增加装置 管理人员"
+      },
+      "1.8.25": {
+        "en": "zhc 16.x \ncorr group from exclude dialog",
+        "de": "zhc 16.x\nkorr gruppe aus ausschluss dialog",
+        "ru": "жк 16.x\nгруппа корр от исключает диалог",
+        "pt": "zhc 16.x\ncorr grupo de excluir diálogo",
+        "nl": "zhc 16\ncorr groep uitgesloten dialog",
+        "fr": "zhc 16.x\ngroupe corr de l'exclusion du dialogue",
+        "it": "zhc 16.x\ngruppo corr da escludere finestra di dialogo",
+        "es": "zhc 16.x\ngrupo de corr de excluir diálogo",
+        "pl": "żc 16.x\ngrupa kor z wyłączeniem dialogu",
+        "uk": "жк 16.x\nгрупа з виключення діалогу",
+        "zh-cn": "页: 1\n集团排除了口号"
+      },
       "1.8.24": {
         "en": "switch to exposes tab for some Aqara Devices",
         "de": "schalter, um die Registerkarte für einige Aqara-Geräte freizusetzen",
@@ -41,58 +93,6 @@
         "pl": "w przypadku, gdy meta jest pusta",
         "uk": "аварійний випадок, коли мета",
         "zh-cn": "c 当元空时发生事故"
-      },
-      "1.8.21": {
-        "en": "no converter found",
-        "de": "kein konverter gefunden",
-        "ru": "не найдено конвертер",
-        "pt": "não encontrado",
-        "nl": "geen converter gevonden",
-        "fr": "aucun convertisseur trouvé",
-        "it": "nessun convertitore trovato",
-        "es": "no convertidor encontrado",
-        "pl": "nie znaleziono konwerterów",
-        "uk": "не знайдено",
-        "zh-cn": "未找到转换器"
-      },
-      "1.8.20": {
-        "en": "add log",
-        "de": "log",
-        "ru": "добавить лог",
-        "pt": "adicionar log",
-        "nl": "voeg logboek toe",
-        "fr": "ajouter log",
-        "it": "aggiungi log",
-        "es": "añadir registro",
-        "pl": "dodać",
-        "uk": "увійти",
-        "zh-cn": "增 编"
-      },
-      "1.8.19": {
-        "en": "fix occupancy_timeout\nfix battery percentage and voltage",
-        "de": "fix occupation_timeout\nbatterieanteil und spannung fixieren",
-        "ru": "исправить occupancy_timeout\nисправить процент батареи и напряжение",
-        "pt": "corrigir ocupação_timeout\ncorrigir a porcentagem da bateria e a tensão",
-        "nl": "vertaling:\nvertaling:",
-        "fr": "fix occupancy_timeout\nfixer le pourcentage de la batterie et la tension",
-        "it": "fix occupazione_timeout\ncorreggere la percentuale della batteria e la tensione",
-        "es": "arreglar ocupación_timeout\nfijar porcentaje de batería y tensión",
-        "pl": "naprawa occupancy_time\nodsetek baterii i napięcia",
-        "uk": "фіксувати occupancy_timeout\nфіксувати відсоток акумулятора і напруга",
-        "zh-cn": "fix 占用:时间假\nfix 电池百分比和火山"
-      },
-      "1.8.18": {
-        "en": "little fix sentry and error log\n",
-        "de": "kleines fix-sende- und fehlerprotokoll\n",
-        "ru": "мало исправлена отправка и ошибка журнала\n",
-        "pt": "pequena correção sentinela e log de erro\n",
-        "nl": "kleine herstellende sentimentele logboek\n",
-        "fr": "petit journal de réparation et d'erreur\n",
-        "it": "piccolo fix registro di errore\n",
-        "es": "pequeño solucion centry y error log\n",
-        "pl": "wadliwość i błąd\n",
-        "uk": "маленька фіксація відправлень і журнал помилок\n",
-        "zh-cn": "很少发送过材料和错误逻辑\n"
       }
     },
     "titleLang": {
@@ -145,6 +145,9 @@
     "loglevel": "info",
     "type": "hardware",
     "materialize": true,
+    "supportedMessages": {
+      "deviceManager": true
+    },
     "messagebox": true,
     "stopBeforeUpdate": true,
     "dataFolder": "zigbee_%INSTANCE%",

package/lib/developer.js

@@ -100,17 +100,23 @@ class Developer {
             return;
         }
         const cfg = obj.message.hasOwnProperty('cfg') ? obj.message.cfg : null;
-
-        const publishTarget = this.zbController.getDevice(devId) ? devId : this.zbController.getGroup(parseInt(devId));
-        if (!publishTarget) {
-            this.adapter.sendTo(obj.from, obj.command, {localErr: `Device or group ${devId} not found!`}, obj.callback);
-            return;
+        let publishTarget;
+        try {
+            publishTarget = this.zbController.getDevice(devId) ? devId : this.zbController.getGroup(parseInt(devId));
+            if (!publishTarget) {
+                this.adapter.sendTo(obj.from, obj.command, {localErr: `Device or group ${devId} not found!`}, obj.callback);
+                return;
+            }
+        } catch (error) {
+            this.error(`SendToZigbee failed from publishTarget ${devId} (${error})`);
         }
+
         if (!cid || !cmd) {
             this.adapter.sendTo(obj.from, obj.command, {localErr: 'Incomplete data (cid or cmd)'}, obj.callback);
             return;
         }
         this.debug(`Ready to send (ep: ${ep}, cid: ${cid}, cmd ${cmd.name}, zcl: ${JSON.stringify(zclData)})`);
+
         try {
             await this.zbController.publish(publishTarget, cid, cmd.name, zclData, cfg, ep, cmdType, (err, msg) => {
                 // map err and msg in one object for sendTo

package/lib/devicemgmt.js

@@ -0,0 +1,393 @@
+const dmUtils = require('@jey-cee/dm-utils');
+const humanizeDuration = require('humanize-duration');
+
+class dmZigbee extends dmUtils.DeviceManagement {
+
+    async getInstanceInfo() {
+        const data = {
+            ...super.getInstanceInfo(),
+            apiVersion: 'v1',
+            actions: [
+                {
+                    id: 'refresh',
+                    icon: 'fas fa-redo-alt',
+                    title: '',
+                    description: {
+                        en: 'Refresh device list',
+                        de: 'Geräteliste aktualisieren',
+                        ru: 'Обновить список устройств',
+                        pt: 'Atualizar lista de dispositivos',
+                        nl: 'Vernieuw apparaatlijst',
+                        fr: 'Actualiser la liste des appareils',
+                        it: 'Aggiorna elenco dispositivi',
+                        es: 'Actualizar lista de dispositivos',
+                        pl: 'Odśwież listę urządzeń',
+
+                        uk: 'Оновити список пристроїв'
+                    },
+                    handler: this.handleRefresh.bind(this)
+                },
+                {
+                    id: 'newDevice',
+                    icon: 'fas fa-plus',
+                    title: '',
+                    description: {
+                        en: 'Add new device to Zigbee',
+                        de: 'Neues Gerät zu Zigbee hinzufügen',
+                        ru: 'Добавить новое устройство в Zigbee',
+                        pt: 'Adicionar novo dispositivo ao Zigbee',
+                        nl: 'Voeg nieuw apparaat toe aan Zigbee',
+                        fr: 'Ajouter un nouvel appareil à Zigbee',
+                        it: 'Aggiungi nuovo dispositivo a Zigbee',
+                        es: 'Agregar nuevo dispositivo a Zigbee',
+                        pl: 'Dodaj nowe urządzenie do Zigbee',
+
+                        uk: 'Додати новий пристрій до Zigbee'
+                    },
+                    handler: this.handleNewDevice.bind(this)
+                }
+            ],
+        };
+        return data;
+    }
+
+    async handleRefresh(context) {
+        this.adapter.log.info('handleRefresh');
+        return { refresh: true };
+    }
+
+    async handleNewDevice(context) {
+        this.adapter.log.info('handleNewDevice');
+
+        const res = await this.adapter.zbController.permitJoin(permitTime);
+
+        const permitTime = this.adapter.config.countDown;
+
+        const progress = await context.openProgress('Searching...', { label: '0%' });
+        await this.delay(500);
+        for (let i = 1; i <= permitTime; i += 1) {
+            await this.delay(300);
+            this.log.info(`Progress at ${i}%`);
+            await progress.update({ value: i, label: `${i}%` });
+        }
+
+        await this.delay(1000);
+        await progress.close();
+
+        return { refresh: true };
+    }
+
+
+
+    async listDevices() {
+        const devices = await this.adapter.getDevicesAsync();
+        const arrDevices = [];
+        for (const i in devices) {
+            const status = {};
+
+            if (devices[i].common.type == 'group') continue;
+
+            const available = await this.adapter.getStateAsync(`${devices[i]._id}.available`);
+            if(available !== null && available !== undefined) {
+                status.connection = available.val ? 'connected' : 'disconnected';
+            }
+
+            const link_quality = await this.adapter.getStateAsync(`${devices[i]._id}.link_quality`);
+            if(link_quality) {
+                status.rssi = link_quality.val;
+            }
+
+            const battery = await this.adapter.getStateAsync(`${devices[i]._id}.battery`);
+            if(battery) {
+                status.battery = battery.val;
+            }
+
+            let hastDetails = false;
+            // Check if device has native.Sender_ID
+            if(devices[i].native.id) {
+                hastDetails = true;
+            }
+
+            const deviceInfo = await this.adapter.zbController.getDevice('0x'+devices[i].native.id);
+
+            const res = {
+                id: devices[i]._id,
+                name: devices[i].common.name,
+                icon: devices[i].common.icon ? '/adapter/zigbee/' + devices[i].common.icon : null,
+                manufacturer: `${deviceInfo._manufacturerName}`  ,
+                model: `${deviceInfo._modelID}`,
+                status: status,
+                hasDetails: hastDetails,
+                actions: [
+                    /*           {
+                        id: 'delete',
+                        icon: 'fa-solid fa-trash-can',
+                        description: {
+                            en: 'Delete this device',
+                            de: 'Gerät löschen',
+                            ru: 'Удалить это устройство',
+                            pt: 'Excluir este dispositivo',
+                            nl: 'Verwijder dit apparaat',
+                            fr: 'Supprimer cet appareil',
+                            it: 'Elimina questo dispositivo',
+                            es: 'Eliminar este dispositivo',
+                            pl: 'Usuń to urządzenie',
+                            'zh-cn': '删除此设备',
+                            uk: 'Видалити цей пристрій'
+                        },
+                        handler: this.handleDeleteDevice.bind(this)
+                    },*/
+                    {
+                        id: 'rename',
+                        icon: 'fa-solid fa-pen',
+                        description: {
+                            en: 'Rename this device',
+                            de: 'Gerät umbenennen',
+                            ru: 'Переименовать это устройство',
+                            pt: 'Renomear este dispositivo',
+                            nl: 'Hernoem dit apparaat',
+                            fr: 'Renommer cet appareil',
+                            it: 'Rinomina questo dispositivo',
+                            es: 'Renombrar este dispositivo',
+                            pl: 'Zmień nazwę tego urządzenia',
+                            'zh-cn': '重命名此设备',
+                            uk: 'Перейменуйте цей пристрій'
+                        },
+                        handler: this.handleRenameDevice.bind(this)
+                    }
+                ]
+            };
+            // if id contains gateway remove res.actions
+            if(devices[i]._id.includes('gateway')) {
+                res.actions = [];
+            }
+            arrDevices.push(res);
+        }
+        return arrDevices;
+    }
+
+    async getDeviceDetails(id, action, context) {
+        this.adapter.log.info('getDeviceDetails');
+        const devices = await this.adapter.getDevicesAsync();
+        const device = devices.find(d => d._id === id);
+        if(!device) {
+            return {error: 'Device not found'};
+        }
+        if(!device.native.id) {
+            return null;
+        }
+
+        const deviceInfo = await this.adapter.zbController.getDevice('0x'+ device.native.id);
+        const lastSeen = await this.formatDate(deviceInfo._lastSeen);
+
+        const items = {};
+
+        for (const devInfo in deviceInfo._endpoints[0].inputClusters) {
+
+            const val = deviceInfo._endpoints[0].inputClusters[devInfo];
+            const valType = typeof val;
+
+            if (valType != 'object') {
+                const item = {
+                    ['inputCluster'+devInfo]: {
+                        type: 'staticText',
+                        text: `inputCluster ${devInfo} : ${val}`,
+                        newLine: true,
+                    },
+                };
+                Object.assign(items,item);
+            }
+
+        }
+
+        const data = {
+            id: deviceInfo._ieeeAddr,
+            schema: {
+                type: 'tabs',
+                items: {
+                    _tab_Start: {
+                        type: 'panel',
+                        label: 'Main',
+
+                        items: {
+                            header_Start: {
+                                type: 'header',
+                                text: `${device.common.name} ${deviceInfo._ieeeAddr}`,
+                                size: 3,
+                            },
+                            _link: {
+                                label: `Manufacturer: ${deviceInfo._manufacturerName}`,
+                                type: 'staticLink',
+                                href: `https://www.zigbee2mqtt.io/supported-devices/#v=${deviceInfo._manufacturerName}`,
+                                button: true,
+                            },
+                            _link2: {
+                                label: `Model : ${device.common.type}`,
+                                type: 'staticLink',
+                                href: `https://www.zigbee2mqtt.io/devices/${device.common.type}.html`,
+                                button: true,
+                            },
+                            _softwareBuildID: {
+                                type: 'staticText',
+                                text: `<b>Software Build Id:</b> ${deviceInfo._softwareBuildID}`,
+                                style: {
+                                    fontSize: 14
+                                }
+                            },
+
+                            _divider2: {
+                                type: 'divider',
+                                color: 'primary',
+                            },
+                            _interviewCompleted: {
+                                type: 'checkbox',
+                                label: `Interview completed`,
+                                checked: deviceInfo._interviewCompleted == 1 ?  'true' : 'false',
+                                disabled: 'true',
+                                newLine: true,
+                            },
+                            _configure: {
+                                type: 'checkbox',
+                                label: 'is Configured',
+                                help: 'if it possible',
+                                checked: deviceInfo.meta.configured == 1 ?  'true' : 'false',
+                                disabled: 'true',
+                            },
+                            _lastSeen: {
+                                type: 'staticText',
+                                text: `<b>Last seen:</b> ${lastSeen}`,
+                            },
+                            _manufacturerID: {
+                                type: 'staticText',
+                                text: `<b>Manufacturer Id:</b> ${deviceInfo._manufacturerID}`,
+                                newLine: true,
+                            },
+                            _network: {
+                                type: 'staticText',
+                                text: `<b>Network address:</b> 0x${deviceInfo._networkAddress}`,
+                            },
+                            _type: {
+                                type: 'staticText',
+                                text: `<b>Device Type:</b> ${deviceInfo._type}`,
+                            },
+                            _powered: {
+                                type: 'staticText',
+                                text: deviceInfo._powerSource ? `<b>Power:</b> ${deviceInfo._powerSource.toUpperCase()}` : ``,
+                            },
+                            _maxListeners: {
+                                type: 'staticText',
+                                text: `<b>max Listeners:</b> ${deviceInfo._maxListeners}`,
+                            },
+                        },
+                    },
+                    _tab_Details: {
+                        type: 'panel',
+                        label: 'Details',
+                        items,
+                    },
+                },
+            },
+        };
+
+        return data;
+    }
+
+    async handleDeleteDevice(id, context) {
+        const devId = id.replace(/zigbee\.\d\./, '');
+        const deviceInfo = await this.adapter.zbController.getDevice('0x'+  devId);
+
+
+        const response = await context.showConfirmation({
+            en: `Do you really want to delete the device ${deviceInfo._ieeeAddr}?`,
+            de: `Möchten Sie das Gerät ${deviceInfo._ieeeAddr} wirklich löschen?`,
+            ru: `Вы действительно хотите удалить устройство ${deviceInfo._ieeeAddr}?`,
+            pt: `Você realmente deseja excluir o dispositivo ${deviceInfo._ieeeAddr}?`,
+            nl: `Weet u zeker dat u het apparaat ${deviceInfo._ieeeAddr} wilt verwijderen?`,
+            fr: `Voulez-vous vraiment supprimer l'appareil ${deviceInfo._ieeeAddr} ?`,
+            it: `Vuoi davvero eliminare il dispositivo ${deviceInfo._ieeeAddr}?`,
+            es: `¿Realmente desea eliminar el dispositivo ${deviceInfo._ieeeAddr}?`,
+            pl: `Czy na pewno chcesz usunąć urządzenie ${deviceInfo._ieeeAddr}?`,
+            'zh-cn': `您真的要删除设备 ${deviceInfo._ieeeAddr} 吗？`,
+            uk: `Ви дійсно бажаєте видалити пристрій ${deviceInfo._ieeeAddr}?`
+        });
+
+
+        // delete device
+        if(response === false) {
+            return {refresh: false};
+        }
+        const res = await this.adapter.leaveDevice('0x'+  devId);
+
+        if (res !== null) {
+            this.adapter.log.info(`${devId} deleted`);
+            return {refresh: true};
+        } else {
+            this.adapter.log.error(`Can not delete device ${devId}: ${JSON.stringify(res)}`);
+            return {refresh: false};
+        }
+    }
+
+    async handleRenameDevice(id, context) {
+        const result = await context.showForm({
+            type : 'panel',
+            items: {
+                newName: {
+                    type: 'text',
+                    trim: false,
+                    placeholder: '',
+                }
+            }}, {
+            data: {
+                newName: ''
+            },
+            title: {
+                en: 'Enter new name',
+                de: 'Neuen Namen eingeben',
+                ru: 'Введите новое имя',
+                pt: 'Digite um novo nome',
+                nl: 'Voer een nieuwe naam in',
+                fr: 'Entrez un nouveau nom',
+                it: 'Inserisci un nuovo nome',
+                es: 'Ingrese un nuevo nombre',
+                pl: 'Wpisz nowe imię',
+                'zh-cn': '输入新名称',
+                uk: 'Введіть нове ім\'я'
+            }
+        });
+        if (result == undefined || result.newName == '') {
+            return {refresh: false};
+        }
+
+        const obj = {
+            common: {
+                name: result.newName
+            }
+        };
+        const res = await this.adapter.extendObjectAsync(id, obj);
+        this.adapter.log.info(JSON.stringify(res));
+        if (res === null) {
+            this.adapter.log.warn(`Can not rename device ${context.id}: ${JSON.stringify(res)}`);
+
+        }
+
+        return {refresh: true};
+    }
+
+    async formatDate(time, type) {   //'ISO_8601' | 'ISO_8601_local' | 'epoch' | 'relative'
+        if (type === 'ISO_8601') return new Date(time).toISOString();
+        else if (type === 'ISO_8601_local') return this.toLocalISOString(new Date(time));
+        else if (type === 'epoch') return time;
+        else { // relative
+            const ago = humanizeDuration(Date.now() - time, {language: 'en', largest: 2, round: true}) + ' ago';
+            return ago;
+        }
+    }
+
+    toLocalISOString(d) {
+        const off = d.getTimezoneOffset();
+        return new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes() - off, d.getSeconds(), d.getMilliseconds()).toISOString();
+    }
+
+}
+
+module.exports = dmZigbee;

package/lib/devices.js

@@ -3041,6 +3041,10 @@ const devices = [
     },
 
     /* ------------ images only for admin ------------------- */
+    {
+        models: ['LED1923R5/LED1925G6'],
+        icon: 'img/LED1923R5.png',
+    },
     {
         models: ['E1812'],
         icon: 'img/ikea_E1812.png',

package/lib/exposes.js

@@ -5,7 +5,7 @@ const statesDefs = require('./states.js').states;
 const rgb = require('./rgb.js');
 const utils = require('./utils.js');
 const colors = require('./colors.js');
-const ea = zigbeeHerdsmanConverters.exposes.access;
+const ea = require('zigbee-herdsman-converters/lib/exposes.js').access;
 
 function genState(expose, role, name, desc) {
     let state;

package/lib/statescontroller.js

@@ -8,7 +8,7 @@ const fs = require('fs');
 const request = require('request');
 
 let savedDeviceNames = {};
-let knownUndefinedDevices = {};
+const knownUndefinedDevices = {};
 
 class StatesController extends EventEmitter {
     constructor(adapter) {
@@ -138,7 +138,7 @@ class StatesController extends EventEmitter {
         const result = {};
         // find model states for options and get it values
         const devStates = await this.getDevStates('0x' + devId, model);
-        if (devStates == null || devStates == undefined) {
+        if (devStates == null || devStates == undefined || devStates.states == null || devStates.states == undefined) {
             callback(result);
             return;
         }

package/lib/utils.js

@@ -108,7 +108,7 @@ function flatten(arr) {
 
 const forceEndDevice = flatten(
     ['QBKG03LM', 'QBKG04LM', 'ZNMS13LM', 'ZNMS12LM']
-        .map(model => zigbeeHerdsmanConverters.devices.find((d) => d.model === model))
+        .map(model => zigbeeHerdsmanConverters.findByModel(model))
         .map(mappedModel => mappedModel.zigbeeModel));
 
 // Xiaomi uses 4151 and 4447 (lumi.plug) as manufacturer ID.

package/lib/zbDeviceAvailability.js

@@ -7,11 +7,11 @@ const utils = require('./utils');
 // 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'),
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === '53170161'),
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === 'V3-BTZB'),
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === 'SPZB0001'),
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === '014G2461')
+    zigbeeHerdsmanConverters.findByModel('E11-G13'),
+    zigbeeHerdsmanConverters.findByModel('53170161'),
+    zigbeeHerdsmanConverters.findByModel('V3-BTZB'),
+    zigbeeHerdsmanConverters.findByModel('SPZB0001'),
+    zigbeeHerdsmanConverters.findByModel('014G2461')
 ];
 
 // asgothian: 29.12.2020: Removed color and color_temp from readable

package/lib/zbDeviceConfigure.js

@@ -4,10 +4,10 @@ const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const BaseExtension = require('./zbBaseExtension');
 
 const forcedConfigureOnEachStart = [
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === 'V3-BTZB'),
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === '014G2461'),
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === 'SPZB0001'),
-    zigbeeHerdsmanConverters.devices.find((d) => d.model === 'ZK03840')
+    zigbeeHerdsmanConverters.findByModel('V3-BTZB'),
+    zigbeeHerdsmanConverters.findByModel('014G2461'),
+    zigbeeHerdsmanConverters.findByModel('SPZB0001'),
+    zigbeeHerdsmanConverters.findByModel('ZK03840')
 ];
 
 class DeviceConfigure extends BaseExtension {
@@ -130,13 +130,15 @@ class DeviceConfigure extends BaseExtension {
     }
 
     async doConfigure(device, mappedDevice) {
-        this.info(`Configuring ${device.ieeeAddr} ${device.modelID}`);
         const coordinatorEndpoint = await this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
         try {
-            await mappedDevice.configure(device, coordinatorEndpoint, this);
-            device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
-            device.save();
-            this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
+            if (mappedDevice !== undefined) {
+                this.info(`Configuring ${device.ieeeAddr} ${device.modelID}`);
+                await mappedDevice.configure(device, coordinatorEndpoint, this);
+                device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
+                device.save();
+                this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
+            }
         } catch (error) {
             this.sendError(error);
             this.error(