@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/keen_home.js

@@ -0,0 +1,80 @@
+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 e = exposes.presets;
+const ea = exposes.access;
+
+module.exports = [
+    {
+        zigbeeModel: ['RS-THP-MP-1.0'],
+        model: 'RS-THP-MP-1.0',
+        vendor: 'Keen Home',
+        description: 'Temperature Sensor',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.battery, fz.xiaomi_temperature, fz.humidity, fz.keen_home_smart_vent_pressure],
+        toZigbee: [],
+        exposes: [e.battery(), e.temperature(), e.humidity(), e.pressure(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.powerSource = 'Battery';
+            device.save();
+        },
+    },
+    {
+        zigbeeModel: ['SV01-410-MP-1.0', 'SV01-410-MP-1.1', 'SV01-410-MP-1.4', 'SV01-410-MP-1.5', 'SV01-412-MP-1.0', 'SV01-612-MP-1.1',
+            'SV01-412-MP-1.1', 'SV01-412-MP-1.4', 'SV01-610-MP-1.0', 'SV01-610-MP-1.1', 'SV01-612-MP-1.0', 'SV01-612-MP-1.2',
+            'SV01-610-MP-1.4'],
+        model: 'SV01',
+        vendor: 'Keen Home',
+        description: 'Smart vent',
+        fromZigbee: [fz.cover_position_via_brightness, fz.temperature, fz.battery, fz.keen_home_smart_vent_pressure,
+            fz.ignore_onoff_report],
+        toZigbee: [tz.cover_via_brightness],
+        meta: {battery: {dontDividePercentage: true}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genLevelCtrl', 'genPowerCfg', 'msTemperatureMeasurement', 'msPressureMeasurement'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.temperature(endpoint);
+            await reporting.pressure(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.cover_position().setAccess('state', ea.ALL), e.temperature(), e.battery(), e.pressure()],
+    },
+    {
+        zigbeeModel: ['SV02-410-MP-1.3', 'SV02-412-MP-1.3', 'SV02-610-MP-1.0', 'SV02-610-MP-1.3', 'SV02-612-MP-1.2', 'SV02-612-MP-1.3',
+            'SV02-410-MP-1.0', 'SV02-410-MP-1.2', 'SV02-412-MP-1.2'],
+        model: 'SV02',
+        vendor: 'Keen Home',
+        description: 'Smart vent',
+        fromZigbee: [fz.cover_position_via_brightness, fz.temperature, fz.battery, fz.keen_home_smart_vent_pressure,
+            fz.ignore_onoff_report],
+        toZigbee: [tz.cover_via_brightness],
+        meta: {battery: {dontDividePercentage: true}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genLevelCtrl', 'genPowerCfg', 'msTemperatureMeasurement', 'msPressureMeasurement'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.temperature(endpoint);
+            await reporting.pressure(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.cover_position().setAccess('state', ea.ALL), e.temperature(), e.battery(), e.pressure()],
+    },
+    {
+        zigbeeModel: ['GW01-001-MP-1.0'],
+        model: 'GW01',
+        description: 'Signal repeater',
+        vendor: 'Keen Home',
+        fromZigbee: [fz.linkquality_from_basic],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const payload = [{attribute: 'modelId', minimumReportInterval: 3600, maximumReportInterval: 14400}];
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic']);
+            await endpoint.configureReporting('genBasic', payload);
+            device.powerSource = 'Mains (single phase)';
+        },
+        exposes: [],
+    },
+];

package/devices/klikaanklikuit.js

@@ -0,0 +1,17 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['Socket Switch'],
+        model: 'ZCC-3500',
+        vendor: 'KlikAanKlikUit',
+        description: 'Zigbee socket switch',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+];

package/devices/kmpcil.js

