zigbee-herdsman-converters 14.0.374 → 14.0.378

package/converters/fromZigbee.js

@@ -3672,7 +3672,7 @@ const converters = {
             case tuya.dataPoints.moesSboostHeatingCountdown:
                 return {boost_heating_countdown: value};
             case tuya.dataPoints.moesSreset:
-                break;
+                return {valve_state: value ? 'CLOSED' : 'OPEN'};
             case tuya.dataPoints.moesSwindowDetectionFunktion_A2:
                 return {window_detection: value ? 'ON' : 'OFF'};
             case tuya.dataPoints.moesSwindowDetection:
@@ -4136,6 +4136,51 @@ const converters = {
             }
         },
     },
+    evanell_thermostat: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            for (const dpValue of msg.data.dpValues) {
+                const value = tuya.getDataValue(dpValue);
+                switch (dpValue.dp) {
+                case tuya.dataPoints.evanellChildLock:
+                    result.child_lock = value ? 'LOCK' : 'UNLOCK';
+                    break;
+                case tuya.dataPoints.evanellBattery:
+                    result.battery = value;
+                    break;
+                case tuya.dataPoints.evanellHeatingSetpoint:
+                    result.current_heating_setpoint = value/10;
+                    break;
+                case tuya.dataPoints.evanellLocalTemp:
+                    result.local_temperature = value/10;
+                    break;
+                case tuya.dataPoints.evanellMode:
+                    switch (value) {
+                    case 0: // manual
+                        result.system_mode = 'auto';
+                        break;
+                    case 2: // away
+                        result.system_mode = 'heat';
+                        break;
+                    case 3: // auto
+                        result.system_mode = 'off';
+                        break;
+                    default:
+                        meta.logger.warn('zigbee-herdsman-converters:evanell_thermostat: ' +
+                          `Mode ${value} is not recognized.`);
+                        break;
+                    }
+                    break;
+                default:
+                    meta.logger.warn(`zigbee-herdsman-converters:evanell_thermostat: NOT RECOGNIZED ` +
+                      `DP #${dpValue.dp} with data ${JSON.stringify(dpValue)}`);
+                }
+            }
+            return result;
+        },
+    },
     etop_thermostat: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport'],
