Railcom Update

Author: Asbelos

DCC.cpp

@@ -1239,47 +1239,3 @@ void DCC::displayCabList(Print * stream) {
      StringFormatter::send(stream,F("<* Default momentum=%d/%d *>\n"),
               DCC::defaultMomentumA,DCC::defaultMomentumD);
 }
-
-void DCC::setLocoInBlock(uint16_t loco, uint16_t blockid, bool exclusive) {
-  // avoid unused warnings when EXRAIL not active
-  (void)loco; (void)blockid; (void)exclusive;
-  
-  // update block loco is in, tell exrail leaving old block, and entering new.
-
-  // NOTE: The loco table scanning is really inefficient and needs rewriting
-  //   This was done once in the momentum poc.  
-  #ifdef EXRAIL_ACTIVE
-  auto slot=LocoSlot::getSlot(loco,true);
-  if (!slot) return; // loco not known, nothing to do
-  
-  auto oldBlock=slot->getBlockOccupied(); 
-  if (oldBlock==blockid) return; 
-  if (oldBlock) RMFT2::blockEvent(oldBlock,loco,false);
-  slot->setBlockOccupied(blockid);
-  if (blockid) RMFT2::blockEvent(blockid,loco,true);
-
-  if (exclusive) {
-    SLOTLOOP {
-          if (slot->getLoco()!=loco &&  slot->getBlockOccupied()==blockid) {
-            RMFT2::blockEvent(blockid,slot->getLoco(),false);
-            slot->setBlockOccupied(0);
-          }
-      }
-    }
-  
-  #endif 
-}
-
-void DCC::clearBlock(uint16_t blockid) {
-  (void)blockid; // avoid unused warning when EXRAIL not active
-  // clear block occupied by loco, tell exrail about all leavers
-  #ifdef EXRAIL_ACTIVE
-  SLOTLOOP {
-       
-        if (slot->getBlockOccupied()==blockid) {
-        RMFT2::blockEvent(blockid,slot->getLoco(),false);
-        slot->setBlockOccupied(0);
-        }
-      }
-  #endif
-}

DCC.h

@@ -83,8 +83,6 @@ class DCC
   static void verifyCVByte(int16_t cv, byte byteValue, ACK_CALLBACK callback);
   static void verifyCVBit(int16_t cv, byte bitNum, bool bitValue, ACK_CALLBACK callback);
   static bool setTime(uint16_t minutes,uint8_t speed, bool suddenChange);
-  static void setLocoInBlock(uint16_t loco, uint16_t blockid, bool exclusive);
-  static void clearBlock(uint16_t blockid);
   static void getDriveawayLocoId(ACK_CALLBACK callback);
   static void getLocoId(ACK_CALLBACK callback);
   static void getConsistId(ACK_CALLBACK callback);

DCCTimerAVR.cpp

@@ -72,44 +72,44 @@ void DCCTimer::startRailcomTimer(byte brakePin) {
      - Sets the Railcom pin high at first tick and subsequent ticks 
        until its reset to setting pin 9 low at next tick.
         
-     - Cycles at 436uS so the second tick is the 
+     - Cycles at cutoutDuration so the second tick is the 
         correct distance from the cutout.
         
      - Waveform code is responsible for resetting 
        any time between the first and second tick.
        (there will be 7 DCC timer1 ticks in which to do this.)
     
     */
-  const int cutoutDuration = 430; // Desired interval in microseconds
-  const int cycle=cutoutDuration/2;
+  const int Tcs=(26+32)/2;   // half way spec Desired time from idealised setup call (at previous DCC timer interrupt) to the cutout.  
+  const int Tce=(454+488)/2; // half way spec (460..480uS) Time from start of cutout to end of cutout.
+  const int cutoutDuration = Tce-Tcs; // Desired interval in microseconds
+  const int cycle=(cutoutDuration+1)/2; // 
 
-  const byte RailcomFudge0=58+58+29;
+  const byte delayBeforeCutout=58+58+Tcs; // Expected time from idealised setup call (at previous DCC timer interrupt) to the cutout. This is the time we need to wait before we can set pin 9 high. We will then set pin 9 low at the next tick which is cutoutDuration later. This value should be reduced to reflect the Timer1 value measuring the time since the previous hardware interrupt.
 
   // Set Timer2 to CTC mode with set on compare match
   TCCR2A = (1 << WGM21) | (1 << COM2B0) | (1 << COM2B1);
   // Prescaler of 32
   TCCR2B =  (1 << CS21) | (1 << CS20); 
-  OCR2A = cycle-1; // Compare match value for 430 uS
+  OCR2A = cycle; // Compare match value for cutout duration
   // Enable Timer2 output on pin 9 (OC2B)
   DDRB |= (1 << DDB1);
 
-  // RailcomFudge2 is the expected time from idealised 
+  // timeSlip is the expected time from idealised 
   // setup call (at previous DCC timer interrupt) to the cutout. 
   // This value should be reduced to reflect the Timer1 value
   // measuring the time since the previous hardware interrupt
-  byte tcfudge=TCNT1/16; 
-  TCNT2=cycle-RailcomFudge0/2+tcfudge/2;
 
-  
- // Previous TIMER1 Tick was at rising end-of-packet bit
- // Cutout starts half way through first preamble
- // that is 2.5 * 58uS later.
-  }
+  // tcnt1 = prescaler 64,  tcnt2 prescaler=32
+  noInterrupts();
+  uint16_t timeSlip=(TCNT1/64)*32; 
+  TCNT2=cycle-timeSlip/2-delayBeforeCutout/2;
+  interrupts();
+}
 
 void DCCTimer::ackRailcomTimer() {
   // Change Timer2 to CTC mode with RESET pin 9 on next compare match
   TCCR2A = (1 << WGM21) | (1 << COM2B1);
-  // diagnostic digitalWrite(4,LOW);
 }
 
 

