@willieee802/zigbee-herdsman 0.48.3 → 0.49.0

package/src/adapter/ezsp/driver/frame.ts

@@ -0,0 +1,101 @@
+/* v8 ignore start */
+
+import {RANDOMIZE_SEQ, RANDOMIZE_START} from "./consts";
+import crc16ccitt from "./utils/crc16ccitt";
+
+export enum FrameType {
+    UNKNOWN = 0,
+    ERROR = 1,
+    DATA = 2,
+    ACK = 3,
+    NAK = 4,
+    RST = 5,
+    RSTACK = 6,
+}
+
+/**
+ * Basic class to handle uart-level frames
+ * https://www.silabs.com/documents/public/user-guides/ug101-uart-gateway-protocol-reference.pdf
+ */
+export class Frame {
+    /**
+     * Type of the Frame as determined by its control byte.
+     */
+    public readonly type: FrameType;
+    public readonly buffer: Buffer;
+
+    public constructor(buffer: Buffer) {
+        this.buffer = buffer;
+
+        const ctrlByte = this.buffer[0];
+
+        if ((ctrlByte & 0x80) === 0) {
+            this.type = FrameType.DATA;
+        } else if ((ctrlByte & 0xe0) === 0x80) {
+            this.type = FrameType.ACK;
+        } else if ((ctrlByte & 0xe0) === 0xa0) {
+            this.type = FrameType.NAK;
+        } else if (ctrlByte === 0xc0) {
+            this.type = FrameType.RST;
+        } else if (ctrlByte === 0xc1) {
+            this.type = FrameType.RSTACK;
+        } else if (ctrlByte === 0xc2) {
+            this.type = FrameType.ERROR;
+        } else {
+            this.type = FrameType.UNKNOWN;
+        }
+    }
+
+    get control(): number {
+        return this.buffer[0];
+    }
+
+    public static fromBuffer(buffer: Buffer): Frame {
+        return new Frame(buffer);
+    }
+
+    /**
+     * XOR s with a pseudo-random sequence for transmission.
+     * Used only in data frames.
+     */
+    public static makeRandomizedBuffer(buffer: Buffer): Buffer {
+        let rand = RANDOMIZE_START;
+        const out = Buffer.alloc(buffer.length);
+        let outIdx = 0;
+
+        for (const c of buffer) {
+            out.writeUInt8(c ^ rand, outIdx++);
+
+            if (rand % 2) {
+                rand = (rand >> 1) ^ RANDOMIZE_SEQ;
+            } else {
+                rand = rand >> 1;
+            }
+        }
+
+        return out;
+    }
+
+    /**
+     * Throws on CRC error.
+     */
+    public checkCRC(): void {
+        const crc = crc16ccitt(this.buffer.subarray(0, -3), 65535);
+        const crcArr = Buffer.from([crc >> 8, crc % 256]);
+        const subArr = this.buffer.subarray(-3, -1);
+
+        if (!subArr.equals(crcArr)) {
+            throw new Error(`<-- CRC error: ${this.toString()}|${subArr.toString("hex")}|${crcArr.toString("hex")}`);
+        }
+    }
+
+    /**
+     *
+     * @returns Buffer to hex string
+     */
+    public toString(): string {
+        return this.buffer.toString("hex");
+    }
+}
+
+export default Frame;

package/src/adapter/ezsp/driver/index.ts

@@ -0,0 +1,4 @@
+import {Driver, EmberIncomingMessage} from "./driver";
+import {Ezsp} from "./ezsp";
+
+export {Ezsp, Driver, EmberIncomingMessage};

package/src/adapter/ezsp/driver/multicast.ts

