@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/plaid.js

@@ -0,0 +1,25 @@
+const fz = require('../converters/fromZigbee');
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'PS-SPRZMS-SLP3', manufacturerName: 'PLAID SYSTEMS'}],
+        zigbeeModel: ['PS-SPRZMS-SLP3'],
+        model: 'PS-SPRZMS-SLP3',
+        vendor: 'PLAID SYSTEMS',
+        description: 'Spruce temperature and moisture sensor',
+        toZigbee: [],
+        fromZigbee: [fz.temperature, fz.humidity, fz.plaid_battery],
+        exposes: [e.humidity(), e.temperature(), e.battery(), e.battery_voltage()],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'msRelativeHumidity', 'genPowerCfg']);
+            await reporting.temperature(endpoint);
+            await reporting.humidity(endpoint);
+            device.powerSource = 'Battery';
+        },
+    },
+];

package/devices/plugwise.js

@@ -0,0 +1,173 @@
+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 utils = require('../lib/utils');
+const e = exposes.presets;
+const ea = exposes.access;
+const herdsman = require('zigbee-herdsman');
+
+const manufacturerOptions = {manufacturerCode: herdsman.Zcl.ManufacturerCode.PLUGWISE_BV};
+
+const plugwisePushForce = {
+    0: 'standard',
+    0x60000: 'high',
+    0x70000: 'very_high',
+};
+
+const plugwiseRadioStrength = {
+    0: 'normal',
+    1: 'high',
+};
+
+const fzLocal = {
+    plugwise_radiator_valve: {
+        cluster: 'hvacThermostat',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = fz.thermostat.convert(model, msg, publish, options, meta);
+
+            // Reports pIHeatingDemand between 0 and 100 already
+            if (typeof msg.data['pIHeatingDemand'] == 'number') {
+                result.pi_heating_demand = utils.precisionRound(msg.data['pIHeatingDemand'], 0);
+            }
+
+            if (typeof msg.data[0x4003] == 'number') {
+                result.current_heating_setpoint = utils.precisionRound(msg.data[0x4003], 2) / 100;
+            }
+            if (typeof msg.data[0x4008] == 'number') {
+                result.plugwise_t_diff = msg.data[0x4008];
+            }
+            if (typeof msg.data[0x4002] == 'number') {
+                result.error_status = msg.data[0x4002];
+            }
+            if (typeof msg.data[0x4001] == 'number') {
+                result.valve_position = msg.data[0x4001];
+            }
+            return result;
+        },
+    },
+};
+
+const tzLocal = {
+    plugwise_calibrate_valve: {
+        key: ['calibrate_valve'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.command('hvacThermostat', 'plugwiseCalibrateValve', {},
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
+            return {state: {'calibrate_valve': value}};
+        },
+    },
+    plugwise_valve_position: {
+        key: ['plugwise_valve_position', 'valve_position'],
+        convertSet: async (entity, key, value, meta) => {
+            const payload = {0x4001: {value, type: 0x20}};
+            await entity.write('hvacThermostat', payload, manufacturerOptions);
+            // Tom does not automatically send back updated value so ask for it
+            await entity.read('hvacThermostat', [0x4001], manufacturerOptions);
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', [0x4001], manufacturerOptions);
+        },
+    },
+    plugwise_push_force: {
+        key: ['plugwise_push_force', 'force'],
+        convertSet: async (entity, key, value, meta) => {
+            const val = utils.getKey(plugwisePushForce, value, value, Number);
+            const payload = {0x4012: {value: val, type: 0x23}};
+            await entity.write('hvacThermostat', payload, manufacturerOptions);
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', [0x4012], manufacturerOptions);
+        },
+    },
+    plugwise_radio_strength: {
+        key: ['plugwise_radio_strength', 'radio_strength'],
+        convertSet: async (entity, key, value, meta) => {
+            const val = utils.getKey(plugwiseRadioStrength, value, value, Number);
+            const payload = {0x4014: {value: val, type: 0x10}};
+            await entity.write('hvacThermostat', payload, manufacturerOptions);
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', [0x4014], manufacturerOptions);
+        },
+    },
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['160-01'],
+        model: '160-01',
+        vendor: 'Plugwise',
+        description: 'Plug power socket on/off with power consumption monitoring',
+        fromZigbee: [fz.on_off, fz.metering],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+        exposes: [e.switch(), e.power(), e.energy()],
+    },
+    {
+        zigbeeModel: ['106-03'],
+        model: '106-03',
+        vendor: 'Plugwise',
+        description: 'Tom thermostatic radiator valve',
+        fromZigbee: [fz.temperature, fz.battery, fzLocal.plugwise_radiator_valve],
+        // sytem_mode and occupied_heating_setpoint is not supported: https://github.com/Koenkk/zigbee2mqtt.io/pull/1666
+        toZigbee: [
+            tz.thermostat_pi_heating_demand,
+            tzLocal.plugwise_valve_position,
+            tzLocal.plugwise_push_force,
+            tzLocal.plugwise_radio_strength,
+            tzLocal.plugwise_calibrate_valve,
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic', 'genPowerCfg', 'hvacThermostat']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatPIHeatingDemand(endpoint);
+        },
+        exposes: [e.battery(),
+            exposes.numeric('pi_heating_demand', ea.STATE_GET).withValueMin(0).withValueMax(100).withUnit('%')
+                .withDescription('Position of the valve (= demanded heat) where 0% is fully closed and 100% is fully open'),
+            exposes.numeric('local_temperature', ea.STATE).withUnit('°C').withDescription('Current temperature measured on the device'),
+            exposes.numeric('valve_position', ea.ALL).withValueMin(0).withValueMax(100)
+                .withDescription('Directly control the radiator valve. The values range from 0 (valve ' +
+                    'closed) to 100 (valve fully open)'),
+            exposes.enum('force', ea.ALL, ['standard', 'high', 'very_high'])
+                .withDescription('How hard the motor pushes the valve. The closer to the boiler, the higher the force needed'),
+            exposes.enum('radio_strength', ea.ALL, ['normal', 'high'])
+                .withDescription('Transmits with higher power when range is not sufficient'),
+            exposes.binary('calibrate_valve', ea.STATE_SET, 'calibrate', 'idle')
+                .withDescription('Calibrates valve on next wakeup'),
+        ],
+    },
+    {
+        zigbeeModel: ['158-01'],
+        model: '158-01',
+        vendor: 'Plugwise',
+        description: 'Lisa zone thermostat',
+        fromZigbee: [fz.thermostat, fz.temperature, fz.battery],
+        toZigbee: [
+            tz.thermostat_system_mode,
+            tz.thermostat_occupied_heating_setpoint,
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic', 'genPowerCfg', 'hvacThermostat']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.thermostatTemperature(endpoint);
+        },
+        exposes: [e.battery(),
+            exposes.climate()
+                .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5, ea.ALL)
+                .withLocalTemperature(ea.STATE)
+                .withSystemMode(['off', 'auto'], ea.ALL),
+        ],
+    },
+];