@@ -5160,7 +5205,7 @@ const converters = {
             if (msg.data.hasOwnProperty('0')) payload.detection_period = msg.data['0'];
             if (msg.data.hasOwnProperty('4')) payload.mode_switch = {4: 'anti_flicker_mode', 1: 'quick_mode'}[msg.data['4']];
             if (msg.data.hasOwnProperty('10')) payload.switch_type = {1: 'toggle', 2: 'momentary'}[msg.data['10']];
-            if (msg.data.hasOwnProperty('258')) payload.occupancy_timeout = msg.data['258'];
+            if (msg.data.hasOwnProperty('258')) payload.detection_interval = msg.data['258'];
             if (msg.data.hasOwnProperty('268')) payload.motion_sensitivity = {1: 'low', 2: 'medium', 3: 'high'}[msg.data['268']];
             if (msg.data.hasOwnProperty('512')) {
                 if (['ZNCZ15LM', 'QBCZ14LM', 'QBCZ15LM'].includes(model.model)) {
@@ -5321,7 +5366,7 @@ const converters = {
             if (msg.data.hasOwnProperty('illuminance')) {
                 // The occupancy sensor only sends a message when motion detected.
                 // Therefore we need to publish the no_motion detected by ourselves.
-                const timeout = meta && meta.state && meta.state.hasOwnProperty('occupancy_timeout') ? meta.state.occupancy_timeout : 60;
+                const timeout = meta && meta.state && meta.state.hasOwnProperty('detection_interval') ? meta.state.detection_interval : 60;
 
                 // Stop existing timers because motion is detected and set a new one.
                 globalStore.getValue(msg.endpoint, 'timers', []).forEach((t) => clearTimeout(t));
@@ -5355,7 +5400,7 @@ const converters = {
 
             // The occupancy sensor only sends a message when motion detected.
             // Therefore we need to publish the no_motion detected by ourselves.
-            const timeout = meta && meta.state && meta.state.hasOwnProperty('occupancy_timeout') ? meta.state.occupancy_timeout : 60;
+            const timeout = meta && meta.state && meta.state.hasOwnProperty('detection_interval') ? meta.state.detection_interval : 60;
 
             // Stop existing timers because motion is detected and set a new one.
             globalStore.getValue(msg.endpoint, 'timers', []).forEach((t) => clearTimeout(t));
@@ -7516,41 +7561,58 @@ const converters = {
             const dpValue = tuya.firstDpValue(msg, meta, 'tuya_radar_sensor');
             const dp = dpValue.dp;
             const value = tuya.getDataValue(dpValue);
+            let result = null;
             switch (dp) {
             case tuya.dataPoints.trsPresenceState:
-                return {presence: {0: false, 1: true}[value]};
+                result = {presence: {0: false, 1: true}[value]};
+                break;
             case tuya.dataPoints.trsMotionState:
-                return {motion: {1: false, 2: true}[value]};
+                result = {occupancy: {1: false, 2: true}[value]};
+                break;
             case tuya.dataPoints.trsMotionSpeed:
-                return {motion_speed: value};
+                result = {motion_speed: value};
+                break;
             case tuya.dataPoints.trsMotionDirection:
-                return {motion_direction: {0: 'standing_still', 1: 'moving_forward', 2: 'moving_backward'}[value]};
+                result = {motion_direction: tuya.tuyaRadar.motionDirection[value]};
+                break;
             case tuya.dataPoints.trsScene:
-                return {radar_scene: {'default': 0, 'area': 1, 'toilet': 2, 'bedroom': 3, 'parlour': 4, 'office': 5, 'hotel': 6}[value]};
+                result = {radar_scene: tuya.tuyaRadar.radarScene[value]};
+                break;
             case tuya.dataPoints.trsSensitivity:
-                return {radar_sensitivity: value};
+                result = {radar_sensitivity: value};
+                break;
             case tuya.dataPoints.trsIlluminanceLux:
-                return {illuminance_lux: value};
+                result = {illuminance_lux: value};
+                break;
+            default:
+                meta.logger.warn(`fromZigbee.tuya_radar_sensor: NOT RECOGNIZED DP ${dp} with data ${JSON.stringify(dpValue)}`);
             }
+            return result;
         },
     },
     tuya_smart_vibration_sensor: {
         cluster: 'manuSpecificTuya',
         type: ['commandGetData', 'commandDataResponse', 'raw'],
         convert: (model, msg, publish, options, meta) => {
-            const dp = msg.data.dp;
-            const value = tuya.getDataValue(msg.data.datatype, msg.data.data);
-            switch (dp) {
-            case tuya.dataPoints.state:
-                return {contact: Boolean(value)};
-            case tuya.dataPoints.thitBatteryPercentage:
-                return {battery: value};
-            case tuya.dataPoints.tuyaVibration:
-                return {vibration: Boolean(value)};
-            default:
-                meta.logger.warn(`zigbee-herdsman-converters:tuya_smart_vibration_sensor: NOT RECOGNIZED ` +
-                    `DP #${dp} with data ${JSON.stringify(msg.data)}`);
+            const result = {};
+            for (const dpValue of msg.data.dpValues) {
+                const value = tuya.getDataValue(dpValue);
+                switch (dpValue.dp) {
+                case tuya.dataPoints.state:
+                    result.contact = Boolean(value);
+                    break;
+                case tuya.dataPoints.thitBatteryPercentage:
+                    result.battery = value;
+                    break;
+                case tuya.dataPoints.tuyaVibration:
+                    result.vibration = Boolean(value);
+                    break;
+                default:
+                    meta.logger.warn(`zigbee-herdsman-converters:tuya_smart_vibration_sensor: NOT RECOGNIZED ` +
+                        `DP #${dpValue.dp} with data ${JSON.stringify(dpValue)}`);
+                }
             }
+            return result;
         },
     },
     moes_thermostat_tv: {

package/converters/toZigbee.js

@@ -2078,12 +2078,12 @@ const converters = {
             await entity.read('aqaraOpple', [0x0000], manufacturerOptions.xiaomi);
         },
     },
-    aqara_occupancy_timeout: {
-        key: ['occupancy_timeout'],
+    aqara_detection_interval: {
+        key: ['detection_interval'],
         convertSet: async (entity, key, value, meta) => {
             value *= 1;
             await entity.write('aqaraOpple', {0x0102: {value: [value], type: 0x20}}, manufacturerOptions.xiaomi);
-            return {state: {occupancy_timeout: value}};
+            return {state: {detection_interval: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('aqaraOpple', [0x0102], manufacturerOptions.xiaomi);
@@ -5029,6 +5029,28 @@ const converters = {
             }
         },
     },
+    ts0201_temperature_humidity_alarm: {
+        key: ['alarm_humidity_max', 'alarm_humidity_min', 'alarm_temperature_max', 'alarm_temperature_min'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'alarm_temperature_max':
+            case 'alarm_temperature_min':
+            case 'alarm_humidity_max':
+            case 'alarm_humidity_min': {
+                // await entity.write('manuSpecificTuya_2', {[key]: value});
+                // instead write as custom attribute to override incorrect herdsman dataType from uint16 to int16
+                // https://github.com/Koenkk/zigbee-herdsman/blob/v0.13.191/src/zcl/definition/cluster.ts#L4235
+                const keyToAttributeLookup = {'alarm_temperature_max': 0xD00A, 'alarm_temperature_min': 0xD00B,
+                    'alarm_humidity_max': 0xD00D, 'alarm_humidity_min': 0xD00E};
+                const payload = {[keyToAttributeLookup[key]]: {value: value, type: 0x29}};
+                await entity.write('manuSpecificTuya_2', payload);
+                break;
+            }
+            default: // Unknown key
+                meta.logger.warn(`Unhandled key ${key}`);
+            }
+        },
+    },
     heiman_ir_remote: {
         key: ['send_key', 'create', 'learn', 'delete', 'get_list'],
         convertSet: async (entity, key, value, meta) => {
@@ -5066,7 +5088,7 @@ const converters = {
         key: ['scene_store'],
         convertSet: async (entity, key, value, meta) => {
             const isGroup = entity.constructor.name === 'Group';
-            const groupid = isGroup ? entity.groupID : 0;
+            const groupid = isGroup ? entity.groupID : value.hasOwnProperty('group_id') ? value.group_id : 0;
             let sceneid = value;
             let scenename = null;
             if (typeof value === 'object') {
@@ -5166,7 +5188,7 @@ const converters = {
             }
 
             const isGroup = entity.constructor.name === 'Group';
-            const groupid = isGroup ? entity.groupID : 0;
+            const groupid = isGroup ? entity.groupID : value.hasOwnProperty('group_id') ? value.group_id : 0;
             const sceneid = value.ID;
             const scenename = value.name;
             const transtime = value.hasOwnProperty('transition') ? value.transition : 0;
@@ -5411,6 +5433,35 @@ const converters = {
             await tuya.sendDataPointValue(entity, tuya.dataPoints.saswellTempCalibration, value);
         },
     },
+    evanell_thermostat_current_heating_setpoint: {
+        key: ['current_heating_setpoint'],
+        convertSet: async (entity, key, value, meta) => {
+            const temp = Math.round(value * 10);
+            await tuya.sendDataPointValue(entity, tuya.dataPoints.evanellHeatingSetpoint, temp);
+        },
+    },
+    evanell_thermostat_system_mode: {
+        key: ['system_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (value) {
+            case 'off':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.evanellMode, 3 /* off */);
+                break;
+            case 'heat':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.evanellMode, 2 /* manual */);
+                break;
+            case 'auto':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.evanellMode, 0 /* auto */);
+                break;
+            }
+        },
+    },
+    evanell_thermostat_child_lock: {
+        key: ['child_lock'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointBool(entity, tuya.dataPoints.evanellChildLock, value === 'LOCK');
+        },
+    },
     silvercrest_smart_led_string: {
         key: ['color', 'brightness', 'effect'],
         convertSet: async (entity, key, value, meta) => {
@@ -6244,11 +6295,13 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
             case 'radar_scene':
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.trsScene, value);
-                return {state: {radar_scene: value}};
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.trsScene, utils.getKey(tuya.tuyaRadar.radarScene, value));
+                break;
             case 'radar_sensitivity':
                 await tuya.sendDataPointValue(entity, tuya.dataPoints.trsSensitivity, value);
-                return {state: {radar_sensitivity: value}};
+                break;
+            default: // Unknown Key
+                meta.logger.warn(`toZigbee.tuya_radar_sensor: Unhandled Key ${key}`);
             }
         },
     },

package/devices/bticino.js

@@ -30,19 +30,22 @@ module.exports = [
         vendor: 'BTicino',
         description: 'Dimmer switch with neutral',
         extend: extend.light_onoff_brightness({noConfigure: true}),
-        exposes: [
-            e.light_brightness(),
+        fromZigbee: [fz.brightness, fz.identify, fz.on_off, fz.lighting_ballast_configuration],
+        toZigbee: [tz.light_onoff_brightness, tz.legrand_settingAlwaysEnableLed, tz.legrand_settingEnableLedIfOn,
+            tz.legrand_settingEnableDimmer, tz.legrand_identify, tz.ballast_config],
+        exposes: [e.light_brightness(),
+            exposes.numeric('ballast_minimum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the minimum brightness value'),
+            exposes.numeric('ballast_maximum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the maximum brightness value'),
             exposes.binary('dimmer_enabled', ea.STATE_SET, 'ON', 'OFF').withDescription('Allow the device to change brightness'),
             exposes.binary('permanent_led', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable or disable the permanent blue LED'),
-            exposes.binary('led_when_on', ea.STATE_SET, 'ON', 'OFF').withDescription('Enables the LED when the light is on'),
-        ],
-        fromZigbee: [fz.brightness, fz.identify, fz.on_off],
-        toZigbee: [tz.light_onoff_brightness, tz.legrand_settingAlwaysEnableLed, tz.legrand_settingEnableLedIfOn,
-            tz.legrand_settingEnableDimmer, tz.legrand_identify],
+            exposes.binary('led_when_on', ea.STATE_SET, 'ON', 'OFF').withDescription('Enables the LED when the light is on')],
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'genLevelCtrl', 'genBinaryInput']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'genLevelCtrl',
+                'genBinaryInput', 'lightingBallastCfg']);
             await reporting.onOff(endpoint);
             await reporting.brightness(endpoint);
         },

package/devices/evanell.js

@@ -0,0 +1,29 @@
+const exposes = require('../lib/exposes');
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const tuya = require('../lib/tuya');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+const ea = exposes.access;
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_dmfguuli'}],
+        model: 'EZ200',
+        vendor: 'Evanell',
+        description: 'Thermostatic radiator valve',
+        fromZigbee: [fz.evanell_thermostat],
+        toZigbee: [tz.evanell_thermostat_current_heating_setpoint, tz.evanell_thermostat_system_mode,
+            tz.evanell_thermostat_child_lock],
+        onEvent: tuya.onEventSetTime,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic']);
+        },
+        exposes: [e.child_lock(), e.battery(),
+            exposes.climate()
+                .withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET).withLocalTemperature(ea.STATE)
+                .withSystemMode(['off', 'heat', 'auto'], ea.STATE_SET),
+        ],
+    },
+];

