AxoSequencer: fix step-timeout alarm not falling after timeout clears

CHANGELOG.md

@@ -1,3 +1,20 @@
+### [CORE] AxoSequencer step-timeout alarm — does not fall after timeout clears
+
+**Note:** PLC bug fix in `src/core/ctrl/src/AxoCoordination/AxoSequencer/AxoSequencer.st` (`AxoStepTimedOutMessenger.Activate`). No public-API change. Branch: `fix-issue-when-timeout-sequencer-alarm-doesnot-fall`.
+
+- fix: `AxoStepTimedOutMessenger.Activate` now resolves `_context := inParent.GetContext()` on every call rather than only on the first rising transition into `ActiveAcknowledgeNotRequired`, and refreshes `ActiveContextCount := _context.OpenCycleCount()` on every cycle the messenger remains non-Idle. Previously, `ActiveContextCount` was set once at rise time and never advanced, so the `AxoMessenger` base could not detect that `Activate` was still being called cycle-to-cycle, and the step-timeout alarm would not fall when the sequencer left the timed-out step.
+- fix: Added explicit `Run(IAxoObject inParent)` override on `AxoSequencer` calling `SUPER.Run(inParent)` — placeholder for the per-cycle `_msgStepTimedOut.Serve(THIS)` wiring (currently commented) so the override site exists for the messenger lifecycle without changing observable behaviour.
+
+**Impact:**
+- Sequencer step-timeout alarms now transition Idle → Active → Idle correctly across the step-timeout boundary; operators no longer see a stale "Step timed out" entry persisting after the sequencer has advanced past the timed-out step.
+- The aggregate count maintained via `THIS.GetParent().AggregateMessage(1)` is now driven by an `ActiveContextCount` that tracks the actual cycle of last activation, restoring the standard `AxoMessenger` fall semantics for this messenger.
+
+**Risks/Review:**
+- The `Run` override is a pass-through to `SUPER.Run` — no behavioural difference yet, but adds an extra virtual call per sequencer cycle. The commented `_msgStepTimedOut.Serve(THIS)` line is the intended wiring for a follow-up patch and is left in place as a documentation marker.
+
+**Testing:**
+- AxoSequencer step-timeout scenario in the showcase (`/core/AxoSequencer`) — induce a timeout, observe the messenger rises, then allow the step to complete and verify the alarm falls within one cycle of the step transition.
+
 ### [CORE] AxoIncidentBar — perf, ranking-accuracy, and sender-identification fixes
 
 **Note:** Patch follow-up to the `0.56.0` AxoIncidentBar feature. All changes in `src/core/src/AXOpen.Core/AxoMessenger/Static/` and `src/core/src/AXOpen.Core.Blazor/AxoMessenger/Static/`. No PLC source change. No public-API removal; `IRankableMessage` gains one new member with an adapter-side default. Branch: `fix-incident-bar-perf-issues`.

GitVersion.yml

@@ -1,5 +1,5 @@
 mode: ContinuousDeployment
-next-version: 0.56.1
+next-version: 0.56.2
 branches:
   main:
     regex: ^master$|^main$

src/core/ctrl/src/AxoCoordination/AxoSequencer/AxoSequencer.st

@@ -50,6 +50,14 @@ NAMESPACE AXOpen.Core
             _sequenceMode : eAxoSequenceMode;
         END_VAR
 
+        METHOD PUBLIC OVERRIDE Run
+            VAR_INPUT
+                inParent : IAxoObject;
+            END_VAR
+            SUPER.Run(inParent);
+            //_msgStepTimedOut.Serve(THIS);
+        END_METHOD     
+
         METHOD PUBLIC SetAnalitics
             VAR_INPUT
                 inAnalytics : IAxoSequencerAnalytics;
@@ -566,20 +574,22 @@ NAMESPACE AXOpen.Core
                 RETURN;
             END_IF;
 
+
+            _context := inParent.GetContext();
             IF(THIS.MessengerState = eAxoMessengerState#Idle && _refObservedStep <> inStep) THEN
-                THIS.MessengerState := eAxoMessengerState#ActiveAcknowledgeNotRequired;            
-                _context := inParent.GetContext();   
+                THIS.MessengerState := eAxoMessengerState#ActiveAcknowledgeNotRequired;                               
                 Risen := _context.GetRtc().NowUTC();                
                 Fallen := LDATE_AND_TIME#1970-01-01-00:00:00.000;
                 Acknowledged := LDATE_AND_TIME#1970-01-01-00:00:00.000;                                
                 Category := eAxoMessageCategory#Error;   
                 Message := System.Strings.Concat(MSG_STEP_TIMED_OUT, inStep^.GetStepDescription());  
                 MessageCode := ULINT#18446744073709551615; // No specific message code for step timeout                
                 _context.GetLogger().Log(System.Strings.Concat(RISE_SIGNATURE, Message), AXOpen.Logging.eLogLevel#Error, THIS);                
-                _refObservedStep := inStep;
+                _refObservedStep := inStep;                
             END_IF;
-
+            
             IF(THIS.MessengerState <> eAxoMessengerState#Idle && _refObservedStep = inStep) THEN
+                ActiveContextCount := _context.OpenCycleCount();    
                 THIS.GetParent().AggregateMessage(1);
             END_IF;    
         END_METHOD

src/core/docs/CHANGELOG.md

@@ -92,3 +92,8 @@
 - `AxoMessageProvider.ReadDetails` issues its batch read at `eAccessPriority.Low` to reduce contention with operator-driven traffic.
 - Added Serilog diagnostics to `AxoIncidentBarView.ConfigurePolling` and `Tick` (`Information`, `Debug`, `Warning`, `Error`) so polling lifecycle and per-tick state are visible without attaching a debugger.
 - `IRankableMessage` exposes a new `SenderSymbol` member (full PLC symbol path). `AxoMessengerRankableAdapter` accepts an optional `senderSymbol` projector and falls back to the messenger symbol when none is supplied — existing call sites compile unchanged.
+
+### 0.56.2
+
+**Bug fixes:**
+- `AxoSequencer` step-timeout messenger: `_context` is now resolved on every `_msgStepTimedOut.Activate(...)` call rather than only on the first rising transition, and `ActiveContextCount` is refreshed each cycle the messenger remains active. Previously, once the step-timeout alarm was raised, the active-context counter never advanced, so the parent `AggregateMessage(1)` accumulation could leave the alarm stuck active and prevent it from falling on the next sequencer cycle.