LocoSlot.cpp

@@ -31,7 +31,6 @@ void LocoSlot::prepare(uint16_t locoId) {
     momentumA=MOMENTUM_USE_DEFAULT;
     momentumD=MOMENTUM_USE_DEFAULT;
     targetSpeed=128;
-    blockOccupied=0;
     savedSpeedCode=0; 
 
     snifferSpeedCode=128; // default direction forward

LocoSlot.h

@@ -43,9 +43,7 @@ class LocoSlot {
   LocoSlot* consistNext;
 
   // DCC data for this loco 
-  uint16_t loco;             // DCC loco id
-  uint16_t blockOccupied;    // railcom detected block 
-  
+  uint16_t loco;          // DCC loco id
   byte targetSpeed;       // speed set by throttle
   byte speedCode;         // current DCC speed and direction
   byte snifferSpeedCode;  // sniffer speed and direction
@@ -93,8 +91,6 @@ class LocoSlot {
   void setGroupFlags(byte v) { groupFlags=v; }
   uint32_t getFunctions() { return functions; }
   void setFunctions(uint32_t v) { functions=v; }
-  uint16_t getBlockOccupied() { return blockOccupied; }
-  void setBlockOccupied(uint16_t v) { blockOccupied=v; }
   void forget();
   void saveSpeed();
   byte getSavedSpeedCode() ;

Railcom.cpp

@@ -18,15 +18,31 @@
  *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+
+ /*
+ This class acts as a 3 way coordinator between
+  - the DCC waveform cutout generator,
+  - the incoming railcom collector notifications
+  - and the EXRAIL2 block enter/exit system   
+  */
 #include "Railcom.h"
 #include "DCC.h"
 #include "DCCWaveform.h"
+#include "EXRAIL2.h"
 
 uint16_t Railcom::expectLoco=0;
 uint16_t Railcom::expectCV=0;
 unsigned long Railcom::expectWait=0;
 ACK_CALLBACK Railcom::expectCallback=0;
 
+enum ResponseType: byte { 
+        ENTER_BLOCK=0x00,  // loco entering block, block id and loco id follow
+        EXIT_BLOCK=0x80,   // loco exiting block, block id and loco id follow
+        CV_VALUE=0x40,     // cv value read from a POM, cv value follow
+        CV_VALUE_LIST=0xC0, // list of cv values read from a POM, cv id and 4 values follow
+    };
+  
+
 // anticipate is used when waiting for a CV read from a railcom loco
 void Railcom::anticipate(uint16_t loco, uint16_t cv, ACK_CALLBACK callback) { 
     expectLoco=loco;
@@ -42,31 +58,32 @@ void Railcom::process(int16_t firstVpin,byte * buffer, byte length) {
     byte i=0; 
     while (i<length) {
         byte block=buffer[i] & 0x3f;
-        byte type=buffer[i]>>6;
-
+        (void)block; // avoid compiler warning if not using EXRAIL
+        byte type=buffer[i] & 0xc0;
+        
         switch (type) {
             // a type=0 record has block,locohi,locolow
-            case 0: {
+            case ENTER_BLOCK:
+            case EXIT_BLOCK:
+             {
+                #ifdef EXRAIL_ACTIVE
                 uint16_t locoid= ((uint16_t)buffer[i+1])<<8 | ((uint16_t)buffer[i+2]);
-                DIAG(F("RC3 b=%d l=%d"),block,locoid);
-        
-                if (locoid==0) DCC::clearBlock(firstVpin+block);
-                else DCC::setLocoInBlock(locoid,firstVpin+block,true);
+                RMFT2::blockEvent(firstVpin+block,locoid,type==ENTER_BLOCK);
+                #endif
                 i+=3;
             }
             break;
-       case 2: { // csv value from POM read
+       case CV_VALUE: { // csv value from POM read
             byte value=buffer[i+1];
             if (expectCV && DCCWaveform::getRailcomLastLocoAddress()==expectLoco) {
-                DCC::setLocoInBlock(expectLoco,firstVpin+block,false);
                 if (expectCallback) expectCallback(value);
                 expectCV=0;
             }
             i+=2;
         }
          break;
          default:
-          DIAG(F("Unknown RC Collector code %d"),type);
+          DIAG(F("Unknown RC Collector code 0x%x"),type);
           return;
         }
       }