Harden cook stability: graceful shutdown, preheat race, PID guards

Inferno.Api/Devices/RtdArray.cs

@@ -30,6 +30,7 @@ public class RtdArray : IRtdArray, IDisposable
         int _probeInvalidCount;
 
         Task _adcReadTask;
+        readonly CancellationTokenSource _stopCts = new();
 
         public RtdArray(SpiDevice spi)
         {
@@ -52,7 +53,7 @@ private static double GetTemp(ConcurrentQueue<double> resistances)
 
         private async Task ReadAdc()
         {
-            while (true)
+            while (!_stopCts.IsCancellationRequested)
             {
                 int grillValue;
                 int probeValue;
@@ -62,17 +63,23 @@ private async Task ReadAdc()
                     grillValue = _adc.Read(0);
                     probeValue = _adc.Read(1);
                 }
+                catch (OperationCanceledException)
+                {
+                    break;
+                }
                 catch (Exception ex)
                 {
                     Console.WriteLine($"{DateTime.Now} {ex.Message} {ex.StackTrace}");
-                    await Task.Delay(TimeSpan.FromMilliseconds(10));
+                    try { await Task.Delay(TimeSpan.FromMilliseconds(10), _stopCts.Token); }
+                    catch (OperationCanceledException) { break; }
                     continue;
                 }
 
                 EnqueueIfValid(_grillResistances, grillValue, "Grill", ref _grillInvalidCount);
                 EnqueueIfValid(_probeResistances, probeValue, "Probe", ref _probeInvalidCount);
 
-                await Task.Delay(TimeSpan.FromMilliseconds(10));
+                try { await Task.Delay(TimeSpan.FromMilliseconds(10), _stopCts.Token); }
+                catch (OperationCanceledException) { break; }
             }
         }
 
@@ -129,6 +136,8 @@ protected virtual void Dispose(bool disposing)
             {
                 if (disposing)
                 {
+                    _stopCts.Cancel();
+                    _stopCts.Dispose();
                     _adc.Dispose();
                 }
                 disposedValue = true;

Inferno.Api/Pid/SmokerPid.cs

@@ -22,33 +22,65 @@ public SmokerPid(double PB, double Ti, double Td)
             _PB = PB;
             _Ti = Ti;
             _Td = Td;
+            _lastUpdate = DateTime.Now;
+            // NaN means "no valid previous sample yet" — the next reading seeds state
+            // instead of computing a derivative/integral across an unknown gap.
+            _lastTemp = double.NaN;
         }
 
         public double GetControlVariable(double currentTemp)
         {
+            DateTime now = DateTime.Now;
+
             if (double.IsNaN(currentTemp))
             {
-                _lastUpdate = DateTime.Now;
+                // Sensor dropout: hold the integral, advance the clock, and force the
+                // next valid reading to re-seed so we don't compute a bogus derivative
+                // across the gap.
+                _lastUpdate = now;
+                _lastTemp = double.NaN;
                 return 0;
             }
 
             double error = currentTemp - SetPoint;
-
             double P = GainP() * error;
 
-            TimeSpan dT = DateTime.Now - _lastUpdate;
-            _integral += error * dT.TotalSeconds;
-            _integral = _integral.Clamp(-IntegralMax(), IntegralMax());
-            double I = GainI() * _integral;
+            if (double.IsNaN(_lastTemp))
+            {
+                // First reading (or first after a dropout): seed state and return
+                // proportional-only. A stale/huge dt here would otherwise spike the
+                // integral and derivative.
+                _lastTemp = currentTemp;
+                _lastUpdate = now;
+                Debug.WriteLine($"u={P} (seed)");
+                return P;
+            }
+
+            double dtSeconds = (now - _lastUpdate).TotalSeconds;
 
-            double derivative = (currentTemp - _lastTemp) / dT.TotalSeconds;
-            double D = GainD() * derivative;
+            double I;
+            double D = 0;
+            if (dtSeconds > 0)
+            {
+                _integral += error * dtSeconds;
+                _integral = _integral.Clamp(-IntegralMax(), IntegralMax());
+                I = GainI() * _integral;
+
+                double derivative = (currentTemp - _lastTemp) / dtSeconds;
+                D = GainD() * derivative;
+            }
+            else
+            {
+                // Two calls in the same instant: no time elapsed, so don't accumulate
+                // the integral or divide by zero for the derivative.
+                I = GainI() * _integral;
+            }
 
             double u = P + I + D;
             Debug.WriteLine($"u={u} ({P}+{I}+{D})");
 
             _lastTemp = currentTemp;
-            _lastUpdate = DateTime.Now;
+            _lastUpdate = now;
 
             return u;
         }

Inferno.Api/Program.cs

@@ -30,4 +30,14 @@
 
 app.MapControllers();
 
+// On a clean stop (systemctl stop / SIGTERM / Ctrl-C), tear the smoker down so the
+// auger and igniter relays are de-energized instead of being left in their last
+// commanded state. Smoker.Dispose() drives a hard safe-off and releases the devices;
+// the shared GPIO controller is disposed afterward.
+app.Lifetime.ApplicationStopping.Register(() =>
+{
+    (app.Services.GetService<ISmoker>() as IDisposable)?.Dispose();
+    _gpio.Dispose();
+});
+
 app.Run();

Inferno.Api/Services/DisplayUpdater.cs