@@ -0,0 +1,78 @@
+/* v8 ignore start */
+
+import {logger} from "../../../utils/logger";
+import type {Driver} from "./driver";
+import {EzspConfigId} from "./types";
+import {EmberStatus} from "./types/named";
+import {EmberMulticastTableEntry} from "./types/struct";
+
+const NS = "zh:ezsp:cast";
+
+export class Multicast {
+    tableSize = 16;
+    private driver: Driver;
+    private _multicast: Record<number, [EmberMulticastTableEntry, number]>;
+    private _available: number[];
+
+    constructor(driver: Driver) {
+        this.driver = driver;
+        this._multicast = {};
+        this._available = [];
+    }
+
+    private async _initialize(): Promise<void> {
+        const size = await this.driver.ezsp.getConfigurationValue(EzspConfigId.CONFIG_MULTICAST_TABLE_SIZE);
+        for (let i = 0; i < size; i++) {
+            const entry = await this.driver.ezsp.getMulticastTableEntry(i);
+            logger.debug(`MulticastTableEntry[${i}] = ${entry}`, NS);
+            if (entry.endpoint !== 0) {
+                this._multicast[entry.multicastId] = [entry, i];
+            } else {
+                this._available.push(i);
+            }
+        }
+    }
+
+    async startup(enpoints: {id: number; member_of: number[]}[]): Promise<void> {
+        await this._initialize();
+        for (const ep of enpoints) {
+            if (!ep.id) continue;
+            for (const group_id of ep.member_of) {
+                await this.subscribe(group_id, ep.id);
+            }
+        }
+    }
+
+    public async subscribe(groupId: number, endpoint: number): Promise<EmberStatus> {
+        if (this._multicast[groupId] !== undefined) {
+            logger.debug(`${groupId} is already subscribed`, NS);
+            return EmberStatus.SUCCESS;
+        }
+
+        try {
+            const idx = this._available.pop();
+
+            if (idx === undefined) {
+                throw new Error("No available");
+            }
+
+            const entry: EmberMulticastTableEntry = new EmberMulticastTableEntry();
+            entry.endpoint = endpoint;
+            entry.multicastId = groupId;
+            entry.networkIndex = 0;
+            const status = await this.driver.ezsp.setMulticastTableEntry(idx, entry);
+            if (status !== EmberStatus.SUCCESS) {
+                logger.error(`Set MulticastTableEntry #${idx} for ${entry.multicastId} multicast id: ${status}`, NS);
+                this._available.push(idx);
+                return status;
+            }
+
+            this._multicast[entry.multicastId] = [entry, idx];
+            logger.debug(`Set MulticastTableEntry #${idx} for ${entry.multicastId} multicast id: ${status}`, NS);
+            return status;
+        } catch (error) {
+            logger.error(`No more available slots MulticastId subscription (${(error as Error).stack})`, NS);
+            return EmberStatus.INDEX_OUT_OF_RANGE;
+        }
+    }
+}

package/src/adapter/ezsp/driver/parser.ts

@@ -0,0 +1,81 @@
+/* v8 ignore start */
+
+import * as stream from "node:stream";
+
+import {logger} from "../../../utils/logger";
+import * as consts from "./consts";
+import Frame from "./frame";
+
+const NS = "zh:ezsp:uart";
+
+export class Parser extends stream.Transform {
+    private tail: Buffer[];
+
+    public constructor() {
+        super();
+
+        this.tail = [];
+    }
+
+    public override _transform(chunk: Buffer, _: string, cb: () => void): void {
+        if (chunk.indexOf(consts.CANCEL) >= 0) {
+            this.reset();
+            chunk = chunk.subarray(chunk.lastIndexOf(consts.CANCEL) + 1);
+        }
+
+        if (chunk.indexOf(consts.SUBSTITUTE) >= 0) {
+            this.reset();
+            chunk = chunk.subarray(chunk.indexOf(consts.FLAG) + 1);
+        }
+
+        logger.debug(`<-- [${chunk.toString("hex")}]`, NS);
+
+        let delimiterPlace = chunk.indexOf(consts.FLAG);
+
+        while (delimiterPlace >= 0) {
+            const buffer = chunk.subarray(0, delimiterPlace + 1);
+            const frameBuffer = Buffer.from([...this.unstuff(Buffer.concat([...this.tail, buffer]))]);
+            this.reset();
+
+            try {
+                const frame = Frame.fromBuffer(frameBuffer);
+
+                if (frame) {
+                    this.emit("parsed", frame);
+                }
+            } catch (error) {
+                logger.debug(`<-- error ${error}`, NS);
+            }
+
+            chunk = chunk.subarray(delimiterPlace + 1);
+            delimiterPlace = chunk.indexOf(consts.FLAG);
+        }
+
+        this.tail.push(chunk);
+        cb();
+    }
+
+    private *unstuff(buffer: Buffer): Generator<number> {
+        /* Unstuff (unescape) a buffer after receipt */
+        let escaped = false;
+        for (const byte of buffer) {
+            if (escaped) {
+                yield byte ^ consts.STUFF;
+                escaped = false;
+            } else {
+                if (byte === consts.ESCAPE) {
+                    escaped = true;
+                } else if (byte === consts.XOFF || byte === consts.XON) {
+                    // skip
+                } else {
+                    yield byte;
+                }
+            }
+        }
+    }
+
+    public reset(): void {
+        // clear tail
+        this.tail.length = 0;
+    }
+}

package/src/adapter/ezsp/driver/types/basic.ts

