@willieee802/zigbee-herdsman 0.48.3 → 0.49.0

package/src/adapter/zigate/driver/constants.ts

@@ -0,0 +1,150 @@
+import {ClusterId as ZdoClusterId} from "../../../zspec/zdo";
+
+export enum AddressMode {
+    Bound = 0x00, //Use one or more bound nodes/endpoints, with acknowledgements
+    Group = 0x01, //Use a pre-defined group address, with acknowledgements
+    Short = 0x02, //Use a 16-bit network address, with acknowledgements
+    Ieee = 0x03, //Use a 64-bit IEEE/MAC address, with acknowledgements
+    Broadcast = 0x04, //Perform a broadcast
+    NoTransmit = 0x05, //Do not transmit
+    BoundNoAck = 0x06, //Perform a bound transmission, with no acknowledgements
+    ShortNoAck = 0x07, //Perform a transmission using a 16-bit network address, with no acknowledgements
+    IeeeNoAck = 0x08, //Perform a transmission using a 64-bit IEEE/MAC address, with no acknowledgements
+    BoundNonBlocking = 0x09, //Perform a non-blocking bound transmission, with acknowledgements
+    BoundNonBlockingNoAck = 10, //Perform a non-blocking bound transmission, with no acknowledgements
+}
+
+export enum DeviceType {
+    Coordinator = 0,
+    Router = 1,
+    LegacyRouter = 2,
+}
+
+export enum LogLevel {
+    EMERG = 0,
+    ALERT = 1,
+    "CRIT " = 2,
+    ERROR = 3,
+    "WARN " = 4,
+    "NOT  " = 5,
+    "INFO " = 6,
+    DEBUG = 7,
+}
+
+export enum Status {
+    E_SL_MSG_STATUS_SUCCESS = 0,
+    E_SL_MSG_STATUS_INCORRECT_PARAMETERS = 1,
+    E_SL_MSG_STATUS_UNHANDLED_COMMAND = 2,
+    E_SL_MSG_STATUS_BUSY = 3,
+    E_SL_MSG_STATUS_STACK_ALREADY_STARTED = 4,
+}
+
+export enum ZiGateCommandCode {
+    GetNetworkState = 0x0009,
+    RawMode = 0x0002,
+    SetExtendedPANID = 0x0020,
+    SetChannelMask = 0x0021,
+    GetVersion = 0x0010,
+    Reset = 0x0011,
+    ErasePersistentData = 0x0012,
+    RemoveDevice = 0x0026,
+    RawAPSDataRequest = 0x0530,
+    GetTimeServer = 0x0017,
+    SetTimeServer = 0x0016,
+    PermitJoinStatus = 0x0014,
+    GetDevicesList = 0x0015,
+
+    StartNetwork = 0x0024,
+    StartNetworkScan = 0x0025,
+    SetCertification = 0x0019,
+
+    // ResetFactoryNew = 0x0013,
+    OnOff = 0x0092,
+    OnOffTimed = 0x0093,
+    AttributeDiscovery = 0x0140,
+    AttributeRead = 0x0100,
+    AttributeWrite = 0x0110,
+    DescriptorComplex = 0x0531,
+
+    // zdo
+    Bind = 0x0030,
+    UnBind = 0x0031,
+    NwkAddress = 0x0040,
+    IEEEAddress = 0x0041,
+    NodeDescriptor = 0x0042,
+    SimpleDescriptor = 0x0043,
+    PowerDescriptor = 0x0044,
+    ActiveEndpoint = 0x0045,
+    MatchDescriptor = 0x0046,
+    // ManagementLeaveRequest = 0x0047, XXX: some non-standard form of LeaveRequest?
+    PermitJoin = 0x0049,
+    ManagementNetworkUpdate = 0x004a,
+    SystemServerDiscovery = 0x004b,
+    LeaveRequest = 0x004c,
+    ManagementLQI = 0x004e,
+    // ManagementRtg = 0x004?,
+    // ManagementBind = 0x004?,
+
+    SetDeviceType = 0x0023,
+    LED = 0x0018,
+    SetTXpower = 0x0806,
+    SetSecurityStateKey = 0x0022,
+    AddGroup = 0x0060,
+}
+
+export const ZDO_REQ_CLUSTER_ID_TO_ZIGATE_COMMAND_ID: Readonly<Partial<Record<ZdoClusterId, ZiGateCommandCode>>> = {
+    [ZdoClusterId.NETWORK_ADDRESS_REQUEST]: ZiGateCommandCode.NwkAddress,
+    [ZdoClusterId.IEEE_ADDRESS_REQUEST]: ZiGateCommandCode.IEEEAddress,
+    [ZdoClusterId.NODE_DESCRIPTOR_REQUEST]: ZiGateCommandCode.NodeDescriptor,
+    [ZdoClusterId.POWER_DESCRIPTOR_REQUEST]: ZiGateCommandCode.PowerDescriptor,
+    [ZdoClusterId.SIMPLE_DESCRIPTOR_REQUEST]: ZiGateCommandCode.SimpleDescriptor,
+    [ZdoClusterId.MATCH_DESCRIPTORS_REQUEST]: ZiGateCommandCode.MatchDescriptor,
+    [ZdoClusterId.ACTIVE_ENDPOINTS_REQUEST]: ZiGateCommandCode.ActiveEndpoint,
+    [ZdoClusterId.SYSTEM_SERVER_DISCOVERY_REQUEST]: ZiGateCommandCode.SystemServerDiscovery,
+    [ZdoClusterId.BIND_REQUEST]: ZiGateCommandCode.Bind,
+    [ZdoClusterId.UNBIND_REQUEST]: ZiGateCommandCode.UnBind,
+    [ZdoClusterId.LQI_TABLE_REQUEST]: ZiGateCommandCode.ManagementLQI,
+    // [ZdoClusterId.ROUTING_TABLE_REQUEST]: ZiGateCommandCode.ManagementRtg,
+    // [ZdoClusterId.BINDING_TABLE_REQUEST]: ZiGateCommandCode.ManagementBind,
+    [ZdoClusterId.LEAVE_REQUEST]: ZiGateCommandCode.LeaveRequest,
+    [ZdoClusterId.NWK_UPDATE_REQUEST]: ZiGateCommandCode.ManagementNetworkUpdate,
+    [ZdoClusterId.PERMIT_JOINING_REQUEST]: ZiGateCommandCode.PermitJoin,
+};
+
+export enum ZiGateMessageCode {
+    DeviceAnnounce = 0x004d,
+    Status = 0x8000,
+    LOG = 0x8001,
+    DataIndication = 0x8002,
+    NodeClusterList = 0x8003,
+    NodeAttributeList = 0x8004,
+    NodeCommandIDList = 0x8005,
+    SimpleDescriptorResponse = 0x8043,
+    NetworkState = 0x8009,
+    VersionList = 0x8010,
+    APSDataACK = 0x8011,
+    APSDataConfirm = 0x8012,
+    APSDataConfirmFailed = 0x8702,
+    NetworkJoined = 0x8024,
+    LeaveIndication = 0x8048,
+    RouterDiscoveryConfirm = 0x8701,
+    PermitJoinStatus = 0x8014,
+    GetTimeServer = 0x8017,
+    ManagementLQIResponse = 0x804e,
+    ManagementLeaveResponse = 0x8047,
+    PDMEvent = 0x8035,
+    PDMLoaded = 0x0302,
+    RestartNonFactoryNew = 0x8006,
+    RestartFactoryNew = 0x8007,
+    ExtendedStatusCallBack = 0x9999,
+    AddGroupResponse = 0x8060,
+}
+// biome-ignore lint/suspicious/noExplicitAny: API
+export type ZiGateObjectPayload = any;
+
+export enum ZPSNwkKeyState {
+    ZPS_ZDO_NO_NETWORK_KEY = 0,
+    ZPS_ZDO_PRECONFIGURED_LINK_KEY = 1,
+    ZPS_ZDO_DISTRIBUTED_LINK_KEY = 2,
+    ZPS_ZDO_PRECONFIGURED_INSTALLATION_CODE = 3,
+}

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

