zigbee-herdsman 4.1.1 → 4.2.0

package/src/adapter/deconz/driver/frameParser.ts

@@ -1,128 +1,129 @@
 /* v8 ignore start */
 
 import {EventEmitter} from "node:events";
-
+import {Buffalo} from "../../../buffalo";
 import {logger} from "../../../utils/logger";
 import * as Zdo from "../../../zspec/zdo";
-import PARAM, {
+import {
+    ApsAddressMode,
+    type ApsRequest,
+    ApsStatusCode,
     type Command,
+    CommandStatus,
     type DataStateResponse,
+    FirmwareCommand,
     type GpDataInd,
-    type ParamChannel,
-    type ParamChannelMask,
-    type ParamExtPanId,
-    type ParamMac,
-    type ParamNwkAddr,
-    type ParamPanId,
-    type ParamPermitJoin,
+    ParamId,
     type ReceivedDataResponse,
     type Request,
 } from "./constants";
-import {apsBusyQueue, busyQueue, enableRTS, enableRtsTimeout} from "./driver";
+import {apsBusyQueue, busyQueue} from "./driver";
 
 const NS = "zh:deconz:frameparser";
 
-const MIN_BUFFER_SIZE = 3;
 const littleEndian = true;
 const lastReceivedGpInd = {srcId: 0, commandId: 0, frameCounter: 0};
 export const frameParserEvents = new EventEmitter();
 
 function parseReadParameterResponse(view: DataView): Command | null {
+    const seqNumber = view.getUint8(1);
+    const status = view.getUint8(2);
     const parameterId = view.getUint8(7);
+    let pos = 8;
+    let result = null;
 
     switch (parameterId) {
-        case PARAM.PARAM.Network.MAC: {
-            const mac: ParamMac = view.getBigUint64(8, littleEndian).toString(16);
-            let result = mac;
-            while (result.length < 16) {
-                result = `0${result}`;
-            }
-            result = `0x${result}`;
-            logger.debug(`MAC: ${result}`, NS);
-            return result;
+        case ParamId.MAC_ADDRESS: {
+            result = view.getBigUint64(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.PAN_ID: {
-            const panId: ParamPanId = view.getUint16(8, littleEndian);
-            logger.debug(`PANID: ${panId.toString(16)}`, NS);
-            return panId;
+        case ParamId.APS_TRUST_CENTER_ADDRESS: {
+            result = view.getBigUint64(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.NWK_ADDRESS: {
-            const nwkAddr: ParamNwkAddr = view.getUint16(8, littleEndian);
-            logger.debug(`NWKADDR: ${nwkAddr.toString(16)}`, NS);
-            return nwkAddr;
+        case ParamId.NWK_PANID: {
+            result = view.getUint16(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.EXT_PAN_ID: {
-            const extPanId: ParamExtPanId = view.getBigUint64(8, littleEndian).toString(16);
-            let res = extPanId;
-            while (res.length < 16) {
-                res = `0${res}`;
-            }
-            res = `0x${res}`;
-            logger.debug(`EXT_PANID: ${res}`, NS);
-            return res;
+        case ParamId.STK_PROTOCOL_VERSION: {
+            result = view.getUint16(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.APS_EXT_PAN_ID: {
-            const apsExtPanId: ParamExtPanId = view.getBigUint64(8, littleEndian).toString(16);
-            let resAEPID = apsExtPanId;
-            while (resAEPID.length < 16) {
-                resAEPID = `0${resAEPID}`;
-            }
-            resAEPID = `0x${resAEPID}`;
-            logger.debug(`APS_EXT_PANID: ${resAEPID}`, NS);
-            return resAEPID;
+        case ParamId.NWK_NETWORK_ADDRESS: {
+            result = view.getUint16(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.NETWORK_KEY: {
-            const networkKey1 = view.getBigUint64(9).toString(16);
-            let res1 = networkKey1;
-            while (res1.length < 16) {
-                res1 = `0${res1}`;
-            }
-            const networkKey2 = view.getBigUint64(17).toString(16);
-            let res2 = networkKey2;
-            while (res2.length < 16) {
-                res2 = `0${res2}`;
+        case ParamId.NWK_EXTENDED_PANID: {
+            result = view.getBigUint64(pos, littleEndian);
+            break;
+        }
+        case ParamId.APS_USE_EXTENDED_PANID: {
+            result = view.getBigUint64(pos, littleEndian);
+            break;
+        }
+        case ParamId.STK_NETWORK_KEY: {
+            result = Buffer.alloc(16);
+            pos += 1; // key index
+            for (let i = 0; i < 16; i++) {
+                result[i] = view.getUint8(pos);
+                pos += 1;
             }
-            logger.debug("NETWORK_KEY: hidden", NS);
-            return `0x${res1}${res2}`;
+            break;
+        }
+        case ParamId.STK_CURRENT_CHANNEL: {
+            result = view.getUint8(pos);
+            break;
+        }
+        case ParamId.APS_CHANNEL_MASK: {
+            result = view.getUint32(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.CHANNEL: {
-            const channel: ParamChannel = view.getUint8(8);
-            logger.debug(`CHANNEL: ${channel}`, NS);
-            return channel;
+        case ParamId.STK_FRAME_COUNTER: {
+            result = view.getUint32(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.CHANNEL_MASK: {
-            const chMask: ParamChannelMask = view.getUint32(8, littleEndian);
-            logger.debug(`CHANNELMASK: ${chMask.toString(16)}`, NS);
-            return chMask;
+        case ParamId.STK_PERMIT_JOIN: {
+            result = view.getUint8(pos);
+            break;
         }
-        case PARAM.PARAM.Network.PERMIT_JOIN: {
-            const permitJoin: ParamPermitJoin = view.getUint8(8);
-            logger.debug(`PERMIT_JOIN: ${permitJoin}`, NS);
-            return permitJoin;
+        case ParamId.DEV_WATCHDOG_TTL: {
+            result = view.getUint32(pos, littleEndian);
+            break;
         }
-        case PARAM.PARAM.Network.WATCHDOG_TTL: {
-            const ttl: ParamPermitJoin = view.getUint32(8);
-            logger.debug(`WATCHDOG_TTL: ${ttl}`, NS);
-            return ttl;
+        case ParamId.STK_NWK_UPDATE_ID: {
+            result = view.getUint8(pos);
+            break;
         }
         default:
             //throw new Error(`unknown parameter id ${parameterId}`);
             logger.debug(`unknown parameter id ${parameterId}`, NS);
-            return null;
+            break;
+    }
+
+    if (parameterId in ParamId) {
+        let p: Command | string | null = result;
+        if (parameterId === ParamId.STK_NETWORK_KEY) {
+            // don't show in logs
+            p = "<hidden>";
+        } else if (typeof result === "bigint") {
+            p = `0x${result.toString(16).padStart(16, "0")}`;
+        }
+        logger.debug(`Received read parameter response for ${ParamId[parameterId]}, seq: ${seqNumber}, status: ${status}, parameter: ${p}`, NS);
     }
+
+    return result;
 }
 
-function parseReadFirmwareResponse(view: DataView): number[] {
-    const fw = [view.getUint8(5), view.getUint8(6), view.getUint8(7), view.getUint8(8)];
-    logger.debug(`read firmware version response - version: ${fw}`, NS);
+function parseReadFirmwareResponse(view: DataView): number {
+    const fw = view.getUint32(5, littleEndian);
+    logger.debug(`read firmware version response - version: 0x${fw.toString(16)}`, NS);
     return fw;
 }
 
 function parseDeviceStateResponse(view: DataView): number {
-    const flag = view.getUint8(5);
-    logger.debug(`device state: ${flag.toString(2)}`, NS);
-    frameParserEvents.emit("receivedDataNotification", flag);
-    return flag;
+    const deviceState = view.getUint8(5);
+    frameParserEvents.emit("deviceStateUpdated", deviceState);
+    return deviceState;
 }
 
 function parseChangeNetworkStateResponse(view: DataView): number {
@@ -132,192 +133,229 @@ function parseChangeNetworkStateResponse(view: DataView): number {
     return state;
 }
 
-function parseQuerySendDataStateResponse(view: DataView): DataStateResponse | null {
-    try {
-        const commandId = view.getUint8(0);
-        const seqNr = view.getUint8(1);
-        const status = view.getUint8(2);
+function parseApsConfirmResponse(view: DataView): DataStateResponse | null {
+    const buf = new Buffalo(Buffer.from(view.buffer));
 
-        if (status !== 0) {
-            if (status !== 5) {
-                logger.debug(`DATA_CONFIRM RESPONSE - seqNr.: ${seqNr} status: ${status}`, NS);
-            }
+    const commandId = buf.readUInt8();
+    const seqNr = buf.readUInt8();
+    const status = buf.readUInt8();
 
-            return null;
-        }
+    if (status !== CommandStatus.Success) {
+        logger.debug(`Response APS-DATA.confirm seq: ${seqNr} status: ${CommandStatus[status]} (error)`, NS);
+        return null;
+    }
 
-        const frameLength = 7;
-        const payloadLength = view.getUint16(5, littleEndian);
-        const deviceState = view.getUint8(7);
-        const requestId = view.getUint8(8);
-        const destAddrMode = view.getUint8(9);
+    const frameLength = buf.readUInt16();
+    const payloadLength = buf.readUInt16();
+    // payload
+    const deviceState = buf.readUInt8();
+    const requestId = buf.readUInt8();
+    const destAddrMode = buf.readUInt8();
+
+    let destAddr64: string | undefined;
+    let destAddr16: number | undefined;
+    let destEndpoint: number | undefined;
+    let destAddr = "";
+
+    if (destAddrMode === ApsAddressMode.Nwk) {
+        destAddr16 = buf.readUInt16();
+        destAddr = destAddr16.toString(16).padStart(4, "0");
+        destEndpoint = buf.readUInt8();
+    } else if (destAddrMode === ApsAddressMode.Group) {
+        destAddr16 = buf.readUInt16();
+        destAddr = destAddr16.toString(16).padStart(4, "0");
+    } else if (destAddrMode === ApsAddressMode.Ieee) {
+        destAddr64 = buf.readUInt64().toString(16).padStart(16, "0");
+        destAddr = destAddr64;
+        destEndpoint = buf.readUInt8();
+    } else {
+        logger.debug(`Response APS-DATA.confirm seq: ${seqNr} unsupported address mode: ${destAddrMode}`, NS);
+    }
 
-        let destAddr64: string | undefined;
-        let destAddr16: number | undefined;
-        let destEndpoint: number | undefined;
-        let destAddr = "";
+    const srcEndpoint = buf.readUInt8();
+    const confirmStatus = buf.readUInt8();
 
-        if (destAddrMode === PARAM.PARAM.addressMode.IEEE_ADDR) {
-            let res = view.getBigUint64(10, littleEndian).toString(16);
-            while (res.length < 16) {
-                res = `0${res}`;
-            }
-            destAddr64 = res;
-            // const buf2 = view.buffer.slice(18, view.buffer.byteLength);
-            destAddr = destAddr64;
-        } else {
-            destAddr16 = view.getUint16(10, littleEndian);
-            // const buf2 = view.buffer.slice(12, view.buffer.byteLength);
-            destAddr = destAddr16.toString(16);
-        }
+    // resolve APS-DATA.request promise
+    const i = apsBusyQueue.findIndex((r: ApsRequest) => r.request && r.request.requestId === requestId);
 
-        if (destAddrMode === PARAM.PARAM.addressMode.NWK_ADDR || destAddrMode === PARAM.PARAM.addressMode.IEEE_ADDR) {
-            destEndpoint = view.getUint8(view.byteLength - 7);
-        }
+    if (i < 0) {
+        return null;
+    }
 
-        const srcEndpoint = view.getUint8(view.byteLength - 6);
-        const confirmStatus = view.getInt8(view.byteLength - 5);
+    const req: ApsRequest = apsBusyQueue[i];
 
-        let newStatus = deviceState.toString(2);
+    let strstatus = "unknown";
+    const hexstatus = `0x${confirmStatus.toString(16).padStart(2, "0")}`;
+    if (confirmStatus in ApsStatusCode) {
+        strstatus = ApsStatusCode[confirmStatus];
+    }
 
-        for (let l = 0; l <= 8 - newStatus.length; l++) {
-            newStatus = `0${newStatus}`;
-        }
+    if (confirmStatus === ApsStatusCode.Success) {
+        req.resolve(confirmStatus);
+    } else {
+        req.reject(new Error(`Failed APS-DATA.request with confirm status: ${strstatus} (${hexstatus})`));
+    }
 
-        // resolve send data request promise
-        const i = apsBusyQueue.findIndex((r: Request) => r.request && r.request.requestId === requestId);
+    //remove from busyqueue
+    apsBusyQueue.splice(i, 1);
+
+    logger.debug(`APS-DATA.confirm  destAddr: 0x${destAddr} APS request id: ${requestId} confirm status: ${strstatus} ${hexstatus}`, NS);
+    frameParserEvents.emit("deviceStateUpdated", deviceState);
+
+    return {
+        commandId,
+        seqNr,
+        status,
+        frameLength,
+        payloadLength,
+        deviceState,
+        requestId,
+        destAddrMode,
+        destAddr16,
+        destAddr64,
+        destEndpoint,
+        srcEndpoint,
+        confirmStatus,
+    };
+}
 
-        if (i < 0) {
-            return null;
-        }
+// TODO(mpi): The ../buffalo/buffalo.ts already provides this, so we should reuse it instead of a own implementation?!
+class UDataView {
+    littleEndian = true;
+    pos = 0;
+    view: DataView;
+    constructor(view: DataView, littleEndian: boolean) {
+        this.view = view;
+        this.littleEndian = littleEndian;
+    }
 
-        clearTimeout(enableRtsTimeout);
-        enableRTS(); // enable ReadyToSend because confirm received
-        const req: Request = apsBusyQueue[i];
+    getI8(): number {
+        if (this.pos + 1 <= this.view.byteLength) {
+            this.pos += 1;
+            return this.view.getInt8(this.pos - 1);
+        }
+        throw new RangeError();
+    }
 
-        // TODO timeout (at driver.ts)
-        if (confirmStatus !== 0) {
-            // reject if status is not SUCCESS
-            //logger.debug("REJECT APS_REQUEST - request id: " + requestId + " confirm status: " + confirmStatus, NS);
-            req.reject(new Error(`confirmStatus=${confirmStatus}`));
-        } else {
-            //logger.debug("RESOLVE APS_REQUEST - request id: " + requestId + " confirm status: " + confirmStatus, NS);
-            req.resolve(confirmStatus);
+    getU8(): number {
+        if (this.pos + 1 <= this.view.byteLength) {
+            this.pos += 1;
+            return this.view.getUint8(this.pos - 1);
         }
+        throw new RangeError();
+    }
 
-        //remove from busyqueue
-        apsBusyQueue.splice(i, 1);
+    getU16(): number {
+        if (this.pos + 2 <= this.view.byteLength) {
+            this.pos += 2;
+            return this.view.getUint16(this.pos - 2, this.littleEndian);
+        }
+        throw new RangeError();
+    }
 
-        logger.debug(`DATA_CONFIRM RESPONSE - destAddr: 0x${destAddr} request id: ${requestId} confirm status: ${confirmStatus}`, NS);
-        frameParserEvents.emit("receivedDataNotification", deviceState);
+    getU32(): number {
+        if (this.pos + 4 <= this.view.byteLength) {
+            this.pos += 4;
+            return this.view.getUint16(this.pos - 4, this.littleEndian);
+        }
+        throw new RangeError();
+    }
 
-        return {
-            commandId,
-            seqNr,
-            status,
-            frameLength,
-            payloadLength,
-            deviceState,
-            requestId,
-            destAddrMode,
-            destAddr16,
-            destAddr64,
-            destEndpoint,
-            srcEndpoint,
-            confirmStatus,
-        };
-    } catch (error) {
-        logger.debug(`DATA_CONFIRM RESPONSE - ${error}`, NS);
-        return null;
+    getU64(): bigint {
+        if (this.pos + 8 <= this.view.byteLength) {
+            this.pos += 8;
+            return this.view.getBigUint64(this.pos - 8, this.littleEndian);
+        }
+        throw new RangeError();
     }
 }
 
-function parseReadReceivedDataResponse(view: DataView): ReceivedDataResponse | null {
+function parseApsDataIndicationResponse(inview: DataView): ReceivedDataResponse | null {
     // min 28 bytelength
     try {
-        let buf2: ArrayBuffer;
-        let buf3: ArrayBuffer;
+        const uview = new UDataView(inview, true);
 
-        const commandId = view.getUint8(0);
-        const seqNr = view.getUint8(1);
-        const status = view.getUint8(2);
+        const commandId = uview.getU8();
+        const seqNr = uview.getU8();
+        const status = uview.getU8();
 
-        if (status !== 0) {
-            if (status !== 5) {
-                logger.debug(`DATA_INDICATION RESPONSE - seqNr.: ${seqNr} status: ${status}`, NS);
-            }
+        if (status !== CommandStatus.Success) {
+            logger.debug(`Response APS-DATA.indication seq: ${seqNr} status: ${CommandStatus[status]}`, NS);
             return null;
         }
 
-        const frameLength = view.getUint16(3, littleEndian);
-        const payloadLength = view.getUint16(5, littleEndian);
-        const deviceState = view.getUint8(7);
-        const destAddrMode = view.getUint8(8);
+        const frameLength = uview.getU16();
+        const payloadLength = uview.getU16();
+        //------ start of payload ----------------------------------
+        const deviceState = uview.getU8();
+        const destAddrMode = uview.getU8();
 
         let destAddr64: string | undefined;
         let destAddr16: number | undefined;
-        let destAddr = "";
+        let destAddr: string | number;
 
-        if (destAddrMode === PARAM.PARAM.addressMode.IEEE_ADDR) {
-            let res = view.getBigUint64(9, littleEndian).toString(16);
-            while (res.length < 16) {
-                res = `0${res}`;
-            }
-            destAddr64 = res;
-            buf2 = view.buffer.slice(17, view.buffer.byteLength);
+        if (destAddrMode === ApsAddressMode.Ieee) {
+            destAddr64 = uview.getU64().toString(16).padStart(16, "0");
+            destAddr16 = 0xfffe;
             destAddr = destAddr64;
-        } else {
-            destAddr16 = view.getUint16(9, littleEndian);
-            buf2 = view.buffer.slice(11, view.buffer.byteLength);
+        } else if (destAddrMode === ApsAddressMode.Nwk || destAddrMode === ApsAddressMode.Group) {
+            destAddr16 = uview.getU16();
             destAddr = destAddr16.toString(16);
+        } else {
+            throw new Error(`unsupported destination address mode: ${destAddrMode}`);
         }
 
-        view = new DataView(buf2);
-        const destEndpoint = view.getUint8(0);
-        const srcAddrMode = view.getUint8(1);
+        const destEndpoint = uview.getU8();
+        const srcAddrMode = uview.getU8();
 
         let srcAddr64: string | undefined;
-        let srcAddr16: number | undefined;
-        let srcAddr = "";
+        let srcAddr16 = 0xfffe;
+        let srcAddr: string | number;
 
-        if (srcAddrMode === PARAM.PARAM.addressMode.NWK_ADDR || srcAddrMode === 0x04) {
-            srcAddr16 = view.getUint16(2, littleEndian);
-            buf3 = view.buffer.slice(4, view.buffer.byteLength);
+        if (srcAddrMode === ApsAddressMode.Nwk || srcAddrMode === ApsAddressMode.NwkAndIeee) {
+            srcAddr16 = uview.getU16();
             srcAddr = srcAddr16.toString(16);
-        }
 
-        if (srcAddrMode === PARAM.PARAM.addressMode.IEEE_ADDR || srcAddrMode === 0x04) {
-            let res = view.getBigUint64(2, littleEndian).toString(16);
-            while (res.length < 16) {
-                res = `0${res}`;
+            if (srcAddrMode === ApsAddressMode.NwkAndIeee) {
+                srcAddr64 = uview.getU64().toString(16).padStart(16, "0");
             }
-            srcAddr64 = res;
-            buf3 = view.buffer.slice(10, view.buffer.byteLength);
-            srcAddr = srcAddr64;
+        } else {
+            throw new Error(`unsupported source address mode: ${srcAddrMode}`);
+        }
+        //  else if (srcAddrMode === PARAM.PARAM.addressMode.IEEE_ADDR) {
+        //     srcAddr64 = uview.getU64().toString(16).padStart(16, '0');
+        //     srcAddr = srcAddr64;
+        // }
+
+        const srcEndpoint = uview.getU8();
+        const profileId = uview.getU16();
+        const clusterId = uview.getU16();
+        const asduLength = uview.getU16();
+        const asdu = new Uint8Array(asduLength);
+        for (let i = 0; i < asduLength; i++) {
+            asdu[i] = uview.getU8();
         }
 
-        // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-        view = new DataView(buf3!); // XXX: not validated?
-        const srcEndpoint = view.getUint8(0);
-        const profileId = view.getUint16(1, littleEndian);
-        const clusterId = view.getUint16(3, littleEndian);
-        const asduLength = view.getUint16(5, littleEndian);
-        const asduPayload = Buffer.from(view.buffer.slice(7, asduLength + 7));
-        const lqi = view.getUint8(view.byteLength - 8);
-        const rssi = view.getInt8(view.byteLength - 3);
+        // The following two bytes depends on protocol version 2 or 3
+        // for now just discard
+        uview.getU16();
 
-        let newStatus = deviceState.toString(2);
+        const lqi = uview.getU8();
 
-        for (let l = 0; l <= 8 - newStatus.length; l++) {
-            newStatus = `0${newStatus}`;
-        }
+        // version >= 2
+        let rssi = 0;
+        try {
+            rssi = uview.getI8();
+        } catch (_) {}
 
         logger.debug(
-            `DATA_INDICATION RESPONSE - seqNr. ${seqNr} srcAddr: 0x${srcAddr} destAddr: 0x${destAddr} profile id: 0x${profileId.toString(16)} cluster id: 0x${clusterId.toString(16)} lqi: ${lqi}`,
+            `Response APS-DATA.indication seq: ${seqNr} srcAddr: 0x${srcAddr} destAddr: 0x${destAddr} profile id: 0x${profileId.toString(16).padStart(4, "0")} cluster id: 0x${clusterId.toString(16).padStart(4, "0")} lqi: ${lqi}`,
             NS,
         );
-        logger.debug(`response payload: ${asduPayload.toString("hex")}`, NS);
-        frameParserEvents.emit("receivedDataNotification", deviceState);
+        //logger.debug(`Response payload: [${Array.from(asdu).map(x =>x.toString(16).padStart(2, '0')).join(' ')}]`, NS);
+        frameParserEvents.emit("deviceStateUpdated", deviceState);
+
+        const asduPayload = Buffer.from(asdu);
 
         const response: ReceivedDataResponse = {
             commandId,
@@ -346,18 +384,18 @@ function parseReadReceivedDataResponse(view: DataView): ReceivedDataResponse | n
         frameParserEvents.emit("receivedDataPayload", response);
         return response;
     } catch (error) {
-        logger.debug(`DATA_INDICATION RESPONSE - ${error}`, NS);
+        logger.debug(`Response APS-DATA.indication error: ${error}`, NS);
         return null;
     }
 }
 
-function parseEnqueueSendDataResponse(view: DataView): number | null {
+function parseApsDataRequestResponse(view: DataView): number | null {
     try {
         const status = view.getUint8(2);
         const requestId = view.getUint8(8);
         const deviceState = view.getUint8(7);
-        logger.debug(`DATA_REQUEST RESPONSE - request id: ${requestId} status: ${status}`, NS);
-        frameParserEvents.emit("receivedDataNotification", deviceState);
+        logger.debug(`Response APS-DATA.request APS request id: ${requestId} status: ${CommandStatus[status]}`, NS);
+        frameParserEvents.emit("deviceStateUpdated", deviceState);
         return deviceState;
     } catch (error) {
         logger.debug(`parseEnqueueSendDataResponse - ${error}`, NS);
@@ -367,8 +405,14 @@ function parseEnqueueSendDataResponse(view: DataView): number | null {
 
 function parseWriteParameterResponse(view: DataView): number | null {
     try {
+        const status = view.getUint8(2);
         const parameterId = view.getUint8(7);
-        logger.debug(`write parameter response - parameter id: ${parameterId} - status: ${view.getUint8(2)}`, NS);
+
+        if (parameterId in ParamId) {
+            // should always be true
+            logger.debug(`Write parameter response parameter: ${ParamId[parameterId]}, status: ${CommandStatus[status]}`, NS);
+        }
+
         return parameterId;
     } catch (error) {
         logger.debug(`parseWriteParameterResponse - ${error}`, NS);
@@ -376,14 +420,13 @@ function parseWriteParameterResponse(view: DataView): number | null {
     }
 }
 
-function parseReceivedDataNotification(view: DataView): number | null {
+function parseDeviceStateChangedNotification(view: DataView): number | null {
     try {
         const deviceState = view.getUint8(5);
-        logger.debug(`DEVICE_STATE changed: ${deviceState.toString(2)}`, NS);
-        frameParserEvents.emit("receivedDataNotification", deviceState);
+        frameParserEvents.emit("deviceStateUpdated", deviceState);
         return deviceState;
     } catch (error) {
-        logger.debug(`parseReceivedDataNotification - ${error}`, NS);
+        logger.debug(`parsedeviceStateUpdated - ${error}`, NS);
         return null;
     }
 }
@@ -455,44 +498,80 @@ function parseGreenPowerDataIndication(view: DataView): GpDataInd | null {
 }
 function parseMacPollCommand(_view: DataView): number {
     //logger.debug("Received command MAC_POLL", NS);
-    return 28;
+    return FirmwareCommand.MacPollIndication;
 }
 function parseBeaconRequest(_view: DataView): number {
     logger.debug("Received Beacon Request", NS);
-    return 31;
+    return FirmwareCommand.Beacon;
+}
+
+function parseDebugLog(view: DataView): null {
+    let dbg = "";
+    const buf = new Buffalo(Buffer.from(view.buffer));
+
+    /* const commandId = */ buf.readUInt8();
+    /* const seqNr = */ buf.readUInt8();
+    const status = buf.readUInt8();
+
+    if (status !== CommandStatus.Success) {
+        // unlikely
+        return null;
+    }
+
+    /* const frameLength = */ buf.readUInt16();
+    const payloadLength = buf.readUInt16();
+
+    for (let i = 0; i < payloadLength && buf.isMore(); i++) {
+        const ch = buf.readUInt8();
+        if (ch >= 32 && ch <= 127) {
+            dbg += String.fromCharCode(ch);
+        }
+    }
+
+    if (dbg.length !== 0) {
+        logger.debug(`firmware log: ${dbg}`, NS);
+    }
+
+    return null;
 }
 
 function parseUnknownCommand(view: DataView): number {
     const id = view.getUint8(0);
-    logger.debug(`received unknown command - id ${id}`, NS);
+    if (id in FirmwareCommand) {
+        logger.debug(`received unsupported command: ${FirmwareCommand[id]} id: 0x${id.toString(16).padStart(2, "0")}`, NS);
+    } else {
+        logger.debug(`received unknown command: id: 0x${id.toString(16).padStart(2, "0")}`, NS);
+    }
     return id;
 }
 function getParserForCommandId(id: number): (view: DataView) => Command | object | number | null {
     switch (id) {
-        case PARAM.PARAM.FrameType.ReadParameter:
+        case FirmwareCommand.ReadParameter:
             return parseReadParameterResponse;
-        case PARAM.PARAM.FrameType.WriteParameter:
+        case FirmwareCommand.WriteParameter:
             return parseWriteParameterResponse;
-        case PARAM.PARAM.FrameType.ReadFirmwareVersion:
+        case FirmwareCommand.FirmwareVersion:
             return parseReadFirmwareResponse;
-        case PARAM.PARAM.FrameType.ReadDeviceState:
+        case FirmwareCommand.Status:
             return parseDeviceStateResponse;
-        case PARAM.PARAM.APS.DATA_INDICATION:
-            return parseReadReceivedDataResponse;
-        case PARAM.PARAM.APS.DATA_REQUEST:
-            return parseEnqueueSendDataResponse;
-        case PARAM.PARAM.APS.DATA_CONFIRM:
-            return parseQuerySendDataStateResponse;
-        case PARAM.PARAM.FrameType.DeviceStateChanged:
-            return parseReceivedDataNotification;
-        case PARAM.PARAM.NetworkState.CHANGE_NETWORK_STATE:
+        case FirmwareCommand.ApsDataIndication:
+            return parseApsDataIndicationResponse;
+        case FirmwareCommand.ApsDataRequest:
+            return parseApsDataRequestResponse;
+        case FirmwareCommand.ApsDataConfirm:
+            return parseApsConfirmResponse;
+        case FirmwareCommand.StatusChangeIndication:
+            return parseDeviceStateChangedNotification;
+        case FirmwareCommand.ChangeNetworkState:
             return parseChangeNetworkStateResponse;
-        case PARAM.PARAM.FrameType.GreenPowerDataInd:
+        case FirmwareCommand.ZgpDataIndication:
             return parseGreenPowerDataIndication;
-        case 28:
+        case FirmwareCommand.MacPollIndication:
             return parseMacPollCommand;
-        case 31:
+        case FirmwareCommand.Beacon:
             return parseBeaconRequest;
+        case FirmwareCommand.DebugLog:
+            return parseDebugLog;
         default:
             return parseUnknownCommand;
         //throw new Error(`unknown command id ${id}`);
@@ -501,54 +580,54 @@ function getParserForCommandId(id: number): (view: DataView) => Command | object
 
 function processFrame(frame: Uint8Array): void {
     const [seqNumber, status, command, commandId] = parseFrame(frame);
-    //logger.debug(`process frame with seq: ${seqNumber} status: ${status}`, NS);
+    // logger.debug(`Process frame with cmd: 0x${commandId.toString(16).padStart(2,'0')}, seq: ${seqNumber} status: ${status}`, NS);
 
-    let queue = busyQueue;
+    let queue: ApsRequest[] | Request[] = busyQueue;
 
-    if (commandId === PARAM.PARAM.APS.DATA_INDICATION || commandId === PARAM.PARAM.APS.DATA_REQUEST || commandId === PARAM.PARAM.APS.DATA_CONFIRM) {
+    if (commandId === FirmwareCommand.ApsDataRequest) {
         queue = apsBusyQueue;
     }
 
-    const i = queue.findIndex((r: Request) => r.seqNumber === seqNumber);
+    const i = queue.findIndex((r: ApsRequest | Request) => r.seqNumber === seqNumber && r.commandId === commandId);
     if (i < 0) {
         return;
     }
 
-    const req: Request = queue[i];
+    const req: ApsRequest | Request = queue[i];
 
-    if (commandId === PARAM.PARAM.APS.DATA_REQUEST) {
-        // if confirm is true resolve request only when data confirm arrives
-        // TODO only return if a confirm was requested. if no confirm needed: go ahead
-        //if (req.confirm === true) {
-        return;
-        //}
+    if (commandId === FirmwareCommand.ApsDataRequest) {
+        if (status === CommandStatus.Success) {
+            // wait for APS-DATA.confirm to arrive
+            return;
+        }
+
+        // TODO(mpi): Within the timeout we should reschedule the APS-DATA.request (given that network state = connected)
+        // continue to reject as there will be no APS-DATA.confirm
     }
 
     //remove from busyqueue
     queue.splice(i, 1);
 
-    if (status !== 0) {
-        // reject if status is not SUCCESS
-        //logger.debug("REJECT REQUEST", NS);
-        req.reject(new Error(`status=${status}`));
-    } else {
-        //logger.debug("RESOLVE REQUEST", NS);
+    if (status === CommandStatus.Success) {
         req.resolve(command);
-    }
-}
+    } else {
+        let cmdName: string;
+        if (commandId in FirmwareCommand) {
+            cmdName = FirmwareCommand[commandId];
+        } else {
+            cmdName = `0x${commandId.toString(16).padStart(2, "0")}`;
+        }
 
-function parseFrame(frame: Uint8Array): [number | null, number | null, ReturnType<ReturnType<typeof getParserForCommandId>>, number | null] {
-    if (frame.length < MIN_BUFFER_SIZE) {
-        logger.debug("received frame size to small - discard frame", NS);
-        return [null, null, null, null];
+        req.reject(new Error(`Command ${cmdName} failed with status: ${CommandStatus[status]}`));
     }
+}
 
+function parseFrame(frame: Uint8Array): [number, number, ReturnType<ReturnType<typeof getParserForCommandId>>, number] {
+    // at this point frame.buffer.length is at least 5 bytes long
     const view = new DataView(frame.buffer);
     const commandId = view.getUint8(0);
     const seqNumber = view.getUint8(1);
     const status = view.getUint8(2);
-    //const frameLength = view.getUint16(3, littleEndian);
-    //const payloadLength = view.getUint16(5, littleEndian);
     const parser = getParserForCommandId(commandId);
 
     return [seqNumber, status, parser(view), commandId];