@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/lifecontrol.js

@@ -0,0 +1,92 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const globalStore = require('../lib/store');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['Leak_Sensor'],
+        model: 'MCLH-07',
+        vendor: 'LifeControl',
+        description: 'Water leak switch',
+        fromZigbee: [fz.ias_water_leak_alarm_1, fz.battery],
+        toZigbee: [],
+        meta: {battery: {dontDividePercentage: true}},
+        exposes: [e.water_leak(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['Door_Sensor'],
+        model: 'MCLH-04',
+        vendor: 'LifeControl',
+        description: 'Door sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['vivi ZLight'],
+        model: 'MCLH-02',
+        vendor: 'LifeControl',
+        description: 'RGB LED lamp',
+        extend: extend.light_onoff_brightness_colortemp_color(),
+    },
+    {
+        zigbeeModel: ['RICI01'],
+        model: 'MCLH-03',
+        vendor: 'LifeControl',
+        description: 'Power plug',
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+        },
+        onEvent: async (type, data, device) => {
+            // This device doesn't support reporting correctly.
+            // https://github.com/Koenkk/zigbee-herdsman-converters/pull/1270
+            const endpoint = device.getEndpoint(1);
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            } else if (!globalStore.hasValue(device, 'interval')) {
+                const interval = setInterval(async () => {
+                    try {
+                        await endpoint.read('haElectricalMeasurement', ['rmsVoltage', 'rmsCurrent', 'activePower']);
+                        await endpoint.read('seMetering', ['currentSummDelivered', 'multiplier', 'divisor']);
+                    } catch (error) {
+                        // Do nothing
+                    }
+                }, 10*1000); // Every 10 seconds
+                globalStore.putValue(device, 'interval', interval);
+            }
+        },
+        exposes: [e.switch(), e.power(), e.current(), e.voltage(), e.energy()],
+    },
+    {
+        zigbeeModel: ['Motion_Sensor'],
+        model: 'MCLH-05',
+        vendor: 'LifeControl',
+        description: 'Motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery],
+        toZigbee: [],
+        meta: {battery: {dontDividePercentage: true}},
+        exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['VOC_Sensor'],
+        model: 'MCLH-08',
+        vendor: 'LifeControl',
+        description: 'Air sensor',
+        fromZigbee: [fz.lifecontrolVoc, fz.battery],
+        toZigbee: [],
+        meta: {battery: {dontDividePercentage: true}},
+        exposes: [e.temperature(), e.humidity(), e.voc().withUnit('ppb'), e.eco2(), e.battery()],
+    },
+];

package/devices/lightsolutions.js

@@ -0,0 +1,37 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['91-947'],
+        model: '200403V2-B',
+        vendor: 'LightSolutions',
+        description: 'Mini dimmer 200W',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['91-948'],
+        model: '200106V3',
+        vendor: 'LightSolutions',
+        description: 'Zigbee switch 200W',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['42-032'],
+        model: '42-032',
+        vendor: 'LightSolutions',
+        description: 'LED driver CCT 12V - 30W - CCT',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [160, 450]}),
+    },
+];

package/devices/linkind.js

