fix(focas): decode servo/spindle meters by their base/exponent envelope; MaxRpm -> MotorSpeedPct

Servo (0x0056) and spindle (0x0040) meter records are 8 bytes: [i32 value][u16 base][u16 exponent], the same self-describing envelope as the position blocks. Servo: offset 4 was read as a decimal count. It is the BASE (a steady 10), so every load was divided by 10^10 and published ~0 -- the sister ignitionoee panel read servo 0% on every axis of a Makino cutting at 20,000 rpm. Loads are now value / base^exponent, a direct percentage. Spindle: the raw meter is a 1/16384 fraction of full scale. Settled on the real Z-34184 by regressing the type-1 meter against cnc_rddynamic2 spindle speed over 596..20,000 rpm (rpm = 1.220749 x meter; 16384 x 1.220749 = 20000.75). So: - Spindle/{name}/Load publishes % of rated load (Float64; was the raw Int32 count -- a reading of 9155 meant 55.9%). - Spindle/{name}/MaxRpm is RENAMED Spindle/{name}/MotorSpeedPct (Float64, % of maximum speed) and is polled with Load. The old node was actively wrong: the type-1 meter is the live motor speed, and it was read once at bootstrap and served forever as if it were a max-RPM constant. Client-visible: FIXED: tags on .../MaxRpm must be re-pointed. - The spindle read no longer stops at the first zero after slot 1 (which dropped an idle second spindle and kept non-zero residue); every slot is returned. A record whose envelope is undescribable (base not 2/10, exponent > 18 -- e.g. residue past the configured axis/spindle count) publishes BadNoData, never a Good 0. Ported from the sister ignitionoee FOCAS driver v0.17.2/v0.17.3 (Focas.Wire-019); live captures live-spmeter-{load,maxrpm}-0x0040.bin added as fixtures.
2026-10-07 14:07:22 -04:00
parent 69e0a622f3
commit 1dba46bd7b
13 changed files with 518 additions and 123 deletions
@@ -643,7 +643,8 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,

                // Spindle subtree — one folder per discovered spindle, suppressed
                // entirely on series that don't export cnc_rdspdlname. Per-spindle
-                // Load + MaxRpm each gated on their own capability probe.
+                // Load + MotorSpeedPct (both cnc_rdspmeter percentages of full scale)
+                // each gated on their own capability probe.
                if (cache.Capabilities.Spindles)
                {
                    var spindleRoot = deviceFolder.Folder("Spindle", "Spindle");
@@ -652,9 +653,9 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                        var name = cache.SpindleSegments[i];
                        var spindleFolder = spindleRoot.Folder(name, name);
                        if (cache.Capabilities.SpindleLoad)
-                            EmitFixedVariable(spindleFolder, $"Spindle/{name}", "Load", DriverDataType.Int32);
-                        if (cache.Capabilities.SpindleMaxRpm && i < cache.SpindleMaxRpms.Count)
-                            EmitFixedVariable(spindleFolder, $"Spindle/{name}", "MaxRpm", DriverDataType.Int32);
+                            EmitFixedVariable(spindleFolder, $"Spindle/{name}", "Load", DriverDataType.Float64);
+                        if (cache.Capabilities.SpindleMotorSpeed)
+                            EmitFixedVariable(spindleFolder, $"Spindle/{name}", "MotorSpeedPct", DriverDataType.Float64);
                    }
                }

@@ -927,7 +928,7 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,

                // Optional-API probes — each returns empty / throws when unsupported.
                var spindles = await SafeProbe(() => client.GetSpindleNamesAsync(ct), []);
-                var spindleMaxRpms = await SafeProbe(() => client.GetSpindleMaxRpmsAsync(ct), []);
+                var spindleMotorSpeeds = await SafeProbe(() => client.GetSpindleMotorSpeedsAsync(ct), []);
                var servoLoads = await SafeProbe(() => client.GetServoLoadsAsync(ct), []);
                var programInfo = await SafeTryProbe(() => client.GetProgramInfoAsync(ct));
                var timer = await SafeTryProbe(() => client.GetTimerAsync(FocasTimerKind.PowerOn, ct));
@@ -936,13 +937,12 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                var caps = new FocasFixedTreeCapabilities(
                    Spindles: spindles.Count > 0,
                    SpindleLoad: spindleLoad.Count > 0,
-                    SpindleMaxRpm: spindleMaxRpms.Count > 0,
+                    SpindleMotorSpeed: spindleMotorSpeeds.Count > 0,
                    ServoLoad: servoLoads.Count > 0,
                    ProgramInfo: programInfo is not null,
                    Timers: timer is not null);

