optimized

Author: mkalkbrenner

src/EventDispatcher/Event.h

@@ -48,6 +48,7 @@
 #define CONFIG_TOPIC_SWITCHES 115                 // "s"
 #define CONFIG_TOPIC_TRIGGER 116                  // "t"
 #define CONFIG_TOPIC_SWITCH_MATRIX 120            // "x"
+#define CONFIG_TOPIC_SWITCH_CHAIN 121             // "y"
 
 #define CONFIG_TOPIC_HOLD_POWER_ACTIVATION_TIME 65  // "A"
 #define CONFIG_TOPIC_DURATION 65                    // "A"
@@ -76,6 +77,7 @@
 #define CONFIG_TOPIC_LIGHT_UP 85                    // "U"
 #define CONFIG_TOPIC_ACTIVE_LOW 86                  // "V"
 #define CONFIG_TOPIC_POWER 87                       // "W"
+#define CONFIG_TOPIC_NEXT_BOARD 88                  // "X"
 #define CONFIG_TOPIC_TYPE 89                        // "Y"
 #define CONFIG_TOPIC_EFFECT 89                      // "Y"
 #define CONFIG_TOPIC_MODE 90                        // "Z"

src/EventDispatcher/EventDispatcher.cpp

@@ -41,6 +41,10 @@ void EventDispatcher::setCrossLinkSerial(HardwareSerial &reference) {
 
 void EventDispatcher::setDebug(bool enabled) { debugEnabled = enabled; }
 
+void EventDispatcher::setNextSwitchBoard(byte boardId) {
+  nextSwitchBoard = boardId;
+}
+
 void EventDispatcher::addListener(EventListener *eventListener) {
   addListener(eventListener, EVENT_SOURCE_ANY);
 }
@@ -153,6 +157,10 @@ size_t EventDispatcher::getV2PayloadBytes(ppuc::v2::FrameType frameType) {
     case ppuc::v2::kFrameOutputState:
       return ppuc::v2::BitsToBytes(runtimeConfig.coilBits) +
              ppuc::v2::BitsToBytes(runtimeConfig.lampBits);
+    case ppuc::v2::kFrameSwitchState:
+      return ppuc::v2::BitsToBytes(runtimeConfig.switchBits);
+    case ppuc::v2::kFrameSwitchNoChange:
+      return 0;
     case ppuc::v2::kFrameHeartbeat:
     case ppuc::v2::kFrameError:
     case ppuc::v2::kFrameReset:
@@ -226,11 +234,26 @@ bool EventDispatcher::processV2Frame(const byte* frame, size_t payloadBytes) {
     const size_t lampBytes = ppuc::v2::BitsToBytes(runtimeConfig.lampBits);
     applyOutputStates(&frame[4], coilBytes, &frame[4 + coilBytes], lampBytes);
     if (frame[2] == board) {
-      sendSwitchStateFrame((byte)((board + 1) % ppuc::v2::kMaxBoards));
+      if (switchDirty) {
+        sendSwitchStateFrame(nextSwitchBoard);
+        switchDirty = false;
+      } else {
+        sendSwitchNoChangeFrame(nextSwitchBoard);
+      }
     }
     return true;
   }
 
+  if (frameType == ppuc::v2::kFrameSwitchState) {
+    const size_t switchBytes = ppuc::v2::BitsToBytes(runtimeConfig.switchBits);
+    applySwitchStates(&frame[4], switchBytes);
+    return true;
+  }
+
+  if (frameType == ppuc::v2::kFrameSwitchNoChange) {
+    return true;
+  }
+
   if (frameType == ppuc::v2::kFrameReset) {
     dispatch(new Event(EVENT_RESET));
     return true;
@@ -405,6 +428,9 @@ void EventDispatcher::updateSwitchBitmap(Event *event) {
 
   ppuc::v2::SetBitmapBit(switchStates, (uint16_t)mappedIndex,
                          event->value != 0);
+  if (!applyingRemoteSwitchState) {
+    switchDirty = true;
+  }
 }
 
 void EventDispatcher::applyOutputStates(const byte *coils, size_t coilBytes,
@@ -437,6 +463,24 @@ void EventDispatcher::applyOutputStates(const byte *coils, size_t coilBytes,
   memcpy(outputLamps, lamps, lampBytes);
 }
 
+void EventDispatcher::applySwitchStates(const byte* switches,
+                                        size_t switchBytes) {
+  // Global switch state is board-to-board on the RS485 bus. CPU/libppuc never
+  // broadcasts switch states. Every board consumes incoming switch frames and
+  // emits local switch events for fast-flip/effect listeners.
+  applyingRemoteSwitchState = true;
+  for (uint16_t n = 0; n < runtimeConfig.switchBits; ++n) {
+    bool oldState = ppuc::v2::GetBitmapBit(switchStates, n);
+    bool newState = ppuc::v2::GetBitmapBit(switches, n);
+    if (oldState != newState) {
+      dispatch(new Event(EVENT_SOURCE_SWITCH, switchIndexToNumber[n],
+                         newState ? 1 : 0, true));
+    }
+  }
+  applyingRemoteSwitchState = false;
+  memcpy(switchStates, switches, switchBytes);
+}
+
 void EventDispatcher::sendSwitchStateFrame(byte nextBoard) {
   // Switch updates are transmitted as a compact V2 frame containing the full
   // dense switch bitmap. The CPU selects the responding board via token
@@ -472,6 +516,31 @@ void EventDispatcher::sendSwitchStateFrame(byte nextBoard) {
   lastPoll = millis();
 }
 
+void EventDispatcher::sendSwitchNoChangeFrame(byte nextBoard) {
+  byte* frame = v2DmaTxBuffer;
+  frame[0] = ppuc::v2::kSyncByte;
+  frame[1] = ppuc::v2::ComposeTypeAndFlags(ppuc::v2::kFrameSwitchNoChange,
+                                           ppuc::v2::kFlagNone);
+  frame[2] = nextBoard;
+  frame[3] = txSequence++;
+  uint16_t crc = ppuc::v2::Crc16Ccitt(frame, ppuc::v2::kHeaderBytes);
+  frame[4] = highByte(crc);
+  frame[5] = lowByte(crc);
+
+  if (!v2UartDmaActive || !sendV2FrameUartDma(frame, ppuc::v2::kResetFrameBytes)) {
+    v2TxFallback++;
+    digitalWrite(rs485Pin, HIGH);  // Write.
+    delayMicroseconds(RS485_MODE_SWITCH_DELAY);
+    hwSerial->write(frame, ppuc::v2::kResetFrameBytes);
+    hwSerial->flush();
+    digitalWrite(rs485Pin, LOW);  // Read.
+    delayMicroseconds(RS485_MODE_SWITCH_DELAY);
+  }
+
+  v2SwitchNoChangeTx++;
+  lastPoll = millis();
+}
+
 bool EventDispatcher::handleV2Frame() {
   if (hwSerial->available() < (int)ppuc::v2::kHeaderBytes) {
     return false;
@@ -490,7 +559,8 @@ bool EventDispatcher::handleV2Frame() {
   if (frameType != ppuc::v2::kFrameHeartbeat &&
       frameType != ppuc::v2::kFrameError &&
       frameType != ppuc::v2::kFrameReset && payloadBytes == 0 &&
-      frameType != ppuc::v2::kFrameOutputState) {
+      frameType != ppuc::v2::kFrameOutputState &&
+      frameType != ppuc::v2::kFrameSwitchNoChange) {
     return false;
   }
 
@@ -572,6 +642,8 @@ void EventDispatcher::update() {
     Serial.print(v2RxDmaTimeouts);
     Serial.print(" tx=");
     Serial.print(v2TxFrames);
+    Serial.print(" tx_nochange=");
+    Serial.print(v2SwitchNoChangeTx);
     Serial.print(" tx_fallback=");
     Serial.println(v2TxFallback);
     rp2040.resumeOtherCore();

src/EventDispatcher/EventDispatcher.h

@@ -40,6 +40,7 @@ class EventDispatcher {
 
   void setCrossLinkSerial(HardwareSerial& reference);
   void setDebug(bool enabled);
+  void setNextSwitchBoard(byte boardId);
 
   void addListener(EventListener* eventListener, char sourceId);
 
@@ -61,8 +62,10 @@ class EventDispatcher {
   size_t getV2PayloadBytes(ppuc::v2::FrameType frameType);
   bool processV2Frame(const byte* frame, size_t payloadBytes);
   void sendSwitchStateFrame(byte nextBoard);
+  void sendSwitchNoChangeFrame(byte nextBoard);
   void applyOutputStates(const byte* coils, size_t coilBytes, const byte* lamps,
                          size_t lampBytes);
+  void applySwitchStates(const byte* switches, size_t switchBytes);
   void updateSwitchBitmap(Event* event);
   int16_t findMappedIndex(const uint16_t* table, uint16_t count,
                           uint16_t number);
@@ -109,11 +112,15 @@ class EventDispatcher {
   uint32_t v2RxDmaRestarts = 0;
   uint32_t v2RxDmaTimeouts = 0;
   uint32_t v2TxFrames = 0;
+  uint32_t v2SwitchNoChangeTx = 0;
   uint32_t v2TxFallback = 0;
+  bool switchDirty = false;
+  bool applyingRemoteSwitchState = false;
 
   bool rs485 = false;
   uint8_t rs485Pin = 0;
   byte board = 255;
+  byte nextSwitchBoard = ppuc::v2::kNoBoard;
   uint32_t lastPoll;
   bool running = false;
 

src/IOBoardController.cpp

@@ -117,6 +117,12 @@ void IOBoardController::handleEvent(ConfigEvent *event) {
         }
         break;
 
+      case CONFIG_TOPIC_SWITCH_CHAIN:
+        if (event->key == CONFIG_TOPIC_NEXT_BOARD) {
+          _eventDispatcher->setNextSwitchBoard((byte)event->value);
+        }
+        break;
+
       case CONFIG_TOPIC_SWITCHES:
         switch (event->key) {
           case CONFIG_TOPIC_PORT:

src/PPUCProtocolV2.h

@@ -42,6 +42,7 @@ enum FrameType : uint8_t {
   kFrameMapping = 0x06,
   kFrameReset = 0x07,
   kFrameConfig = 0x08,
+  kFrameSwitchNoChange = 0x09,
 };
 
 enum MappingDomain : uint8_t {