@robotical/raftjs 2.1.0 → 2.1.2

package/examples/dashboard/src/LoggingPanel.tsx

@@ -0,0 +1,264 @@
+import React, { useEffect, useState, useRef } from 'react';
+import ConnManager from './ConnManager';
+import { LogConfig } from './LogConfigPanel';
+import { getHostPosixTZ } from '../../../src/RaftTimezone';
+import './styles.css';
+
+// Minimal query-value encoder: only encode characters that break query string parsing.
+// Unlike encodeURIComponent (which encodes ~40 chars), this keeps JSON, colons, commas
+// etc. as-is, significantly reducing message size for BLE transport.
+function encodeQueryValue(s: string): string {
+  return s.replace(/%/g, '%25').replace(/&/g, '%26').replace(/=/g, '%3D');
+}
+
+const connManager = ConnManager.getInstance();
+
+interface LogStatus {
+  isLogging: boolean;
+  fileName: string;
+  elapsedSecs: number;
+  bytesWritten: number;
+  samples: number;
+  flushCount: number;
+  bufferOverflows: number;
+  avgWriteMs: number;
+  maxWriteMs: number;
+  bytesPerSec: number;
+}
+
+const emptyStatus: LogStatus = {
+  isLogging: false,
+  fileName: '',
+  elapsedSecs: 0,
+  bytesWritten: 0,
+  samples: 0,
+  flushCount: 0,
+  bufferOverflows: 0,
+  avgWriteMs: 0,
+  maxWriteMs: 0,
+  bytesPerSec: 0,
+};
+
+interface LoggingPanelProps {
+  onLogStopped?: () => void;
+  pausePolling?: boolean;
+  logConfig?: LogConfig | null;
+}
+
+export default function LoggingPanel({ onLogStopped, pausePolling, logConfig }: LoggingPanelProps) {
+  const [status, setStatus] = useState<LogStatus>(emptyStatus);
+  const [label, setLabel] = useState('');
+  const [isBusy, setIsBusy] = useState(false);
+  const [lastError, setLastError] = useState('');
+  const pollTimerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const wasLoggingRef = useRef(false);
+
+  const fetchStatus = async () => {
+    if (!connManager.getConnector().isConnected()) return;
+    try {
+      const resp = await connManager.getConnector().sendRICRESTMsg(
+        'datalog?action=status', {}
+      );
+      if (resp && typeof resp === 'object') {
+        const r = resp as any;
+        const flushLatency = r.flushLatency ?? {};
+        const nowLogging = r.active ?? false;
+        setStatus({
+          isLogging: nowLogging,
+          fileName: r.fileName ?? '',
+          elapsedSecs: (r.durationMs ?? 0) / 1000,
+          bytesWritten: r.totalBytesWritten ?? 0,
+          samples: r.samples ?? 0,
+          flushCount: r.flushCount ?? 0,
+          bufferOverflows: r.bufferOverflows ?? 0,
+          avgWriteMs: (flushLatency.avgUs ?? 0) / 1000,
+          maxWriteMs: (flushLatency.maxUs ?? 0) / 1000,
+          bytesPerSec: r.bytesPerSec ?? 0,
+        });
+        // Detect timed logging session that finished on its own
+        if (wasLoggingRef.current && !nowLogging) {
+          onLogStopped?.();
+        }
+        wasLoggingRef.current = nowLogging;
+      }
+    } catch (e) {
+      console.warn('Failed to fetch logging status', e);
+    }
+  };
+
+  // Poll status every 2 seconds (paused during file downloads)
+  useEffect(() => {
+    if (pausePolling) {
+      if (pollTimerRef.current) clearInterval(pollTimerRef.current);
+      pollTimerRef.current = null;
+      return;
+    }
+    fetchStatus();
+    pollTimerRef.current = setInterval(fetchStatus, 2000);
+    return () => {
+      if (pollTimerRef.current) clearInterval(pollTimerRef.current);
+    };
+  }, [pausePolling]);
+
+  const handleStart = async () => {
+    setIsBusy(true);
+    setLastError('');
+    try {
+      const labelParam = label.trim() ? `&label=${encodeQueryValue(label.trim())}` : '';
+      let configParam = '';
+      if (logConfig && logConfig.devices.length > 0) {
+        configParam = `&config=${encodeQueryValue(JSON.stringify(logConfig))}`;
+      }
+      // Include current UTC time so firmware can timestamp the log even without NTP
+      const utcParam = `&UTC=${encodeQueryValue(new Date().toISOString().replace(/\.\d{3}Z$/, 'Z'))}`;
+      const posixTZ = getHostPosixTZ();
+      const tzParam = posixTZ ? `&tz=${encodeQueryValue(posixTZ)}` : '';
+      const resp = await connManager.getConnector().sendRICRESTMsg(
+        `datalog?action=start${labelParam}${configParam}${utcParam}${tzParam}`, {}
+      );
+      const r = resp as any;
+      if (r?.rslt !== 'ok') {
+        setLastError(r?.error || 'Start failed');
+      }
+      await fetchStatus();
+    } catch (e) {
+      setLastError('Failed to send start command');
+    }
+    setIsBusy(false);
+  };
+
+  const handleStop = async () => {
+    setIsBusy(true);
+    setLastError('');
+    try {
+      const resp = await connManager.getConnector().sendRICRESTMsg(
+        'datalog?action=stop', {}
+      );
+      const r = resp as any;
+      if (r?.rslt !== 'ok') {
+        setLastError(r?.error || 'Stop failed');
+      }
+      await fetchStatus();
+      onLogStopped?.();
+    } catch (e) {
+      setLastError('Failed to send stop command');
+    }
+    setIsBusy(false);
+  };
+
+  const handleSimulate = async () => {
+    setIsBusy(true);
+    setLastError('');
+    try {
+      const resp = await connManager.getConnector().sendRICRESTMsg(
+        'datalog?action=simulate', {}
+      );
+      const r = resp as any;
+      if (r?.rslt !== 'ok') {
+        setLastError(r?.error || 'Simulate failed');
+      }
+      await fetchStatus();
+    } catch (e) {
+      setLastError('Failed to send simulate command');
+    }
+    setIsBusy(false);
+  };
+
+  const formatBytes = (bytes: number): string => {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  };
+
+  const formatDuration = (secs: number): string => {
+    const h = Math.floor(secs / 3600);
+    const m = Math.floor((secs % 3600) / 60);
+    const s = Math.floor(secs % 60);
+    if (h > 0) return `${h}h ${m}m ${s}s`;
+    if (m > 0) return `${m}m ${s}s`;
+    return `${s}s`;
+  };
+
+  return (
+    <div className="info-box logging-panel">
+      <h3>Data Logging</h3>
+
+      {status.isLogging ? (
+        <>
+          <div className="logging-status-active">
+            <div className="logging-indicator" />
+            <span>Logging Active</span>
+          </div>
+          <div className="info">
+            <div className="info-line">
+              <div className="info-label">File:</div>
+              <div className="info-value">{status.fileName}</div>
+            </div>
+            <div className="info-line">
+              <div className="info-label">Duration:</div>
+              <div className="info-value">{formatDuration(status.elapsedSecs)}</div>
+            </div>
+            <div className="info-line">
+              <div className="info-label">Written:</div>
+              <div className="info-value">{formatBytes(status.bytesWritten)}</div>
+            </div>
+            <div className="info-line">
+              <div className="info-label">Writes:</div>
+              <div className="info-value">{status.flushCount} flushes, {status.samples} samples (overflows: {status.bufferOverflows})</div>
+            </div>
+            <div className="info-line">
+              <div className="info-label">Write time:</div>
+              <div className="info-value">avg {status.avgWriteMs.toFixed(1)}ms, max {status.maxWriteMs.toFixed(1)}ms</div>
+            </div>
+            {status.bytesPerSec > 0 && (
+              <div className="info-line">
+                <div className="info-label">Rate:</div>
+                <div className="info-value">{formatBytes(status.bytesPerSec)}/s</div>
+              </div>
+            )}
+          </div>
+          <button
+            className="action-button logging-stop-button"
+            onClick={handleStop}
+            disabled={isBusy}
+          >
+            Stop Logging
+          </button>
+        </>
+      ) : (
+        <>
+          <div className="logging-start-controls">
+            <input
+              type="text"
+              className="logging-label-input"
+              placeholder="Session label (optional)"
+              value={label}
+              onChange={(e) => setLabel(e.target.value)}
+              onKeyDown={(e) => { if (e.key === 'Enter') handleStart(); }}
+            />
+            <div className="logging-button-row">
+              <button
+                className="action-button"
+                onClick={handleStart}
+                disabled={isBusy || (logConfig !== undefined && (!logConfig || logConfig.devices.length === 0))}
+              >
+                Start Logging
+              </button>
+              <button
+                className="action-button logging-simulate-button"
+                onClick={handleSimulate}
+                disabled={isBusy}
+              >
+                Simulate
+              </button>
+            </div>
+          </div>
+        </>
+      )}
+
+      {lastError && (
+        <div className="logging-error">{lastError}</div>
+      )}
+    </div>
+  );
+}

