@robdobsn/raftjs 1.10.7 → 1.11.5

package/src/RaftDeviceManager.ts

@@ -7,7 +7,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-import { DeviceAttributeState, DeviceAttributesState, DevicesState, DeviceState, getDeviceKey } from "./RaftDeviceStates";
+import { DeviceAttributeState, DeviceAttributesState, DevicesState, DeviceState, DeviceStats, DeviceOnlineState, formatDeviceAddrHex, getDeviceKey, parseDeviceKey } from "./RaftDeviceStates";
 import { DeviceMsgJson } from "./RaftDeviceMsg";
 import { RaftOKFail } from './RaftTypes';
 import { DeviceTypeInfo, DeviceTypeAction, DeviceTypeInfoRecs, RaftDevTypeInfoResponse } from "./RaftDeviceInfo";
@@ -29,6 +29,10 @@ export interface DeviceDecodedData {
     fromOfflineBuffer?: boolean;
 }
 
+interface DeviceStatsInternal extends DeviceStats {
+    windowEvents: Array<{ timeMs: number; samples: number }>;
+}
+
 export class DeviceManager implements RaftDeviceMgrIF{
 
     // Max data points to store
@@ -58,10 +62,15 @@ export class DeviceManager implements RaftDeviceMgrIF{
     private _newDeviceAttributeCallbacks: Array<(deviceKey: string, attrState: DeviceAttributeState) => void> = [];
     private _newAttributeDataCallbacks: Array<(deviceKey: string, attrState: DeviceAttributeState) => void> = [];
     private _decodedDataCallbacks: Array<(decoded: DeviceDecodedData) => void> = [];
+    private _deviceRemovedCallbacks: Array<(deviceKey: string, state: DeviceState) => void> = [];
 
     // Debug message index (to help debug with async messages)
     private _debugMsgIndex = 0;
 
+    // Device stats (sample counts, rates)
+    private _statsWindowMs = 5000;
+    private _deviceStats: { [deviceKey: string]: DeviceStatsInternal } = {};
+
     public getDevicesState(): DevicesState {
         return this._devicesState;
     }
@@ -70,6 +79,14 @@ export class DeviceManager implements RaftDeviceMgrIF{
         return this._devicesState[deviceKey];
     }
 
+    public getDeviceStats(deviceKey: string): DeviceStats {
+        return this.cloneDeviceStats(this.getOrCreateDeviceStats(deviceKey));
+    }
+
+    public resetDeviceStats(deviceKey: string): void {
+        this._deviceStats[deviceKey] = this.createEmptyStats();
+    }
+
     // Cached device type data
     private _cachedDeviceTypeRecs: DeviceTypeInfoRecs = {};
 
@@ -169,6 +186,16 @@ export class DeviceManager implements RaftDeviceMgrIF{
         this._decodedDataCallbacks = this._decodedDataCallbacks.filter((cb) => cb !== callback);
     }
 
+    public addDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
+        if (!this._deviceRemovedCallbacks.includes(callback)) {
+            this._deviceRemovedCallbacks.push(callback);
+        }
+    }
+
+    public removeDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
+        this._deviceRemovedCallbacks = this._deviceRemovedCallbacks.filter((cb) => cb !== callback);
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // Set the friendly name for the device
     ////////////////////////////////////////////////////////////////////////////
@@ -185,79 +212,129 @@ export class DeviceManager implements RaftDeviceMgrIF{
     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 0002 4ae1 0787052606240007  000e 80 00000000 0003 0006 030001af01
-        // 0080  0011 80 00000000 0002 e46e 061e05a206830433  0010 80000000000003e4760006030001c701
-        // 0080  0010 81 00000015 0004 e4a2 0650fe00305002    0011 80000000000002e4a8061f059f06850438   001080000000000003e4aa0006030001c701
-        
-        // 0080  0011 80 00000000 0002 31e4 05ea05a506660137  000e 80 00000000 0003 0007 030001d901
-
-        // 0080  0011 80 00000000 0002 4d63 0792053e06500061  000e 80 00000000 0003 0005 030001de01
-
-        // 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 section length bytes themselves
-        //   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
+        // DevBIN message format
+        //
+        // The rxMsg passed to this function has a 2-byte message type prefix (e.g. 0x0080)
+        // added by the transport layer. After that prefix comes a devbin frame:
+        //
+        // Devbin envelope (2 bytes):
+        //   Byte 0: magic+version  0xDB = devbin v1 (valid range 0xDB–0xDF for v1–v5)
+        //   Byte 1: topicIndex     0x00–0xFE = topic index; 0xFF = no topic
+        //
+        // Then zero or more per-device records, concatenated back-to-back:
+        //   Bytes 0-1:  recordLen    uint16 big-endian — number of body bytes that follow (min 7)
+        //   Byte  2:    statusBus    bit 7 = online flag, bit 6 = pending deletion, bits 5:4 = reserved, bits 3:0 = bus number (0-15)
+        //   Bytes 3-6:  address      uint32 big-endian — device address on the bus
+        //   Bytes 7-8:  devTypeIdx   uint16 big-endian — device type table index
+        //   Bytes 9+:   pollData     variable length (recordLen − 7 bytes) — device data
+        //
+        // Example message (with transport prefix):
+        //   0080 DB01 0015 81 0000076a 000b bff10000ffffffff7a07d1f1221c 000e 80 00000000 001f bc340000030001
+        //   ^^^^ ^^^^                                                     ^^^^
+        //   |    |  |  ||   |          |    |                              Record 2 ...
+        //   |    |  |  ||   |          |    pollData (14 bytes)
+        //   |    |  |  ||   |          devTypeIdx = 0x000b (11)
+        //   |    |  |  ||   address = 0x0000076a (slot 7, I2C addr 0x6a)
+        //   |    |  |  |busInfo = 0x81 (bus 1, online)
+        //   |    |  |  recordLen = 0x0015 (21 bytes)
+        //   |    |  topicIndex = 0x01
+        //   |    magic+version = 0xDB (devbin v1)
+        //   msgType prefix (transport layer)
 
         // Debug
         // const debugMsgTime = Date.now();
         const debugMsgIndex = this._debugMsgIndex++;
 
-        // Message layout
-        const msgTypeLen = 2; // Length of the message type (first two bytes)
-        const sectionLengthLen = 2; // Length of the inclusive section length (first two bytes of each section)
-        const sectionConnectionModeLen = 1; // Length of the connection mode (next byte after section length)
-        const sectionDeviceAddrLen = 4; // Length of the device address (next 4 bytes after connection mode)
-        const sectionDeviceTypeIdxLen = 2; // Length of the device type index (next 2 bytes after device address)
-        const sectionHeaderLen = sectionConnectionModeLen + sectionDeviceAddrLen + sectionDeviceTypeIdxLen;
+        // Message layout constants
+        const msgTypeLen = 2; // Transport-layer message type prefix (first two bytes, e.g. 0x0080)
+        const devbinEnvelopeLen = 2; // Devbin envelope: magic+version (1 byte) + topicIndex (1 byte)
+        const devbinMagicMin = 0xDB;
+        const devbinMagicMax = 0xDF;
+        const recordLenLen = 2; // Per-record length prefix (uint16 big-endian)
+        const busInfoLen = 1; // statusBus byte: bit 7 = online, bit 6 = pending deletion, bits 3:0 = bus number
+        const deviceAddrLen = 4; // Device address (uint32 big-endian)
+        const devTypeIdxLen = 2; // Device type index (uint16 big-endian)
+        const recordHeaderLen = busInfoLen + deviceAddrLen + devTypeIdxLen; // = 7, minimum record body
 
         // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} rxMsg.length ${rxMsg.length} rxMsg ${RaftUtils.bufferToHex(rxMsg)}`);
 
         // Start after the message type
         let msgPos = msgTypeLen;
 
-        // Iterate through sections
+        // Check for devbin envelope (magic+version + topicIndex)
+        if (rxMsg.length >= msgTypeLen + devbinEnvelopeLen) {
+            const envelopeMagicVer = rxMsg[msgTypeLen];
+            if ((envelopeMagicVer & 0xF0) === 0xD0) {
+                if ((envelopeMagicVer < devbinMagicMin) || (envelopeMagicVer > devbinMagicMax)) {
+                    console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid devbin envelope magic/version ${envelopeMagicVer}`);
+                    return;
+                }
+
+                const topicIndex = rxMsg[msgTypeLen + 1];
+                if (topicIndex !== 0xFF) {
+                    const topicName = this._systemUtils?.getPublishTopicName(topicIndex);
+                    if (topicName && topicName !== "devbin") {
+                        return;
+                    }
+                }
+
+                msgPos += devbinEnvelopeLen;
+            }
+        }
+
+        // Iterate through device records
         while (msgPos < rxMsg.length) {
 
-            // Check length
+            // Check minimum length for record length prefix + record header
             const remainingLen = rxMsg.length - msgPos;
-            if (remainingLen < sectionLengthLen + sectionHeaderLen) {
-                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid length ${rxMsg.length} < ${sectionLengthLen + sectionHeaderLen + msgPos}`);
+            if (remainingLen < recordLenLen + recordHeaderLen) {
+                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid length ${rxMsg.length} < ${recordLenLen + recordHeaderLen + msgPos}`);
                 return;
             }
 
-            // Get the length of the section
-            const sectionLen = (rxMsg[msgPos] << 8) + rxMsg[msgPos + 1];
-            if (sectionLen > remainingLen + sectionLengthLen) {
-                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid msgPos ${msgPos} msgLen ${sectionLen} remainingLenAfterLenBytes ${remainingLen-sectionLengthLen}`);
+            // Get the record body length (bytes that follow the 2-byte length prefix)
+            const recordLen = (rxMsg[msgPos] << 8) + rxMsg[msgPos + 1];
+            if (recordLen > remainingLen - recordLenLen) {
+                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid msgPos ${msgPos} recordLen ${recordLen} remainingAfterLenBytes ${remainingLen - recordLenLen}`);
                 return;
             }
 
-            // Extract message elements
-            let sectionPos = msgPos + sectionLengthLen;
-            const busNum = rxMsg[sectionPos] & 0x7f;
-            const isOnline = (rxMsg[sectionPos] & 0x80) !== 0;
-            sectionPos += sectionConnectionModeLen;
-            // Get the device address and type index
-            const devAddr = (rxMsg[sectionPos] << 24) + (rxMsg[sectionPos + 1] << 16) + (rxMsg[sectionPos + 2] << 8) + rxMsg[sectionPos + 3];
-            sectionPos += sectionDeviceAddrLen;
-            const devTypeIdx = (rxMsg[sectionPos] << 8) + rxMsg[sectionPos + 1];
-            let attrGroupPos = sectionPos + sectionDeviceTypeIdxLen;
+            // Extract record header fields
+            let recordPos = msgPos + recordLenLen;
+
+            // statusBus byte: bit 7 = online, bit 6 = pending deletion, bits 3:0 = bus number
+            const statusByte = rxMsg[recordPos];
+            const busNum = statusByte & 0x0f;
+            const isOnline = (statusByte & 0x80) !== 0;
+            const isPendingDeletion = (statusByte & 0x40) !== 0;
+            recordPos += busInfoLen;
+
+            // Device address (uint32 big-endian)
+            const devAddr = (rxMsg[recordPos] << 24) + (rxMsg[recordPos + 1] << 16) + (rxMsg[recordPos + 2] << 8) + rxMsg[recordPos + 3];
+            recordPos += deviceAddrLen;
+
+            // Device type index (uint16 big-endian)
+            const devTypeIdx = (rxMsg[recordPos] << 8) + rxMsg[recordPos + 1];
+            let pollDataPos = recordPos + devTypeIdxLen;
 
             // Debug
-            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} overallLen ${rxMsg.length} sectionPos ${msgPos} sectionLen ${sectionLen} ${attrGroupPos} ${RaftUtils.bufferToHex(rxMsg.slice(msgPos, msgPos + sectionLen))}`);
-            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} connMode ${busNum} isOnline ${isOnline} devAddr ${devAddr} devTypeIdx ${devTypeIdx} attrGroupDataLen ${sectionLen - sectionHeaderLen}`);
+            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} overallLen ${rxMsg.length} recordStart ${msgPos} recordLen ${recordLen} ${pollDataPos} ${RaftUtils.bufferToHex(rxMsg.slice(msgPos, msgPos + recordLenLen + recordLen))}`);
+            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} bus ${busNum} isOnline ${isOnline} devAddr 0x${devAddr.toString(16)} devTypeIdx ${devTypeIdx} pollDataLen ${recordLen - recordHeaderLen}`);
 
-            // Device key
-            const deviceKey = getDeviceKey(busNum.toString(), devAddr.toString(16));
+            // Format device address as canonical hex and build device key
+            const devAddrHex = formatDeviceAddrHex(devAddr);
+            const deviceKey = getDeviceKey(busNum.toString(), devAddrHex);
 
             // Update the last update time
             this._deviceLastUpdateTime[deviceKey] = Date.now();
 
+            // Handle pending deletion - remove device and skip further processing
+            if (isPendingDeletion) {
+                this.removeDevice(deviceKey);
+                msgPos += recordLenLen + recordLen;
+                continue;
+            }
+
             // Check if a device state already exists
             if (!(deviceKey in this._devicesState) || (this._devicesState[deviceKey].deviceTypeInfo === undefined)) {
 
@@ -265,13 +342,13 @@ export class DeviceManager implements RaftDeviceMgrIF{
                 const deviceTypeInfo = await this.getDeviceTypeInfo(busNum.toString(), devTypeIdx.toString());
                 
                 // Debug
-                // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} busNum ${busNum} devAddr ${devAddr} devTypeIdx ${devTypeIdx} deviceTypeInfo ${JSON.stringify(deviceTypeInfo)}`);
+                // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} busNum ${busNum} devAddr 0x${devAddr.toString(16)} devTypeIdx ${devTypeIdx} deviceTypeInfo ${JSON.stringify(deviceTypeInfo)}`);
 
                 // Handle case where device type info is not available
                 if (deviceTypeInfo === undefined) {
-                    console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} deviceType ${devTypeIdx} info not available, skipping attribute processing for this section`);
-                    // Skip to next section without processing attributes
-                    msgPos += sectionLengthLen + sectionLen;
+                    console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} deviceType ${devTypeIdx} info not available, skipping attribute processing for this record`);
+                    // Skip to next record without processing attributes
+                    msgPos += recordLenLen + recordLen;
                     continue;
                 }
 