@@ -5,14 +5,15 @@
 
 namespace Inferno.Api.Services
 {
-    public class DisplayUpdater
+    public class DisplayUpdater : IDisposable
     {
         ISmoker _smoker;
         IDisplay _display;
 
         bool _heartbeatFlag;
 
         Task _updateDisplayLoop;
+        readonly CancellationTokenSource _stopCts = new();
 
         public DisplayUpdater(ISmoker smoker, IDisplay display)
         {
@@ -25,7 +26,7 @@ public DisplayUpdater(ISmoker smoker, IDisplay display)
         private async Task UpdateDisplayLoop()
         {
             Debug.WriteLine("Starting display thread.");
-            while (true)
+            while (!_stopCts.IsCancellationRequested)
             {
                 try
                 {
@@ -61,7 +62,11 @@ private async Task UpdateDisplayLoop()
                     }
 
                     _heartbeatFlag = !_heartbeatFlag;
-                    await Task.Delay(TimeSpan.FromSeconds(1));
+                    await Task.Delay(TimeSpan.FromSeconds(1), _stopCts.Token);
+                }
+                catch (OperationCanceledException)
+                {
+                    break;
                 }
                 catch (Exception ex)
                 {
@@ -71,6 +76,12 @@ private async Task UpdateDisplayLoop()
             }
         }
 
+        public void Dispose()
+        {
+            _stopCts.Cancel();
+            _stopCts.Dispose();
+        }
+
         private string HardwareStatus()
         {
             var status = _smoker.Status;

Inferno.Api/Services/FireMinder.cs

@@ -6,13 +6,14 @@
 
 namespace Inferno.Api.Services
 {
-    public class FireMinder
+    public class FireMinder : IDisposable
     {
         ISmoker _smoker;
         IRelayDevice _igniter;
         Func<DateTime> _now;
         LidMonitor _lidMonitor;
         Task _fireMinderLoop;
+        readonly CancellationTokenSource _stopCts = new();
         TimeSpan _igniterTimeout = TimeSpan.FromMinutes(10);
         TimeSpan _fireTimeout = TimeSpan.FromMinutes(10);
         /// <summary>
@@ -84,12 +85,16 @@ private async Task FireMinderLoop()
         {
             Debug.WriteLine("Starting Fire Minder thread.");
             ResetFireStatus();
-            while (true)
+            while (!_stopCts.IsCancellationRequested)
             {
                 try
                 {
                     Tick();
-                    await Task.Delay(TimeSpan.FromSeconds(1));
+                    await Task.Delay(TimeSpan.FromSeconds(1), _stopCts.Token);
+                }
+                catch (OperationCanceledException)
+                {
+                    break;
                 }
                 catch (Exception ex)
                 {
@@ -100,6 +105,12 @@ private async Task FireMinderLoop()
             }
         }
 
+        public void Dispose()
+        {
+            _stopCts.Cancel();
+            _stopCts.Dispose();
+        }
+
         /// <summary>
         /// One iteration of the fire-health state machine. Extracted from the loop so
         /// it can be driven deterministically in tests with an injected clock.

Inferno.Api/Services/PreheatMonitor.cs

@@ -7,46 +7,55 @@ public class PreheatMonitor
         public const double ProximityPct = 0.10;
 
         private readonly Queue<double> _tempHistory = new();
+        // Update() runs on a fixed-cadence loop while Reset() is driven from API
+        // threads (mode changes); guard the (non-concurrent) queue against both.
+        private readonly object _lock = new();
 
         public bool IsPreheated { get; private set; }
 
         public void Update(double grillTemp, int setPoint, bool isCookingMode, bool isFireHealthy)
         {
-            if (IsPreheated) return;
-
-            if (!isCookingMode || !isFireHealthy)
+            lock (_lock)
             {
-                _tempHistory.Clear();
-                return;
-            }
+                if (IsPreheated) return;
+
+                if (!isCookingMode || !isFireHealthy)
+                {
+                    _tempHistory.Clear();
+                    return;
+                }
 
-            if (Double.IsNaN(grillTemp) || grillTemp < 0)
-                return;
+                if (Double.IsNaN(grillTemp) || grillTemp < 0)
+                    return;
 
-            _tempHistory.Enqueue(grillTemp);
-            while (_tempHistory.Count > WindowSize)
-                _tempHistory.Dequeue();
+                _tempHistory.Enqueue(grillTemp);
+                while (_tempHistory.Count > WindowSize)
+                    _tempHistory.Dequeue();
 
-            if (_tempHistory.Count < WindowSize)
-                return;
+                if (_tempHistory.Count < WindowSize)
+                    return;
 
-            double min = _tempHistory.Min();
-            double max = _tempHistory.Max();
-            if (max - min >= MaxRange)
-                return;
+                double min = _tempHistory.Min();
+                double max = _tempHistory.Max();
+                if (max - min >= MaxRange)
+                    return;
 
-            double avg = _tempHistory.Average();
-            double threshold = setPoint * (1.0 - ProximityPct);
-            if (avg < threshold)
-                return;
+                double avg = _tempHistory.Average();
+                double threshold = setPoint * (1.0 - ProximityPct);
+                if (avg < threshold)
+                    return;
 
-            IsPreheated = true;
+                IsPreheated = true;
+            }
         }
 
         public void Reset()
         {
-            IsPreheated = false;
-            _tempHistory.Clear();
+            lock (_lock)
+            {
+                IsPreheated = false;
+                _tempHistory.Clear();
+            }
         }
     }
 }