iobroker.zigbee 2.0.0 → 2.0.1

package/lib/exclude.js

@@ -1,4 +1,5 @@
 'use strict';
+const devicedefinitions = require('./devices');
 
 class Exclude {
     constructor(adapter) {
@@ -9,6 +10,7 @@ class Exclude {
     start(zbController, stController) {
         this.zbController = zbController;
         this.stController = stController;
+        this.localConfig = stController.localConfig;
     }
 
     stop() {
@@ -52,6 +54,12 @@ class Exclude {
                             this.adapter.sendTo(obj.from, obj.command, exclude, obj.callback));
                     }
                     break;
+                case 'getExcludable':
+                    if (obj && obj.message && typeof obj.message === 'object') {
+                        this.getExcludable(exclude =>
+                            this.adapter.sendTo(obj.from, obj.command, exclude, obj.callback));
+                    }
+                    break;
                 case 'delExclude':
                     if (obj && obj.message) {
                         this.delExclude(obj.from, obj.command, obj.message, err =>
@@ -74,7 +82,7 @@ class Exclude {
     }
 
     extractExcludeId(stateId) {
-        return stateId.replace(`${this.adapter.namespace}.exclude.`, '');
+        return stateId.replace(`${this.adapter.namespace}.info.legacy.`, '');
     }
 
     getExcludeName(devName, stateId) {
@@ -83,18 +91,10 @@ class Exclude {
 
     async addExclude(from, command, params, callback) {
         try {
-            this.debug('addExclude message: ' + JSON.stringify(params));
+            //this.warn('addExclude message: ' + JSON.stringify(params));
             const exclude_mod = params.exclude_model.common.type;
-            const stateId = `exclude.${exclude_mod}`;
-
-            this.adapter.setObjectNotExists(stateId,
-                {
-                    type: 'state',
-                    common: {name: exclude_mod},
-                },
-                () => this.adapter.setState(stateId, exclude_mod, true, () =>
-                    callback()),
-            );
+            this.localConfig.updateLocalOverride(exclude_mod, exclude_mod, 'legacy', exclude_mod, true);
+            callback({});
         } catch (error) {
             this.error(`Failed to addExclude ${error.stack}`);
             throw new Error(`Failed to addExclude ${error.stack}`);
@@ -104,58 +104,34 @@ class Exclude {
     async delExclude(from, command, exclude_id, callback) {
         try {
             this.debug(`delExclude message: ${JSON.stringify(exclude_id)}`);
-            const stateId = `exclude.${exclude_id}`;
-            this.adapter.getStateAsync(stateId)
-                .then(async (stateV) => {
-                    this.debug(`found state: ${JSON.stringify(stateV)}`);
-                    this.adapter.deleteState(null, 'exclude', exclude_id, async () =>
-                        callback());
-                });
+            this.localConfig.updateLocalOverride(exclude_id, exclude_id, 'legacy', '', true);
+            callback({});
         } catch (error) {
             this.error(`Failed to delExclude ${error.stack}`);
             throw new Error(`Failed to delExclude ${error.stack}`);
         }
     }
 
-    getExclude(callback) {
+    async getExclude(callback) {
         try {
-            const exclude = [];
-            this.adapter.getStatesOf('exclude', (err, states) => {
-                if (!err && states) {
-                    const exc = [];
-                    states.forEach(state => {
-                        if (state._id.startsWith(`${this.adapter.namespace}.exclude`)) {
-                            exc.push(new Promise(resolve =>
-                                this.adapter.getStateAsync(state._id)
-                                    .then(stateVa => {
-                                        if (stateVa !== null) {
-                                            const val = {
-                                                id: this.extractExcludeId(state._id),
-                                                name: stateVa.val
-                                            };
-                                            if (this.extractExcludeId(state._id) !== 'all') {
-                                                exclude.push(val);
-                                            }
-                                        }
-                                        resolve();
-                                    })));
-                        }
-                    });
-                    return Promise.all(exc)
-                        .then(() => {
-                            const arrExclude = JSON.stringify(exclude);
-                            this.debug(`getExclude result: ${arrExclude}`);
-                            this.adapter.setState('exclude.all', arrExclude, true, () =>
-                                callback(exclude));
-                        });
-                } else {
-                    this.debug(`getExclude result: ${JSON.stringify(exclude)}`);
-                    callback(exclude);
-                }
-            });
+            const exclude = this.localConfig.getOverridesWithKey('legacy', true)
+            callback({legacy: exclude});
         } catch (error) {
             this.error(`Failed to getExclude ${error.stack}`);
+            callback({error: 'unable to get excludes' });
+        }
+    }
+
+    async getExcludable(callback) {
+        const devices = this.zbController.getClients();
+        const excludables = [];
+        for (const device of devices) {
+            const obj = await this.adapter.getObjectAsync(device.ieeeAddr.substr(2));
+            if (obj && obj.common && obj.common.type) {
+                excludables.push(obj.common.tyoe);
+            }
         }
+        callback(devices.pairedLegacyDevices(excludables));
     }
 }
 

package/lib/exposes.js

@@ -16,6 +16,7 @@ function genState(expose, role, name, desc) {
     const stateId = stname.replace(/\*/g, '');
     const stateName = (desc || expose.description || expose.name);
     const propName = expose.property;
+    // 'switch' | 'lock' | 'binary' | 'list' | 'numeric' | 'enum' | 'text' | 'composite' | 'light' | 'cover' | 'fan' | 'climate';
     switch (expose.type) {
         case 'binary':
             state = {
@@ -275,12 +276,24 @@ function createFromExposes(model, def) {
 
     return newDev;
 
-
+    function hasMultipleProperties(obj, prop, len) {
+        const l = (len ? len: Object.keys.length(obj));
+        if (l != prop.length) return false;
+        for (const key of prop) {
+            if (!obj.hasOwnProperty(key)) return false;
+        }
+        return true;
+    };
 
     function genStateFromExpose(expose) {
         let state;
         switch (expose.type) {
-            case 'light':
+            case 'light': {
+                let hasColorXY = false;
+                let hasColorHS = false;
+                let colorXYprop = undefined;
+                let colorHSprop = undefined;
+
                 for (const prop of expose.features) {
                     switch (prop.name) {
                         case 'state': {
@@ -364,237 +377,14 @@ function createFromExposes(model, def) {
                             pushToStates(statesDefs.colortemp_move, prop.access);
                             break;
                         }
-                        case 'color_xy': {
-                            const stateNameC = expose.endpoint ? `color_${expose.endpoint}` : 'color';
-                            pushToStates({
-                                id: stateNameC,
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Color ${expose.endpoint ? expose.endpoint : ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.rgb',
-                                write: true,
-                                read: true,
-                                type: 'string',
-                                setter: value => {
-                                    // convert RGB to XY for set
-                                    /*
-                                    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(value);
-                                    let xy = [0, 0];
-                                    if (result) {
-                                        const r = parseInt(result[1], 16),
-                                            g = parseInt(result[2], 16),
-                                            b = parseInt(result[3], 16);
-                                        xy = rgb.rgb_to_cie(r, g, b);
-                                    }
-                                    return {
-                                        x: xy[0],
-                                        y: xy[1]
-                                    };
-        */
-                                    let xy = [0, 0];
-                                    const rgbcolor = colors.ParseColor(value);
-
-                                    xy = rgb.rgb_to_cie(rgbcolor.r, rgbcolor.g, rgbcolor.b);
-                                    return {
-                                        x: xy[0],
-                                        y: xy[1],
-                                    };
-                                },
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    return {...options, transition: transitionTime};
-                                },
-                                getter: payload => {
-                                    if (payload.color && payload.color.hasOwnProperty('x') && payload.color.hasOwnProperty('y')) {
-                                        const colorval = rgb.cie_to_rgb(payload.color.x, payload.color.y);
-                                        return `#${utils.decimalToHex(colorval[0])}${utils.decimalToHex(colorval[1])}${utils.decimalToHex(colorval[2])}`;
-                                    } else {
-                                        return undefined;
-                                    }
-                                },
-                                epname: expose.endpoint,
-                                setattr: 'color',
-                            }, prop.access);
-                            break;
-                        }
+                        case 'color_xy':
+                            colorXYprop = prop;
+                            hasColorXY = true; break;
                         case 'color_hs': {
-                            const stateNameH = expose.endpoint ? `color_${expose.endpoint}` : 'color';
-                            pushToStates({
-                                id: stateNameH,
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Color ${expose.endpoint ? expose.endpoint : ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.rgb',
-                                write: true,
-                                read: true,
-                                type: 'string',
-                                setter: value => {
-                                    const _rgb = colors.ParseColor(value);
-                                    const hsv = rgb.rgbToHSV(_rgb.r, _rgb.g, _rgb.b, true);
-                                    return {
-                                        hue: Math.min(Math.max(hsv.h, 1), 359),
-                                        saturation: hsv.s,
-                                        //                                        brightness: Math.floor(hsv.v * 2.55),
-                                    };
-                                },
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    return {...options, transition: transitionTime};
-                                },
-                                epname: expose.endpoint,
-                                setattr: 'color',
-                            }, prop.access);
-                            pushToStates({
-                                id: expose.endpoint ? `hue_${expose.endpoint}` : 'hue',
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Hue ${expose.endpoint || ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.hue',
-                                write: true,
-                                read: false,
-                                type: 'number',
-                                min: 0,
-                                max: 360,
-                                inOptions: true,
-                                setter: (value, options) => {
-                                    return {
-                                        hue: value,
-                                        saturation: options.saturation,
-                                    };
-                                },
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    const hasHueCalibrationTable = options && options.hasOwnProperty('hue_calibration');
-                                    if (hasHueCalibrationTable)
-                                        try {
-                                            return {
-                                                ...options,
-                                                transition: transitionTime,
-                                                hue_correction: JSON.parse(options.hue_calibration)
-                                            };
-                                        } catch {
-                                            const hue_correction_table = [];
-                                            options.hue_calibration.split(',').forEach(element => {
-                                                const match = /([0-9]+):([0-9]+)/.exec(element);
-                                                if (match && match.length === 3)
-                                                    hue_correction_table.push({
-                                                        in: Number(match[1]),
-                                                        out: Number(match[2])
-                                                    });
-                                            });
-                                            if (hue_correction_table.length > 0) {
-                                                return {
-                                                    ...options,
-                                                    transition: transitionTime,
-                                                    hue_correction: hue_correction_table
-                                                };
-                                            }
-                                        }
-                                    return {...options, transition: transitionTime};
-                                },
-
-                            }, prop.access);
-                            pushToStates({
-                                id: expose.endpoint ? `saturation_${expose.endpoint}` : 'saturation',
-                                prop: expose.endpoint ? `color_${expose.endpoint}` : 'color',
-                                name: `Saturation ${expose.endpoint ? expose.endpoint : ''}`.trim(),
-                                icon: undefined,
-                                role: 'level.color.saturation',
-                                write: true,
-                                read: false,
-                                type: 'number',
-                                min: 0,
-                                max: 100,
-                                inOptions: true,
-                                setter: (value, options) => ({
-                                    hue: options.hue,
-                                    saturation: value,
-                                }),
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    const hasHueCalibrationTable = options && options.hasOwnProperty('hue_calibration');
-                                    if (hasHueCalibrationTable)
-                                        try {
-                                            return {
-                                                ...options,
-                                                transition: transitionTime,
-                                                hue_correction: JSON.parse(options.hue_calibration)
-                                            };
-                                        } catch {
-                                            const hue_correction_table = [];
-                                            options.hue_calibration.split(',').forEach(element => {
-                                                const match = /([0-9]+):([0-9]+)/.exec(element);
-                                                if (match && match.length === 3)
-                                                    hue_correction_table.push({
-                                                        in: Number(match[1]),
-                                                        out: Number(match[2])
-                                                    });
-                                            });
-                                            if (hue_correction_table.length > 0) {
-                                                return {
-                                                    ...options,
-                                                    transition: transitionTime,
-                                                    hue_correction: hue_correction_table
-                                                };
-                                            }
-                                        }
-                                    return {...options, transition: transitionTime};
-                                },
-
-                            }, prop.access);
+                            colorHSprop = prop;
+                            hasColorHS = true;
                             pushToStates(statesDefs.hue_move, prop.access);
                             pushToStates(statesDefs.saturation_move, prop.access);
-                            pushToStates({
-                                id: 'hue_calibration',
-                                prop: 'color',
-                                name: 'Hue color calibration table',
-                                icon: undefined,
-                                role: 'table',
-                                write: true,
-                                read: false,
-                                type: 'string',
-                                inOptions: true,
-                                setter: (value, options) => ({
-                                    hue: options.hue,
-                                    saturation: options.saturation,
-                                }),
-                                setterOpt: (value, options) => {
-                                    const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-                                    const transitionTime = hasTransitionTime ? options.transition_time : 0;
-                                    const hasHueCalibrationTable = options && options.hasOwnProperty('hue_calibration');
-                                    if (hasHueCalibrationTable)
-                                        try {
-                                            return {
-                                                ...options,
-                                                transition: transitionTime,
-                                                hue_correction: JSON.parse(options.hue_calibration)
-                                            };
-                                        } catch {
-                                            const hue_correction_table = [];
-                                            options.hue_calibration.split(',').forEach(element => {
-                                                const match = /([0-9]+):([0-9]+)/.exec(element);
-                                                if (match && match.length === 3) {
-                                                    hue_correction_table.push({
-                                                        in: Number(match[1]),
-                                                        out: Number(match[2])
-                                                    });
-                                                }
-                                            });
-                                            if (hue_correction_table.length > 0) {
-                                                return {
-                                                    ...options,
-                                                    transition: transitionTime,
-                                                    hue_correction: hue_correction_table
-                                                };
-                                            }
-                                        }
-                                    return {...options, transition: transitionTime};
-                                },
-                            }, prop.access);
                             break;
                         }
                         default:
@@ -602,9 +392,181 @@ function createFromExposes(model, def) {
                             break;
                     }
                 }
+                if (hasColorXY || hasColorHS) {
+                    const nameWithEp = expose.endpoint ? `color_${expose.endpoint}` : 'color';
+                    pushToStates({
+                        id: nameWithEp,
+                        name: `Color ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                        icon: undefined,
+                        role: 'level.color.rgb',
+                        write: true,
+                        read: true,
+                        type: 'string',
+                        setter: value => {
+                            try {
+                                // JSON
+                                const colorJSON = JSON.parse(value.replaceAll("'",'"'));
+                                const numProp = Object.keys(colorJSON).length;
+                                if (hasMultipleProperties(colorJSON, ['hsb'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hsl'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hsv'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['h','s','b'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['h','s','v'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['h','s','l'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hue', 'saturation'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['hex'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['rgb'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['x', 'y'], numProp)) return colorJSON;
+                                if (hasMultipleProperties(colorJSON, ['r', 'g', 'b'], numProp)) return colorJSON;
+                                //return { json:colorJSON, numProp:numProp, value:value };
+                            }
+                            catch (error) {
+                                //return { error: error.message };
+                            };
+                            // hex or named color
+                            const rgbcolor = colors.ParseColor(value);
+                            return rgbcolor;
+                        },
+                        setterOpt: (value, options) => {
+                            const hasTransitionTime = options && options.hasOwnProperty('transition_time');
+                            const transitionTime = hasTransitionTime ? options.transition_time : 0;
+                            return {...options, transition: transitionTime};
+                        },
+                        getter: payload => {
+                            if (typeof payload.color == 'object') {
+                                const colorJSON = payload.color;
+                                const color = JSON.stringify(colorJSON)
+                                const numProp = Object.keys(colorJSON);
+                                if (hasMultipleProperties(colorJSON, ['hsb'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hsl'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hsv'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','b'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','v'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','l'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hue', 'saturation'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['hex'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['rgb'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['x', 'y'], numProp)) return color;
+                                if (hasMultipleProperties(colorJSON, ['r', 'g', 'b'], numProp)) return color;
+                            }
+                            return undefined;
+                        },
+                        epname: expose.endpoint,
+                        setattr: 'color',
+                    }, (colorHSprop ? colorHSprop.access : colorXYprop.access));
+                    if (hasColorXY) {
+                        let channelWithEp = expose.endpoint ? `color_xy_${expose.endpoint}` : 'color_xy';
+                        pushToStates({
+                            id: `${channelWithEp}.x`,
+                            name: `X`,
+                            icon: undefined,
+                            role: 'level.color',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 1,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorXYprop.access);
+                        pushToStates({
+                            id: `${channelWithEp}.y`,
+                            name: `Y`,
+                            icon: undefined,
+                            role: 'level.color',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 1,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorXYprop.access);
+                        channelWithEp = expose.endpoint ? `color_rgb_${expose.endpoint}` : 'color_rgb';
+                        pushToStates({
+                            id: `${channelWithEp}.r`,
+                            name: `Red`,
+                            icon: undefined,
+                            role: 'level.color.red',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 255,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color',
+                            composites: [`${channelWithEp}.r`,`${channelWithEp}.g`]
+                        }, colorXYprop.access);
+                        pushToStates({
+                            id: `${channelWithEp}.g`,
+                            name: `Green`,
+                            icon: undefined,
+                            role: 'level.color.green',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 255,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color',
+                            composites: [`${channelWithEp}.x`,`${channelWithEp}.y`]
+                        });
+                        pushToStates({
+                            id: `${channelWithEp}.b`,
+                            name: `Blue`,
+                            icon: undefined,
+                            role: 'level.color.blue',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 255,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorXYprop.access);
+                    }
+                    if (hasColorHS) {
+                        const channelWithEp = expose.endpoint ? `color_hs_${expose.endpoint}` : 'color_hs';
+                        pushToStates({
+                            id: `${channelWithEp}.hue`,
+                            name: `Hue`,
+                            icon: undefined,
+                            role: 'level.color.hue',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 360,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorHSprop.access);
+                        pushToStates({
+                            id: `${channelWithEp}.saturation`,
+                            name: `Saturation`,
+                            icon: undefined,
+                            role: 'level.color',
+                            write: true,
+                            read: true,
+                            type: 'number',
+                            min: 0,
+                            max: 100,
+                            compositeKey: channelWithEp,
+                            compositeTimeout: 500,
+                            compositeState: 'color'
+                        }, colorHSprop.access);
+
+                    }
+                }
+
                 pushToStates(statesDefs.transition_time, ea.STATE_SET);
                 break;
-
+            }
             case 'switch':
                 for (const prop of expose.features) {
                     switch (prop.name) {
@@ -671,6 +633,7 @@ function createFromExposes(model, def) {
 
             case 'enum':
                 switch (expose.name) {
+
                     case 'action': {
                         // Ansatz:
 
@@ -911,16 +874,14 @@ function createFromExposes(model, def) {
     }
 
 }
-function applyExposes(mappedDevices, byModel, allExcludesObj) {
-    // for exclude search
-    const allExcludesStr = JSON.stringify(allExcludesObj);
-    // create or update device from exposes
+function applyExposes(mappedDevices, byModel) {
+    // create or device from exposes
     for (const deviceDef of zigbeeHerdsmanConverters.definitions) {
-        applyDeviceDef(mappedDevices, byModel, allExcludesStr, deviceDef);
+        applyDeviceDef(mappedDevices, byModel, deviceDef);
 
         if (deviceDef.hasOwnProperty('whiteLabel')) {
             for (const deviceWhiteLabel of deviceDef.whiteLabel) {
-                applyDeviceDef(mappedDevices, byModel, allExcludesStr, {
+                applyDeviceDef(mappedDevices, byModel, {
                     ...deviceDef,
                     model: deviceWhiteLabel.model,
                     vendor: deviceWhiteLabel.vendor,
@@ -931,20 +892,16 @@ function applyExposes(mappedDevices, byModel, allExcludesObj) {
     }
 }
 
-function applyDeviceDef(mappedDevices, byModel, allExcludesStr, deviceDef) {
+function applyDeviceDef(mappedDevices, byModel, deviceDef) {
     const stripModel = utils.getModelRegEx(deviceDef.model);
     const existsMap = byModel.get(stripModel);
 
-    if ((deviceDef.hasOwnProperty('exposes') && (!existsMap || !existsMap.hasOwnProperty('states'))) || allExcludesStr.indexOf(stripModel) > 0) {
+    if (deviceDef.hasOwnProperty('exposes') && (!existsMap || !existsMap.hasOwnProperty('states'))) {
         try {
             const newDevice = createFromExposes(stripModel, deviceDef);
-            if (!existsMap) {
-                mappedDevices.push(newDevice);
-                byModel.set(stripModel, newDevice);
-            } else {
-                existsMap.states = newDevice.states;
-                existsMap.exposed = true;
-            }
+            mappedDevices.push(newDevice);
+            byModel.set(stripModel, newDevice);
+
         } catch (e) {
             console.log(`Wrong expose device definition ${deviceDef.vendor} ${stripModel}`);
         }