Initial sample rate in drop-down

Author: robdobsn

examples/dashboard/src/DeviceActionsForm.tsx

@@ -1,10 +1,20 @@
 import React, { useEffect, useRef, useState } from 'react';
 import ConnManager from './ConnManager';
-import { DeviceTypeAction } from '../../../src/RaftDeviceInfo';
+import { DeviceTypeAction, ActionMapEntry } from '../../../src/RaftDeviceInfo';
 import DispLEDGrid from './DispLedGrid';
 
 const connManager = ConnManager.getInstance();
 
+// Generic sample rate options for devices without _conf.rate
+const GENERIC_SAMPLE_RATES = [50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.01, 0.001];
+
+// Find the closest value in an array to a target
+function findClosest(arr: number[], target: number): number {
+    return arr.reduce((prev, curr) =>
+        Math.abs(curr - target) < Math.abs(prev - target) ? curr : prev
+    );
+}
+
 type DeviceActionsTableProps = {
     deviceKey: string;
 };
@@ -18,18 +28,28 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
     const [deviceActions, setDeviceActions] = useState<DeviceTypeAction[]>([]);
     const [inputValues, setInputValues] = useState<InputValues>({});
     const [actionStatus, setActionStatus] = useState<string>('');
+    const [genericRateHz, setGenericRateHz] = useState<number>(10);
+    const [isBusDevice, setIsBusDevice] = useState<boolean>(false);
+    const [hasConfRate, setHasConfRate] = useState<boolean>(false);
 
     useEffect(() => {
         if (!deviceManager) {
             return;
         }
         // Wait a little while inline for the device to be ready
-        setTimeout(() => {
+        setTimeout(async () => {
             const deviceState = deviceManager.getDeviceState(deviceKey);
             const { deviceTypeInfo } = deviceState;
             const actions: DeviceTypeAction[] = deviceTypeInfo?.actions || [];
             setDeviceActions(actions);
-            // Initialize input values
+            // Check if this is a bus device (has a valid busName)
+            const busName = deviceState?.busName ?? '';
+            const isBus = busName !== '' && busName !== '0';
+            setIsBusDevice(isBus);
+            // Check if device has _conf.rate action
+            const confRateAction = actions.find(a => a.n === '_conf.rate');
+            setHasConfRate(!!confRateAction);
+            // Initialize input values with defaults
             const initialValues: InputValues = actions.reduce((acc, action) => {
                 acc[action.n] =
                     action.d ??
@@ -40,6 +60,47 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                         : 0);
                 return acc;
             }, {} as InputValues);
+
+            // Query current poll config from firmware to initialize rate dropdowns
+            if (isBus && deviceState?.deviceAddress) {
+                try {
+                    const cmd = `devman/devconfig?bus=${busName}&addr=${deviceState.deviceAddress}`;
+                    const resp = await connManager.getConnector().sendRICRESTMsg(cmd, {}) as any;
+                    if (resp?.rslt === 'ok' && resp.pollIntervalUs > 0) {
+                        const currentRateHz = 1000000 / resp.pollIntervalUs;
+                        if (confRateAction?.map) {
+                            // For _conf.rate: find the map key whose interval and numSamples
+                            // best match the current config (both i and s needed to disambiguate
+                            // e.g. 52Hz and 104Hz both use i=50000 but differ in s)
+                            let bestKey = String(confRateAction.d ?? '');
+                            let bestDist = Infinity;
+                            for (const [key, entry] of Object.entries(confRateAction.map)) {
+                                const mapEntry = entry as ActionMapEntry;
+                                if (mapEntry.i !== undefined) {
+                                    let dist = Math.abs(mapEntry.i - resp.pollIntervalUs);
+                                    // Add penalty for numSamples mismatch to disambiguate entries with same interval
+                                    if (mapEntry.s !== undefined && resp.numSamples !== undefined) {
+                                        dist += Math.abs(mapEntry.s - resp.numSamples) * 1000000;
+                                    }
+                                    if (dist < bestDist) {
+                                        bestDist = dist;
+                                        bestKey = key;
+                                    }
+                                }
+                            }
+                            if (bestKey) {
+                                initialValues['_conf.rate'] = parseFloat(bestKey);
+                            }
+                        } else {
+                            // For generic rate dropdown: find closest option
+                            setGenericRateHz(findClosest(GENERIC_SAMPLE_RATES, currentRateHz));
+                        }
+                    }
+                } catch (err) {
+                    // Ignore query errors — keep defaults
+                }
+            }
+
             setInputValues(initialValues);
         }, 1000);
     }, [deviceKey]);
@@ -71,7 +132,24 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
         }
     };
 