@@ -0,0 +1,148 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+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 ea = exposes.access;
+
+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'],
+        model: 'KMPCIL_RES005',
+        vendor: 'KMPCIL',
+        description: 'Environment sensor',
+        exposes: [e.battery(), e.temperature(), e.humidity(), e.pressure(), e.illuminance().withAccess(ea.STATE_GET),
+            e.illuminance_lux().withAccess(ea.STATE_GET), e.occupancy(), e.switch()],
+        fromZigbee: [fz.battery, fz.temperature, fz.humidity, fz.pressure, fz.illuminance, fz.kmpcil_res005_occupancy,
+            fz.kmpcil_res005_on_off],
+        toZigbee: [tz.kmpcil_res005_on_off, tz.illuminance],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(8);
+            const binds = ['genPowerCfg', 'msTemperatureMeasurement', 'msRelativeHumidity', 'msPressureMeasurement',
+                'msIlluminanceMeasurement', 'genBinaryInput', 'genBinaryOutput'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.temperature(endpoint);
+            await reporting.humidity(endpoint);
+            const payloadBattery = [{
+                attribute: 'batteryPercentageRemaining', minimumReportInterval: 1, maximumReportInterval: 120, reportableChange: 1}];
+            await endpoint.configureReporting('genPowerCfg', payloadBattery);
+            const payload = [{attribute: 'measuredValue', minimumReportInterval: 5, maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 200}];
+            await endpoint.configureReporting('msIlluminanceMeasurement', payload);
+            const payloadPressure = [{
+                // 0 = measuredValue, override dataType from int16 to uint16
+                // https://github.com/Koenkk/zigbee-herdsman/pull/191/files?file-filters%5B%5D=.ts#r456569398
+                attribute: {ID: 0, type: 33}, minimumReportInterval: 2, maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 3}];
+            await endpoint.configureReporting('msPressureMeasurement', payloadPressure);
+            const options = {disableDefaultResponse: true};
+            await endpoint.write('genBinaryInput', {0x0051: {value: 0x01, type: 0x10}}, options);
+            await endpoint.write('genBinaryInput', {0x0101: {value: 25, type: 0x23}}, options);
+            const payloadBinaryInput = [{
+                attribute: 'presentValue', minimumReportInterval: 0, maximumReportInterval: 30, reportableChange: 1}];
+            await endpoint.configureReporting('genBinaryInput', payloadBinaryInput);
+            await endpoint.write('genBinaryOutput', {0x0051: {value: 0x01, type: 0x10}}, options);
+            const payloadBinaryOutput = [{
+                attribute: 'presentValue', minimumReportInterval: 0, maximumReportInterval: 30, reportableChange: 1}];
+            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/konke.js

@@ -0,0 +1,141 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+const fzLocal = {
+    command_recall_konke: {
+        cluster: 'genScenes',
+        type: 'commandRecall',
+        convert: (model, msg, publish, options, meta) => {
+            const payload = {
+                241: 'hexagon',
+                242: 'square',
+                243: 'triangle',
+                244: 'circle',
+            };
+            return {action: payload[msg.data.sceneid]};
+        },
+    },
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['3AFE170100510001', '3AFE280100510001'],
+        model: '2AJZ4KPKEY',
+        vendor: 'Konke',
+        description: 'Multi-function button',
+        fromZigbee: [fz.konke_action, fz.battery, fz.legacy.konke_click],
+        toZigbee: [],
+        exposes: [e.battery_low(), e.battery(), e.action(['single', 'double', 'hold'])],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+            // Has Unknown power source, force it.
+            device.powerSource = 'Battery';
+            device.save();
+        },
+    },
+    {
+        zigbeeModel: ['3AFE14010402000D', '3AFE27010402000D', '3AFE28010402000D'],
+        model: '2AJZ4KPBS',
+        vendor: 'Konke',
+        description: 'Motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1_with_timeout, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['3AFE140103020000', '3AFE220103020000'],
+        model: '2AJZ4KPFT',
+        vendor: 'Konke',
+        description: 'Temperature and humidity sensor',
+        fromZigbee: [fz.temperature, fz.humidity, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'msTemperatureMeasurement']);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.temperature(endpoint);
+        },
+        exposes: [e.temperature(), e.humidity(), e.battery()],
+    },
+    {
+        zigbeeModel: ['3AFE010104020028'],
+        model: 'TW-S1',
+        description: 'Photoelectric smoke detector',
+        vendor: 'Konke',
+        fromZigbee: [fz.ias_smoke_alarm_1],
+        toZigbee: [],
+        exposes: [e.smoke(), e.battery_low()],
+    },
+    {
+        zigbeeModel: ['3AFE130104020015', '3AFE270104020015', '3AFE280104020015'],
+        model: '2AJZ4KPDR',
+        vendor: 'Konke',
+        description: 'Contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['LH07321'],
+        model: 'LH07321',
+        vendor: 'Konke',
+        description: 'Water detector',
+        fromZigbee: [fz.ias_water_leak_alarm_1],
+        toZigbee: [],
+        exposes: [e.water_leak(), e.battery_low(), e.tamper()],
+    },
+    {
+        fingerprint: [{modelID: 'TS0222', manufacturerName: '_TYZB01_fi5yftwv'}, {modelID: '3AFE090103021000'}],
+        model: 'KK-ES-J01W',
+        vendor: 'Konke',
+        description: 'Temperature, relative humidity and illuminance sensor',
+        fromZigbee: [fz.battery, fz.illuminance, fz.humidity, fz.temperature],
+        toZigbee: [],
+        exposes: [e.battery(), e.battery_voltage(), e.illuminance(), e.illuminance_lux().withUnit('lx'), e.humidity(), e.temperature()],
+    },
+    {
+        zigbeeModel: ['3AFE241000040002'],
+        model: 'KK-TQ-J01W',
+        vendor: 'Konke',
+        description: 'Smart 4 key scene switch',
+        fromZigbee: [fzLocal.command_recall_konke, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        exposes: [e.battery(), e.battery_voltage(), e.battery_low(), e.action(['hexagon', 'square', 'triangle', 'circle'])],
+    },
+    {
+        zigbeeModel: ['3AFE07010402100D', '3AFE08010402100D'],
+        model: 'KK-BS-J01W',
+        vendor: 'Konke',
+        description: 'Occupancy sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1_with_timeout, fz.battery],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_voltage(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['3AFE21100402102A'],
+        model: 'KK-WA-J01W',
+        vendor: 'Konke',
+        description: 'Water detector',
+        fromZigbee: [fz.ias_water_leak_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.water_leak(), e.battery_low(), e.tamper(), e.battery(), e.battery_voltage()],
+    },
+    {
+        zigbeeModel: ['3AFE221004021015'],
+        model: 'KK-DS-J01W',
+        vendor: 'Konke',
+        description: 'Contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.battery(), e.battery_voltage()],
+    },
+];