package/examples/dashboard/src/Main.tsx

@@ -11,6 +11,10 @@ import {
 import StatusPanel from './StatusPanel';
 import DevicesPanel from './DevicesPanel';
 import CommandPanel from './CommandPanel';
+import LoggingPanel from './LoggingPanel';
+import LogFilesPanel from './LogFilesPanel';
+import LogConfigPanel, { LogConfig } from './LogConfigPanel';
+
 import LatencyTestPanel from './LatencyTestPanel';
 import SettingsManager from './SettingsManager';
 
@@ -34,6 +38,9 @@ export default function Main() {
   const [ipAddress, setIpAddress] = useState<string>(
     localStorage.getItem('lastIpAddress') || ''
   );
+  const [fileRefreshTrigger, setFileRefreshTrigger] = useState(0);
+  const [downloadActive, setDownloadActive] = useState(false);
+  const [logConfig, setLogConfig] = useState<LogConfig | null>(null);
 
   const [serialNo, setSerialNo] = useState<string>('');
 
@@ -148,10 +155,10 @@ export default function Main() {
             {connectionStatus === RaftConnEvent.CONN_CONNECTED ? (
               <>
                 <div className="connected-panel">
-                  <div className="info-boxes">
+                  <div className="info-boxes connection-info">
                     <div className="info-box">
                       <div className="conn-indication">
-                        <h3>Connected</h3>
+                        <h3>Connected via {connManager.getConnector().getConnMethod() || 'Unknown'}</h3>
                       </div>
                       <div>
                         <button
@@ -169,6 +176,9 @@ export default function Main() {
                   <StatusPanel />
                   {latencyTestEnabled && <LatencyTestPanel />}
                   <CommandPanel />
+                  <LogConfigPanel onConfigChanged={setLogConfig} disabled={false} />
+                  <LoggingPanel onLogStopped={() => setFileRefreshTrigger(n => n + 1)} pausePolling={downloadActive} logConfig={logConfig} />
+                  <LogFilesPanel refreshTrigger={fileRefreshTrigger} onDownloadActiveChange={setDownloadActive} />
                 </div>
                 <DevicesPanel />
               </>

package/examples/dashboard/src/SettingsScreen.tsx

@@ -24,9 +24,14 @@ const SettingsScreen = ({ onBack }: { onBack: () => void }) => {
     settingsManager.getSetting('latencyAttributeName') || 'amb0'
   );
   const [latencyChangeThreshold, setLatencyChangeThreshold] = useState<number>(
-    settingsManager.getSetting('latencyChangeThreshold') || 100
+    settingsManager.getSetting('latencyChangeThreshold') ?? 100
   );
 
+  const parseIntOrDefault = (value: string, fallback: number): number => {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? fallback : parsed;
+  };
+
   const handleSaveAndReturn = () => {
     // Save settings to SettingsManager
     settingsManager.setSetting('latencyTest', latencyTest);
@@ -83,7 +88,7 @@ const SettingsScreen = ({ onBack }: { onBack: () => void }) => {
                   value={maxChartDataPoints}
                   onChange={(e) =>
                     setMaxChartDataPoints(
-                      Math.min(parseInt(e.target.value, 10) || 1, 500)
+                      Math.min(parseIntOrDefault(e.target.value, 1), 500)
                     )
                   }
                   style={{ width: '50px', marginLeft: '10px' }}
@@ -101,7 +106,7 @@ const SettingsScreen = ({ onBack }: { onBack: () => void }) => {
                   value={maxDatapointsToStore}
                   onChange={(e) =>
                     setMaxDatapointsToStore(
-                      Math.min(parseInt(e.target.value, 10) || 1, 100000)
+                      Math.min(parseIntOrDefault(e.target.value, 1), 100000)
                     )
                   }
                   style={{ width: '50px', marginLeft: '10px' }}
@@ -141,7 +146,7 @@ const SettingsScreen = ({ onBack }: { onBack: () => void }) => {
                       min="1"
                       value={latencyChangeThreshold}
                       onChange={(e) =>
-                        setLatencyChangeThreshold(parseInt(e.target.value, 10) || 1)
+                        setLatencyChangeThreshold(parseIntOrDefault(e.target.value, 1))
                       }
                       style={{ width: '60px', marginLeft: '10px' }}
                     />

package/examples/dashboard/src/SystemTypeCog/CogStateInfo.ts

@@ -2,7 +2,6 @@ import { time } from "console";
 import RaftLog from "../../../../src/RaftLog";
 import { DeviceManager } from "../../../../src/RaftDeviceManager";
 import RaftUtils from "../../../../src/RaftUtils";
-import { TextDecoder } from 'text-encoding';
 
 // export interface IMUStateInfo {
 //     gx: number;
@@ -47,6 +46,14 @@ export class CogStateInfo {
         return this._deviceManager; 
     }
 
+    async handleBinaryPayload(rxMsg: Uint8Array): Promise<void> {
+        await this._deviceManager.handleClientMsgBinary(rxMsg);
+    }
+
+    async handleJsonPayload(jsonString: string): Promise<void> {
+        await this._deviceManager.handleClientMsgJson(jsonString);
+    }
+
     updateFromMsg(rxMsg: Uint8Array, frameTimeMs: number, isBinary: boolean): Array<string> {
 
         // Debug 
@@ -54,14 +61,14 @@ export class CogStateInfo {
 
         if (isBinary) {
             // console.log(`CogStateInfo: updateFromMsg: ${RaftUtils.bufferToHex(rxMsg)}`);
-            this._deviceManager.handleClientMsgBinary(rxMsg);
+            this.handleBinaryPayload(rxMsg);
         } else {
             // Convert Uint8Array to string
             const decoder = new TextDecoder('utf-8');
             const jsonString = decoder.decode(rxMsg.slice(2));
 
             // Handle using device manager
-            this._deviceManager.handleClientMsgJson(jsonString);
+            this.handleJsonPayload(jsonString);
         }
 
     //     // Debug

package/examples/dashboard/src/SystemTypeCog/SystemTypeCog.ts

@@ -1,5 +1,5 @@
 import { RaftSubscribeForUpdatesCBType, RaftSystemType } from "../../../../src/RaftSystemType";
-import { RaftEventFn, RaftLog, RaftOKFail, RaftPublishEvent, RaftPublishEventNames, RaftSystemUtils } from "../../../../src/main";
+import { inspectPublishFrame, RaftEventFn, RaftLog, RaftPublishEvent, RaftPublishEventNames, RaftSubscriptionUpdateResponse, RaftSystemUtils } from "../../../../src/main";
 import { CogStateInfo } from "./CogStateInfo";
 import { DeviceManager } from "../../../../src/RaftDeviceManager";
 
@@ -53,10 +53,16 @@ export default class SystemTypeCog implements RaftSystemType {
           ']}';
 
         const msgHandler = systemUtils.getMsgHandler();
-        const ricResp = await msgHandler.sendRICRESTCmdFrame<RaftOKFail>(
+        const ricResp = await msgHandler.sendRICRESTCmdFrame<RaftSubscriptionUpdateResponse>(
           enable ? subscribeEnable : subscribeDisable
         );
 
+        // Cache topic index->name map from response, then refresh from pubtopics endpoint when enabling
+        systemUtils.updatePublishTopicMapFromSubscriptionResponse(ricResp);
+        if (enable) {
+          await systemUtils.refreshPublishTopicMap();
+        }
+
         // Debug
         RaftLog.debug(`subscribe enable/disable returned ${JSON.stringify(ricResp)}`);
       } catch (error: unknown) {
@@ -72,13 +78,41 @@ export default class SystemTypeCog implements RaftSystemType {
 
       // RICLog.debug(`rxOtherMsgType payload ${RaftUtils.bufferToHex(payload)}`);
       RaftLog.verbose(`rxOtherMsgType payloadLen ${payload.length}`);
-      const topicIDs = this._stateInfo.updateFromMsg(payload, frameTimeMs, SUBSCRIBE_BINARY_MSGS);
+
+      const frameMeta = inspectPublishFrame(payload, (idx) => this._systemUtils?.getPublishTopicName(idx));
+      let handledByDeviceManager = false;
+
+      if (frameMeta.frameType === "binary") {
+        if (frameMeta.binaryHasEnvelope) {
+          if (frameMeta.topicName === "devbin") {
+            this._stateInfo.handleBinaryPayload(payload);
+            handledByDeviceManager = true;
+          }
+        } else if (SUBSCRIBE_BINARY_MSGS) {
+          this._stateInfo.handleBinaryPayload(payload);
+          handledByDeviceManager = true;
+        }
+      } else if (frameMeta.frameType === "json") {
+        if (frameMeta.topicName === "devjson" || frameMeta.topicName === undefined) {
+          if (frameMeta.jsonString !== undefined) {
+            this._stateInfo.handleJsonPayload(frameMeta.jsonString);
+            handledByDeviceManager = true;
+          }
+        }
+      }
+
+      const topicIDs = frameMeta.topicIndex !== undefined ? [frameMeta.topicIndex.toString()] : [];
 
       // Call event handler if registered
       if (this._onEvent) {
         this._onEvent("pub", RaftPublishEvent.PUBLISH_EVENT_DATA, RaftPublishEventNames[RaftPublishEvent.PUBLISH_EVENT_DATA],
           {
             topicIDs: topicIDs,
+            topicName: frameMeta.topicName,
+            topicIndex: frameMeta.topicIndex,
+            topicVersion: frameMeta.version,
+            frameType: frameMeta.frameType,
+            handledByDeviceManager,
             payload: payload,
             frameTimeMs: frameTimeMs,
             isBinary: SUBSCRIBE_BINARY_MSGS

package/examples/dashboard/src/SystemTypeGeneric/StateInfoGeneric.ts

@@ -7,6 +7,14 @@ export class StateInfoGeneric {
     public constructor(private _deviceManager: DeviceManager) {
     }
 
+    async handleBinaryPayload(rxMsg: Uint8Array): Promise<void> {
+        await this._deviceManager.handleClientMsgBinary(rxMsg);
+    }
+
+    async handleJsonPayload(jsonString: string): Promise<void> {
+        await this._deviceManager.handleClientMsgJson(jsonString);
+    }
+
     updateFromMsg(rxMsg: Uint8Array, frameTimeMs: number, isBinary: boolean): Array<string> {
 
         // Debug 
@@ -15,14 +23,14 @@ export class StateInfoGeneric {
         // Handle binary or JSON
         if (isBinary) {
             // Handle using device manager
-            this._deviceManager.handleClientMsgBinary(rxMsg);            
+            this.handleBinaryPayload(rxMsg);
         } else {
             // Convert Uint8Array to string
             const decoder = new TextDecoder('utf-8');
             const jsonString = decoder.decode(rxMsg.slice(2));
 
             // Handle using device manager
-            this._deviceManager.handleClientMsgJson(jsonString);
+            this.handleJsonPayload(jsonString);
         }
         return [];
 

package/examples/dashboard/src/SystemTypeGeneric/SystemTypeGeneric.ts

@@ -1,9 +1,9 @@
 import { RaftSubscribeForUpdatesCBType, RaftSystemType } from "../../../../src/RaftSystemType";
-import { RaftEventFn, RaftLog, RaftOKFail, RaftPublishEvent, RaftPublishEventNames, RaftSystemUtils } from "../../../../src/main";
+import { inspectPublishFrame, RaftEventFn, RaftLog, RaftPublishEvent, RaftPublishEventNames, RaftSubscriptionUpdateResponse, RaftSystemUtils } from "../../../../src/main";
 import { StateInfoGeneric } from "./StateInfoGeneric";
 import { DeviceManager } from "../../../../src/RaftDeviceManager";
 
-const SUBSCRIBE_BINARY_MSGS = false;
+const SUBSCRIBE_BINARY_MSGS = true;
 
 export default class SystemTypeGeneric implements RaftSystemType {
     nameForDialogs = "Generic System";
@@ -39,24 +39,30 @@ export default class SystemTypeGeneric implements RaftSystemType {
 
     // Subscribe for updates
     subscribeForUpdates: RaftSubscribeForUpdatesCBType | null = async (systemUtils: RaftSystemUtils, enable: boolean) => {
-      // Subscription rate
+      // Subscription rate — must be high enough to match max polling rate
       const subscribeRateHz = 0.1;
       try {
         const topic = SUBSCRIBE_BINARY_MSGS ? "devbin" : "devjson";
         const subscribeDisable = '{"cmdName":"subscription","action":"update",' +
           '"pubRecs":[' +
-          `{"name":"${topic}","rateHz":0,}` +
+          `{"name":"${topic}","rateHz":0}` +
           ']}';
         const subscribeEnable = '{"cmdName":"subscription","action":"update",' +
           '"pubRecs":[' +
-          `{"name":"${topic}","trigger":"timeorchange","rateHz":${subscribeRateHz.toString()}}` +
+          `{"name":"${topic}","trigger":"timeorchange","rateHz":${subscribeRateHz.toString()},"minMs":10}` +
           ']}';
 
         const msgHandler = systemUtils.getMsgHandler();
-        const ricResp = await msgHandler.sendRICRESTCmdFrame<RaftOKFail>(
+        const ricResp = await msgHandler.sendRICRESTCmdFrame<RaftSubscriptionUpdateResponse>(
           enable ? subscribeEnable : subscribeDisable
         );
 
+        // Cache topic index->name map from response, then refresh from pubtopics endpoint when enabling
+        systemUtils.updatePublishTopicMapFromSubscriptionResponse(ricResp);
+        if (enable) {
+          await systemUtils.refreshPublishTopicMap();
+        }
+
         // Debug
         RaftLog.debug(`subscribe enable/disable returned ${JSON.stringify(ricResp)}`);
       } catch (error: unknown) {
@@ -72,13 +78,41 @@ export default class SystemTypeGeneric implements RaftSystemType {
 
       // RICLog.debug(`rxOtherMsgType payload ${RaftUtils.bufferToHex(payload)}`);
       RaftLog.verbose(`rxOtherMsgType payloadLen ${payload.length}`);
-      const topicIDs = this._stateInfo.updateFromMsg(payload, frameTimeMs, SUBSCRIBE_BINARY_MSGS);
+
+      const frameMeta = inspectPublishFrame(payload, (idx) => this._systemUtils?.getPublishTopicName(idx));
+      let handledByDeviceManager = false;
+
+      if (frameMeta.frameType === "binary") {
+        if (frameMeta.binaryHasEnvelope) {
+          if (frameMeta.topicName === "devbin") {
+            this._stateInfo.handleBinaryPayload(payload);
+            handledByDeviceManager = true;
+          }
+        } else if (SUBSCRIBE_BINARY_MSGS) {
+          this._stateInfo.handleBinaryPayload(payload);
+          handledByDeviceManager = true;
+        }
+      } else if (frameMeta.frameType === "json") {
+        if (frameMeta.topicName === "devjson" || frameMeta.topicName === undefined) {
+          if (frameMeta.jsonString !== undefined) {
+            this._stateInfo.handleJsonPayload(frameMeta.jsonString);
+            handledByDeviceManager = true;
+          }
+        }
+      }
+
+      const topicIDs = frameMeta.topicIndex !== undefined ? [frameMeta.topicIndex.toString()] : [];
 
       // Call event handler if registered
       if (this._onEvent) {
         this._onEvent("pub", RaftPublishEvent.PUBLISH_EVENT_DATA, RaftPublishEventNames[RaftPublishEvent.PUBLISH_EVENT_DATA],
           {
             topicIDs: topicIDs,
+            topicName: frameMeta.topicName,
+            topicIndex: frameMeta.topicIndex,
+            topicVersion: frameMeta.version,
+            frameType: frameMeta.frameType,
+            handledByDeviceManager,
             payload: payload,
             frameTimeMs: frameTimeMs,
             isBinary: SUBSCRIBE_BINARY_MSGS

package/examples/dashboard/src/SystemTypeMarty/RICStateInfo.ts

@@ -1,5 +1,6 @@
 import RaftDeviceMgrIF from "../../../../src/RaftDeviceMgrIF";
-import { DeviceAttributeState, DevicesState, DeviceState } from "../../../../src/RaftDeviceStates";
+import { SampleRateResult } from "../../../../src/RaftDeviceInfo";
+import { DeviceAttributeState, DevicesState, DeviceState, DeviceOnlineState } from '../../../../src/RaftDeviceStates';
 import { RICSERIAL_PAYLOAD_POS } from "../../../../src/RaftProtocolDefs";
 import RICAddOnManager from "./RICAddOnManager";
 import RICCommsStats from "./RICCommsStats";
@@ -45,12 +46,18 @@ export class RICStateInfo implements RaftDeviceMgrIF {
             deviceTimeline: {
                 timestampsUs: [],
                 lastReportTimestampUs: 0,
-                reportTimestampOffsetUs: 0
+                reportTimestampOffsetUs: 0,
+                totalSamplesAdded: 0,
+                emaLastSampleTimeUs: 0,
+                emaIntervalUs: 0,
+                emaPrevPollTimeUs: 0,
+                emaCalibrated: false,
+                emaCalibrationPolls: 0
             },
             deviceAttributes: {},
             deviceIsNew: false,
             stateChanged: false,
-            isOnline: false,
+            onlineState: DeviceOnlineState.Offline,
             deviceAddress: "",
             deviceType: "",
             busName: ""
@@ -85,6 +92,14 @@ export class RICStateInfo implements RaftDeviceMgrIF {
         // TODO - implement if RICStateInfo is to be used as a DeviceMgr
     }
 
+    addDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
+    removeDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
     sendAction(deviceKey: string, action: any, data: any): void {
         // TODO - implement if RICStateInfo is to be used as a DeviceMgr
     }
@@ -93,5 +108,21 @@ export class RICStateInfo implements RaftDeviceMgrIF {
         // TODO - implement if RICStateInfo is to be used as a DeviceMgr
     }
 
+    async setSampleRate(deviceKey: string, sampleRateHz: number, options?: {
+        numSamples?: number; intervalUs?: number; maxNumSamples?: number;
+    }): Promise<SampleRateResult> {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+        return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: 0, intervalUs: 0, numSamples: 0, error: 'Not implemented' };
+    }
+
+    getDeviceStats(deviceKey: string): any {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+        return {};
+    }
+
+    resetDeviceStats(deviceKey: string): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
   }