removed lagacy event transmisson support, added ackknowledge

Author: mkalkbrenner

AGENTS.md

@@ -212,6 +212,29 @@ Current transport-tuning points to remember in `RS485Comm`:
 - switch-reply receive window in `ReceiveSwitchStateFrame()`
 - stale-input flush after a missed switch-reply chain
 - miss-count threshold before `m_needSessionResync = true`
+- output-frame pacing in the runtime loop
+- serial write timeout / short-write retry behavior
+
+## Current Freeze Status
+
+- Long-run attract-mode testing is still not robust.
+- One run may work for several minutes, while another can freeze in under a minute.
+- The visible freeze still correlates with missed switch-reply chains and the host recovery path.
+- Host timing changes clearly affect the symptom, but that does not prove the root cause is host-only.
+- Treat firmware as still in scope, especially the board-side switch reply path and token forwarding behavior.
+
+## Virtual Board Implementation Notes
+
+- First implementation slice is host-side only.
+- `libppuc` now tracks configured boards and switch ownership by board from YAML.
+- Board presence is now determined by explicit firmware-backed `ConfigAck` responses during startup config transmission.
+- Every `ConfigFrame` must be acknowledged by the addressed board.
+- Missing configured boards become host-side virtual boards if they do not acknowledge config during startup.
+- Config frames that are not acknowledged are printed as startup errors with board/topic/index/key details.
+- All switches owned by a virtual board are initialized to `open`.
+- Host-side switch injection is now limited to switches owned by virtualized boards.
+- This is the intended basis for bench setups where the cabinet board is absent.
+- Current limitation: virtual switch boards are not yet full synthetic participants in the runtime switch-reply cycle, and host-side virtual switch updates are not yet pushed into board-local high-power gating logic.
 
 ## Next Bring-Up Focus
 

src/PPUC.cpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <cstring>
 #include <set>
+#include <unordered_map>
 
 #include "Adafruit_NeoPixel.h"
 #include "RS485Comm.h"
@@ -112,6 +113,10 @@ void PPUC::SetDebug(bool debug) {
   m_debug = debug;
 }
 
+void PPUC::SetDebugErrors(bool debugErrors) {
+  m_pRS485Comm->SetDebugErrors(debugErrors);
+}
+
 bool PPUC::GetDebug() { return m_debug; }
 
 void PPUC::SetRom(const char* rom) { strcpy(m_rom, rom); }
