zigbee-herdsman-converters 15.0.25 → 15.0.26

package/devices/diyruz.js

@@ -63,7 +63,8 @@ module.exports = [
         vendor: 'DIYRuZ',
         description: '[DiY 8/12/20 button keypad](http://modkam.ru/?p=1114)',
         fromZigbee: [fz.diyruz_freepad_clicks, fz.diyruz_freepad_config, fz.battery],
-        exposes: [e.battery(), e.action(['*_single', '*_double', '*_triple', '*_quadruple', '*_release'])].concat(((enpoinsCount) => {
+        exposes: [e.battery(),
+            e.action(['*_single', '*_double', '*_triple', '*_quadruple', '*_release', '*_hold'])].concat(((enpoinsCount) => {
             const features = [];
             for (let i = 1; i <= enpoinsCount; i++) {
                 const epName = `button_${i}`;

package/devices/philips.js

@@ -1575,6 +1575,13 @@ module.exports = [
         description: 'Hue Gradient Signe floor lamp (wood)',
         extend: philips.extend.light_onoff_brightness_colortemp_color_gradient({colorTempRange: [153, 500]}),
     },
+    {
+        zigbeeModel: ['929003516101'],
+        model: '929003516101',
+        vendor: 'Philips',
+        description: 'Hue Gradient Signe floor lamp (wood)',
+        extend: philips.extend.light_onoff_brightness_colortemp_color_gradient({colorTempRange: [153, 500]}),
+    },
     {
         zigbeeModel: ['LCT020'],
         model: '4080148P7',
@@ -2224,6 +2231,13 @@ module.exports = [
         description: 'Hue white filament Edison ST19 E26 LED warm-to-cool',
         extend: philips.extend.light_onoff_brightness_colortemp({colorTempRange: [222, 454]}),
     },
+    {
+        zigbeeModel: ['LTV005'],
+        model: '9290029808',
+        vendor: 'Philips',
+        description: 'Hue white filament Edison ST23 E26 LED warm-to-cool',
+        extend: philips.extend.light_onoff_brightness_colortemp({colorTempRange: [222, 454]}),
+    },
     {
         zigbeeModel: ['LTO004'],
         model: '9290024785',

package/devices/xiaomi.js

@@ -10,6 +10,8 @@ const ea = exposes.access;
 const globalStore = require('../lib/store');
 const xiaomi = require('../lib/xiaomi');
 const utils = require('../lib/utils');
+const {printNumberAsHex, printNumbersAsHexSequence} = utils;
+const {fp1, manufacturerCode} = xiaomi;
 
 const xiaomiExtend = {
     light_onoff_brightness_colortemp: (options={disableColorTempStartup: true}) => ({
@@ -211,6 +213,73 @@ const fzLocal = {
             return result;
         },
     },
+    aqara_fp1_region_events: {
+        cluster: 'aqaraOpple',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            /**
+             * @type {{ region_event?: string; }}
+             */
+            const payload = {};
+            const log = utils.createLogger(meta.logger, 'xiaomi', 'aqara_fp1');
+
+            Object.entries(msg.data).forEach(([key, value]) => {
+                const eventKey = parseInt(key);
+                const eventKeyHex = printNumberAsHex(eventKey, 4);
+
+                switch (eventKey) {
+                case fp1.constants.region_event_key: {
+                    if (
+                        !Buffer.isBuffer(value) ||
+                        !(typeof value[0] === 'string' || typeof value[0] === 'number') ||
+                        !(typeof value[1] === 'string' || typeof value[1] === 'number')
+                    ) {
+                        log('warn', `region_event: Unrecognized payload structure '${JSON.stringify(value)}'`);
+                        break;
+                    }
+
+                    /**
+                     * @type {[ regionId: number | string, eventTypeCode: number | string ]}
+                     */
+                    const [regionIdRaw, eventTypeCodeRaw] = value;
+                    const regionId = parseInt(regionIdRaw, 10);
+                    const eventTypeCode = parseInt(eventTypeCodeRaw, 10);
+
+                    if (Number.isNaN(regionId)) {
+                        log('warn', `region_event: Invalid regionId "${regionIdRaw}"`);
+                        break;
+                    }
+                    if (!Object.values(fp1.constants.region_event_types).includes(eventTypeCode)) {
+                        log('warn', `region_event: Unknown region event type "${eventTypeCode}"`);
+                        break;
+                    }
+
+                    const eventTypeName = fp1.mappers.aqara_fp1.region_event_type_names[eventTypeCode];
+                    log('debug', `region_event: Triggered event (region "${regionId}", type "${eventTypeName}")`);
+                    payload.region_event = `region_${regionId}_${eventTypeName}`;
+                    break;
+                }
+                case 0xf7: {
+                    const valueHexSequence = printNumbersAsHexSequence(value, 2);
+                    log('debug', `Unhandled key ${eventKeyHex} = ${valueHexSequence}`);
+                    break;
+                }
+                case 0x0142:
+                case 0x0143:
+                case 0x0144:
+                case 0x0146: {
+                    log('debug', `Unhandled key ${eventKeyHex} = ${value}`);
+                    break;
+                }
+                default: {
+                    log('warn', `Unknown key ${eventKeyHex} = ${value}`);
+                }
+                }
+            });
+
+            return payload;
+        },
+    },
 };
 
 const tzLocal = {
@@ -415,6 +484,113 @@ const tzLocal = {
             return {state: {[key]: value}};
         },
     },
+    aqara_fp1_region_upsert: {
+        key: ['region_upsert'],
+        convertSet: async (entity, key, value, meta) => {
+            const log = utils.createLogger(meta.logger, 'xiaomi', 'aqara_fp1:region_upsert');
+            const commandWrapper = fp1.parseAqaraFp1RegionUpsertInput(value);
+
+            if (!commandWrapper.isSuccess) {
+                log('warn',
+                    `encountered an error (${commandWrapper.error.reason}) ` +
+                    `while parsing configuration commands (input: ${JSON.stringify(value)})`,
+                );
+
+                return;
+            }
+
+            const command = commandWrapper.payload.command;
+
+            log('debug', `trying to create region ${command.region_id}`);
+
+            /** @type {Record<string, Set<number>>} */
+            const sortedZonesAccumulator = {};
+            const sortedZones = command.zones
+                .reduce(
+                    (accumulator, zone) => {
+                        if (!accumulator[zone.y]) {
+                            accumulator[zone.y] = new Set();
+                        }
+
+                        accumulator[zone.y].add(zone.x);
+
+                        return accumulator;
+                    },
+                    sortedZonesAccumulator,
+                );
+
+            const deviceConfig = new Uint8Array(7);
+
+            // Command parameters
+            deviceConfig[0] = fp1.constants.region_config_cmds.create;
+            deviceConfig[1] = command.region_id;
+            deviceConfig[6] = fp1.constants.region_config_cmd_suffix_upsert;
+            // Zones definition
+            deviceConfig[2] |= fp1.encodeXCellsDefinition(sortedZones['1']);
+            deviceConfig[2] |= fp1.encodeXCellsDefinition(sortedZones['2']) << 4;
+            deviceConfig[3] |= fp1.encodeXCellsDefinition(sortedZones['3']);
+            deviceConfig[3] |= fp1.encodeXCellsDefinition(sortedZones['4']) << 4;
+            deviceConfig[4] |= fp1.encodeXCellsDefinition(sortedZones['5']);
+            deviceConfig[4] |= fp1.encodeXCellsDefinition(sortedZones['6']) << 4;
+            deviceConfig[5] |= fp1.encodeXCellsDefinition(sortedZones['7']);
+
+            log('info', `create region ${command.region_id} ${printNumbersAsHexSequence([...deviceConfig], 2)}`);
+
+            const payload = {
+                [fp1.constants.region_config_write_attribute]: {
+                    value: deviceConfig,
+                    type: fp1.constants.region_config_write_attribute_type,
+                },
+            };
+
+            await entity.write('aqaraOpple', payload, {manufacturerCode});
+        },
+    },
+    aqara_fp1_region_delete: {
+        key: ['region_delete'],
+        convertSet: async (entity, key, value, meta) => {
+            const log = utils.createLogger(meta.logger, 'xiaomi', 'aqara_fp1:region_delete');
+            const commandWrapper = fp1.parseAqaraFp1RegionDeleteInput(value);
+
+            if (!commandWrapper.isSuccess) {
+                log('warn',
+                    `encountered an error (${commandWrapper.error.reason}) ` +
+                    `while parsing configuration commands (input: ${JSON.stringify(value)})`,
+                );
+                return;
+            }
+
+            const command = commandWrapper.payload.command;
+
+            log('debug', `trying to delete region ${command.region_id}`);
+
+            const deviceConfig = new Uint8Array(7);
+
+            // Command parameters
+            deviceConfig[0] = fp1.constants.region_config_cmds.delete;
+            deviceConfig[1] = command.region_id;
+            deviceConfig[6] = fp1.constants.region_config_cmd_suffix_delete;
+            // Zones definition
+            deviceConfig[2] = 0;
+            deviceConfig[3] = 0;
+            deviceConfig[4] = 0;
+            deviceConfig[5] = 0;
+
+            log('info',
+                `delete region ${command.region_id} ` +
+                `(${printNumbersAsHexSequence([...deviceConfig], 2)})`,
+            );
+
+            const payload = {
+                [fp1.constants.region_config_write_attribute]: {
+                    value: deviceConfig,
+                    type: fp1.constants.region_config_write_attribute_type,
+                },
+            };
+
+            await entity.write('aqaraOpple', payload, {manufacturerCode});
+        },
+    },
 };
 
 module.exports = [
@@ -1471,11 +1647,14 @@ module.exports = [
         zigbeeModel: ['lumi.motion.ac01'],
         model: 'RTCZCGQ11LM',
         vendor: 'Xiaomi',
-        description: 'Aqara presence detector FP1 (regions not supported for now)',
-        fromZigbee: [fz.aqara_opple],
-        toZigbee: [tz.RTCZCGQ11LM_presence, tz.RTCZCGQ11LM_monitoring_mode, tz.RTCZCGQ11LM_approach_distance,
-            tz.aqara_motion_sensitivity, tz.RTCZCGQ11LM_reset_nopresence_status],
-        exposes: [e.presence().withAccess(ea.STATE_GET),
+        description: 'Aqara presence detector FP1',
+        fromZigbee: [fz.aqara_opple, fzLocal.aqara_fp1_region_events],
+        toZigbee: [
+            tz.RTCZCGQ11LM_presence, tz.RTCZCGQ11LM_monitoring_mode, tz.RTCZCGQ11LM_approach_distance, tz.aqara_motion_sensitivity,
+            tz.RTCZCGQ11LM_reset_nopresence_status, tzLocal.aqara_fp1_region_upsert, tzLocal.aqara_fp1_region_delete,
+        ],
+        exposes: [
+            e.presence().withAccess(ea.STATE_GET), e.device_temperature(), e.power_outage_count(),
             exposes.enum('presence_event', ea.STATE, ['enter', 'leave', 'left_enter', 'right_leave', 'right_enter', 'left_leave',
                 'approach', 'away']).withDescription('Presence events: "enter", "leave", "left_enter", "right_leave", ' +
                 '"right_enter", "left_leave", "approach", "away"'),
@@ -1486,7 +1665,41 @@ module.exports = [
             exposes.enum('motion_sensitivity', ea.ALL, ['low', 'medium', 'high']).withDescription('Different sensitivities ' +
                 'means different static human body recognition rate and response speed of occupied'),
             exposes.enum('reset_nopresence_status', ea.SET, ['']).withDescription('Reset the status of no presence'),
-            e.device_temperature(), e.power_outage_count()],
+            exposes.enum('action', ea.STATE, ['region_*_enter', 'region_*_leave', 'region_*_occupied',
+                'region_*_unoccupied']).withDescription('Most recent region event. Event template is "region_<REGION_ID>_<EVENT_TYPE>", ' +
+                'where <REGION_ID> is region number (1-10), <EVENT_TYPE> is one of "enter", "leave", "occupied", "unoccupied". ' +
+                '"enter" / "leave" events are usually triggered first, followed by "occupied" / "unoccupied" after a couple of seconds.'),
+            exposes.composite('region_upsert', 'region_upsert', ea.SET)
+                .withDescription(
+                    'Definition of a new region to be added (or replace existing one). ' +
+                    'Creating or modifying a region requires you to define which zones of a 7x4 detection grid ' +
+                    'should be active for that zone. Regions can overlap, meaning that a zone can be defined ' +
+                    'in more than one region (eg. "zone x = 1 & y = 1" can be added to region 1 & 2). ' +
+                    '"Zone x = 1 & y = 1" is the nearest zone on the right (from sensor\'s perspective, along the detection path).',
+                )
+                .withFeature(
+                    exposes.numeric('region_id', ea.SET)
+                        .withValueMin(fp1.constants.region_config_regionId_min)
+                        .withValueMax(fp1.constants.region_config_regionId_max),
+                )
+                .withFeature(
+                    exposes.list('zones', ea.SET,
+                        exposes.composite('zone_position', ea.SET)
+                            .withFeature(exposes.numeric('x', ea.SET)
+                                .withValueMin(fp1.constants.region_config_zoneX_min)
+                                .withValueMax(fp1.constants.region_config_zoneX_max))
+                            .withFeature(exposes.numeric('y', ea.SET)
+                                .withValueMin(fp1.constants.region_config_zoneY_min)
+                                .withValueMax(fp1.constants.region_config_zoneY_max)),
+                    ),
+                ),
+            exposes.composite('region_delete', 'region_delete', ea.SET)
+                .withDescription('Region definition to be deleted from the device.')
+                .withFeature(exposes.numeric('region_id', ea.SET)
+                    .withValueMin(fp1.constants.region_config_regionId_min)
+                    .withValueMax(fp1.constants.region_config_regionId_max),
+                ),
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('aqaraOpple', [0x010c], {manufacturerCode: 0x115f});
@@ -2710,7 +2923,7 @@ module.exports = [
         fromZigbee: [fzLocal.aqara_feeder],
         toZigbee: [tzLocal.aqara_feeder],
         exposes: [
-            exposes.enum('feed', ea.STATE_SET, ['START']).withDescription('Start feeding'),
+            exposes.enum('feed', ea.STATE_SET, ['', 'START']).withDescription('Start feeding'),
             exposes.enum('feeding_source', ea.STATE, ['schedule', 'manual', 'remote']).withDescription('Feeding source'),
             exposes.numeric('feeding_size', ea.STATE).withDescription('Feeding size').withUnit('portion'),
             exposes.numeric('portions_per_day', ea.STATE).withDescription('Portions per day'),
@@ -2734,6 +2947,10 @@ module.exports = [
                 .withUnit('g'),
         ],
         ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('aqaraOpple', [0xfff1], {manufacturerCode: 0x115f});
+        },
     },
     {
         zigbeeModel: ['lumi.remote.acn007'],

package/index.js

@@ -228,5 +228,15 @@ module.exports = {
             const payload = {0xf00: {value: 23, type: 35}};
             await endpoint.readResponse('genBasic', data.meta.zclTransactionSequenceNumber, payload, options);
         }
+        // Aqara feeder C1 polls the time during the interview, need to send back the local time instead of the UTC.
+        // The device.definition has not yet been set - therefore the device.definition.onEvent method does not work.
+        if (type === 'message' && data.type === 'read' && data.cluster === 'genTime' &&
+            device.modelID === 'aqara.feeder.acn001') {
+            device.skipTimeResponse = true;
+            const oneJanuary2000 = new Date('January 01, 2000 00:00:00 UTC+00:00').getTime();
+            const secondsUTC = Math.round(((new Date()).getTime() - oneJanuary2000) / 1000);
+            const secondsLocal = secondsUTC - (new Date()).getTimezoneOffset() * 60;
+            await device.getEndpoint(1).readResponse('genTime', data.meta.zclTransactionSequenceNumber, {time: secondsLocal});
+        }
     },
 };

package/lib/utils.js

@@ -454,6 +454,37 @@ function attachOutputCluster(device, clusterKey) {
     }
 }
 
+/**
+ * @param {number} value
+ * @param {number} hexLength
+ * @return {string}
+ */
+function printNumberAsHex(value, hexLength) {
+    const hexValue = value.toString(16).padStart(hexLength, '0');
+    return `0x${hexValue}`;
+}
+
+/**
+ * @param {number[]} numbers
+ * @param {number} hexLength
+ * @return {string}
+ */
+function printNumbersAsHexSequence(numbers, hexLength) {
+    return numbers.map((v) => v.toString(16).padStart(hexLength, '0')).join(':');
+}
+
+// Note: this is valid typescript-flavored JSDoc
+// eslint-disable-next-line valid-jsdoc
+/**
+ * @param {logger} logger
+ * @param {vendor} vendor
+ * @param {key} key
+ * @returns {(level: string, message: string) => void}
+ */
+const createLogger = (logger, vendor, key) => (level, message) => {
+    logger[level](`zigbee-herdsman-converters:${vendor}:${key}: ${message}`);
+};
+
 module.exports = {
     noOccupancySince,
     getOptions,
@@ -490,4 +521,7 @@ module.exports = {
     getSceneState,
     extendDevice,
     attachOutputCluster,
+    printNumberAsHex,
+    printNumbersAsHexSequence,
+    createLogger,
 };

package/lib/xiaomi.js

@@ -684,9 +684,188 @@ const numericAttributes2Options = (definition) => {
     return result;
 };
 
+// For RTCZCGQ11LM
+/**
+ * @typedef {{
+*  x: number,
+*  y: number,
+* }} AqaraFP1RegionZone
+*/
+const fp1Constants = {
+    region_event_key: 0x0151,
+    region_event_types: {
+        Enter: 1,
+        Leave: 2,
+        Occupied: 4,
+        Unoccupied: 8,
+    },
+    region_config_write_attribute: 0x0150,
+    region_config_write_attribute_type: 0x41,
+    region_config_cmds: {
+        /**
+         * Creates new region (or force replaces existing one)
+         * with new zones definition.
+         */
+        create: 1,
+        /**
+         * Modifies existing region.
+         * Note: unused, as it seems to break existing regions
+         * (region stops reporting new detection events).
+         * Use "create" instead, as it replaces existing region with new one.
+         */
+        modify: 2,
+        /**
+         * Deletes existing region.
+         */
+        delete: 3,
+    },
+    region_config_regionId_min: 1,
+    region_config_regionId_max: 10,
+    region_config_zoneY_min: 1,
+    region_config_zoneY_max: 7,
+    region_config_zoneX_min: 1,
+    region_config_zoneX_max: 4,
+    region_config_cmd_suffix_upsert: 0xff,
+    region_config_cmd_suffix_delete: 0x00,
+};
+const fp1Mappers = {
+    aqara_fp1: {
+        region_event_type_names: {
+            [fp1Constants.region_event_types.Enter]: 'enter',
+            [fp1Constants.region_event_types.Leave]: 'leave',
+            [fp1Constants.region_event_types.Occupied]: 'occupied',
+            [fp1Constants.region_event_types.Unoccupied]: 'unoccupied',
+        },
+    },
+};
+const fp1 = {
+    constants: fp1Constants,
+    mappers: fp1Mappers,
+    /**
+     * @param {undefined | Set<number>} xCells
+     * @return {number}
+     */
+    encodeXCellsDefinition: (xCells) => {
+        if (!xCells || !xCells.size) {
+            return 0;
+        }
+        return [...xCells.values()].reduce((accumulator, marker) => accumulator + fp1.encodeXCellIdx(marker), 0);
+    },
+    /**
+     * @param {number} cellXIdx
+     * @return {number}
+     */
+    encodeXCellIdx: (cellXIdx) => {
+        return 2 ** (cellXIdx - 1);
+    },
+    // Note: let TypeScript infer the return type to enable union discrimination
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * @param {unknown} input
+     */
+    parseAqaraFp1RegionDeleteInput: (input) => {
+        if (!input || typeof input !== 'object') {
+            return fp1.failure({reason: 'NOT_OBJECT'});
+        }
+
+        if (!('region_id' in input) || !fp1.isAqaraFp1RegionId(input.region_id)) {
+            return fp1.failure({reason: 'INVALID_REGION_ID'});
+        }
+
+        return {
+            /** @type true */
+            isSuccess: true,
+            payload: {
+                command: {
+                    region_id: input.region_id,
+                },
+            },
+        };
+    },
+    // Note: let TypeScript infer the return type to enable union discrimination
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * @param {unknown} input
+     */
+    parseAqaraFp1RegionUpsertInput: (input) => {
+        if (!input || typeof input !== 'object') {
+            return fp1.failure({reason: 'NOT_OBJECT'});
+        }
+
+        if (!('region_id' in input) || !fp1.isAqaraFp1RegionId(input.region_id)) {
+            return fp1.failure({reason: 'INVALID_REGION_ID'});
+        }
+
+        if (!('zones' in input) || !Array.isArray(input.zones) || !input.zones.length) {
+            return fp1.failure({reason: 'ZONES_LIST_EMPTY'});
+        }
+
+        if (!input.zones.every(fp1.isAqaraFp1RegionZoneDefinition)) {
+            return fp1.failure({reason: 'INVALID_ZONES'});
+        }
+
+        return {
+            /** @type true */
+            isSuccess: true,
+            payload: {
+                command: {
+                    region_id: input.region_id,
+                    zones: input.zones,
+                },
+            },
+        };
+    },
+    // Note: this is valid typescript JSDoc
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * @param {unknown} value
+     * @returns {value is number}
+     */
+    isAqaraFp1RegionId: (value) => {
+        return (
+            typeof value === 'number' &&
+            value >= fp1.constants.region_config_regionId_min &&
+            value <= fp1.constants.region_config_regionId_max
+        );
+    },
+    // Note: this is valid typescript JSDoc
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * @param {unknown} value
+     * @returns {value is AqaraFP1RegionZone}
+     */
+    isAqaraFp1RegionZoneDefinition: (value) => {
+        return (
+            value &&
+            typeof value === 'object' &&
+            'x' in value &&
+            'y' in value &&
+            typeof value.x === 'number' &&
+            typeof value.y === 'number' &&
+            value.x >= fp1.constants.region_config_zoneX_min &&
+            value.x <= fp1.constants.region_config_zoneX_max &&
+            value.y >= fp1.constants.region_config_zoneY_min &&
+            value.y <= fp1.constants.region_config_zoneY_max
+        );
+    },
+    /**
+     * @template {Record<string, unknown>} ErrorType
+     * @param {ErrorType} error
+     * @return { { isSuccess: false, error: ErrorType } }
+     */
+    failure: (error) => {
+        return {
+            isSuccess: false,
+            error,
+        };
+    },
+};
+
 module.exports = {
     buffer2DataObject,
     numericAttributes2Payload,
     numericAttributes2Options,
     VOCKQJK11LMDisplayUnit,
+    fp1,
+    manufacturerCode: 0x115f,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "15.0.25",
+  "version": "15.0.26",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [