refactor(radio): flatten per-FM logical switch state to single global context

Replace lswFm[MAX_FLIGHT_MODES] (one LogicalSwitchContext per FM per LS)
with a flat lswCtx[MAX_LOGICAL_SWITCHES] array.  The previous commit's
test suite proved that per-FM state is fully redundant: timer/sticky/edge
lastValue is always identical across FMs, the `state` bit is dead in
non-active FMs, and delay/duration divergence is a bug (background timer
expiry) not a feature.

During FM fade transitions, the mixer evaluates mixes for multiple FMs
in a single cycle. To preserve the existing behavior where fading-out FMs
see the LS state from the moment of transition (smooth cross-fade for
LS-conditioned mixes), a uint32_t bitmap array per FM captures the frozen
LS state at transition time. getSwitch() reads from the frozen bitmap for
non-active FMs and from live lswCtx[] for the active FM. This replaces
~2 KB of per-FM context with 9 × 8 = 72 bytes of bitmaps + 1 byte for
mixerActiveFlightMode.

Changes:
- Flatten lswFm[MAX_FLIGHT_MODES] → lswCtx[MAX_LOGICAL_SWITCHES]
- Remove LogicalSwitchesFlightModeContext wrapper struct
- Hide LogicalSwitchContext struct and lswCtx[] as implementation details
  in switches.cpp; expose lswGetState/lswGetLastValue/lswSetState accessors
- Collapse logicalSwitchesTimerTick from FM×LS nested loop to single LS loop
- Replace logicalSwitchesCopyState with lswFreezeState bitmap snapshot
  called from mixer on FM transition
- Add mixerActiveFlightMode to distinguish active FM from temporarily
  assigned mixerCurrentFlightMode during fade evaluation
- Replace 16-test LswPerFmTest suite with 8-test LswTest suite verifying
  single-context behavior (delay/duration survive FM switches correctly)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: raphaelcoeffic

radio/src/edgetx.h

@@ -265,6 +265,7 @@ enum PerOutMode {
 };
 
 extern uint8_t mixerCurrentFlightMode;
+extern uint8_t mixerActiveFlightMode;
 extern uint8_t lastFlightMode;
 extern uint8_t flightModeTransitionLast;
 

radio/src/mixer.cpp

@@ -755,6 +755,7 @@ static inline bitfield_channels_t upper_channels_mask(uint16_t ch)
 }
 
 uint8_t mixerCurrentFlightMode;
+uint8_t mixerActiveFlightMode;
 
 void evalFlightModeMixes(uint8_t mode, uint8_t tick10ms)
 {
@@ -1165,7 +1166,7 @@ void evalMixes(uint8_t tick10ms)
         fp_act[lastFlightMode] = 0;
         fp_act[fm] = MAX_ACT;
       }
-      logicalSwitchesCopyState(lastFlightMode, fm); // push last logical switches state from old to new flight mode
+      lswFreezeState(lastFlightMode);
     }
     lastFlightMode = fm;
   }
@@ -1181,6 +1182,8 @@ void evalMixes(uint8_t tick10ms)
     }
   }
 
