zigbee-herdsman-converters 14.0.519 → 14.0.522

package/converters/fromZigbee.js

@@ -7270,59 +7270,6 @@ const converters = {
             };
         },
     },
-    ubisys_dimmer_setup: {
-        cluster: 'manuSpecificUbisysDimmerSetup',
-        type: ['attributeReport', 'readResponse'],
-        convert: (model, msg, publish, options, meta) => {
-            if (msg.data.hasOwnProperty('capabilities')) {
-                const capabilities = msg.data.capabilities;
-                const forwardPhaseControl = capabilities & 1;
-                const reversePhaseControl = (capabilities & 2) >>> 1;
-                const reactanceDiscriminator = (capabilities & 0x20) >>> 5;
-                const configurableCurve = (capabilities & 0x40) >>> 6;
-                const overloadDetection = (capabilities & 0x80) >>> 7;
-                return {
-                    capabilities_forward_phase_control: forwardPhaseControl ? true : false,
-                    capabilities_reverse_phase_control: reversePhaseControl ? true : false,
-                    capabilities_reactance_discriminator: reactanceDiscriminator ? true : false,
-                    capabilities_configurable_curve: configurableCurve ? true : false,
-                    capabilities_overload_detection: overloadDetection ? true : false,
-                };
-            }
-            if (msg.data.hasOwnProperty('status')) {
-                const status = msg.data.status;
-                const forwardPhaseControl = status & 1;
-                const reversePhaseControl = (status & 2) >>> 1;
-                const overload = (status & 8) >>> 3;
-                const capacitiveLoad = (status & 0x40) >>> 6;
-                const inductiveLoad = (status & 0x80) >>> 7;
-                return {
-                    status_forward_phase_control: forwardPhaseControl ? true : false,
-                    status_reverse_phase_control: reversePhaseControl ? true : false,
-                    status_overload: overload ? true : false,
-                    status_capacitive_load: capacitiveLoad ? true : false,
-                    status_inductive_load: inductiveLoad ? true : false,
-                };
-            }
-            if (msg.data.hasOwnProperty('mode')) {
-                const mode = msg.data.mode;
-                const phaseControl = mode & 3;
-                const phaseControlValues = {0: 'automatic', 1: 'forward', 2: 'reverse'};
-                return {
-                    mode_phase_control: phaseControlValues[phaseControl],
-                };
-            }
-        },
-    },
-    ubisys_dimmer_setup_genLevelCtrl: {
-        cluster: 'genLevelCtrl',
-        type: ['attributeReport', 'readResponse'],
-        convert: (model, msg, publish, options, meta) => {
-            if (msg.data.hasOwnProperty('ubisysMinimumOnLevel')) {
-                return {minimum_on_level: msg.data.ubisysMinimumOnLevel};
-            }
-        },
-    },
     itcmdr_clicks: {
         cluster: 'genMultistateInput',
         type: ['readResponse', 'attributeReport'],

package/converters/toZigbee.js

@@ -20,13 +20,6 @@ const manufacturerOptions = {
     hue: {manufacturerCode: herdsman.Zcl.ManufacturerCode.PHILIPS},
     ikea: {manufacturerCode: herdsman.Zcl.ManufacturerCode.IKEA_OF_SWEDEN},
     sinope: {manufacturerCode: herdsman.Zcl.ManufacturerCode.SINOPE_TECH},
-    /*
-     * Ubisys doesn't accept a manufacturerCode on some commands
-     * This bug has been reported, but it has not been fixed:
-     * https://github.com/Koenkk/zigbee-herdsman/issues/52
-     */
-    ubisys: {manufacturerCode: herdsman.Zcl.ManufacturerCode.UBISYS},
-    ubisysNull: {manufacturerCode: null},
     tint: {manufacturerCode: herdsman.Zcl.ManufacturerCode.MUELLER_LICHT_INT},
     legrand: {manufacturerCode: herdsman.Zcl.ManufacturerCode.VANTAGE, disableDefaultResponse: true},
     viessmann: {manufacturerCode: herdsman.Zcl.ManufacturerCode.VIESSMAN_ELEKTRO},
@@ -2734,6 +2727,17 @@ const converters = {
             await entity.read('aqaraOpple', [0x0002], manufacturerOptions.xiaomi);
         },
     },
+    RTCGQ14LM_trigger_indicator: {
+        key: ['trigger_indicator'],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = {true: 1, false: 0};
+            await entity.write('aqaraOpple', {0x0152: {value: lookup[value], type: 0x20}}, manufacturerOptions.xiaomi);
+            return {state: {trigger_indicator: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x0152], manufacturerOptions.xiaomi);
+        },
+    },
     LLKZMK11LM_interlock: {
         key: ['interlock'],
         convertSet: async (entity, key, value, meta) => {
@@ -4395,421 +4399,6 @@ const converters = {
             }
         },
     },
