Channel2 support

DCC.cpp

@@ -897,6 +897,42 @@ DCC::LOCO DCC::speedTable[MAX_LOCOS];
 int DCC::lastLocoReminder = 0;
 int DCC::highestUsedReg = 0;
 
+void DCC::setLocoInBlock(int loco, uint16_t blockid, bool 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
+  int reg=lookupSpeedTable(loco,true);
+  if (reg<0) return;
+  auto oldBlock=speedTable[reg].blockOccupied; 
+  if (oldBlock==blockid) return; 
+  if (oldBlock) RMFT2::blockEvent(oldBlock,loco,false);
+  speedTable[reg].blockOccupied=blockid;
+  if (blockid) RMFT2::blockEvent(blockid,loco,true);
+
+  if (exclusive) {
+    for (int reg = 0; reg <= highestUsedReg; reg++) {
+       if (speedTable[reg].loco!=loco &&  speedTable[reg].blockOccupied==blockid) {
+        RMFT2::blockEvent(blockid,speedTable[reg].loco,false);
+        speedTable[reg].blockOccupied=0;
+      }
+  }
+  }
+  #endif 
+}
+
+void DCC::clearBlock(uint16_t blockid) {
+  // Railcom reports block empty... tell Exrail about all leavers 
+  #ifdef EXRAIL_ACTIVE
+  for (int reg = 0; reg <= highestUsedReg; reg++) {
+       if (speedTable[reg].blockOccupied==blockid) {
+        RMFT2::blockEvent(blockid,speedTable[reg].loco,false);
+        speedTable[reg].blockOccupied=0;
+      }
+  }
+  #endif 
+}
 
 void DCC::displayCabList(Print * stream) {
 

DCC.h

@@ -102,12 +102,14 @@ public:
     byte speedCode;
     byte groupFlags;
     uint32_t functions;
+    uint16_t blockOccupied; // railcom detected block 
   };
  static LOCO speedTable[MAX_LOCOS];
  static int lookupSpeedTable(int locoId, bool autoCreate=true);
  static byte cv1(byte opcode, int cv);
  static byte cv2(int cv);
- 
+ static void setLocoInBlock(int locoid, uint16_t blockid, bool exclusive);
+ static void clearBlock(uint16_t blockid);
 private:
   static byte loopStatus;
   static void setThrottle2(uint16_t cab, uint8_t speedCode);

DCCEXParser.cpp

@@ -1205,6 +1205,10 @@ bool DCCEXParser::parseD(Print *stream, int16_t params, int16_t p[])
         Diag::CMD = onOff;
         return true;
 
+    case "RAILCOM"_hk: // <D RAILCOM ON/OFF>
+        Diag::RAILCOM = onOff;
+        return true;
+
 #ifdef HAS_ENOUGH_MEMORY
     case "WIFI"_hk: // <D WIFI ON/OFF>
         Diag::WIFI = onOff;

DCCWaveform.cpp

