@willieee802/zigbee-herdsman 0.48.3 → 0.49.1

package/src/adapter/ember/uart/consts.ts

@@ -0,0 +1,109 @@
+import {EZSP_MAX_FRAME_LENGTH, EZSP_MIN_FRAME_LENGTH} from "../ezsp/consts";
+
+/**
+ * Define the size of the receive buffer pool on the EZSP host.
+ *
+ * The number of receive buffers does not need to be greater than the number of packet buffers available on the NCP,
+ * because this in turn is the maximum number of callbacks that could be received between commands.
+ * In reality a value of 20 is a generous allocation.
+ */
+export const EZSP_HOST_RX_POOL_SIZE = 32;
+/**
+ * The number of transmit buffers must be set to the number of receive buffers
+ * -- to hold the immediate ACKs sent for each callabck frame received --
+ * plus 3 buffers for the retransmit queue and one each for an automatic ACK
+ * (due to data flow control) and a command.
+ */
+export const TX_POOL_BUFFERS = EZSP_HOST_RX_POOL_SIZE + 5;
+
+/** protocol version */
+export const ASH_VERSION = 2;
+
+/**
+ * Timeouts before link is judged down.
+ *
+ * Consecutive ACK timeouts (minus 1) needed to enter the ERROR state.
+ *
+ * Is 3 in ash-ncp.h
+ */
+export const ASH_MAX_TIMEOUTS = 6;
+/** max time in msecs for ncp to wake */
+export const ASH_MAX_WAKE_TIME = 150;
+
+/**
+ * Define the units used by the Not Ready timer as 2**n msecs
+ * log2 of msecs per NR timer unit
+ */
+export const ASH_NR_TIMER_BIT = 4;
+
+/** Control byte mask for DATA frame */
+export const ASH_DFRAME_MASK = 0x80;
+/** Control byte mask for short frames (ACK/NAK) */
+export const ASH_SHFRAME_MASK = 0xe0;
+
+/** Acknowledge frame number */
+export const ASH_ACKNUM_MASK = 0x07;
+export const ASH_ACKNUM_BIT = 0;
+/** Retransmitted frame flag */
+export const ASH_RFLAG_MASK = 0x08;
+export const ASH_RFLAG_BIT = 3;
+/** Receiver not ready flag */
+export const ASH_NFLAG_MASK = 0x08;
+export const ASH_NFLAG_BIT = 3;
+/** Reserved for future use */
+export const ASH_PFLAG_MASK = 0x10;
+export const ASH_PFLAG_BIT = 4;
+/** DATA frame number */
+export const ASH_FRMNUM_MASK = 0x70;
+export const ASH_FRMNUM_BIT = 4;
+
+/**
+ * The wake byte special function applies only when in between frames,
+ * so it does not need to be escaped within a frame.
+ * (also means NCP data pending)
+ */
+export const ASH_WAKE = 0xff; /*!<   */
+
+/** Constant used in byte-stuffing (XOR mask used in byte stuffing) */
+export const ASH_FLIP = 0x20;
+
+// Field and frame lengths, excluding flag byte and any byte stuffing overhead
+// All limits are inclusive
+export const ASH_MIN_DATA_FIELD_LEN = EZSP_MIN_FRAME_LENGTH;
+export const ASH_MAX_DATA_FIELD_LEN = EZSP_MAX_FRAME_LENGTH;
+/** with control */
+export const ASH_MIN_DATA_FRAME_LEN = ASH_MIN_DATA_FIELD_LEN + 1;
+/** control plus data field, but not CRC */
+export const ASH_MIN_FRAME_LEN = 1;
+export const ASH_MAX_FRAME_LEN = ASH_MAX_DATA_FIELD_LEN + 1;
+export const ASH_CRC_LEN = 2;
+export const ASH_MIN_FRAME_WITH_CRC_LEN = ASH_MIN_FRAME_LEN + ASH_CRC_LEN;
+export const ASH_MAX_FRAME_WITH_CRC_LEN = ASH_MAX_FRAME_LEN + ASH_CRC_LEN;
+
+// Lengths for each frame type: includes control and data field (if any), excludes the CRC and flag bytes
+/** ash frame len data min */
+export const ASH_FRAME_LEN_DATA_MIN = ASH_MIN_DATA_FIELD_LEN + 1;
+/** [control] */
+export const ASH_FRAME_LEN_ACK = 1;
+/** [control] */
+export const ASH_FRAME_LEN_NAK = 1;
+/** [control] */
+export const ASH_FRAME_LEN_RST = 1;
+/** [control, version, reset reason] */
+export const ASH_FRAME_LEN_RSTACK = 3;
+/** [control, version, error] */
+export const ASH_FRAME_LEN_ERROR = 3;
+
+// Define lengths of short frames - includes control byte and data field
+/** longest non-data frame sent */
+export const SH_TX_BUFFER_LEN = 2;
+/** longest non-data frame received */
+export const SH_RX_BUFFER_LEN = 3;
+
+// Define constants for the LFSR in randomizeBuffer()
+/** polynomial */
+export const LFSR_POLY = 0xb8;
+/** initial value (seed) */
+export const LFSR_SEED = 0x42;
+
+export const VALID_BAUDRATES = [600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 230400, 460800];

