zigbee-herdsman-converters 25.41.0 → 25.43.0

package/dist/lib/lumi.js

@@ -319,6 +319,9 @@ msg, meta, model, options, dataObject) => {
                 else if (["RTCGQ15LM"].includes(model.model)) {
                     payload.occupancy = value;
                 }
+                else if (["PS-S04D"].includes(model.model)) {
+                    payload.presence = value === 1;
+                }
                 else if (["WSDCGQ01LM", "WSDCGQ11LM", "WSDCGQ12LM", "VOCKQJK11LM"].includes(model.model)) {
                     // https://github.com/Koenkk/zigbee2mqtt/issues/798
                     // Sometimes the sensor publishes non-realistic vales, filter these
@@ -411,7 +414,7 @@ msg, meta, model, options, dataObject) => {
                     const battery = value / 2;
                     payload.battery = (0, utils_1.precisionRound)(battery, 2);
                 }
-                else if (["RTCZCGQ11LM", "PS-S04D"].includes(model.model)) {
+                else if (["RTCZCGQ11LM"].includes(model.model)) {
                     payload.presence = (0, utils_1.getFromLookup)(value, { 0: false, 1: true, 255: null });
                 }
                 else if (["ZNXDD01LM"].includes(model.model)) {
@@ -2337,6 +2340,32 @@ exports.lumiModernExtend = {
             ],
         };
     },
+    fp1eAIInterference: () => {
+        const attribute = { ID: 0x015e, type: 0x20 }; // Attribute: 350
+        return modernExtend.binary({
+            name: "ai_interference_source_selfidentification",
+            valueOn: ["ON", 1],
+            valueOff: ["OFF", 0],
+            cluster: "manuSpecificLumi",
+            attribute: attribute,
+            description: "AI interference source self-identification switch, when enabled can identify fans, air conditioners and other interference sources",
+            access: "ALL",
+            zigbeeCommandOptions: { manufacturerCode: exports.manufacturerCode },
+        });
+    },
+    fp1eAdaptiveSensitivity: () => {
+        const attribute = { ID: 0x015d, type: 0x20 }; // Attribute: 349
+        return modernExtend.binary({
+            name: "ai_sensitivity_adaptive",
+            valueOn: ["ON", 1],
+            valueOff: ["OFF", 0],
+            cluster: "manuSpecificLumi",
+            attribute: attribute,
+            description: "Adaptive sensitivity switch function.",
+            access: "ALL",
+            zigbeeCommandOptions: { manufacturerCode: exports.manufacturerCode },
+        });
+    },
     fp1ePresence: () => {
         const attribute = { ID: 0x0142, type: 0x20 };
         return modernExtend.binary({
@@ -4010,6 +4039,84 @@ exports.fromZigbee = {
             return result;
         },
     },
+    w100_0844_req: {
+        cluster: "manuSpecificLumi",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const attr = msg.data[65522];
+            if (!attr || !node_buffer_1.Buffer.isBuffer(attr))
+                return;
+            const endsWith = node_buffer_1.Buffer.from([0x08, 0x00, 0x08, 0x44]);
+            if (attr.slice(-4).equals(endsWith)) {
+                logger_1.logger.info(`Detected PMTSD request from device ${meta.device.ieeeAddr}`, NS);
+                return { action: "data_request" };
+            }
+        },
+    },
+    pmtsd_from_w100: {
+        cluster: "manuSpecificLumi",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const data = msg.data[65522];
+            if (!data || !node_buffer_1.Buffer.isBuffer(data))
+                return;
+            const endsWith = node_buffer_1.Buffer.from([0x08, 0x44]);
+            const idx = data.indexOf(endsWith);
+            if (idx === -1 || idx + 2 >= data.length)
+                return;
+            const payloadLen = data[idx + 2];
+            const payloadStart = idx + 3;
+            const payloadEnd = payloadStart + payloadLen;
+            if (payloadEnd > data.length)
+                return;
+            const payloadBytes = data.slice(payloadStart, payloadEnd);
+            let payloadAscii;
+            try {
+                payloadAscii = payloadBytes.toString("ascii");
+            }
+            catch {
+                return;
+            }
+            const result = {};
+            const partsForCombined = [];
+            const pairs = payloadAscii.split("_");
+            pairs.forEach((p) => {
+                if (p.length >= 2) {
+                    const key = p[0];
+                    const value = p.slice(1);
+                    let newKey;
+                    switch (key) {
+                        case "p":
+                            newKey = "PW";
+                            break;
+                        case "m":
+                            newKey = "MW";
+                            break;
+                        case "t":
+                            newKey = "TW";
+                            break;
+                        case "s":
+                            newKey = "SW";
+                            break;
+                        case "d":
+                            newKey = "DW";
+                            break;
+                        default:
+                            newKey = `${key.toUpperCase()}W`;
+                    }
+                    result[newKey] = value;
+                    partsForCombined.push(`${newKey}${value}`);
+                }
+            });
+            const ts = Date.now();
+            const combinedString = partsForCombined.length ? `${ts}_${partsForCombined.join("_")}` : `${ts}`;
+            logger_1.logger.info(`Decoded PMTSD: ${JSON.stringify(result)} from ${meta.device.ieeeAddr}`, NS);
+            return {
+                ...result,
+                data: combinedString,
+            };
+        },
+    },
 };
 exports.toZigbee = {
     // lumi generic
@@ -5554,5 +5661,88 @@ exports.toZigbee = {
             throw new Error(`Not supported: '${key}'`);
         },
     },