-                state.FixedTreeCache = new FocasFixedTreeCache(
-                    sys, [.. axes], [.. spindles], [.. spindleMaxRpms], caps);
+                state.FixedTreeCache = new FocasFixedTreeCache(sys, [.. axes], [.. spindles], caps);
                // The bootstrap IS an answer from the device, and Identity comes entirely from it —
                // so stamp liveness here as well as per tick, or a CNC whose axis poll never
                // succeeds would serve a perfectly valid sysinfo as stale.
@@ -958,15 +958,14 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
            }
        }

-        // Prime the spindle-loads cache from bootstrap if supported — avoids a
+        // Prime the spindle-meter caches from bootstrap if supported — avoids a
        // "tree is there but reads say BadNodeIdUnknown" window on startup.
-        if (state.FixedTreeCache?.Capabilities is { SpindleLoad: true })
+        if (state.FixedTreeCache?.Capabilities is { SpindleLoad: true } or { SpindleMotorSpeed: true })
        {
            try
            {
                var client2 = await EnsureConnectedAsync(state, ct).ConfigureAwait(false);
-                var loads = await client2.GetSpindleLoadsAsync(ct).ConfigureAwait(false);
-                for (var i = 0; i < loads.Count; i++) state.LastSpindleLoads[i] = loads[i];
+                await PollSpindleMetersAsync(state, client2, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
@@ -1019,17 +1018,16 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                            state.Options.HostAddress);
                    }
                }
-                if (cache.Capabilities.SpindleLoad)
+                if (cache.Capabilities.SpindleLoad || cache.Capabilities.SpindleMotorSpeed)
                {
                    try
                    {
-                        var loads = await client.GetSpindleLoadsAsync(ct).ConfigureAwait(false);
-                        for (var i = 0; i < loads.Count; i++) state.LastSpindleLoads[i] = loads[i];
+                        await PollSpindleMetersAsync(state, client, ct).ConfigureAwait(false);
                    }
                    catch (Exception ex)
                    {
                        /* transient */
-                        _logger.LogDebug(ex, "FOCAS spindle-loads poll failed for {Host}",
+                        _logger.LogDebug(ex, "FOCAS spindle-meter poll failed for {Host}",
                            state.Options.HostAddress);
                    }
                }
@@ -1148,7 +1146,27 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
    {
        var segments = FixedTreeNames.Disambiguate(loads.Select(l => l.AxisName));
        for (var i = 0; i < loads.Count; i++)
-            state.LastServoLoads[segments[i]] = loads[i].LoadPercent;
+            state.LastServoLoads[segments[i]] = loads[i].LoadPercent ?? NoValue;
+    }
+
+    /// <summary>
+    ///     Read and cache both spindle meters (load, motor speed) — each a <c>cnc_rdspmeter</c>
+    ///     percentage of full scale (16384 = 100%) — for every spindle slot, as capability allows.
+    ///     A slot whose record describes no value is cached as <see cref="NoValue"/> (BadNoData).
+    /// </summary>
+    private static async Task PollSpindleMetersAsync(DeviceState state, IFocasClient client, CancellationToken ct)
+    {
+        var caps = state.FixedTreeCache?.Capabilities;
+        if (caps is { SpindleLoad: true })
+        {
+            var loads = await client.GetSpindleLoadsAsync(ct).ConfigureAwait(false);
+            for (var i = 0; i < loads.Count; i++) state.LastSpindleLoads[i] = loads[i] ?? NoValue;
+        }
+        if (caps is { SpindleMotorSpeed: true })
+        {
+            var speeds = await client.GetSpindleMotorSpeedsAsync(ct).ConfigureAwait(false);
+            for (var i = 0; i < speeds.Count; i++) state.LastSpindleMotorSpeeds[i] = speeds[i] ?? NoValue;
+        }
    }

    private static object? TimerValue(DeviceState state, FocasTimerKind kind) =>
@@ -1240,7 +1258,7 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                return CachedDouble(load, status, sourceUtc, now);
        }

-        // Spindle matches: "Spindle/{name}/Load" + "Spindle/{name}/MaxRpm"
+        // Spindle matches: "Spindle/{name}/Load" + "Spindle/{name}/MotorSpeedPct"
        if (suffixFull.StartsWith("Spindle/", StringComparison.Ordinal)
            && state.FixedTreeCache is { } spindleCache)
        {
@@ -1259,14 +1277,14 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                }
                if (idx >= 0)
                {
-                    object? value = field switch
+                    var meters = field switch
                    {
-                        "Load" => state.LastSpindleLoads.TryGetValue(idx, out var l) ? (object)l : null,
-                        "MaxRpm" => idx < spindleCache.SpindleMaxRpms.Count ? (object)spindleCache.SpindleMaxRpms[idx] : null,
+                        "Load" => state.LastSpindleLoads,
+                        "MotorSpeedPct" => state.LastSpindleMotorSpeeds,
                        _ => null,
                    };
-                    if (value is not null)
-                        return new DataValueSnapshot(value, status, sourceUtc, now);
+                    if (meters is not null && meters.TryGetValue(idx, out var pct))
+                        return CachedDouble(pct, status, sourceUtc, now);
                }
            }
        }
