railcom tidy

DCCWaveform.cpp

@@ -77,6 +77,7 @@ void DCCWaveform::interruptHandler() {
   if (cutoutNextTime) {
     cutoutNextTime=false;
     railcomSampleWindow=false; // about to cutout, stop reading railcom data.
+    railcomCutoutCounter++;
     DCCTimer::startRailcomTimer(9);
   }
   byte sigMain=signalTransform[mainTrack.state];
@@ -125,6 +126,7 @@ bool DCCWaveform::railcomPossible=false;     // High accuracy only
 volatile bool DCCWaveform::railcomActive=false;     // switched on by user
 volatile bool DCCWaveform::railcomDebug=false;     // switched on by user
 volatile bool DCCWaveform::railcomSampleWindow=false; // true during packet transmit
+volatile byte DCCWaveform::railcomCutoutCounter=0;    // cyclic cutout
 
 bool DCCWaveform::setRailcom(bool on, bool debug) {
   if (on && railcomPossible) {

DCCWaveform.h

@@ -87,6 +87,9 @@ class DCCWaveform {
     inline static bool isRailcom() {
       return railcomActive;
     };
+    inline static byte getRailcomCutoutCounter() {
+      return railcomCutoutCounter;
+    };
     inline static bool isRailcomSampleWindow() {
       return railcomSampleWindow;
     };
@@ -125,6 +128,7 @@ class DCCWaveform {
     static volatile bool railcomActive;     // switched on by user
     static volatile bool railcomDebug;     // switched on by user
     static volatile bool railcomSampleWindow; // when safe to sample
+    static volatile byte railcomCutoutCounter; // incremented for each cutout
     static bool cutoutNextTime;   // railcom
 #ifdef ARDUINO_ARCH_ESP32
   static RMTChannel *rmtMainChannel;

EXRAIL3.cpp

@@ -1,5 +1,6 @@
 // file exists to break #include dependency loop
 #include "EXRAIL2.h"
+#include "EXRAIL3.h"
 void RMFT3::blockEvent(int16_t block, int16_t loco, bool entering)  {
     RMFT2::blockEvent(block,loco,entering);
 };

IO_I2CRailcom.h

@@ -45,7 +45,6 @@
 
 #ifndef IO_I2CRailcom_h
 #define IO_I2CRailcom_h
-#include "EXRAIL3.h"
 #include "IODevice.h"
 #include "I2CManager.h"
 #include "DIAG.h"
@@ -54,7 +53,6 @@
 
 // Debug and diagnostic defines, enable too many will result in slowing the driver
 #define DIAG_I2CRailcom
-#define DIAG_I2CRailcom_data
 
 class I2CRailcom : public IODevice {
 private: 
@@ -62,14 +60,16 @@ private:
   uint8_t _UART_CH=0x00; // channel 0 or 1 flips each loop if npins>1
   byte _inbuf[65];
   byte _outbuf[2];
-  Railcom _channelMonitors[2];
-  int16_t _locoInBlock[2]; 
+  byte cutoutCounter[2]; 
+  Railcom * _channelMonitors[2]; 
 public:
   // Constructor
    I2CRailcom(VPIN firstVpin, int nPins, I2CAddress i2cAddress){
     _firstVpin = firstVpin;
     _nPins = nPins;
     _I2CAddress = i2cAddress;
+    _channelMonitors[0]=new Railcom(firstVpin);
+    if (nPins>1) _channelMonitors[1]=new Railcom(firstVpin+1);
     addDevice(this);
    } 
   
@@ -110,46 +110,27 @@ public:
     // IF we have 2 channels, flip channels each loop
     if (_nPins>1) _UART_CH=_UART_CH?0:1;
 
+    // have we read this cutout already?
+    auto cut=DCCWaveform::getRailcomCutoutCounter();
+    if (cutoutCounter[_UART_CH]==cut) return; 
+    cutoutCounter[_UART_CH]=cut; 
+    
     // Read incoming raw Railcom data, and process accordingly
 
     auto inlength = UART_ReadRegister(REG_RXLV);
     if (inlength==0) return; 
-    
-    #ifdef DIAG_I2CRailcom
-          DIAG(F("Railcom: %s/%d RX Fifo length: %d"),_I2CAddress.toString(), _UART_CH, inlength); 
-    #endif
-
+    if (inlength> sizeof(_inbuf)) inlength=sizeof(_inbuf); 
+    _inbuf[0]=0;
+    if (inlength>0) {
       // Read data buffer from UART
       _outbuf[0]=(byte)(REG_RHR << 3 | _UART_CH << 1);
       I2CManager.read(_I2CAddress, _inbuf, inlength, _outbuf, 1); 
-
+    }
     // HK: Reset FIFO at end of read cycle
     UART_WriteRegister(REG_FCR, 0x07,false);
     
-    #ifdef DIAG_I2CRailcom_data
-      DIAG(F("Railcom %s/%d RX FIFO Data"), _I2CAddress.toString(), _UART_CH);
-      for (int i = 0; i < inlength; i++){
-        DIAG(F("[0x%x]: 0x%x"), i, _inbuf[i]);  
-      }
-    #endif
-    
-    // Ask Railcom to interpret the channel1 loco
-    auto locoid=_channelMonitors[_UART_CH].getChannel1Loco(_inbuf);
-    #ifdef DIAG_I2CRailcom
-      DIAG(F("Railcom Channel1=%d"), locoid);
-    #endif
-    if (locoid<0) return; // -1 indicates Railcom needs another packet
-    
-    // determine if loco in this block has changed 
-    auto prevLoco=_locoInBlock[_UART_CH];
-    if (locoid==prevLoco) return;
-    
-    // Previous loco (if any) is exiting block  
-    if (prevLoco) RMFT3::blockEvent(_firstVpin+_UART_CH,prevLoco,false);
-    
-    // new loco, if any, is entering block
-    _locoInBlock[_UART_CH]=locoid;
-    if (locoid) RMFT3::blockEvent(_firstVpin+_UART_CH,locoid,true);
+    // Ask Railcom to interpret the raw data
+    _channelMonitors[_UART_CH]->process(_inbuf,inlength);
   }
           
  

Railcom.cpp

@@ -49,7 +49,13 @@
  **/
 
 #include "Railcom.h"
+#include "defines.h"
 #include "FSH.h"
+#include "EXRAIL3.h"
+#include "DIAG.h"
+
+//#define DIAG_I2CRailcom_data
+
 
   /** Table for 8-to-6 decoding of railcom data. This table can be indexed by the
    * 8-bit value read from the railcom channel, and the return value will be
@@ -129,41 +135,70 @@ const uint8_t HIGHFLASH decode[256] =
         RMOB_LOGON_ENABLE_FEEDBACK = 15,
 };
 
-
-Railcom::Railcom() {
+Railcom::Railcom(uint16_t blockvpin) {
     haveHigh=false;
     haveLow=false;
+    packetsWithNoData=0;
+    locoOnTrack=0;
+    vpin=blockvpin;
 }
 
     /* returns -1: Call again next packet
                 0: No loco on track
                >0: loco id
     */
-int16_t Railcom::getChannel1Loco(uint8_t * inbound) {
+void Railcom::process(uint8_t * inbound, uint8_t length) {
+    #ifdef DIAG_I2CRailcom_data
+      DIAG(F("Railcom %d RX FIFO Data, %d"), vpin,length);
+      for (int i = 0; i < 2; i++){
+        if (inbound[i]) DIAG(F("[0x%x]: 0x%x"), i, inbound[i]);  
+      }
+    #endif
     auto v1=GETHIGHFLASH(decode,inbound[0]);
-    if (v1>MAX_VALID) return -1;
-    auto v2=GETHIGHFLASH(decode,inbound[1]);
-    if (v2>MAX_VALID) return -1;
-    auto packet=(v1<<6) | v2;
+    auto v2=(length>2) ? GETHIGHFLASH(decode,inbound[1]):0x0;
+    uint16_t packet=(v1<<6) | (v2 & 0x3f);
     // packet is 12 bits TTTTDDDDDDDD
     auto type=packet>>8;   
     auto data= packet & 0xFF;
     if (type==RMOB_ADRHIGH) {
         holdoverHigh=data;
         haveHigh=true;
+        packetsWithNoData=0;
         }
     else if (type==RMOB_ADRLOW) {
         holdoverLow=data;
         haveLow=true;
+        packetsWithNoData=0;
         }
     else if (type==RMOB_EXT) {
-        return -1; /* ignore*/
+        return; /* ignore*/
         }
     else {
+        if (packetsWithNoData>MAX_WAIT_FOR_GLITCH) {
+            // treat as no loco
             haveHigh=false;
             haveLow=false;
-        return 0; // treat as no loco 
+            // Previous loco (if any) is exiting block  
+            blockEvent(false);
+            locoOnTrack=0;
+            return ; 
         }
-    if (haveHigh && haveLow) return ((holdoverHigh<<8)| holdoverLow);
-    return -1; // call again, need next packet 
+        packetsWithNoData++;
+        return; // need more data          
+    }    
+    if (haveHigh && haveLow) {
+        uint16_t thisLoco=((holdoverHigh<<8)| holdoverLow);
+        if (locoOnTrack!=thisLoco) {
+            // Previous loco (if any) is exiting block  
+            blockEvent(false);
+            locoOnTrack=thisLoco;
+            blockEvent(true); 
+        }
+    }
+}
+
+void Railcom::blockEvent(bool entering) {
+    #ifdef EXRAIL_ACTIVE
+    if (locoOnTrack) RMFT3::blockEvent(vpin,locoOnTrack,entering);
+    #endif
 }

Railcom.h

@@ -24,17 +24,22 @@
 
 class Railcom {
   public:
-    Railcom();
+    Railcom(uint16_t vpin);
 
     /* returns -1: Call again next packet
                 0: No loco on track
                >0: loco id
     */
-    int16_t getChannel1Loco(uint8_t * inbound);
+  void process(uint8_t * inbound,uint8_t length);
   
   private:
+  void blockEvent(bool entering);
+  uint16_t locoOnTrack;
+  uint16_t vpin;
  uint8_t holdoverHigh,holdoverLow;
  bool haveHigh,haveLow; 
+ uint8_t packetsWithNoData;  
+ static const byte MAX_WAIT_FOR_GLITCH=20; // number of dead or empty packets before assuming loco=0 
 };
 
 #endif