zigbee-herdsman 3.5.2 → 4.0.2

package/src/adapter/z-stack/unpi/parser.ts

@@ -0,0 +1,56 @@
+import * as stream from "node:stream";
+
+import {logger} from "../../../utils/logger";
+import {DataStart, MinMessageLength, PositionDataLength, SOF} from "./constants";
+import {Frame} from "./frame";
+
+const NS = "zh:zstack:unpi:parser";
+
+export class Parser extends stream.Transform {
+    private buffer: Buffer;
+
+    public constructor() {
+        super();
+        this.buffer = Buffer.from([]);
+    }
+
+    public override _transform(chunk: Buffer, _: string, cb: () => void): void {
+        logger.debug(`<-- [${[...chunk]}]`, NS);
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.parseNext();
+        cb();
+    }
+
+    private parseNext(): void {
+        logger.debug(`--- parseNext [${[...this.buffer]}]`, NS);
+
+        if (this.buffer.length !== 0 && this.buffer.readUInt8(0) !== SOF) {
+            // Buffer doesn't start with SOF, skip till SOF.
+            const index = this.buffer.indexOf(SOF);
+            if (index !== -1) {
+                this.buffer = this.buffer.slice(index, this.buffer.length);
+            }
+        }
+
+        if (this.buffer.length >= MinMessageLength && this.buffer.readUInt8(0) === SOF) {
+            const dataLength = this.buffer[PositionDataLength];
+            const fcsPosition = DataStart + dataLength;
+            const frameLength = fcsPosition + 1;
+
+            if (this.buffer.length >= frameLength) {
+                const frameBuffer = this.buffer.slice(0, frameLength);
+
+                try {
+                    const frame = Frame.fromBuffer(dataLength, fcsPosition, frameBuffer);
+                    logger.debug(`--> parsed ${frame}`, NS);
+                    this.emit("parsed", frame);
+                } catch (error) {
+                    logger.debug(`--> error ${error}`, NS);
+                }
+
+                this.buffer = this.buffer.slice(frameLength, this.buffer.length);
+                this.parseNext();
+            }
+        }
+    }
+}

package/src/adapter/z-stack/unpi/writer.ts

@@ -0,0 +1,21 @@
+import * as stream from "node:stream";
+
+import {logger} from "../../../utils/logger";
+import type {Frame} from "./frame";
+
+const NS = "zh:zstack:unpi:writer";
+
+export class Writer extends stream.Readable {
+    public writeFrame(frame: Frame): void {
+        const buffer = frame.toBuffer();
+        logger.debug(`--> frame [${[...buffer]}]`, NS);
+        this.push(buffer);
+    }
+
+    public writeBuffer(buffer: Buffer): void {
+        logger.debug(`--> buffer [${[...buffer]}]`, NS);
+        this.push(buffer);
+    }
+
+    public override _read(): void {}
+}

package/src/adapter/z-stack/utils/channel-list.ts

@@ -0,0 +1,40 @@
+/**
+ * Converts packed `uint32` channel list to array of channel numbers.
+ *
+ * @param packedList Packed channel list value.
+ */
+export const unpackChannelList = (packedList: number): number[] => {
+    return Array(26 - 11 + 1)
+        .fill(0)
+        .map((_, i) => 11 + i)
+        .filter((c) => ((1 << c) & packedList) > 0);
+};
+
+/**
+ * Converts array of channel numbers to packed `uint32` structure represented as number.
+ * Supported channel range is 11 - 29.
+ *
+ * @param channelList List of channels to be packed.
+ */
+export const packChannelList = (channelList: number[]): number => {
+    const invalidChannel = channelList.find((c) => c < 11 || c > 26);
+    /* v8 ignore start */
+    if (invalidChannel !== undefined) {
+        throw new Error(`Cannot pack channel list - unsupported channel ${invalidChannel}`);
+    }
+    /* v8 ignore stop */
+    return channelList.reduce((a, c) => a + (1 << c), 0);
+};
+
+/**
+ * Compares two channel lists. Either number arrays or packed `uint32` numbers may be provided.
+ *
+ * @param list1 First list to compare.
+ * @param list2 Second list to compare.
+ */
+export const compareChannelLists = (list1: number | number[], list2: number | number[]): boolean => {
+    /* v8 ignore next */
+    list1 = Array.isArray(list1) ? packChannelList(list1) : list1;
+    list2 = Array.isArray(list2) ? packChannelList(list2) : list2;
+    return list1 === list2;
+};

package/src/adapter/z-stack/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./channel-list";
+export * from "./network-options";

package/src/adapter/z-stack/utils/network-options.ts

@@ -0,0 +1,26 @@
+/* v8 ignore start */
+
+import type * as Models from "../../../models";
+import {compareChannelLists} from "./channel-list";
+
+/**
+ * Checks if two network options models match.
+ *
+ * @param opts1 First network options struct to check.
+ * @param opts2 Second network options struct to check.
+ */
+export const compareNetworkOptions = (
+    opts1: Models.NetworkOptions,
+    opts2: Models.NetworkOptions,
+    lenientExtendedPanIdMatching?: boolean,
+): boolean => {
+    return Boolean(
+        opts1.panId === opts2.panId &&
+            (opts1.extendedPanId.equals(opts2.extendedPanId) ||
+                (lenientExtendedPanIdMatching && (opts1.hasDefaultExtendedPanId || opts2.hasDefaultExtendedPanId)) ||
+                (lenientExtendedPanIdMatching && opts1.extendedPanId.equals(Buffer.from(opts2.extendedPanId).reverse()))) &&
+            opts1.networkKey.equals(opts2.networkKey) &&
+            compareChannelLists(opts1.channelList, opts2.channelList) &&
+            opts1.networkKeyDistribute === opts2.networkKeyDistribute,
+    );
+};