@@ -1477,7 +1495,6 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
        FocasSysInfo SysInfo,
        IReadOnlyList<FocasAxisName> Axes,
        IReadOnlyList<FocasSpindleName> Spindles,
-        IReadOnlyList<int> SpindleMaxRpms,
        FocasFixedTreeCapabilities Capabilities)
    {
        /// <summary>
@@ -1503,14 +1520,14 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
    /// <summary>
    ///     Per-device optional-API capability flags — which of the "this may or may not
    ///     exist on this CNC series" calls succeeded at bootstrap. Drives per-series
-    ///     node suppression so a 16i that doesn't export <c>cnc_rdspmaxrpm</c> simply
-    ///     doesn't get a <c>Spindle/{name}/MaxRpm</c> node (instead of surfacing
+    ///     node suppression so a 16i that doesn't export <c>cnc_rdspmeter</c> simply
+    ///     doesn't get a <c>Spindle/{name}/MotorSpeedPct</c> node (instead of surfacing
    ///     <c>BadDeviceFailure</c> on every read).
    /// </summary>
    internal sealed record FocasFixedTreeCapabilities(
        bool Spindles,          // cnc_rdspdlname returned 1+ spindle names
-        bool SpindleLoad,       // cnc_rdspload bootstrap probe succeeded
-        bool SpindleMaxRpm,     // cnc_rdspmaxrpm bootstrap probe succeeded
+        bool SpindleLoad,       // cnc_rdspmeter type 0 (load) bootstrap probe succeeded
+        bool SpindleMotorSpeed, // cnc_rdspmeter type 1 (motor speed) bootstrap probe succeeded
        bool ServoLoad,         // cnc_rdsvmeter bootstrap probe returned data
        bool ProgramInfo,       // cnc_exeprgname2 + cnc_rdblkcount + cnc_rdopmode work
        bool Timers);           // cnc_rdtimer works for at least PowerOn
@@ -1580,8 +1597,16 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
        public ConcurrentDictionary<FocasTimerKind, FocasTimer> LastTimers { get; } = new();
        /// <summary>Gets the last servo load percentages by servo name.</summary>
        public ConcurrentDictionary<string, double> LastServoLoads { get; } = new(StringComparer.OrdinalIgnoreCase);
-        /// <summary>Gets the last spindle load percentages by spindle index.</summary>
-        public ConcurrentDictionary<int, int> LastSpindleLoads { get; } = new();
+        /// <summary>
+        ///     Gets the last spindle load percentages (% of rated load) by spindle index;
+        ///     <see cref="NoValue"/> for a slot the CNC described as holding none.
+        /// </summary>
+        public ConcurrentDictionary<int, double> LastSpindleLoads { get; } = new();
+        /// <summary>
+        ///     Gets the last spindle motor-speed percentages (% of maximum speed) by spindle index;
+        ///     <see cref="NoValue"/> for a slot the CNC described as holding none.
+        /// </summary>
+        public ConcurrentDictionary<int, double> LastSpindleMotorSpeeds { get; } = new();

        /// <summary>Disposes the FOCAS client instance.</summary>
        public void DisposeClient()
@@ -140,9 +140,10 @@ public interface IFocasClient : IDisposable
    // ---- Fixed-tree T3.5 (servo meters) ----

    /// <summary>
-    ///     Read the servo-load meter percentages across all configured axes.
-    ///     Values are percentages (scaled by <c>10^Dec</c>). Empty list on a
-    ///     disconnected session or unsupported CNC.
+    ///     Read the servo-load meter percentages across all configured axes. Each record's own
+    ///     <c>value / base^exponent</c> envelope is applied (servo loads are direct percentages);
+    ///     a record whose envelope describes no value carries a null <see cref="FocasServoLoad.LoadPercent"/>.
+    ///     Empty list on a disconnected session or unsupported CNC.
    /// </summary>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns>The servo-load meter percentages across all configured axes.</returns>
@@ -151,26 +152,31 @@ public interface IFocasClient : IDisposable
    // ---- Fixed-tree T3.6 (spindle meters) ----

    /// <summary>
-    ///     Read per-spindle load percentages. Result list index corresponds to
-    ///     spindle index from <see cref="GetSpindleNamesAsync"/>. Empty list on a
-    ///     disconnected session or when the CNC doesn't support the call (older
-    ///     series like 16i may return EW_FUNC).
+    ///     Read per-spindle load as a percentage of rated load (<c>cnc_rdspmeter</c> type 0; the
+    ///     raw meter is a 1/16384 fraction of full scale). Result list index corresponds to
+    ///     spindle index from <see cref="GetSpindleNamesAsync"/>; a slot whose record describes no
+    ///     value is null. Empty list on a disconnected session or when the CNC doesn't support the
+    ///     call (older series like 16i may return EW_FUNC).
    /// </summary>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns>Per-spindle load percentages, indexed as per <see cref="GetSpindleNamesAsync"/>.</returns>
-    Task<IReadOnlyList<int>> GetSpindleLoadsAsync(CancellationToken cancellationToken);
+    Task<IReadOnlyList<double?>> GetSpindleLoadsAsync(CancellationToken cancellationToken);

    /// <summary>
-    ///     Read per-spindle maximum RPM values. Static configuration, fetched once at
-    ///     bootstrap. Index alignment as per <see cref="GetSpindleLoadsAsync"/>.
+    ///     Read per-spindle motor speed as a percentage of maximum speed (<c>cnc_rdspmeter</c>
+    ///     type 1, historically labelled <c>cnc_rdspmaxrpm</c>). A live value, not a max-RPM
+    ///     constant. Index alignment and null semantics as per <see cref="GetSpindleLoadsAsync"/>.
    /// </summary>
    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>Per-spindle maximum RPM values, indexed as per <see cref="GetSpindleLoadsAsync"/>.</returns>
-    Task<IReadOnlyList<int>> GetSpindleMaxRpmsAsync(CancellationToken cancellationToken);
+    /// <returns>Per-spindle motor-speed percentages, indexed as per <see cref="GetSpindleLoadsAsync"/>.</returns>
+    Task<IReadOnlyList<double?>> GetSpindleMotorSpeedsAsync(CancellationToken cancellationToken);
 }

