@robotical/raftjs 1.3.5 → 1.4.1

package/src/RaftDeviceManager.ts

@@ -11,11 +11,10 @@ import { DeviceAttributeState, DevicesState, DeviceState, getDeviceKey } from ".
 import { DeviceMsgJson } from "./RaftDeviceMsg";
 import { RaftOKFail } from './RaftTypes';
 import { DeviceTypeInfo, DeviceTypeAction, DeviceTypeInfoRecs, RaftDevTypeInfoResponse } from "./RaftDeviceInfo";
-import struct, { DataType } from 'python-struct';
 import AttributeHandler from "./RaftAttributeHandler";
 import RaftSystemUtils from "./RaftSystemUtils";
 import RaftDeviceMgrIF from "./RaftDeviceMgrIF";
-import { Buffer } from 'buffer';
+import { structPack } from "./RaftStruct";
 
 export class DeviceManager implements RaftDeviceMgrIF{
 
@@ -32,7 +31,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
     private _attributeHandler = new AttributeHandler();
 
     // Devices state
-    private _devicesState = new DevicesState();
+    public _devicesState = new DevicesState();
 
     // Last time each device was updated - used to detect devices that are no longer present
     private _deviceLastUpdateTime: { [deviceKey: string]: number } = {};
@@ -45,9 +44,9 @@ export class DeviceManager implements RaftDeviceMgrIF{
     private _systemUtils: RaftSystemUtils | null = null;
 
     // Device callbacks
-    private _callbackNewDevice: ((deviceKey: string, state: DeviceState) => void) | null = null;
-    private _callbackNewDeviceAttribute: ((deviceKey: string, attrState: DeviceAttributeState) => void) | null = null;
-    private _callbackNewAttributeData: ((deviceKey: string, attrState: DeviceAttributeState) => void) | null = null;
+    private _newDeviceCallbacks: Array<(deviceKey: string, state: DeviceState) => void> = [];
+    private _newDeviceAttributeCallbacks: Array<(deviceKey: string, attrState: DeviceAttributeState) => void> = [];
+    private _newAttributeDataCallbacks: Array<(deviceKey: string, attrState: DeviceAttributeState) => void> = [];
 
     public getDevicesState(): DevicesState {
         return this._devicesState;
@@ -67,6 +66,15 @@ export class DeviceManager implements RaftDeviceMgrIF{
     constructor() {
     }
 
+    ////////////////////////////////////////////////////////////////////////////
+    // Settings
+    ////////////////////////////////////////////////////////////////////////////
+
+    public setMaxDataPointsToStore(maxDatapointsToStore: number): void {
+        this._maxDatapointsToStore = maxDatapointsToStore;
+        // console.log(`DeviceManager setMaxDataPointsToStore ${maxDatapointsToStore}`);
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // Send REST commands
     ////////////////////////////////////////////////////////////////////////////
@@ -77,7 +85,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             const msgHandler = this._systemUtils?.getMsgHandler();
             if (msgHandler) {
                 const msgRslt = await msgHandler.sendRICRESTURL<RaftOKFail>(cmd);
-                return msgRslt.isOk();
+                return msgRslt.rslt === "ok";
             }
             return false;
         } catch (error) {
@@ -98,21 +106,37 @@ export class DeviceManager implements RaftDeviceMgrIF{
     }
 
     ////////////////////////////////////////////////////////////////////////////
-    // Callbacks
+    // Register callbacks
     ////////////////////////////////////////////////////////////////////////////
 
-    // Register state change callbacks
-    public onNewDevice(callback: (deviceKey: string, state: DeviceState) => void): void {
-        // Save the callback
-        this._callbackNewDevice = callback;
+    public addNewDeviceCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
+        if (!this._newDeviceCallbacks.includes(callback)) {
+            this._newDeviceCallbacks.push(callback);
+        }
     }
-    public onNewDeviceAttribute(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
-        // Save the callback
-        this._callbackNewDeviceAttribute = callback;
+
+    public removeNewDeviceCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
+        this._newDeviceCallbacks = this._newDeviceCallbacks.filter((cb) => cb !== callback);
     }
-    public onNewAttributeData(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
-        // Save the callback
-        this._callbackNewAttributeData = callback;
+
+    public addNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
+        if (!this._newDeviceAttributeCallbacks.includes(callback)) {
+            this._newDeviceAttributeCallbacks.push(callback);
+        }
+    }
+
+    public removeNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
+        this._newDeviceAttributeCallbacks = this._newDeviceAttributeCallbacks.filter((cb) => cb !== callback);
+    }
+
+    public addAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
+        if (!this._newAttributeDataCallbacks.includes(callback)) {
+            this._newAttributeDataCallbacks.push(callback);
+        }
+    }
+
+    public removeAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
+        this._newAttributeDataCallbacks = this._newAttributeDataCallbacks.filter((cb) => cb !== callback);
     }
 
     ////////////////////////////////////////////////////////////////////////////
@@ -124,14 +148,145 @@ export class DeviceManager implements RaftDeviceMgrIF{
         await this._systemUtils?.setRaftName(friendlyName);
     }
 
+    ////////////////////////////////////////////////////////////////////////////
+    // Handle device message binary
+    ////////////////////////////////////////////////////////////////////////////
+
+    public async handleClientMsgBinary(rxMsg: Uint8Array) {
+        // console.log(`DeviceManager client1 msg ${RaftUtils.bufferToHex(rxMsg)}`);
+
+        // Example messages
+        // 0080 0015 81 0000006a 0004 53b7 feff00000100081857079314 0011 80 00000000 0011 53b2 075106e400d60054 0010 80 00000000 0012 5231 000d0000010e01
+        // 0080 0011 80 00000000                                                     0011 53f1 075806e900d70052 0010 80 00000000 0012 5231 000d0000010e01
+
+        // First two bytes of each message are the message type (0080)
+        // There are then a series of sections each of which is the data for a device
+        //   First two bytes of each section is the section length (big endian) not including the length bytes
+        //   Next byte is the connection mode (0 for direct connect, 1+ for bus number) and the MSB of this byte is 1 if the device is online
+        //   Next is the device address (4 bytes big endian)
+        //   Next is the device type index (2 bytes big endian)
+        //   Finally the device data which can be one or more groups of attributes defined by the schema
+
+        // Iterate through sections
+        let msgPos = 2;
+        while (msgPos < rxMsg.length) {
+
+            // Check length
+            if (rxMsg.length < msgPos + 11) {
+                console.warn(`DeviceManager handleClientMsgBinary invalid length ${rxMsg.length}`);
+                return;
+            }
+
+            // Get the length of the section
+            const sectionLen = (rxMsg[msgPos] << 8) + rxMsg[msgPos + 1];
+            if (sectionLen > rxMsg.length) {
+                console.warn(`DeviceManager handleClientMsgBinary invalid msgPos ${msgPos} msgLen ${sectionLen} rxMsgLen ${rxMsg.length}`);
+                return;
+            }
+
+            // Extract message elements
+            const busNum = rxMsg[msgPos + 2] & 0x7f;
+            const isOnline = (rxMsg[msgPos + 2] & 0x80) !== 0;
+            const devAddr = (rxMsg[msgPos + 3] << 24) + (rxMsg[msgPos + 4] << 16) + (rxMsg[msgPos + 5] << 8) + rxMsg[msgPos + 6];
+            const devTypeIdx = (rxMsg[msgPos + 7] << 8) + rxMsg[msgPos + 8];
+            let attrGroupPos = msgPos + 9;
+
+            // Debug
+            // console.log(`DeviceManager overallLen ${rxMsg.length} sectionPos ${msgPos} sectionLen ${sectionLen} ${RaftUtils.bufferToHex(rxMsg.slice(msgPos, msgPos + sectionLen))}`);
+            // console.log(`DeviceManager connMode ${busNum} isOnline ${isOnline} devAddr ${devAddr} devTypeIdx ${devTypeIdx} attrGroupDataLen ${sectionLen - 9}`);
+
+            // Device key
+            const deviceKey = getDeviceKey(busNum.toString(), devAddr.toString(), devTypeIdx.toString());
+
+            // Update the last update time
+            this._deviceLastUpdateTime[deviceKey] = Date.now();
+
+            // Check if a device state already exists
+            if (!(deviceKey in this._devicesState) || (this._devicesState[deviceKey].deviceTypeInfo === undefined)) {
+                // Get the device type info
+                const deviceTypeInfo = await this.getDeviceTypeInfo(busNum.toString(), devAddr.toString(), devTypeIdx.toString());
+                // console.log(`DeviceManager deviceTypeInfo ${JSON.stringify(deviceTypeInfo)}`);
+
+                // Check if device record exists
+                if (deviceKey in this._devicesState) {
+                    if (deviceTypeInfo !== undefined) {
+                        this._devicesState[deviceKey].deviceTypeInfo = deviceTypeInfo;
+                        this._devicesState[deviceKey].deviceType = deviceTypeInfo.name || "";
+                        this._devicesState[deviceKey].busName = busNum.toString();
+                        this._devicesState[deviceKey].deviceAddress = devAddr.toString();
+                    }
+                } else {
+                    // Create device record - device type info may be undefined
+                    this._devicesState[deviceKey] = {
+                        deviceTypeInfo: deviceTypeInfo,
+                        deviceTimeline: {
+                            timestampsUs: [],
+                            lastReportTimestampUs: 0,
+                            reportTimestampOffsetUs: 0
+                        },
+                        deviceAttributes: {},
+                        deviceIsNew: true,
+                        stateChanged: false,
+                        isOnline: true,
+                        deviceAddress: devAddr.toString(),
+                        deviceType: deviceTypeInfo?.name || "",
+                        busName: busNum.toString()
+                    };
+                }
+            }
+
+            // Get device state
+            const deviceState = this._devicesState[deviceKey];
+            deviceState.isOnline = isOnline;
+            
+            // Check if device type info is available
+            if (deviceState.deviceTypeInfo && deviceState.deviceTypeInfo.resp) {
+
+                // Iterate over attributes in the group
+                const pollRespMetadata = deviceState.deviceTypeInfo!.resp!;
+
+                // Iterate over attribute groups
+                while (attrGroupPos < msgPos + sectionLen + 2) {
+                    const curTimelineLen = deviceState.deviceTimeline.timestampsUs.length;
+                    const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, attrGroupPos,
+                        deviceState.deviceTimeline, pollRespMetadata,
+                        deviceState.deviceAttributes,
+                        this._maxDatapointsToStore);
+                    if (newMsgBufIdx < 0)
+                        break;
+                    attrGroupPos = newMsgBufIdx;
+                    if (deviceState.deviceTimeline.timestampsUs.length !== curTimelineLen) {
+                        deviceState.stateChanged = true;
+                    }
+                }
+            }
+
+            // Move to next message
+            msgPos += sectionLen + 2;
+        }
+
+        // Check for devices that have not been updated for a while
+        if (this._removeDevicesFlag) {
+            const nowTime = Date.now();
+            Object.entries(this._deviceLastUpdateTime).forEach(([deviceKey, lastUpdateTime]) => {
+                if ((nowTime - lastUpdateTime) > this._removeDevicesTimeMs) {
+                    delete this._devicesState[deviceKey];
+                }
+            });
+        }
+        
+        // Process the callback
+        this.processStateCallback();        
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // Handle device message JSON
     ////////////////////////////////////////////////////////////////////////////
 
-    public handleClientMsgJson(jsonMsg: string) {
+    public async handleClientMsgJson(jsonMsg: string) {
 
-        let data = JSON.parse(jsonMsg) as DeviceMsgJson;
-        // console.log(`DeviceManager websocket message ${JSON.stringify(data)}`);
+        const data = JSON.parse(jsonMsg) as DeviceMsgJson;
+        // console.log(`DeviceManager client msg ${JSON.stringify(data)}`);
 
         // Iterate over the buses
         Object.entries(data).forEach(([busName, devices]) => {
@@ -150,8 +305,17 @@ export class DeviceManager implements RaftDeviceMgrIF{
                     return;
                 }
 
+                // Device type name
+                let deviceTypeName = "";
+                if (attrGroups && typeof attrGroups === 'object' && "_t" in attrGroups && typeof attrGroups._t === "string") {
+                    deviceTypeName = attrGroups._t || "";
+                } else {
+                    console.warn(`DeviceManager missing device type attrGroups ${JSON.stringify(attrGroups)}`);
+                    return;
+                }
+
                 // Device key
-                const deviceKey = getDeviceKey(busName, devAddr);
+                const deviceKey = getDeviceKey(busName, devAddr, deviceTypeName);
 
                 // Update the last update time
                 this._deviceLastUpdateTime[deviceKey] = Date.now();
@@ -159,14 +323,6 @@ export class DeviceManager implements RaftDeviceMgrIF{
                 // Check if a device state already exists
                 if (!(deviceKey in this._devicesState) || (this._devicesState[deviceKey].deviceTypeInfo === undefined)) {
 
-                    let deviceTypeName = "";
-                    if (attrGroups && typeof attrGroups === 'object' && "_t" in attrGroups && typeof attrGroups._t === "string") {
-                        deviceTypeName = attrGroups._t || "";
-                    } else {
-                        console.warn(`DeviceManager missing device type attrGroups ${JSON.stringify(attrGroups)}`);
-                        return;
-                    }
-
                     // Get the device type info
                     const deviceTypeInfo = await this.getDeviceTypeInfo(busName, devAddr, deviceTypeName);
 
@@ -174,6 +330,9 @@ export class DeviceManager implements RaftDeviceMgrIF{
                     if (deviceKey in this._devicesState) {
                         if (deviceTypeInfo !== undefined) {
                             this._devicesState[deviceKey].deviceTypeInfo = deviceTypeInfo;
+                            this._devicesState[deviceKey].deviceType = deviceTypeName;
+                            this._devicesState[deviceKey].deviceAddress = devAddr;
+                            this._devicesState[deviceKey].busName = busName;
                         }
                     } else {
                         // Create device record - device type info may be undefined
@@ -187,7 +346,10 @@ export class DeviceManager implements RaftDeviceMgrIF{
                             deviceAttributes: {},
                             deviceIsNew: true,
                             stateChanged: false,
-                            isOnline: true
+                            isOnline: true,
+                            deviceAddress: devAddr,
+                            deviceType: deviceTypeName,
+                            busName: busName
                         };
                     }
                 }
@@ -221,9 +383,6 @@ export class DeviceManager implements RaftDeviceMgrIF{
                     // Convert the hex string to an arraybuffer by converting each pair of hex chars to a byte
                     const msgBytes = this.hexToBytes(msgHexStr);
 
-                    // Convert to a Buffer
-                    const msgBuffer = Buffer.from(msgBytes);
-
                     // Work through the message which may contain multiple data instances
                     let msgBufIdx = 0;
 
@@ -234,7 +393,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
                     while (msgBufIdx < msgBytes.length) {
 
                         const curTimelineLen = deviceState.deviceTimeline.timestampsUs.length;
-                        const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(msgBuffer, msgBufIdx,
+                        const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(msgBytes, msgBufIdx,
                             deviceState.deviceTimeline, pollRespMetadata,
                             deviceState.deviceAttributes,
                             this._maxDatapointsToStore);
@@ -274,33 +433,18 @@ export class DeviceManager implements RaftDeviceMgrIF{
 
             // Check if device record is new
             if (deviceState.deviceIsNew) {
-                if (this._callbackNewDevice) {
-                    this._callbackNewDevice(
-                        deviceKey,
-                        deviceState
-                    );
-                }
+                this._newDeviceCallbacks.forEach((cb) => cb(deviceKey, deviceState));
                 deviceState.deviceIsNew = false;
             }
 
             // Iterate over the attributes
-            Object.entries(deviceState.deviceAttributes).forEach(([_attrKey, attrState]) => {
+            Object.entries(deviceState.deviceAttributes).forEach(([, attrState]): void => {
                 if (attrState.newAttribute) {
-                    if (this._callbackNewDeviceAttribute) {
-                        this._callbackNewDeviceAttribute(
-                            deviceKey,
-                            attrState
-                        );
-                    }
+                    this._newDeviceAttributeCallbacks.forEach((cb) => cb(deviceKey, attrState));
                     attrState.newAttribute = false;
                 }
                 if (attrState.newData) {
-                    if (this._callbackNewAttributeData) {
-                        this._callbackNewAttributeData(
-                            deviceKey,
-                            attrState
-                        );
-                    }
+                    this._newAttributeDataCallbacks.forEach((cb) => cb(deviceKey, attrState));
                     attrState.newData = false;
                 }
             });
@@ -352,17 +496,45 @@ export class DeviceManager implements RaftDeviceMgrIF{
     // Send action to device
     ////////////////////////////////////////////////////////////////////////////
 
-    public async sendAction(deviceKey: string, action: DeviceTypeAction, data: DataType[]): Promise<boolean> {
+    private toHex(data: Uint8Array): string {
+        return Array.from(data)
+            .map(byte => byte.toString(16).padStart(2, "0"))
+            .join("");
+    }
+
+    public async sendAction(deviceKey: string, action: DeviceTypeAction, data: number[]): Promise<boolean> {
         // console.log(`DeviceManager sendAction ${deviceKey} action name ${action.n} value ${value} prefix ${action.w}`);
 
-        // Form the write bytes
-        let writeBytes = action.t ? struct.pack(action.t, data) : Buffer.from([]);
+        let writeBytes: Uint8Array;
+
+        // Check for one data item
+        if (data.length === 1) {
+
+            let value = data[0];
+
+            // Check for conversion
+            if (action.sub !== undefined) {
+                value = value - action.sub;
+            }
+            if (action.mul !== undefined) {
+                value = value * action.mul;
+            }
+
+            // Form the write bytes
+            writeBytes = action.t ? structPack(action.t, [value]) : new Uint8Array(0);
+
+        } else
+        {
+
+            // Form the write bytes which may have multiple data items
+            writeBytes = action.t ? structPack(action.t, data) : new Uint8Array(0);
+        }
 
         // Convert to hex string
-        let writeHexStr = Buffer.from(writeBytes).toString('hex');
+        let writeHexStr = this.toHex(writeBytes);
 
-        // Add prefix
-        writeHexStr = action.w + writeHexStr;
+        // Add prefix and postfix
+        writeHexStr = (action.w ? action.w : "") + writeHexStr + (action.wz ? action.wz : "");
 
         // Separate the bus and address in the deviceKey (_ char)
         const devBus = deviceKey.split("_")[0]
@@ -380,7 +552,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             const msgHandler = this._systemUtils?.getMsgHandler();
             if (msgHandler) {
                 const msgRslt = await msgHandler.sendRICRESTURL<RaftOKFail>(cmd);
-                return msgRslt.isOk();
+                return msgRslt.rslt === "ok";
             }
             return false;
         } catch (error) {
@@ -393,13 +565,13 @@ export class DeviceManager implements RaftDeviceMgrIF{
     // Send a compound action to the device
     ////////////////////////////////////////////////////////////////////////////
 
-    public async sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: DataType[][]): Promise<boolean> {
+    public async sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: number[][]): Promise<boolean> {
         // console.log(`DeviceManager sendAction ${deviceKey} action name ${action.n} value ${value} prefix ${action.w}`);
 
         // Check if all data to be sent at once
         if (action.concat) {
             // Form a single list by flattening data
-            let dataToWrite: DataType[] = [];
+            let dataToWrite: number[] = [];
             for (let dataIdx = 0; dataIdx < data.length; dataIdx++) {
                 dataToWrite = dataToWrite.concat(data[dataIdx]);
             }
@@ -412,7 +584,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             for (let dataIdx = 0; dataIdx < data.length; dataIdx++) {
 
                 // Create the data to write by prepending the index to the data for this index
-                let dataToWrite = [dataIdx as DataType].concat(data[dataIdx]);
+                const dataToWrite = [dataIdx as number].concat(data[dataIdx]);
 
                 // Use sendAction to send this
                 allOk = allOk && await this.sendAction(deviceKey, action, dataToWrite);
@@ -432,5 +604,4 @@ export class DeviceManager implements RaftDeviceMgrIF{
         }
         return bytes;
     }
-
 }

package/src/RaftDeviceMgrIF.ts

@@ -7,7 +7,6 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-import { DataType } from "python-struct";
 import { DeviceTypeAction } from "./RaftDeviceInfo";
 import { DeviceAttributeState, DevicesState, DeviceState } from "./RaftDeviceStates";
 
@@ -17,12 +16,18 @@ export default interface RaftDeviceMgrIF {
     getDevicesState(): DevicesState;
     getDeviceState(deviceKey: string): DeviceState;
 
+    // Settings
+    setMaxDataPointsToStore(maxDataPointsToStore: number): void;
+
     // Callbacks
-    onNewDevice(callback: (deviceKey: string, state: DeviceState) => void): void;
-    onNewDeviceAttribute(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
-    onNewAttributeData(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
+    addNewDeviceCallback(callback: (deviceKey: string, state: DeviceState) => void): void;
+    removeNewDeviceCallback(callback: (deviceKey: string, state: DeviceState) => void): void;
+    addNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
+    removeNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
+    addAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
+    removeAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
 
     // Send action to device
-    sendAction(deviceKey: string, action: DeviceTypeAction, data: DataType[]): void;
-    sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: DataType[][]): void;
+    sendAction(deviceKey: string, action: DeviceTypeAction, data: number[]): void;
+    sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: number[][]): void;
 }

package/src/RaftDeviceStates.ts

@@ -30,7 +30,7 @@ export function deviceAttrGetLatestFormatted(attrState: DeviceAttributeState): s
             decimalPlaces = parseInt(parts[1], 10);
         }
         const formattedNumber = value.toFixed(decimalPlaces);
-        let fieldWidth = parseInt(parts[0], 10);
+        const fieldWidth = parseInt(parts[0], 10);
         return fieldWidth ? formattedNumber.padStart(fieldWidth, ' ') : formattedNumber;
     } else if (format.endsWith('x')) {
         // Hexadecimal formatting
@@ -51,6 +51,7 @@ export interface DeviceAttributeState {
     name: string;
     newAttribute: boolean;
     newData: boolean;
+    numNewValues: number;
     values: number[];
     units: string;
     range: number[];
@@ -76,6 +77,9 @@ export interface DeviceState {
     deviceIsNew: boolean;
     stateChanged: boolean;
     isOnline: boolean;
+    deviceAddress: string;
+    deviceType: string;
+    busName: string;
 }
 
 export class DevicesState {
@@ -83,6 +87,6 @@ export class DevicesState {
 }
 
 // Add the getDeviceKey method to generate a composite key
-export function getDeviceKey(busName: string, devAddr: string): string {
-    return `${busName}_${devAddr}`;
+export function getDeviceKey(busName: string, devAddr: string, devType: string): string {
+    return `${busName}_${devAddr}_${devType}`;
 }

package/src/RaftMsgHandler.ts

@@ -571,7 +571,6 @@ export default class RaftMsgHandler {
     // if (msgRsltCode === RaftMsgResultCode.MESSAGE_RESULT_OK) {
     const resolve = this._msgTrackInfos[msgNum].resolve;
     if (resolve) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       RaftLog.verbose(`_msgCompleted msgNum ${msgNum} result ${msgRsltCode.toString()} ${JSON.stringify(msgRsltObj)}`);
       (resolve as ((arg: object | null) => void))(msgRsltObj);
     }
@@ -679,7 +678,7 @@ export default class RaftMsgHandler {
     // RICREST protocol
     msgBuf[msgBufPos++] = RICRESTElemCode.RICREST_ELEM_CODE_FILEBLOCK;
 
-    // Buffer header
+    // Header
     msgBuf[msgBufPos++] = streamID & 0xff;
     msgBuf[msgBufPos++] = (blockStart >> 16) & 0xff;
     msgBuf[msgBufPos++] = (blockStart >> 8) & 0xff;