package/devices/popp.js

@@ -0,0 +1,10 @@
+const {extendDevice} = require('../lib/utils');
+
+module.exports = [
+    extendDevice(require('./danfoss'), '014G2461', {
+        zigbeeModel: ['eT093WRO', 'eT093WRG'],
+        model: '701721',
+        vendor: 'Popp',
+        description: 'Smart thermostat based on Danfoss Ally (014G2461)',
+    }),
+];

package/devices/profalux.js

@@ -0,0 +1,47 @@
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+const ea = exposes.access;
+
+module.exports = [
+    {
+        fingerprint: [{manufId: 4368, endpoints: [{ID: 1, profileID: 260, deviceID: 513, inputClusters: [0, 3, 21],
+            outputClusters: [3, 4, 5, 6, 8, 256, 64544, 64545]}]}],
+        model: 'NB102',
+        vendor: 'Profalux',
+        description: 'Cover remote',
+        fromZigbee: [],
+        toZigbee: [],
+        exposes: [],
+    },
+    {
+        zigbeeModel: [
+            'MOT-C1Z06C\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000',
+            'MOT-C1Z10F\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000',
+        ],
+        fingerprint: [{manufId: 4368, endpoints: [{ID: 1, profileID: 260, deviceID: 512,
+            inputClusters: [0, 3, 4, 5, 6, 8, 10, 21, 256, 64544, 64545], outputClusters: [3, 64544]}]}],
+        model: 'NSAV061',
+        vendor: 'Profalux',
+        description: 'Cover',
+        fromZigbee: [fz.cover_position_via_brightness, fz.cover_state_via_onoff],
+        toZigbee: [tz.cover_via_brightness],
+        exposes: [e.cover_position().setAccess('state', ea.ALL)],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genLevelCtrl']);
+            await reporting.brightness(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['MAI-ZTP20F'],
+        model: 'MAI-ZTP20F',
+        vendor: 'Profalux',
+        description: 'Cover remote',
+        fromZigbee: [],
+        toZigbee: [],
+        exposes: [],
+    },
+];

package/devices/prolight.js

@@ -0,0 +1,54 @@
+const extend = require('../lib/extend');
+const fz = require('../converters/fromZigbee');
+const exposes = require('../lib/exposes');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['PROLIGHT E27 WHITE AND COLOUR'],
+        model: '5412748727371',
+        vendor: 'Prolight',
+        description: 'E27 white and colour bulb',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555]}),
+    },
+    {
+        zigbeeModel: ['PROLIGHT E27 WARM WHITE CLEAR'],
+        model: '5412748727432',
+        vendor: 'Prolight',
+        description: 'E27 filament bulb dimmable',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['PROLIGHT E27 WARM WHITE'],
+        model: '5412748727364',
+        vendor: 'Prolight',
+        description: 'E27 bulb dimmable',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['PROLIGHT GU10 WHITE AND COLOUR'],
+        model: '5412748727401',
+        vendor: 'Prolight',
+        description: 'GU10 white and colour spot',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555]}),
+    },
+    {
+        zigbeeModel: ['PROLIGHT GU10 WARM WHITE'],
+        model: '5412748727395',
+        vendor: 'Prolight',
+        description: 'GU10 spot dimmable',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['PROLIGHT REMOTE CONTROL'],
+        model: '5412748727388',
+        vendor: 'Prolight',
+        description: 'Remote control',
+        toZigbee: [],
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_move_to_level, fz.command_move, fz.command_stop,
+            fz.command_move_to_color_temp, fz.command_move_to_color, fz.command_move_color_temperature, fz.battery],
+        exposes: [e.battery(), e.action(['on', 'off', 'color_temperature_move', 'color_temperature_move_up',
+            'color_temperature_move_down', 'color_move', 'brightness_move_up', 'brightness_move_down',
+            'brightness_stop', 'brightness_move_to_level'])],
+    },
+];

