Remove hard-coded pin and fix timing

Author: mikesmitty

DCCTimer.h

@@ -62,8 +62,8 @@ class DCCTimer {
   static bool isPWMPin(byte pin);
   static void setPWM(byte pin, bool high);
   static void clearPWM();
-  static void startRailcomTimer(byte brakePin);
-  static void ackRailcomTimer();
+  static void startRailcomTimer(bool isMain, bool lastBit);
+  static void ackRailcomTimer(bool isMain);
   static void DCCEXanalogWriteFrequency(uint8_t pin, uint32_t frequency);
   static void DCCEXanalogWrite(uint8_t pin, int value, bool invert);
   static void DCCEXledcDetachPin(uint8_t pin);

DCCTimerAVR.cpp

@@ -60,7 +60,7 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   }
 
 
-void DCCTimer::startRailcomTimer(byte brakePin) {
+void DCCTimer::startRailcomTimer(bool isMain, bool lastBit) {
 #if defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2560)
   /* The Railcom timer is started in such a way that it 
      - First triggers 28uS after the last TIMER1 tick. 
@@ -77,9 +77,11 @@ void DCCTimer::startRailcomTimer(byte brakePin) {
        (there will be 7 DCC timer1 ticks in which to do this.)
     
     */
-  (void) brakePin; // Ignored... works on pin 9 only 
+  (void) lastBit; // Ignored
   const int cutoutDuration = 430; // Desired interval in microseconds
 
+  if (!isMain) return;
+
   // Set up Timer2 for CTC mode (Clear Timer on Compare Match)
   TCCR2A = 0; // Clear Timer2 control register A
   TCCR2B = 0; // Clear Timer2 control register B
@@ -117,8 +119,9 @@ void DCCTimer::startRailcomTimer(byte brakePin) {
 #endif
 }
 
-void DCCTimer::ackRailcomTimer() {
+void DCCTimer::ackRailcomTimer(bool isMain) {
 #if defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2560)
+  if (!isMain) return;
   OCR2B= 0x00;  // brake pin pwm duty cycle 0 at next tick
 #endif
 }

DCCTimerMEGAAVR.cpp

@@ -80,13 +80,15 @@ extern char *__malloc_heap_start;
     interruptHandler();
   }
 
-void DCCTimer::startRailcomTimer(byte brakePin) {
+void DCCTimer::startRailcomTimer(bool isMain, bool lastBit) {
   // TODO: for intended operation see DCCTimerAVR.cpp
-  (void) brakePin; 
+  (void) isMain;
+  (void) lastBit;
 }
 
-void DCCTimer::ackRailcomTimer() {
+void DCCTimer::ackRailcomTimer(bool isMain) {
   // TODO: for intended operation see DCCTimerAVR.cpp
+  (void) isMain;
 }
 
   bool DCCTimer::isPWMPin(byte pin) {

DCCTimerSAMD.cpp

@@ -76,13 +76,15 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   interrupts();
 }
 
-void DCCTimer::startRailcomTimer(byte brakePin) {
+void DCCTimer::startRailcomTimer(bool isMain, bool lastBit) {
   // TODO: for intended operation see DCCTimerAVR.cpp
-  (void) brakePin; 
+  (void) isMain;
+  (void) lastBit;
 }
 
-void DCCTimer::ackRailcomTimer() {
+void DCCTimer::ackRailcomTimer(bool isMain) {
   // TODO: for intended operation see DCCTimerAVR.cpp
+  (void) isMain;
 }
 
 // Timer IRQ handlers replace the dummy handlers (in cortex_handlers)

DCCTimerSTM32.cpp

@@ -30,9 +30,7 @@
 #ifdef ARDUINO_ARCH_STM32
 
 #include "DCCTimer.h"
-#ifdef DEBUG_ADC
 #include "TrackManager.h"
-#endif
 #include "DIAG.h"
 #include <wiring_private.h>
 
@@ -215,68 +213,106 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   interrupts();
 }
 
-// Static variables for Railcom timer shared between functions
-static HardwareTimer *railcomTimer = nullptr;
-static byte railcomBrakePin = 255;
+// Static variables for Railcom timers - separate for main and prog tracks
+static HardwareTimer *railcomMainTimer = nullptr;
+static HardwareTimer *railcomProgTimer = nullptr;
 
-// Timer callback functions
-void railcomEndCallback() {
-  if (railcomBrakePin != 255) {
-    digitalWrite(railcomBrakePin, LOW);
+// Timer callback functions for main track
+void railcomMainEndCallback() {
+  TrackManager::setMainBrake(false, true);
+  if (railcomMainTimer) {
+    railcomMainTimer->pause();
+    railcomMainTimer->detachInterrupt();
   }
-  if (railcomTimer) {
-    railcomTimer->pause();
-    railcomTimer->detachInterrupt();
+}
+
+void railcomMainStartCallback() {
+  TrackManager::setMainBrake(true, true);
+  if (railcomMainTimer) {
+    railcomMainTimer->pause();
+    railcomMainTimer->detachInterrupt();
+    // Start timer for cutout duration (430us)
+    railcomMainTimer->setOverflow(430, MICROSEC_FORMAT);
+    railcomMainTimer->attachInterrupt(railcomMainEndCallback);
+    railcomMainTimer->refresh();
+    railcomMainTimer->resume();
   }
 }
 
-void railcomStartCallback() {
-  if (railcomBrakePin != 255) {
-    digitalWrite(railcomBrakePin, HIGH);
+// Timer callback functions for prog track
+void railcomProgEndCallback() {
+  TrackManager::setProgBrake(false, true);
+  if (railcomProgTimer) {
+    railcomProgTimer->pause();
+    railcomProgTimer->detachInterrupt();
   }
-  if (railcomTimer) {
-    railcomTimer->pause();
-    railcomTimer->detachInterrupt();
+}
+
+void railcomProgStartCallback() {
+  TrackManager::setProgBrake(true, true);
+  if (railcomProgTimer) {
+    railcomProgTimer->pause();
+    railcomProgTimer->detachInterrupt();
     // Start timer for cutout duration (430us)
-    railcomTimer->setOverflow(430, MICROSEC_FORMAT);
-    railcomTimer->attachInterrupt(railcomEndCallback);
-    railcomTimer->refresh();
-    railcomTimer->resume();
+    railcomProgTimer->setOverflow(430, MICROSEC_FORMAT);
+    railcomProgTimer->attachInterrupt(railcomProgEndCallback);
+    railcomProgTimer->refresh();
+    railcomProgTimer->resume();
   }
 }
 
-void DCCTimer::startRailcomTimer(byte brakePin) {
-  const uint32_t cutoutOffset = 10;  // 26-32 microseconds after last DCC tick minus overhead
+void DCCTimer::startRailcomTimer(bool isMain, bool lastBit) {
+  uint32_t cutoutOffset;
+  HardwareTimer *timer = nullptr;
+
+  // We're just starting the last XOR bit, wait for the bit length, terminator bit, and initial cutout delay, minus some overhead
+  if (lastBit) {
+    // 1-bit
+    cutoutOffset = 2 * 58 + 116 + 10;
+  } else {
+    // 0-bit
+    cutoutOffset = 2 * 116 + 116 + 10;
+  }
 
-  // Configure brakePin as output
-  pinMode(brakePin, OUTPUT);
-  digitalWrite(brakePin, LOW);
+  if (isMain) {
+    TrackManager::setMainBrake(false, true);
 
-  // Initialize timer if not already done
-  if (!railcomTimer) {
-    railcomTimer = new HardwareTimer(TIM3);
-  }
+    // Initialize main timer if not already done
+    if (!railcomMainTimer) {
+      railcomMainTimer = new HardwareTimer(TIM3);
+    }
+    timer = railcomMainTimer;
+  } else {
+    TrackManager::setProgBrake(false, true);
 
-  // Store the brake pin for callbacks
-  railcomBrakePin = brakePin;
+    // Initialize prog timer if not already done (use TIM4 for prog track)
+    if (!railcomProgTimer) {
+      railcomProgTimer = new HardwareTimer(TIM4);
+    }
+    timer = railcomProgTimer;
+  }
 
   // Start timer for offset
-  railcomTimer->pause();
-  railcomTimer->setPrescaleFactor(1);
-  railcomTimer->setOverflow(cutoutOffset, MICROSEC_FORMAT);
-  railcomTimer->attachInterrupt(railcomStartCallback);
-  railcomTimer->refresh();
-  railcomTimer->resume();
+  timer->pause();
+  timer->setPrescaleFactor(1);
+  timer->setOverflow(cutoutOffset, MICROSEC_FORMAT);
+  timer->attachInterrupt(isMain ? railcomMainStartCallback : railcomProgStartCallback);
+  timer->refresh();
+  timer->resume();
 }
 
-void DCCTimer::ackRailcomTimer() {
-  // Immediately end the Railcom cutout: set brake pin LOW and stop timer
-  if (railcomBrakePin != 255) {
-    digitalWrite(railcomBrakePin, LOW);
+void DCCTimer::ackRailcomTimer(bool isMain) {
+  // Immediately end the Railcom cutout for whichever timer is active
+  // Check both timers and stop any that are running
+  if (isMain && railcomMainTimer) {
+    railcomMainTimer->pause();
+    railcomMainTimer->detachInterrupt();
+    TrackManager::setMainBrake(false, true);
   }
-  if (railcomTimer) {
-    railcomTimer->pause();
-    railcomTimer->detachInterrupt();
+  if (!isMain && railcomProgTimer) {
+    railcomProgTimer->pause();
+    railcomProgTimer->detachInterrupt();
+    TrackManager::setProgBrake(false, true);
   }
 }
 

DCCTimerTEENSY.cpp

@@ -39,13 +39,15 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   myDCCTimer.begin(interruptHandler, DCC_SIGNAL_TIME);
   }
 
-void DCCTimer::startRailcomTimer(byte brakePin) {
+void DCCTimer::startRailcomTimer(bool isMain, bool lastBit) {
   // TODO: for intended operation see DCCTimerAVR.cpp
-  (void) brakePin; 
+  (void) isMain;
+  (void) lastBit;
 }
 
-void DCCTimer::ackRailcomTimer() {
+void DCCTimer::ackRailcomTimer(bool isMain) {
   // TODO: for intended operation see DCCTimerAVR.cpp
+  (void) isMain;
 }
 
 bool DCCTimer::isPWMPin(byte pin) {

DCCWaveform.cpp

@@ -147,7 +147,7 @@ void DCCWaveform::interrupt2() {
     // that the reminder doesn't block a more urgent packet. 
     reminderWindowOpen=transmitRepeats==0 && remainingPreambles<12 && remainingPreambles>1;
     if (remainingPreambles==1) promotePendingPacket();
-    else if (remainingPreambles==10 && isMainTrack && railcomActive) DCCTimer::ackRailcomTimer();
+    else if (remainingPreambles==10 && railcomActive) DCCTimer::ackRailcomTimer(isMainTrack);
     // Update free memory diagnostic as we don't have anything else to do this time.
     // Allow for checkAck and its called functions using 22 bytes more.
     else DCCTimer::updateMinimumFreeMemoryISR(22); 
@@ -176,7 +176,7 @@ void DCCWaveform::interrupt2() {
       // through the first preamble bit.
       // Note.. we are still sending the last packet bit
       //    and we then have to allow for the packet end bit
-      if (isMainTrack && railcomActive) DCCTimer::startRailcomTimer(9);
+      if (railcomActive) DCCTimer::startRailcomTimer(isMainTrack, state == WAVE_MID_1);
       }
   }  
 }

TrackManager.cpp

@@ -653,6 +653,14 @@ void TrackManager::reportGauges(Print* stream) {
     StringFormatter::send(stream,F(">\n"));    
 }
 
+void TrackManager::setTrackBrake(TRACK_MODE trackmode, bool on, bool interruptContext) {
+  FOR_EACH_TRACK(t) {
+    if (track[t]->getMode() & trackmode) {
+      track[t]->setBrake(on, interruptContext);
+    }
+  }
+}
+
 void TrackManager::setJoinRelayPin(byte joinRelayPin) {
   joinRelay=joinRelayPin;
   if (joinRelay!=UNUSED_PIN) {

TrackManager.h

@@ -70,6 +70,10 @@ class TrackManager {
     static void setMainPower(POWERMODE mode) {setTrackPower(TRACK_MODE_MAIN, mode);}
     static void setProgPower(POWERMODE mode) {setTrackPower(TRACK_MODE_PROG, mode);}
 
+    static void setTrackBrake(TRACK_MODE trackmode, bool on, bool interruptContext=false);
+    static void setMainBrake(bool on, bool interruptContext=false) {setTrackBrake(TRACK_MODE_MAIN, on, interruptContext);}
+    static void setProgBrake(bool on, bool interruptContext=false) {setTrackBrake(TRACK_MODE_PROG, on, interruptContext);}
+
     static const int16_t MAX_TRACKS=8;
     static bool setTrackMode(byte track, TRACK_MODE mode, int16_t DCaddr=0);
     static bool parseEqualSign(Print * stream,  int16_t params, int16_t p[]);