zigbee-herdsman 6.0.1 → 6.0.3

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

@@ -1,101 +0,0 @@
-/* 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

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

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

@@ -1,78 +0,0 @@
-/* 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

@@ -1,81 +0,0 @@
-/* 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

@@ -1,201 +0,0 @@
-/* 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

@@ -1,239 +0,0 @@
-/* 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,
-};