@@ -127,10 +127,11 @@ 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
+volatile byte DCCWaveform::railcomLastAddressHigh=0;
+volatile byte DCCWaveform::railcomLastAddressLow=0;
 
 bool DCCWaveform::setRailcom(bool on, bool debug) {
   if (on && railcomPossible) {
-    // TODO check possible
     railcomActive=true;
     railcomDebug=debug;
   }
@@ -233,6 +234,12 @@ void DCCWaveform::promotePendingPacket() {
         return;
       }
 
+    // Remember address bytes of last sent packet so that Railcom can
+    // work out where the channel2 data came from.
+    railcomLastAddressHigh=transmitPacket[0];
+    railcomLastAddressLow =transmitPacket[1];
+  
+    
     if (packetPending) {
         // Copy pending packet to transmit packet
         // a fixed length memcpy is faster than a variable length loop for these small lengths

DCCWaveform.h

@@ -100,6 +100,14 @@ class DCCWaveform {
       railcomPossible=yes;
       if (!yes) setRailcom(false,false);
     };
+    inline static uint16_t getRailcomLastLocoAddress() {
+      // first 2 bits 00=short loco, 11=long loco , 01/10 = accessory
+      byte addressType=railcomLastAddressHigh & 0xC0;
+      if (addressType==0xC0) return ((railcomLastAddressHigh & 0x3f)<<8) | railcomLastAddressLow;
+      if (addressType==0x00) return railcomLastAddressHigh & 0x3F;
+      return 0; 
+    }
+
   private:
 #ifndef ARDUINO_ARCH_ESP32
     volatile bool packetPending;
@@ -129,6 +137,7 @@ class DCCWaveform {
     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 volatile byte railcomLastAddressHigh,railcomLastAddressLow;
     static bool cutoutNextTime;   // railcom
 #ifdef ARDUINO_ARCH_ESP32
   static RMTChannel *rmtMainChannel;

IO_I2CRailcom.h

@@ -58,7 +58,7 @@ class I2CRailcom : public IODevice {
 private: 
   // SC16IS752 defines
   uint8_t _UART_CH=0x00; // channel 0 or 1 flips each loop if npins>1
-  byte _inbuf[65];
+  byte _inbuf[12];
   byte _outbuf[2];
   byte cutoutCounter[2]; 
   Railcom * _channelMonitors[2]; 
@@ -118,7 +118,7 @@ public:
     // Read incoming raw Railcom data, and process accordingly
 
     auto inlength = UART_ReadRegister(REG_RXLV);
-    if (inlength==0) return; 
+    
     if (inlength> sizeof(_inbuf)) inlength=sizeof(_inbuf); 
     _inbuf[0]=0;
     if (inlength>0) {

Railcom.cpp

@@ -51,10 +51,9 @@
 #include "Railcom.h"
 #include "defines.h"
 #include "FSH.h"
-#include "EXRAIL3.h"
+#include "DCC.h"
 #include "DIAG.h"
 
-//#define DIAG_I2CRailcom_data
 
 
   /** Table for 8-to-6 decoding of railcom data. This table can be indexed by the
@@ -135,31 +134,49 @@ const uint8_t HIGHFLASH decode[256] =
         RMOB_LOGON_ENABLE_FEEDBACK = 15,
 };
 
+// each railcom block is represented by an instance of this class.
+// The blockvpin is the vpin associated with this block for the purposes of 
+// a HAL driver for the railcom detection and the EXRAIL ONBLOCKENTER/ONBLOCKEXIT
+
 Railcom::Railcom(uint16_t blockvpin) {
     haveHigh=false;
     haveLow=false;
     packetsWithNoData=0;
-    locoOnTrack=0;
+    lastChannel1Loco=0;
     vpin=blockvpin;
 }
 
-    /* returns -1: Call again next packet
+
-                0: No loco on track
+// Process is called by a raw data collector. 
-               >0: loco id
-    */
 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 (length<2 || (inbound[0]==0 && inbound[1]==0)) {
-        if (inbound[i]) DIAG(F("[0x%x]: 0x%x"), i, inbound[i]);  
+        noData();
+        return;
     }
-    #endif
+
+    
+    if (Diag::RAILCOM) {
+      static const char hexchars[]="0123456789ABCDEF";
+      if (length>2) {  
+        USB_SERIAL.print(F("<*R "));
+        for (byte i=0;i<length;i++) {
+          if (i==2) Serial.write(' ');
+          USB_SERIAL.write(hexchars[inbound[i]>>4]);
+          USB_SERIAL.write(hexchars[inbound[i]& 0x0F ]);
+        }
+        USB_SERIAL.print(F(" *>\n"));
+      }
+    }
+
+
     auto v1=GETHIGHFLASH(decode,inbound[0]);
-    auto v2=(length>2) ? GETHIGHFLASH(decode,inbound[1]):0x0;
+    auto v2=(length>1) ? GETHIGHFLASH(decode,inbound[1]):INV;
     uint16_t packet=(v1<<6) | (v2 & 0x3f);
     // packet is 12 bits TTTTDDDDDDDD
-    auto type=packet>>8;   
+    byte type=(packet>>8) & 0x0F;   
-    auto data= packet & 0xFF;
+    byte data= packet & 0xFF;
     if (type==RMOB_ADRHIGH) {
         holdoverHigh=data;
         haveHigh=true;
@@ -174,31 +191,38 @@ void Railcom::process(uint8_t * inbound, uint8_t length) {
         return; /* ignore*/
         }
     else {
-        if (packetsWithNoData>MAX_WAIT_FOR_GLITCH) {
+        // channel1 is unreadable so maybe multiple locos in block
-            // treat as no loco
+        if (length>2 && GETHIGHFLASH(decode,inbound[0])!=INV) {
-            haveHigh=false;
+            // it looks like we have channel2 data
-            haveLow=false;
+            auto thisLoco=DCCWaveform::getRailcomLastLocoAddress();
-            // Previous loco (if any) is exiting block  
+            if (Diag::RAILCOM) DIAG(F("c2=%d"),thisLoco);
-            blockEvent(false);
+            if (thisLoco) DCC::setLocoInBlock(thisLoco,vpin,false); // this loco is in block, but not exclusive 
-            locoOnTrack=0;
+            return;
-            return ; 
         }
-        packetsWithNoData++;
+        // channel1 no good and no channel2 
-        return; // need more data          
+        noData();
+        return;           
     }    
     if (haveHigh && haveLow) {
         uint16_t thisLoco=((holdoverHigh<<8)| holdoverLow);
-        if (locoOnTrack!=thisLoco) {
+        if (thisLoco!=lastChannel1Loco) {
-            // Previous loco (if any) is exiting block  
+            // the exclusive DCC call is quite expensive, we dont want to call it every packet
-            blockEvent(false);
+            DCC::setLocoInBlock(thisLoco,vpin,true); // only this loco is in block
-            locoOnTrack=thisLoco;
+            lastChannel1Loco=thisLoco; 
-            blockEvent(true); 
         }
     }
 }
 
-void Railcom::blockEvent(bool entering) {
+
-    #ifdef EXRAIL_ACTIVE
+void Railcom::noData() {
-    if (locoOnTrack) RMFT3::blockEvent(vpin,locoOnTrack,entering);
+    if (packetsWithNoData>MAX_WAIT_FOR_GLITCH) return; 
-    #endif
+    if (packetsWithNoData==MAX_WAIT_FOR_GLITCH) {
+            // treat as no loco
+            haveHigh=false;
+            haveLow=false;
+            lastChannel1Loco=0;
+            // Previous locos (if any) is exiting block  
+            DCC::clearBlock(vpin);
+        }
+        packetsWithNoData++;
 }

Railcom.h

@@ -33,12 +33,12 @@ class Railcom {
   void process(uint8_t * inbound,uint8_t length);
   
   private:
-  void blockEvent(bool entering);
+  void noData();
-  uint16_t locoOnTrack;
   uint16_t vpin;
  uint8_t holdoverHigh,holdoverLow;
  bool haveHigh,haveLow; 
  uint8_t packetsWithNoData; 
+ uint16_t lastChannel1Loco; 
  static const byte MAX_WAIT_FOR_GLITCH=20; // number of dead or empty packets before assuming loco=0 
 };
 

StringFormatter.cpp

@@ -27,6 +27,8 @@ bool Diag::WIFI=false;
 bool Diag::WITHROTTLE=false;
 bool Diag::ETHERNET=false;
 bool Diag::LCN=false;
+bool Diag::RAILCOM=false;
+
 
  
 void StringFormatter::diag( const FSH* input...) {

StringFormatter.h

@@ -30,6 +30,7 @@ class Diag {
   static bool WITHROTTLE;
   static bool ETHERNET;
   static bool LCN;
+  static bool RAILCOM;
   
 };