-    ubisys_configure_j1: {
-        key: ['configure_j1'],
-        convertSet: async (entity, key, value, meta) => {
-            const log = (message) => {
-                meta.logger.warn(`ubisys: ${message}`);
-            };
-            const sleepSeconds = async (s) => {
-                return new Promise((resolve) => setTimeout(resolve, s * 1000));
-            };
-            const waitUntilStopped = async () => {
-                let operationalStatus = 0;
-                do {
-                    await sleepSeconds(2);
-                    operationalStatus = (await entity.read('closuresWindowCovering',
-                        ['operationalStatus'])).operationalStatus;
-                } while (operationalStatus != 0);
-                await sleepSeconds(2);
-            };
-            const writeAttrFromJson = async (attr, jsonAttr = attr, converterFunc, delaySecondsAfter) => {
-                if (jsonAttr.startsWith('ubisys')) {
-                    jsonAttr = jsonAttr.substring(6, 1).toLowerCase + jsonAttr.substring(7);
-                }
-                if (value.hasOwnProperty(jsonAttr)) {
-                    let attrValue = value[jsonAttr];
-                    if (converterFunc) {
-                        attrValue = converterFunc(attrValue);
-                    }
-                    const attributes = {};
-                    attributes[attr] = attrValue;
-                    await entity.write('closuresWindowCovering', attributes, manufacturerOptions.ubisys);
-                    if (delaySecondsAfter) {
-                        await sleepSeconds(delaySecondsAfter);
-                    }
-                }
-            };
-            const stepsPerSecond = value.steps_per_second || 50;
-            const hasCalibrate = value.hasOwnProperty('calibrate');
-            // cancel any running calibration
-            let mode = (await entity.read('closuresWindowCovering', ['windowCoveringMode'])).windowCoveringMode;
-            const modeCalibrationBitMask = 0x02;
-            if (mode & modeCalibrationBitMask) {
-                await entity.write('closuresWindowCovering', {windowCoveringMode: mode & ~modeCalibrationBitMask});
-                await sleepSeconds(2);
-            }
-            // delay a bit if reconfiguring basic configuration attributes
-            await writeAttrFromJson('windowCoveringType', undefined, undefined, 2);
-            await writeAttrFromJson('configStatus', undefined, undefined, 2);
-            if (await writeAttrFromJson('windowCoveringMode', undefined, undefined, 2)) {
-                mode = value['windowCoveringMode'];
-            }
-            if (hasCalibrate) {
-                log('Cover calibration starting...');
-                // first of all, move to top position to not confuse calibration later
-                log('  Moving cover to top position to get a good starting point...');
-                await entity.command('closuresWindowCovering', 'upOpen');
-                await waitUntilStopped();
-                log('  Settings some attributes...');
-                // reset attributes
-                await entity.write('closuresWindowCovering', {
-                    installedOpenLimitLiftCm: 0,
-                    installedClosedLimitLiftCm: 240,
-                    installedOpenLimitTiltDdegree: 0,
-                    installedClosedLimitTiltDdegree: 900,
-                    ubisysLiftToTiltTransitionSteps: 0xffff,
-                    ubisysTotalSteps: 0xffff,
-                    ubisysLiftToTiltTransitionSteps2: 0xffff,
-                    ubisysTotalSteps2: 0xffff,
-                }, manufacturerOptions.ubisys);
-                // enable calibration mode
-                await sleepSeconds(2);
-                await entity.write('closuresWindowCovering', {windowCoveringMode: mode | modeCalibrationBitMask});
-                await sleepSeconds(2);
-                // move down a bit and back up to detect upper limit
-                log('  Moving cover down a bit...');
-                await entity.command('closuresWindowCovering', 'downClose');
-                await sleepSeconds(5);
-                await entity.command('closuresWindowCovering', 'stop');
-                await sleepSeconds(2);
-                log('  Moving up again to detect upper limit...');
-                await entity.command('closuresWindowCovering', 'upOpen');
-                await waitUntilStopped();
-                log('  Moving down to count steps from open to closed...');
-                await entity.command('closuresWindowCovering', 'downClose');
-                await waitUntilStopped();
-                log('  Moving up to count steps from closed to open...');
-                await entity.command('closuresWindowCovering', 'upOpen');
-                await waitUntilStopped();
-            }
-            // now write any attribute values present in JSON
-            await writeAttrFromJson('installedOpenLimitLiftCm');
-            await writeAttrFromJson('installedClosedLimitLiftCm');
-            await writeAttrFromJson('installedOpenLimitTiltDdegree');
-            await writeAttrFromJson('installedClosedLimitTiltDdegree');
-            await writeAttrFromJson('ubisysTurnaroundGuardTime');
-            await writeAttrFromJson('ubisysLiftToTiltTransitionSteps');
-            await writeAttrFromJson('ubisysTotalSteps');
-            await writeAttrFromJson('ubisysLiftToTiltTransitionSteps2');
-            await writeAttrFromJson('ubisysTotalSteps2');
-            await writeAttrFromJson('ubisysAdditionalSteps');
-            await writeAttrFromJson('ubisysInactivePowerThreshold');
-            await writeAttrFromJson('ubisysStartupSteps');
-            // some convenience functions to not have to calculate
-            await writeAttrFromJson('ubisysTotalSteps', 'open_to_closed_s', (s) => s * stepsPerSecond);
-            await writeAttrFromJson('ubisysTotalSteps2', 'closed_to_open_s', (s) => s * stepsPerSecond);
-            await writeAttrFromJson('ubisysLiftToTiltTransitionSteps', 'lift_to_tilt_transition_ms',
-                (s) => s * stepsPerSecond / 1000);
-            await writeAttrFromJson('ubisysLiftToTiltTransitionSteps2', 'lift_to_tilt_transition_ms',
-                (s) => s * stepsPerSecond / 1000);
-            if (hasCalibrate) {
-                log('  Finalizing calibration...');
-                // disable calibration mode again
-                await sleepSeconds(2);
-                await entity.write('closuresWindowCovering', {windowCoveringMode: mode & ~modeCalibrationBitMask});
-                await sleepSeconds(2);
-                // re-read and dump all relevant attributes
-                log('  Done - will now read back the results.');
-                converters.ubisys_configure_j1.convertGet(entity, key, meta);
-            }
-        },
-        convertGet: async (entity, key, meta) => {
-            const log = (json) => {
-                meta.logger.warn(`ubisys: Cover configuration read: ${JSON.stringify(json)}`);
-            };
-            log(await entity.read('closuresWindowCovering', [
-                'windowCoveringType',
-                'physicalClosedLimitLiftCm',
-                'physicalClosedLimitTiltDdegree',
-                'installedOpenLimitLiftCm',
-                'installedClosedLimitLiftCm',
-                'installedOpenLimitTiltDdegree',
-                'installedClosedLimitTiltDdegree',
-            ]));
-            log(await entity.read('closuresWindowCovering', [
-                'configStatus',
-                'windowCoveringMode',
-                'currentPositionLiftPercentage',
-                'currentPositionLiftCm',
-                'currentPositionTiltPercentage',
-                'currentPositionTiltDdegree',
-                'operationalStatus',
-            ]));
-            log(await entity.read('closuresWindowCovering', [
-                'ubisysTurnaroundGuardTime',
-                'ubisysLiftToTiltTransitionSteps',
-                'ubisysTotalSteps',
-                'ubisysLiftToTiltTransitionSteps2',
-                'ubisysTotalSteps2',
-                'ubisysAdditionalSteps',
-                'ubisysInactivePowerThreshold',
-                'ubisysStartupSteps',
-            ], manufacturerOptions.ubisys));
-        },
-    },
-    ubisys_dimmer_setup: {
-        key: ['capabilities_forward_phase_control',
-            'capabilities_reverse_phase_control',
-            'capabilities_reactance_discriminator',
-            'capabilities_configurable_curve',
-            'capabilities_overload_detection',
-            'status_forward_phase_control',
-            'status_reverse_phase_control',
-            'status_overload',
-            'status_capacitive_load',
-            'status_inductive_load',
-            'mode_phase_control'],
-        convertSet: async (entity, key, value, meta) => {
-            if (key === 'mode_phase_control') {
-                const phaseControl = value.toLowerCase();
-                const phaseControlValues = {'automatic': 0, 'forward': 1, 'reverse': 2};
-                utils.validateValue(phaseControl, Object.keys(phaseControlValues));
-                await entity.write('manuSpecificUbisysDimmerSetup',
-                    {'mode': phaseControlValues[phaseControl]}, manufacturerOptions.ubisysNull);
-            }
-            converters.ubisys_dimmer_setup.convertGet(entity, key, meta);
-        },
-        convertGet: async (entity, key, meta) => {
-            await entity.read('manuSpecificUbisysDimmerSetup', ['capabilities'], manufacturerOptions.ubisysNull);
-            await entity.read('manuSpecificUbisysDimmerSetup', ['status'], manufacturerOptions.ubisysNull);
-            await entity.read('manuSpecificUbisysDimmerSetup', ['mode'], manufacturerOptions.ubisysNull);
-        },
-    },
-    ubisys_dimmer_setup_genLevelCtrl: {
-        key: ['minimum_on_level'],
-        convertSet: async (entity, key, value, meta) => {
-            if (key === 'minimum_on_level') {
-                await entity.write('genLevelCtrl', {'ubisysMinimumOnLevel': value}, manufacturerOptions.ubisys);
-            }
-            converters.ubisys_dimmer_setup_genLevelCtrl.convertGet(entity, key, meta);
-        },
-        convertGet: async (entity, key, meta) => {
-            await entity.read('genLevelCtrl', ['ubisysMinimumOnLevel'], manufacturerOptions.ubisys);
-        },
-    },
-    ubisys_device_setup: {
-        key: ['configure_device_setup'],
-        convertSet: async (entity, key, value, meta) => {
-            const devMgmtEp = meta.device.getEndpoint(232);
-
-            if (value.hasOwnProperty('input_configurations')) {
-                // example: [0, 0, 0, 0]
-                await devMgmtEp.write(
-                    'manuSpecificUbisysDeviceSetup',
-                    {'inputConfigurations': {elementType: 'data8', elements: value.input_configurations}},
-                    manufacturerOptions.ubisysNull,
-                );
-            }
-
-            if (value.hasOwnProperty('input_actions')) {
-                // example (default for C4): [[0,13,1,6,0,2], [1,13,2,6,0,2], [2,13,3,6,0,2], [3,13,4,6,0,2]]
-                await devMgmtEp.write(
-                    'manuSpecificUbisysDeviceSetup',
-                    {'inputActions': {elementType: 'octetStr', elements: value.input_actions}},
-                    manufacturerOptions.ubisysNull,
-                );
-            }
-
-            if (value.hasOwnProperty('input_action_templates')) {
-                const templateTypes = {
-                    // source: "ZigBee Device Physical Input Configurations Integrator’s Guide"
-                    // (can be obtained directly from ubisys upon request)
-                    'toggle': {
-                        getInputActions: (input, endpoint) => [
-                            [input, 0x0D, endpoint, 0x06, 0x00, 0x02],
-                        ],
-                    },
-                    'toggle_switch': {
-                        getInputActions: (input, endpoint) => [
-                            [input, 0x0D, endpoint, 0x06, 0x00, 0x02],
-                            [input, 0x03, endpoint, 0x06, 0x00, 0x02],
-                        ],
-                    },
-                    'on_off_switch': {
-                        getInputActions: (input, endpoint) => [
-                            [input, 0x0D, endpoint, 0x06, 0x00, 0x01],
-                            [input, 0x03, endpoint, 0x06, 0x00, 0x00],
-                        ],
-                    },
-                    'on': {
-                        getInputActions: (input, endpoint) => [
-                            [input, 0x0D, endpoint, 0x06, 0x00, 0x01],
-                        ],
-                    },
-                    'off': {
-                        getInputActions: (input, endpoint) => [
-                            [input, 0x0D, endpoint, 0x06, 0x00, 0x00],
-                        ],
-                    },
-                    'dimmer_single': {
-                        getInputActions: (input, endpoint, template) => {
-                            const moveUpCmd = template.no_onoff || template.no_onoff_up ? 0x01 : 0x05;
-                            const moveDownCmd = template.no_onoff || template.no_onoff_down ? 0x01 : 0x05;
-                            const moveRate = template.rate || 50;
-                            return [
-                                [input, 0x07, endpoint, 0x06, 0x00, 0x02],
-                                [input, 0x86, endpoint, 0x08, 0x00, moveUpCmd, 0x00, moveRate],
-                                [input, 0xC6, endpoint, 0x08, 0x00, moveDownCmd, 0x01, moveRate],
-                                [input, 0x0B, endpoint, 0x08, 0x00, 0x03],
-                            ];
-                        },
-                    },
-                    'dimmer_double': {
-                        doubleInputs: true,
-                        getInputActions: (inputs, endpoint, template) => {
-                            const moveUpCmd = template.no_onoff || template.no_onoff_up ? 0x01 : 0x05;
-                            const moveDownCmd = template.no_onoff || template.no_onoff_down ? 0x01 : 0x05;
-                            const moveRate = template.rate || 50;
-                            return [
-                                [inputs[0], 0x07, endpoint, 0x06, 0x00, 0x01],
-                                [inputs[0], 0x06, endpoint, 0x08, 0x00, moveUpCmd, 0x00, moveRate],
-                                [inputs[0], 0x0B, endpoint, 0x08, 0x00, 0x03],
-                                [inputs[1], 0x07, endpoint, 0x06, 0x00, 0x00],
-                                [inputs[1], 0x06, endpoint, 0x08, 0x00, moveDownCmd, 0x01, moveRate],
-                                [inputs[1], 0x0B, endpoint, 0x08, 0x00, 0x03],
-                            ];
-                        },
-                    },
-                    'cover': {
-                        cover: true,
-                        doubleInputs: true,
-                        getInputActions: (inputs, endpoint) => [
-                            [inputs[0], 0x0D, endpoint, 0x02, 0x01, 0x00],
-                            [inputs[0], 0x07, endpoint, 0x02, 0x01, 0x02],
-                            [inputs[1], 0x0D, endpoint, 0x02, 0x01, 0x01],
-                            [inputs[1], 0x07, endpoint, 0x02, 0x01, 0x02],
-                        ],
-                    },
-                    'cover_switch': {
-                        cover: true,
-                        doubleInputs: true,
-                        getInputActions: (inputs, endpoint) => [
-                            [inputs[0], 0x0D, endpoint, 0x02, 0x01, 0x00],
-                            [inputs[0], 0x03, endpoint, 0x02, 0x01, 0x02],
-                            [inputs[1], 0x0D, endpoint, 0x02, 0x01, 0x01],
-                            [inputs[1], 0x03, endpoint, 0x02, 0x01, 0x02],
-                        ],
-                    },
-                    'cover_up': {
-                        cover: true,
-                        getInputActions: (input, endpoint) => [
-                            [input, 0x0D, endpoint, 0x02, 0x01, 0x00],
-                        ],
-                    },
-                    'cover_down': {
-                        cover: true,
-                        getInputActions: (input, endpoint) => [
-                            [input, 0x0D, endpoint, 0x02, 0x01, 0x01],
-                        ],
-                    },
-                    'scene': {
-                        scene: true,
-                        getInputActions: (input, endpoint, groupId, sceneId) => [
-                            [input, 0x07, endpoint, 0x05, 0x00, 0x05, groupId & 0xff, groupId >> 8, sceneId],
-                        ],
-                        getInputActions2: (input, endpoint, groupId, sceneId) => [
-                            [input, 0x06, endpoint, 0x05, 0x00, 0x05, groupId & 0xff, groupId >> 8, sceneId],
-                        ],
-                    },
-                    'scene_switch': {
-                        scene: true,
-                        getInputActions: (input, endpoint, groupId, sceneId) => [
-                            [input, 0x0D, endpoint, 0x05, 0x00, 0x05, groupId & 0xff, groupId >> 8, sceneId],
-                        ],
-                        getInputActions2: (input, endpoint, groupId, sceneId) => [
-                            [input, 0x03, endpoint, 0x05, 0x00, 0x05, groupId & 0xff, groupId >> 8, sceneId],
-                        ],
-                    },
-                };
-
-                // first input
-                let input = 0;
-                // first client endpoint - depends on actual device
-                let endpoint = {'S1': 2, 'S2': 3, 'D1': 2, 'J1': 2, 'C4': 1}[meta.mapped.model];
-                // default group id
-                let groupId = 0;
-
-                const templates = Array.isArray(value.input_action_templates) ? value.input_action_templates :
-                    [value.input_action_templates];
-                let resultingInputActions = [];
-                for (const template of templates) {
-                    const templateType = templateTypes[template.type];
-                    if (!templateType) {
-                        throw new Error(`input_action_templates: Template type '${template.type}' is not valid ` +
-                            `(valid types: ${Object.keys(templateTypes)})`);
-                    }
-
-                    if (template.hasOwnProperty('input')) {
-                        input = template.input;
-                    }
-                    if (template.hasOwnProperty('endpoint')) {
-                        endpoint = template.endpoint;
-                    }
-                    // C4 cover endpoints only start at 5
-                    if (templateType.cover && meta.mapped.model === 'C4' && endpoint < 5) {
-                        endpoint += 4;
-                    }
-
-                    let inputActions;
-                    if (!templateType.doubleInputs) {
-                        if (!templateType.scene) {
-                            // single input, no scene(s)
-                            inputActions = templateType.getInputActions(input, endpoint, template);
-                        } else {
-                            // scene(s) (always single input)
-                            if (!template.hasOwnProperty('scene_id')) {
-                                throw new Error(`input_action_templates: Need an attribute 'scene_id' for '${template.type}'`);
-                            }
-                            if (template.hasOwnProperty('group_id')) {
-                                groupId = template.group_id;
-                            }
-                            inputActions = templateType.getInputActions(input, endpoint, groupId, template.scene_id);
-
-                            if (template.hasOwnProperty('scene_id_2')) {
-                                if (template.hasOwnProperty('group_id_2')) {
-                                    groupId = template.group_id_2;
-                                }
-                                inputActions = inputActions.concat(templateType.getInputActions2(input, endpoint, groupId,
-                                    template.scene_id_2));
-                            }
-                        }
-                    } else {
-                        // double inputs
-                        input = template.hasOwnProperty('inputs') ? template.inputs : [input, input + 1];
-                        inputActions = templateType.getInputActions(input, endpoint, template);
-                    }
-                    resultingInputActions = resultingInputActions.concat(inputActions);
-
-                    meta.logger.warn(`ubisys: Using input(s) ${input} and endpoint ${endpoint} for '${template.type}'.`);
-                    // input might by now be an array (in case of double inputs)
-                    input = (Array.isArray(input) ? Math.max(...input) : input) + 1;
-                    endpoint += 1;
-                }
-
-                meta.logger.debug(`ubisys: input_actions to be sent to '${meta.options.friendlyName}': ` +
-                    JSON.stringify(resultingInputActions));
-                await devMgmtEp.write(
-                    'manuSpecificUbisysDeviceSetup',
-                    {'inputActions': {elementType: 'octetStr', elements: resultingInputActions}},
-                    manufacturerOptions.ubisysNull,
-                );
-            }
-
-            // re-read effective settings and dump them to the log
-            converters.ubisys_device_setup.convertGet(entity, key, meta);
-        },
-
-        convertGet: async (entity, key, meta) => {
-            const log = (dataRead) => {
-                meta.logger.warn(
-                    `ubisys: Device setup read for '${meta.options.friendly_name}': ${JSON.stringify(utils.toSnakeCase(dataRead))}`);
-            };
-            const devMgmtEp = meta.device.getEndpoint(232);
-            log(await devMgmtEp.read('manuSpecificUbisysDeviceSetup', ['inputConfigurations'], manufacturerOptions.ubisysNull));
-            log(await devMgmtEp.read('manuSpecificUbisysDeviceSetup', ['inputActions'], manufacturerOptions.ubisysNull));
-        },
-    },
     tint_scene: {
         key: ['tint_scene'],
         convertSet: async (entity, key, value, meta) => {

package/devices/kmpcil.js

@@ -3,8 +3,71 @@ const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/lega
 const tz = require('../converters/toZigbee');
 const constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
+const globalStore = require('../lib/store');
+const utils = require('../lib/utils');
 const e = exposes.presets;
 
+const kmpcilOptions={
+    presence_timeout_dc: () => {
+        return exposes.numeric('presence_timeout_dc').withValueMin(60).withDescription(
+            'Time in seconds after which presence is cleared after detecting it (default 60 seconds) while in DC.');
+    },
+    presence_timeout_battery: () => {
+        return exposes.numeric('presence_timeout_battery').withValueMin(120).withDescription(
+            'Time in seconds after which presence is cleared after detecting it (default 420 seconds) while in Battery.');
+    },
+};
+
+function handleKmpcilPresence(model, msg, publish, options, meta) {
+    const useOptionsTimeoutBattery = options && options.hasOwnProperty('presence_timeout_battery');
+    const timeoutBattery = useOptionsTimeoutBattery ? options.presence_timeout_battery : 420; // 100 seconds by default
+
+    const useOptionsTimeoutDc = options && options.hasOwnProperty('presence_timeout_dc');
+    const timeoutDc = useOptionsTimeoutDc ? options.presence_timeout_dc : 60;
+
+    const mode = meta.state? meta.state['power_state'] : false;
+
+    const timeout = mode ? timeoutDc : timeoutBattery;
+    // Stop existing timer because motion is detected and set a new one.
+    clearTimeout(globalStore.getValue(msg.endpoint, 'timer'));
+    const timer = setTimeout(() => publish({presence: false}), timeout * 1000);
+    globalStore.putValue(msg.endpoint, 'timer', timer);
+
+    return {presence: true};
+}
+
+const kmpcilConverters = {
+    presence_binary_input: {
+        cluster: 'genBinaryInput',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const payload = handleKmpcilPresence(model, msg, publish, options, meta);
+            if (msg.data.hasOwnProperty('presentValue')) {
+                const presentValue = msg.data['presentValue'];
+                payload.power_state = (presentValue & 0x01)> 0;
+                payload.occupancy = (presentValue & 0x04) > 0;
+                payload.vibration = (presentValue & 0x02) > 0;
+            }
+            return payload;
+        },
+    },
+    presence_power: {
+        cluster: 'genPowerCfg',
+        type: ['attributeReport', 'readResponse'],
+        options: [kmpcilOptions.presence_timeout_dc(), kmpcilOptions.presence_timeout_battery()],
+        convert: (model, msg, publish, options, meta) => {
+            const payload = handleKmpcilPresence(model, msg, publish, options, meta);
+            if (msg.data.hasOwnProperty('batteryVoltage')) {
+                payload.voltage = msg.data['batteryVoltage'] * 100;
+                if (model.meta && model.meta.battery && model.meta.battery.voltageToPercentage) {
+                    payload.battery = utils.batteryVoltageToPercentage(payload.voltage, model.meta.battery.voltageToPercentage);
+                }
+            }
+            return payload;
+        },
+    },
+};
+
 module.exports = [
     {
         zigbeeModel: ['RES005'],
@@ -47,4 +110,38 @@ module.exports = [
             await endpoint.configureReporting('genBinaryOutput', payloadBinaryOutput);
         },
     },
+    {
+        zigbeeModel: ['tagv1'],
+        model: 'KMPCIL-tag-001',
+        vendor: 'KMPCIL',
+        description: 'Arrival sensor',
+        fromZigbee: [kmpcilConverters.presence_binary_input, kmpcilConverters.presence_power, fz.temperature],
+        exposes: [e.battery(), e.presence(), exposes.binary('power_state', exposes.access.STATE, true, false),
+            e.occupancy(), e.vibration(), e.temperature()],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_1500_2800'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            for (const cluster of ['msTemperatureMeasurement', 'genPowerCfg', 'genBinaryInput']) {
+                // This sleep here(and the sleep) after is to allow the command to be
+                // fully sent to coordinator.  In case repeater involved and the repeater
+                // is litted in resources,  we may want to give some time so that the sequence of
+                // commands does not overwhelm the repeater.
+                await utils.sleep(2000);
+                await endpoint.bind(cluster, coordinatorEndpoint);
+            }
+
+            await utils.sleep(1000);
+            const p = reporting.payload('batteryVoltage', 0, 10, 1);
+            await endpoint.configureReporting('genPowerCfg', p);
+
+            await utils.sleep(1000);
+            const p2 = reporting.payload('presentValue', 0, 300, 1);
+            await endpoint.configureReporting('genBinaryInput', p2);
+
+            await utils.sleep(1000);
+            await reporting.temperature(endpoint);
+            await endpoint.read('genBinaryInput', ['presentValue']);
+        },
+    },
 ];