package/src/adapter/ember/uart/enums.ts

@@ -0,0 +1,192 @@
+/**
+ * Identify the type of frame from control byte.
+ *
+ * Control byte formats
+ *  +---------+----+----+----+----+----+----+----+----++---------+
+ *  |         | B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 ||  Range  |
+ *  +---------+----+----+----+----+----+----+----+----++---------+
+ *  | DATA    |  0 |   frameNum   | rF |    ackNum    ||0x00-0x7F|
+ *  +---------+----+----+----+----+----+----+----+----++---------+
+ *  | ACK     |  1 |  0 |  0 | pF | nF |    ackNum    ||0x80-0x9F|
+ *  | NAK     |  1 |  0 |  1 | pF | nF |    ackNum    ||0xA0-0xBF|
+ *  +---------+----+----+----+----+----+----+----+----++---------+
+ *  | RST     |  1 |  1 |  0 |  0 |  0 |  0 |  0 |  0 ||   0xC0  |
+ *  | RSTACK  |  1 |  1 |  0 |  0 |  0 |  0 |  0 |  1 ||   0xC1  |
+ *  | ERROR   |  1 |  1 |  0 |  0 |  0 |  0 |  1 |  0 ||   0xC2  |
+ *  +---------+----+----+----+----+----+----+----+----++---------+
+ *           rF = rFlag (retransmission flag)
+ *           nF = nFlag (receiver not ready flag, always 0 in frames sent by the NCP)
+ *           pF = flag reserved for future use
+ *           frameNum = DATA frame’s 3-bit sequence number
+ *           ackNum = acknowledges receipt of DATA frames up to, but not including, ackNum
+ *  Control byte values 0xC3-0xFE are unused, 0xFF is reserved.
+ */
+export enum AshFrameType {
+    INVALID = -1,
+    /**
+     * Carries all EZSP frames.
+     *
+     * [CONTROL, EZSP 0, EZSP 1, EZSP 2, EZSP n, CRC high, CRC low, FLAG]
+     *
+     * Notation used in documentation: DATA(F, A, R)
+     * - F: frame number (frmNum)
+     * - A: acknowledge number (ackNum)
+     * - R: retransmit flag (reTx)
+     *
+     * Example without pseudo-random sequence applied to Data Field:
+     * - EZSP “version” command: 00 00 00 02
+     * - DATA(2, 5, 0) = 25 00 00 00 02 1A AD 7E
+     * - EZSP “version” response: 00 80 00 02 02 11 30
+     * - DATA(5, 3, 0) = 53 00 80 00 02 02 11 30 63 16 7E
+     *
+     * Example with pseudo-random sequence applied to Data Field:
+     * - EZSP “version” command: 00 00 00 02
+     * - DATA(2, 5, 0) = 25 42 21 A8 56 A6 09 7E
+     * - EZSP “version” response: 00 80 00 02 02 11 30
+     * - DATA(5, 3, 0) = 53 42 A1 A8 56 28 04 82 96 23 7E
+     *
+     * Sent by: NCP, Host
+     */
+    DATA = 0,
+    /**
+     * Acknowledges receipt of a valid DATA frame.
+     *
+     * [CONTROL, CRC high, CRC low, FLAG]
+     *
+     * Notation used in documentation: ACK(A)+/-
+     * - A: acknowledge number (ackNum)
+     * - +/-: not ready flag (nRdy); “+” = “0” = “ready”; “-” = “1” = “not ready”
+     *
+     * Examples:
+     * - ACK(1)+ :81 60 59 7E
+     * - ACK(6)– : 8E 91 B6 7E
+     *
+     * Sent by: NCP, Host
+     */
+    ACK = 0x80, // 0b10000000
+    /**
+     * Indicates receipt of a DATA frame with an error or that was discarded due to lack of memory.
+     *
+     * [CONTROL, CRC high, CRC low, FLAG]
+     *
+     * Notation used in documentation: NAK(A)+/-
+     * - A: acknowledge number (ackNum)
+     * - +/-: not ready flag (nRdy); “+” = “0” = “ready”; “-” = “1” = “not ready”
+     *
+     * Examples:
+     * - NAK(6)+ : A6 34 DC 7E
+     * - NAK(5)- : AD 85 B7 7E
+     *
+     * Sent by: NCP, Host
+     */
+    NAK = 0xa0, // 0b10100000
+    /**
+     * Requests the NCP to perform a software reset (valid even if the NCP is in the FAILED state).
+     *
+     * [CONTROL, CRC high, CRC low, FLAG]
+     *
+     * Notation used in documentation: RST()
+     *
+     * Example: C0 38 BC 7E
+     *
+     * Sent by: Host
+     */
+    RST = 0xc0, // 0b11000000
+    /**
+     * Informs the Host that the NCP has reset and the reason for the reset.
+     *
+     * [CONTROL, version, reset code, CRC high, CRC low, FLAG]
+     *
+     * Notation used in documentation: RSTACK(V, C)
+     * - V: version
+     * - C: reset code
+     *
+     * Example: C1 02 02 9B 7B 7E
+     *
+     * Sent by: NCP
+     */
+    RSTACK = 0xc1, // 0b11000001
+    /**
+     * Informs the Host that the NCP detected a fatal error and is in the FAILED state.
+     *
+     * [CONTROL, version, error code, CRC high, CRC low, FLAG]
+     *
+     * Notation used in documentation: ERROR(V, C )
+     * - V: version
+     * - C: reset code
+     *
+     * Example: C2 01 52 FA BD 7E
+     *
+     * Sent by: NCP
+     */
+    ERROR = 0xc2, // 0b11000010
+}
+
+export const enum AshReservedByte {
+    /**
+     * Marks the end of a frame.
+     *
+     * When a Flag Byte is received, the data received since the last Flag Byte or Cancel Byte
+     * is tested to see whether it is a valid frame. */
+    FLAG = 0x7e,
+    /**
+     * Indicates that the following byte is escaped.
+     *
+     * If the byte after the Escape Byte is not a reserved byte,
+     * bit 5 of the byte is complemented to restore its original value.
+     * If the byte after the Escape Byte is a reserved value, the Escape Byte has no effect. */
+    ESCAPE = 0x7d,
+    /**
+     * Resume transmission.
+     *
+     * Used in XON/XOFF flow control. Always ignored if received by the NCP.
+     */
+    XON = 0x11,
+    /**
+     * Stop transmission.
+     *
+     * Used in XON/XOFF flow control. Always ignored if received by the NCP
+     */
+    XOFF = 0x13,
+    /**
+     * Replaces a byte received with a low-level communication error (e.g., framing error) from the UART.
+     *
+     * When a Substitute Byte is processed, the data between the previous and the next Flag Bytes is ignored.
+     */
+    SUBSTITUTE = 0x18,
+    /**
+     * Terminates a frame in progress.
+     *
+     * A Cancel Byte causes all data received since the previous Flag Byte to be ignored.
+     * Note that as a special case, RST and RSTACK frames are preceded by Cancel Bytes to ignore any link startup noise.
+     */
+    CANCEL = 0x1a,
+}
+
+/**
+ * The NCP enters the FAILED state if it detects one of the following errors:
+ * - An abnormal internal reset due to an error, failed assertion, or fault.
+ * - Exceeding the maximum number of consecutive acknowledgement timeouts.
+ *
+ * When the NCP enters the FAILED state, the NCP sends an ERROR frame containing a reset or error code
+ * and will reply to all subsequent frames received, except RST, with an ERROR frame.
+ * To reinitialize the ASH protocol, the Host must reset the NCP by either asserting the nRESET pin or sending the RST frame.
+ *
+ * The codes are returned by the NCP in the:
+ * - Reset Code byte of a RSTACK frame
+ * - Error Code byte of an ERROR frame.
+ *
+ * Silicon Labs wireless mesh chips can detect numerous reset fault causes beyond those in the table.
+ * When sent to the host, these new reset codes have 0x80 added to the value returned by their HAL’s reset code.
+ */
+export enum NcpFailedCode {
+    RESET_UNKNOWN_REASON = 0,
+    RESET_EXTERNAL = 1,
+    RESET_POWERON = 2,
+    RESET_WATCHDOG = 3,
+    RESET_ASSERT = 6,
+    RESET_BOOTLOADER = 9,
+    RESET_SOFTWARE = 11,
+    ERROR_EXCEEDED_MAXIMUM_ACK_TIMEOUT_COUNT = 0x51,
+    CHIP_SPECIFIC_ERROR_RESET_CODE = 0x80,
+}