-    if (deviceActions.length === 0) {
+    const handleGenericRateSend = async () => {
+        if (!deviceManager) {
+            return;
+        }
+        setActionStatus('Setting sample rate...');
+        const result = await deviceManager.setSampleRate(deviceKey, genericRateHz);
+        if (result.ok) {
+            setActionStatus(`Rate: ${result.actualRateHz} Hz, poll: ${result.intervalUs} µs, buf: ${result.numSamples}`);
+        } else {
+            setActionStatus(`Error: ${result.error}`);
+        }
+        setTimeout(() => setActionStatus(''), 5000);
+    };
+
+    // Show generic rate control for bus devices without _conf.rate
+    const showGenericRate = isBusDevice && !hasConfRate;
+
+    if (deviceActions.length === 0 && !showGenericRate) {
         return <></>;
     }
 
@@ -103,9 +181,11 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                             );
                         } else if (action.map) {
                             const mapKeys = Object.keys(action.map).sort((a, b) => parseFloat(a) - parseFloat(b));
+                            // Use "Rate Hz" label for _conf.rate actions
+                            const actionLabel = action.n === '_conf.rate' ? 'Rate Hz' : (action.desc ?? action.n);
                             return (
                                 <tr key={action.n}>
-                                    <td>{action.desc ?? action.n}</td>
+                                    <td>{actionLabel}</td>
                                     <td>
                                         <select
                                             value={inputValues[action.n]}
@@ -173,6 +253,26 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                             );
                         }
                     })}
+                    {showGenericRate && (
+                        <tr key="__generic_rate">
+                            <td>Rate Hz</td>
+                            <td>
+                                <select
+                                    value={genericRateHz}
+                                    onChange={(e) => setGenericRateHz(parseFloat(e.target.value))}
+                                >
+                                    {GENERIC_SAMPLE_RATES.map((rate) => (
+                                        <option key={rate} value={rate}>
+                                            {rate >= 1 ? `${rate} Hz` : `${rate} Hz`}
+                                        </option>
+                                    ))}
+                                </select>
+                            </td>
+                            <td>
+                                <button onClick={handleGenericRateSend}>Send</button>
+                            </td>
+                        </tr>
+                    )}
                 </tbody>
             </table>
             {actionStatus && <div className="action-status">{actionStatus}</div>}

examples/dashboard/src/LoggingPanel.tsx

@@ -43,6 +43,7 @@ export default function LoggingPanel({ onLogStopped, pausePolling, logConfig }:
   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;
@@ -53,8 +54,9 @@ export default function LoggingPanel({ onLogStopped, pausePolling, logConfig }:
       if (resp && typeof resp === 'object') {
         const r = resp as any;
         const flushLatency = r.flushLatency ?? {};
+        const nowLogging = r.active ?? false;
         setStatus({
-          isLogging: r.active ?? false,
+          isLogging: nowLogging,
           fileName: r.fileName ?? '',
           elapsedSecs: (r.durationMs ?? 0) / 1000,
           bytesWritten: r.totalBytesWritten ?? 0,
@@ -65,6 +67,11 @@ export default function LoggingPanel({ onLogStopped, pausePolling, logConfig }:
           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);

examples/dashboard/src/Main.tsx

@@ -155,7 +155,7 @@ 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 via {connManager.getConnector().getConnMethod() || 'Unknown'}</h3>

examples/dashboard/src/styles.css

@@ -94,10 +94,19 @@ h1 {
     gap: 10px;
 }
 
+.connection-info {
+    flex: 0 0 auto;
+    max-width: 140px;
+}
+
+.connection-info .info-box {
+    padding: 8px 12px;
+}
+
 .connected-panel {
     display: flex;
     justify-content: flex-start;
-    gap: 20px;
+    gap: 10px;
     align-items: stretch;
     flex-direction: row;
     width: 100%;

src/RaftDeviceManager.ts

@@ -931,7 +931,26 @@ export class DeviceManager implements RaftDeviceMgrIF{
         // Find the _conf.rate action
         const confRateAction = typeInfo.actions?.find(a => a.n === '_conf.rate');
         if (!confRateAction?.map) {
-            return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: 0, intervalUs: 0, numSamples: 0, error: 'Device does not have a _conf.rate action with a rate map' };
+            // No _conf.rate action — use generic sample rate setting
+            // Non-FIFO devices: poll once per sample period, 1 sample per read
+            const samplePeriodUs = Math.round(1000000 / sampleRateHz);
+            const numSamples = options?.numSamples ?? 1;
+            const intervalUs = options?.intervalUs ?? Math.max(5000, samplePeriodUs);
+
+            const { bus: devBus, addr: devAddr } = parseDeviceKey(deviceKey);
+            const cmd = `devman/devconfig?bus=${devBus}&addr=${devAddr}&intervalUs=${intervalUs}&numSamples=${numSamples}`;
+
+            try {
+                const msgHandler = this._systemUtils?.getMsgHandler();
+                if (!msgHandler) {
+                    return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: sampleRateHz, intervalUs, numSamples, error: 'No message handler available' };
+                }
+                const msgRslt = await msgHandler.sendRICRESTURL<RaftOKFail>(cmd);
+                const ok = msgRslt.rslt === 'ok';
+                return { ok, requestedRateHz: sampleRateHz, actualRateHz: sampleRateHz, intervalUs, numSamples, error: ok ? undefined : `Firmware returned: ${msgRslt.rslt}` };
+            } catch (error) {
+                return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: sampleRateHz, intervalUs, numSamples, error: `${error}` };
+            }
         }
 
         // Find the closest supported rate from the map keys