package/devices/hive.js

@@ -2,9 +2,9 @@ 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 constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
+const {extendDevice} = require('../lib/utils');
 const e = exposes.presets;
 const ea = exposes.access;
 
@@ -149,130 +149,12 @@ module.exports = [
             }
         },
     },
-    {
-        // TRV001 is the same as Danfoss Ally (eTRV0100) and Popp eT093WRO. If implementing anything, please consider
-        // changing those two too.
+    extendDevice(require('./danfoss'), '014G2461', {
         zigbeeModel: ['TRV001'],
         model: 'UK7004240',
         vendor: 'Hive',
-        description: 'Radiator valve based on Danfos Ally',
-        fromZigbee: [fz.battery, fz.thermostat, fz.thermostat_weekly_schedule, fz.hvac_user_interface, fz.danfoss_thermostat],
-        toZigbee: [tz.danfoss_thermostat_occupied_heating_setpoint, tz.thermostat_local_temperature, tz.danfoss_mounted_mode_active,
-            tz.danfoss_mounted_mode_control, tz.danfoss_thermostat_vertical_orientation, tz.danfoss_algorithm_scale_factor,
-            tz.danfoss_heat_available, tz.danfoss_heat_required, tz.danfoss_day_of_week, tz.danfoss_trigger_time,
-            tz.danfoss_window_open_internal, tz.danfoss_window_open_external, tz.danfoss_load_estimate,
-            tz.danfoss_viewing_direction, tz.danfoss_external_measured_room_sensor, tz.thermostat_keypad_lockout,
-            tz.thermostat_system_mode, tz.danfoss_load_balancing_enable, tz.danfoss_load_room_mean,
-            tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule, tz.thermostat_programming_operation_mode],
-        exposes: [e.battery(), e.keypad_lockout(), e.programming_operation_mode(),
-            exposes.binary('mounted_mode_active', ea.STATE_GET, true, false)
-                .withDescription('Is the unit in mounting mode. This is set to `false` for mounted (already on ' +
-                    'the radiator) or `true` for not mounted (after factory reset)'),
-            exposes.binary('mounted_mode_control', ea.ALL, true, false)
-                .withDescription('Set the unit mounting mode. `false` Go to Mounted Mode or `true` Go to Mounting Mode'),
-            exposes.binary('thermostat_vertical_orientation', ea.ALL, true, false)
-                .withDescription('Thermostat Orientation. This is important for the PID in how it assesses temperature. ' +
-                    '`false` Horizontal or `true` Vertical'),
-            exposes.binary('viewing_direction', ea.ALL, true, false)
-                .withDescription('Viewing/Display Direction. `false` Horizontal or `true` Vertical'),
-            exposes.binary('heat_available', ea.ALL, true, false)
-                .withDescription('Not clear how this affects operation. `false` No Heat Available or `true` Heat Available'),
-            exposes.binary('heat_required', ea.STATE_GET, true, false)
-                .withDescription('Whether or not the unit needs warm water. `false` No Heat Request or `true` Heat Request'),
-            exposes.enum('setpoint_change_source', ea.STATE, ['manual', 'schedule', 'externally'])
-                .withDescription('Values observed are `0` (manual), `1` (schedule) or `2` (externally)'),
-            exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 32, 0.5).withLocalTemperature().withPiHeatingDemand()
-                .withSystemMode(['heat']).withRunningState(['idle', 'heat'], ea.STATE),
-            exposes.numeric('external_measured_room_sensor', ea.ALL)
-                .withDescription('Set at maximum 3 hours interval but not more often than every 30 minutes and 0.1 ' +
-                    'degrees difference. Resets every 3hours to standard. e.g. 21C = 2100 (-8000=undefined).')
-                .withValueMin(-8000).withValueMax(3500),
-            exposes.numeric('window_open_internal', ea.STATE_GET).withValueMin(0).withValueMax(4)
-                .withDescription('0=Quarantine, 1=Windows are closed, 2=Hold - Windows are maybe about to open, ' +
-                    '3=Open window detected, 4=In window open state from external but detected closed locally'),
-            exposes.binary('window_open_external', ea.ALL, true, false)
-                .withDescription('Set if the window is open or close. This setting will trigger a change in the internal ' +
-                    'window and heating demand. `false` (windows are closed) or `true` (windows are open)'),
-            exposes.enum('day_of_week', ea.ALL,
-                ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'away_or_vacation'])
-                .withDescription('Exercise day of week: 0=Sun...6=Sat, 7=undefined'),
-            exposes.numeric('trigger_time', ea.ALL).withValueMin(0).withValueMax(65535)
-                .withDescription('Exercise trigger time. Minutes since midnight (65535=undefined). Range 0 to 1439'),
-            exposes.numeric('algorithm_scale_factor', ea.ALL).withValueMin(1).withValueMax(10)
-                .withDescription('Scale factor of setpoint filter timeconstant ("aggressiveness" of control algorithm) '+
-                    '1= Quick ...  5=Moderate ... 10=Slow'),
-            exposes.binary('load_balancing_enable', ea.ALL, true, false)
-                .withDescription('Whether or not the thermostat acts as standalone thermostat or shares load with other ' +
-                    'thermostats in the room. The gateway must update load_room_mean if enabled.'),
-            exposes.numeric('load_room_mean', ea.ALL)
-                .withDescription('Mean radiator load for room calculated by gateway for load balancing purposes (-8000=undefined)')
-                .withValueMin(-8000).withValueMax(2000),
-            exposes.numeric('load_estimate', ea.STATE_GET)
-                .withDescription('Load estimate on this radiator')],
-        configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint = device.getEndpoint(1);
-            const options = {manufacturerCode: 0x1246};
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'hvacThermostat']);
-
-            // standard ZCL attributes
-            await reporting.batteryPercentageRemaining(endpoint);
-            await reporting.thermostatTemperature(endpoint);
-            await reporting.thermostatPIHeatingDemand(endpoint);
-            await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
-
-            // danfoss attributes
-            await endpoint.configureReporting('hvacThermostat', [{
-                attribute: 'danfossMountedModeActive',
-                minimumReportInterval: constants.repInterval.MINUTE,
-                maximumReportInterval: constants.repInterval.MAX,
-                reportableChange: 1,
-            }], options);
-            await endpoint.configureReporting('hvacThermostat', [{
-                attribute: 'danfossWindowOpenInternal',
-                minimumReportInterval: constants.repInterval.MINUTE,
-                maximumReportInterval: constants.repInterval.HOUR,
-                reportableChange: 1,
-            }], options);
-            await endpoint.configureReporting('hvacThermostat', [{
-                attribute: 'danfossHeatRequired',
-                minimumReportInterval: constants.repInterval.MINUTE,
-                maximumReportInterval: constants.repInterval.HOUR,
-                reportableChange: 1,
-            }], options);
-            await endpoint.configureReporting('hvacThermostat', [{
-                attribute: 'danfossExternalMeasuredRoomSensor',
-                minimumReportInterval: constants.repInterval.MINUTE,
-                maximumReportInterval: constants.repInterval.MAX,
-                reportableChange: 1,
-            }], options);
-
-            await endpoint.read('hvacThermostat', [
-                'danfossWindowOpenExternal',
-                'danfossDayOfWeek',
-                'danfossTriggerTime',
-                'danfossAlgorithmScaleFactor',
-                'danfossHeatAvailable',
-                'danfossMountedModeControl',
-                'danfossMountedModeActive',
-                'danfossExternalMeasuredRoomSensor',
-                'danfossLoadBalancingEnable',
-                'danfossLoadRoomMean',
-            ], options);
-
-            // read systemMode to have an initial value
-            await endpoint.read('hvacThermostat', ['systemMode']);
-
-            // read keypadLockout, we don't need reporting as it cannot be set physically on the device
-            await endpoint.read('hvacUserInterfaceCfg', ['keypadLockout']);
-
-            // Seems that it is bug in Danfoss, device does not asks for the time with binding
-            // So, we need to write time during configure (same as for HEIMAN devices)
-            const time = Math.round(((new Date()).getTime() - constants.OneJanuary2000) / 1000);
-            // Time-master + synchronised
-            const values = {timeStatus: 3, time: time, timeZone: ((new Date()).getTimezoneOffset() * -1) * 60};
-            endpoint.write('genTime', values);
-        },
-    },
+        description: 'Radiator valve based on Danfoss Ally (014G2461)',
+    }),
     {
         zigbeeModel: ['SLR1'],
         model: 'SLR1',

package/devices/iris.js

@@ -19,6 +19,8 @@ module.exports = [
             await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'genPowerCfg']);
             await reporting.temperature(endpoint);
             await reporting.batteryVoltage(endpoint);