package/devices/qmotion.js

@@ -0,0 +1,33 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const e = exposes.presets;
+const ea = exposes.access;
+const reporting = require('../lib/reporting');
+
+module.exports = [
+    {
+        zigbeeModel: ['Rollershade QdR'],
+        model: 'QZR-ZIG2400',
+        vendor: 'Qmotion',
+        description: '5 channel remote',
+        fromZigbee: [fz.identify, fz.cover_position_tilt],
+        exposes: [e.action(['identify']), exposes.numeric('position', ea.STATE)],
+        toZigbee: [],
+    },
+    {
+        zigbeeModel: ['Honeycomb Internal Battery', 'Rollershade Internal Battery'],
+        model: 'HDM40PV620',
+        vendor: 'Qmotion',
+        description: 'Motorized roller blind',
+        fromZigbee: [fz.identify, fz.cover_position_tilt, fz.battery],
+        toZigbee: [tz.cover_state, tz.cover_position_tilt],
+        exposes: [e.cover_position(), e.battery()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'closuresWindowCovering']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.currentPositionLiftPercentage(endpoint);
+        },
+    },
+];

package/devices/qoto.js

@@ -0,0 +1,113 @@
+const fz = require('../converters/fromZigbee');
+const exposes = require('../lib/exposes');
+const tuya = require('../lib/tuya');
+const e = exposes.presets;
+const ea = exposes.access;
+
+const dataPoints = {
+    valve_state_auto_shutdown: 2,
+    water_flow: 3,
+    shutdown_timer: 11,
+    remaining_watering_time: 101,
+    valve_state: 102,
+    last_watering_duration: 107,
+    battery: 110,
+};
+
+const fzLocal = {
+    watering_timer: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            for (const dpValue of msg.data.dpValues) {
+                const dp = dpValue.dp; // First we get the data point ID
+                const value = tuya.getDataValue(dpValue); // This function will take care of converting the data to proper JS type
+                switch (dp) {
+                case dataPoints.water_flow: {
+                    result.water_flow = value;
+                    break;
+                }
+                case dataPoints.remaining_watering_time: {
+                    result.remaining_watering_time = value;
+                    break;
+                }
+                case dataPoints.last_watering_duration: {
+                    result.last_watering_duration = value;
+                    break;
+                }
+
+                case dataPoints.valve_state: {
+                    result.valve_state = value;
+                    break;
+                }
+
+                case dataPoints.shutdown_timer: {
+                    result.shutdown_timer = value;
+                    break;
+                }
+                case dataPoints.valve_state_auto_shutdown: {
+                    result.valve_state_auto_shutdown = value;
+                    result.valve_state = value;
+                    break;
+                }
+
+                case dataPoints.battery: {
+                    result.battery = value;
+                    break;
+                }
+                default: {
+                    meta.logger.debug(`>>> UNKNOWN DP #${dp} with data "${JSON.stringify(dpValue)}"`);
+                }
+                }
+            }
+            return result;
+        },
+    },
+};
+
+const tzLocal = {
+    valve_state: {
+        key: ['valve_state'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointValue(entity, dataPoints.valve_state, value);
+        },
+    },
+    shutdown_timer: {
+        key: ['shutdown_timer'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointValue(entity, dataPoints.shutdown_timer, value);
+        },
+    },
+    valve_state_auto_shutdown: {
+        key: ['valve_state_auto_shutdown'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointValue(entity, dataPoints.valve_state_auto_shutdown, value);
+        },
+    },
+};
+
+module.exports = [
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_arge1ptm', '_TZE200_anv5ujhv']),
+        model: 'QT-05M',
+        vendor: 'QOTO',
+        description: 'Solar powered garden watering timer',
+        fromZigbee: [fz.ignore_basic_report, fz.ignore_tuya_set_time, fz.ignore_onoff_report, fzLocal.watering_timer],
+        toZigbee: [tzLocal.valve_state, tzLocal.shutdown_timer, tzLocal.valve_state_auto_shutdown],
+        exposes: [
+            exposes.numeric('water_flow', ea.STATE).withUnit('%').withValueMin(0).withDescription('Current water flow in %.'),
+            exposes.numeric('last_watering_duration', ea.STATE).withUnit('sec').withValueMin(0)
+                .withDescription('Last watering duration in seconds.'),
+            exposes.numeric('remaining_watering_time', ea.STATE).withUnit('sec').withValueMin(0)
+                .withDescription('Remaning watering time (for auto shutdown). Updates every minute, and every 10s in the last minute.'),
+            exposes.numeric('valve_state', ea.STATE_SET).withValueMin(0).withValueMax(100).withValueStep(5).withUnit('%')
+                .withDescription('Set valve to %.'),
+            exposes.numeric('shutdown_timer', ea.STATE_SET).withValueMin(0).withValueMax(14400).withUnit('sec')
+                .withDescription('Auto shutdown in seconds.'),
+            exposes.numeric('valve_state_auto_shutdown', ea.STATE_SET).withValueMin(0).withValueMax(100).withValueStep(5).withUnit('%')
+                .withDescription('Set valve to % with auto shutdown.'),
+            e.battery(),
+        ],
+    },
+];