-/// <summary>One servo-meter entry — one axis's current load percentage.</summary>
-public sealed record FocasServoLoad(string AxisName, double LoadPercent);
+/// <summary>
+///     One servo-meter entry — one axis's current load percentage; null when the CNC's record
+///     described no usable value (never a fabricated 0).
+/// </summary>
+public sealed record FocasServoLoad(string AxisName, double? LoadPercent);

 /// <summary>Which cumulative counter <see cref="IFocasClient.GetTimerAsync"/> reads.</summary>
 public enum FocasTimerKind
@@ -297,19 +303,16 @@ public sealed record FocasDynamicSnapshot(
 /// </param>
 public readonly record struct FocasPosition(int Raw, int Base = 0, int Exponent = 0, bool HasScale = false)
 {
-    /// <summary>
-    ///     Largest exponent that can describe a real coordinate. An i32 carries at most ten digits,
-    ///     so anything beyond is a misread block — and left unbounded, <c>raw / 10^400</c> is
-    ///     <c>raw / Infinity = 0.0</c>, a Good reading of a machine parked at the origin.
-    /// </summary>
-    public const int MaxExponent = 18;
-
    /// <summary>
    ///     False when the block says it holds no usable position: the <c>0xFFFF</c> vacant marker, a
    ///     base other than 2 or 10, or an absurd exponent. A per-node quality decision — that node
    ///     publishes Bad, its siblings are unaffected.
    /// </summary>
-    public bool IsValid => !HasScale || (Exponent <= MaxExponent && Base is 2 or 10);
+    /// <remarks>
+    ///     The exponent bound matters: left unbounded, <c>raw / 10^400</c> is
+    ///     <c>raw / Infinity = 0.0</c> — a Good reading of a machine parked at the origin.
+    /// </remarks>
+    public bool IsValid => !HasScale || Wire.FocasValueEnvelope.IsValid(Base, Exponent);

    /// <summary>
    ///     The position in engineering units: <c>Raw / Base^Exponent</c> when the block carried its
@@ -321,7 +324,7 @@ public readonly record struct FocasPosition(int Raw, int Base = 0, int Exponent
    public double? ToEngineering(int fallbackDecimalPlaces)
    {
        if (!IsValid) return null;
-        if (HasScale) return Exponent == 0 ? Raw : Raw / Math.Pow(Base, Exponent);
+        if (HasScale) return Wire.FocasValueEnvelope.Scale(Raw, Base, Exponent);
        var dp = Math.Max(0, fallbackDecimalPlaces);
        return dp > 0 ? Raw / Math.Pow(10, dp) : Raw;
    }
@@ -99,12 +99,12 @@ public sealed class SynchronizedFocasClient : IFocasClient
        RunBoundedAsync(ct => _inner.GetServoLoadsAsync(ct), cancellationToken);

    /// <inheritdoc />
-    public Task<IReadOnlyList<int>> GetSpindleLoadsAsync(CancellationToken cancellationToken) =>
+    public Task<IReadOnlyList<double?>> GetSpindleLoadsAsync(CancellationToken cancellationToken) =>
        RunBoundedAsync(ct => _inner.GetSpindleLoadsAsync(ct), cancellationToken);

    /// <inheritdoc />
-    public Task<IReadOnlyList<int>> GetSpindleMaxRpmsAsync(CancellationToken cancellationToken) =>
-        RunBoundedAsync(ct => _inner.GetSpindleMaxRpmsAsync(ct), cancellationToken);
+    public Task<IReadOnlyList<double?>> GetSpindleMotorSpeedsAsync(CancellationToken cancellationToken) =>
+        RunBoundedAsync(ct => _inner.GetSpindleMotorSpeedsAsync(ct), cancellationToken);

    /// <summary>Disposes the inner client and the call gate.</summary>
    public void Dispose()
@@ -420,12 +420,15 @@ public sealed class FocasWireClient : IAsyncDisposable, IDisposable
        return new FocasResult<IReadOnlyList<WireServoMeter>>(rc, result);
    }

-    /// <summary>Read per-spindle load percentages via <c>cnc_rdspload</c> (command <c>0x0040</c> with arg1=0).</summary>
+    /// <summary>
+    ///     Read the per-spindle load meter via <c>cnc_rdspmeter</c> (command <c>0x0040</c>, type 0).
+    ///     <see cref="WireSpindleMetric.Percent"/> is % of rated load (16384 = 100%).
+    /// </summary>
    /// <param name="spindleSelector">Spindle selector; -1 selects all spindles.</param>
    /// <param name="cancellationToken">Cancellation token for the read operation.</param>
    /// <param name="timeout">Optional per-call timeout override.</param>
    /// <param name="pathId">Optional path ID override; defaults to <see cref="PathId"/>.</param>
-    /// <returns>The per-spindle load percentages, wrapped in a <see cref="FocasResult{T}"/>.</returns>
+    /// <returns>The per-spindle load meters, wrapped in a <see cref="FocasResult{T}"/>.</returns>
    public Task<FocasResult<IReadOnlyList<WireSpindleMetric>>> ReadSpindleLoadAsync(
        short spindleSelector = -1,
        CancellationToken cancellationToken = default,
@@ -433,13 +436,19 @@ public sealed class FocasWireClient : IAsyncDisposable, IDisposable
        ushort? pathId = null)
        => ReadSpindleMetricAsync(0, spindleSelector, cancellationToken, timeout, pathId);

-    /// <summary>Read per-spindle maximum RPMs via <c>cnc_rdspmaxrpm</c> (command <c>0x0040</c> with arg1=1).</summary>
+    /// <summary>
+    ///     Read the per-spindle motor-speed meter via <c>cnc_rdspmeter</c> (command <c>0x0040</c>,
+    ///     type 1 — historically labelled <c>cnc_rdspmaxrpm</c>). It is NOT a maximum-RPM constant:
+    ///     it is the live motor speed as a fraction of maximum, <see cref="WireSpindleMetric.Percent"/>
+    ///     (a regression against <c>cnc_rddynamic2</c> spindle speed on a real 31i-B gives
+    ///     <c>rpm = 1.220749 × meter</c>, i.e. 16384 = the spindle's 20,000 rpm maximum).
+    /// </summary>
    /// <param name="spindleSelector">Spindle selector; -1 selects all spindles.</param>
    /// <param name="cancellationToken">Cancellation token for the read operation.</param>
    /// <param name="timeout">Optional per-call timeout override.</param>
    /// <param name="pathId">Optional path ID override; defaults to <see cref="PathId"/>.</param>
-    /// <returns>The per-spindle maximum RPMs, wrapped in a <see cref="FocasResult{T}"/>.</returns>
-    public Task<FocasResult<IReadOnlyList<WireSpindleMetric>>> ReadSpindleMaxRpmAsync(
+    /// <returns>The per-spindle motor-speed meters, wrapped in a <see cref="FocasResult{T}"/>.</returns>
+    public Task<FocasResult<IReadOnlyList<WireSpindleMetric>>> ReadSpindleMotorSpeedAsync(
        short spindleSelector = -1,
        CancellationToken cancellationToken = default,
        TimeSpan? timeout = null,
@@ -771,13 +780,27 @@ public sealed class FocasWireClient : IAsyncDisposable, IDisposable
            callTimeout.Token,
            new RequestBlock(0x0040, metric, spindleSelector, PathId: EffectivePathId(pathId))).ConfigureAwait(false);

-        return ToResult<IReadOnlyList<WireSpindleMetric>>(block, payload =>
-        {
-            var values = new List<WireSpindleMetric>();
-            for (var offset = 0; offset + 8 <= payload.Length; offset += 8)
-                values.Add(new WireSpindleMetric((short)(values.Count + 1), ReadInt32(payload, offset)));
-            return values;
-        });
+        return ToResult(block, ParseSpindleMetrics);
+    }
+
+    /// <summary>
+    ///     Decode a <c>cnc_rdspmeter</c> (0x0040) payload: 8-byte records of
+    ///     <c>[+0..3] i32 value</c>, <c>[+4..5] u16 base</c>, <c>[+6..7] u16 exponent</c>, one per
+    ///     slot of a fixed multi-slot buffer (slots past the spindle count are residue and decode
+    ///     as <see cref="WireSpindleMetric.IsValid"/> = false). Every slot is returned, in wire order.
+    /// </summary>
+    /// <param name="payload">The response-block payload.</param>
+    /// <returns>The per-slot meters.</returns>
+    internal static IReadOnlyList<WireSpindleMetric> ParseSpindleMetrics(byte[] payload)
+    {
+        var values = new List<WireSpindleMetric>();
+        for (var offset = 0; offset + 8 <= payload.Length; offset += 8)
+            values.Add(new WireSpindleMetric(
+                (short)(values.Count + 1),
+                ReadInt32(payload, offset),
+                BinaryPrimitives.ReadUInt16BigEndian(payload.AsSpan(offset + 4, 2)),
+                BinaryPrimitives.ReadUInt16BigEndian(payload.AsSpan(offset + 6, 2))));
+        return values;
    }

    private async Task<FocasResult<T>> ReadSingleAsync<T>(
@@ -958,18 +981,16 @@ public sealed class FocasWireClient : IAsyncDisposable, IDisposable
        payload.Length >= 8 ? BinaryPrimitives.ReadInt32LittleEndian(payload.AsSpan(4, 4)) : 0);

    /// <summary>
-    ///     Decode a <c>cnc_rdsvmeter</c> response into <see cref="WireServoMeter"/> records. On the
-    ///     31i-B (v3) each per-axis LOADELM is <b>8 bytes</b> — {int32 data; int16 dec; int16 unit}
-    ///     — NOT the 12-byte shape the original parser assumed. The 12-byte stride misaligned after
-    ///     the first record (it read the dec/unit shorts of the prior record as the next record's
-    ///     data → wild values like 655360). Axis NAMES are not in the svmeter payload; they come
-    ///     from the <c>cnc_rdaxisname</c> (0x0089) block requested alongside it and are correlated
-    ///     by index. Validated against a live 31i-B 2026-06-25.
-    ///     <para><b>Scaling caveat:</b> downstream applies LoadPercent = data / 10^dec; on the 31i-B
-    ///     <c>dec</c> read as 10, which makes idle loads vanishingly small. The data/dec/unit field
-    ///     semantics for servo load are inferred from the wire and not yet confirmed against the
-    ///     machine's servo-meter screen — confirm magnitude at commissioning. The alignment + name
-    ///     fix here is what removes the gross misaligned garbage.</para>
+    ///     Decode a <c>cnc_rdsvmeter</c> response into <see cref="WireServoMeter"/> records. Each
+    ///     per-axis record is <b>8 bytes</b> — <c>[+0..3] i32 value</c>, <c>[+4..5] u16 base</c>,
+    ///     <c>[+6..7] u16 exponent</c> — the same self-describing envelope as the position blocks,
+    ///     so the load is <c>value / base^exponent</c>, a direct percentage. (A 12-byte stride
+    ///     misaligned after the first record; reading offset 4 as a decimal count divided every load
+    ///     by 10^10 — both fixed against live 31i-B captures, the latter by the sister ignitionoee
+    ///     driver, Focas.Wire-019.) Axis NAMES are not in the svmeter payload; they come from the
+    ///     <c>cnc_rdaxisname</c> (0x0089) block requested alongside it and are correlated by index.
+    ///     The payload is a fixed 32-slot buffer: slots past the controlled-axis count are residue
+    ///     and decode as <see cref="WireServoMeter.IsValid"/> = false.
    /// </summary>
    /// <param name="svPayload">The raw <c>cnc_rdsvmeter</c> response payload.</param>
    /// <param name="axisNamePayload">The raw <c>cnc_rdaxisname</c> response payload used to correlate axis names by index.</param>
@@ -989,8 +1010,8 @@ public sealed class FocasWireClient : IAsyncDisposable, IDisposable
                (short)(index + 1),
                name,
                ReadInt32(svPayload, offset),
-                ReadInt16(svPayload, offset + 4),
-                ReadInt16(svPayload, offset + 6)));
+                BinaryPrimitives.ReadUInt16BigEndian(svPayload.AsSpan(offset + 4, 2)),   // BASE, not a decimal
+                BinaryPrimitives.ReadUInt16BigEndian(svPayload.AsSpan(offset + 6, 2))));
        }
        return result;
    }