+  mixerActiveFlightMode = fm;
+
   int32_t weight = 0;
   if (flightModesFade) {
     memclear(sum_chans512, sizeof(sum_chans512));

radio/src/model_arena.h

@@ -81,14 +81,14 @@
 // ARENA_EXPOS          ~22         (none — expos share the input pipeline)
 // ARENA_CURVES         4           4-8 (curveEnd[] pointer)
 // ARENA_POINTS         1           (none)
-// ARENA_LOGICAL_SW     ~20         4 (LogicalSwitchContext) × MAX_FLIGHT_MODES = 36 B
+// ARENA_LOGICAL_SW     ~20         4 (LogicalSwitchContext) per LS = 4 × count B
 // ARENA_CUSTOM_FN      16          4 (lastFunctionTime[]) per context × 2 contexts = 8 B
-// ARENA_FLIGHT_MODES   ~28         2 (fp_act[]) + MAX_LOGICAL_SWITCHES×4 (lswFm[]) ≈ 258 B
+// ARENA_FLIGHT_MODES   ~28         2 (fp_act[])
 // ARENA_GVAR_DATA      7           (none)
 // ARENA_GVAR_VALUES    2           (none)
 //
-// Largest runtime cost: MAX_FLIGHT_MODES × lswFm = FM × LS × 4 bytes.
-// With 9 FM × 64 LS × 4 = 2304 bytes.  Raising FM to 16 → 4096 bytes.
+// lswCtx[] is a flat global array (not per-FM): LS × 4 bytes.
+// With 64 LS × 4 = 256 bytes (independent of FM count).
 //
 // MAX_OUTPUT_CHANNELS has no arena section but carries runtime cost:
 // chans[32×4] + channelOutputs[32×2] + ex_chans[32×2] + safetyCh[32×2]

radio/src/switches.cpp

@@ -55,10 +55,38 @@ enum LogicalSwitchContextState {
   SWITCH_ENABLE
 };
 
-LogicalSwitchesFlightModeContext lswFm[MAX_FLIGHT_MODES];
+PACK(struct LogicalSwitchContext {
+  uint8_t state:1;
+  uint8_t timerState:2;
+  uint8_t spare:1;
+  uint8_t deltaTimer:4;
+  uint8_t timer;
+  int16_t lastValue;
+});
+
+static LogicalSwitchContext lswCtx[MAX_LOGICAL_SWITCHES];
+
+// Frozen LS state bitmaps for FM fade transitions.
+// When transitioning between flight modes with fade, the fading-out FM's
+// LS state is frozen at the moment of transition so that mix evaluation
+// during the fade sees the pre-transition LS values (preserving smooth
+// cross-fade behavior for LS-conditioned mixes).
+#define FROZEN_LS_WORDS ((MAX_LOGICAL_SWITCHES + 31) / 32)
+static uint32_t frozenLsState[MAX_FLIGHT_MODES][FROZEN_LS_WORDS];
+
+static inline void frozenLsSet(uint8_t fm, uint8_t idx)
+{
+  frozenLsState[fm][idx >> 5] |= (1u << (idx & 31));
+}
+
+static inline bool frozenLsGet(uint8_t fm, uint8_t idx)
+{
+  return (frozenLsState[fm][idx >> 5] >> (idx & 31)) & 1;
+}
+
 CircularBuffer<uint8_t, 8> luaSetStickySwitchBuffer;
 
-#define LS_LAST_VALUE(fm, idx) lswFm[fm].lsw[idx].lastValue
+#define LS_LAST_VALUE(idx) lswCtx[idx].lastValue
 
 tmr10ms_t switchesMidposStart[MAX_SWITCHES];
 uint64_t  switchesPos = 0;
@@ -475,23 +503,23 @@ PACK(typedef struct {
 
 bool getLSStickyState(uint8_t idx)
 {
-  return lswFm[mixerCurrentFlightMode].lsw[idx].lastValue & 1;
+  return lswCtx[idx].lastValue & 1;
 }
 
 void logicalSwitchesInit(bool force)
 {
   for (unsigned int idx=0; idx<MAX_LOGICAL_SWITCHES; idx++) {
     LogicalSwitchData * ls = lswAddress(idx);
     if (ls->func == LS_FUNC_STICKY && (force || ls->lsPersist)) {
-      lswFm[mixerCurrentFlightMode].lsw[idx].lastValue = ls->lsState;
+      lswCtx[idx].lastValue = ls->lsState;
     }
   }
 }
 
 bool getLogicalSwitch(uint8_t idx)
 {
   LogicalSwitchData * ls = lswAddress(idx);
-  LogicalSwitchContext &context = lswFm[mixerCurrentFlightMode].lsw[idx];
+  LogicalSwitchContext &context = lswCtx[idx];
   bool result;
 
   if (ls->func == LS_FUNC_NONE || (!ls->andsw.isNone() && !getSwitch(ls->andsw))) {
@@ -713,7 +741,10 @@ bool getSwitch(const SwitchRef& ref, uint8_t flags)
     }
 
     case SWITCH_TYPE_LOGICAL:
-      result = lswFm[mixerCurrentFlightMode].lsw[ref.index].state;
+      if (mixerCurrentFlightMode != mixerActiveFlightMode)
+        result = frozenLsGet(mixerCurrentFlightMode, ref.index);
+      else
+        result = lswCtx[ref.index].state;
       break;
 
     case SWITCH_TYPE_FLIGHT_MODE: {
@@ -767,7 +798,7 @@ uint8_t getXPotPosition(uint8_t idx)
 void evalLogicalSwitches(bool isCurrentFlightmode)
 {
   for (unsigned int idx=0; idx<MAX_LOGICAL_SWITCHES; idx++) {
-    LogicalSwitchContext & context = lswFm[mixerCurrentFlightMode].lsw[idx];
+    LogicalSwitchContext & context = lswCtx[idx];
     bool result = getLogicalSwitch(idx);
     if (isCurrentFlightmode) {
       if (result) {
@@ -1044,91 +1075,86 @@ void logicalSwitchesTimerTick()
     uint8_t s = msg >> 7;
     LogicalSwitchData * ls = lswAddress(i);
     if (ls->func == LS_FUNC_STICKY) {
-      for (uint8_t fm=0; fm<MAX_FLIGHT_MODES; fm++) {
-        ls_sticky_struct & lastValue = (ls_sticky_struct &)LS_LAST_VALUE(fm, i);
-        lastValue.state = s;
-        bool now;
-        if (s)
-          now = getSwitch(ls->v2.swtch);
-        else
-          now = getSwitch(ls->v1.swtch);
-        if (now)
-          lastValue.last |= 1;
-        else
-          lastValue.last &= ~1;
-      }
+      ls_sticky_struct & lastValue = (ls_sticky_struct &)LS_LAST_VALUE(i);
+      lastValue.state = s;
+      bool now;
+      if (s)
+        now = getSwitch(ls->v2.swtch);
+      else
+        now = getSwitch(ls->v1.swtch);
+      if (now)
+        lastValue.last |= 1;
+      else
+        lastValue.last &= ~1;
     }
     msg = luaSetStickySwitchBuffer.read();
   }
 
   // Update logical switches
-  for (uint8_t fm=0; fm<MAX_FLIGHT_MODES; fm++) {
-    for (uint8_t i=0; i<MAX_LOGICAL_SWITCHES; i++) {
-      LogicalSwitchData * ls = lswAddress(i);
-      if (ls->func == LS_FUNC_TIMER) {
-        int16_t *lastValue = &LS_LAST_VALUE(fm, i);
-        if (*lastValue == 0 || *lastValue == CS_LAST_VALUE_INIT) {
-          *lastValue = -lswTimerValue(ls->v1.value);
-        } else if (*lastValue < 0) {
-          if (++(*lastValue) == 0) *lastValue = lswTimerValue(ls->v2.value);
-        } else {  // if (*lastValue > 0)
-          if (--(*lastValue) == 0) *lastValue = -lswTimerValue(ls->v1.value);
-        }
-      } else if (ls->func == LS_FUNC_STICKY) {
-        ls_sticky_struct & lastValue = (ls_sticky_struct &)LS_LAST_VALUE(fm, i);
-        bool before = lastValue.last & 0x01;
-        if (lastValue.state) {
-            if (!ls->v2.swtch.isNone()) { // only if used / source set
-                bool now = getSwitch(ls->v2.swtch);
-                if (now != before) {
-                  lastValue.last ^= 1;
-                  if (!before) {
-                    lastValue.state = 0;
-                  }
+  for (uint8_t i=0; i<MAX_LOGICAL_SWITCHES; i++) {
+    LogicalSwitchData * ls = lswAddress(i);
+    if (ls->func == LS_FUNC_TIMER) {
+      int16_t *lastValue = &LS_LAST_VALUE(i);
+      if (*lastValue == 0 || *lastValue == CS_LAST_VALUE_INIT) {
+        *lastValue = -lswTimerValue(ls->v1.value);
+      } else if (*lastValue < 0) {
+        if (++(*lastValue) == 0) *lastValue = lswTimerValue(ls->v2.value);
+      } else {  // if (*lastValue > 0)
+        if (--(*lastValue) == 0) *lastValue = -lswTimerValue(ls->v1.value);
+      }
+    } else if (ls->func == LS_FUNC_STICKY) {
+      ls_sticky_struct & lastValue = (ls_sticky_struct &)LS_LAST_VALUE(i);
+      bool before = lastValue.last & 0x01;
+      if (lastValue.state) {
+          if (!ls->v2.swtch.isNone()) { // only if used / source set
+              bool now = getSwitch(ls->v2.swtch);
+              if (now != before) {
+                lastValue.last ^= 1;
+                if (!before) {
+                  lastValue.state = 0;
                 }
-            }
-        }
-        else {
-            if (!ls->v1.swtch.isNone()) { // only if used / source set
-                bool now = getSwitch(ls->v1.swtch);
-                if (before != now) {
-                  lastValue.last ^= 1;
-                  if (!before) {
-                    lastValue.state = 1;
-                  }
+              }
+          }
+      }
+      else {
+          if (!ls->v1.swtch.isNone()) { // only if used / source set
+              bool now = getSwitch(ls->v1.swtch);
+              if (before != now) {
+                lastValue.last ^= 1;
+                if (!before) {
+                  lastValue.state = 1;
                 }
-            }
-        }
-      } else if (ls->func == LS_FUNC_EDGE) {
-        ls_stay_struct & lastValue = (ls_stay_struct &)LS_LAST_VALUE(fm, i);
-        // if this ls was reset by the logicalSwitchesReset() the lastValue will be set to CS_LAST_VALUE_INIT(0x8000)
-        // when it is unpacked into ls_stay_struct the lastValue.duration will have a value of 0x4000
-        // this will produce an instant true for edge logical switch if the second parameter is big enough.
-        // So we reset it here.
-        if (LS_LAST_VALUE(fm, i) == CS_LAST_VALUE_INIT) {
-          lastValue.duration = 0;
-        }
-        lastValue.state = false;
-        bool state = getSwitch(ls->v1.swtch);
-        if (state) {
-          if (ls->v3 == -1 && lastValue.duration == lswTimerValue(ls->v2.value))
-            lastValue.state = true;
-          if (lastValue.duration < 1000)
-            lastValue.duration++;
-        }
-        else {
-          if (lastValue.duration > lswTimerValue(ls->v2.value) && (ls->v3 == 0 || lastValue.duration <= lswTimerValue(ls->v2.value+ls->v3)))
-            lastValue.state = true;
-          lastValue.duration = 0;
-        }
+              }
+          }
       }
-
-      // decrement delay/duration timer
-      LogicalSwitchContext &context = lswFm[fm].lsw[i];
-      if (context.timer) {
-        context.timer--;
+    } else if (ls->func == LS_FUNC_EDGE) {
+      ls_stay_struct & lastValue = (ls_stay_struct &)LS_LAST_VALUE(i);
+      // if this ls was reset by the logicalSwitchesReset() the lastValue will be set to CS_LAST_VALUE_INIT(0x8000)
+      // when it is unpacked into ls_stay_struct the lastValue.duration will have a value of 0x4000
+      // this will produce an instant true for edge logical switch if the second parameter is big enough.
+      // So we reset it here.
+      if (LS_LAST_VALUE(i) == CS_LAST_VALUE_INIT) {
+        lastValue.duration = 0;
+      }
+      lastValue.state = false;
+      bool state = getSwitch(ls->v1.swtch);
+      if (state) {
+        if (ls->v3 == -1 && lastValue.duration == lswTimerValue(ls->v2.value))
+          lastValue.state = true;
+        if (lastValue.duration < 1000)
+          lastValue.duration++;
+      }
+      else {
+        if (lastValue.duration > lswTimerValue(ls->v2.value) && (ls->v3 == 0 || lastValue.duration <= lswTimerValue(ls->v2.value+ls->v3)))
+          lastValue.state = true;
+        lastValue.duration = 0;
       }
     }
+
+    // decrement delay/duration timer
+    if (lswCtx[i].timer) {
+      lswCtx[i].timer--;
+    }
   }
 }
 
@@ -1189,28 +1215,48 @@ int16_t lswTimerValue(delayval_t val)
 
 void logicalSwitchesReset()
 {
-  memset(lswFm, 0, sizeof(lswFm));
+  memset(lswCtx, 0, sizeof(lswCtx));
 
-  for (uint8_t fm=0; fm<MAX_FLIGHT_MODES; fm++) {
-    for (uint8_t i=0; i<MAX_LOGICAL_SWITCHES; i++) {
-      LS_LAST_VALUE(fm, i) = CS_LAST_VALUE_INIT;
-    }
+  for (uint8_t i=0; i<MAX_LOGICAL_SWITCHES; i++) {
+    LS_LAST_VALUE(i) = CS_LAST_VALUE_INIT;
   }
 
   luaSetStickySwitchBuffer.clear();
 }
 
+void lswFreezeState(uint8_t fm)
+{
+  memset(frozenLsState[fm], 0, sizeof(frozenLsState[fm]));
+  for (uint8_t i = 0; i < MAX_LOGICAL_SWITCHES; i++) {
+    if (lswCtx[i].state)
+      frozenLsSet(fm, i);
+  }
+}
+
+bool lswGetState(uint8_t idx)
+{
+  return lswCtx[idx].state;
+}
+
+int16_t lswGetLastValue(uint8_t idx)
+{
+  return lswCtx[idx].lastValue;
+}
+
+void lswSetState(uint8_t idx, uint8_t state, uint8_t timer, int16_t lastValue)
+{
+  lswCtx[idx].state = state;
+  lswCtx[idx].timer = timer;
+  lswCtx[idx].lastValue = lastValue;
+}
+
 getvalue_t convertLswTelemValue(LogicalSwitchData * ls)
 {
   getvalue_t val;
   val = convert16bitsTelemValue(ls->v1.source.index + 1, ls->v2.value);
   return val;
 }
 
-void logicalSwitchesCopyState(uint8_t src, uint8_t dst)
-{
-  lswFm[dst] = lswFm[src];
-}
 
 void setAllPreflightSwitchStates()
 {