@@ -0,0 +1,197 @@
+/* v8 ignore start */
+
+import {logger} from "../../../utils/logger";
+
+const NS = "zh:zigate:frame";
+
+enum ZiGateFrameChunkSize {
+    UInt8 = 1,
+    UInt16 = 2,
+    UInt32 = 3,
+    UInt64 = 4,
+}
+
+const hasStartByte = (startByte: number, frame: Buffer): boolean => {
+    return frame.indexOf(startByte, 0) === 0;
+};
+
+const hasStopByte = (stopByte: number, frame: Buffer): boolean => {
+    return frame.indexOf(stopByte, frame.length - 1) === frame.length - 1;
+};
+
+const combineBytes = (byte: number, idx: number, frame: number[]): [number, number] => {
+    const nextByte = frame[idx + 1];
+
+    return [byte, nextByte];
+};
+// maybe any
+const removeDuplicate = (_: unknown, idx: number, frame: number[][]): boolean => {
+    if (idx === 0) {
+        return true;
+    }
+
+    const [first] = frame[idx - 1];
+
+    return first !== 0x2;
+};
+
+const decodeBytes = (bytesPair: [number, number]): number => {
+    return bytesPair[0] === 0x2 ? bytesPair[1] ^ 0x10 : bytesPair[0];
+};
+
+const readBytes = (bytes: Buffer): number => {
+    return bytes.readUIntBE(0, bytes.length);
+};
+
+const writeBytes = (bytes: Buffer, val: number): void => {
+    bytes.writeUIntBE(val, 0, bytes.length);
+};
+
+const xor = (checksum: number, byte: number): number => {
+    return checksum ^ byte;
+};
+
+const decodeFrame = (frame: Buffer): Buffer => {
+    const arrFrame = Array.from(frame).map(combineBytes).filter(removeDuplicate).map(decodeBytes);
+
+    return Buffer.from(arrFrame);
+};
+
+const getFrameChunk = (frame: Buffer, pos: number, size: ZiGateFrameChunkSize): Buffer => {
+    return frame.slice(pos, pos + size);
+};
+
+export default class ZiGateFrame {
+    static readonly START_BYTE = 0x1;
+    static readonly STOP_BYTE = 0x3;
+
+    msgCodeBytes: Buffer = Buffer.alloc(ZiGateFrameChunkSize.UInt16);
+    msgLengthBytes: Buffer = Buffer.alloc(ZiGateFrameChunkSize.UInt16);
+    checksumBytes: Buffer = Buffer.alloc(ZiGateFrameChunkSize.UInt8);
+    msgPayloadBytes: Buffer = Buffer.alloc(0);
+    rssiBytes: Buffer = Buffer.alloc(0);
+
+    msgLengthOffset = 0;
+
+    constructor(frame?: Buffer) {
+        if (frame !== undefined) {
+            const decodedFrame = decodeFrame(frame);
+            // logger.debug(`decoded frame >>> %o`, decodedFrame, NS);
+            // Due to ZiGate incoming frames with erroneous msg length
+            this.msgLengthOffset = -1;
+
+            if (!ZiGateFrame.isValid(frame)) {
+                logger.error("Provided frame is not a valid ZiGate frame.", NS);
+                return;
+            }
+
+            this.buildChunks(decodedFrame);
+
+            try {
+                if (this.readMsgCode() !== 0x8001) logger.debug(() => `${JSON.stringify(this)}`, NS);
+            } catch (error) {
+                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
+                logger.error((error as Error).stack!, NS);
+            }
+
+            if (this.readChecksum() !== this.calcChecksum()) {
+                logger.error("Provided frame has an invalid checksum.", NS);
+                return;
+            }
+        }
+    }
+
+    static isValid(frame: Buffer): boolean {
+        return hasStartByte(ZiGateFrame.START_BYTE, frame) && hasStopByte(ZiGateFrame.STOP_BYTE, frame);
+    }
+
+    buildChunks(frame: Buffer): void {
+        this.msgCodeBytes = getFrameChunk(frame, 1, this.msgCodeBytes.length);
+        this.msgLengthBytes = getFrameChunk(frame, 3, this.msgLengthBytes.length);
+        this.checksumBytes = getFrameChunk(frame, 5, this.checksumBytes.length);
+        this.msgPayloadBytes = getFrameChunk(frame, 6, this.readMsgLength());
+        this.rssiBytes = getFrameChunk(frame, 6 + this.readMsgLength(), ZiGateFrameChunkSize.UInt8);
+    }
+
+    toBuffer(): Buffer {
+        const length = 5 + this.readMsgLength();
+
+        const escapedData = this.escapeData(
+            Buffer.concat([this.msgCodeBytes, this.msgLengthBytes, this.checksumBytes, this.msgPayloadBytes], length),
+        );
+
+        return Buffer.concat([Uint8Array.from([ZiGateFrame.START_BYTE]), escapedData, Uint8Array.from([ZiGateFrame.STOP_BYTE])]);
+    }
+
+    escapeData(data: Buffer): Buffer {
+        let encodedLength = 0;
+        const encodedData = Buffer.alloc(data.length * 2);
+        const FRAME_ESCAPE_XOR = 0x10;
+        const FRAME_ESCAPE = 0x02;
+        for (const b of data) {
+            if (b <= FRAME_ESCAPE_XOR) {
+                encodedData[encodedLength++] = FRAME_ESCAPE;
+                encodedData[encodedLength++] = b ^ FRAME_ESCAPE_XOR;
+            } else {
+                encodedData[encodedLength++] = b;
+            }
+        }
+        return encodedData.slice(0, encodedLength);
+    }
+
+    readMsgCode(): number {
+        return readBytes(this.msgCodeBytes);
+    }
+
+    writeMsgCode(msgCode: number): ZiGateFrame {
+        writeBytes(this.msgCodeBytes, msgCode);
+        this.writeChecksum();
+        return this;
+    }
+
+    readMsgLength(): number {
+        return readBytes(this.msgLengthBytes) + this.msgLengthOffset;
+    }
+
+    writeMsgLength(msgLength: number): ZiGateFrame {
+        writeBytes(this.msgLengthBytes, msgLength);
+        return this;
+    }
+
+    readChecksum(): number {
+        return readBytes(this.checksumBytes);
+    }
+
+    writeMsgPayload(msgPayload: Buffer): ZiGateFrame {
+        this.msgPayloadBytes = Buffer.from(msgPayload);
+        this.writeMsgLength(msgPayload.length);
+        this.writeChecksum();
+        return this;
+    }
+
+    readRSSI(): number {
+        return readBytes(this.rssiBytes);
+    }
+
+    writeRSSI(rssi: number): ZiGateFrame {
+        this.rssiBytes = Buffer.from([rssi]);
+        this.writeChecksum();
+        return this;
+    }
+
+    calcChecksum(): number {
+        let checksum = 0x00;
+
+        checksum = this.msgCodeBytes.reduce(xor, checksum);
+        checksum = this.msgLengthBytes.reduce(xor, checksum);
+        checksum = this.rssiBytes.reduce(xor, checksum);
+        checksum = this.msgPayloadBytes.reduce(xor, checksum);
+
+        return checksum;
+    }
+
+    writeChecksum(): this {
+        this.checksumBytes = Buffer.from([this.calcChecksum()]);
+        return this;
+    }
+}