package/devices/legrand.js

@@ -32,8 +32,8 @@ module.exports = [
     {
         zigbeeModel: [' Contactor\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'+
             '\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'],
-        model: 'FC80CC',
-        description: 'Legrand (or Bticino) DIN contactor module',
+        model: '412171',
+        description: 'DIN contactor module ( Bticino FC80CC )',
         vendor: 'Legrand',
         extend: extend.switch(),
         fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement, fz.legrand_cluster_fc01, fz.ignore_basic_report, fz.ignore_genOta],
@@ -52,8 +52,8 @@ module.exports = [
     {
         zigbeeModel: [' Teleruptor\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'+
             '\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'],
-        model: 'FC80RC',
-        description: 'Legrand (or Bticino) DIN smart relay for light control (note: Legrand 412170 may be similar to Bticino FC80RC)',
+        model: '412170',
+        description: 'DIN smart relay for light control ( Bticino FC80RC ) ',
         vendor: 'Legrand',
         extend: extend.switch(),
         fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement, fz.legrand_cluster_fc01, fz.ignore_basic_report, fz.ignore_genOta],

package/devices/lidl.js

@@ -528,6 +528,17 @@ module.exports = [
             device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
         },
     },
+    {
+        fingerprint: [{modelID: 'TS0502B', manufacturerName: '_TZ3210_c2iwpxf1'}],
+        model: '14156408L',
+        vendor: 'Lidl',
+        description: 'Livarno Lux smart LED ceiling light',
+        ...extend.light_onoff_brightness_colortemp_color({disableColorTempStartup: true, colorTempRange: [153, 500]}),
+        meta: {applyRedFix: true, enhancedHue: false},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 16});
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_p9ao60da'}],
         model: 'HG08008',