package/src/adapter/z-stack/znp/buffaloZnp.ts

@@ -0,0 +1,175 @@
+import {Buffalo} from "../../../buffalo";
+import ParameterType from "./parameterType";
+import type {BuffaloZnpOptions} from "./tstype";
+
+interface Network {
+    neightborPanId: number;
+    logicalChannel: number;
+    stackProfile: number;
+    zigbeeVersion: number;
+    beaconOrder: number;
+    superFrameOrder: number;
+    permitJoin: number;
+}
+
+class BuffaloZnp extends Buffalo {
+    private readListNetwork(length: number): Network[] {
+        const value: Network[] = [];
+        for (let i = 0; i < length; i++) {
+            const neightborPanId = this.readUInt16();
+            const logicalChannel = this.readUInt8();
+            const value1 = this.readUInt8();
+            const value2 = this.readUInt8();
+            const permitJoin = this.readUInt8();
+
+            value.push({
+                neightborPanId,
+                logicalChannel,
+                stackProfile: value1 & 0x0f,
+                zigbeeVersion: (value1 & 0xf0) >> 4,
+                beaconOrder: value2 & 0x0f,
+                superFrameOrder: (value2 & 0xf0) >> 4,
+                permitJoin,
+            });
+        }
+
+        return value;
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: API
+    public write(type: ParameterType, value: any, options: BuffaloZnpOptions): void {
+        switch (type) {
+            case ParameterType.UINT8: {
+                this.writeUInt8(value);
+                break;
+            }
+            case ParameterType.UINT16: {
+                this.writeUInt16(value);
+                break;
+            }
+            case ParameterType.UINT32: {
+                this.writeUInt32(value);
+                break;
+            }
+            case ParameterType.IEEEADDR: {
+                this.writeIeeeAddr(value);
+                break;
+            }
+            case ParameterType.BUFFER: {
+                this.writeBuffer(value, options.length ?? value.length);
+                break;
+            }
+            case ParameterType.BUFFER8: {
+                this.writeBuffer(value, 8);
+                break;
+            }
+            case ParameterType.BUFFER16: {
+                this.writeBuffer(value, 16);
+                break;
+            }
+            case ParameterType.BUFFER18: {
+                this.writeBuffer(value, 18);
+                break;
+            }
+            case ParameterType.BUFFER32: {
+                this.writeBuffer(value, 32);
+                break;
+            }
+            case ParameterType.BUFFER42: {
+                this.writeBuffer(value, 42);
+                break;
+            }
+            case ParameterType.BUFFER100: {
+                this.writeBuffer(value, 100);
+                break;
+            }
+            case ParameterType.LIST_UINT8: {
+                this.writeListUInt8(value);
+                break;
+            }
+            case ParameterType.LIST_UINT16: {
+                this.writeListUInt16(value);
+                break;
+            }
+            // NOTE: not writable
+            // case ParameterType.LIST_NETWORK:
+            case ParameterType.INT8: {
+                this.writeInt8(value);
+                break;
+            }
+            default: {
+                throw new Error(`Write for '${type}' not available`);
+            }
+        }
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: API
+    public read(type: ParameterType, options: BuffaloZnpOptions): any {
+        switch (type) {
+            case ParameterType.UINT8: {
+                return this.readUInt8();
+            }
+            case ParameterType.UINT16: {
+                return this.readUInt16();
+            }
+            case ParameterType.UINT32: {
+                return this.readUInt32();
+            }
+            case ParameterType.IEEEADDR: {
+                return this.readIeeeAddr();
+            }
+            case ParameterType.BUFFER: {
+                if (options.length == null) {
+                    throw new Error("Cannot read BUFFER without length option specified");
+                }
+
+                return this.readBuffer(options.length);
+            }
+            case ParameterType.BUFFER8: {
+                return this.readBuffer(8);
+            }
+            case ParameterType.BUFFER16: {
+                return this.readBuffer(16);
+            }
+            case ParameterType.BUFFER18: {
+                return this.readBuffer(18);
+            }
+            case ParameterType.BUFFER32: {
+                return this.readBuffer(32);
+            }
+            case ParameterType.BUFFER42: {
+                return this.readBuffer(42);
+            }
+            case ParameterType.BUFFER100: {
+                return this.readBuffer(100);
+            }
+            case ParameterType.LIST_UINT8: {
+                if (options.length == null) {
+                    throw new Error("Cannot read LIST_UINT8 without length option specified");
+                }
+
+                return this.readListUInt8(options.length);
+            }
+            case ParameterType.LIST_UINT16: {
+                if (options.length == null) {
+                    throw new Error("Cannot read LIST_UINT16 without length option specified");
+                }
+
+                return this.readListUInt16(options.length);
+            }
+            case ParameterType.LIST_NETWORK: {
+                if (options.length == null) {
+                    throw new Error("Cannot read LIST_NETWORK without length option specified");
+                }
+
+                return this.readListNetwork(options.length);
+            }
+            case ParameterType.INT8: {
+                return this.readInt8();
+            }
+            default: {
+                throw new Error(`Read for '${type}' not available`);
+            }
+        }
+    }
+}
+
+export default BuffaloZnp;