@@ -59,18 +59,104 @@ public sealed record WireDynamic(
    int SpindleSpeed,
    WireAxisPosition Axis);

-/// <summary>One servo-meter entry from <c>cnc_rdsvmeter</c> — per-axis load percentage (scale by 10^<see cref="Decimal"/>).</summary>
+/// <summary>
+///     The self-describing <c>(value, base, exponent)</c> envelope shared by every value record on
+///     the FOCAS wire — <c>cnc_rddynamic2</c> positions, servo meters, spindle meters:
+///     <c>scaled = value / base^exponent</c>, where only base 2 and base 10 are meaningful.
+/// </summary>
+internal static class FocasValueEnvelope
+{
+    /// <summary>
+    ///     Largest exponent that can describe a real value. An i32 carries at most ten digits, so
+    ///     anything beyond is a misread record — and <c>value / 10^400</c> would be
+    ///     <c>value / Infinity = 0.0</c>, a plausible Good zero.
+    /// </summary>
+    public const int MaxExponent = 18;
+
+    /// <summary>
+    ///     True when the record describes a usable value. A fixed multi-slot buffer's slots past the
+    ///     configured axis/spindle count hold unrelated memory, which shows up exactly here: a base
+    ///     that is neither 2 nor 10, or an absurd exponent (incl. the <c>0xFFFF</c> vacant marker).
+    /// </summary>
+    /// <param name="base">The record's base field.</param>
+    /// <param name="exponent">The record's exponent field.</param>
+    /// <returns>Whether the record may be published.</returns>
+    public static bool IsValid(int @base, int exponent) => exponent <= MaxExponent && @base is 2 or 10;
+
+    /// <summary><c>value / base^exponent</c>, or null when <see cref="IsValid"/> is false.</summary>
+    /// <param name="value">The raw value.</param>
+    /// <param name="base">The record's base field.</param>
+    /// <param name="exponent">The record's exponent field.</param>
+    /// <returns>The scaled value, or null.</returns>
+    public static double? Scale(int value, int @base, int exponent) =>
+        !IsValid(@base, exponent) ? null : exponent == 0 ? value : value / Math.Pow(@base, exponent);
+}
+
+/// <summary>
+///     One servo-meter entry from <c>cnc_rdsvmeter</c> (0x0056): one axis's load. The 8-byte record
+///     is <c>[+0..3] i32 value</c>, <c>[+4..5] u16 base</c>, <c>[+6..7] u16 exponent</c> and the load
+///     is a <b>direct</b> percentage, <see cref="Scaled"/> = <c>value / base^exponent</c>.
+/// </summary>
+/// <remarks>
+///     Offset 4 used to be read as a decimal count ("data / 10^dec"). It is the <b>base</b> — a
+///     steady 10 — so every load was divided by 10^10 and published ~0 (a real Makino cutting at
+///     20,000 rpm read servo 0% on every axis). Found by the sister ignitionoee driver,
+///     Focas.Wire-019 (v0.17.2).
+/// </remarks>
+/// <param name="Index">1-based axis slot.</param>
+/// <param name="Name">Axis name from the companion 0x0089 block (empty when none).</param>
+/// <param name="Value">Raw load value.</param>
+/// <param name="Base">Scale base (2 or 10 when meaningful).</param>
+/// <param name="Exponent">Scale exponent.</param>
 public sealed record WireServoMeter(
    short Index,
    string Name,
    int Value,
-    short Decimal,
-    short Unit);
+    int Base,
+    int Exponent)
+{
+    /// <summary>False for a record whose envelope describes no usable value (buffer residue).</summary>
+    public bool IsValid => FocasValueEnvelope.IsValid(Base, Exponent);

-/// <summary>One spindle metric slot from <c>cnc_rdspload</c> / <c>cnc_rdspmaxrpm</c>.</summary>
+    /// <summary>The load percentage, <c>Value / Base^Exponent</c>; null when <see cref="IsValid"/> is false.</summary>
+    public double? Scaled => FocasValueEnvelope.Scale(Value, Base, Exponent);
+}
+
+/// <summary>
+///     One spindle-meter slot from <c>cnc_rdspmeter</c> (0x0040; type 0 = load, type 1 = motor
+///     speed). Same 8-byte envelope as <see cref="WireServoMeter"/>, but the scaled value is a
+///     fraction of full scale in <c>1/16384</c> units — see <see cref="Percent"/>.
+/// </summary>
+/// <param name="Index">1-based spindle slot.</param>
+/// <param name="Value">Raw meter value, in 1/16384-of-full-scale units.</param>
+/// <param name="Base">Scale base.</param>
+/// <param name="Exponent">Scale exponent.</param>
 public sealed record WireSpindleMetric(
    short Index,
-    int Value);
+    int Value,
+    int Base,
+    int Exponent)
+{
+    /// <summary>
+    ///     The meter's full-scale count: <c>16384</c> = 2^14 = 100% of rated load (type 0) or of
+    ///     maximum spindle speed (type 1). Settled on the real Z-34184 by regressing the type-1
+    ///     meter against <c>cnc_rddynamic2</c> spindle speed over 596–20,000 rpm:
+    ///     <c>rpm = 1.220749 × meter</c>, <c>16384 × 1.220749 = 20000.75</c> (Focas.Wire-019).
+    /// </summary>
+    public const int FullScale = 1 << 14;
+
+    /// <summary>False for a record whose envelope describes no usable value (buffer residue).</summary>
+    public bool IsValid => FocasValueEnvelope.IsValid(Base, Exponent);
+
+    /// <summary>
+    ///     The meter as a percentage — <c>(Value / Base^Exponent) × 100 / 16384</c> — or null when
+    ///     <see cref="IsValid"/> is false. Values above 100 are real (short-term overload; the i16
+    ///     record clamps one count short of 200%).
+    /// </summary>
+    public double? Percent => FocasValueEnvelope.Scale(Value, Base, Exponent) is { } scaled
+        ? scaled * 100.0 / FullScale
+        : null;
+}

 /// <summary>
 ///     One axis-name slot from <c>cnc_rdaxisname</c>. <see cref="Index"/> is the 1-based