package/devices/ksentry.js

@@ -0,0 +1,17 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['Lamp_01'],
+        model: 'KS-SM001',
+        vendor: 'Ksentry Electronics',
+        description: 'Zigbee on/off controller',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(11);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+];

package/devices/kurvia.js

@@ -0,0 +1,17 @@
+const tz = require('../converters/toZigbee');
+const extend = require('../lib/extend');
+
+const extendData = extend.light_onoff_brightness_colortemp_color({colorTempRange: [250, 454]});
+
+module.exports = [
+    {
+        zigbeeModel: ['ZB-CL01'],
+        model: 'ZB-CL01',
+        vendor: 'KURVIA',
+        description: 'GU10 GRBWC built from AliExpress',
+        extend: extendData,
+        toZigbee: [tz.on_off].concat(extendData.toZigbee),
+        meta: {applyRedFix: true, enhancedHue: false},
+    },
+];
+

package/devices/kwikset.js

@@ -0,0 +1,120 @@
+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 e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['SMARTCODE_CONVERT_GEN1', 'Smartcode'],
+        model: '66492-001',
+        vendor: 'Kwikset',
+        description: 'Home connect smart lock conversion kit',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
+        toZigbee: [tz.lock],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+    {
+        zigbeeModel: ['SMARTCODE_CONVERT_GEN1_W3'],
+        model: '99140-139',
+        vendor: 'Kwikset',
+        description: 'Home connect smart lock conversion kit',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
+        toZigbee: [tz.lock],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+    {
+        zigbeeModel: ['SMARTCODE_DEADBOLT_10_L'],
+        model: '99140-002',
+        vendor: 'Kwikset',
+        description: 'SmartCode traditional electronic deadbolt',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
+        toZigbee: [tz.lock],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+    {
+        zigbeeModel: ['SMARTCODE_DEADBOLT_10_W3', 'SMARTCODE_DEADBOLT_10T_W3'],
+        model: '99140-031',
+        vendor: 'Kwikset',
+        description: 'SmartCode traditional electronic deadbolt',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+    {
+        zigbeeModel: ['SMARTCODE_DEADBOLT_5'],
+        model: '99100-045',
+        vendor: 'Kwikset',
+        description: '910 SmartCode traditional electronic deadbolt',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            console.log(device);
+            console.log(endpoint.clusters);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+    {
+        zigbeeModel: ['SMARTCODE_DEADBOLT_5_L'],
+        model: '99100-006',
+        vendor: 'Kwikset',
+        description: '910 SmartCode traditional electronic deadbolt',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
+        toZigbee: [tz.lock],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+    {
+        zigbeeModel: ['SMARTCODE_LEVER_5'],
+        model: '99120-021',
+        vendor: 'Kwikset',
+        description: '912 SmartCode traditional electronic lever',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            console.log(device);
+            console.log(endpoint.clusters);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+];

package/devices/lanesto.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['FB56-ZBW14LF1.4'],
+        model: '322054',
+        vendor: 'Lanesto',
+        description: 'Dimmable led driver',
+        extend: extend.light_onoff_brightness(),
+    },
+];

package/devices/lds.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['ZBT-RGBWLight-A0000'],
+        model: 'ZBT-RGBWLight-A0000',
+        vendor: 'LDS',
+        description: 'Ynoa smart LED E27',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555]}),
+    },
+];

