@willieee802/zigbee-herdsman 0.48.2 → 0.49.0

package/test/adapter/ember/ash.test.ts

@@ -0,0 +1,337 @@
+import {MockBinding, type MockPortBinding} from "@serialport/binding-mock";
+import type {OpenOptions} from "@serialport/stream";
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+import {EzspStatus} from "../../../src/adapter/ember/enums";
+import {EzspBuffalo} from "../../../src/adapter/ember/ezsp/buffalo";
+import {
+    EZSP_EXTENDED_FRAME_CONTROL_LB_INDEX,
+    EZSP_FRAME_CONTROL_COMMAND,
+    EZSP_FRAME_CONTROL_NETWORK_INDEX_MASK,
+    EZSP_FRAME_CONTROL_NETWORK_INDEX_OFFSET,
+    EZSP_FRAME_CONTROL_SLEEP_MODE_MASK,
+    EZSP_FRAME_ID_INDEX,
+    EZSP_MAX_FRAME_LENGTH,
+    EZSP_PARAMETERS_INDEX,
+    EZSP_SEQUENCE_INDEX,
+} from "../../../src/adapter/ember/ezsp/consts";
+import {EzspFrameID} from "../../../src/adapter/ember/ezsp/enums";
+import {CONFIG_TX_K, UartAsh} from "../../../src/adapter/ember/uart/ash";
+import {EZSP_HOST_RX_POOL_SIZE, TX_POOL_BUFFERS} from "../../../src/adapter/ember/uart/consts";
+import {EzspBuffer} from "../../../src/adapter/ember/uart/queues";
+import {lowByte} from "../../../src/adapter/ember/utils/math";
+import {wait} from "../../../src/utils/";
+import {ASH_ACK_FIRST_BYTES, adapterSONOFFDongleE, RECD_RSTACK_BYTES, SEND_ACK_FIRST_BYTES, SEND_RST_BYTES} from "./consts";
+
+const mockSerialPortCloseEvent = vi.fn();
+const mockSerialPortErrorEvent = vi.fn();
+
+// todo doesnt reset if closing
+// todo doesnt start if closing or connected
+// todo doesnt close port if already closed on stop
+// todo port error triggers stop
+// todo emit `reset` only on port error
+// todo emit `close` only when ASH layer stopped
+// todo emit `frame` only on valid DATA frame
+
+const mocks = [mockSerialPortCloseEvent, mockSerialPortErrorEvent];
+
+describe("Ember UART ASH Protocol", () => {
+    const openOpts: OpenOptions<MockPortBinding> = {path: "/dev/ttyACM0", baudRate: 115200, binding: MockBinding};
+    /**
+     * Mock binding provides:
+     *
+     * uartAsh.serialPort.port.recording => Buffer of all data written if record==true
+     *
+     * uartAsh.serialPort.port.lastWrite => Buffer of last write
+     */
+    let uartAsh: UartAsh;
+    let buffalo: EzspBuffalo;
+    let frameSequence: number;
+
+    beforeAll(() => {
+        vi.useRealTimers(); // messes with serialport promise handling otherwise?
+    });
+
+    afterAll(() => {
+        vi.useRealTimers();
+    });
+
+    beforeEach(() => {
+        for (const mock of mocks) {
+            mock.mockClear();
+        }
+
+        frameSequence = 0;
+        uartAsh = new UartAsh(openOpts);
+        buffalo = new EzspBuffalo(Buffer.alloc(EZSP_MAX_FRAME_LENGTH));
+        MockBinding.createPort("/dev/ttyACM0", {/*echo: true,*/ record: true, /*readyData: emitRSTACK,*/ ...adapterSONOFFDongleE});
+
+        buffalo.setPosition(0);
+    });
+
+    afterEach(async () => {
+        await uartAsh.stop();
+        MockBinding.reset();
+    });
+
+    it("Inits properly and allocates buffers as needed", () => {
+        expect(uartAsh.connected).toStrictEqual(false);
+        expect(uartAsh.txQueue).toBeDefined();
+        expect(uartAsh.reTxQueue).toBeDefined();
+        expect(uartAsh.txFree).toBeDefined();
+        expect(uartAsh.rxQueue).toBeDefined();
+        expect(uartAsh.rxFree).toBeDefined();
+        expect(uartAsh.ncpSleepEnabled).toStrictEqual(false);
+        expect(uartAsh.ncpHasCallbacks).toStrictEqual(false);
+        expect(uartAsh.txQueue.length).toStrictEqual(0);
+        expect(uartAsh.reTxQueue.length).toStrictEqual(0);
+        expect(uartAsh.txFree.length).toStrictEqual(TX_POOL_BUFFERS);
+        expect(uartAsh.rxQueue.length).toStrictEqual(0);
+        expect(uartAsh.rxFree.length).toStrictEqual(EZSP_HOST_RX_POOL_SIZE);
+        expect(uartAsh.txQueue.tail).toStrictEqual(undefined);
+        expect(uartAsh.reTxQueue.tail).toStrictEqual(undefined);
+        expect(uartAsh.txFree.link).toBeInstanceOf(EzspBuffer);
+        expect(uartAsh.txFree.link!.data.length).toStrictEqual(EZSP_MAX_FRAME_LENGTH);
+        expect(uartAsh.rxQueue.tail).toStrictEqual(undefined);
+        expect(uartAsh.rxFree.link).toBeInstanceOf(EzspBuffer);
+        expect(uartAsh.rxFree.link!.data.length).toStrictEqual(EZSP_MAX_FRAME_LENGTH);
+
+        for (const c in uartAsh.counters) {
+            expect(uartAsh.counters[c]).toStrictEqual(0);
+        }
+
+        // this is mostly Queues testing, but make sure it works in "real" context
+        const link = uartAsh.txFree.link;
+        const buffer = uartAsh.txFree.allocBuffer();
+
+        expect(buffer).toStrictEqual(link);
+        expect(uartAsh.txFree.link).toStrictEqual(buffer!.link);
+        expect(uartAsh.txFree.length).toStrictEqual(TX_POOL_BUFFERS - 1);
+
+        uartAsh.txQueue.addTail(buffer!);
+
+        expect(buffer!.link).toStrictEqual(undefined);
+        expect(uartAsh.txQueue.tail).toStrictEqual(buffer);
+        expect(uartAsh.txQueue.length).toStrictEqual(1);
+
+        const head = uartAsh.txQueue.removeHead();
+
+        expect(head).toStrictEqual(buffer);
+        expect(head).toStrictEqual(link);
+        expect(uartAsh.txQueue.tail).toStrictEqual(undefined);
+        expect(uartAsh.txQueue.length).toStrictEqual(0);
+
+        uartAsh.txFree.freeBuffer(head);
+
+        uartAsh.txQueue.addTail(uartAsh.txFree.allocBuffer()!);
+        uartAsh.txQueue.addTail(uartAsh.txFree.allocBuffer()!);
+
+        expect(uartAsh.txQueue.length).toStrictEqual(2);
+        expect(uartAsh.txFree.length).toStrictEqual(TX_POOL_BUFFERS - 2);
+    });
+
+    it("Reaches CONNECTED state", async () => {
+        //@ts-expect-error private
+        const initPortSpy = vi.spyOn(uartAsh, "initPort");
+        const resetNcpSpy = vi.spyOn(uartAsh, "resetNcp");
+        const sendExecSpy = vi.spyOn(uartAsh, "sendExec");
+        //@ts-expect-error private
+        const onPortCloseSpy = vi.spyOn(uartAsh, "onPortClose");
+        //@ts-expect-error private
+        const onPortErrorSpy = vi.spyOn(uartAsh, "onPortError");
+
+        const resetResult = await uartAsh.resetNcp();
+
+        //@ts-expect-error private
+        expect(uartAsh.serialPort.settings.binding).toBe(MockBinding); // just making sure mock was registered
+        expect(resetResult).toStrictEqual(EzspStatus.SUCCESS);
+        expect(resetNcpSpy).toHaveBeenCalledTimes(1);
+        expect(initPortSpy).toHaveBeenCalledTimes(1);
+        //@ts-expect-error private
+        expect(uartAsh.flags).toStrictEqual(48); // RST|CAN
+        //@ts-expect-error private
+        expect(uartAsh.serialPort).toBeDefined();
+        //@ts-expect-error private
+        expect(uartAsh.writer).toBeDefined();
+        //@ts-expect-error private
+        expect(uartAsh.parser).toBeDefined();
+        expect(uartAsh.portOpen).toBeTruthy();
+
+        //@ts-expect-error private
+        vi.spyOn(uartAsh.serialPort, "asyncFlush").mockImplementationOnce(vi.fn());
+        //@ts-expect-error private
+        uartAsh.serialPort.port.emitData(Buffer.from(RECD_RSTACK_BYTES));
+        const startResult = await uartAsh.start();
+
+        expect(startResult).toStrictEqual(EzspStatus.SUCCESS);
+        expect(sendExecSpy).toHaveBeenCalled();
+        await new Promise(setImmediate); // flush
+        //@ts-expect-error private
+        expect(uartAsh.serialPort.port.recording).toStrictEqual(Buffer.from([...SEND_RST_BYTES, ...ASH_ACK_FIRST_BYTES]));
+        expect(uartAsh.connected).toBeTruthy();
+        expect(uartAsh.counters.txAllFrames).toStrictEqual(2); // RST + ACK
+        expect(uartAsh.counters.txAckFrames).toStrictEqual(1); // post-RSTACK ACK
+        expect(uartAsh.counters.rxAllFrames).toStrictEqual(1); // RSTACK
+
+        for (const key in uartAsh.counters) {
+            if (key !== "txAllFrames" && key !== "rxAllFrames" && key !== "txAckFrames") {
+                expect(uartAsh.counters[key]).toStrictEqual(0);
+            }
+        }
+
+        await uartAsh.stop();
+
+        expect(onPortErrorSpy).toHaveBeenCalledTimes(0);
+        expect(onPortCloseSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it.skip("Resets but failed to start b/c error in RSTACK frame returned by NCP", async () => {
+        //@ts-expect-error private
+        const rejectFrameSpy = vi.spyOn(uartAsh, "rejectFrame");
+        //@ts-expect-error private
+        const receiveFrameSpy = vi.spyOn(uartAsh, "receiveFrame");
+        //@ts-expect-error private
+        const decodeByteSpy = vi.spyOn(uartAsh, "decodeByte");
+
+        const resetResult = await uartAsh.resetNcp();
+
+        expect(resetResult).toStrictEqual(EzspStatus.SUCCESS);
+
+        const badCrcRSTACK = Buffer.from(RECD_RSTACK_BYTES);
+        badCrcRSTACK[badCrcRSTACK.length - 2] = 0; // throw CRC low
+
+        //@ts-expect-error private
+        vi.spyOn(uartAsh.serialPort, "asyncFlush").mockImplementationOnce(vi.fn());
+        //@ts-expect-error private
+        uartAsh.serialPort.port.emitData(badCrcRSTACK);
+        const startResult = await uartAsh.start();
+
+        await wait(10);
+
+        expect(startResult).toStrictEqual(EzspStatus.HOST_FATAL_ERROR);
+        expect(uartAsh.counters.txAllFrames).toStrictEqual(1);
+        expect(uartAsh.counters.rxAllFrames).toStrictEqual(0);
+        expect(uartAsh.counters.rxCrcErrors).toStrictEqual(1);
+        expect(rejectFrameSpy).toHaveBeenCalledTimes(1); // received bad RSTACK
+        expect(decodeByteSpy.mock.results[decodeByteSpy.mock.results.length - 1].value[0]).toStrictEqual(EzspStatus.ASH_BAD_CRC);
+        expect(receiveFrameSpy).toHaveLastReturnedWith(EzspStatus.NO_RX_DATA);
+        expect(uartAsh.connected).toBeFalsy();
+    });
+
+    describe("In CONNECTED state...", () => {
+        beforeEach(async () => {
+            const resetResult = await uartAsh.resetNcp();
+            //@ts-expect-error private
+            vi.spyOn(uartAsh.serialPort, "asyncFlush").mockImplementationOnce(vi.fn());
+            //@ts-expect-error private
+            uartAsh.serialPort.port.emitData(Buffer.from(RECD_RSTACK_BYTES));
+            const startResult = await uartAsh.start();
+
+            expect(resetResult).toStrictEqual(EzspStatus.SUCCESS);
+            expect(startResult).toStrictEqual(EzspStatus.SUCCESS);
+            expect(uartAsh.connected).toBeTruthy();
+
+            uartAsh.sendExec(); // ACK for RSTACK == 8070787e
+            expect(uartAsh.idle).toBeTruthy();
+            expect(uartAsh.counters.txAckFrames).toStrictEqual(1); // ACK for RSTACK
+        });
+        afterEach(async () => {});
+
+        it("Sends DATA frame to NCP", async () => {
+            buffalo.setPosition(EZSP_PARAMETERS_INDEX);
+            buffalo.setCommandByte(EZSP_FRAME_ID_INDEX, lowByte(EzspFrameID.VERSION));
+            buffalo.setCommandByte(EZSP_SEQUENCE_INDEX, frameSequence++);
+            buffalo.setCommandByte(
+                EZSP_EXTENDED_FRAME_CONTROL_LB_INDEX,
+                EZSP_FRAME_CONTROL_COMMAND |
+                    (0x00 & EZSP_FRAME_CONTROL_SLEEP_MODE_MASK) |
+                    ((0x00 << EZSP_FRAME_CONTROL_NETWORK_INDEX_OFFSET) & EZSP_FRAME_CONTROL_NETWORK_INDEX_MASK),
+            );
+            buffalo.writeUInt8(13); // desiredProtocolVersion
+
+            const sendBuf = buffalo.getWritten();
+
+            uartAsh.send(sendBuf.length, sendBuf);
+
+            await wait(10);
+
+            expect(uartAsh.counters.txDataFrames).toStrictEqual(1);
+            //@ts-expect-error private
+            expect(uartAsh.serialPort.port.recording).toStrictEqual(
+                Buffer.concat([
+                    Buffer.from("1ac038bc7e", "hex"), // RST
+                    Buffer.from("8070787e", "hex"), // RSTACK ACK
+                    Buffer.from("004221a8597c057e", "hex"), // DATA
+                ]),
+            );
+        });
+
+        it("Sends DATA frame and receives response from NCP", async () => {
+            buffalo.setPosition(EZSP_PARAMETERS_INDEX);
+            buffalo.setCommandByte(EZSP_FRAME_ID_INDEX, lowByte(EzspFrameID.VERSION));
+            buffalo.setCommandByte(EZSP_SEQUENCE_INDEX, frameSequence++);
+            buffalo.setCommandByte(
+                EZSP_EXTENDED_FRAME_CONTROL_LB_INDEX,
+                EZSP_FRAME_CONTROL_COMMAND |
+                    (0x00 & EZSP_FRAME_CONTROL_SLEEP_MODE_MASK) |
+                    ((0x00 << EZSP_FRAME_CONTROL_NETWORK_INDEX_OFFSET) & EZSP_FRAME_CONTROL_NETWORK_INDEX_MASK),
+            );
+            buffalo.writeUInt8(2); // desiredProtocolVersion
+
+            const sendBuf = buffalo.getWritten();
+
+            uartAsh.send(sendBuf.length, sendBuf);
+
+            await wait(10);
+
+            //@ts-expect-error private
+            uartAsh.serialPort.port.emitData(Buffer.from(SEND_ACK_FIRST_BYTES)); // just an ACK, doesn't matter what it is
+
+            await wait(10); // force wait new frame
+
+            expect(uartAsh.counters.txAckFrames).toStrictEqual(1);
+            expect(uartAsh.counters.rxAckFrames).toStrictEqual(1);
+        });
+
+        it("TODO: Sends DATA frame with NR flags when buffers are low on host", async () => {});
+
+        it("TODO: Sends DATA frame but times out waiting for response", async () => {});
+
+        it("TODO: Resends DATA frame", async () => {});
+
+        it("Allows sending up to TX_K frames before receiving ACK", async () => {
+            buffalo.setPosition(EZSP_PARAMETERS_INDEX);
+            buffalo.setCommandByte(EZSP_FRAME_ID_INDEX, lowByte(EzspFrameID.VERSION));
+            buffalo.setCommandByte(EZSP_SEQUENCE_INDEX, frameSequence++);
+            buffalo.setCommandByte(
+                EZSP_EXTENDED_FRAME_CONTROL_LB_INDEX,
+                EZSP_FRAME_CONTROL_COMMAND |
+                    (0x00 & EZSP_FRAME_CONTROL_SLEEP_MODE_MASK) |
+                    ((0x00 << EZSP_FRAME_CONTROL_NETWORK_INDEX_OFFSET) & EZSP_FRAME_CONTROL_NETWORK_INDEX_MASK),
+            );
+            buffalo.writeUInt8(13); // desiredProtocolVersion
+
+            const sendBuf = buffalo.getWritten();
+
+            for (let i = 0; i <= CONFIG_TX_K; i++) {
+                uartAsh.send(sendBuf.length, sendBuf);
+            }
+
+            await wait(10);
+
+            expect(uartAsh.counters.txDataFrames).toStrictEqual(3);
+            expect(uartAsh.txQueue.length).toStrictEqual(1);
+
+            //@ts-expect-error private
+            expect(uartAsh.serialPort.port.recording).toStrictEqual(
+                Buffer.concat([
+                    Buffer.from("1ac038bc7e", "hex"), // RST
+                    Buffer.from("8070787e", "hex"), // RSTACK ACK
+                    Buffer.from("004221a8597c057e", "hex"), // DATA 1
+                    Buffer.from("104221a859785f7e", "hex"), // DATA 2
+                    Buffer.from("204221a85974b17e", "hex"), // DATA 3
+                ]),
+            );
+        });
+    });
+});

package/test/adapter/ember/consts.ts

@@ -0,0 +1,131 @@
+import {ASH_VERSION} from "../../../src/adapter/ember/uart/consts";
+import {AshFrameType, AshReservedByte, NcpFailedCode} from "../../../src/adapter/ember/uart/enums";
+
+export const adapterSONOFFDongleE = {manufacturer: "ITEAD", vendorId: "1a86", productId: "55d4"};
+export const adapterHASkyConnect = {manufacturer: "Nabu Casa", vendorId: "10c4", productId: "ea60"};
+
+/**
+ * Bytes sent to NCP on init
+ *
+ * 1ac038bc7e
+ */
+export const SEND_RST_BYTES = [
+    AshReservedByte.CANCEL, // 26 - 0x1a
+    AshFrameType.RST, // 192 - 0xc0
+    56, // CRC high - 0x38
+    188, // CRC low - 0xbc
+    AshReservedByte.FLAG, // 126 - 0x7e
+];
+
+/**
+ * Pre-decoding values.
+ *
+ * [193, 2, 2, 155, 123, 126]
+ *
+ * 1ac1020b0a527e
+ */
+export const RECD_RSTACK_BYTES = [
+    AshReservedByte.CANCEL, // 26 - 0x1a
+    AshFrameType.RSTACK, // 193 - 0xc1
+    ASH_VERSION, // 2 - 0x02
+    NcpFailedCode.RESET_SOFTWARE, // 11 - 0x0b
+    10, // CRC high - 0x0a
+    82, // CRC low - 0x52
+    AshReservedByte.FLAG, // 126 - 0x7e
+];
+
+/**
+ * ACK following first DATA frame sent.
+ *
+ * ACK(1)+
+ */
+export const SEND_ACK_FIRST_BYTES = [
+    AshFrameType.ACK + 1,
+    0x60, // CRC High
+    0x59, // CRC Low
+    AshReservedByte.FLAG,
+];
+
+/**
+ * ACK sent by ASH (Z2M) after RSTACK received.
+ *
+ * ACK(0)+
+ */
+export const ASH_ACK_FIRST_BYTES = [
+    AshFrameType.ACK,
+    0x70, // CRC High
+    0x78, // CRC Low
+    AshReservedByte.FLAG,
+];
+
+/**
+ * Pre-decoding values.
+ *
+ * [194, 2, 81, 168, 189, 126]
+ *
+ * c20251a8bd7e
+ */
+export const RECD_ERROR_ACK_TIMEOUT_BYTES = [
+    AshFrameType.ERROR,
+    ASH_VERSION,
+    NcpFailedCode.ERROR_EXCEEDED_MAXIMUM_ACK_TIMEOUT_COUNT,
+    0xa8, // CRC High
+    0xbd, // CRC Low
+    AshReservedByte.FLAG,
+];
+
+export const RCED_ERROR_WATCHDOG_BYTES = [
+    AshFrameType.ERROR,
+    ASH_VERSION,
+    NcpFailedCode.RESET_WATCHDOG,
+    0xd2, // CRC High
+    0x0a, // CRC Low
+    AshReservedByte.FLAG,
+];
+
+export const RCED_DATA_WITH_CRC_ERROR = Buffer.from("b658904124ab5593499cdd93623cd29874f5de5083f97b1e66efc9af417e", "hex");
+
+export const RCED_DATA_RETRY = Buffer.from("0eafb1a96b2a7d334fa674eb04aaa760499d4e27cdd9ce6192f2c46989fcfb817e", "hex");
+
+/** desiredProtocolVersion: 13 */
+export const SEND_DATA_VERSION = Buffer.from("004221a8597c057e", "hex");
+/** protocolVersion: 13, stackType: 2, stackVersion: 29712 */
+export const RCED_DATA_VERSION = Buffer.from("0142a1a8592805c6a8777e", "hex");
+export const RCED_DATA_VERSION_RES = [13, 2, 29712];
+
+// [ZCL to=51678 apsFrame={"profileId":260,"clusterId":6,"sourceEndpoint":1,"destinationEndpoint":1,"options":4416,"groupId":0,"sequence":0} header={"frameControl":{"reservedBits":0,"frameType":1,"direction":0,"disableDefaultResponse":false,"manufacturerSpecific":false},"manufacturerCode":null,"transactionSequenceNumber":4,"commandIdentifier":0}]
+// [FRAME: ID=52:"SEND_UNICAST" Seq=39 Len=25]
+// [FRAME type=DATA frmTx=7 frmRx=0]
+export const SEND_UNICAST_ASH_RAW = "706521a9602a156c90904b23aa5493098d4e27abeece648af9c677b97e";
+// [FRAME type=DATA ackNum=0 frmNum=0]
+export const SEND_UNICAST_REPLY_FN0_ASH_RAW = "0065a1a9602a15b25994d0954c7e";
+// [FRAME: ID=52:"SEND_UNICAST" Seq=39 Len=10]
+// [SENT type=DIRECT apsSequence=154 messageTag=3 status=OK]
+export const SEND_UNICAST_REPLY_FN0_EZSP = "2780013400000000009a";
+
+// [FRAME type=DATA ackNum=0 frmNum=1]
+export const MESSAGE_SENT_HANDLER_FN1_ASH_RAW = "1065b1a96b2a15b259944afb6351934f9c4f26ebfcce677d31fec66357897e";
+// [CBFRAME: ID=63:"MESSAGE_SENT_HANDLER" Seq=39 Len=26]
+// ezspMessageSentHandler(): callback called with: [status=OK], [type=DIRECT], [indexOrDestination=51678], [apsFrame={"profileId":260,"clusterId":6,"sourceEndpoint":1,"destinationEndpoint":1,"options":4416,"groupId":0,"sequence":154}], [messageTag=3]
+export const MESSAGE_SENT_HANDLER_FN1_EZSP = "2790013f000000000000dec9040106000101401100009a030000";
+
+// [FRAME type=DATA ackNum=0 frmNum=2]
+export const INCOMING_MESSAGE_HANDLER_FN2_ASH_RAW = "2065b1a97d312a15b658924a24ab5593499c3ef962edce678bfdc6638903813ca7edcdde6f8ae7c3d0d5d26b68937e";
+// [CBFRAME: ID=69:"INCOMING_MESSAGE_HANDLER" Seq=39 Len=42]
+// ezspIncomingMessageHandler(): callback called with: [type=UNICAST], [apsFrame={"profileId":260,"clusterId":6,"sourceEndpoint":1,"destinationEndpoint":1,"options":256,"groupId":0,"sequence":112}], [packetInfo:{"senderShortId":51678,"senderLongId":"0x0000000000000000","bindingIndex":255,"addressIndex":255,"lastHopLqi":3,"lastHopRssi":0,"lastHopTimestamp":6}], [messageContents=18040b0000]
+// Received payload: clusterID=6, address=51678, groupID=0, endpoint=1, destinationEndpoint=1, wasBroadcast=false, linkQuality=3, frame={"header":{"frameControl":{"frameType":0,"manufacturerSpecific":false,"direction":1,"disableDefaultResponse":true,"reservedBits":0},"manufacturerCode":null,"transactionSequenceNumber":4,"commandIdentifier":11},"payload":{"cmdId":0,"statusCode":0},"command":{"ID":11,"name":"defaultRsp","parameters":[{"name":"cmdId","type":32},{"name":"statusCode","type":32}]}}
+export const INCOMING_MESSAGE_HANDLER_FN2_EZSP = "2790014500000401060001010001000070dec90000000000000000ffff0300060000000518040b000002";
+
+// [FRAME type=DATA ackNum=0 frmNum=0]
+export const MESSAGE_SENT_HANDLER_FN0_ASH_RAW = "0065b1a96b2a15b259944afb6351934f9c4f26ebfcce6766fec66302907e";
+// [CBFRAME: ID=63:"MESSAGE_SENT_HANDLER" Seq=39 Len=26]
+// ezspMessageSentHandler(): callback called with: [status=OK], [type=DIRECT], [indexOrDestination=51678], [apsFrame={"profileId":260,"clusterId":6,"sourceEndpoint":1,"destinationEndpoint":1,"options":4416,"groupId":0,"sequence":237}], [messageTag=3]
+export const MESSAGE_SENT_HANDLER_FN0_EZSP = "2790013f000000000000dec904010600010140110000ed030000";
+
+// [FRAME: ID=85:"SET_POLICY" Seq=79 Len=7]
+// [FRAME type=DATA frmTx=7 frmRx=0]
+export const SET_POLICY_ASH_RAW = "700d21a9012a15b0f5667e";
+// [FRAME type=DATA ackNum=0 frmNum=1]
+export const SET_POLICY_REPLY_FN1_ASH_RAW = "100da1a9012a15b259944fb87e";
+// [FRAME: ID=85:"SET_POLICY" Seq=79 Len=9]
+export const SET_POLICY_REPLY_FN1_EZSP = "4f8001550000000000";