iobroker.zigbee 3.2.5 → 3.3.1-alpha.0

package/lib/exposes.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
-const statesDefs = require('./states').states;
 const rgb = require('./rgb');
 const utils = require('./utils');
 const colors = require('./colors');
@@ -33,7 +32,7 @@ function genState(expose, role, name, desc) {
                 type: 'boolean',
             };
             if (readable) {
-                state.getter = payload => payload[propName] === (expose.value_on || 'ON');
+                state.getter = payload => payload[propName] === (typeof expose.value_on == 'boolean' ? expose.value_on : expose.value_on || 'ON');
             } else {
                 state.getter = payload => undefined;
             }
@@ -138,6 +137,7 @@ function genState(expose, role, name, desc) {
 }
 
 function createFromExposes(model, def, device, log) {
+    const { getStateDefinition } = require('./models');
     const states = [];
     // make the different (set and get) part of state is updatable if different exposes is used for get and set
     // as example:
@@ -251,9 +251,20 @@ function createFromExposes(model, def, device, log) {
         }
     }
 
+    function modifyState(state, properties, clone) {
+        const rv = clone ? {} : state;
+        if (clone) for (const prop of Object.keys(state))
+            rv[prop] = state[prop];
+        for (const prop of Object.keys(properties)) {
+            if (properties[prop] != undefined)
+                rv[prop] = properties[prop];
+        }
+        return rv;
+    }
+
     if (typeof def.exposes == 'object') {
         for (const expose of def.exposes) {
-            genStateFromExpose(expose);
+            genStateFromExpose(expose, def);
         }
     }
 