@@ -242,34 +242,32 @@ public sealed class WireFocasClient : IFocasClient
        var result = await _wire.ReadServoMeterAsync(32, cancellationToken).ConfigureAwait(false);
        if (!result.IsOk || result.Value is null) return [];
        return result.Value
-            .Select(m => new FocasServoLoad(m.Name ?? string.Empty, m.Value / Math.Pow(10.0, m.Decimal)))
+            .Select(m => new FocasServoLoad(m.Name ?? string.Empty, m.Scaled))
            .Where(s => s.AxisName.Length > 0)
            .ToList();
    }

    /// <inheritdoc />
-    public Task<IReadOnlyList<int>> GetSpindleLoadsAsync(CancellationToken cancellationToken) =>
+    public Task<IReadOnlyList<double?>> GetSpindleLoadsAsync(CancellationToken cancellationToken) =>
        ReadSpindleMetricAsync((sel, ct) => _wire.ReadSpindleLoadAsync(sel, ct), cancellationToken);

    /// <inheritdoc />
-    public Task<IReadOnlyList<int>> GetSpindleMaxRpmsAsync(CancellationToken cancellationToken) =>
-        ReadSpindleMetricAsync((sel, ct) => _wire.ReadSpindleMaxRpmAsync(sel, ct), cancellationToken);
+    public Task<IReadOnlyList<double?>> GetSpindleMotorSpeedsAsync(CancellationToken cancellationToken) =>
+        ReadSpindleMetricAsync((sel, ct) => _wire.ReadSpindleMotorSpeedAsync(sel, ct), cancellationToken);