package/devices/led_trading.js

@@ -0,0 +1,69 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const exposes = require('../lib/exposes');
+const utils = require('../lib/utils');
+const e = exposes.presets;
+
+const fzLocal = {
+    led_trading_9133: {
+        cluster: 'greenPower',
+        type: ['commandNotification', 'commandCommisioningNotification'],
+        convert: (model, msg, publish, options, meta) => {
+            const commandID = msg.data.commandID;
+            if (utils.hasAlreadyProcessedMessage(msg, model, msg.data.frameCounter, `${msg.device.ieeeAddr}_${commandID}`)) return;
+            if (commandID === 224) return;
+            const lookup = {0x13: 'press_1', 0x14: 'press_2', 0x15: 'press_3', 0x16: 'press_4',
+                0x1B: 'hold_1', 0x1C: 'hold_2', 0x1D: 'hold_3', 0x1E: 'hold_4'};
+            if (!lookup.hasOwnProperty(commandID)) {
+                meta.logger.error(`led_trading_9133: missing command '${commandID}'`);
+            } else {
+                return {action: lookup[commandID]};
+            }
+        },
+    },
+};
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'GreenPower_2', ieeeAddr: /^0x00000000427.....$/}],
+        model: '9133',
+        vendor: 'Led Trading',
+        description: 'Pushbutton transmitter module',
+        fromZigbee: [fzLocal.led_trading_9133],
+        toZigbee: [],
+        exposes: [e.action(['press_1', 'hold_1', 'press_2', 'hold_2', 'press_3', 'hold_3', 'press_4', 'hold_4'])],
+    },
+    {
+        zigbeeModel: ['HK-LN-DIM-A'],
+        model: 'HK-LN-DIM-A',
+        vendor: 'LED Trading',
+        description: 'ZigBee AC phase-cut dimmer',
+        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: ['HK-LN-SOCKET-A'],
+        model: '9134',
+        vendor: 'LED Trading',
+        description: 'Powerstrip with 4 sockets and USB',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),
+            e.switch().withEndpoint('l3'), e.switch().withEndpoint('l4'), e.switch().withEndpoint('l5')],
+        meta: {multiEndpoint: true},
+        endpoint: (device) => {
+            return {l1: 1, l2: 2, l3: 3, l4: 4, l5: 5};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(5), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+];