package/src/adapter/ember/uart/parser.ts

@@ -0,0 +1,42 @@
+/* v8 ignore start */
+
+import {Transform, type TransformCallback} from "node:stream";
+
+// import {logger} from '../../../utils/logger';
+import {AshReservedByte} from "./enums";
+
+// const NS = 'zh:ember:uart:ash:parser';
+
+export class AshParser extends Transform {
+    #buffer = Buffer.alloc(0);
+
+    override _transform(chunk: Buffer, _encoding: BufferEncoding, cb: TransformCallback): void {
+        let data = Buffer.concat([this.#buffer, chunk]);
+        let position: number;
+
+        // biome-ignore lint/suspicious/noAssignInExpressions: shorter
+        while ((position = data.indexOf(AshReservedByte.FLAG)) !== -1) {
+            // emit the frame via 'data' event
+            const frame = data.subarray(0, position + 1);
+
+            // expensive and very verbose, enable locally only if necessary
+            // logger.debug(`<<<< [FRAME raw=${frame.toString('hex')}]`, NS);
+            this.push(frame);
+
+            // remove the frame from internal buffer (set below)
+            data = data.subarray(position + 1);
+        }
+
+        this.#buffer = data;
+
+        cb();
+    }
+
+    override _flush(cb: TransformCallback): void {
+        this.push(this.#buffer);
+
+        this.#buffer = Buffer.alloc(0);
+
+        cb();
+    }
+}

package/src/adapter/ember/uart/queues.ts

@@ -0,0 +1,247 @@
+/* v8 ignore start */
+
+import {logger} from "../../../utils/logger";
+import {EZSP_MAX_FRAME_LENGTH} from "../ezsp/consts";
+
+const NS = "zh:ember:uart:queues";
+
+/**
+ * Buffer to hold a DATA frame.
+ * Allocates `data` to `EZSP_MAX_FRAME_LENGTH` filled with zeroes.
+ */
+export class EzspBuffer {
+    /** uint8_t[EZSP_MAX_FRAME_LENGTH] */
+    public data: Buffer;
+    public link?: EzspBuffer;
+    /** uint8_t */
+    public len: number;
+
+    constructor() {
+        this.data = Buffer.alloc(EZSP_MAX_FRAME_LENGTH); // inits to all-zeroes
+        this.link = undefined;
+        this.len = 0;
+    }
+}
+
+/**
+ * Simple queue (singly-linked list)
+ */
+export class EzspQueue {
+    public tail?: EzspBuffer;
+
+    constructor() {
+        this.tail = undefined;
+    }
+
+    /**
+     * Get the number of buffers in the queue.
+     * @returns
+     */
+    get length(): number {
+        let head = this.tail;
+        let count = 0;
+
+        for (count; head !== undefined; count++) {
+            head = head.link;
+        }
+
+        return count;
+    }
+
+    get empty(): boolean {
+        return this.tail === undefined;
+    }
+
+    /**
+     * Get a pointer to the buffer at the head of the queue.
+     * @returns
+     */
+    get head(): EzspBuffer {
+        let head = this.tail;
+
+        if (head === undefined) {
+            throw new Error("Tried to get head from an empty queue.");
+        }
+
+        while (head.link !== undefined) {
+            head = head.link;
+        }
+
+        return head;
+    }
+
+    /**
+     * Get a pointer to the Nth entry in the queue (the tail corresponds to N = 1).
+     *
+     * @param n
+     * @returns
+     */
+    public getNthEntry(n: number): EzspBuffer | undefined {
+        if (n === 0) {
+            throw new Error("Asked for 0th element in queue.");
+        }
+
+        let buf = this.tail;
+
+        while (--n) {
+            if (buf === undefined) {
+                throw new Error("Less than N entries in queue.");
+            }
+
+            buf = buf.link;
+        }
+
+        return buf;
+    }
+
+    /**
+     * Get a pointer to the entry before the specified entry (closer to the tail).
+     * If the buffer specified is undefined, the head entry is returned.
+     * If the buffer specified is the tail, undefined is returned.
+     * @param entry The buffer to look before.
+     * @returns
+     */
+    public getPrecedingEntry(entry?: EzspBuffer): EzspBuffer | undefined {
+        let buf = this.tail;
+
+        if (buf === entry) {
+            return undefined;
+        }
+
+        if (buf === undefined) {
+            throw new Error("Tried to get preceding entry from an empty queue.");
+        }
+
+        do {
+            if (buf.link === entry) {
+                return buf;
+            }
+
+            buf = buf.link;
+        } while (buf !== undefined);
+
+        throw new Error("Buffer not in queue.");
+    }
+
+    /**
+     * Add a buffer to the tail of the queue.
+     * @param buf
+     */
+    public addTail(buf: EzspBuffer): void {
+        if (buf) {
+            buf.link = this.tail;
+            this.tail = buf;
+        } else {
+            throw new Error("Called addTail with undefined buffer");
+        }
+    }
+
+    /**
+     * Remove the buffer at the head of the queue.
+     * @returns The removed buffer.
+     */
+    public removeHead(): EzspBuffer {
+        let head = this.tail;
+
+        if (head === undefined) {
+            throw new Error("Tried to remove head from an empty queue.");
+        }
+
+        if (head.link === undefined) {
+            this.tail = undefined;
+        } else {
+            let prev: EzspBuffer;
+
+            do {
+                prev = head;
+                head = head.link;
+            } while (head.link !== undefined);
+
+            prev.link = undefined;
+        }
+
+        return head;
+    }
+
+    /**
+     * Remove the specified entry from the queue.
+     * @param entry
+     * @returns A pointer to the preceding entry (if any).
+     */
+    public removeEntry(entry: EzspBuffer): EzspBuffer | undefined {
+        const buf = this.getPrecedingEntry(entry);
+
+        if (buf !== undefined) {
+            buf.link = entry.link;
+        } else {
+            this.tail = entry.link;
+        }
+
+        return buf;
+    }
+}
+
+/**
+ * Simple free list (singly-linked list)
+ */
+export class EzspFreeList {
+    public link?: EzspBuffer;
+
+    constructor() {
+        this.link = undefined;
+    }
+
+    /**
+     * Get the number of buffers in the free list.
+     * @returns
+     */
+    get length(): number {
+        let next = this.link;
+        let count = 0;
+
+        for (count; next !== undefined; count++) {
+            next = next.link;
+        }
+
+        return count;
+    }
+
+    /**
+     * Add a buffer to the free list.
+     * @param buf
+     */
+    public freeBuffer(buf: EzspBuffer): void {
+        if (buf) {
+            buf.link = this.link;
+            this.link = buf;
+        } else {
+            throw new Error("Called freeBuffer with undefined buffer");
+        }
+    }
+
+    /**
+     * Get a buffer from the free list.
+     * @returns
+     */
+    public allocBuffer(): EzspBuffer | undefined {
+        const buf = this.link;
+
+        if (buf !== undefined) {
+            this.link = buf.link;
+            buf.len = 0;
+
+            if (buf.data.length !== EZSP_MAX_FRAME_LENGTH) {
+                // should never happen if buffers are handled properly, but just in case, re-alloc to max length
+                buf.data = Buffer.alloc(EZSP_MAX_FRAME_LENGTH);
+
+                const e = new Error();
+                logger.error(`Pre-allocated buffer had improper size and had to be re-allocated. ${e.stack}`, NS);
+            } else {
+                // (void) memset(buffer->data, 0, EZSP_MAX_FRAME_LENGTH);
+                buf.data.fill(0);
+            }
+        }
+
+        return buf;
+    }
+}

package/src/adapter/ember/uart/writer.ts

@@ -0,0 +1,50 @@
+/* v8 ignore start */
+
+import {Readable} from "node:stream";
+import {ASH_MAX_FRAME_WITH_CRC_LEN} from "./consts";
+
+// import {logger} from '../../../utils/logger';
+
+// const NS = 'zh:ember:uart:ash:writer';
+
+export class AshWriter extends Readable {
+    #writtenLen = 0;
+    #bytesToWrite = Buffer.alloc(ASH_MAX_FRAME_WITH_CRC_LEN);
+
+    private writeBytes(): void {
+        // expensive and very verbose, enable locally only if necessary
+        // logger.debug(`>>>> [FRAME raw=${buffer.toString('hex')}]`, NS);
+
+        // copy, can't use ref
+        const buffer = Buffer.from(this.#bytesToWrite.subarray(0, this.#writtenLen));
+        this.#writtenLen = 0;
+
+        // this.push(buffer);
+        this.emit("data", buffer);
+    }
+
+    public writeByte(byte: number): void {
+        this.#writtenLen = this.#bytesToWrite.writeUInt8(byte, this.#writtenLen);
+    }
+
+    public writeAvailable(): boolean {
+        if (this.readableLength < this.readableHighWaterMark) {
+            return true;
+        }
+
+        this.writeFlush();
+
+        return false;
+    }
+
+    /**
+     * If there is anything to send, send to the port.
+     */
+    public writeFlush(): void {
+        if (this.#writtenLen > 0) {
+            this.writeBytes();
+        }
+    }
+
+    public override _read(): void {}
+}

package/src/adapter/ember/utils/initters.ts

@@ -0,0 +1,58 @@
+/* v8 ignore start */
+
+import * as ZSpec from "../../../zspec";
+import type {NetworkCache} from "../adapter/emberAdapter";
+import {INVALID_RADIO_CHANNEL, ZB_PSA_ALG} from "../consts";
+import {EmberJoinMethod, SecManDerivedKeyType, SecManFlag, SecManKeyType} from "../enums";
+import {EMBER_AES_HASH_BLOCK_SIZE} from "../ezsp/consts";
+import type {EmberAesMmoHashContext, SecManContext} from "../types";
+
+/**
+ * Initialize a network cache index with proper "invalid" values.
+ * @returns
+ */
+export const initNetworkCache = (): NetworkCache => {
+    return {
+        eui64: ZSpec.BLANK_EUI64,
+        parameters: {
+            extendedPanId: ZSpec.BLANK_EXTENDED_PAN_ID.slice(), // copy
+            panId: ZSpec.INVALID_PAN_ID,
+            radioTxPower: 0,
+            radioChannel: INVALID_RADIO_CHANNEL,
+            joinMethod: EmberJoinMethod.MAC_ASSOCIATION,
+            nwkManagerId: ZSpec.NULL_NODE_ID,
+            nwkUpdateId: 0,
+            channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+        },
+    };
+};
+
+/**
+ * This routine will initialize a Security Manager context correctly for use in subsequent function calls.
+ * @returns
+ */
+export const initSecurityManagerContext = (): SecManContext => {
+    return {
+        coreKeyType: SecManKeyType.NONE,
+        keyIndex: 0,
+        derivedType: SecManDerivedKeyType.NONE,
+        eui64: "0x0000000000000000",
+        multiNetworkIndex: 0,
+        flags: SecManFlag.NONE,
+        psaKeyAlgPermission: ZB_PSA_ALG, // unused for classic key storage
+    };
+};
+
+/**
+ *  This routine clears the passed context so that a new hash calculation
+ *  can be performed.
+ *
+ *  @returns context A pointer to the location of hash context to clear.
+ */
+export const aesMmoHashInit = (): EmberAesMmoHashContext => {
+    // MEMSET(context, 0, sizeof(EmberAesMmoHashContext));
+    return {
+        result: Buffer.alloc(EMBER_AES_HASH_BLOCK_SIZE), // uint8_t[EMBER_AES_HASH_BLOCK_SIZE]
+        length: 0x00000000, // uint32_t
+    };
+};