zigbee-herdsman 4.3.1 → 4.4.0

package/package.json

@@ -63,7 +63,7 @@
     "type": "git",
     "url": "git+https://github.com/Koenkk/zigbee-herdsman.git"
   },
-  "version": "4.3.1",
+  "version": "4.4.0",
   "scripts": {
     "build": "tsc",
     "build:watch": "tsc -w",

package/src/adapter/deconz/adapter/deconzAdapter.ts

@@ -252,11 +252,12 @@ export class DeconzAdapter extends Adapter {
     ): Promise<ZdoTypes.RequestToResponseMap[K] | undefined> {
         const transactionID = this.nextTransactionID();
         payload[0] = transactionID;
-        let txOptions = 0;
+        const txOptions = 0;
 
-        if (networkAddress < NwkBroadcastAddress.BroadcastLowPowerRouters) {
-            txOptions = 0x4; // enable APS ACKs for unicast addresses
-        }
+        // TODO(mpi): Disable APS ACKs for now until we find a better solution to not block queues.
+        //if (networkAddress < NwkBroadcastAddress.BroadcastLowPowerRouters) {
+        //    txOptions = 0x4; // enable APS ACKs for unicast addresses
+        //}
 
         const isNwkAddrRequest = clusterId === Zdo.ClusterId.NETWORK_ADDRESS_REQUEST;
         const req: ApsDataRequest = {
@@ -361,7 +362,9 @@ export class DeconzAdapter extends Adapter {
         const payload = zclFrame.toBuffer();
 
         // TODO(mpi): Enable APS ACKs for tricky devices, maintain a list of those, or keep at least a few slots free for non APS ACK requests.
-        const txOptions = 0x4; // 0x00 normal, 0x04 APS ACK
+        //const txOptions = 0x4; // 0x00 normal, 0x04 APS ACK
+        // TODO(mpi): Disable APS ACKs for now until we find a better solution to not block queues.
+        const txOptions = 0;
 
         const request: ApsDataRequest = {
             requestId: transactionID,

package/src/adapter/deconz/driver/constants.ts

@@ -196,7 +196,6 @@ interface ReceivedDataResponse {
 }
 
 interface GpDataInd {
-    rspId: number;
     seqNr: number;
     id: number;
     options: number;

package/src/adapter/deconz/driver/frameParser.ts

@@ -438,43 +438,141 @@ function parseDeviceStateChangedNotification(view: DataView): number | null {
     }
 }
 
+// The ApplicationID sub-field contains the information about the application used by the GPD.
+// ApplicationID = 0b000 indicates the GPD_ID field has the length of 4B and contains the GPD SrcID.
+// ApplicationID = 0b010 indicates the GPD_ID field has the length of 8B and contains the GPD IEEE address.
+enum GpApplicationId {
+    SrcId4B = 0,
+    Lped = 1,
+    Ieee8B = 2,
+}
+
+enum GpSecurityLevel {
+    NoSecurity = 0,
+    // TODO(mpi): "Reserved" is noted in the available spec but the code defined it as follows:
+    Reserved = 1, // 0b01 1LSB of frame counter and short (2B) MIC only
+    FrameCounter4BMic4B = 2,
+    EncryptionFrameCounter4BMic4B = 3,
+}
+
+enum ZgpConstants {
+    GpNwkProtocolVersion = 3,
+    GpNwkDataFrame = 0,
+    GpNwkMaintenanceFrame = 1,
+    GpMinMsduSize = 1,
+    GpAutoCommissioningFlag = 1 << 6,
+    GpNwkFrameControlExtensionFlag = 1 << 7,
+}
+
 function parseGreenPowerDataIndication(view: DataView): GpDataInd | null {
     try {
-        let id: number;
-        let rspId: number;
-        let options: number;
-        let srcId: number;
-        let frameCounter: number;
-        let commandId: number;
-        let commandFrameSize: number;
-        let commandFrame: Buffer;
-        const seqNr = view.getUint8(1);
-
-        if (view.byteLength < 30) {
-            logger.debug("GP data notification", NS);
-            id = 0x00; // 0 = notification, 4 = commissioning
-            rspId = 0x01; // 1 = pairing, 2 = commissioning
-            options = 0;
-            view.getUint16(7, littleEndian); // frame ctrl field(7) ext.fcf(8)
-            srcId = view.getUint32(9, littleEndian);
-            frameCounter = view.getUint32(13, littleEndian);
-            commandId = view.getUint8(17);
-            commandFrameSize = view.byteLength - 18 - 6; // cut 18 from begin and 4 (sec mic) and 2 from end (cfc)
-            commandFrame = Buffer.from(view.buffer.slice(18, commandFrameSize + 18));
-        } else {
-            logger.debug("GP commissioning notification", NS);
-            id = 0x04; // 0 = notification, 4 = commissioning
-            rspId = 0x01; // 1 = pairing, 2 = commissioning
-            options = view.getUint16(14, littleEndian); // opt(14) ext.opt(15)
-            srcId = view.getUint32(8, littleEndian);
-            frameCounter = view.getUint32(36, littleEndian);
-            commandId = view.getUint8(12);
-            commandFrameSize = view.byteLength - 13 - 2; // cut 13 from begin and 2 from end (cfc)
-            commandFrame = Buffer.from(view.buffer.slice(13, commandFrameSize + 13));
+        let srcId = 0;
+        let frameCounter = 0;
+        let commandId = 0;
+        let commandFrameSize = 0;
+        let commandFrame: Buffer | undefined;
+
+        const buf = new Buffalo(Buffer.from(view.buffer));
+
+        const _fwCommandId = buf.readUInt8();
+        const seqNr = buf.readUInt8();
+        const fwStatus = buf.readUInt8();
+
+        if (fwStatus !== CommandStatus.Success) {
+            return null;
+        }
+
+        const _frameLength = buf.readUInt16();
+        const _payloadLength = buf.readUInt16();
+
+        // payload
+
+        // implementation ported from deCONZ GP code
+        const nwkFrameControl = buf.readUInt8();
+
+        // check frame type
+        const frameType = nwkFrameControl & 0x03;
+
+        if (frameType !== ZgpConstants.GpNwkDataFrame && frameType !== ZgpConstants.GpNwkMaintenanceFrame) {
+            return null;
+        }
+
+        // check green power protocol version
+        if (((nwkFrameControl >> 2) & 0x03) !== ZgpConstants.GpNwkProtocolVersion) {
+            return null;
+        }
+
+        // extended frame control
+        let nwkExtFrameControl = 0;
+        const hasExtensionFlag = nwkFrameControl & ZgpConstants.GpNwkFrameControlExtensionFlag;
+        if (hasExtensionFlag) {
+            nwkExtFrameControl = buf.readUInt8();
+        }
+
+        const options = nwkExtFrameControl | (nwkFrameControl << 8);
+
+        const applicationId = nwkExtFrameControl & 7;
+        const securityLevel = (nwkExtFrameControl >> 3) & 3;
+
+        if (applicationId !== GpApplicationId.SrcId4B && applicationId !== GpApplicationId.Ieee8B) {
+            return null; // NOTE: GpApplicationId.Lped (1) should be dropped as per spec
+        }
+
+        // The GPDSrcID field is present if the Frame Type sub-field is set to 0b00 and the ApplicationID sub-
+        // field of the Extended NWK Frame Control field is set to 0b000 (or not present).
+        if (
+            applicationId === GpApplicationId.SrcId4B &&
+            frameType === ZgpConstants.GpNwkDataFrame /*|| (frameType === ZgpConstants.GpNwkMaintenanceFrame && hasExtensionFlag) */
+        ) {
+            srcId = buf.readUInt32();
+        }
+        // TODO(mpi): for applicationId == GpApplicationId.Ieee8B:
+        // currently Ieee addresses aren't supported, do they actually appear?!
+        // these need be extracted from MAC header which we don't have here (this is only the NWK payload).
+
+        // frame counter filed
+        frameCounter = 0;
+        let micSize = 0;
+
+        if (hasExtensionFlag && frameType === ZgpConstants.GpNwkDataFrame) {
+            if (applicationId === GpApplicationId.Ieee8B) {
+                const _endpoint = buf.readUInt8();
+            }
+            // If the SecurityLevel is set to 0b00, the SecurityKey sub-field is ignored on reception, and the
+            // fields Security frame counter and MIC are not present.
+            if (securityLevel === GpSecurityLevel.Reserved) {
+                micSize = 2; // TODO(mpi) does this actually exists? Check recent specs!
+            } else if (securityLevel === GpSecurityLevel.FrameCounter4BMic4B || securityLevel === GpSecurityLevel.EncryptionFrameCounter4BMic4B) {
+                frameCounter = buf.readUInt32();
+                micSize = 4;
+            }
+        }
+
+        if (!buf.isMore()) {
+            return null;
+        }
+
+        if (applicationId === GpApplicationId.SrcId4B || applicationId === GpApplicationId.Ieee8B) {
+            commandId = buf.readUInt8();
+            commandFrameSize = buf.getBuffer().length - buf.getPosition() - micSize;
+            //logger.debug(`GPD payload length: ${commandFrameSize}, mic size: ${micSize}`, NS);
+            if (commandFrameSize < 0) {
+                logger.error(`GPD payload length < 0: ${commandFrameSize}`, NS);
+                return null;
+            }
+            commandFrame = Buffer.from(buf.readBuffer(commandFrameSize)); // copy
+        }
+
+        // NOTE(mpi): The old adapter treated (view.byteLength < 30) as notification, larger as commissioning?!
+        // The controller thus rejected commissioning frames.
+        const id = 0; // 0 = notification, 4 = commissioning
+
+        if (commandFrame === undefined) {
+            logger.debug("GPD discard frame since commandFrame is null?!", NS);
+            return null;
         }
 
         const ind: GpDataInd = {
-            rspId,
             seqNr,
             id,
             options,
@@ -485,6 +583,7 @@ function parseGreenPowerDataIndication(view: DataView): GpDataInd | null {
             commandFrame,
         };
 
+        // TODO(mpi): This only tracks one frame, might be a bit optimistic
         if (!(lastReceivedGpInd.srcId === srcId && lastReceivedGpInd.commandId === commandId && lastReceivedGpInd.frameCounter === frameCounter)) {
             lastReceivedGpInd.srcId = srcId;
             lastReceivedGpInd.commandId = commandId;
@@ -503,6 +602,7 @@ function parseGreenPowerDataIndication(view: DataView): GpDataInd | null {
         return null;
     }
 }
+
 function parseMacPollCommand(_view: DataView): number {
     //logger.debug("Received command MAC_POLL", NS);
     return FirmwareCommand.MacPollIndication;

package/src/controller/controller.ts

@@ -18,6 +18,7 @@ import Database from "./database";
 import type * as Events from "./events";
 import GreenPower from "./greenPower";
 import {ZclFrameConverter} from "./helpers";
+import {checkInstallCode, parseInstallCode} from "./helpers/installCodes";
 import {Device, Entity} from "./model";
 import {InterviewState} from "./model/device";
 import Group from "./model/group";
@@ -246,34 +247,12 @@ export class Controller extends events.EventEmitter<ControllerEventMap> {
     }
 
     public async addInstallCode(installCode: string): Promise<void> {
-        const aqaraMatch = installCode.match(/^G\$M:.+\$A:(.+)\$I:(.+)$/);
-        const pipeMatch = installCode.match(/^(.+)\|(.+)$/);
-        let ieeeAddr: string;
-        let keyStr: string;
-
-        if (aqaraMatch) {
-            ieeeAddr = aqaraMatch[1];
-            keyStr = aqaraMatch[2];
-        } else if (pipeMatch) {
-            ieeeAddr = pipeMatch[1];
-            keyStr = pipeMatch[2];
-        } else {
-            assert(
-                installCode.length === 95 || installCode.length === 91,
-                `Unsupported install code, got ${installCode.length} chars, expected 95 or 91`,
-            );
-            const keyStart = installCode.length - (installCode.length === 95 ? 36 : 32);
-            ieeeAddr = installCode.substring(keyStart - 19, keyStart - 3);
-            keyStr = installCode.substring(keyStart, installCode.length);
-        }
-
-        ieeeAddr = `0x${ieeeAddr}`;
-        // match valid else asserted above
-        // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
+        // will throw if code cannot be parsed
+        const [ieeeAddr, keyStr] = parseInstallCode(installCode);
+        // biome-ignore lint/style/noNonNullAssertion: valid from above parsing
         const key = Buffer.from(keyStr.match(/.{1,2}/g)!.map((d) => Number.parseInt(d, 16)));
-
         // will throw if code cannot be fixed and is invalid
-        const [adjustedKey, adjusted] = ZSpec.Utils.checkInstallCode(key, true);
+        const [adjustedKey, adjusted] = checkInstallCode(key, true);
 
         if (adjusted) {
             logger.info(`Install code was adjusted for reason '${adjusted}'.`, NS);

package/src/controller/helpers/installCodes.ts

@@ -0,0 +1,107 @@
+import {INSTALL_CODE_CRC_SIZE, INSTALL_CODE_SIZES} from "../../zspec/consts";
+import {crc16X25} from "../../zspec/utils";
+
+/**
+ * Parse the given code using known formats:
+ * - 95 or 91-length
+ * - Widely adopted (Ubisys, Danfoss, Inovelli, Ledvance): ...Z:<ieee>$I:<key>...
+ * - Pipe-separated (Muller-Licht, Innr): <ieee>|<key>
+ * - Aqara: G$M:...$A:<ieee>$I:<key>
+ * - Hue: HUE:Z:<key> M:<ieee>...
+ * @param installCode
+ * @returns
+ *   - the IEEE address
+ *   - the raw key
+ */
+export function parseInstallCode(installCode: string): [ieeeAddr: string, key: string] {
+    const widelyAdoptedMatch = installCode.match(/Z:([a-zA-Z0-9]{16})\$I:([a-zA-Z0-9]+)/);
+
+    if (widelyAdoptedMatch) {
+        return [`0x${widelyAdoptedMatch[1].toLowerCase()}`, widelyAdoptedMatch[2]];
+    }
+
+    const pipeMatch = installCode.match(/^([a-zA-Z0-9]{16})\|([a-zA-Z0-9]+)$/);
+
+    if (pipeMatch) {
+        return [`0x${pipeMatch[1].toLowerCase()}`, pipeMatch[2]];
+    }
+
+    const aqaraMatch = installCode.match(/^G\$M:.+\$A:([a-zA-Z0-9]{16})\$I:([a-zA-Z0-9]+)$/);
+
+    if (aqaraMatch) {
+        return [`0x${aqaraMatch[1].toLowerCase()}`, aqaraMatch[2]];
+    }
+
+    const hueMatch = installCode.match(/^HUE:Z:([a-zA-Z0-9]+) M:([a-zA-Z0-9]{16})/);
+
+    if (hueMatch) {
+        return [`0x${hueMatch[2].toLowerCase()}`, hueMatch[1]];
+    }
+
+    if (installCode.length === 95 || installCode.length === 91) {
+        const keyStart = installCode.length - (installCode.length === 95 ? 36 : 32);
+
+        return [`0x${installCode.substring(keyStart - 19, keyStart - 3).toLowerCase()}`, installCode.substring(keyStart, installCode.length)];
+    }
+
+    throw new Error(`Unsupported install code, got ${installCode.length} chars, expected 95 or 91 chars, or known format`);
+}
+
+/**
+ * Check if install code (little-endian) is valid, and if not, and requested, fix it.
+ *
+ * WARNING: Due to conflicting sizes between 8-length code with invalid CRC, and 10-length code missing CRC, given 8-length codes are always assumed to be 8-length code with invalid CRC (most probable scenario).
+ *
+ * @param code The code to check. Reference is not modified by this procedure but is returned when code was valid, as `outCode`.
+ * @param adjust If false, throws if the install code is invalid, otherwise try to fix it (CRC)
+ * @returns
+ *   - The adjusted code, or `code` if not adjusted.
+ *   - If adjust is false, undefined, otherwise, the reason why the code needed adjusting or undefined if not.
+ *   - Throws when adjust=false and invalid, or cannot fix.
+ */
+export function checkInstallCode(code: Buffer, adjust = true): [outCode: Buffer, adjusted: "invalid CRC" | "missing CRC" | undefined] {
+    const crcLowByteIndex = code.length - INSTALL_CODE_CRC_SIZE;
+    const crcHighByteIndex = code.length - INSTALL_CODE_CRC_SIZE + 1;
+
+    for (const codeSize of INSTALL_CODE_SIZES) {
+        if (code.length === codeSize) {
+            // install code has CRC, check if valid, if not, replace it
+            const crc = crc16X25(code.subarray(0, -2));
+            const crcHighByte = (crc >> 8) & 0xff;
+            const crcLowByte = crc & 0xff;
+
+            if (code[crcLowByteIndex] !== crcLowByte || code[crcHighByteIndex] !== crcHighByte) {
+                // see WARNING above, 8 is smallest valid length, so always ends up here
+                if (adjust) {
+                    const outCode = Buffer.from(code);
+                    outCode[crcLowByteIndex] = crcLowByte;
+                    outCode[crcHighByteIndex] = crcHighByte;
+
+                    return [outCode, "invalid CRC"];
+                }
+
+                throw new Error(`Install code ${code.toString("hex")} failed CRC validation`);
+            }
+
+            return [code, undefined];
+        }
+
+        if (code.length === codeSize - INSTALL_CODE_CRC_SIZE) {
+            if (adjust) {
+                // install code is missing CRC
+                const crc = crc16X25(code);
+                const outCode = Buffer.alloc(code.length + INSTALL_CODE_CRC_SIZE);
+
+                code.copy(outCode, 0);
+                outCode.writeUInt16LE(crc, code.length);
+
+                return [outCode, "missing CRC"];
+            }
+
+            throw new Error(`Install code ${code.toString("hex")} failed CRC validation`);
+        }
+    }
+
+    // never returned from within the above loop
+    throw new Error(`Install code ${code.toString("hex")} has invalid size`);
+}

package/src/zspec/utils.ts

@@ -1,5 +1,5 @@
 import {createCipheriv} from "node:crypto";
-import {AES_MMO_128_BLOCK_SIZE, ALL_802_15_4_CHANNELS, INSTALL_CODE_CRC_SIZE, INSTALL_CODE_SIZES} from "./consts";
+import {AES_MMO_128_BLOCK_SIZE, ALL_802_15_4_CHANNELS} from "./consts";
 import {BroadcastAddress} from "./enums";
 import type {Eui64} from "./tstypes";
 
@@ -245,62 +245,3 @@ export function aes128MmoHash(data: Buffer): Buffer {
 
     return result;
 }
-
-/**
- * Check if install code (little-endian) is valid, and if not, and requested, fix it.
- *
- * WARNING: Due to conflicting sizes between 8-length code with invalid CRC, and 10-length code missing CRC, given 8-length codes are always assumed to be 8-length code with invalid CRC (most probable scenario).
- *
- * @param code The code to check. Reference is not modified by this procedure but is returned when code was valid, as `outCode`.
- * @param adjust If false, throws if the install code is invalid, otherwise try to fix it (CRC)
- * @returns
- *   - The adjusted code, or `code` if not adjusted.
- *   - If adjust is false, undefined, otherwise, the reason why the code needed adjusting or undefined if not.
- *   - Throws when adjust=false and invalid, or cannot fix.
- */
-export function checkInstallCode(code: Buffer, adjust = true): [outCode: Buffer, adjusted: "invalid CRC" | "missing CRC" | undefined] {
-    const crcLowByteIndex = code.length - INSTALL_CODE_CRC_SIZE;
-    const crcHighByteIndex = code.length - INSTALL_CODE_CRC_SIZE + 1;
-
-    for (const codeSize of INSTALL_CODE_SIZES) {
-        if (code.length === codeSize) {
-            // install code has CRC, check if valid, if not, replace it
-            const crc = crc16X25(code.subarray(0, -2));
-            const crcHighByte = (crc >> 8) & 0xff;
-            const crcLowByte = crc & 0xff;
-
-            if (code[crcLowByteIndex] !== crcLowByte || code[crcHighByteIndex] !== crcHighByte) {
-                // see WARNING above, 8 is smallest valid length, so always ends up here
-                if (adjust) {
-                    const outCode = Buffer.from(code);
-                    outCode[crcLowByteIndex] = crcLowByte;
-                    outCode[crcHighByteIndex] = crcHighByte;
-
-                    return [outCode, "invalid CRC"];
-                }
-
-                throw new Error(`Install code ${code.toString("hex")} failed CRC validation`);
-            }
-
-            return [code, undefined];
-        }
-
-        if (code.length === codeSize - INSTALL_CODE_CRC_SIZE) {
-            if (adjust) {
-                // install code is missing CRC
-                const crc = crc16X25(code);
-                const outCode = Buffer.alloc(code.length + INSTALL_CODE_CRC_SIZE);
-
-                code.copy(outCode, 0);
-                outCode.writeUInt16LE(crc, code.length);
-
-                return [outCode, "missing CRC"];
-            }
-
-            throw new Error(`Install code ${code.toString("hex")} failed CRC validation`);
-        }
-    }
-
-    // never returned from within the above loop
-    throw new Error(`Install code ${code.toString("hex")} has invalid size`);
-}

package/src/zspec/zcl/definition/cluster.ts

@@ -1992,6 +1992,9 @@ export const Clusters: Readonly<Record<ClusterName, Readonly<ClusterDefinition>>
             danfossRoomFloorSensorMode: {ID: 0x4120, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossFloorMinSetpoint: {ID: 0x4121, type: DataType.INT16, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossFloorMaxSetpoint: {ID: 0x4122, type: DataType.INT16, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossScheduleTypeUsed: {ID: 0x4130, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIcon2PreHeat: {ID: 0x4131, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIcon2PreHeatStatus: {ID: 0x414f, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             elkoLoad: {ID: 0x0401, type: DataType.UINT16},
             elkoDisplayText: {ID: 0x0402, type: DataType.CHAR_STR},
             elkoSensor: {ID: 0x0403, type: DataType.ENUM8},
@@ -4280,8 +4283,11 @@ export const Clusters: Readonly<Record<ClusterName, Readonly<ClusterDefinition>>
             lastMessageLqi: {ID: 284, type: DataType.UINT8},
             lastMessageRssi: {ID: 285, type: DataType.INT8},
             danfossSystemStatusCode: {ID: 0x4000, type: DataType.BITMAP16, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossHeatSupplyRequest: {ID: 0x4031, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossSystemStatusWater: {ID: 0x4200, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossMultimasterRole: {ID: 0x4201, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIconApplication: {ID: 0x4210, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIconForcedHeatingCooling: {ID: 0x4220, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             schneiderMeterStatus: {ID: 0xff01, type: DataType.UINT32, manufacturerCode: ManufacturerCode.SCHNEIDER_ELECTRIC},
             schneiderDiagnosticRegister1: {ID: 0xff02, type: DataType.UINT32, manufacturerCode: ManufacturerCode.SCHNEIDER_ELECTRIC},
             schneiderCommunicationQuality: {ID: 0x4000, type: DataType.UINT8, manufacturerCode: ManufacturerCode.SCHNEIDER_ELECTRIC},

package/test/controller.test.ts

@@ -1839,7 +1839,7 @@ describe("Controller", () => {
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x9035EAFFFE424783",
+            "0x9035eafffe424783",
             Buffer.from([0xae, 0x3b, 0x28, 0x72, 0x81, 0xcf, 0x16, 0xf5, 0x50, 0x73, 0x3a, 0x0c, 0xec, 0x38, 0xaa, 0x31, 0xe8, 0x02]),
             false,
         );
@@ -1851,37 +1851,102 @@ describe("Controller", () => {
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(2);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x000D6F00179F2BC9",
+            "0x000d6f00179f2bc9",
             Buffer.from([0xd0, 0xf4, 0x71, 0xc9, 0xbb, 0xa2, 0xc0, 0x20, 0x86, 0x08, 0xe9, 0x1e, 0xed, 0x17, 0xe2, 0xb1, 0x9a, 0xec]),
             false,
         );
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x000D6F00179F2BC9",
+            "0x000d6f00179f2bc9",
             Buffer.from([0xd0, 0xf4, 0x71, 0xc9, 0xbb, 0xa2, 0xc0, 0x20, 0x86, 0x08, 0xe9, 0x1e, 0xed, 0x17, 0xe2, 0xb1]),
             true,
         );
         expect(mockLogger.info).toHaveBeenCalledWith(`Install code was adjusted for reason 'missing CRC'.`, "zh:controller");
     });
 
+    it("Add install code widely adopted format", async () => {
+        await controller.start();
+        // inovelli
+        const code = "Z:6C5CB1FFFE44FDFD$I:5492072F8DE72829FEE139CF8ACA4F43EF21";
+        await controller.addInstallCode(code);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            1,
+            "0x6c5cb1fffe44fdfd",
+            Buffer.from([
+                0x54, 0x92, 0x07, 0x2f, 0x8d, 0xe7, 0x28, 0x29, 0xfe, 0xe1, 0x39, 0xcf, 0x8a, 0xca, 0x4f, 0x43, /*0xef, 0x21 bad CRC?*/ 0x85, 0x44,
+            ]),
+            false,
+        );
+        // danfoss
+        const code2 = "G$M:IC2%Z:540F57FFFE599FAA$I:D79CB21C6D197CE7A3339A683A90DFF2442A%M:1246";
+        await controller.addInstallCode(code2);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            2,
+            "0x540f57fffe599faa",
+            Buffer.from([0xd7, 0x9c, 0xb2, 0x1c, 0x6d, 0x19, 0x7c, 0xe7, 0xa3, 0x33, 0x9a, 0x68, 0x3a, 0x90, 0xdf, 0xf2, 0x44, 0x2a]),
+            false,
+        );
+        // ??
+        const code3 = "Z:4CC206FFFE306C43$I:150A1A57D11A1A01362622DBA97ACF0F9185$D:202%B:4CC206306C43$P:983639%M:1220$F:002D";
+        await controller.addInstallCode(code3);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            3,
+            "0x4cc206fffe306c43",
+            Buffer.from([
+                0x15, 0x0a, 0x1a, 0x57, 0xd1, 0x1a, 0x1a, 0x01, 0x36, 0x26, 0x22, 0xdb, 0xa9, 0x7a, 0xcf, 0x0f, /*0x91, 0x85 bad CRC?*/ 0x0c, 0xca,
+            ]),
+            false,
+        );
+        // ubisys
+        const code4 = "Z:0102030405060708$I:0102030405060708090A0B0C0D0E0F1090FD%G$M:S1-R%M:10F2";
+        await controller.addInstallCode(code4);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            4,
+            "0x0102030405060708",
+            Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x90, 0xfd]),
+            false,
+        );
+        // ledvance
+        const code5 = "Z:F0D1B8000017389A$I:6AB6973274EE6F720200530162754044C930%M:1189$D:008B452720";
+        await controller.addInstallCode(code5);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            5,
+            "0xf0d1b8000017389a",
+            Buffer.from([0x6a, 0xb6, 0x97, 0x32, 0x74, 0xee, 0x6f, 0x72, 0x02, 0x00, 0x53, 0x01, 0x62, 0x75, 0x40, 0x44, 0xc9, 0x30]),
+            false,
+        );
+    });
+
     it("Add install code Aqara", async () => {
         await controller.start();
         const code = "G$M:69775$S:680S00003915$D:0000000017B2335C%Z$A:54EF44100006E7DF$I:3313A005E177A647FC7925620AB207C4BEF5";
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x54EF44100006E7DF",
+            "0x54ef44100006e7df",
             Buffer.from([0x33, 0x13, 0xa0, 0x05, 0xe1, 0x77, 0xa6, 0x47, 0xfc, 0x79, 0x25, 0x62, 0x0a, 0xb2, 0x07, 0xc4, 0xbe, 0xf5]),
             false,
         );
     });
 
+    it("Add install code Hue", async () => {
+        await controller.start();
+        const code = "HUE:Z:0123456789ABCDEF0123456789ABCDEF0123 M:0123456789ABCDEF D:L3B A:1184";
+        await controller.addInstallCode(code);
+        expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
+        expect(mockAddInstallCode).toHaveBeenCalledWith(
+            "0x0123456789abcdef",
+            Buffer.from([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xe7, 0xb8]),
+            false,
+        );
+    });
+
     it("Add install code pipe", async () => {
         await controller.start();
         const code = "54EF44100006E7DF|3313A005E177A647FC7925620AB207C4BEF5";
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x54EF44100006E7DF",
+            "0x54ef44100006e7df",
             Buffer.from([0x33, 0x13, 0xa0, 0x05, 0xe1, 0x77, 0xa6, 0x47, 0xfc, 0x79, 0x25, 0x62, 0x0a, 0xb2, 0x07, 0xc4, 0xbe, 0xf5]),
             false,
         );
@@ -1897,6 +1962,18 @@ describe("Controller", () => {
         expect(mockAddInstallCode).toHaveBeenCalledTimes(0);
     });
 
+    it("Add install code unknown format", async () => {
+        await controller.start();
+
+        const code = "54EF44100006E7DF`3313A005E177A647FC7925620AB207";
+
+        await expect(controller.addInstallCode(code)).rejects.toThrow(
+            "Unsupported install code, got 47 chars, expected 95 or 91 chars, or known format",
+        );
+
+        expect(mockAddInstallCode).toHaveBeenCalledTimes(0);
+    });
+
     it("Controller permit joining all, disabled automatically", async () => {
         await controller.start();