+    pmtsd_to_w100: {
+        key: ["PMTSD_to_W100"],
+        convertSet: async (entity, key, value, meta) => {
+            const { p, m, t, s, d } = value;
+            const pmtsdStr = `P${p}_M${m}_T${t}_S${s}_D${d}`;
+            const pmtsdBytes = Array.from(pmtsdStr).map((c) => c.charCodeAt(0));
+            const pmtsdLen = pmtsdBytes.length;
+            const fixedHeader = [
+                0xaa,
+                0x71,
+                0x1f,
+                0x44,
+                0x00,
+                0x00,
+                0x05,
+                0x41,
+                0x1c,
+                0x00,
+                0x00,
+                0x54,
+                0xef,
+                0x44,
+                0x80,
+                0x71,
+                0x1a,
+                0x08,
+                0x00,
+                0x08,
+                0x44,
+                pmtsdLen,
+            ];
+            const counter = Math.floor(Math.random() * 256);
+            fixedHeader[4] = counter;
+            const fullPayload = [...fixedHeader, ...pmtsdBytes];
+            const checksum = fullPayload.reduce((sum, b) => sum + b, 0) & 0xff;
+            fullPayload[5] = checksum;
+            await entity.write(64704, { 65522: { value: node_buffer_1.Buffer.from(fullPayload), type: 65 } }, { manufacturerCode: 4447, disableDefaultResponse: true });
+            logger_1.logger.info(`PMTSD frame sent: ${pmtsdStr} (Counter: ${counter}, Checksum: ${checksum})`, NS);
+            return {};
+        },
+    },
+    thermostat_mode: {
+        key: ["mode"],
+        convertSet: async (entity, key, value, meta) => {
+            const deviceMac = meta.device.ieeeAddr.replace(/^0x/, "").toLowerCase();
+            const hubMac = "54ef4480711a";
+            function cleanMac(mac, expectedLen) {
+                const cleaned = mac.replace(/[:-]/g, "");
+                if (cleaned.length !== expectedLen) {
+                    throw new Error(`MAC must be ${expectedLen} hex digits`);
+                }
+                return cleaned;
+            }
+            const dev = node_buffer_1.Buffer.from(cleanMac(deviceMac, 16), "hex");
+            const hub = node_buffer_1.Buffer.from(cleanMac(hubMac, 12), "hex");
+            let frame;
+            if (value === "ON") {
+                const prefix = node_buffer_1.Buffer.concat([
+                    node_buffer_1.Buffer.from("aa713244", "hex"),
+                    node_buffer_1.Buffer.from([Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)]),
+                ]);
+                const zigbeeHeader = node_buffer_1.Buffer.from("02412f6891", "hex");
+                const messageId = node_buffer_1.Buffer.from([Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)]);
+                const control = node_buffer_1.Buffer.from([0x18]);
+                const payloadMacs = node_buffer_1.Buffer.concat([dev, node_buffer_1.Buffer.from("0000", "hex"), hub]);
+                const payloadTail = node_buffer_1.Buffer.from("08000844150a0109e7a9bae8b083e58a9f000000000001012a40", "hex");
+                frame = node_buffer_1.Buffer.concat([prefix, zigbeeHeader, messageId, control, payloadMacs, payloadTail]);
+            }
+            else {
+                const prefix = node_buffer_1.Buffer.from([0xaa, 0x71, 0x1c, 0x44, 0x69, 0x1c, 0x04, 0x41, 0x19, 0x68, 0x91]);
+                const frameId = node_buffer_1.Buffer.from([Math.floor(Math.random() * 256)]);
+                const seq = node_buffer_1.Buffer.from([Math.floor(Math.random() * 256)]);
+                const control = node_buffer_1.Buffer.from([0x18]);
+                frame = node_buffer_1.Buffer.concat([prefix, frameId, seq, control, dev]);
+                if (frame.length < 34) {
+                    frame = node_buffer_1.Buffer.concat([frame, node_buffer_1.Buffer.alloc(34 - frame.length, 0x00)]);
+                }
+            }
+            await entity.write(64704, { 65522: { value: frame, type: 0x41 } }, { manufacturerCode: 4447, disableDefaultResponse: true });
+            logger_1.logger.info(`Thermostat_Mode=${value} payload=${frame.toString("hex")}`, NS);
+            return {};
+        },
+    },
 };
 //# sourceMappingURL=lumi.js.map