package/devices/quotra.js

@@ -0,0 +1,18 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['Dimmer_us'],
+        model: 'B07CVL9SZF',
+        vendor: 'Quotra',
+        description: 'Dimmer',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['QV-RGBCCT'],
+        model: 'B07JHL6DRV',
+        vendor: 'Quotra',
+        description: 'RGB WW LED strip',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [150, 500]}),
+    },
+];

package/devices/rademacher.js

@@ -0,0 +1,18 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['RDM-35104001'],
+        model: '35104001',
+        vendor: 'Rademacher',
+        description: 'addZ white + colour',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555]}),
+    },
+    {
+        zigbeeModel: ['RDM-35144001'],
+        model: '35144001',
+        vendor: 'Rademacher',
+        description: 'addZ white + colour',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555]}),
+    },
+];

package/devices/rgb_genie.js

@@ -0,0 +1,119 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+const utils = require('../lib/utils');
+
+const fzLocal = {
+    // ZB-1026 requires separate on/off converters since it re-uses the transaction number
+    // https://github.com/Koenkk/zigbee2mqtt/issues/12957
+    ZB1026_command_on: {
+        cluster: 'genOnOff',
+        type: 'commandOn',
+        convert: (model, msg, publish, options, meta) => {
+            const payload = {action: utils.postfixWithEndpointName('on', msg, model, meta)};
+            utils.addActionGroup(payload, msg, model);
+            return payload;
+        },
+    },
+    ZB1026_command_off: {
+        cluster: 'genOnOff',
+        type: 'commandOff',
+        convert: (model, msg, publish, options, meta) => {
+            const payload = {action: utils.postfixWithEndpointName('off', msg, model, meta)};
+            utils.addActionGroup(payload, msg, model);
+            return payload;
+        },
+    },
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['RGBgenie ZB-1026'],
+        model: 'ZB-1026',
+        vendor: 'RGB Genie',
+        description: 'Zigbee LED dimmer controller',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['RGBgenie ZB-5001'],
+        model: 'ZB-5001',
+        vendor: 'RGB Genie',
+        description: 'Zigbee 3.0 remote control',
+        fromZigbee: [fz.command_recall, fzLocal.ZB1026_command_on, fzLocal.ZB1026_command_off,
+            fz.command_move, fz.command_stop, fz.battery],
+        exposes: [e.battery(), e.action(['recall_*', 'on', 'off', 'brightness_stop', 'brightness_move_up', 'brightness_move_down'])],
+        toZigbee: [],
+    },
+    {
+        zigbeeModel: ['RGBgenie ZB-5121'],
+        model: 'ZB-5121',
+        vendor: 'RGB Genie',
+        description: 'Micro remote and dimmer with single scene recall',
+        fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_step, fz.command_move, fz.command_stop, fz.command_recall],
+        exposes: [e.battery(), e.action(['on', 'off', 'brightness_step_up', 'brightness_step_down', 'brightness_move_up',
+            'brightness_move_down', 'brightness_stop', 'recall_*'])],
+        toZigbee: [],
+        meta: {battery: {dontDividePercentage: true}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['RGBgenie ZB-5122'],
+        model: 'ZB-5122',
+        vendor: 'RGB Genie',
+        description: 'Micro remote and color dimmer with single scene recall',
+        fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_step, fz.command_move,
+            fz.command_stop, fz.command_recall, fz.command_move_to_color, fz.command_move_to_color_temp, fz.command_move_hue,
+            fz.command_move_color_temperature],
+        exposes: [e.battery(), e.action(['on', 'off', 'brightness_step_up', 'brightness_step_down', 'brightness_move_up',
+            'brightness_move_down', 'brightness_stop', 'recall_*', 'color_temperature_move_up', 'color_temperature_move_down',
+            'hue_move', 'hue_stop'])],
+        toZigbee: [],
+    },
+    {
+        zigbeeModel: ['RGBgenie ZB-3009'],
+        model: 'ZB-3009',
+        vendor: 'RGB Genie',
+        description: '3 scene remote and dimmer ',
+        fromZigbee: [fz.command_recall, fz.command_move_hue, fz.command_move, fz.command_stop, fz.command_on, fz.command_off,
+            fz.command_move_to_color_temp, fz.command_move_to_color, fz.command_move_color_temperature],
+        toZigbee: [],
+        exposes: [e.action(['on', 'off', 'brightness_step_up', 'brightness_step_down', 'brightness_move_up',
+            'brightness_move_down', 'brightness_stop', 'recall_*', 'hue_move', 'color_temperature_move', 'color_move',
+            'color_temperature_move_up', 'color_temperature_move_down', 'hue_stop'])],
+    },
+    {
+        zigbeeModel: ['RGBgenie ZB-5028'],
+        model: 'ZB-5028',
+        vendor: 'RGB Genie',
+        description: 'RGB remote with 4 endpoints and 3 scene recalls',
+        fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_step, fz.command_move, fz.command_stop, fz.command_recall,
+            fz.command_move_hue, fz.command_move_to_color, fz.command_move_to_color_temp],
+        exposes: [e.battery(), e.action(['on', 'off', 'brightness_step_up', 'brightness_step_down', 'brightness_move_up',
+            'brightness_move_down', 'brightness_stop', 'recall_1', 'recall_2', 'recall_3', 'hue_move', 'color_temperature_move',
+            'color_move', 'hue_stop'])],
+        toZigbee: [],
+        meta: {multiEndpoint: true, battery: {dontDividePercentage: true}},
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['RGBgenie ZB-5004'],
+        model: 'ZB-5004',
+        vendor: 'RGB Genie',
+        description: 'Zigbee 3.0 remote control',
+        fromZigbee: [fz.command_recall, fz.command_on, fz.command_off, fz.command_move, fz.command_stop, fz.battery],
+        exposes: [e.battery(), e.action(['recall_*', 'on', 'off', 'brightness_stop', 'brightness_move_up', 'brightness_move_down'])],
+        toZigbee: [],
+    },
+];