@@ -0,0 +1,205 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+const ea = exposes.access;
+const globalStore = require('../lib/store');
+
+module.exports = [
+    {
+        zigbeeModel: ['ZB-KeypadGeneric-D0002'],
+        model: 'ZS130000078',
+        vendor: 'Linkind',
+        description: 'Security keypad battery',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.command_arm_with_transaction, fz.battery, fz.ias_ace_occupancy_with_timeout,
+            fz.ias_smoke_alarm_1, fz.command_panic],
+        exposes: [e.battery(), e.battery_voltage(), e.battery_low(), e.occupancy(), e.tamper(),
+            exposes.numeric('action_code', ea.STATE).withDescription('Pin code introduced.'),
+            exposes.numeric('action_transaction', ea.STATE).withDescription('Last action transaction number.'),
+            exposes.text('action_zone', ea.STATE).withDescription('Alarm zone. Default value 23'),
+            e.action([
+                'panic', 'disarm', 'arm_day_zones', 'arm_all_zones', 'exit_delay', 'entry_delay'])],
+        toZigbee: [tz.arm_mode],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            const clusters = ['genPowerCfg', 'ssIasZone', 'ssIasAce', 'genBasic', 'genIdentify'];
+            await reporting.bind(endpoint, coordinatorEndpoint, clusters);
+            await reporting.batteryVoltage(endpoint);
+        },
+        onEvent: async (type, data, device) => {
+            if (type === 'message' && data.type === 'commandGetPanelStatus' && data.cluster === 'ssIasAce' &&
+                globalStore.hasValue(device.getEndpoint(1), 'panelStatus')) {
+                const payload = {
+                    panelstatus: globalStore.getValue(device.getEndpoint(1), 'panelStatus'),
+                    secondsremain: 0x00, audiblenotif: 0x00, alarmstatus: 0x00,
+                };
+                await device.getEndpoint(1).commandResponse(
+                    'ssIasAce', 'getPanelStatusRsp', payload, {}, data.meta.zclTransactionSequenceNumber,
+                );
+            }
+        },
+    },
+    {
+        zigbeeModel: ['ZBT-RGBWSwitch-D0801'],
+        model: 'ZS230002',
+        vendor: 'Linkind',
+        description: '5-key smart bulb dimmer switch light remote control',
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_step, fz.command_move,
+            fz.command_stop, fz.command_move_to_color_temp, fz.command_move_to_color,
+            fz.command_move_to_level, fz.command_move_color_temperature, fz.battery],
+        exposes: [e.battery(), e.battery_low(), e.action(['on', 'off', 'brightness_step_up',
+            'brightness_step_down', 'color_temperature_move', 'color_move', 'brightness_move_up', 'brightness_move_down', 'brightness_stop',
+            'brightness_move_to_level', 'color_temperature_move_up', 'color_temperature_move_down'])],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZBT-CCTLight-D0106', 'ZBT-CCTLight-GLS0108', 'ZBT-CCTLight-GLS0109'],
+        model: 'ZL1000100-CCT-US-V1A02',
+        vendor: 'Linkind',
+        description: 'Zigbee LED 9W A19 bulb, dimmable & tunable',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+    },
+    {
+        zigbeeModel: ['ZBT-CCTLight-C4700107'],
+        model: 'ZL1000400-CCT-EU-2-V1A02',
+        vendor: 'Linkind',
+        description: 'Zigbee LED 5.4W C35 bulb E14, dimmable & tunable',
+        extend: extend.light_onoff_brightness_colortemp(),
+    },
+    {
+        zigbeeModel: ['ZBT-CCTLight-M3500107'],
+        model: 'ZL00030014',
+        vendor: 'Linkind',
+        description: 'Zigbee LED 4.8W GU10 bulb, dimmable & tunable',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+    },
+    {
+        zigbeeModel: ['ZBT-CCTLight-D115'],
+        model: 'ZL13100314',
+        vendor: 'Linkind',
+        description: 'Ceiling light 28W, 3000 lm, Ø40CM CCT',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+    },
+    {
+        zigbeeModel: ['ZBT-CCTLight-BR300107'],
+        model: 'ZL100050004',
+        vendor: 'Linkind',
+        description: 'Zigbee LED 7.4W BR30 bulb E26, dimmable & tunable',
+        extend: extend.light_onoff_brightness_colortemp(),
+    },
+    {
+        zigbeeModel: ['ZBT-DIMLight-GLS0010'],
+        model: 'ZL100010008',
+        vendor: 'Linkind',
+        description: 'Zigbee LED 9W 2700K A19 bulb, dimmable',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['ZBT-DIMLight-D0120'],
+        model: 'ZL1000701-27-EU-V1A02',
+        vendor: 'Linkind',
+        description: 'Zigbee A60 filament bulb 6.3W',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['ZBT-DIMLight-A4700003'],
+        model: 'ZL1000700-22-EU-V1A02',
+        vendor: 'Linkind',
+        description: 'Zigbee A60 led filament, dimmable warm light (2200K), E27. 4.2W, 420lm',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['ZB-MotionSensor-D0003'],
+        model: 'ZS1100400-IN-V1A02',
+        vendor: 'Linkind',
+        description: 'PIR motion sensor, wireless motion detector',
+        fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZB-DoorSensor-D0003'],
+        model: 'ZS110050078',
+        vendor: 'Linkind',
+        description: 'Door/window Sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.battery()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZBT-DIMSwitch-D0001'],
+        model: 'ZS232000178',
+        vendor: 'Linkind',
+        description: '1-key remote control',
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_move, fz.command_stop, fz.battery],
+        exposes: [e.action(['on', 'off', 'brightness_move_up', 'brightness_move_down', 'brightness_stop']), e.battery(), e.battery_low()],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZBT-OnOffPlug-D0011', 'ZBT-OnOffPlug-D0001'],
+        model: 'ZS190000118',
+        vendor: 'Linkind',
+        description: 'Control outlet',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZB-KeyfodGeneric-D0001'],
+        model: 'ZS130000178',
+        vendor: 'Linkind',
+        description: 'Security system key fob',
+        fromZigbee: [fz.command_arm, fz.command_panic],
+        toZigbee: [],
+        exposes: [e.action(['panic', 'disarm', 'arm_partial_zones', 'arm_all_zones'])],
+        onEvent: async (type, data, device) => {
+            // Since arm command has a response zigbee-herdsman doesn't send a default response.
+            // This causes the remote to repeat the arm command, so send a default response here.
+            if (data.type === 'commandArm' && data.cluster === 'ssIasAce') {
+                await data.endpoint.defaultResponse(0, 0, 1281, data.meta.zclTransactionSequenceNumber);
+            }
+        },
+    },
+    {
+        zigbeeModel: ['A001082'],
+        model: 'LS21001',
+        vendor: 'Linkind',
+        description: 'Water leak sensor',
+        fromZigbee: [fz.ias_water_leak_alarm_1, fz.battery],
+        toZigbee: [tz.LS21001_alert_behaviour],
+        exposes: [e.water_leak(), e.battery_low(), e.battery(),
+            exposes.enum('alert_behaviour', ea.STATE_SET, ['siren_led', 'siren', 'led', 'nothing'])
+                .withDescription('Controls behaviour of led/siren on alarm')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+];

package/devices/livingwise.js

@@ -0,0 +1,59 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['abb71ca5fe1846f185cfbda554046cce'],
+        model: 'LVS-ZB500D',
+        vendor: 'LivingWise',
+        description: 'ZigBee smart dimmer switch',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['545df2981b704114945f6df1c780515a'],
+        model: 'LVS-ZB15S',
+        vendor: 'LivingWise',
+        description: 'ZigBee smart in-wall switch',
+        extend: extend.switch(),
+    },
+    {
+        zigbeeModel: ['e70f96b3773a4c9283c6862dbafb6a99'],
+        model: 'LVS-SM10ZW',
+        vendor: 'LivingWise',
+        description: 'Door or window contact switch',
+        fromZigbee: [fz.ias_contact_alarm_1],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper()],
+    },
+    {
+        zigbeeModel: ['895a2d80097f4ae2b2d40500d5e03dcc', '700ae5aab3414ec09c1872efe7b8755a'],
+        model: 'LVS-SN10ZW_SN11',
+        vendor: 'LivingWise',
+        description: 'Occupancy sensor',
+        fromZigbee: [fz.battery, fz.ias_occupancy_alarm_1_with_timeout],
+        toZigbee: [],
+        exposes: [e.battery(), e.occupancy(), e.battery_low(), e.tamper()],
+    },
+    {
+        zigbeeModel: ['55e0fa5cdb144ba3a91aefb87c068cff'],
+        model: 'LVS-ZB15R',
+        vendor: 'LivingWise',
+        description: 'Zigbee smart outlet',
+        extend: extend.switch(),
+    },
+    {
+        zigbeeModel: ['75d430d66c164c26ac8601c05932dc94'],
+        model: 'LVS-SC7',
+        vendor: 'LivingWise',
+        description: 'Scene controller ',
+        fromZigbee: [fz.orvibo_raw_2],
+        exposes: [e.action([
+            'button_1_click', 'button_1_hold', 'button_1_release', 'button_2_click', 'button_2_hold', 'button_2_release',
+            'button_3_click', 'button_3_hold', 'button_3_release', 'button_4_click', 'button_4_hold', 'button_4_release',
+            'button_5_click', 'button_5_hold', 'button_5_release', 'button_6_click', 'button_6_hold', 'button_6_release',
+            'button_7_click', 'button_7_hold', 'button_7_release'])],
+        toZigbee: [],
+    },
+];