@@ -196,52 +201,46 @@ void PPUC::SendLedConfigBlock(const YAML::Node& items, uint32_t type,
 bool PPUC::Connect() {
   if (m_pRS485Comm->Connect(m_serial)) {
     uint8_t index = 0;
+    std::vector<uint8_t> configuredBoards;
     std::vector<uint8_t> switchBoards;
     std::set<uint16_t> coilNumbers;
     std::set<uint16_t> lampNumbers;
     std::set<uint16_t> switchNumbers;
+    std::unordered_map<uint8_t, std::vector<uint16_t>> switchNumbersByBoard;
     const YAML::Node& boards = m_ppucConfig["boards"];
     for (YAML::Node n_board : boards) {
-      m_pRS485Comm->SendConfigEvent(new ConfigEvent(
-          n_board["number"].as<uint8_t>(), (uint8_t)CONFIG_TOPIC_PLATFORM, 0,
-          (uint8_t)CONFIG_TOPIC_PLATFORM, m_platform));
-
-      m_pRS485Comm->SendConfigEvent(
-          new ConfigEvent(n_board["number"].as<uint8_t>(),
-                          (uint8_t)CONFIG_TOPIC_COIN_DOOR_CLOSED_SWITCH, 0,
-                          (uint8_t)CONFIG_TOPIC_NUMBER,
-                          m_ppucConfig["coinDoorClosedSwitch"].as<uint8_t>()));
       m_coinDoorClosedSwitch =
           m_ppucConfig["coinDoorClosedSwitch"].as<uint8_t>();
-
-      m_pRS485Comm->SendConfigEvent(
-          new ConfigEvent(n_board["number"].as<uint8_t>(),
-                          (uint8_t)CONFIG_TOPIC_GAME_ON_SOLENOID, 0,
-                          (uint8_t)CONFIG_TOPIC_NUMBER,
-                          m_ppucConfig["gameOnSolenoid"].as<uint8_t>()));
       m_gameOnSolenoid = m_ppucConfig["gameOnSolenoid"].as<uint8_t>();
 
       if (n_board["pollEvents"].as<bool>()) {
         const uint8_t b = n_board["number"].as<uint8_t>();
         m_pRS485Comm->RegisterSwitchBoard(b);
         switchBoards.push_back(b);
       }
+      configuredBoards.push_back(n_board["number"].as<uint8_t>());
     }
 
     const YAML::Node& switchMatrix = m_ppucConfig["switchMatrix"];
     if (switchMatrix) {
       const YAML::Node& matrixSwitches = switchMatrix["switches"];
       if (matrixSwitches) {
         for (YAML::Node n_switch : matrixSwitches) {
-          switchNumbers.insert(n_switch["number"].as<uint16_t>());
+          const uint16_t switchNumber = n_switch["number"].as<uint16_t>();
+          switchNumbers.insert(switchNumber);
+          switchNumbersByBoard[n_switch["board"].as<uint8_t>()].push_back(
+              switchNumber);
         }
       }
     }
 
     const YAML::Node& switches = m_ppucConfig["switches"];
     if (switches) {
       for (YAML::Node n_switch : switches) {
-        switchNumbers.insert(n_switch["number"].as<uint16_t>());
+        const uint16_t switchNumber = n_switch["number"].as<uint16_t>();
+        switchNumbers.insert(switchNumber);
+        switchNumbersByBoard[n_switch["board"].as<uint8_t>()].push_back(
+            switchNumber);
       }
     }
 
@@ -299,6 +298,24 @@ bool PPUC::Connect() {
     switchMapping.resize(runtimeConfig.switchBits);
     m_pRS485Comm->SetMappings(coilMapping, lampMapping, switchMapping);
     m_pRS485Comm->SetRuntimeConfig(runtimeConfig);
+    m_pRS485Comm->SetConfiguredBoards(configuredBoards);
+    m_pRS485Comm->SetSwitchNumbersByBoard(switchNumbersByBoard);
+
+    for (YAML::Node n_board : boards) {
+      const uint8_t boardNumber = n_board["number"].as<uint8_t>();
+      m_pRS485Comm->SendConfigEvent(new ConfigEvent(
+          boardNumber, (uint8_t)CONFIG_TOPIC_PLATFORM, 0,
+          (uint8_t)CONFIG_TOPIC_PLATFORM, m_platform));
+      m_pRS485Comm->SendConfigEvent(
+          new ConfigEvent(boardNumber,
+                          (uint8_t)CONFIG_TOPIC_COIN_DOOR_CLOSED_SWITCH, 0,
+                          (uint8_t)CONFIG_TOPIC_NUMBER,
+                          m_ppucConfig["coinDoorClosedSwitch"].as<uint8_t>()));
+      m_pRS485Comm->SendConfigEvent(
+          new ConfigEvent(boardNumber, (uint8_t)CONFIG_TOPIC_GAME_ON_SOLENOID,
+                          0, (uint8_t)CONFIG_TOPIC_NUMBER,
+                          m_ppucConfig["gameOnSolenoid"].as<uint8_t>()));
+    }
 
     // Send switch matrix configuration to I/O boards
     // IMPORTANT: This must be done before sending individual switch configs
@@ -633,12 +650,22 @@ bool PPUC::Connect() {
       }
     }
 
-    // Configure token-ring handoff for switch-capable boards before the V2
-    // setup frame starts runtime processing on the boards.
-    for (size_t i = 0; i < switchBoards.size(); ++i) {
-      const uint8_t current = switchBoards[i];
-      const uint8_t next = (i + 1 < switchBoards.size())
-                               ? switchBoards[i + 1]
+    m_pRS485Comm->FinalizeConfiguredBoardPresence();
+
+    std::vector<uint8_t> presentSwitchBoards;
+    for (const uint8_t board : switchBoards) {
+      if (m_pRS485Comm->IsBoardPresent(board)) {
+        presentSwitchBoards.push_back(board);
+      }
+    }
+    m_pRS485Comm->SetActiveSwitchBoards(presentSwitchBoards);
+
+    // Configure token-ring handoff only across boards that acknowledged
+    // configuration during startup.
+    for (size_t i = 0; i < presentSwitchBoards.size(); ++i) {
+      const uint8_t current = presentSwitchBoards[i];
+      const uint8_t next = (i + 1 < presentSwitchBoards.size())
+                               ? presentSwitchBoards[i + 1]
                                : ppuc::v2::kNoBoard;
       m_pRS485Comm->SendConfigEvent(new ConfigEvent(
           current, (uint8_t)CONFIG_TOPIC_SWITCH_CHAIN, 0,
@@ -692,6 +719,15 @@ void PPUC::SetGIState(int string, int brightness) {
       ppuc::v2::ClampGiLevel(giBrightness)));
 }
 
+void PPUC::SetSwitchState(int number, int state) {
+  m_pRS485Comm->SetVirtualSwitchState(static_cast<uint16_t>(number),
+                                      state == 0 ? 0 : 1);
+}
+
+bool PPUC::IsSwitchVirtualized(int number) {
+  return m_pRS485Comm->IsSwitchVirtualized(static_cast<uint16_t>(number));
+}
+
 PPUCSwitchState* PPUC::GetNextSwitchState() {
   return m_pRS485Comm->GetNextSwitchState();
 }
@@ -741,6 +777,12 @@ void PPUC::CoilTest(uint8_t number) {
 
   for (const auto& coil : GetCoils()) {
     if (coil.type == PWM_TYPE_SOLENOID || coil.type == PWM_TYPE_FLASHER) {
+      if (coil.number == GetGameOnSolenoid()) {
+        // Keep the high-power enable coil asserted for the whole test. Pulsing
+        // it as part of the test would drop power and make every following
+        // coil appear dead.
+        continue;
+      }
       if (number != 0 && coil.number != number) {
         continue;
       }

src/PPUC.h

@@ -34,6 +34,7 @@ class PPUCAPI PPUC {
 
   void LoadConfiguration(const char* configFile);
   void SetDebug(bool debug);
+  void SetDebugErrors(bool debugErrors);
   bool GetDebug();
   void SetRom(const char* rom);
   const char* GetRom();
@@ -47,6 +48,8 @@ class PPUCAPI PPUC {
   void SetSolenoidState(int number, int state);
   void SetLampState(int number, int state);
   void SetGIState(int string, int brightness);
+  void SetSwitchState(int number, int state);
+  bool IsSwitchVirtualized(int number);
   PPUCSwitchState* GetNextSwitchState();
 
   uint8_t GetCoinDoorClosedSwitch() { return m_coinDoorClosedSwitch; };