+            device.powerSource = 'Battery';
+            device.save();
         },
         exposes: [e.contact(), e.battery_low(), e.tamper(), e.temperature(), e.battery()],
     },

package/devices/jasco.js

@@ -0,0 +1,18 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['35938'],
+        model: 'ZB3102',
+        vendor: 'Jasco Products',
+        description: 'Zigbee plug-in smart 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']);
+            await reporting.onOff(endpoint);
+        },
+    },
+];

package/devices/ledvance.js

@@ -3,6 +3,13 @@ const extend = require('../lib/extend');
 const reporting = require('../lib/reporting');
 
 module.exports = [
+    {
+        zigbeeModel: ['A60S TW'],
+        model: 'AC33898',
+        vendor: 'LEDVANCE',
+        description: ' Smart+ LED classic E27 Zigbee 10W/810lm',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+    },
     {
         zigbeeModel: ['Outdoor Plug', 'Plug Value'],
         model: 'AC26940/AC31266',

package/devices/moes.js

@@ -206,7 +206,7 @@ module.exports = [
             tz.moesS_thermostat_system_mode, tz.moesS_thermostat_schedule_programming],
         exposes: [
             e.battery(), e.child_lock(), e.eco_mode(), e.eco_temperature(), e.max_temperature(), e.min_temperature(),
-            e.position(), e.window_detection(),
+            e.valve_state(), e.position(), e.window_detection(),
             exposes.binary('window', ea.STATE, 'CLOSED', 'OPEN').withDescription('Window status closed or open '),
             exposes.climate()
                 .withLocalTemperature(ea.STATE).withSetpoint('current_heating_setpoint', 5, 35, 0.5, ea.STATE_SET)

package/devices/philips.js

@@ -2574,4 +2574,13 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['LWA019'],
+        model: '9290024691',
+        vendor: 'Philips',
+        description: 'Hue white single filament bulb A19 E26 with Bluetooth (1100 Lumen)',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
 ];