-    private static async Task<IReadOnlyList<int>> ReadSpindleMetricAsync(
+    /// <summary>
+    ///     One <c>cnc_rdspmeter</c> read as per-slot percentages (null for an undescribable slot).
+    ///     Every slot is returned — the driver reads only the slots of discovered spindles. (This
+    ///     used to stop at the first zero after slot 1, which both dropped a genuinely idle second
+    ///     spindle and kept non-zero buffer residue.)
+    /// </summary>
+    private static async Task<IReadOnlyList<double?>> ReadSpindleMetricAsync(
        Func<short, CancellationToken, Task<FocasResult<IReadOnlyList<WireSpindleMetric>>>> call,
        CancellationToken cancellationToken)
    {
        var result = await call(-1, cancellationToken).ConfigureAwait(false);
        if (!result.IsOk || result.Value is null) return [];
-        var list = new List<int>();
-        foreach (var m in result.Value)
-        {
-            // Fanuc pads unused spindle slots with 0 — stop at the first trailing zero so the
-            // list length matches the configured spindle count.
-            if (m.Value == 0 && list.Count > 0) break;
-            list.Add(m.Value);
-        }
-        return list;
+        return result.Value.Select(m => m.Percent).ToList();
    }

    /// <summary>Disposes the wire client and releases all resources.</summary>