@@ -261,7 +272,7 @@ function createFromExposes(model, def, device, log) {
     if (typeof def.exposes == 'function') {
         const expFunction = def.exposes((device === undefined || device === null) ? {isDummyDevice: true} : device, {});   // maybee here check manufacturerName for tuya devices
         for (const expose of expFunction) {
-            genStateFromExpose(expose);
+            genStateFromExpose(expose, def);
         }
     }
     const icon = utils.getDeviceIcon(def);
@@ -276,7 +287,7 @@ function createFromExposes(model, def, device, log) {
     return newDev;
 
     function hasMultipleProperties(obj, prop, len) {
-        const l = (len ? len: Object.keys.length(obj));
+        const l = (len ? len: Object.keys(obj).length);
         if (l != prop.length) return false;
         for (const key of prop) {
             if (!obj.hasOwnProperty(key)) return false;
@@ -284,7 +295,16 @@ function createFromExposes(model, def, device, log) {
         return true;
     };
 
-    function genStateFromExpose(expose) {
+    function definitionHasTZHandler(definition, id) {
+        const tz = definition?.herdsmanModel?.toZigbee;
+        for (const converter of tz) {
+            if (converter.key.includes(id))
+                return true;
+        }
+        return false;
+    }
+
+    function genStateFromExpose(expose, deviceDefinition) {
         let state;
         switch (expose.type) {
             case 'light': {
@@ -297,6 +317,15 @@ function createFromExposes(model, def, device, log) {
                     switch (prop.name) {
                         case 'state': {
                             const stateNameS = expose.endpoint ? `state_${expose.endpoint}` : 'state';
+                            pushToStates(modifyState( getStateDefinition('state'), {
+                                id:stateNameS,
+                                name: `Switch state ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                getter: (payload) => (payload[stateNameS] === (prop.value_on || 'ON')),
+                                epname: expose.endpoint,
+                                setterOpt: undefined,
+                                setattr:'state',
+                            }, true), prop.access);
+                            /*
                             pushToStates({
                                 id: stateNameS,
                                 name: `Switch state ${expose.endpoint ? expose.endpoint : ''}`.trim(),
@@ -309,15 +338,22 @@ function createFromExposes(model, def, device, log) {
                                 setter: (value) => (value) ? prop.value_on || 'ON' : ((prop.value_off != undefined) ? prop.value_off : 'OFF'),
                                 epname: expose.endpoint,
                                 setattr: 'state',
-                            }, prop.access);
+                            }, prop.access);*/
                             break;
                         }
 
                         case 'brightness': {
                             const stateNameB = expose.endpoint ? `brightness_${expose.endpoint}` : 'brightness';
-                            pushToStates({
+                            pushToStates(modifyState(getStateDefinition('brightness'), {
                                 id: stateNameB,
                                 name: `Brightness ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                getter: payload => utils.bulbLevelToAdapterLevel(payload[stateNameB]),
+                                epname: expose.endpoint,
+                                setattr: 'brightness',
+                            }, true), prop.access);
+                            /*pushToStates({
+                                id: expose.endpoint ? `brightness_${expose.endpoint}` : 'brightness',
+                                name: `Brightness ${expose.endpoint ? expose.endpoint : ''}`.trim(),
                                 icon: undefined,
                                 role: 'level.dimmer',
                                 write: true,
@@ -344,29 +380,33 @@ function createFromExposes(model, def, device, log) {
                                 epname: expose.endpoint,
                                 setattr: 'brightness',
                             }, prop.access);
-                            //pushToStates(statesDefs.brightness_move, prop.access);
-                            pushToStates({
-                                id: 'brightness_move',
-                                prop: 'brightness_move',
-                                name: `Dimming ${expose.endpoint ? expose.endpoint : ''}`.trim(),
-                                icon: undefined,
-                                role: 'state',
-                                write: true,
-                                read: false,
-                                type: 'number',
-                                min: -50, // ignore expose.value_min
-                                max: 50, // ignore expose.value_max
-                                epname: expose.endpoint,
-                                setattr: 'brightness_move',
-                            }, prop.access);
-                            //pushToStates(statesDefs.brightness_move, prop.access);
+                            */
+                            if (definitionHasTZHandler(deviceDefinition, 'brightness_move')) {
+                                const setattr = definitionHasTZHandler(deviceDefinition, 'brightness_move_onoff') ? 'brightness_move_onoff':'brightness_move';
+                                pushToStates(modifyState(getStateDefinition('brightness_move'), {
+                                    id: expose.endpoint ? `brightness_move_${expose.endpoint}` : 'brightness_move',
+                                    name: `Dimming ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                    write: true,
+                                    read: false,
+                                    epname: expose.endpoint,
+                                    setattr: setattr,
+                                }, true), prop.access);
+                            }
                             break;
                         }
                         case 'color_temp': {
                             const stateNameT = expose.endpoint ? `colortemp_${expose.endpoint}` : 'colortemp';
-                            pushToStates(
+                            pushToStates(modifyState(getStateDefinition('colortemp'), {
+                                id: expose.endpoint ? `colortemp_${expose.endpoint}` : 'colortemp',
+                                prop: expose.endpoint ? `color_temp_${expose.endpoint}` : 'color_temp',
+                                name: `Color temperature ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                epname: expose.endpoint,
+                                getter: payload => payload[stateNameT] || payload[expose.endpoint ? `color_temp_${expose.endpoint}` : 'color_temp'],
+                                setattr: 'color_temp',
+                            }, true), prop.access);
+                            /*pushToStates(
                                 {
-                                    id: stateNameT,
+                                    id: expose.endpoint ? `colortemp_${expose.endpoint}` : 'colortemp',
                                     prop: expose.endpoint ? `color_temp_${expose.endpoint}` : 'color_temp',
                                     name: `Color temperature ${expose.endpoint ? expose.endpoint : ''}`.trim(),
                                     icon: undefined,
@@ -387,8 +427,15 @@ function createFromExposes(model, def, device, log) {
                                     epname: expose.endpoint,
                                     setattr: 'color_temp',
                                 },
-                                prop.access);
-                            pushToStates(statesDefs.colortemp_move, prop.access);
+                                prop.access);*/
+                            if (definitionHasTZHandler(deviceDefinition, 'colortemp_move'))
+                                pushToStates(modifyState(getStateDefinition('colortemp_move'), {
+                                    id: expose.endpoint ? `colortemp_move_${expose.endpoint}` : 'colortemp_move',
+                                    prop: expose.endpoint ? `colortemp_move_${expose.endpoint}` : 'colortemp_move',
+                                    name: `Shift color temperature ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                    setattr: 'colortemp_move',
+                                    epname: expose.endpoint,
+                                }, true), prop.access);
                             break;
                         }
                         case 'color_xy':
@@ -397,8 +444,22 @@ function createFromExposes(model, def, device, log) {
                         case 'color_hs': {
                             colorHSprop = prop;
                             hasColorHS = true;
-                            pushToStates(statesDefs.hue_move, prop.access);
-                            pushToStates(statesDefs.saturation_move, prop.access);
+                            if (definitionHasTZHandler(deviceDefinition, 'hue_move'))
+                                pushToStates(modifyState(getStateDefinition('hue_move'), {
+                                    id: expose.endpoint ? `hue_move_${expose.endpoint}` : 'hue_move',
+                                    prop: expose.endpoint ? `hue_move_${expose.endpoint}`:'hue_move',
+                                    name: `Hue shift ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                    epname: expose.endpoint,
+                                    setattr: 'hue_move'
+                                },true), prop.access);
+                            if (definitionHasTZHandler(deviceDefinition, 'saturation_move'))
+                                pushToStates(modifyState(getStateDefinition('saturation_move'), {
+                                    id: expose.endpoint ? `saturation_move${expose.endpoint}` : 'saturation_move',
+                                    prop: expose.endpoint ? `saturation_move${expose.endpoint}`:'saturation_move',
+                                    name: `Saturation shift ${expose.endpoint ? expose.endpoint : ''}`.trim(),
+                                    epname: expose.endpoint,
+                                    setattr: 'saturation_move'
+                                },true), prop.access);
                             break;
                         }
                         default:
@@ -493,18 +554,19 @@ function createFromExposes(model, def, device, log) {
                             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;
+                                //const numProp = Object.keys(colorJSON).length;
+                                if (hasMultipleProperties(colorJSON, ['hsb'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['hsl'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['hsv'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','b'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','v'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['h','s','l'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['hue', 'saturation'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['h', 's'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['hex'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['rgb'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['x', 'y'])) return color;
+                                if (hasMultipleProperties(colorJSON, ['r', 'g', 'b'])) return color;
                             }
                             return undefined;
                         },
@@ -591,6 +653,7 @@ function createFromExposes(model, def, device, log) {
                         const channelWithEp = expose.endpoint ? `color_hs_${expose.endpoint}` : 'color_hs';
                         pushToStates({
                             id: `${channelWithEp}.hue`,
+                            prop:'color',
                             name: `Hue`,
                             icon: undefined,
                             role: 'level.color.hue',
@@ -601,13 +664,21 @@ function createFromExposes(model, def, device, log) {
                             max: 360,
                             compositeKey: channelWithEp,
                             compositeTimeout: 500,
-                            compositeState: 'color'
+                            compositeState: 'color',
+                            getter: (payload) => {
+                                if (typeof payload.color == 'object') {
+                                    if (payload.color?.hue) {
+                                        return payload.color.hue;
+                                    }
+                                }
+                            }
                         }, colorHSprop.access);
                         pushToStates({
                             id: `${channelWithEp}.saturation`,
+                            prop:'color',
                             name: `Saturation`,
                             icon: undefined,
-                            role: 'level.color',
+                            role: 'level.color.saturation',
                             write: true,
                             read: true,
                             type: 'number',
@@ -615,13 +686,20 @@ function createFromExposes(model, def, device, log) {
                             max: 100,
                             compositeKey: channelWithEp,
                             compositeTimeout: 500,
-                            compositeState: 'color'
+                            compositeState: 'color',
+                            getter: (payload) => {
+                                if (typeof payload.color == 'object') {
+                                    if (payload.color?.saturation) {
+                                        return payload.color.saturation;
+                                    }
+                                }
+                            }
                         }, colorHSprop.access);
 
                     }
                 }
 
-                pushToStates(statesDefs.transition_time, ea.STATE_SET);
+                pushToStates(getStateDefinition('transition_time'), ea.STATE_SET);
                 break;
             }
             case 'switch':
@@ -647,35 +725,45 @@ function createFromExposes(model, def, device, log) {
                             break;
 
                         case 'battery':
-                            state = statesDefs.battery;
+                            state = modifyState(genState(expose, 'value.battery'), {
+                                icon:'img/battery_p.png',
+                            });
+                            //state = getStateDefinition('battery');
                             break;
 
                         case 'voltage':
-                            state = genState(expose);
+                            state = genState(expose, 'level.voltage');
+                            // state = getStateDefinition('voltage')
                             break;
 
                         case 'temperature':
-                            state = statesDefs.temperature;
+                            state = genState(expose, 'value.temperature');
+                            //state = getStateDefinition('temperature');
                             break;
 
                         case 'humidity':
-                            state = statesDefs.humidity;
+                            state = genState(expose, 'value.humidity');
+                            //state = getStateDefinition('humidity');
                             break;
 
                         case 'pressure':
-                            state = statesDefs.pressure;
+                            state = genState(expose, 'value.pressure');
+                            //state = getStateDefinition('pressure');
                             break;
 
                         case 'illuminance':
-                            state = statesDefs.illuminance_raw;
+                            state = genState(expose, 'value.brightness', 'illuminance_raw' )
+                            //state = getStateDefinition('illuminance_raw');
                             break;
 
                         case 'illuminance_lux':
-                            state = statesDefs.illuminance;
+                            state = genState(expose, 'value.brightness', 'illuminance');
+                            //state = getStateDefinition('illuminance');
                             break;
 
                         case 'power':
-                            state = statesDefs.load_power;
+                            state = genState(expose, 'value.power', 'load_power');
+                            //state = getStateDefinition('load_power');
                             break;
 
                         default:
@@ -759,29 +847,50 @@ function createFromExposes(model, def, device, log) {
                     state = genState(expose);
                 } else {
                     switch (expose.name) {
-                        case 'contact':
-                            state = statesDefs.contact;
-                            pushToStates(statesDefs.opened, ea.STATE);
+                        case 'contact': {
+                            state = modifyState(genState(expose, 'sensor'), { getter: payload => payload.contact });
+                            // state = getStateDefinition('contact');
+                            pushToStates(modifyState(genState(expose, 'sensor'), {
+                                id:'opened',
+                                name:'Is open',
+                                role:'sensor.contact',
+                                getter: payload => !payload.contact,
+                            }), ea.STATE);
+                            //pushToStates(getStateDefinition('opened'), ea.STATE);
                             break;
-
+                        }
                         case 'battery_low':
-                            state = statesDefs.heiman_batt_low;
+                            state = genState(expose,'indicator.lowbat', expose.name, 'Battery Status Low');
                             break;
 
                         case 'tamper':
-                            state = statesDefs.tamper;
+                            state = modifyState(genState(expose, 'indicator', 'tampered'), {
+                                prop:'tamper',
+                                name:'Is tampered'
+                            });
                             break;
 
                         case 'water_leak':
-                            state = statesDefs.water_detected;
+                            state = modifyState(genState(expose, 'indicator', 'detected'), {
+                                prop:'water_leak',
+                                name:'Water leak detected'
+                            })
+                            // state = getStateDefinition('water_detected');
                             break;
 
                         case 'lock':
-                            state = statesDefs.child_lock;
+                            state = modifyState(genState(expose, 'switch.lock'), {
+                                prop: 'child_lock',
+                                name: 'Locked',
+                                getter: payload => (payload.child_lock === 'LOCKED'),
+                                setter: (value) => (value) ? 'LOCK': 'UNLOCK',
+                            });
+                            // state = getStateDefinition('child_lock');
                             break;
 
                         case 'occupancy':
-                            state = statesDefs.occupancy;
+                            state = genState(expose, 'sensor.motion');
+                            //state = getStateDefinition('occupancy');
                             break;
 
                         default:
@@ -816,20 +925,6 @@ function createFromExposes(model, def, device, log) {
 
             case 'climate':
                 for (const prop of expose.features) {
-                    /* switch (prop.name) {
-                        case 'away_mode':
-                            pushToStates(statesDefs.climate_away_mode, prop.access);
-                            break;
-                        case 'system_mode':
-                            pushToStates(statesDefs.climate_system_mode, prop.access);
-                            break;
-                        case 'running_mode':
-                            pushToStates(statesDefs.climate_running_mode, prop.access);
-                            break;
-                        default:
-                            pushToStates(genState(prop), prop.access);
-                            break;
-                    }*/
                     pushToStates(genState(prop), prop.access);
                 }
                 break;
@@ -963,6 +1058,20 @@ async function applyExposeForDevice(mappedDevices, byModel, device, options) {
     return applyDeviceDef(mappedDevices, byModel, deviceDef, device);
 }
 
+async function applyHerdsmanModel(modelDesc) {
+    try {
+        const newModel = createFromExposes(modelDesc.key, modelDesc, modelDesc.device)
+        if (newModel) {
+            if (modelDesc.UUID) newModel.UUID = modelDesc.UUID;
+        }
+        return { newModel:newModel, message:'', error:'' };
+    }
+    catch (error) {
+        return { model:undefined, message:'Error in applyHerdsmanModel', error:error};
+    }
+}
+
+
 function applyDeviceDef(mappedDevices, byModel, deviceDef, device) {
     const stripModel = utils.getModelRegEx(deviceDef.model);
     const existsMap = byModel.get(stripModel);
@@ -982,4 +1091,5 @@ function applyDeviceDef(mappedDevices, byModel, deviceDef, device) {
 
 module.exports = {
     applyExposeForDevice: applyExposeForDevice,
+    applyHerdsmanModel: applyHerdsmanModel,
 };

package/lib/groups.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const json = require('./json');
-const statesMapping = require('./devices');
+const stateDefinitions = require('./models');
 const idRegExp = new RegExp(/group_(\d+)/);
 const { getZbId , getAdId } = require('./utils');
 
@@ -64,7 +64,7 @@ class Groups {
         this.GroupUpdateQueue = []
         this.zbController.on('published', this.onGroupStatePublished.bind(this));
         this.stController.on('changed', this.onDeviceStateChanged.bind(this));
-        this.syncGroups();
+        this.syncGroups(true);
     }
 
     stop() {
@@ -108,6 +108,8 @@ class Groups {
                 case 'updateGroupMembership':
                     this.updateGroupMembership(obj.from, obj.command, obj.message, obj.callback);
                     break;
+                case 'syncGroups':
+                    this.syncGroupsCallback(obj);
             }
         }
     }
@@ -370,6 +372,11 @@ class Groups {
         return response.groups;
     }
 
+    async syncGroupsCallback(obj) {
+        await this.syncGroups(true);
+        this.adapter.sendTo(obj.from, obj.command, obj.message, obj.callback);
+    }
+
     async updateGroupMembership(from, command, message, callback) {
         try {
             const groups = message && message.groups ? message.groups : {};
@@ -406,7 +413,7 @@ class Groups {
                     }
                 }
             }
-            this.syncGroups(GroupsToSync);
+            this.syncGroups(false,GroupsToSync);
         } catch (e) {
             this.warn('caught error ' + JSON.stringify(e) + ' in updateGroupMembership');
             this.adapter.sendTo(from, command, {error: e}, callback);
@@ -483,12 +490,13 @@ class Groups {
             }
         }
         this.debug(`rename group name ${message.name}, id ${id}, remove ${JSON.stringify(message.removeMembers)}`);
-        this.syncGroups([parseInt(message.id)]);
+        this.syncGroups(false, [parseInt(message.id)]);
     }
 
     addMissingState(arr, states) {
         if (typeof arr != 'object') arr = [];
         for (const state of [...states]) {
+            if (state === undefined) continue;
             if (arr.find((candidate) => candidate == state.id)=== undefined) arr.push(state.id)
         }
         return arr;
@@ -496,17 +504,17 @@ class Groups {
 
     async getGroupMemberCapabilities(members) {
         // const rv = [];
-        const rv = this.addMissingState([],statesMapping.commonGroupStates);
+        const rv = this.addMissingState([],stateDefinitions.commonGroupStates);
         for (const member of members) {
             const entity = await this.zbController.resolveEntity(member.ieee, member.epid);
             if (!entity) continue;
             if (entity.endpoint.inputClusters.includes(6)) { // genOnOff
-                this.addMissingState(rv,statesMapping.onOffStates);
+                this.addMissingState(rv,stateDefinitions.onOffStates);
             }
             if (entity.endpoint.inputClusters.includes(768)) { //genLightingColorCtrl
-                this.addMissingState(rv, statesMapping.lightStatesWithColor);
+                this.addMissingState(rv, stateDefinitions.lightStatesWithColor);
             } else if (entity.endpoint.inputClusters.includes(8)) { // genLvlControl
-                this.addMissingState(rv,statesMapping.lightStates);
+                this.addMissingState(rv,stateDefinitions.lightStates);
             }
         }
         return rv;
@@ -609,7 +617,7 @@ class Groups {
         return val;
     }
 
-    async syncGroups(group_id) {
+    async syncGroups(changed, group_id) {
         const numericGroupIdArray = [];
         if (group_id) group_id.forEach(gid => numericGroupIdArray.push(Groups.extractGroupID(gid)));
         // get all group id's from the database and the respective names from the local overrides (if present)
@@ -624,7 +632,7 @@ class Groups {
                 const members = await this.zbController.getGroupMembersFromController(j);
                 const memberInfo = { capabilities: [], members: [] };
                 const storedGroupInfo = this.GroupData.hasOwnProperty(id) ? this.GroupData[id] : { capabilities: [], members: [] };
-                let GroupMembersChanged = false;
+                let GroupMembersChanged = changed;
                 if (members) for (const member of members) {
                     const entity = await this.zbController.resolveEntity(member.ieee, member.epid);
                     let epname = undefined;
@@ -668,15 +676,16 @@ class Groups {
                     }, () => {
                         this.adapter.extendObject(id, {common: {name: name, type: 'group', icon: icon}});
                         // create writable states for groups from their devices
-                        for (const stateInd in statesMapping.groupStates) {
-                            if (!statesMapping.groupStates.hasOwnProperty(stateInd)) {
+                        for (const stateInd in stateDefinitions.groupStates) {
+                            if (!stateDefinitions.groupStates.hasOwnProperty(stateInd)) {
                                 continue;
                             }
-                            const statedesc = statesMapping.groupStates[stateInd];
+                            const statedesc = stateDefinitions.groupStates[stateInd];
                             const common = {};
-                            for (const prop in statedesc) common[prop] = statedesc[prop];
+                            for (const prop in statedesc)
+                                if (typeof statedesc[prop] != 'function')
+                                    common[prop] = statedesc[prop];
                             common.color= memberInfo.capabilities.find((candidate) => candidate == statedesc.id) ? null: '#888888';
-
                             this.stController.updateState(id, statedesc.id, undefined, common);
                         }
                         resolve();
@@ -694,6 +703,10 @@ class Groups {
                             if ( dev.native.id && !usedGroupsIds.includes(dev.native.id)) {
                                 this.stController.deleteObj(`group_${dev.native.id}`);
                             }
+                            else {
+                                // mark disconnected group states
+                                this.stController.deleteOrphanedDeviceStates(dev.native.id, 'group', false, undefined, true);
+                            }
                         }
                     });
                 }

package/lib/{devices.js → legacy/devices.js}

@@ -1,9 +1,9 @@
 'use strict';
 
 const states = require('./states.js').states;
-const utils = require('./utils.js');
-const rgb = require('./rgb.js');
-const { applyExposeForDevice} = require('./exposes.js');
+const utils = require('../utils.js');
+const rgb = require('../rgb.js');
+const { applyExposeForDevice} = require('../exposes.js');
 
 
 // return list of changing states when incoming state is changed
@@ -307,6 +307,30 @@ const generator = {
                     setattr: 'state',
                 });
             }
+            if (endpoint.supportsInputCluster('haElectricalMeasurement')) {
+                devstates.push({
+                    id: `channel_${epID}.voltage`,
+                    prop: `voltage_${epName}`,
+                    name: `voltage state ${epID}`,
+                    icon: undefined,
+                    write: false,
+                    read: true,
+                    type: 'number',
+                    getter: payload => payload[`voltage_${epName}`],
+                });
+            }
+            if (endpoint.supportsInputCluster('msTemperatureMeasurement')) {
+                devstates.push({
+                    id: `channel_${epID}.temper`,
+                    prop: `temperature_${epName}`,
+                    name: `temperature state ${epID}`,
+                    icon: undefined,
+                    write: false,
+                    read: true,
+                    type: 'number',
+                    getter: payload => payload[`temperature_${epName}`],
+                });
+            }
             if (endpoint.supportsOutputCluster('genMultistateInput') || endpoint.clusters.hasOwnProperty('genMultistateInput'))
             {
                 devstates.push({

package/lib/{states.js → legacy/states.js}

@@ -2,9 +2,9 @@
 
 /*eslint no-unused-vars: ['off']*/
 
-const rgb = require(__dirname + '/rgb.js');
-const utils = require(__dirname + '/utils.js');
-const colors = require(__dirname + '/colors.js');
+const rgb = require('../rgb.js');
+const utils = require('../utils.js');
+const colors = require('../colors.js');
 
 /* states for device:
    id - sysname of state, id