@@ -281,7 +358,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
                         this._devicesState[deviceKey].deviceTypeInfo = deviceTypeInfo;
                         this._devicesState[deviceKey].deviceType = deviceTypeInfo.name || "";
                         this._devicesState[deviceKey].busName = busNum.toString();
-                        this._devicesState[deviceKey].deviceAddress = devAddr.toString();
+                        this._devicesState[deviceKey].deviceAddress = devAddrHex;
                     }
                 } else {
                     // Create device record - device type info may be undefined
@@ -295,8 +372,8 @@ export class DeviceManager implements RaftDeviceMgrIF{
                         deviceAttributes: {},
                         deviceIsNew: true,
                         stateChanged: false,
-                        isOnline: true,
-                        deviceAddress: devAddr.toString(),
+                        onlineState: DeviceOnlineState.Online,
+                        deviceAddress: devAddrHex,
                         deviceType: deviceTypeInfo?.name || "",
                         busName: busNum.toString()
                     };
@@ -305,7 +382,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
 
             // Get device state
             const deviceState = this._devicesState[deviceKey];
-            deviceState.isOnline = isOnline;
+            deviceState.onlineState = isOnline ? DeviceOnlineState.Online : DeviceOnlineState.Offline;
             
             // Check if device type info is available and complete
             if (deviceState.deviceTypeInfo && deviceState.deviceTypeInfo.resp) {
@@ -313,25 +390,25 @@ export class DeviceManager implements RaftDeviceMgrIF{
                 // Iterate over attributes in the group
                 const pollRespMetadata = deviceState.deviceTypeInfo!.resp!;
 
-                // Iterate over attribute groups
-                const attrGroupDataLen = sectionLen - sectionHeaderLen;
-                const attrGroupStartPos = attrGroupPos;
+                // Process poll data (recordLen - recordHeaderLen bytes)
+                const pollDataLen = recordLen - recordHeaderLen;
+                const pollDataStartPos = pollDataPos;
                 const attrLengthsBefore = this.snapshotAttrLengths(deviceState.deviceAttributes, pollRespMetadata);
                 const timelineLenBefore = deviceState.deviceTimeline.timestampsUs.length;
-                while (attrGroupPos < attrGroupStartPos + attrGroupDataLen) {
+                while (pollDataPos < pollDataStartPos + pollDataLen) {
 
                     // Add bounds checking
-                    if (attrGroupPos >= rxMsg.length) {
-                        console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} exceeds message length ${rxMsg.length}`);
+                    if (pollDataPos >= rxMsg.length) {
+                        console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} exceeds message length ${rxMsg.length}`);
                         break;
                     }
 
-                    const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, attrGroupPos,
+                    const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, pollDataPos,
                         deviceState.deviceTimeline, pollRespMetadata,
                         deviceState.deviceAttributes,
                         this._maxDatapointsToStore);
 
-                    // console.log(`DevMan.handleClientMsgBinary decoded debugIdx ${debugMsgIndex} devType ${deviceState.deviceTypeInfo.name} attrGroupDataLen ${attrGroupDataLen} attrGroupPos ${attrGroupPos} sectionLen ${sectionLen} msgPos ${msgPos} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen} pollRespMetadata ${JSON.stringify(pollRespMetadata)}`);
+                    // console.log(`DevMan.handleClientMsgBinary decoded debugIdx ${debugMsgIndex} devType ${deviceState.deviceTypeInfo.name} pollDataLen ${pollDataLen} pollDataPos ${pollDataPos} recordLen ${recordLen} msgPos ${msgPos} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen} pollRespMetadata ${JSON.stringify(pollRespMetadata)}`);
 
                     if (newMsgBufIdx < 0)
                     {
@@ -340,32 +417,34 @@ export class DeviceManager implements RaftDeviceMgrIF{
                     }
                     
                     // Prevent infinite loops
-                    if (newMsgBufIdx <= attrGroupPos) {
-                        console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} processMsgAttrGroup didn't advance position from ${attrGroupPos} to ${newMsgBufIdx}`);
+                    if (newMsgBufIdx <= pollDataPos) {
+                        console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} processMsgAttrGroup didn't advance position from ${pollDataPos} to ${newMsgBufIdx}`);
                         break;
                     }
 
-                    attrGroupPos = newMsgBufIdx;
+                    pollDataPos = newMsgBufIdx;
                     deviceState.stateChanged = true;
 
                     // console.log(`debugMsgTime ${debugMsgTime} newPt debugMsgIdx ${debugMsgIndex} rxMsgLen ${rxMsg.length} devType ${deviceState.deviceTypeInfo!.name} timestampsUs ${deviceState.deviceTimeline.timestampsUs[deviceState.deviceTimeline.timestampsUs.length - 1]} curTimelineLen ${deviceState.deviceTimeline.timestampsUs.length}`);
 
-
-                    // console.log(`DevMan.handleClientMsgBinary group done debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} sectionLen ${sectionLen} msgPos ${msgPos} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen}`);
+                    // console.log(`DevMan.handleClientMsgBinary group done debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} recordLen ${recordLen} msgPos ${msgPos} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen}`);
                 }
 
                 // Inform decoded-data callbacks
-                this.emitDecodedData(deviceKey, busNum.toString(), devAddr.toString(), deviceState,
+                this.emitDecodedData(deviceKey, busNum.toString(), devAddrHex, deviceState,
                     pollRespMetadata, attrLengthsBefore, timelineLenBefore);
+
+                const newSamples = deviceState.deviceTimeline.timestampsUs.length - timelineLenBefore;
+                this.updateDeviceStats(deviceKey, newSamples, Date.now());
             } else {
                 console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} deviceState incomplete for device ${deviceKey}, skipping attribute processing`);
             }
 
             // Debug
-            // console.log(`DevMan.handleClientMsgBinary section done debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} sectionLen ${sectionLen} msgPos ${msgPos} newMsgPos ${msgPos + sectionLengthLen + sectionLen} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen}`);
+            // console.log(`DevMan.handleClientMsgBinary record done debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} recordLen ${recordLen} msgPos ${msgPos} newMsgPos ${msgPos + recordLenLen + recordLen} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen}`);
 
-            // Move to next message
-            msgPos += sectionLengthLen + sectionLen;
+            // Advance past this record (recordLenLen + recordLen bytes)
+            msgPos += recordLenLen + recordLen;
         }
 
         // Check for devices that have not been updated for a while
@@ -374,6 +453,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             Object.entries(this._deviceLastUpdateTime).forEach(([deviceKey, lastUpdateTime]) => {
                 if ((nowTime - lastUpdateTime) > this._removeDevicesTimeMs) {
                     delete this._devicesState[deviceKey];
+                    delete this._deviceStats[deviceKey];
                 }
             });
         }
@@ -394,6 +474,11 @@ export class DeviceManager implements RaftDeviceMgrIF{
         // Iterate over the buses
         Object.entries(data).forEach(([busName, devices]) => {
 
+            // Check the bus name doesn't start with _ which is reserved for non-device information such as topic name
+            if (busName.startsWith("_")) {
+                return;
+            }
+
             // Check for bus status info
             if (devices && typeof devices === "object" && "_s" in devices) {
                 // console.log(`DeviceManager bus status ${JSON.stringify(devices._s)}`);
@@ -414,7 +499,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
                 if (attrGroups && typeof attrGroups === 'object' && "_t" in attrGroups && typeof attrGroups._t === "string") {
                     deviceTypeName = attrGroups._t || "";
                 } else if (attrGroups && typeof attrGroups === 'object' && "_i" in attrGroups && typeof attrGroups._i === "number") {
-                    deviceTypeIdx = attrGroups._i || -1;
+                    deviceTypeIdx = attrGroups._i ?? -1;
                     deviceTypeName = deviceTypeIdx.toString();
                 } else
                 {
@@ -454,7 +539,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
                             deviceAttributes: {},
                             deviceIsNew: true,
                             stateChanged: false,
-                            isOnline: true,
+                            onlineState: DeviceOnlineState.Online,
                             deviceAddress: devAddr,
                             deviceType: deviceTypeName,
                             busName: busName
@@ -465,9 +550,15 @@ export class DeviceManager implements RaftDeviceMgrIF{
                 // Get device state
                 const deviceState = this._devicesState[deviceKey];
 
-                // Check for online/offline state information
+                // Check for online/offline/pending-deletion state information
                 if (attrGroups && typeof attrGroups === "object" && "_o" in attrGroups) {
-                    deviceState.isOnline = ((attrGroups._o === true) || (attrGroups._o === "1") || (attrGroups._o === 1));
+                    const onlineStateVal = typeof attrGroups._o === 'number' ? attrGroups._o : parseInt(String(attrGroups._o), 10);
+                    if (onlineStateVal === 2) {
+                        // Pending deletion - remove device and skip further processing
+                        this.removeDevice(deviceKey);
+                        return;
+                    }
+                    deviceState.onlineState = onlineStateVal === 1 ? DeviceOnlineState.Online : DeviceOnlineState.Offline;
                 }
 
                 // Check if device type info is available
@@ -517,6 +608,9 @@ export class DeviceManager implements RaftDeviceMgrIF{
 
                     this.emitDecodedData(deviceKey, busName, devAddr, deviceState, pollRespMetadata,
                         attrLengthsBefore, timelineLenBefore, attrGroupName, markers);
+
+                    const newSamples = deviceState.deviceTimeline.timestampsUs.length - timelineLenBefore;
+                    this.updateDeviceStats(deviceKey, newSamples, Date.now());
                 });
             });
         });
@@ -527,6 +621,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             Object.entries(this._deviceLastUpdateTime).forEach(([deviceKey, lastUpdateTime]) => {
                 if ((nowTime - lastUpdateTime) > this._removeDevicesTimeMs) {
                     delete this._devicesState[deviceKey];
+                    delete this._deviceStats[deviceKey];
                 }
             });
         }
@@ -564,6 +659,22 @@ export class DeviceManager implements RaftDeviceMgrIF{
         });
     }
 
+    ////////////////////////////////////////////////////////////////////////////
+    // Remove a device (e.g. on pending deletion)
+    ////////////////////////////////////////////////////////////////////////////
+
+    private removeDevice(deviceKey: string): void {
+        // Snapshot the state before removal for callbacks
+        const deviceState = this._devicesState[deviceKey];
+        if (deviceState) {
+            deviceState.onlineState = DeviceOnlineState.PendingDeletion;
+            this._deviceRemovedCallbacks.forEach((cb) => cb(deviceKey, deviceState));
+        }
+        delete this._devicesState[deviceKey];
+        delete this._deviceLastUpdateTime[deviceKey];
+        delete this._deviceStats[deviceKey];
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // Get device type info
     ////////////////////////////////////////////////////////////////////////////
@@ -686,9 +797,8 @@ export class DeviceManager implements RaftDeviceMgrIF{
         // 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]
-        const devAddr = deviceKey.split("_")[1]
+        // Parse the device key into bus and address components
+        const { bus: devBus, addr: devAddr } = parseDeviceKey(deviceKey);
 
         // Send the action to the server
         const cmd = "devman/cmdraw?bus=" + devBus + "&addr=" + devAddr + "&hexWr=" + writeHexStr;
@@ -755,6 +865,66 @@ export class DeviceManager implements RaftDeviceMgrIF{
         return bytes;
     }
 
+    ////////////////////////////////////////////////////////////////////////////
+    // Helpers for device stats
+    ////////////////////////////////////////////////////////////////////////////
+
+    private createEmptyStats(): DeviceStatsInternal {
+        return {
+            totalSamples: 0,
+            windowMs: this._statsWindowMs,
+            windowSamples: 0,
+            sampleRateHz: 0,
+            lastSampleTimeMs: null,
+            lastUpdateTimeMs: null,
+            windowEvents: []
+        };
+    }
+
+    private getOrCreateDeviceStats(deviceKey: string): DeviceStatsInternal {
+        if (!this._deviceStats[deviceKey]) {
+            this._deviceStats[deviceKey] = this.createEmptyStats();
+        }
+        return this._deviceStats[deviceKey];
+    }
+
+    private cloneDeviceStats(stats: DeviceStatsInternal): DeviceStats {
+        return {
+            totalSamples: stats.totalSamples,
+            windowMs: stats.windowMs,
+            windowSamples: stats.windowSamples,
+            sampleRateHz: stats.sampleRateHz,
+            lastSampleTimeMs: stats.lastSampleTimeMs,
+            lastUpdateTimeMs: stats.lastUpdateTimeMs
+        };
+    }
+
+    private updateDeviceStats(deviceKey: string, newSamples: number, nowMs: number): void {
+        const stats = this.getOrCreateDeviceStats(deviceKey);
+        stats.lastUpdateTimeMs = nowMs;
+
+        if (newSamples > 0) {
+            stats.totalSamples += newSamples;
+            stats.lastSampleTimeMs = nowMs;
+            stats.windowEvents.push({ timeMs: nowMs, samples: newSamples });
+        }
+
+        const windowStartMs = nowMs - stats.windowMs;
+        while (stats.windowEvents.length > 0 && stats.windowEvents[0].timeMs < windowStartMs) {
+            stats.windowEvents.shift();
+        }
+
+        const windowSamples = stats.windowEvents.reduce((sum, entry) => sum + entry.samples, 0);
+        stats.windowSamples = windowSamples;
+        if (stats.windowEvents.length === 0) {
+            stats.sampleRateHz = 0;
+            return;
+        }
+
+        const actualWindowMs = Math.max(1, nowMs - stats.windowEvents[0].timeMs);
+        stats.sampleRateHz = (windowSamples * 1000) / actualWindowMs;
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // Helpers for decoded data callbacks
     ////////////////////////////////////////////////////////////////////////////
@@ -765,7 +935,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             return lengths;
         }
         pollRespMetadata.a.forEach((attr) => {
-            lengths[attr.n] = deviceAttrs[attr.n]?.values.length || 0;
+            lengths[attr.n] = deviceAttrs[attr.n]?.values.length ?? 0;
         });
         return lengths;
     }
@@ -794,7 +964,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             if (!attrState) {
                 return;
             }
-            const prevLen = attrLengthsBefore[attr.n] || 0;
+            const prevLen = attrLengthsBefore[attr.n] ?? 0;
             if (attrState.values.length > prevLen) {
                 attrValues[attr.n] = attrState.values.slice(prevLen);
                 hasValues = hasValues || attrValues[attr.n].length > 0;

package/src/RaftDeviceMgrIF.ts

@@ -8,13 +8,15 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 import { DeviceTypeAction } from "./RaftDeviceInfo";
-import { DeviceAttributeState, DevicesState, DeviceState } from "./RaftDeviceStates";
+import { DeviceAttributeState, DevicesState, DeviceState, DeviceStats } from "./RaftDeviceStates";
 
 export default interface RaftDeviceMgrIF {
 
     // Get state of devices
     getDevicesState(): DevicesState;
     getDeviceState(deviceKey: string): DeviceState;
+    getDeviceStats(deviceKey: string): DeviceStats;
+    resetDeviceStats(deviceKey: string): void;
 
     // Settings
     setMaxDataPointsToStore(maxDataPointsToStore: number): void;
@@ -26,6 +28,8 @@ export default interface RaftDeviceMgrIF {
     removeNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
     addAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
     removeAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
+    addDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void;
+    removeDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void;
 
     // Send action to device
     sendAction(deviceKey: string, action: DeviceTypeAction, data: number[]): void;