package/devices/livolo.js

@@ -0,0 +1,286 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const globalStore = require('../lib/store');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+const ea = exposes.access;
+
+const poll = async (device) => {
+    try {
+        const endpoint = device.getEndpoint(6);
+        const options = {transactionSequenceNumber: 0, srcEndpoint: 8, disableResponse: true, disableRecovery: true};
+        await endpoint.command('genOnOff', 'toggle', {}, options);
+    } catch (error) {
+        // device is lost, need to permit join
+    }
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['TI0001          '],
+        model: 'TI0001',
+        description: 'Zigbee switch (1, 2, 3, 4 gang)',
+        vendor: 'Livolo',
+        exposes: [
+            e.switch().withEndpoint('left'),
+            e.switch().withEndpoint('right'),
+            e.switch().withEndpoint('bottom_left'),
+            e.switch().withEndpoint('bottom_right'),
+        ],
+        fromZigbee: [fz.livolo_switch_state, fz.livolo_switch_state_raw, fz.livolo_new_switch_state_4gang],
+        toZigbee: [tz.livolo_socket_switch_on_off],
+        endpoint: (device) => {
+            return {'left': 6, 'right': 6, 'bottom_left': 6, 'bottom_right': 6};
+        },
+        configure: poll,
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => await poll(device), 300*1000);
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+            if (data.cluster === 'genPowerCfg' && data.type === 'raw') {
+                const dp = data.data[10];
+                if (data.data[0] === 0x7a && data.data[1] === 0xd1) {
+                    const endpoint = device.getEndpoint(6);
+                    if (dp === 0x01) {
+                        const options = {manufacturerCode: 0x1ad2, disableDefaultResponse: true, disableResponse: true,
+                            reservedBits: 3, direction: 1, writeUndiv: true};
+                        const payload = {0x2002: {value: [0, 0, 0, 0, 0, 0, 0], type: 0x0e}};
+                        await endpoint.readResponse('genPowerCfg', 0xe9, payload, options);
+                    }
+                }
+            }
+        },
+    },
+    {
+        zigbeeModel: ['TI0001-switch'],
+        model: 'TI0001-switch',
+        description: 'Zigbee switch 1 gang',
+        vendor: 'Livolo',
+        fromZigbee: [fz.livolo_new_switch_state, fz.power_on_behavior],
+        toZigbee: [tz.livolo_socket_switch_on_off, tz.power_on_behavior],
+        extend: extend.switch(),
+        configure: poll,
+        endpoint: (device) => {
+            return {'left': 6, 'right': 6};
+        },
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => {
+                        await poll(device);
+                    }, 300*1000); // Every 300 seconds
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+        },
+    },
+    {
+        zigbeeModel: ['TI0001-switch-2gang'],
+        model: 'TI0001-switch-2gang',
+        description: 'Zigbee Switch 2 gang',
+        vendor: 'Livolo',
+        fromZigbee: [fz.livolo_new_switch_state_2gang],
+        toZigbee: [tz.livolo_socket_switch_on_off],
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right')],
+        configure: poll,
+        endpoint: (device) => {
+            return {'left': 6, 'right': 6};
+        },
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => {
+                        await poll(device);
+                    }, 300*1000); // Every 300 seconds
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+        },
+    },
+    {
+        zigbeeModel: ['TI0001-curtain-switch'],
+        model: 'TI0001-curtain-switch',
+        description: 'Zigbee curtain switch (can only read status, control does not work yet)',
+        vendor: 'Livolo',
+        fromZigbee: [fz.livolo_curtain_switch_state],
+        toZigbee: [tz.livolo_socket_switch_on_off],
+        // toZigbee: [tz.livolo_curtain_switch_on_off],
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right')],
+        configure: poll,
+        endpoint: (device) => {
+            return {'left': 6, 'right': 6};
+        },
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => {
+                        await poll(device);
+                    }, 300*1000); // Every 300 seconds
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+        },
+    },
+    {
+        zigbeeModel: ['TI0001-socket'],
+        model: 'TI0001-socket',
+        description: 'Zigbee socket',
+        vendor: 'Livolo',
+        extend: extend.switch(),
+        fromZigbee: [fz.livolo_socket_state, fz.power_on_behavior],
+        toZigbee: [tz.livolo_socket_switch_on_off, tz.power_on_behavior],
+        configure: poll,
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => {
+                        await poll(device);
+                    }, 300*1000); // Every 300 seconds
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+        },
+    },
+    {
+        zigbeeModel: ['TI0001-dimmer'],
+        model: 'TI0001-dimmer',
+        description: 'Zigbee dimmer',
+        vendor: 'Livolo',
+        fromZigbee: [fz.livolo_dimmer_state],
+        toZigbee: [tz.livolo_socket_switch_on_off, tz.livolo_dimmer_level],
+        exposes: [e.light_brightness()],
+        configure: poll,
+        endpoint: (device) => {
+            return {'left': 6, 'right': 6};
+        },
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (!globalStore.hasValue(device, 'interval')) {
+                await poll(device);
+                const interval = setInterval(async () => {
+                    await poll(device);
+                }, 300*1000); // Every 300 seconds
+                globalStore.putValue(device, 'interval', interval);
+            }
+        },
+    },
+    {
+        zigbeeModel: ['TI0001-cover'],
+        model: 'TI0001-cover',
+        description: 'Zigbee roller blind motor',
+        vendor: 'Livolo',
+        fromZigbee: [fz.livolo_cover_state, fz.command_off],
+        toZigbee: [tz.livolo_cover_state, tz.livolo_cover_position, tz.livolo_cover_options],
+        exposes: [
+            e.cover_position().setAccess('position', ea.STATE_SET),
+            exposes.composite('options', 'options', ea.STATE_SET)
+                .withDescription('Motor options')
+                .withFeature(exposes.numeric('motor_speed', ea.STATE_SET)
+                    .withValueMin(20)
+                    .withValueMax(40)
+                    .withDescription('Motor speed')
+                    .withUnit('rpm'))
+                .withFeature(exposes.enum('motor_direction', ea.STATE_SET, ['FORWARD', 'REVERSE'])
+                    .withDescription('Motor direction')),
+            exposes.binary('moving', ea.STATE)
+                .withDescription('Motor is moving'),
+        ],
+        configure: poll,
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (!globalStore.hasValue(device, 'interval')) {
+                await poll(device);
+                const interval = setInterval(async () => {
+                    await poll(device);
+                }, 300*1000); // Every 300 seconds
+                globalStore.putValue(device, 'interval', interval);
+            }
+            // This is needed while pairing in order to let the device know that the interview went right and prevent
+            // it from disconnecting from the Zigbee network.
+            if (data.cluster === 'genPowerCfg' && data.type === 'raw') {
+                const dp = data.data[10];
+                if (data.data[0] === 0x7a && data.data[1] === 0xd1) {
+                    const endpoint = device.getEndpoint(6);
+                    if (dp === 0x02) {
+                        const options = {manufacturerCode: 0x1ad2, disableDefaultResponse: true, disableResponse: true,
+                            reservedBits: 3, direction: 1, writeUndiv: true};
+                        const payload = {0x0802: {value: [data.data[3], 0, 0, 0, 0, 0, 0], type: data.data[2]}};
+                        await endpoint.readResponse('genPowerCfg', 0xe9, payload, options);
+                    }
+                }
+            }
+        },
+    },
+    {
+        zigbeeModel: ['TI0001-pir'],
+        model: 'TI0001-pir',
+        description: 'Zigbee motion Sensor',
+        vendor: 'Livolo',
+        exposes: [
+            e.occupancy(),
+        ],
+        fromZigbee: [fz.livolo_pir_state],
+        toZigbee: [],
+        configure: poll,
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => await poll(device), 10*1000);
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+            if (data.cluster === 'genPowerCfg' && data.type === 'raw') {
+                const dp = data.data[10];
+                if (data.data[0] === 0x7a && data.data[1] === 0xd1) {
+                    const endpoint = device.getEndpoint(6);
+                    if (dp === 0x01) {
+                        const options = {manufacturerCode: 0x1ad2, disableDefaultResponse: true, disableResponse: true,
+                            reservedBits: 3, direction: 1, writeUndiv: true};
+                        const payload = {0x2002: {value: [0, 0, 0, 0, 0, 0, 0], type: 0x0e}};
+                        await endpoint.readResponse('genPowerCfg', 0xe9, payload, options);
+                    }
+                }
+            }
+        },
+    },
+];