package/src/adapter/zigate/driver/messageType.ts

@@ -0,0 +1,287 @@
+import {ZiGateMessageCode} from "./constants";
+import ParameterType from "./parameterType";
+
+export interface ZiGateMessageParameter {
+    name: string;
+    parameterType: ParameterType;
+    options?: object;
+}
+
+export interface ZiGateMessageType {
+    response: ZiGateMessageParameter[];
+}
+
+export const ZiGateMessage: {[k: number]: ZiGateMessageType} = {
+    [ZiGateMessageCode.GetTimeServer]: {
+        response: [
+            {name: "timestampUTC", parameterType: ParameterType.UINT32}, // <Timestamp UTC: uint32_t> from 2000-01-01 00:00:00
+        ],
+    },
+    [ZiGateMessageCode.DeviceAnnounce]: {
+        response: [
+            {name: "shortAddress", parameterType: ParameterType.UINT16},
+            {name: "ieee", parameterType: ParameterType.IEEEADDR},
+            {name: "MACcapability", parameterType: ParameterType.MACCAPABILITY},
+            // MAC capability
+            // Bit 0 – Alternate PAN Coordinator
+            // Bit 1 – Device Type
+            // Bit 2 – Power source
+            // Bit 3 – Receiver On when Idle
+            // Bit 4,5 – Reserved
+            // Bit 6 – Security capability
+            // Bit 7 – Allocate Address
+            // {name: 'rejoin', parameterType: ParameterType.UINT8},
+        ],
+    },
+    [ZiGateMessageCode.Status]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status:uint8_t>
+            // 0 = Success
+            // 1 = Incorrect parameters
+            // 2 = Unhandled command
+            // 3 = Command failed
+            // 4 = Busy (Node is carrying out a lengthy operation and is currently unable to handle the incoming command)
+            // 5 = Stack already started (no new configuration accepted)
+            // 128 – 244 = Failed (Zigbee event codes)
+            // Packet Type: The value of the initiating command request.
+            {name: "sequence", parameterType: ParameterType.UINT8}, // <sequence number: uint8_t>
+            {name: "packetType", parameterType: ParameterType.UINT16}, // <Packet Type: uint16_t>
+
+            // from 3.1d
+            // {name: 'requestSent', parameterType: ParameterType.MAYBE_UINT8},// <requestSent: uint8_t>  - 1 if a request been sent to
+            // // a device(aps ack/nack 8011 should be expected) , 0 otherwise
+            // {name: 'seqApsNum', parameterType: ParameterType.MAYBE_UINT8},// <seqApsNum: uint8_t>  - sqn of the APS layer - used to
+            // // check sqn sent back in aps ack
+            //
+            // // from 3.1e
+            // {name: 'PDUM_u8GetNpduUse', parameterType: ParameterType.MAYBE_UINT8},
+            // {name: 'u8GetApduUse', parameterType: ParameterType.MAYBE_UINT8},
+            //
+            // // debug 3.1e++
+            // {name: 'PDUM_u8GetMaxNpduUse', parameterType: ParameterType.MAYBE_UINT8},
+            // {name: 'u8GetMaxApduUse', parameterType: ParameterType.MAYBE_UINT8},
+        ],
+    },
+    [ZiGateMessageCode.PermitJoinStatus]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status:uint8_t>
+        ],
+    },
+    [ZiGateMessageCode.DataIndication]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            {name: "profileID", parameterType: ParameterType.UINT16}, // <Profile ID: uint16_t>
+            {name: "clusterID", parameterType: ParameterType.UINT16}, // <cluster ID: uint16_t>
+            {name: "sourceEndpoint", parameterType: ParameterType.UINT8}, // <source endpoint: uint8_t>
+            {name: "destinationEndpoint", parameterType: ParameterType.UINT8}, // <destination endpoint: uint8_t>
+            {name: "sourceAddressMode", parameterType: ParameterType.UINT8}, // <source address mode: uint8_t>
+            {name: "sourceAddress", parameterType: ParameterType.ADDRESS_WITH_TYPE_DEPENDENCY},
+            // <source address: uint16_t or uint64_t>
+            {name: "destinationAddressMode", parameterType: ParameterType.UINT8},
+            // <destination address mode: uint8_t>
+            {name: "destinationAddress", parameterType: ParameterType.ADDRESS_WITH_TYPE_DEPENDENCY},
+            // <destination address: uint16_t or uint64_t>
+            // {name: 'payloadSize', parameterType: ParameterType.UINT8}, // <payload size : uint8_t>
+            {name: "payload", parameterType: ParameterType.BUFFER_RAW}, // <payload : data each element is
+            // uint8_t>
+        ],
+    },
+    [ZiGateMessageCode.NodeClusterList]: {
+        response: [
+            {name: "sourceEndpoint", parameterType: ParameterType.UINT8}, //<source endpoint: uint8_t t>
+            {name: "profileID", parameterType: ParameterType.UINT16}, // <profile ID: uint16_t>
+            {name: "clusterCount", parameterType: ParameterType.UINT8},
+            {name: "clusterList", parameterType: ParameterType.LIST_UINT16}, // <cluster list: data each entry is uint16_t>
+        ],
+    },
+    [ZiGateMessageCode.NodeAttributeList]: {
+        response: [
+            {name: "sourceEndpoint", parameterType: ParameterType.UINT8}, //<source endpoint: uint8_t t>
+            {name: "profileID", parameterType: ParameterType.UINT16}, // <profile ID: uint16_t>
+            {name: "clusterID", parameterType: ParameterType.UINT16}, // <cluster ID: uint16_t>
+            {name: "attributeCount", parameterType: ParameterType.UINT8},
+            {name: "attributeList", parameterType: ParameterType.LIST_UINT16}, //  <attribute list: data each entry is uint16_t>
+        ],
+    },
+    [ZiGateMessageCode.NodeCommandIDList]: {
+        response: [
+            {name: "sourceEndpoint", parameterType: ParameterType.UINT8}, //<source endpoint: uint8_t t>
+            {name: "profileID", parameterType: ParameterType.UINT16}, // <profile ID: uint16_t>
+            {name: "clusterID", parameterType: ParameterType.UINT16}, // <cluster ID: uint16_t>
+            {name: "commandIDCount", parameterType: ParameterType.UINT8},
+            {name: "commandIDList", parameterType: ParameterType.LIST_UINT8}, // <command ID list:data each entry is uint8_t>
+        ],
+    },
+    [ZiGateMessageCode.APSDataACK]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            // {name: 'sourceEndpoint', parameterType: ParameterType.UINT8}, // <source endpoint: uint8_t>
+            // {name: 'destinationAddressMode', parameterType: ParameterType.UINT8},
+            // // <destination address mode: uint8_t>
+            {name: "destinationAddress", parameterType: ParameterType.UINT16},
+            {name: "destinationEndpoint", parameterType: ParameterType.UINT8}, // <destination endpoint: uint8_t>
+            {name: "clusterID", parameterType: ParameterType.UINT16},
+            // // <destination address: uint16_t or uint64_t>
+            {name: "seqNumber", parameterType: ParameterType.UINT8}, // <seq number: uint8_t>
+        ],
+    },
+    [ZiGateMessageCode.APSDataConfirm]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            {name: "sourceEndpoint", parameterType: ParameterType.UINT8}, // <source endpoint: uint8_t>
+            {name: "destinationAddressMode", parameterType: ParameterType.UINT8},
+
+            {name: "destinationAddressMode", parameterType: ParameterType.UINT8},
+            // <destination address mode: uint8_t>
+            {name: "destinationAddress", parameterType: ParameterType.ADDRESS_WITH_TYPE_DEPENDENCY},
+            // <destination address: uint16_t or uint64_t>
+            {name: "seqNumber", parameterType: ParameterType.UINT8}, // <seq number: uint8_t>
+            // from 3.1e
+            {name: "PDUM_u8GetNpduUse", parameterType: ParameterType.MAYBE_UINT8},
+            {name: "u8GetApduUse", parameterType: ParameterType.MAYBE_UINT8},
+        ],
+    },
+    [ZiGateMessageCode.APSDataConfirmFailed]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            {name: "sourceEndpoint", parameterType: ParameterType.UINT8}, // <src endpoint: uint8_t>
+            {name: "destinationEndpoint", parameterType: ParameterType.UINT8}, // <dst endpoint: uint8_t>
+            {name: "destinationAddressMode", parameterType: ParameterType.UINT8}, // <dst address mode: uint8_t>
+            {name: "destinationAddress", parameterType: ParameterType.ADDRESS_WITH_TYPE_DEPENDENCY},
+            // <destination address: uint64_t>
+            {name: "seqNumber", parameterType: ParameterType.UINT8}, // <seq number: uint8_t>
+            // from 3.1e
+            {name: "PDUM_u8GetNpduUse", parameterType: ParameterType.MAYBE_UINT8},
+            {name: "u8GetApduUse", parameterType: ParameterType.MAYBE_UINT8},
+        ],
+    },
+    [ZiGateMessageCode.NetworkState]: {
+        response: [
+            {name: "shortAddress", parameterType: ParameterType.UINT16}, // <Short Address: uint16_t>
+            {name: "extendedAddress", parameterType: ParameterType.IEEEADDR}, // <Extended Address: uint64_t>
+            {name: "PANID", parameterType: ParameterType.UINT16}, // <PAN ID: uint16_t>
+            {name: "ExtPANID", parameterType: ParameterType.IEEEADDR}, // <Ext PAN ID: uint64_t>
+            {name: "Channel", parameterType: ParameterType.UINT8}, // <Channel: uint8_t>
+        ],
+    },
+    [ZiGateMessageCode.VersionList]: {
+        response: [
+            {name: "major", parameterType: ParameterType.UINT8},
+            {name: "minor", parameterType: ParameterType.UINT8},
+            {name: "revision", parameterType: ParameterType.UINT16},
+        ],
+    },
+    [ZiGateMessageCode.NetworkJoined]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            // Status:
+            // 0 = Joined existing network
+            // 1 = Formed new network
+            // 128 – 244 = Failed (Zigbee event codes)
+            {name: "shortAddress", parameterType: ParameterType.UINT16}, // <short address: uint16_t>
+            // {name: 'extendedAddress', parameterType: ParameterType.IEEEADDR}, // <extended address:uint64_t>
+            // {name: 'channel', parameterType: ParameterType.UINT8}, // <channel: uint8_t>
+        ],
+    },
+    [ZiGateMessageCode.LeaveIndication]: {
+        response: [
+            {name: "extendedAddress", parameterType: ParameterType.IEEEADDR}, // <extended address: uint64_t>
+            {name: "rejoin", parameterType: ParameterType.UINT8}, // <rejoin status: uint8_t>
+        ],
+    },
+    // [ZiGateMessageCode.ManagementLeaveResponse]: {
+    //     response: [
+    //         {name: 'sqn', parameterType: ParameterType.UINT8},
+    //         {name: 'status', parameterType: ParameterType.UINT8}, // <status: uint8_t>
+    //     ],
+    // },
+    [ZiGateMessageCode.RouterDiscoveryConfirm]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            // {name: 'nwkStatus', parameterType: ParameterType.UINT8}, // <nwk status: uint8_t>
+            // {name: 'dstAddress', parameterType: ParameterType.UINT16}, // <nwk status: uint16_t>
+        ],
+    },
+    // [ZiGateMessageCode.SimpleDescriptorResponse]: {
+    //     response: [
+    //         {name: 'sourceEndpoint', parameterType: ParameterType.UINT8}, //<source endpoint: uint8_t>
+    //         {name: 'profile ID', parameterType: ParameterType.UINT16}, // <profile ID: uint16_t>
+    //         {name: 'clusterID', parameterType: ParameterType.UINT16}, // <cluster ID: uint16_t>
+    //         {name: 'attributeList', parameterType: ParameterType.LIST_UINT16}, // <attribute list: data each entry is uint16_t>
+    //     ],
+    // },
+    // [ZiGateMessageCode.ManagementLQIResponse]: {
+    //     response: [
+    //         {name: 'sequence', parameterType: ParameterType.UINT8}, // <Sequence number: uint8_t>
+    //         {name: 'status', parameterType: ParameterType.UINT8}, // <status: uint8_t>
+    //         {name: 'neighbourTableEntries', parameterType: ParameterType.UINT8}, // <Neighbour Table Entries : uint8_t>
+    //         {name: 'neighbourTableListCount', parameterType: ParameterType.UINT8}, // <Neighbour Table List Count : uint8_t>
+    //         {name: 'startIndex', parameterType: ParameterType.UINT8}, // <Start Index : uint8_t>
+    //         // XXX: broken? automatic ziGateObject parsing will always read below as-is, even if it's not supposed to
+    //         // @TODO list TYPE
+    //         // <List of Entries elements described below :>
+    //         // Note: If Neighbour Table list count is 0, there are no elements in the list.
+    //         {name: 'NWKAddress', parameterType: ParameterType.UINT16}, // NWK Address : uint16_t
+    //         {name: 'Extended PAN ID', parameterType: ParameterType.IEEEADDR}, // Extended PAN ID : uint64_t
+    //         {name: 'IEEE Address', parameterType: ParameterType.IEEEADDR}, // IEEE Address : uint64_t
+    //         {name: 'Depth', parameterType: ParameterType.UINT8}, // Depth : uint_t
+    //         {name: 'linkQuality', parameterType: ParameterType.UINT8}, // Link Quality : uint8_t
+    //         {name: 'bitMap', parameterType: ParameterType.UINT8}, // Bit map of attributes Described below: uint8_t
+    //         // bit 0-1 Device Type
+    //         // (0-Coordinator 1-Router 2-End Device)
+    //         // bit 2-3 Permit Join status
+    //         // (1- On 0-Off)
+    //         // bit 4-5 Relationship
+    //         // (0-Parent 1-Child 2-Sibling)
+    //         // bit 6-7 Rx On When Idle status
+    //         // (1-On 0-Off)
+    //         {name: 'srcAddress', parameterType: ParameterType.UINT16}, // <Src Address : uint16_t> ( only from v3.1a)
+    //     ],
+    // },
+    [ZiGateMessageCode.PDMEvent]: {
+        response: [
+            {name: "eventStatus", parameterType: ParameterType.UINT8}, // <event status: uint8_t>
+            {name: "recordID", parameterType: ParameterType.UINT32}, // <record ID: uint32_t>
+        ],
+    },
+    [ZiGateMessageCode.PDMLoaded]: {
+        response: [{name: "length", parameterType: ParameterType.UINT8}],
+    },
+    [ZiGateMessageCode.RestartNonFactoryNew]: {
+        // Non “Factory new” Restart
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            //	0 – STARTUP
+            // 1 – RUNNING
+            // 2 – NFN_START
+        ],
+    },
+    [ZiGateMessageCode.RestartFactoryNew]: {
+        // “Factory New” Restart
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8}, // <status: uint8_t>
+            // 0 – STARTUP
+            // 2 – NFN_START
+            // 6 – RUNNING
+            // The node is not yet provisioned.
+        ],
+    },
+    [ZiGateMessageCode.ExtendedStatusCallBack]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT8},
+            // https://github.com/fairecasoimeme/ZiGate/blob/aac14153db332eb5b898cba0f57f5999e5cf11eb/Module%20Radio/Firmware/src/sdk/JN-SW-4170/Components/ZPSNWK/Include/zps_nwk_pub.h#L89
+        ],
+    },
+    32769: {
+        response: [
+            {name: "logLevel", parameterType: ParameterType.LOG_LEVEL},
+            {name: "log", parameterType: ParameterType.STRING},
+        ],
+    },
+    [ZiGateMessageCode.AddGroupResponse]: {
+        response: [
+            {name: "status", parameterType: ParameterType.UINT16},
+            {name: "groupAddress", parameterType: ParameterType.UINT16},
+        ],
+    },
+};

package/src/adapter/zigate/driver/parameterType.ts

@@ -0,0 +1,32 @@
+// All multi-byte values are big-endian
+enum ParameterType {
+    UINT8 = 0,
+    UINT16 = 1,
+    UINT32 = 2,
+    IEEEADDR = 3,
+
+    BUFFER = 4,
+    BUFFER8 = 5,
+    BUFFER16 = 6,
+    BUFFER18 = 7,
+    BUFFER32 = 8,
+    BUFFER42 = 9,
+    BUFFER100 = 10,
+
+    LIST_UINT8 = 11,
+    LIST_UINT16 = 12,
+
+    INT8 = 18,
+    MACCAPABILITY = 100,
+    ADDRESS_WITH_TYPE_DEPENDENCY = 101,
+    RAW = 102,
+
+    // /!\ TODO missing but used in code, IDs assigned for proper compiling, NOT based on spec, needs updating
+    // /!\      some also don't have proper read/write in BuffaloZiGate
+    BUFFER_RAW = 247,
+    MAYBE_UINT8 = 252,
+    LOG_LEVEL = 253,
+    STRING = 254,
+}
+
+export default ParameterType;