@@ -0,0 +1,201 @@
+/* v8 ignore start */
+export class int_t {
+    static _signed = true;
+
+    static serialize(cls: any, value: number): Buffer {
+        const buffer = Buffer.alloc(cls._size, 0);
+        if (cls._signed) {
+            buffer.writeIntLE(value, 0, cls._size);
+        } else {
+            buffer.writeUIntLE(value, 0, cls._size);
+        }
+        return buffer;
+    }
+
+    static deserialize(cls: any, data: Buffer): any[] {
+        return [cls._signed ? data.readIntLE(0, cls._size) : data.readUIntLE(0, cls._size), data.subarray(cls._size)];
+    }
+
+    static valueToName(cls: any, value: any): string {
+        for (const prop of Object.getOwnPropertyNames(cls)) {
+            const desc = Object.getOwnPropertyDescriptor(cls, prop);
+            if (desc?.enumerable && desc.writable && value == desc.value) {
+                return `${cls.name}.${prop}`;
+            }
+        }
+        return "";
+    }
+
+    static valueName(cls: any, value: any): string {
+        for (const prop of Object.getOwnPropertyNames(cls)) {
+            const desc = Object.getOwnPropertyDescriptor(cls, prop);
+            if (desc?.enumerable && desc.writable && value == desc.value) {
+                return `${prop}`;
+            }
+        }
+        return "";
+    }
+}
+
+export class int8s extends int_t {
+    static _size = 1;
+}
+
+export class int16s extends int_t {
+    static _size = 2;
+}
+
+export class int24s extends int_t {
+    static _size = 3;
+}
+
+export class int32s extends int_t {
+    static _size = 4;
+}
+
+export class int64s extends int_t {
+    static _size = 8;
+}
+
+export class uint_t extends int_t {
+    static override _signed = false;
+}
+
+export class uint8_t extends uint_t {
+    static _size = 1;
+}
+
+export class uint16_t extends uint_t {
+    static _size = 2;
+}
+
+export class uint24_t extends uint_t {
+    static _size = 3;
+}
+
+export class uint32_t extends uint_t {
+    static _size = 4;
+}
+
+export class uint64_t extends uint_t {
+    static _size = 8;
+}
+
+export class LVBytes {
+    static serialize(_cls: any, value: any[]): Buffer {
+        if (Buffer.isBuffer(value)) {
+            const ret = Buffer.alloc(1);
+            ret.writeUInt8(value.length, 0);
+            return Buffer.concat([ret, value]);
+        }
+        return Buffer.from([value.length].concat(value));
+    }
+
+    static deserialize(_cls: any, data: Buffer): any[] {
+        const l = data.readIntLE(0, 1);
+        const s = data.subarray(1, l + 1);
+        return [s, data.subarray(l + 1)];
+    }
+}
+
+export abstract class List {
+    static serialize(cls: any, value: any[]): Buffer {
+        // console.assert(((cls._length === null) || (cls.length === cls._length)));
+        return Buffer.from(value.map((i) => i.serialize(cls, i)));
+    }
+
+    static deserialize(cls: any, data: Buffer): any[] {
+        let item;
+        const r: any[] = [];
+        while (data) {
+            [item, data] = cls.itemtype.deserialize(cls.itemtype, data);
+            r.push(item);
+        }
+        return [r, data];
+    }
+}
+
+class _LVList extends List {
+    static override serialize(cls: any, value: any[]): Buffer {
+        const head = [cls.length];
+        const data = List.serialize(cls, value);
+        return Buffer.from(head.concat(data));
+    }
+
+    static override deserialize(cls: any, data: Buffer): any[] {
+        let item;
+        let length;
+        const r: any[] = [];
+        [length, data] = [data[0], data.subarray(1)];
+        for (let i = 0; i < length; i++) {
+            [item, data] = cls.itemtype.deserialize(cls.itemtype, data);
+            r.push(item);
+        }
+        return [r, data];
+    }
+}
+
+export function list(itemtype: any): List {
+    class ConreteList extends List {
+        static itemtype = itemtype;
+    }
+
+    return ConreteList;
+}
+
+export function LVList(itemtype: any): List {
+    class LVList extends _LVList {
+        static itemtype = itemtype;
+    }
+
+    return LVList;
+}
+
+export class WordList extends List {
+    static override serialize(_cls: any, value: any[]): Buffer {
+        const data = value.map((i) => Buffer.from(uint16_t.serialize(uint16_t, i)));
+        return Buffer.concat(data);
+    }
+}
+
+class _FixedList extends List {
+    static override serialize(cls: any, value: any[]): Buffer {
+        const data = value.map((i) => cls.itemtype.serialize(cls.itemtype, i)[0]);
+        return Buffer.from(data);
+    }
+
+    static override deserialize(cls: any, data: Buffer): any[] {
+        let item;
+        const r: any[] = [];
+        for (let i = 0; i < cls._length; i++) {
+            [item, data] = cls.itemtype.deserialize(cls.itemtype, data);
+            r.push(item);
+        }
+        return [r, data];
+    }
+}
+
+export function fixed_list(
+    length: number,
+    itemtype: any,
+): {
+    new (): any;
+    deserialize(cls: any, data: Buffer): any;
+} {
+    class FixedList extends _FixedList {
+        static itemtype = itemtype;
+        static _length = length;
+    }
+
+    return FixedList;
+}
+
+export class Bytes {
+    static serialize(_cls: any, value: any[]): Buffer {
+        return Buffer.from(value);
+    }
+
+    static deserialize(_cls: any, data: Buffer): any[] {
+        return [data];
+    }
+}

package/src/adapter/ezsp/driver/types/index.ts

@@ -0,0 +1,239 @@
+/* v8 ignore start */
+
+import {Bytes, fixed_list, int8s, LVBytes, LVList, list, uint_t, uint8_t, uint16_t, uint24_t, uint32_t, uint64_t, WordList} from "./basic";
+import {
+    Bool,
+    EmberApsOption,
+    EmberBindingType,
+    EmberConcentratorType,
+    EmberConfigTxPowerMode,
+    EmberCounterType,
+    EmberCurrentSecurityBitmask,
+    EmberDerivedKeyType,
+    EmberDeviceUpdate,
+    EmberEUI64,
+    EmberEventUnits,
+    EmberGpKeyType,
+    EmberGpSecurityLevel,
+    EmberIncomingMessageType,
+    EmberInitialSecurityBitmask,
+    EmberJoinDecision,
+    EmberJoinMethod,
+    EmberKeyStatus,
+    EmberKeyStructBitmask,
+    EmberKeyType,
+    EmberLibraryStatus,
+    EmberMacPassthroughType,
+    EmberMulticastId,
+    EmberNetworkInitBitmask,
+    EmberNetworkStatus,
+    EmberNodeId,
+    EmberNodeType,
+    EmberOutgoingMessageType,
+    EmberPanId,
+    EmberRf4ceApplicationCapabilities,
+    EmberRf4ceNodeCapabilities,
+    EmberRf4ceTxOption,
+    EmberStackError,
+    EmberStatus,
+    EmberZDOCmd,
+    EmberZdoConfigurationFlags,
+    EmberZllKeyIndex,
+    EmberZllState,
+    EzspConfigId,
+    EzspDecisionId,
+    EzspEndpointFlags,
+    EzspExtendedValueId,
+    EzspMfgTokenId,
+    EzspNetworkScanType,
+    EzspPolicyId,
+    EzspSourceRouteOverheadInformation,
+    EzspStatus,
+    EzspValueId,
+    EzspZllNetworkOperation,
+    NcpResetCode,
+    SecureEzspRandomNumber,
+    SecureEzspSecurityLevel,
+    SecureEzspSecurityType,
+    SecureEzspSessionId,
+    SLStatus,
+} from "./named";
+import {
+    EmberAesMmoHashContext,
+    EmberApsFrame,
+    EmberBindingTableEntry,
+    EmberCertificate283k1Data,
+    EmberCertificateData,
+    EmberCurrentSecurityState,
+    EmberGpAddress,
+    EmberGpSinkListEntry,
+    EmberInitialSecurityState,
+    EmberKeyData,
+    EmberKeyStruct,
+    EmberMessageDigest,
+    EmberMultiAddress,
+    EmberMulticastTableEntry,
+    EmberNeighbors,
+    EmberNeighborTableEntry,
+    EmberNetworkInitStruct,
+    EmberNetworkParameters,
+    EmberNodeDescriptor,
+    EmberPrivateKey283k1Data,
+    EmberPrivateKeyData,
+    EmberPublicKey283k1Data,
+    EmberPublicKeyData,
+    EmberRf4ceApplicationInfo,
+    EmberRf4cePairingTableEntry,
+    EmberRf4ceVendorInfo,
+    EmberRouteTableEntry,
+    EmberRoutingTable,
+    EmberRoutingTableEntry,
+    EmberSecurityManagerContext,
+    EmberSecurityManagerNetworkKeyInfo,
+    EmberSignature283k1Data,
+    EmberSignatureData,
+    EmberSimpleDescriptor,
+    EmberSmacData,
+    EmberTokTypeStackZllData,
+    EmberTokTypeStackZllSecurity,
+    EmberZigbeeNetwork,
+    EmberZllAddressAssignment,
+    EmberZllDeviceInfoRecord,
+    EmberZllInitialSecurityState,
+    EmberZllNetwork,
+    EmberZllSecurityAlgorithmData,
+    EzspStruct,
+} from "./struct";
+
+export function deserialize(payload: any, schema: any[]): any[] {
+    const result = [];
+    let value;
+    let data = payload;
+    for (const type of schema) {
+        [value, data] = type.deserialize(type, data);
+        result.push(value);
+    }
+    return [result, data];
+}
+
+export function serialize(data: any[], schema: {serialize: (schema: any, item: any) => Buffer}[]): Buffer {
+    return Buffer.concat(schema.map((s, idx) => s.serialize(s, data[idx])));
+}
+
+export {
+    /* Basic Types */
+    int8s,
+    uint_t,
+    uint8_t,
+    uint16_t,
+    uint24_t,
+    uint32_t,
+    uint64_t,
+    LVBytes,
+    list,
+    LVList,
+    fixed_list,
+    WordList,
+    Bytes,
+    /* Named Types */
+    NcpResetCode,
+    EmberRf4ceTxOption,
+    EmberRf4ceNodeCapabilities,
+    EmberRf4ceApplicationCapabilities,
+    EmberNodeId,
+    EmberPanId,
+    EmberMulticastId,
+    EmberEUI64,
+    EmberLibraryStatus,
+    SecureEzspSecurityType,
+    SecureEzspSecurityLevel,
+    EmberGpSecurityLevel,
+    EmberGpKeyType,
+    SecureEzspRandomNumber,
+    SecureEzspSessionId,
+    Bool,
+    EzspConfigId,
+    EzspValueId,
+    EzspExtendedValueId,
+    EzspEndpointFlags,
+    EmberConfigTxPowerMode,
+    EzspPolicyId,
+    EzspDecisionId,
+    EzspMfgTokenId,
+    EzspStatus,
+    EmberStatus,
+    SLStatus,
+    EmberStackError,
+    EmberEventUnits,
+    EmberNodeType,
+    EmberNetworkStatus,
+    EmberIncomingMessageType,
+    EmberOutgoingMessageType,
+    EmberMacPassthroughType,
+    EmberBindingType,
+    EmberApsOption,
+    EzspNetworkScanType,
+    EmberJoinDecision,
+    EmberInitialSecurityBitmask,
+    EmberCurrentSecurityBitmask,
+    EmberKeyType,
+    EmberKeyStructBitmask,
+    EmberDeviceUpdate,
+    EmberKeyStatus,
+    EmberCounterType,
+    EmberJoinMethod,
+    EmberZdoConfigurationFlags,
+    EmberConcentratorType,
+    EmberZllState,
+    EmberZllKeyIndex,
+    EzspZllNetworkOperation,
+    EzspSourceRouteOverheadInformation,
+    EmberNetworkInitBitmask,
+    EmberZDOCmd,
+    EmberDerivedKeyType,
+    /* Structs */
+    EzspStruct,
+    EmberNetworkParameters,
+    EmberZigbeeNetwork,
+    EmberApsFrame,
+    EmberBindingTableEntry,
+    EmberMulticastTableEntry,
+    EmberKeyData,
+    EmberCertificateData,
+    EmberPublicKeyData,
+    EmberPrivateKeyData,
+    EmberSmacData,
+    EmberSignatureData,
+    EmberCertificate283k1Data,
+    EmberPublicKey283k1Data,
+    EmberPrivateKey283k1Data,
+    EmberSignature283k1Data,
+    EmberMessageDigest,
+    EmberAesMmoHashContext,
+    EmberNeighborTableEntry,
+    EmberRouteTableEntry,
+    EmberInitialSecurityState,
+    EmberCurrentSecurityState,
+    EmberKeyStruct,
+    EmberNetworkInitStruct,
+    EmberZllSecurityAlgorithmData,
+    EmberZllNetwork,
+    EmberZllInitialSecurityState,
+    EmberZllDeviceInfoRecord,
+    EmberZllAddressAssignment,
+    EmberTokTypeStackZllData,
+    EmberTokTypeStackZllSecurity,
+    EmberRf4ceVendorInfo,
+    EmberRf4ceApplicationInfo,
+    EmberRf4cePairingTableEntry,
+    EmberGpAddress,
+    EmberGpSinkListEntry,
+    EmberNodeDescriptor,
+    EmberSimpleDescriptor,
+    EmberMultiAddress,
+    EmberNeighbors,
+    EmberRoutingTable,
+    EmberRoutingTableEntry,
+    EmberSecurityManagerContext,
+    EmberSecurityManagerNetworkKeyInfo,
+};