PCF8574 output pin initialization parameter

Reminder loop idle optimisation

.github/workflows/docs.yml

@@ -0,0 +1,36 @@
+name: Docs
+
+on:
+  push:
+    branches:
+      - devel
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4.1.1
+
+      - name: Install Requirements
+        run: |
+          cd docs
+          python -m pip install --upgrade pip
+          pip3 install -r requirements.txt
+          sudo apt-get install doxygen
+
+      - name: Build Prod docs
+        run: |
+          cd docs
+          make html
+          touch _build/html/.nojekyll
+
+      - name: Deploy
+        uses: JamesIves/github-pages-deploy-action@ba1486788b0490a235422264426c45848eac35c6
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          branch: gh-pages  # The branch the action should deploy to.
+          folder: docs/_build/html  # The folder the action should deploy.

.gitignore

@@ -15,3 +15,6 @@ my*.h
 compile_commands.json
 newcode.txt.old
 UserAddin.txt
+_build
+venv
+.DS_Store

CamParser.cpp

@@ -0,0 +1,141 @@
+/*
+ *  © 2023-2025, Barry Daniel  
+ *  © 2025       Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//sensorCAM parser.cpp version 3.06  Jan 2025
+#include "DCCEXParser.h"
+#include "CamParser.h"
+#include "FSH.h"
+
+const int16_t ver=30177;
+const int16_t ve =2899;
+
+
+// The CAMVPINS array will be filled by IO_EXSensorCam HAL drivers calling
+// the CamParser::addVpin() function.
+// The CAMBaseVpin is the one to be used when commands are given without a vpin. 
+VPIN CamParser::CAMBaseVpin = 0; // no vpins yet known 
+VPIN CamParser::CAMVPINS[] = {0,0,0,0};  // determines max # CAM's
+int CamParser::vpcount=sizeof(CAMVPINS)/sizeof(CAMVPINS[0]);
+
+void CamParser::parse(Print * stream, byte & opcode, byte & paramCount, int16_t p[]) {
+  if (opcode!='N') return; // this is not for us. 
+  if (parseN(stream,paramCount,p)) opcode=0; // we have consumed this
+  // If we fail, the caller will <X> the <N command. 
+}
+     
+bool CamParser::parseN(Print * stream, byte paramCount, int16_t p[]) {
+  (void)stream;  // probably unused parameter   
+  if (CAMBaseVpin==0) CAMBaseVpin=CAMVPINS[0];  // default to CAM 1.
+  VPIN vpin=CAMBaseVpin;   //use current CAM selection
+
+  if (paramCount==0) { 
+    DIAG(F("Cam base vpin:%d"),CAMBaseVpin);
+    for (auto i=0;i<vpcount;i++){
+       if (CAMVPINS[i]==0) break;
+       DIAG(F("EXSensorCam #%d vpin %d"),i+1,CAMVPINS[i]);
+    }
+    return true; 
+  }
+  uint8_t camop=p[0]; // cam oprerator 
+  int param1=0;
+  int16_t param3=9999;   // =0 could invoke parameter changes. & -1 gives later errors
+
+  if(camop=='C'){ 
+    if(p[1]>=100) CAMBaseVpin=p[1];
+    if(p[1]<=vpcount && p[1]>0)    CAMBaseVpin=CAMVPINS[p[1]-1];
+    DIAG(F("CAM base Vpin: %c %d "),p[0],CAMBaseVpin);
+    return true;
+  }
+  if (camop<100) {               //switch CAM# if p[1] dictates
+    if(p[1]>=100 && p[1]<=(vpcount*100+99)) {  //limits to CAM# 1 to 4 for now
+      vpin=CAMVPINS[p[1]/100-1];
+      CAMBaseVpin=vpin;     
+      DIAG(F("switching to CAM %d baseVpin:%d"),p[1]/100,vpin); 
+      p[1]=p[1]%100;             //strip off CAM #
+    } 
+  }
+  if (CAMBaseVpin==0) {DIAG(F("<n Error: Invalid CAM selected, default to CAM1>"));
+    return false; // cam not defined
+  }	
+ 
+      // send UPPER case to sensorCAM to flag binary data from a DCCEX-CS parser  
+  switch(paramCount) {    
+    case 1:                          //<N ver> produces '^'
+      if((camop == 'V') || (p[0] == ve) || (p[0] == ver) ) camop='^'; 
+      if (STRCHR_P((const char *)F("EFGMQRVW^"),camop) == nullptr) return false;
+      if (camop=='Q') param3=10;     //<NQ> for activation state of all 10 banks of sensors
+      if (camop=='F') camop=']';     //<NF> for Reset/Finish webCAM.
+      break;    // F Coded as ']' else conflicts with <Nf %%>
+    
+    case 2:                          //<N camop p1>  
+      if (STRCHR_P((const char *)F("ABFHILMNOPQRSTUV"),camop)==nullptr) return false;
+      param1=p[1];
+      break;
+    
+    case 3:              //<N vpin rowY colx > or <N cmd p1 p2>
+      if (p[0]>=100) {   //vpin - i.e. NOT 'A' through 'Z'
+        if (p[1]>236 || p[1]<0) return false;     //row
+        if (p[2]>316 || p[2]<0) return false;     //column
+        camop=0x80;      // special 'a' case for IO_SensorCAM
+        vpin = p[0];
+      }else if (STRCHR_P((const char *)F("IJMNT"),camop) == nullptr) return false; 
+	  camop=p[0];
+      param1 = p[1];  
+      param3 = p[2];
+      break;
+    
+    case 4:          //<N a id row col> 
+      if (camop!='A') return false;          //must start with 'a' 
+      if (p[3]>316 || p[3]<0) return false;
+      if (p[2]>236 || p[2]<0) return false;
+      if (p[1]>97 || p[1]<0) return false;   //treat as bsNo.
+      vpin = vpin + (p[1]/10)*8 + p[1]%10;   //translate p[1]
+      camop=0x80;    // special 'a' case for IO_SensorCAM
+      param1=p[2];   // row
+      param3=p[3];   // col
+      break;
+
+    default:
+      return false;
+  }
+  DIAG(F("CamParser: %d %c %d %d"),vpin,camop,param1,param3);
+  IODevice::writeAnalogue(vpin,param1,camop,param3);
+  return true;
+}
+
+void CamParser::addVpin(VPIN pin) {
+  // called by IO_EXSensorCam starting up a camera on a vpin
+  byte slot=255;
+  for (auto i=0;i<vpcount && slot==255;i++) {
+    if (CAMVPINS[i]==0) {
+      slot=i;
+      CAMVPINS[slot]=pin;
+    }
+  }
+  if (slot==255) {
+    DIAG(F("No more than %d cameras supported"),vpcount);
+    return;
+  }
+  if (slot==0) CAMBaseVpin=pin;
+  DIAG(F("CamParser Registered cam #%dvpin %d"),slot+1,pin);
+  // tell the DCCEXParser that we wish to filter commands
+  DCCEXParser::setCamParserFilter(&parse);
+}

CamParser.h

@@ -0,0 +1,40 @@
+/*
+ *  © 2023-2025, Barry Daniel  
+ *  © 2025       Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef CamParser_H
+#define CamParser_H
+#include <Arduino.h>
+#include "IODevice.h"
+
+class CamParser {
+   public:
+   static void parse(Print * stream, byte & opcode, byte & paramCount, int16_t p[]);
+   static void addVpin(VPIN pin);
+   private:
+    static bool parseN(Print * stream, byte paramCount, int16_t p[]);
+    static VPIN CAMBaseVpin;
+    static VPIN CAMVPINS[];
+    static int vpcount;
+};
+
+
+#endif

CommandDistributor.cpp

@@ -1,6 +1,6 @@
 /*
  *  © 2022 Harald Barth
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2025 Chris Harlow
  *  © 2020 Gregor Baues
  *  © 2022 Colin Murdoch
  *  All rights reserved.
@@ -31,19 +31,21 @@
 #include "DCC.h"
 #include "TrackManager.h"
 #include "StringFormatter.h"
+#include "Websockets.h"
 
 // variables to hold clock time
 int16_t lastclocktime;
 int8_t lastclockrate;
 
 
-#if WIFI_ON || ETHERNET_ON || defined(SERIAL1_COMMANDS) || defined(SERIAL2_COMMANDS) || defined(SERIAL3_COMMANDS)
+#if WIFI_ON || ETHERNET_ON || defined(SERIAL1_COMMANDS) || defined(SERIAL2_COMMANDS) || defined(SERIAL3_COMMANDS) || defined(SERIAL4_COMMANDS) || defined(SERIAL5_COMMANDS) || defined(SERIAL6_COMMANDS)
 // use a buffer to allow broadcast
 StringBuffer * CommandDistributor::broadcastBufferWriter=new StringBuffer();
 template<typename... Targs> void CommandDistributor::broadcastReply(clientType type, Targs... msg){
   broadcastBufferWriter->flush();
   StringFormatter::send(broadcastBufferWriter, msg...);
   broadcastToClients(type);
+  if (type==COMMAND_TYPE) broadcastToClients(WEBSOCKET_TYPE);
 }
 #else
 // on a single USB connection config, write direct to Serial and ignore flush/shove
@@ -56,14 +58,17 @@ template<typename... Targs> void CommandDistributor::broadcastReply(clientType t
 #ifdef CD_HANDLE_RING
   // wifi or ethernet ring streams with multiple client types
   RingStream *  CommandDistributor::ring=0;
-  CommandDistributor::clientType  CommandDistributor::clients[8]={
-    NONE_TYPE,NONE_TYPE,NONE_TYPE,NONE_TYPE,NONE_TYPE,NONE_TYPE,NONE_TYPE,NONE_TYPE};
+CommandDistributor::clientType  CommandDistributor::clients[MAX_NUM_TCP_CLIENTS]={ NONE_TYPE }; // 0 is and must be NONE_TYPE
 
 // Parse is called by Withrottle or Ethernet interface to determine which
 // protocol the client is using and call the appropriate part of dcc++Ex
 void  CommandDistributor::parse(byte clientId,byte * buffer, RingStream * stream) {
-  if (Diag::WIFI && Diag::CMD)
-    DIAG(F("Parse C=%d T=%d B=%s"),clientId, clients[clientId], buffer);
+  if (clientId>=sizeof (clients)) {
+    // Caution, diag dump of buffer could corrupt ringstream
+    // if headed by websocket bytes. 
+    DIAG(F("::parse invalid client=%d"),clientId);
+    return;
+  }
   ring=stream;
 
   // First check if the client is not known
@@ -72,22 +77,40 @@ void  CommandDistributor::parse(byte clientId,byte * buffer, RingStream * stream
   // client is using the DCC++ protocol where all commands start
   // with '<'
   if (clients[clientId] == NONE_TYPE) {
+    auto websock=Websockets::checkConnectionString(clientId,buffer,stream);
+    if (websock) {
+      clients[clientId]=WEBSOCK_CONNECTING_TYPE;
+      // websockets will have replied already 
+      return;
+    }
     if (buffer[0] == '<')
       clients[clientId]=COMMAND_TYPE;
     else
       clients[clientId]=WITHROTTLE_TYPE;
   }
 
+  // after first inbound transmission the websocket is connected
+  if (clients[clientId]==WEBSOCK_CONNECTING_TYPE)
+      clients[clientId]=WEBSOCKET_TYPE;
+      
+      
   // mark buffer that is sent to parser
-  ring->mark(clientId);
-
   // When type is known, send the string
   // to the right parser
   if (clients[clientId] == COMMAND_TYPE) {
+    ring->mark(clientId);
     DCCEXParser::parse(stream, buffer, ring);
   } else if (clients[clientId] == WITHROTTLE_TYPE) {
+    ring->mark(clientId);
     WiThrottle::getThrottle(clientId)->parse(ring, buffer);
   }
+  else if (clients[clientId] == WEBSOCKET_TYPE) {
+    buffer=Websockets::unmask(clientId,ring, buffer);
+    if (!buffer) return; // unmask may have handled it alrerday (ping/pong)
+    // mark ring with client flagged as websocket for transmission later
+    ring->mark(clientId | Websockets::WEBSOCK_CLIENT_MARKER);
+    DCCEXParser::parse(stream, buffer, ring);
+    }
 
   if (ring->peekTargetMark()!=RingStream::NO_CLIENT) {
     // The commit call will either write the length bytes
@@ -105,6 +128,7 @@ void  CommandDistributor::parse(byte clientId,byte * buffer, RingStream * stream
 void CommandDistributor::forget(byte clientId) {
   if (clients[clientId]==WITHROTTLE_TYPE) WiThrottle::forget(clientId);
   clients[clientId]=NONE_TYPE;
+  if (virtualLCDClient==clientId) virtualLCDClient=RingStream::NO_CLIENT;
 }
 #endif 
 
@@ -130,7 +154,7 @@ void CommandDistributor::broadcastToClients(clientType type) {
     for (byte clientId=0; clientId<sizeof(clients); clientId++) {
       if (clients[clientId]==type)  {
 	//DIAG(F("CD mark client %d"), clientId);
-	ring->mark(clientId);
+	ring->mark(clientId | (type==WEBSOCKET_TYPE? Websockets::WEBSOCK_CLIENT_MARKER : 0));
 	ring->print(broadcastBufferWriter->getString());
 	//DIAG(F("CD commit client %d"), clientId);
 	ring->commit();
@@ -162,7 +186,7 @@ void  CommandDistributor::broadcastTurnout(int16_t id, bool isClosed ) {
 }
 
 void CommandDistributor::broadcastTurntable(int16_t id, uint8_t position, bool moving) {
-  broadcastReply(COMMAND_TYPE, F("<i %d %d %d>\n"), id, position, moving);
+  broadcastReply(COMMAND_TYPE, F("<I %d %d %d>\n"), id, position, moving);
 }
 
 void  CommandDistributor::broadcastClockTime(int16_t time, int8_t rate) {
@@ -184,10 +208,15 @@ void CommandDistributor::setClockTime(int16_t clocktime, int8_t clockrate, byte
   {
     case 1:
       if (clocktime != lastclocktime){
+        auto difference = clocktime - lastclocktime;
+        if (difference<0) difference+=1440;
+        DCC::setTime(clocktime,clockrate,difference>2);
         // CAH. DIAG removed because LCD does it anyway. 
         LCD(6,F("Clk Time:%d Sp %d"), clocktime, clockrate);
         // look for an event for this time
+#ifdef EXRAIL_ACTIVE        
         RMFT2::clockEvent(clocktime,1);
+#endif        
         // Now tell everyone else what the time is.
         CommandDistributor::broadcastClockTime(clocktime, clockrate);
         lastclocktime = clocktime;
@@ -206,9 +235,13 @@ int16_t CommandDistributor::retClockTime() {
   return lastclocktime;
 }
 
-void  CommandDistributor::broadcastLoco(byte slot) {
-  DCC::LOCO * sp=&DCC::speedTable[slot];
-  broadcastReply(COMMAND_TYPE, F("<l %d %d %d %l>\n"), sp->loco,slot,sp->speedCode,sp->functions);
+void  CommandDistributor::broadcastLoco(DCC::LOCO*  sp) {
+  if (!sp) {
+    broadcastReply(COMMAND_TYPE,F("<l 0 -1 128 0>\n"));
+    return;
+	}
+  broadcastReply(COMMAND_TYPE, F("<l %d 0 %d %l>\n"), 
+    sp->loco,sp->targetSpeed,sp->functions);
 #ifdef SABERTOOTH
   if (Serial2 && sp->loco == SABERTOOTH) {
     static uint8_t rampingmode = 0;
@@ -247,28 +280,132 @@ void  CommandDistributor::broadcastLoco(byte slot) {
 #endif
 }
 
+void  CommandDistributor::broadcastForgetLoco(int16_t loco) {
+  broadcastReply(COMMAND_TYPE, F("<l %d 0 1 0>\n<- %d>\n"), loco,loco);
+}
+
 void  CommandDistributor::broadcastPower() {
+  char pstr[] = "? x";
+  for(byte t=0; t<TrackManager::MAX_TRACKS; t++)
+    if (TrackManager::getPower(t, pstr))
+      broadcastReply(COMMAND_TYPE, F("<p%s>\n"),pstr);
+
+  byte trackcount=0;
+  byte oncount=0;
+  byte offcount=0;
+  for(byte t=0; t<TrackManager::MAX_TRACKS; t++) {
+    if (TrackManager::isActive(t)) {
+      trackcount++;
+      // do not call getPower(t) unless isActive(t)!
+      if (TrackManager::getPower(t) == POWERMODE::ON)
+	oncount++;
+      else
+	offcount++;
+    }
+  }
+  //DIAG(F("t=%d on=%d off=%d"), trackcount, oncount, offcount);
+
+  char state='2';
+  if (oncount==0 || offcount == trackcount)
+    state = '0';
+  else if (oncount == trackcount) {
+    state = '1';
+  }
+
+  if (state != '2')
+    broadcastReply(COMMAND_TYPE, F("<p%c>\n"),state);
+
+  // additional info about MAIN, PROG and JOIN
   bool main=TrackManager::getMainPower()==POWERMODE::ON;
   bool prog=TrackManager::getProgPower()==POWERMODE::ON;
   bool join=TrackManager::isJoined();
+  //DIAG(F("m=%d p=%d j=%d"), main, prog, join);
   const FSH * reason=F("");
-  char state='1';
-  if (main && prog && join) reason=F(" JOIN");
-  else if (main && prog);
-  else if (main) reason=F(" MAIN");
-  else if (prog) reason=F(" PROG");
-  else state='0';
-  broadcastReply(COMMAND_TYPE, F("<p%c%S>\n"),state,reason);
+  if (join) {
+    reason = F(" JOIN"); // with space at start so we can append without space
+    broadcastReply(COMMAND_TYPE, F("<p1%S>\n"),reason);
+  } else {
+    if (main) {
+      //reason = F("MAIN");
+      broadcastReply(COMMAND_TYPE, F("<p1 MAIN>\n"));
+    }
+    if (prog) {
+      //reason = F("PROG");
+      broadcastReply(COMMAND_TYPE, F("<p1 PROG>\n"));
+    }
+  }
 #ifdef CD_HANDLE_RING
-  broadcastReply(WITHROTTLE_TYPE, F("PPA%c\n"), main?'1':'0');
+  // send '1' if all main are on, otherwise global state (which in that case is '0' or '2')
+  broadcastReply(WITHROTTLE_TYPE, F("PPA%c\n"), main?'1': state);
 #endif
-  LCD(2,F("Power %S%S"),state=='1'?F("On"):F("Off"),reason);  
+
+  LCD(2,F("Power %S%S"),state=='1'?F("On"): ( state=='0'? F("Off") : F("SC") ),reason);
 }
 
 void CommandDistributor::broadcastRaw(clientType type, char * msg) {
   broadcastReply(type, F("%s"),msg);
 }
 
-void CommandDistributor::broadcastTrackState(const FSH* format,byte trackLetter, int16_t dcAddr) {
-  broadcastReply(COMMAND_TYPE, format,trackLetter, dcAddr);
+void CommandDistributor::broadcastMessage(char * message) {
+  broadcastReply(COMMAND_TYPE, F("<m \"%s\">\n"),message);
+  broadcastReply(WITHROTTLE_TYPE, F("Hm%s\n"),message);
 }
+
+void CommandDistributor::broadcastTrackState(const FSH* format, byte trackLetter, const FSH *modename, int16_t dcAddr) {
+  broadcastReply(COMMAND_TYPE, format, trackLetter, modename, dcAddr);
+}
+
+void  CommandDistributor::broadcastRouteState(uint16_t routeId, byte state ) {
+  broadcastReply(COMMAND_TYPE, F("<jB %d %d>\n"),routeId,state);
+}
+
+void  CommandDistributor::broadcastRouteCaption(uint16_t routeId, const FSH* caption ) {
+  broadcastReply(COMMAND_TYPE, F("<jB %d \"%S\">\n"),routeId,caption);
+}
+
+Print * CommandDistributor::getVirtualLCDSerial(byte screen, byte row) {
+  Print * stream=virtualLCDSerial;
+  #ifdef  CD_HANDLE_RING
+  rememberVLCDClient=RingStream::NO_CLIENT;
+  if (!stream && virtualLCDClient!=RingStream::NO_CLIENT) {
+    // If we are broadcasting from a wifi/eth process we need to complete its output
+    // before merging broadcasts in the ring, then reinstate it in case
+    // the process continues to output to its client.
+    if ((rememberVLCDClient = ring->peekTargetMark()) != RingStream::NO_CLIENT) {
+      ring->commit();
+    }
+    ring->mark(virtualLCDClient);   
+    stream=ring; 
+  }
+  #endif
+  if (stream) StringFormatter::send(stream,F("<@ %d %d \""), screen,row);
+  return stream;  
+}
+
+void CommandDistributor::commitVirtualLCDSerial() {
+  #ifdef  CD_HANDLE_RING
+  if (virtualLCDClient!=RingStream::NO_CLIENT) {
+    StringFormatter::send(ring,F("\">\n"));
+    ring->commit();
+    if (rememberVLCDClient!=RingStream::NO_CLIENT) ring->mark(rememberVLCDClient);
+    return;  
+   }
+  #endif
+  StringFormatter::send(virtualLCDSerial,F("\">\n"));  
+}
+
+void CommandDistributor::setVirtualLCDSerial(Print * stream) {
+  #ifdef  CD_HANDLE_RING
+  virtualLCDClient=RingStream::NO_CLIENT;
+  if (stream && stream->availableForWrite()==RingStream::THIS_IS_A_RINGSTREAM) {
+     virtualLCDClient=((RingStream *) stream)->peekTargetMark();
+     virtualLCDSerial=nullptr;
+     return;
+  }      
+    #endif
+  virtualLCDSerial=stream;
+}
+
+Print* CommandDistributor::virtualLCDSerial=&USB_SERIAL;
+byte CommandDistributor::virtualLCDClient=0xFF;
+byte CommandDistributor::rememberVLCDClient=0;

CommandDistributor.h

@@ -1,6 +1,6 @@
 /*
  *  © 2022 Harald Barth
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2025 Chris Harlow
  *  © 2020 Gregor Baues
  *  © 2022 Colin Murdoch
  * 
@@ -28,6 +28,7 @@
 #include "StringBuffer.h"
 #include "defines.h"
 #include "EXRAIL2.h"
+#include "DCC.h"
 
 #if WIFI_ON | ETHERNET_ON 
   // Command Distributor must handle a RingStream of clients
@@ -36,17 +37,18 @@
 
 class CommandDistributor {
 public:
-  enum clientType: byte {NONE_TYPE,COMMAND_TYPE,WITHROTTLE_TYPE};
+  enum clientType: byte {NONE_TYPE = 0,COMMAND_TYPE,WITHROTTLE_TYPE,WEBSOCK_CONNECTING_TYPE,WEBSOCKET_TYPE}; // independent of other types, NONE_TYPE must be 0
 private:
   static void broadcastToClients(clientType type);
   static StringBuffer * broadcastBufferWriter;
   #ifdef CD_HANDLE_RING
     static RingStream * ring;
-    static clientType clients[8];
+    static clientType clients[MAX_NUM_TCP_CLIENTS];
   #endif
 public :
   static void parse(byte clientId,byte* buffer, RingStream * ring);
-  static void broadcastLoco(byte slot);
+  static void broadcastLoco(DCC::LOCO * slot);
+  static void broadcastForgetLoco(int16_t loco);
   static void broadcastSensor(int16_t id, bool value);
   static void broadcastTurnout(int16_t id, bool isClosed);
   static void broadcastTurntable(int16_t id, uint8_t position, bool moving);
@@ -55,10 +57,21 @@ public :
   static int16_t retClockTime();
   static void broadcastPower();
   static void broadcastRaw(clientType type,char * msg);
-  static void broadcastTrackState(const FSH* format,byte trackLetter, int16_t dcAddr);
+  static void broadcastTrackState(const FSH* format,byte trackLetter, const FSH* modename, int16_t dcAddr);
   template<typename... Targs> static void broadcastReply(clientType type, Targs... msg);
   static void forget(byte clientId);
+  static void broadcastRouteState(uint16_t routeId,byte state);
+  static void broadcastRouteCaption(uint16_t routeId,const FSH * caption);
+  static void broadcastMessage(char * message);
   
+  // Handling code for virtual LCD receiver.
+  static Print * getVirtualLCDSerial(byte screen, byte row);
+  static void commitVirtualLCDSerial();
+  static void setVirtualLCDSerial(Print * stream); 
+  private:
+    static Print * virtualLCDSerial;
+    static byte virtualLCDClient;
+    static byte rememberVLCDClient;
 };
 
 #endif

CommandStation-EX.ino

@@ -65,6 +65,9 @@
 #ifdef EXRAIL_WARNING
 #warning You have myAutomation.h but your hardware has not enough memory to do that, so EX-RAIL DISABLED
 #endif
+// compile time check, passwords 1 to 7 chars do not work, so do not try to compile with them at all
+// remember trailing '\0', sizeof("") == 1.
+#define PASSWDCHECK(S) static_assert(sizeof(S) == 1 || sizeof(S) > 8, "Password shorter than 8 chars")
 
 void setup()
 {
@@ -76,6 +79,12 @@ void setup()
 
   DIAG(F("License GPLv3 fsf.org (c) dcc-ex.com"));
 
+// If user has defined a startup delay, delay here before starting IO
+#if defined(STARTUP_DELAY)
+  DIAG(F("Delaying startup for %dms"), STARTUP_DELAY);
+  delay(STARTUP_DELAY);
+#endif
+
 // Initialise HAL layer before reading EEprom or setting up MotorDrivers 
   IODevice::begin();
 
@@ -87,7 +96,7 @@ void setup()
 
   DISPLAY_START (
     // This block is still executed for DIAGS if display not in use
-    LCD(0,F("DCC-EX v%S"),F(VERSION));
+    LCD(0,F("DCC-EX v" VERSION));
     LCD(1,F("Lic GPLv3"));
   );
 
@@ -96,10 +105,12 @@ void setup()
   // Start Ethernet if it exists
 #ifndef ARDUINO_ARCH_ESP32
 #if WIFI_ON
+  PASSWDCHECK(WIFI_PASSWORD); // compile time check
   WifiInterface::setup(WIFI_SERIAL_LINK_SPEED, F(WIFI_SSID), F(WIFI_PASSWORD), F(WIFI_HOSTNAME), IP_PORT, WIFI_CHANNEL, WIFI_FORCE_AP);
 #endif // WIFI_ON
 #else
   // ESP32 needs wifi on always
+  PASSWDCHECK(WIFI_PASSWORD); // compile time check
   WifiESP::setup(WIFI_SSID, WIFI_PASSWORD, WIFI_HOSTNAME, IP_PORT, WIFI_CHANNEL, WIFI_FORCE_AP);
 #endif // ARDUINO_ARCH_ESP32
 
@@ -130,6 +141,23 @@ void setup()
   CommandDistributor::broadcastPower();
 }
 
+/**************** for future reference
+void looptimer(unsigned long timeout, const FSH* message)
+{
+  static unsigned long lasttimestamp = 0;
+  unsigned long now = micros();
+  if (timeout != 0) {
+    unsigned long diff = now - lasttimestamp;
+    if (diff > timeout) {
+      DIAG(message);
+      DIAG(F("DeltaT=%L"), diff);
+      lasttimestamp = micros();
+      return;
+    }
+  }
+  lasttimestamp = now;
+}
+*********************************************/
 void loop()
 {
   // The main sketch has responsibilities during loop()
@@ -137,14 +165,15 @@ void loop()
   // Responsibility 1: Handle DCC background processes
   //                   (loco reminders and power checks)
   DCC::loop();
-
+ 
   // Responsibility 2: handle any incoming commands on USB connection
   SerialManager::loop();
-
+ 
   // Responsibility 3: Optionally handle any incoming WiFi traffic
 #ifndef ARDUINO_ARCH_ESP32
 #if WIFI_ON
   WifiInterface::loop();
+ 
 #endif //WIFI_ON
 #else  //ARDUINO_ARCH_ESP32
 #ifndef WIFI_TASK_ON_CORE0

DCC.cpp

@@ -5,7 +5,7 @@
  *  © 2021 Herb Morton
  *  © 2020-2022 Harald Barth
  *  © 2020-2021 M Steve Todd
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2025 Chris Harlow
  *  All rights reserved.
  *
  *  This file is part of DCC-EX
@@ -37,6 +37,8 @@
 #include "CommandDistributor.h"
 #include "TrackManager.h"
 #include "DCCTimer.h"
+#include "Railcom.h"
+#include "DCCQueue.h"
 
 // This module is responsible for converting API calls into
 // messages to be sent to the waveform generator.
@@ -60,6 +62,8 @@ const byte FN_GROUP_5=0x10;
 FSH* DCC::shieldName=NULL;
 byte DCC::globalSpeedsteps=128;
 
+#define SLOTLOOP for (auto slot=&speedTable[0];slot!=&speedTable[MAX_LOCOS];slot++)
+
 void DCC::begin() {
   StringFormatter::send(&USB_SERIAL,F("<iDCC-EX V-%S / %S / %S G-%S>\n"), F(VERSION), F(ARDUINO_TYPE), shieldName, F(GITHUB_SHA));
 #ifndef DISABLE_EEPROM
@@ -72,13 +76,49 @@ void DCC::begin() {
 #endif
 }
 
+byte DCC::defaultMomentumA=0;
+byte DCC::defaultMomentumD=0;
+bool DCC::linearAcceleration=false; 
+
+byte DCC::getMomentum(LOCO * slot) {
+   auto target=slot->targetSpeed & 0x7f;
+   auto current=slot->speedCode & 0x7f;
+   if (target > current) {
+    // accelerating
+    auto momentum=slot->momentumA==MOMENTUM_USE_DEFAULT ? defaultMomentumA : slot->momentumA;
+    // if nonlinear acceleration, momentum is reduced according to 
+    // gap between throttle and speed.
+    // ie. Loco takes accelerates faster if high throttle
+    if (momentum==0 || linearAcceleration) return momentum;
+    auto powerDifference= (target-current)/8;
+    if (momentum-powerDifference <0) return 0;
+    return momentum-powerDifference; 
+   }
+   return slot->momentumD==MOMENTUM_USE_DEFAULT ? defaultMomentumD : slot->momentumD;
+}
 
 void DCC::setThrottle( uint16_t cab, uint8_t tSpeed, bool tDirection)  {
+  if (tSpeed==1) {
+    if (cab==0) {
+      estopAll(); // ESTOP broadcast fix 
+      return;
+    }
+  } 
   byte speedCode = (tSpeed & 0x7F)  + tDirection * 128;
-  setThrottle2(cab, speedCode);
-  TrackManager::setDCSignal(cab,speedCode); // in case this is a dcc track on this addr
-  // retain speed for loco reminders
-  updateLocoReminder(cab, speedCode );
+  LOCO * slot=lookupSpeedTable(cab);
+  if (slot->targetSpeed==speedCode) return; 
+  slot->targetSpeed=speedCode;
+  byte momentum=getMomentum(slot);
+  if (momentum && tSpeed!=1) { // not ESTOP
+    // we dont throttle speed, we just let the reminders take it to target
+    slot->momentum_base=millis();
+  } 
+  else {  // Momentum not involved, throttle now.
+    slot->speedCode = speedCode;
+    setThrottle2(cab, speedCode);
+    TrackManager::setDCSignal(cab,speedCode); // in case this is a dcc track on this addr
+  }
+  CommandDistributor::broadcastLoco(slot);
 }
 
 void DCC::setThrottle2( uint16_t cab, byte speedCode)  {
@@ -118,8 +158,8 @@ void DCC::setThrottle2( uint16_t cab, byte speedCode)  {
     b[nB++] = speedCode; // for encoding see setThrottle
 
   }
-
-  DCCWaveform::mainTrack.schedulePacket(b, nB, 0);
+  if ((speedCode & 0x7F) == 1) DCCQueue::scheduleEstopPacket(b, nB, 4, cab); // highest priority
+  else DCCQueue::scheduleDCCSpeedPacket( b, nB, 0, cab);
 }
 
 void DCC::setFunctionInternal(int cab, byte byte1, byte byte2) {
@@ -133,32 +173,49 @@ void DCC::setFunctionInternal(int cab, byte byte1, byte byte2) {
   if (byte1!=0) b[nB++] = byte1;
   b[nB++] = byte2;
 
-  DCCWaveform::mainTrack.schedulePacket(b, nB, 0);
+  DCCQueue::scheduleDCCPacket(b, nB, 0, cab);
 }
 
 // returns speed steps 0 to 127 (1 == emergency stop)
 // or -1 on "loco not found"
 int8_t DCC::getThrottleSpeed(int cab) {
-  int reg=lookupSpeedTable(cab);
-  if (reg<0) return -1;
-  return speedTable[reg].speedCode & 0x7F;
+  return getThrottleSpeedByte(cab) & 0x7F;
 }
 
 // returns speed code byte
 // or 128 (speed 0, dir forward) on "loco not found".
+// This is the throttle set speed
 uint8_t DCC::getThrottleSpeedByte(int cab) {
-  int reg=lookupSpeedTable(cab);
-  if (reg<0)
-    return 128;
-  return speedTable[reg].speedCode;
+  LOCO * slot=lookupSpeedTable(cab,false);
+  return slot?slot->targetSpeed:128;
+}
+// returns speed code byte for loco. 
+// This is the most recently send DCC speed packet byte
+// or 128 (speed 0, dir forward) on "loco not found".
+uint8_t DCC::getLocoSpeedByte(int cab) {
+  LOCO* slot=lookupSpeedTable(cab,false);
+  return slot?slot->speedCode:128;
+}
+
+// returns 0 to 7 for frequency
+uint8_t DCC::getThrottleFrequency(int cab) {
+#if defined(ARDUINO_AVR_UNO)
+  (void)cab;
+  return 0;
+#else
+  LOCO* slot=lookupSpeedTable(cab);
+  if (!slot)  return 0; // use default frequency
+  // shift out first 29 bits so we have the 3 "frequency bits" left
+  uint8_t res = (uint8_t)(slot->functions >>29);
+  //DIAG(F("Speed table %d functions %l shifted %d"), reg, slot->functions, res);
+  return res;
+#endif
 }
 
 // returns direction on loco
 // or true/forward on "loco not found"
 bool DCC::getThrottleDirection(int cab) {
-  int reg=lookupSpeedTable(cab);
-  if (reg<0) return true;
-  return (speedTable[reg].speedCode & 0x80) !=0;
+  return getThrottleSpeedByte(cab) & 0x80;
 }
 
 // Set function to value on or off
@@ -182,47 +239,50 @@ bool DCC::setFn( int cab, int16_t functionNumber, bool on) {
        b[nB++] = (functionNumber & 0x7F) | (on ? 0x80 : 0);  // low order bits and state flag
        b[nB++] = functionNumber >>7 ;  // high order bits
     }
-    DCCWaveform::mainTrack.schedulePacket(b, nB, 4);
-    return true;
+    DCCQueue::scheduleDCCPacket(b, nB, 4,cab);
   }
-
-  int reg = lookupSpeedTable(cab);
-  if (reg<0) return false;
-
+  // We use the reminder table up to 28 for normal functions.
+  // We use 29 to 31 for DC frequency as well so up to 28
+  // are "real" functions and 29 to 31 are frequency bits
+  // controlled by function buttons
+  if (functionNumber > 31)
+    return true;
+  
+  LOCO * slot = lookupSpeedTable(cab);
+  
   // Take care of functions:
   // Set state of function
-  unsigned long previous=speedTable[reg].functions;
-  unsigned long funcmask = (1UL<<functionNumber);
+  uint32_t previous=slot->functions;
+  uint32_t funcmask = (1UL<<functionNumber);
   if (on) {
-      speedTable[reg].functions |= funcmask;
+      slot->functions |= funcmask;
   } else {
-      speedTable[reg].functions &= ~funcmask;
+      slot->functions &= ~funcmask;
   }
-  if (speedTable[reg].functions != previous) {
-    updateGroupflags(speedTable[reg].groupFlags, functionNumber);
-    CommandDistributor::broadcastLoco(reg);
+  if (slot->functions != previous) {
+    if (functionNumber <= 28)
+      updateGroupflags(slot->groupFlags, functionNumber);
+    CommandDistributor::broadcastLoco(slot);
   }
   return true;
 }
 
-// Flip function state
+// Flip function state (used from withrottle protocol)
 void DCC::changeFn( int cab, int16_t functionNumber) {
-  if (cab<=0 || functionNumber>28) return;
-  int reg = lookupSpeedTable(cab);
-  if (reg<0) return;
-  unsigned long funcmask = (1UL<<functionNumber);
-  speedTable[reg].functions ^= funcmask;
-  updateGroupflags(speedTable[reg].groupFlags, functionNumber);
-  CommandDistributor::broadcastLoco(reg);
+  auto currentValue=getFn(cab,functionNumber);
+  if (currentValue<0) return;  // function not valid for change  
+  setFn(cab,functionNumber, currentValue?false:true);
 }
 
-int DCC::getFn( int cab, int16_t functionNumber) {
-  if (cab<=0 || functionNumber>28) return -1;  // unknown
-  int reg = lookupSpeedTable(cab);
-  if (reg<0) return -1;
-
+// Report function state (used from withrottle protocol)
+// returns 0 false, 1 true or -1 for do not know
+int8_t DCC::getFn( int cab, int16_t functionNumber) {
+  if (cab<=0 || functionNumber>31)
+    return -1;  // unknown
+  auto slot = lookupSpeedTable(cab);
+  
   unsigned long funcmask = (1UL<<functionNumber);
-  return  (speedTable[reg].functions & funcmask)? 1 : 0;
+  return  (slot->functions & funcmask)? 1 : 0;
 }
 
 // Set the group flag to say we have touched the particular group.
@@ -239,8 +299,22 @@ void DCC::updateGroupflags(byte & flags, int16_t functionNumber) {
 
 uint32_t DCC::getFunctionMap(int cab) {
   if (cab<=0) return 0;  // unknown pretend all functions off
-  int reg = lookupSpeedTable(cab);
-  return (reg<0)?0:speedTable[reg].functions;
+  auto slot = lookupSpeedTable(cab,false);
+  return slot?slot->functions:0;
+}
+
+// saves DC frequency (0..3) in spare functions 29,30,31
+void DCC::setDCFreq(int cab,byte freq) {
+  if (cab==0 || freq>3) return;
+  auto slot=lookupSpeedTable(cab,true);
+  // drop and replace F29,30,31 (top 3 bits) 
+  auto newFunctions=slot->functions & 0x1FFFFFFFUL;
+  if (freq==1)      newFunctions |= (1UL<<29); // F29
+  else if (freq==2) newFunctions |= (1UL<<30); // F30
+  else if (freq==3) newFunctions |= (1UL<<31); // F31
+  if (newFunctions==slot->functions) return; // no change 
+  slot->functions=newFunctions;
+  CommandDistributor::broadcastLoco(slot);
 }
 
 void DCC::setAccessory(int address, byte port, bool gate, byte onoff /*= 2*/) {
@@ -266,16 +340,68 @@ void DCC::setAccessory(int address, byte port, bool gate, byte onoff /*= 2*/) {
   // second byte is of the form 1AAACPPG, where C is 1 for on, PP the ports 0 to 3 and G the gate (coil).
   b[0] = address % 64 + 128;
   b[1] = ((((address / 64) % 8) << 4) + (port % 4 << 1) + gate % 2) ^ 0xF8;
-  if (onoff != 0) {
-    DCCWaveform::mainTrack.schedulePacket(b, 2, 3);      // Repeat on packet three times
-#if defined(EXRAIL_ACTIVE)
-    RMFT2::activateEvent(address<<2|port,gate);
-#endif
-  }
-  if (onoff != 1) {
+  if (onoff==0) {   // off packet only
     b[1] &= ~0x08; // set C to 0
-    DCCWaveform::mainTrack.schedulePacket(b, 2, 3);      // Repeat off packet three times
-  }
+    DCCQueue::scheduleDCCPacket(b, 2, 3);
+  } else if (onoff==1) { // on packet only
+    DCCQueue::scheduleDCCPacket(b, 2, 3);
+  } else { // auto timed on then off  
+    DCCQueue::scheduleAccOnOffPacket(b, 2, 3, 100); // On then off after 100mS
+  } 
+#if defined(EXRAIL_ACTIVE)
+  if (onoff !=0) RMFT2::activateEvent(address<<2|port,gate);
+#endif
+}
+
+bool DCC::setExtendedAccessory(int16_t address, int16_t value, byte repeats) {
+
+/* From https://www.nmra.org/sites/default/files/s-9.2.1_2012_07.pdf
+
+The Extended Accessory Decoder Control Packet is included for the purpose of transmitting aspect control to signal 
+decoders or data bytes to more complex accessory decoders. Each signal head can display one aspect at a time. 
+{preamble} 0 10AAAAAA 0 0AAA0AA1 0 000XXXXX 0 EEEEEEEE 1
+
+XXXXX is for a single head. A value of 00000 for XXXXX indicates the absolute stop aspect. All other aspects 
+represented by the values for XXXXX are determined by the signaling system used and the prototype being 
+modeled.
+
+From https://normen.railcommunity.de/RCN-213.pdf:
+
+More information is in RCN-213 about how the address bits are organized.
+preamble -0- 1 0 A7 A6 A5 A4 A3 A2 -0- 0 ^A10 ^A9 ^A8 0 A1 A0 1 -0- ....
+
+Thus in byte packet form the format is 10AAAAAA, 0AAA0AA1, 000XXXXX
+
+Die Adresse f<>r den ersten erweiterten Zubeh<65>rdecoder ist wie bei den einfachen
+Zubeh<EFBFBD>rdecodern die Adresse 4 = 1000-0001 0111-0001 . Diese Adresse wird in
+Anwenderdialogen als Adresse 1 dargestellt.
+
+This means that the first address shown to the user as "1" is mapped
+to internal address 4.
+
+Note that the Basic accessory format mentions "By convention these
+bits (bits 4-6 of the second data byte) are in ones complement" but
+this note is absent from the advanced packet description. The
+english translation does not mention that the address format for
+the advanced packet follows the one for the basic packet but
+according to the RCN-213 this is the case.
+
+We allow for addresses from -3 to 2047-3 as that allows to address the
+whole range of the 11 bits sent to track.
+*/
+  if ((address > 2044) || (address < -3)) return false; // 2047-3, 11 bits but offset 3
+  if (value != (value & 0x1F)) return false;            // 5 bits
+
+  address+=3;                        // +3 offset according to RCN-213
+  byte b[3];
+  b[0]= 0x80                         // bits always on
+    | ((address>>2) & 0x3F);         // shift out 2, mask out used bits
+  b[1]= 0x01                         // bits always on
+    | (((~(address>>8)) & 0x07)<<4)  // shift out 8, invert, mask 3 bits, shift up 4
+    | ((address & 0x03)<<1);         // mask 2 bits, shift up 1
+  b[2]=value;
+  DCCQueue::scheduleDCCPacket(b, sizeof(b), repeats);
+  return true;
 }
 
 //
@@ -293,7 +419,26 @@ void DCC::writeCVByteMain(int cab, int cv, byte bValue)  {
   b[nB++] = cv2(cv);
   b[nB++] = bValue;
 
-  DCCWaveform::mainTrack.schedulePacket(b, nB, 4);
+  DCCQueue::scheduleDCCPacket(b, nB, 4,cab);
+}
+
+//
+// readCVByteMain: Read a byte with PoM on main.
+// This requires Railcom active 
+//
+void DCC::readCVByteMain(int cab, int cv, ACK_CALLBACK callback)  {
+  byte b[5];
+  byte nB = 0;
+  if (cab > HIGHEST_SHORT_ADDR)
+    b[nB++] = highByte(cab) | 0xC0;    // convert train number into a two-byte address
+
+  b[nB++] = lowByte(cab);
+  b[nB++] = cv1(READ_BYTE_MAIN, cv); // any CV>1023 will become modulus(1024) due to bit-mask of 0x03
+  b[nB++] = cv2(cv);
+  b[nB++] = 0;
+
+  DCCQueue::scheduleDCCPacket(b, nB, 4,cab);
+  Railcom::anticipate(cab,cv,callback);
 }
 
 //
@@ -314,7 +459,45 @@ void DCC::writeCVBitMain(int cab, int cv, byte bNum, bool bValue)  {
   b[nB++] = cv2(cv);
   b[nB++] = WRITE_BIT | (bValue ? BIT_ON : BIT_OFF) | bNum;
 
-  DCCWaveform::mainTrack.schedulePacket(b, nB, 4);
+  DCCQueue::scheduleDCCPacket(b, nB, 4,cab);
+}
+
+bool DCC::setTime(uint16_t minutes,uint8_t speed, bool suddenChange) {
+  /* see rcn-122
+  5 Global commands 
+These commands are sent and begin exclusively with a broadcast address 0 
+always with {synchronous bits} 0 0000-0000 … and end with the checksum 
+... PPPPPPPP 1. Therefore, only the bytes of the commands and not that of 
+shown below whole package shown. The commands can be used by vehicle and 
+accessory decoders alike. 
+
+  5.1 Time command 
+This command is four bytes long and has the format: 
+1100-0001 CCxx-xxxx xxxx-xxxxx xxxx-xxxx 
+CC indicates what data is transmitted in the packet: 
+CC = 00 Model Time 
+1100-0001 00MM-MMMM WWWH-HHHH U0BB-BBBB with: 
+MMMMMM = Minutes, Value range: 0..59 
+WWW =     Day of the Week, Value range: 0 = Monday, 1 = Tuesday, 2 = Wednesday, 
+3 = Thursday, 4 = Friday, 5 = Saturday, 6 = Sunday, 7 = Weekday 
+is not supported. 
+HHHHH =   Hours, value range: 0..23 
+U =         
+Update, i.e. the time has changed suddenly, e.g. by a new one timetable to start.        
+Up to 4 can occur per sudden change commands can be marked like this. 
+BBBBBB =    Acceleration factor, value range 0..63. An acceleration factor of 0 means the  
+model clock has been stopped, a factor of 1 corresponds to real time, at 2 the 
+clock runs twice as fast, at three times as fast as real time, etc. 
+*/
+if (minutes>=1440 || speed>63 ) return false; 
+byte b[5];
+b[0]=0; // broadcast address
+b[1]=0b11000001; // 1100-0001 (model time)
+b[2]=minutes % 60 ;  // MM
+b[3]= 0b11100000 | (minutes/60); // 111H-HHHH weekday not supported
+b[4]= (suddenChange ? 0b10000000 : 0) | speed;
+DCCQueue::scheduleDCCPacket(b, sizeof(b), 2);
+return true; 
 }
 
 FSH* DCC::getMotorShieldName() {
@@ -421,6 +604,37 @@ const ackOp FLASH READ_CV_PROG[] = {
 
 const ackOp FLASH LOCO_ID_PROG[] = {
       BASELINE,
+      // first check cv20 for extended addressing
+      SETCV, (ackOp)20,     // CV 19 is extended
+      SETBYTE, (ackOp)0,
+      VB, WACK, ITSKIP,     // skip past extended section if cv20 is zero
+      // read cv20 and 19 and merge 
+      STARTMERGE,           // Setup to read cv 20
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      VB, WACK, NAKSKIP, // bad read of cv20, assume its 0 
+      BAD20SKIP,     // detect invalid cv20 value and ignore 
+      STASHLOCOID,   // keep cv 20 until we have cv19 as well.
+      SETCV, (ackOp)19, 
+      STARTMERGE,           // Setup to read cv 19
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      V0, WACK, MERGE,
+      VB, WACK, NAKFAIL,  // cant recover if cv 19 unreadable
+      COMBINE1920,  // Combile byte with stash and callback
+// end of advanced 20,19 check
+      SKIPTARGET,
       SETCV, (ackOp)19,     // CV 19 is consist setting
       SETBYTE, (ackOp)0,
       VB, WACK, ITSKIP,     // ignore consist if cv19 is zero (no consist)
@@ -487,6 +701,10 @@ const ackOp FLASH LOCO_ID_PROG[] = {
 
 const ackOp FLASH SHORT_LOCO_ID_PROG[] = {
       BASELINE,
+      // Clear consist CV 19,20
+      SETCV,(ackOp)20,
+      SETBYTE, (ackOp)0,
+      WB,WACK,     // ignore dedcoder without cv20 support
       SETCV,(ackOp)19,
       SETBYTE, (ackOp)0,
       WB,WACK,     // ignore dedcoder without cv19 support
@@ -502,9 +720,27 @@ const ackOp FLASH SHORT_LOCO_ID_PROG[] = {
       CALLFAIL
 };
 
+// for CONSIST_ID_PROG the 20,19 values are already calculated
+const ackOp FLASH CONSIST_ID_PROG[] = {
+      BASELINE,
+      SETCV,(ackOp)20,
+      SETBYTEH,    // high byte to CV 20
+      WB,WACK,ITSKIP,
+      FAIL_IF_NONZERO_NAK, // fail if writing long address to decoder that cant support it
+      SKIPTARGET,
+      SETCV,(ackOp)19,
+      SETBYTEL,   // low byte of word
+      WB,WACK,ITC1,   // If ACK, we are done - callback(1) means Ok
+      VB,WACK,ITC1,   // Some decoders do not ack and need verify
+      CALLFAIL
+};
+
 const ackOp FLASH LONG_LOCO_ID_PROG[] = {
       BASELINE,
-      // Clear consist CV 19
+      // Clear consist CV 19,20
+      SETCV,(ackOp)20,
+      SETBYTE, (ackOp)0,
+      WB,WACK,     // ignore dedcoder without cv20 support
       SETCV,(ackOp)19,
       SETBYTE, (ackOp)0,
       WB,WACK,     // ignore decoder without cv19 support
@@ -573,79 +809,176 @@ void DCC::setLocoId(int id,ACK_CALLBACK callback) {
       DCCACK::Setup(id | 0xc000,LONG_LOCO_ID_PROG, callback);
 }
 
+void DCC::setConsistId(int id,bool reverse,ACK_CALLBACK callback) {
+  if (id<0 || id>10239) { //0x27FF according to standard
+    callback(-1);
+    return;
+  }
+  byte cv20;
+  byte cv19;
+
+  if (id<=HIGHEST_SHORT_ADDR) {
+    cv19=id;
+    cv20=0;
+  }
+  else {
+    cv20=id/100;
+    cv19=id%100;
+  }
+  if (reverse) cv19|=0x80;
+  DCCACK::Setup((cv20<<8)|cv19, CONSIST_ID_PROG, callback);
+}
+
 void DCC::forgetLoco(int cab) {  // removes any speed reminders for this loco
   setThrottle2(cab,1); // ESTOP this loco if still on track
-  int reg=lookupSpeedTable(cab, false);
-  if (reg>=0) {
-    speedTable[reg].loco=0;
-    setThrottle2(cab,1); // ESTOP if this loco still on track
+  auto slot=lookupSpeedTable(cab, false);
+  if (slot) {
+    slot->loco=-1;  // no longer used but not end of world
+    CommandDistributor::broadcastForgetLoco(cab);
   }
 }
 void DCC::forgetAllLocos() {  // removes all speed reminders
   setThrottle2(0,1); // ESTOP all locos still on track
-  for (int i=0;i<MAX_LOCOS;i++) speedTable[i].loco=0;
+  for (int i=0;i<MAX_LOCOS;i++) {
+    if (speedTable[i].loco) CommandDistributor::broadcastForgetLoco(speedTable[i].loco);
+    speedTable[i].loco=0;  // no longer used and looks like end
+  }
 }
 
 byte DCC::loopStatus=0;
 
 void DCC::loop()  {
   TrackManager::loop(); // power overload checks
-  issueReminders();
+  if (DCCWaveform::mainTrack.isReminderWindowOpen()) {
+    // Now is a good time to choose a packet to be sent
+    // Either highest priority from the queues or a reminder
+    if (!DCCQueue::scheduleNext(false)) {
+      // none pending, 
+      issueReminders();
+      DCCQueue::scheduleNext(true); // send any pending and force an idle if none 
+    }
+
+  }
 }
 
 void DCC::issueReminders() {
-  // if the main track transmitter still has a pending packet, skip this time around.
-  if ( DCCWaveform::mainTrack.getPacketPending()) return;
+  while(true) { 
   // Move to next loco slot.  If occupied, send a reminder.
-  int reg = lastLocoReminder+1;
-  if (reg > highestUsedReg) reg = 0;  // Go to start of table
-  if (speedTable[reg].loco > 0) {
-    // have found loco to remind
-    if (issueReminder(reg))
-      lastLocoReminder = reg;
-  } else
-    lastLocoReminder = reg;
+  // slot.loco is -1 for deleted locos, 0 for end of list.
+  for (auto slot=nextLocoReminder;slot->loco;slot++) {
+    if (slot->loco<0) continue; // deleted loco, skip it
+    if (issueReminder(slot)) {
+      nextLocoReminder=slot+1; // remember next one to check
+      return; // reminder sent, exit
+      }
+    }
+    // we have reached the end of the table, so we can move on to 
+    // the next loop state and start from the top.
+    // There are 0-9 loop states..  speed,f1,speed,f2,speed,f3,speed,f4,speed,f5
+    loopStatus++;
+    if (loopStatus>9) loopStatus=0; // reset to 0
+
+    // try looking from the start of the table down to where we started last time
+      
+    for (auto slot=&speedTable[0];slot<nextLocoReminder;slot++) {
+      if (slot->loco<0) continue; // deleted loco, skip it
+      if (issueReminder(slot)) {
+        nextLocoReminder=slot+1; // remember next one to check
+        return; // reminder sent, exit
+        }
+      }
+    // if we get here then we can update the loop status and start again
+    if (loopStatus==0) return; // nothing found at all
+  }
 }
 
-bool DCC::issueReminder(int reg) {
-  unsigned long functions=speedTable[reg].functions;
-  int loco=speedTable[reg].loco;
-  byte flags=speedTable[reg].groupFlags;
+int16_t normalize(byte speed) {
+   if (speed & 0x80) return speed & 0x7F;
+   return 0-1-speed; 
+}
+byte dccalize(int16_t speed) {
+   if (speed>127) return 0xFF;  // 127 forward
+   if (speed<-127) return 0x7F;  // 127 reverse
+   if (speed >=0) return speed | 0x80;
+   // negative speeds... -1==dcc 0, -2==dcc 1 
+   return (int16_t)-1 - speed; 
+}
+
+bool DCC::issueReminder(LOCO * slot) {
+  unsigned long functions=slot->functions;
+  int loco=slot->loco;
+  byte flags=slot->groupFlags;
 
   switch (loopStatus) {
         case 0:
-      //   DIAG(F("Reminder %d speed %d"),loco,speedTable[reg].speedCode);
-         setThrottle2(loco, speedTable[reg].speedCode);
-         break;
+        case 2:
+        case 4:
+        case 6:
+        case 8: {
+         // calculate any momentum change going on
+         auto sc=slot->speedCode;
+         if (slot->targetSpeed!=sc) {
+            // calculate new speed code 
+            auto now=millis();
+            int16_t delay=now-slot->momentum_base;
+            auto millisPerNotch=MOMENTUM_FACTOR * (int16_t)getMomentum(slot);
+            // allow for momentum change to 0 while accelerating/slowing
+            auto ticks=(millisPerNotch>0)?(delay/millisPerNotch):500;
+            if (ticks>0) {
+              auto current=normalize(sc);  // -128..+127
+              auto target=normalize(slot->targetSpeed);
+              // DIAG(F("Momentum l=%d ti=%d sc=%d c=%d t=%d"),loco,ticks,sc,current,target);
+              if (current<target) { // accelerate
+                current+=ticks;
+                if (current>target) current=target;
+              }
+              else  { // slow
+                current-=ticks;
+                if (current<target) current=target;
+              }
+              sc=dccalize(current);
+              //DIAG(F("c=%d newsc=%d"),current,sc);
+              slot->speedCode=sc;
+              TrackManager::setDCSignal(loco,sc); // in case this is a dcc track on this addr
+              slot->momentum_base=now;  
+            }
+          }
+          // DIAG(F("Reminder %d speed %d"),loco,slot->speedCode);
+          setThrottle2(loco, sc);
+        }
+        return true; // reminder sent
        case 1: // remind function group 1 (F0-F4)
-          if (flags & FN_GROUP_1)
-              setFunctionInternal(loco,0, 128 | ((functions>>1)& 0x0F) | ((functions & 0x01)<<4)); // 100D DDDD
+          if (flags & FN_GROUP_1) {
+            setFunctionInternal(loco,0, 128 | ((functions>>1)& 0x0F) | ((functions & 0x01)<<4)); // 100D DDDD
+            return true;  // reminder sent
+          }
           break;
-       case 2: // remind function group 2 F5-F8
-          if (flags & FN_GROUP_2)
-              setFunctionInternal(loco,0, 176 | ((functions>>5)& 0x0F));                           // 1011 DDDD
+       case 3: // remind function group 2 F5-F8
+          if (flags & FN_GROUP_2) {
+  	        setFunctionInternal(loco,0, 176 | ((functions>>5)& 0x0F));      // 1011 DDDD
+            return true;  // reminder sent
+          }
           break;
-       case 3: // remind function group 3 F9-F12
-          if (flags & FN_GROUP_3)
-              setFunctionInternal(loco,0, 160 | ((functions>>9)& 0x0F));                           // 1010 DDDD
+       case 5: // remind function group 3 F9-F12
+          if (flags & FN_GROUP_3) {
+	          setFunctionInternal(loco,0, 160 | ((functions>>9)& 0x0F));    // 1010 DDDD
+            return true;  // reminder sent
+          }
           break;
-       case 4: // remind function group 4 F13-F20
-          if (flags & FN_GROUP_4)
-              setFunctionInternal(loco,222, ((functions>>13)& 0xFF));
-          flags&= ~FN_GROUP_4;  // dont send them again
+       case 7: // remind function group 4 F13-F20
+          if (flags & FN_GROUP_4) {
+	          setFunctionInternal(loco,222, ((functions>>13)& 0xFF));
+            return true; 
+          }
           break;
-       case 5: // remind function group 5 F21-F28
-          if (flags & FN_GROUP_5)
-              setFunctionInternal(loco,223, ((functions>>21)& 0xFF));
-          flags&= ~FN_GROUP_5;  // dont send them again
+       case 9: // remind function group 5 F21-F28
+          if (flags & FN_GROUP_5) {
+	          setFunctionInternal(loco,223, ((functions>>21)& 0xFF));
+            return true;  // reminder sent
+          }
           break;
       }
-      loopStatus++;
-      // if we reach status 6 then this loco is done so
-      // reset status to 0 for next loco and return true so caller
-      // moves on to next loco.
-      if (loopStatus>5) loopStatus=0;
-      return loopStatus==0;
+      return false; // no reminder sent 
     }
 
 
@@ -662,70 +995,128 @@ byte DCC::cv2(int cv)  {
   return lowByte(cv);
 }
 
-int DCC::lookupSpeedTable(int locoId, bool autoCreate) {
+DCC::LOCO *  DCC::lookupSpeedTable(int locoId, bool autoCreate) {
   // determine speed reg for this loco
-  int firstEmpty = MAX_LOCOS;
-  int reg;
-  for (reg = 0; reg < MAX_LOCOS; reg++) {
-    if (speedTable[reg].loco == locoId) break;
-    if (speedTable[reg].loco == 0 && firstEmpty == MAX_LOCOS) firstEmpty = reg;
+  LOCO * firstEmpty=nullptr;
+  SLOTLOOP {
+    if (firstEmpty==nullptr && slot->loco<=0) firstEmpty=slot;
+    if (slot->loco == locoId) return slot;
+    if (slot->loco==0) break; 
   }
-
-  // return -1 if not found and not auto creating
-  if (reg== MAX_LOCOS && !autoCreate) return -1; 
-  if (reg == MAX_LOCOS) reg = firstEmpty;
-  if (reg >= MAX_LOCOS) {
-    DIAG(F("Too many locos"));
-    return -1;
+  if (!autoCreate) return nullptr;
+  if (firstEmpty==nullptr) { 
+    // return last slot if full
+    DIAG(F("Too many locos, reusing last slot"));
+    firstEmpty=&speedTable[MAX_LOCOS-1];
   }
-  if (reg==firstEmpty){
-        speedTable[reg].loco = locoId;
-        speedTable[reg].speedCode=128;  // default direction forward
-        speedTable[reg].groupFlags=0;
-        speedTable[reg].functions=0;
-  }
-  if (reg > highestUsedReg) highestUsedReg = reg;
-  return reg;
+  // fill first empty slot with new entry
+  firstEmpty->loco = locoId;
+  firstEmpty->speedCode=128;  // default direction forward
+  firstEmpty->targetSpeed=128;  // default direction forward
+  firstEmpty->groupFlags=0;
+  firstEmpty->functions=0;
+  firstEmpty->momentumA=MOMENTUM_USE_DEFAULT; 
+  firstEmpty->momentumD=MOMENTUM_USE_DEFAULT; 
+  return firstEmpty;
 }
 
-void  DCC::updateLocoReminder(int loco, byte speedCode) {
-
-  if (loco==0) {
-     // broadcast stop/estop but dont change direction
-     for (int reg = 0; reg <= highestUsedReg; reg++) {
-       if (speedTable[reg].loco==0) continue;
-       byte newspeed=(speedTable[reg].speedCode & 0x80) |  (speedCode & 0x7f);
-       if (speedTable[reg].speedCode != newspeed) {
-         speedTable[reg].speedCode = newspeed;
-         CommandDistributor::broadcastLoco(reg);
-       }
-     }
-     return;
+bool DCC::setMomentum(int locoId,int16_t accelerating, int16_t decelerating) {
+  if (locoId<0) return false;
+  if (locoId==0) {
+    if (accelerating<0 || decelerating<0) return false;
+    defaultMomentumA=accelerating/MOMENTUM_FACTOR;
+    defaultMomentumD=decelerating/MOMENTUM_FACTOR;
+    return true;
   }
+  // -1 is ok and means this loco should use the default.
+  if (accelerating<-1 || decelerating<-1) return false;
+  if (accelerating/MOMENTUM_FACTOR >= MOMENTUM_USE_DEFAULT || 
+      decelerating/MOMENTUM_FACTOR >= MOMENTUM_USE_DEFAULT) return false;
+  
+  // Values stored are 255=MOMENTUM_USE_DEFAULT, or millis/MOMENTUM_FACTOR.
+  // This is to keep the values in a byte rather than int16
+  // thus saving 2 bytes RAM per loco slot.   
+  LOCO* slot=lookupSpeedTable(locoId,true);
+  slot->momentumA=(accelerating<0)? MOMENTUM_USE_DEFAULT: (accelerating/MOMENTUM_FACTOR);
+  slot->momentumD=(decelerating<0)? MOMENTUM_USE_DEFAULT: (decelerating/MOMENTUM_FACTOR);
+  return true; 
+}
 
-  // determine speed reg for this loco
-  int reg=lookupSpeedTable(loco);
-  if (reg>=0 && speedTable[reg].speedCode!=speedCode) {
-    speedTable[reg].speedCode = speedCode;
-    CommandDistributor::broadcastLoco(reg);
+
+void  DCC::estopAll() {
+  setThrottle2(0,1); // estop all locos
+  TrackManager::setDCSignal(0,1); 
+    
+  // remind stop/estop but dont change direction
+  SLOTLOOP {
+    if (slot->loco<=0) continue;
+    byte newspeed=(slot->targetSpeed & 0x80) |  0x01;
+    slot->speedCode = newspeed;
+    slot->targetSpeed = newspeed;
+    CommandDistributor::broadcastLoco(slot);  
   }
 }
 
+
 DCC::LOCO DCC::speedTable[MAX_LOCOS];
-int DCC::lastLocoReminder = 0;
-int DCC::highestUsedReg = 0;
+DCC::LOCO *  DCC::nextLocoReminder = &DCC::speedTable[0];
 
 
 void DCC::displayCabList(Print * stream) {
-
+    StringFormatter::send(stream,F("<*\n")); 
     int used=0;
-    for (int reg = 0; reg <= highestUsedReg; reg++) {
-       if (speedTable[reg].loco>0) {
+    SLOTLOOP {
+       if (slot->loco==0) break;  // no more locos
+       if (slot->loco>0) {
         used ++;
-        StringFormatter::send(stream,F("cab=%d, speed=%d, dir=%c \n"),
-           speedTable[reg].loco,  speedTable[reg].speedCode & 0x7f,(speedTable[reg].speedCode & 0x80) ? 'F':'R');
+        StringFormatter::send(stream,F("cab=%d, speed=%d, target=%d, momentum=%d/%d, block=%d\n"),
+           slot->loco,  slot->speedCode, slot->targetSpeed,
+           slot->momentumA, slot->momentumD, slot->blockOccupied);
        }
      }
-     StringFormatter::send(stream,F("Used=%d, max=%d\n"),used,MAX_LOCOS);
-
+     StringFormatter::send(stream,F("Used=%d, max=%d, momentum=%d/%d *>\n"),
+                            used,MAX_LOCOS, DCC::defaultMomentumA,DCC::defaultMomentumD);
+}
+
+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
+  auto slot=lookupSpeedTable(loco,true);
+  if (!slot) return;
+  auto oldBlock=slot->blockOccupied; 
+  if (oldBlock==blockid) return; 
+  if (oldBlock) RMFT2::blockEvent(oldBlock,loco,false);
+  slot->blockOccupied=blockid;
+  if (blockid) RMFT2::blockEvent(blockid,loco,true);
+
+  if (exclusive) {
+    SLOTLOOP {
+       if (slot->loco==0) break;  // no more locos
+       if (slot->loco>0) {
+          if (slot->loco!=loco &&  slot->blockOccupied==blockid) {
+            RMFT2::blockEvent(blockid,slot->loco,false);
+            slot->blockOccupied=0;
+          }
+      }
+    }
+  }
+  #endif 
+}
+
+void DCC::clearBlock(uint16_t blockid) {
+  // Railcom reports block empty... tell Exrail about all leavers 
+  #ifdef EXRAIL_ACTIVE
+  SLOTLOOP {
+       if (slot->loco==0) break;  // no more locos
+       if (slot->loco>0) {
+        if (slot->blockOccupied==blockid) {
+        RMFT2::blockEvent(blockid,slot->loco,false);
+        slot->blockOccupied=0;
+        }
+      }
+  }
+  #endif 
 }

DCC.h

@@ -3,7 +3,7 @@
  *  © 2021 Fred Decker
  *  © 2021 Herb Morton
  *  © 2020-2021 Harald Barth
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2025 Chris Harlow
  *  All rights reserved.
  *  
  *  This file is part of Asbelos DCC API
@@ -59,18 +59,25 @@ public:
 
   // Public DCC API functions
   static void setThrottle(uint16_t cab, uint8_t tSpeed, bool tDirection);
+  static void estopAll();
   static int8_t getThrottleSpeed(int cab);
   static uint8_t getThrottleSpeedByte(int cab);
+  static uint8_t getLocoSpeedByte(int cab); // may lag throttle 
+  static uint8_t getThrottleFrequency(int cab);
   static bool getThrottleDirection(int cab);
   static void writeCVByteMain(int cab, int cv, byte bValue);
+  static void readCVByteMain(int cab, int cv, ACK_CALLBACK callback);
+  
   static void writeCVBitMain(int cab, int cv, byte bNum, bool bValue);
   static void setFunction(int cab, byte fByte, byte eByte);
   static bool setFn(int cab, int16_t functionNumber, bool on);
   static void changeFn(int cab, int16_t functionNumber);
-  static int  getFn(int cab, int16_t functionNumber);
+  static int8_t getFn(int cab, int16_t functionNumber);
   static uint32_t getFunctionMap(int cab);
+  static void setDCFreq(int cab,byte freq);
   static void updateGroupflags(byte &flags, int16_t functionNumber);
   static void setAccessory(int address, byte port, bool gate, byte onoff = 2);
+  static bool setExtendedAccessory(int16_t address, int16_t value, byte repeats=3);
   static bool writeTextPacket(byte *b, int nBytes);
   
   // ACKable progtrack calls  bitresults callback 0,0 or -1, cv returns value or -1
@@ -80,10 +87,12 @@ public:
   static void writeCVBit(int16_t cv, byte bitNum, bool bitValue, ACK_CALLBACK callback);
   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(int loco, uint16_t blockid, bool exclusive);
+  static void clearBlock(uint16_t blockid);
   static void getLocoId(ACK_CALLBACK callback);
   static void setLocoId(int id,ACK_CALLBACK callback);
-
+  static void setConsistId(int id,bool reverse,ACK_CALLBACK callback);
   // Enhanced API functions
   static void forgetLoco(int cab); // removes any speed reminders for this loco
   static void forgetAllLocos();    // removes all speed reminders
@@ -98,21 +107,32 @@ public:
     int loco;
     byte speedCode;
     byte groupFlags;
-    unsigned long functions;
+    uint32_t functions;
+    // Momentum management variables
+    uint32_t momentum_base;     // millis() when speed modified under momentum
+    byte momentumA, momentumD;
+    byte targetSpeed;           // speed set by throttle
+    uint16_t blockOccupied; // railcom detected block 
   };
+ static const int16_t MOMENTUM_FACTOR=7;  
+ static const byte MOMENTUM_USE_DEFAULT=255;
+ static bool linearAcceleration;  
+ static byte getMomentum(LOCO * slot);
+ 
  static LOCO speedTable[MAX_LOCOS];
- static int lookupSpeedTable(int locoId, bool autoCreate=true);
+ static LOCO * lookupSpeedTable(int locoId, bool autoCreate=true);
  static byte cv1(byte opcode, int cv);
  static byte cv2(int cv);
+ static bool setMomentum(int locoId,int16_t accelerating, int16_t decelerating);
  
 private:
   static byte loopStatus;
+  static byte defaultMomentumA;  // Accelerating
+  static byte defaultMomentumD;  // Accelerating
   static void setThrottle2(uint16_t cab, uint8_t speedCode);
-  static void updateLocoReminder(int loco, byte speedCode);
   static void setFunctionInternal(int cab, byte fByte, byte eByte);
-  static bool issueReminder(int reg);
-  static int lastLocoReminder;
-  static int highestUsedReg;
+  static bool issueReminder(LOCO * slot);
+  static LOCO* nextLocoReminder;
   static FSH *shieldName;
   static byte globalSpeedsteps;
 
@@ -123,6 +143,7 @@ private:
   // NMRA codes #
   static const byte SET_SPEED = 0x3f;
   static const byte WRITE_BYTE_MAIN = 0xEC;
+  static const byte READ_BYTE_MAIN = 0xE4;
   static const byte WRITE_BIT_MAIN = 0xE8;
   static const byte WRITE_BYTE = 0x7C;
   static const byte VERIFY_BYTE = 0x74;

DCCACK.cpp

@@ -27,8 +27,8 @@
 #include "DCCWaveform.h"
 #include "TrackManager.h"
 
-unsigned int DCCACK::minAckPulseDuration = 2000; // micros
-unsigned int DCCACK::maxAckPulseDuration = 20000; // micros
+unsigned long DCCACK::minAckPulseDuration = 2000; // micros
+unsigned long DCCACK::maxAckPulseDuration = 20000; // micros
   
 MotorDriver *  DCCACK::progDriver=NULL;
 ackOp  const *  DCCACK::ackManagerProg;
@@ -50,8 +50,8 @@ volatile uint8_t DCCACK::numAckSamples=0;
 uint8_t DCCACK::trailingEdgeCounter=0;
 
 
- unsigned int DCCACK::ackPulseDuration;  // micros
- unsigned long DCCACK::ackPulseStart; // micros
+unsigned long DCCACK::ackPulseDuration;  // micros
+unsigned long DCCACK::ackPulseStart; // micros
  volatile bool DCCACK::ackDetected;
  unsigned long DCCACK::ackCheckStart; // millis
  volatile bool DCCACK::ackPending;
@@ -67,16 +67,24 @@ CALLBACK_STATE DCCACK::callbackState=READY;
 ACK_CALLBACK DCCACK::ackManagerCallback;
 
 void  DCCACK::Setup(int cv, byte byteValueOrBitnum, ackOp const program[], ACK_CALLBACK callback) {
+  // On ESP32 the joined track is hidden from sight (it has type MAIN)
+  // and because of that we need first check if track was joined and
+  // then unjoin if necessary. This requires that the joined flag is
+  // cleared when the prog track is removed.
   ackManagerRejoin=TrackManager::isJoined();
+  //DIAG(F("Joined is %d"), ackManagerRejoin);
   if (ackManagerRejoin) {
     // Change from JOIN must zero resets packet.
     TrackManager::setJoin(false);
     DCCWaveform::progTrack.clearResets();
   }
-
   progDriver=TrackManager::getProgDriver();
+  //DIAG(F("Progdriver is %d"), progDriver);
   if (progDriver==NULL) {
-    TrackManager::setJoin(ackManagerRejoin);
+    if (ackManagerRejoin) {
+      DIAG(F("Joined but no Prog track"));
+      TrackManager::setJoin(false);
+    }
     callback(-3); // we dont have a prog track!
     return;
   }
@@ -127,7 +135,7 @@ bool DCCACK::checkResets(uint8_t numResets) {
 void DCCACK::setAckBaseline() {
       int baseline=progDriver->getCurrentRaw();
       ackThreshold= baseline + progDriver->mA2raw(ackLimitmA);
-      if (Diag::ACK) DIAG(F("ACK baseline=%d/%dmA Threshold=%d/%dmA Duration between %uus and %uus"),
+      if (Diag::ACK) DIAG(F("ACK baseline=%d/%dmA Threshold=%d/%dmA Duration between %lus and %lus"),
 			  baseline,progDriver->raw2mA(baseline),
 			  ackThreshold,progDriver->raw2mA(ackThreshold),
                           minAckPulseDuration, maxAckPulseDuration);
@@ -146,7 +154,7 @@ void DCCACK::setAckPending() {
 
 byte DCCACK::getAck() {
       if (ackPending) return (2);  // still waiting
-      if (Diag::ACK) DIAG(F("%S after %dmS max=%d/%dmA pulse=%uuS samples=%d gaps=%d"),ackDetected?F("ACK"):F("NO-ACK"), ackCheckDuration,
+      if (Diag::ACK) DIAG(F("%S after %dmS max=%d/%dmA pulse=%luS samples=%d gaps=%d"),ackDetected?F("ACK"):F("NO-ACK"), ackCheckDuration,
 			  ackMaxCurrent,progDriver->raw2mA(ackMaxCurrent), ackPulseDuration, numAckSamples, numAckGaps);
       if (ackDetected) return (1); // Yes we had an ack
       return(0);  // pending set off but not detected means no ACK.   
@@ -314,6 +322,14 @@ void DCCACK::loop() {
           callback( LONG_ADDR_MARKER | ( ackManagerByte + ((ackManagerStash - 192) << 8)));
           return;
 
+     case COMBINE1920:
+          // ackManagerStash is  cv20, ackManagerByte is CV 19
+          // This will not be called if cv20==0
+          ackManagerByte &= 0x7F;  // ignore direction marker
+          ackManagerByte %=100;    // take last 2 decimal digits 
+          callback( ackManagerStash*100+ackManagerByte);
+          return;
+
      case ITSKIP:
           if (!ackReceived) break;
           // SKIP opcodes until SKIPTARGET found
@@ -322,6 +338,29 @@ void DCCACK::loop() {
             opcode=GETFLASH(ackManagerProg);
           }
           break;
+
+     case NAKSKIP:
+          if (ackReceived) break;
+          // SKIP opcodes until SKIPTARGET found
+          while (opcode!=SKIPTARGET) {
+            ackManagerProg++;
+            opcode=GETFLASH(ackManagerProg);
+          }
+          break;
+     case BAD20SKIP:
+          if (ackManagerByte > 120) {
+            // skip to SKIPTARGET if cv20 is >120 (some decoders respond with 255)
+            if (Diag::ACK) DIAG(F("XX cv20=%d "),ackManagerByte);
+            while (opcode!=SKIPTARGET) {
+              ackManagerProg++;
+              opcode=GETFLASH(ackManagerProg);
+            }
+          }
+          break; 
+     case FAIL_IF_NONZERO_NAK: // fail if writing long address to decoder that cant support it
+          if (ackManagerByte==0) break;
+          callback(-4);  
+          return;           
      case SKIPTARGET:
           break;
      default:
@@ -466,4 +505,3 @@ void DCCACK::checkAck(byte sentResetsSincePacket) {
     }      
     ackPulseStart=0;  // We have detected a too-short or too-long pulse so ignore and wait for next leading edge 
 }
-

DCCACK.h

@@ -56,6 +56,10 @@ enum ackOp : byte
   STASHLOCOID,      // keeps current byte value for later
   COMBINELOCOID,    // combines current value with stashed value and returns it
   ITSKIP,           // skip to SKIPTARGET if ack true
+  NAKSKIP,          // skip to SKIPTARGET if ack false
+  COMBINE1920,      // combine cvs 19 and 20 and callback
+  BAD20SKIP,        // skip to SKIPTARGET if cv20 is >120 (some decoders respond with 255) 
+  FAIL_IF_NONZERO_NAK, // fail if writing long address to decoder that cant support it
   SKIPTARGET = 0xFF // jump to target
 };
 
@@ -77,10 +81,10 @@ class DCCACK {
     static inline void setAckLimit(int mA) {
 	ackLimitmA = mA;
     }
-    static inline void setMinAckPulseDuration(unsigned int i) {
+    static inline void setMinAckPulseDuration(unsigned long i) {
 	minAckPulseDuration = i;
     }
-    static inline void setMaxAckPulseDuration(unsigned int i) {
+    static inline void setMaxAckPulseDuration(unsigned long i) {
 	maxAckPulseDuration = i;
     }
 
@@ -124,11 +128,11 @@ class DCCACK {
     static unsigned long ackCheckStart; // millis
     static unsigned int ackCheckDuration; // millis       
     
-    static unsigned int ackPulseDuration;  // micros
+    static unsigned long ackPulseDuration;  // micros
     static unsigned long ackPulseStart; // micros
 
-    static unsigned int minAckPulseDuration ; // micros
-    static unsigned int maxAckPulseDuration ; // micros
+    static unsigned long minAckPulseDuration ; // micros
+    static unsigned long maxAckPulseDuration ; // micros
     static MotorDriver* progDriver;
     static volatile uint8_t numAckGaps;
     static volatile uint8_t numAckSamples;

DCCEX.h

@@ -49,6 +49,7 @@
 #include "CommandDistributor.h"
 #include "TrackManager.h"
 #include "DCCTimer.h"    
+#include "KeywordHasher.h"
 #include "EXRAIL.h"
     
 #endif

DCCEXParser.h

@@ -1,7 +1,7 @@
 /*
  *  © 2021 Mike S
  *  © 2021 Fred Decker
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2025 Chris Harlow
  *  All rights reserved.
  *  
  *  This file is part of Asbelos DCC API
@@ -37,19 +37,22 @@ struct DCCEXParser
    static void parseOne(Print * stream,  byte * command,  RingStream * ringStream);
    static void setFilter(FILTER_CALLBACK filter);
    static void setRMFTFilter(FILTER_CALLBACK filter);
+   static void setCamParserFilter(FILTER_CALLBACK filter);
    static void setAtCommandCallback(AT_COMMAND_CALLBACK filter);
    static const int MAX_COMMAND_PARAMS=10;  // Must not exceed this
  
    private:
   
     static const int16_t MAX_BUFFER=50;  // longest command sent in
-    static int16_t splitValues( int16_t result[MAX_COMMAND_PARAMS], const byte * command, bool usehex);
+    static int16_t splitValues( int16_t result[MAX_COMMAND_PARAMS], byte * command, bool usehex);
      
     static bool parseT(Print * stream, int16_t params, int16_t p[]);
     static bool parseZ(Print * stream, int16_t params, int16_t p[]);
     static bool parseS(Print * stream, int16_t params, int16_t p[]);
     static bool parsef(Print * stream, int16_t params, int16_t p[]);
+    static bool parseC(Print * stream, int16_t params, int16_t p[]);
     static bool parseD(Print * stream, int16_t params, int16_t p[]);
+    static bool parseJM(Print * stream, int16_t params, int16_t p[]);
 #ifndef IO_NO_HAL
     static bool parseI(Print * stream, int16_t params, int16_t p[]);
 #endif
@@ -67,13 +70,16 @@ struct DCCEXParser
     static void callback_W(int16_t result);
     static void callback_W4(int16_t result);
     static void callback_B(int16_t result);        
-    static void callback_R(int16_t result);
+    static void callback_R(int16_t result); // prog
+    static void callback_r(int16_t result); // main
     static void callback_Rloco(int16_t result);
     static void callback_Wloco(int16_t result);
+    static void callback_Wconsist(int16_t result);
     static void callback_Vbit(int16_t result);
     static void callback_Vbyte(int16_t result);
     static FILTER_CALLBACK  filterCallback;
     static FILTER_CALLBACK  filterRMFTCallback;
+    static FILTER_CALLBACK  filterCamParserCallback;
     static AT_COMMAND_CALLBACK  atCommandCallback;
     static bool funcmap(int16_t cab, byte value, byte fstart, byte fstop);
     static void sendFlashList(Print * stream,const int16_t flashList[]);

DCCQueue.cpp

@@ -0,0 +1,234 @@
+/*
+ *  © 2025 Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/* What does this queue manager do:
+  1. It provides a high priority queue and a low priority queue.
+  2. It manages situations where multiple loco speed commands are in the queue.
+  3. It allows an ESTOP to jump the queue and eliminate any outstanding speed commands that would later undo the stop.
+  4. It allows for coil on/off accessory commands to be synchronized to a given time delay.
+  5. It prevents transmission of sequential packets to the same loco id 
+  */
+#include "Arduino.h"
+#include "defines.h"
+#include "DCCQueue.h"
+#include "DCCWaveform.h"
+#include "DIAG.h"
+
+// create statics 
+DCCQueue* DCCQueue::lowPriorityQueue=new DCCQueue();
+DCCQueue* DCCQueue::highPriorityQueue=new DCCQueue();
+PendingSlot* DCCQueue::recycleList=nullptr;
+uint16_t DCCQueue::lastSentPacketLocoId=0; // used to prevent two packets to the same loco in a row
+
+
+    DCCQueue::DCCQueue() {
+        head=nullptr;
+        tail=nullptr;
+    }
+    
+    void DCCQueue::addQueue(PendingSlot* p) {
+        if (tail) tail->next=p;
+        else head=p;
+        tail=p;
+        p->next=nullptr;          
+    }
+
+    void DCCQueue::jumpQueue(PendingSlot* p) {
+        p->next=head;
+        head=p;
+        if (!tail) tail=p; 
+    }
+
+    
+    void DCCQueue::recycle(PendingSlot* p) {
+        p->next=recycleList;
+        recycleList=p;
+    }
+    
+    // Packet joins end of low priority queue.
+    void DCCQueue::scheduleDCCPacket(byte* packet, byte length, byte repeats, uint16_t loco) {
+        lowPriorityQueue->addQueue(getSlot(NORMAL_PACKET,packet,length,repeats,loco));
+    }
+    
+    // Packet replaces existing loco speed packet or joins end of high priority queue. 
+    
+    void DCCQueue::scheduleDCCSpeedPacket(byte* packet, byte length, byte repeats, uint16_t loco) {
+        for (auto p=highPriorityQueue->head;p;p=p->next) {
+            if (p->locoId==loco) {
+                // replace existing packet
+                if (length>sizeof(p->packet)) {
+                    DIAG(F("DCC bad packet length=%d"),length);
+                    length=sizeof(p->packet); // limit to size of packet
+                }
+                memcpy(p->packet,packet,length);
+                p->packetLength=length;
+                p->packetRepeat=repeats;
+                return;
+            }
+        }
+        highPriorityQueue->addQueue(getSlot(NORMAL_PACKET,packet,length,repeats,loco));
+    }
+    
+    
+    // ESTOP -  
+    // any outstanding throttle packet for this loco (all if loco=0) discarded
+    // Packet joins start of queue,
+   
+    
+    void DCCQueue::scheduleEstopPacket(byte* packet, byte length, byte repeats,uint16_t loco) {
+        
+        // DIAG(F("DCC ESTOP loco=%d"),loco);
+       
+        // kill any existing throttle packets for this loco (or all locos if broadcast)
+        // this will also remove any estop packets for this loco (or all locos if broadcast) but they will be replaced
+        PendingSlot * previous=nullptr;
+        auto p=highPriorityQueue->head;
+        while(p) {
+            if (p->type!=ACC_OFF_PACKET && (loco==0 || p->locoId==loco)) {
+                // drop this packet from the highPriority   queue 
+                if (previous) previous->next=p->next;
+                else highPriorityQueue->head=p->next;
+                
+                recycle(p);  // recycle this slot
+
+                // address next packet
+                p=previous?previous->next : highPriorityQueue->head;
+            }
+            else {
+                previous=p;
+                p=p->next;
+            }
+        }
+        // add the estop packet to the start of the queue
+        highPriorityQueue->jumpQueue(getSlot(NORMAL_PACKET,packet,length,repeats,0));
+    }
+
+    // Accessory coil-On Packet joins end of queue as normal.
+    // When dequeued, packet is retained at start of queue 
+    // but modified to coil-off and given the delayed start.
+    // getNext will ignore this packet until the requested start time. 
+    void DCCQueue::scheduleAccOnOffPacket(byte* packet, byte length, byte repeats,int16_t delayms) {
+        auto p=getSlot(ACC_ON_PACKET,packet,length,repeats,0);
+        p->delayOff=delayms;
+        lowPriorityQueue->addQueue(p);
+    };
+
+    
+    // Schedule the next dcc packet from the queues or an idle packet if none pending.
+    const byte idlePacket[] = {0xFF, 0x00};
+
+    bool DCCQueue::scheduleNext(bool force) {
+        if (highPriorityQueue->scheduleNextInternal()) return true;
+        if (lowPriorityQueue->scheduleNextInternal()) return true;
+        if (force) {
+            // This will arise when there is nothing available to be sent that will not compromise the rules
+            // typically this will only happen when there is only one loco in the reminders as the closely queued 
+            // speed and function reminders must be separated by at least one packet not sent to that loco.
+            DCCWaveform::mainTrack.schedulePacket(idlePacket,sizeof(idlePacket),0);
+            lastSentPacketLocoId=0;
+            return true;
+        }
+        return false;
+    }
+
+    bool DCCQueue::scheduleNextInternal() {
+        PendingSlot* previous=nullptr;
+        for (auto p=head;p;previous=p,p=p->next) {
+            // skip over pending ACC_OFF packets which are still delayed
+            if (p->type == ACC_OFF_PACKET && millis()<p->startTime) continue;
+            if (p->locoId) {
+                // Prevent two consecutive packets to the same loco. 
+                // this also means repeats cant be done by waveform 
+                if (p->locoId==lastSentPacketLocoId) continue;  // try again later 
+                DCCWaveform::mainTrack.schedulePacket(p->packet,p->packetLength,0);
+                lastSentPacketLocoId=p->locoId;
+                if (p->packetRepeat) {
+                    p->packetRepeat--;
+                    return true; // leave this packet in the queue
+                }
+            }
+            else {
+                // Non loco packets can repeat automatically
+                DCCWaveform::mainTrack.schedulePacket(p->packet,p->packetLength,p->packetRepeat);
+                lastSentPacketLocoId=0;
+            }
+
+            // remove this slot from the queue 
+            if (previous) previous->next=p->next;
+            else head=p->next;
+            if (!head) tail=nullptr;
+            
+            // special cases handling 
+            if (p->type == ACC_ON_PACKET) {
+                // convert to a delayed off packet and jump the high priority queue
+                p->type= ACC_OFF_PACKET;
+                p->packet[1]  &= ~0x08; // set C to 0 (gate off) 
+                p->startTime=millis()+p->delayOff;
+                highPriorityQueue->jumpQueue(p);
+                return true;
+            }
+             
+            // Recycle packet just consumed
+            recycle(p);     
+            return true;
+        }
+        
+        // No packets found
+        return false;
+    }
+    
+    // obtain and initialise slot for a PendingSlot.
+    PendingSlot*  DCCQueue::getSlot(PendingType type, byte* packet, byte length, byte repeats,uint16_t loco) {
+        PendingSlot * p; 
+        if (recycleList) {
+            p=recycleList;
+            recycleList=p->next;
+        }
+        else { 
+            static int16_t created=0;
+            int16_t q1=0;
+            int16_t q2=0;
+            for (auto p=highPriorityQueue->head;p;p=p->next) q1++;
+            for (auto p=lowPriorityQueue->head;p;p=p->next) q2++;
+            bool leak=(q1+q2)!=created;
+            DIAG(F("New DCC queue slot type=%d length=%d loco=%d q1=%d q2=%d created=%d"),
+                   type,length,loco,q1,q2, created);
+            if (leak) {
+                for (auto p=highPriorityQueue->head;p;p=p->next) DIAG(F("q1 %d %d"),p->type,p->locoId);
+                for (auto p=lowPriorityQueue->head;p;p=p->next) DIAG(F("q2 %d %d"),p->type,p->locoId);
+            }       
+            p=new PendingSlot; // need a queue entry
+            created++; 
+        }
+        p->next=nullptr;
+        p->type=type;
+        p->packetLength=length;
+        p->packetRepeat=repeats; 
+        if (length>sizeof(p->packet)) {
+            DIAG(F("DCC bad packet length=%d"),length);
+            length=sizeof(p->packet); // limit to size of packet
+        }
+        p->startTime=0; // not used for loco packets
+        memcpy((void*)p->packet,packet,length);
+        p->locoId=loco;
+        return p; 
+    }
+
+    

DCCQueue.h

@@ -0,0 +1,83 @@
+/*
+ *  © 2025 Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef DCCQueue_h
+#define DCCQueue_h
+#include "Arduino.h"
+#include "DCCWaveform.h"
+
+enum PendingType:byte {NORMAL_PACKET,SPEED_PACKET,FUNCTION_PACKET,ACC_ON_PACKET,ACC_OFF_PACKET,DEAD_PACKET};
+  struct PendingSlot {
+      PendingSlot* next; 
+      PendingType type;
+      byte packetLength;
+      byte packetRepeat;
+      byte packet[MAX_PACKET_SIZE];
+      
+      union { // use depends on packet type
+        uint16_t locoId;    // SPEED & FUNCTION packets  
+        uint16_t delayOff;  // ACC_ON_PACKET delay to apply between on/off
+        uint32_t startTime; // ACC_OFF_PACKET time (mS) to transmit 
+      };
+  };
+  
+class DCCQueue {
+  public:
+    
+    
+    // Non-speed packets are queued in the main queue
+    static void scheduleDCCPacket(byte* packet, byte length, byte repeats, uint16_t loco=0);
+
+    // Speed packets are queued in the high priority queue
+    static void scheduleDCCSpeedPacket(byte* packet, byte length, byte repeats, uint16_t loco);
+    
+    // ESTOP packets jump the high priority queue and discard any outstanding throttle packets for this loco  
+    static void scheduleEstopPacket(byte* packet, byte length, byte repeats,uint16_t loco);
+
+    // Accessory gate-On Packet joins end of main queue as normal. 
+    // When dequeued, packet is modified to gate-off and given the delayed start in the high priority queue. 
+    // getNext will ignore this packet until the requested start time.
+    static void scheduleAccOnOffPacket(byte* packet, byte length, byte repeats,int16_t delayms);
+
+  
+    // Schedules a main track packet from the queues.
+    static bool scheduleNext(bool force); 
+
+  private:
+    bool scheduleNextInternal(); 
+  // statics to manage high and low priority queues and recycleing of PENDINGs
+    static PendingSlot* recycleList;
+    static DCCQueue* highPriorityQueue;
+    static DCCQueue* lowPriorityQueue;
+    static uint16_t lastSentPacketLocoId; // used to prevent two packets to the same loco in a row
+
+    DCCQueue();
+    
+    PendingSlot*  head;
+    PendingSlot * tail;
+    
+    // obtain and initialise slot for a PendingSlot. 
+    static PendingSlot*  getSlot(PendingType type, byte* packet, byte length, byte repeats, uint16_t loco);
+    static void recycle(PendingSlot* p);
+    void addQueue(PendingSlot * p);
+    void jumpQueue(PendingSlot * p);
+  
+};
+#endif

DCCRMT.cpp

@@ -1,5 +1,5 @@
 /*
- *  © 2021-2022, Harald Barth.
+ *  © 2021-2024, Harald Barth.
  *  
  *  This file is part of DCC-EX
  *
@@ -17,6 +17,25 @@
  *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+/*
+ * RMT has "channels" which us FIFO RAM where you place what you want to send
+ * or receive. Channels can be merged to get more words per channel.
+ *
+ * WROOM: 8 channels total of 512 words, 64 words per channel. We use currently
+ * channel 0+1 for 128 words for DCC MAIN and 2+3 for DCC PROG.
+ *
+ * S3: 8 channels total of 384 words. 4 channels dedicated for TX and 4 channels
+ * dedicated for RX. 48 words per channel. So for TX there are 4 channels and we
+ * could use them with 96 words for MAIN and PROG if DCC data does fit in there.
+ *
+ * C3: 4 channels total of 192 words. As we do not use RX we can use all for TX
+ * so the situation is the same as for the -S3
+ *
+ * C6, H2: 4 channels total of 192 words. 2 channels dedictaed for TX and
+ * 2 channels dedicated for RX. Half RMT capacity compared to the C3.
+ *
+ */
+
 #if defined(ARDUINO_ARCH_ESP32)
 #include "defines.h"
 #include "DIAG.h"
@@ -25,6 +44,18 @@
 #include "DCCWaveform.h" // for MAX_PACKET_SIZE
 #include "soc/gpio_sig_map.h"
 
+// check for right type of ESP32
+#include "soc/soc_caps.h"
+#ifndef SOC_RMT_MEM_WORDS_PER_CHANNEL
+#error This symobol should be defined
+#endif
+#if SOC_RMT_MEM_WORDS_PER_CHANNEL < 64
+#warning This is not an ESP32-WROOM but some other unsupported variant
+#warning You are outside of the DCC-EX supported hardware
+#endif
+
+static const byte RMT_CHAN_PER_DCC_CHAN = 2;
+
 // Number of bits resulting out of X bytes of DCC payload data
 // Each byte has one bit extra and at the end we have one EOF marker
 #define DATA_LEN(X) ((X)*9+1)
@@ -75,12 +106,30 @@ void IRAM_ATTR interrupt(rmt_channel_t channel, void *t) {
 RMTChannel::RMTChannel(pinpair pins, bool isMain) {
   byte ch;
   byte plen;
+
+  // Below we check if the DCC packet actually fits into the RMT hardware
+  // Currently MAX_PACKET_SIZE = 5 so with checksum there are
+  // MAX_PACKET_SIZE+1 data packets. Each need DATA_LEN (9) bits.
+  // To that we add the preamble length, the fencepost DCC end bit
+  // and the RMT EOF marker.
+  // SOC_RMT_MEM_WORDS_PER_CHANNEL is either 64 (original WROOM) or
+  // 48 (all other ESP32 like the -C3 or -S2
+  // The formula to get the possible MAX_PACKET_SIZE is
+  //
+  // ALLOCATED = RMT_CHAN_PER_DCC_CHAN * SOC_RMT_MEM_WORDS_PER_CHANNEL
+  // MAX_PACKET_SIZE = floor((ALLOCATED - PREAMBLE_LEN - 2)/9 - 1)
+  //
+
   if (isMain) {
     ch = 0;
     plen = PREAMBLE_BITS_MAIN;
+    static_assert (DATA_LEN(MAX_PACKET_SIZE+1) + PREAMBLE_BITS_MAIN + 2 <= RMT_CHAN_PER_DCC_CHAN * SOC_RMT_MEM_WORDS_PER_CHANNEL,
+		  "Number of DCC packet bits greater than ESP32 RMT memory available");
   } else {
-    ch = 2;
+    ch = RMT_CHAN_PER_DCC_CHAN; // number == offset
     plen = PREAMBLE_BITS_PROG;
+    static_assert (DATA_LEN(MAX_PACKET_SIZE+1) + PREAMBLE_BITS_PROG + 2 <= RMT_CHAN_PER_DCC_CHAN * SOC_RMT_MEM_WORDS_PER_CHANNEL,
+		   "Number of DCC packet bits greater than ESP32 RMT memory available");
   }
     
   // preamble
@@ -115,7 +164,7 @@ RMTChannel::RMTChannel(pinpair pins, bool isMain) {
   // data: max packet size today is 5 + checksum
   maxDataLen = DATA_LEN(MAX_PACKET_SIZE+1);  // plus checksum
   data = (rmt_item32_t*)malloc(maxDataLen*sizeof(rmt_item32_t));
-  
+
   rmt_config_t config;
   // Configure the RMT channel for TX
   bzero(&config, sizeof(rmt_config_t));
@@ -123,20 +172,10 @@ RMTChannel::RMTChannel(pinpair pins, bool isMain) {
   config.channel = channel = (rmt_channel_t)ch;
   config.clk_div = RMT_CLOCK_DIVIDER;
   config.gpio_num = (gpio_num_t)pins.pin;
-  config.mem_block_num = 2; // With longest DCC packet 11 inc checksum (future expansion)
-                            // number of bits needed is 22preamble + start +
-                            // 11*9 + extrazero + EOT = 124
-                            // 2 mem block of 64 RMT items should be enough
-
+  config.mem_block_num = RMT_CHAN_PER_DCC_CHAN;
+  // use config
   ESP_ERROR_CHECK(rmt_config(&config));
   addPin(pins.invpin, true);
-  /*
-  // test: config another gpio pin
-  gpio_num_t gpioNum = (gpio_num_t)(pin-1);
-  PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpioNum], PIN_FUNC_GPIO);
-  gpio_set_direction(gpioNum, GPIO_MODE_OUTPUT);
-  gpio_matrix_out(gpioNum, RMT_SIG_OUT0_IDX, 0, 0);
-  */
   
   // NOTE: ESP_INTR_FLAG_IRAM is *NOT* included in this bitmask
   ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, ESP_INTR_FLAG_LOWMED|ESP_INTR_FLAG_SHARED));

DCCRMT.h

@@ -44,6 +44,12 @@ class RMTChannel {
       return true;
     return dataReady;
   };
+  inline void waitForDataCopy() {
+    while(1) { // do nothing and wait for interrupt clearing dataReady to happen
+      if (dataReady == false)
+	break;
+    }
+  };
   inline uint32_t packetCount() { return packetCounter; };
   
  private:

DCCTimer.h

@@ -1,5 +1,5 @@
 /*
- *  © 2022-2023 Paul M. Antoine
+ *  © 2022-2024 Paul M. Antoine
  *  © 2021 Mike S
  *  © 2021-2023 Harald Barth
  *  © 2021 Fred Decker
@@ -62,8 +62,14 @@ 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 DCCEXanalogWriteFrequency(uint8_t pin, uint32_t frequency);
-  static void DCCEXanalogWrite(uint8_t pin, int value);
+  static void DCCEXanalogWrite(uint8_t pin, int value, bool invert);
+  static void DCCEXledcDetachPin(uint8_t pin);
+  static void DCCEXanalogCopyChannel(int8_t frompin, int8_t topin);
+  static void DCCEXInrushControlOn(uint8_t pin, int duty, bool invert);
+  static void DCCEXledcAttachPin(uint8_t pin, int8_t channel, bool inverted);
 
 // Update low ram level.  Allow for extra bytes to be specified
 // by estimation or inspection, that may be used by other 
@@ -85,6 +91,7 @@ class DCCTimer {
   static void reset();
   
 private:
+  static void DCCEXanalogWriteFrequencyInternal(uint8_t pin, uint32_t frequency);
   static int freeMemory();
   static volatile int minimum_free_memory;
   static const int DCC_SIGNAL_TIME=58;  // this is the 58uS DCC 1-bit waveform half-cycle 
@@ -128,6 +135,8 @@ private:
   #if defined (ARDUINO_ARCH_STM32)
   // bit array of used pins (max 32)
   static uint32_t usedpins;
+  static uint32_t * analogchans;        // Array of channel numbers to be scanned
+  static ADC_TypeDef * * adcchans;      // Array to capture which ADC is each input channel on
 #else
   // bit array of used pins (max 16)
   static uint16_t usedpins;

DCCTimerAVR.cpp

@@ -2,7 +2,7 @@
  *  © 2021 Mike S
  *  © 2021-2023 Harald Barth
  *  © 2021 Fred Decker
- *  © 2021 Chris Harlow
+ *  © 2021-2025 Chris Harlow
  *  © 2021 David Cutting
  *  All rights reserved.
  *  
@@ -29,6 +29,7 @@
 #include <avr/boot.h> 
 #include <avr/wdt.h>
 #include "DCCTimer.h"
+#include "DIAG.h"
 #ifdef DEBUG_ADC
 #include "TrackManager.h"
 #endif
@@ -39,6 +40,9 @@ INTERRUPT_CALLBACK interruptHandler=0;
     #define TIMER1_A_PIN   11
     #define TIMER1_B_PIN   12
     #define TIMER1_C_PIN   13
+    #define TIMER2_A_PIN   10
+    #define TIMER2_B_PIN   9
+    
 #else
    #define TIMER1_A_PIN   9
    #define TIMER1_B_PIN   10
@@ -53,8 +57,62 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
     TCCR1B = _BV(WGM13) | _BV(CS10);     // Mode 8, clock select 1
     TIMSK1 = _BV(TOIE1); // Enable Software interrupt
     interrupts();
+//diagnostic    pinMode(4,OUTPUT);
   }
 
+
+void DCCTimer::startRailcomTimer(byte brakePin) {
+  (void) brakePin; // Ignored... works on pin 9 only 
+  // diagnostic digitalWrite(4,HIGH);   
+
+  /* The Railcom timer is started in such a way that it 
+     - First triggers 58+29 uS after the previous TIMER1 tick. 
+       This provides an accurate offset (in High Accuracy mode)
+       for the start of the Railcom cutout.
+     - 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 
+        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 byte RailcomFudge0=58+58+29;
+  
+  // 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
+  // Enable Timer2 output on pin 9 (OC2B)
+  DDRB |= (1 << DDB1);
+
+  // RailcomFudge2 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.
+  }
+
+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);
+}
+
+
 // ISR called by timer interrupt every 58uS
   ISR(TIMER1_OVF_vect){ interruptHandler(); }
 
@@ -120,11 +178,90 @@ int DCCTimer::freeMemory() {
 }
 
 void DCCTimer::reset() {
-  wdt_enable( WDTO_15MS); // set Arduino watchdog timer for 15ms 
-  delay(50);            // wait for the prescaller time to expire
+  // 250ms chosen to circumwent bootloader bug which
+  // hangs at too short timepout (like 15ms)
+  wdt_enable( WDTO_250MS); // set Arduino watchdog timer for 250ms 
+  delay(500);              // wait for it to happen
 
 }
 
+void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t f) {
+  DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, f);
+}
+void DCCTimer::DCCEXanalogWriteFrequencyInternal(uint8_t pin, uint32_t fbits) {
+#if defined(ARDUINO_AVR_UNO)
+      (void)fbits;
+      (void) pin;
+      // Not worth doin something here as:
+      // If we are on pin 9 or 10 we are on Timer1 and we can not touch Timer1 as that is our DCC source.
+      // If we are on pin 5 or 6 we are on Timer 0 ad we can not touch Timer0 as that is millis() etc.
+      // We are most likely not on pin 3 or 11 as no known motor shield has that as brake.
+#endif
+#if defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2560)
+  // Speed mapping is done like this:
+  // No functions buttons:   000  0   -> low          131Hz
+  // Only F29 pressed        001  1   -> mid          490Hz
+  // F30 with or w/o F29     01x  2-3 -> high        3400Hz
+  // F31 with or w/o F29/30  1xx  4-7 -> supersonic 62500Hz
+  uint8_t abits;
+  uint8_t bbits;
+  if (pin == 9 || pin == 10) { // timer 2 is different
+
+    if (fbits >= 4)
+      abits = B00000011;
+    else
+      abits = B00000001;
+
+    if (fbits >= 4)
+      bbits = B0001;
+    else if (fbits >= 2)
+      bbits = B0010;
+    else if (fbits == 1)
+      bbits = B0100;
+    else //  fbits == 0
+      bbits = B0110;
+
+    TCCR2A = (TCCR2A & B11111100) | abits; // set WGM0 and WGM1
+    TCCR2B = (TCCR2B & B11110000) | bbits; // set WGM2 and 3 bits of prescaler
+    DIAG(F("Timer 2 A=%x B=%x"), TCCR2A, TCCR2B);
+
+  } else { // not timer 9 or 10
+    abits = B01;
+
+    if (fbits >= 4)
+      bbits = B1001;
+    else if (fbits >= 2)
+      bbits = B0010;
+    else if (fbits == 1)
+      bbits = B0011;
+    else
+      bbits = B0100;
+
+    switch (pin) {
+      // case 9 and 10 taken care of above by if()
+    case 6:
+    case 7:
+    case 8:
+      // Timer4
+      TCCR4A = (TCCR4A & B11111100) | abits; // set WGM0 and WGM1
+      TCCR4B = (TCCR4B & B11100000) | bbits; // set WGM2 and WGM3 and divisor
+      //DIAG(F("Timer 4 A=%x B=%x"), TCCR4A, TCCR4B);
+      break;
+    case 46:
+    case 45:
+    case 44:
+      // Timer5
+      TCCR5A = (TCCR5A & B11111100) | abits; // set WGM0 and WGM1
+      TCCR5B = (TCCR5B & B11100000) | bbits; // set WGM2 and WGM3 and divisor
+      //DIAG(F("Timer 5 A=%x B=%x"), TCCR5A, TCCR5B);
+      break;
+    default:
+      break;
+    }
+  }
+#endif
+}
+
 #if defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2560)
 #define NUM_ADC_INPUTS 16
 #else

DCCTimerESP.cpp

@@ -76,8 +76,20 @@ int DCCTimer::freeMemory() {
 #endif
 
 ////////////////////////////////////////////////////////////////////////
-
 #ifdef ARDUINO_ARCH_ESP32
+
+#if __has_include("esp_idf_version.h")
+#include "esp_idf_version.h"
+#endif
+#if ESP_IDF_VERSION_MAJOR == 4
+// all well correct IDF version
+#else
+#error "DCC-EX does not support compiling with IDF version 5.0 or later. Downgrade your ESP32 library to a version that contains IDF version 4. Arduino ESP32 library 3.0.0 is too new. Downgrade to one of 2.0.9 to 2.0.17"
+#endif
+
+// protect all the rest of the code from IDF version 5
+#if ESP_IDF_VERSION_MAJOR == 4
+#include "DIAG.h"
 #include <driver/adc.h>
 #include <soc/sens_reg.h>
 #include <soc/sens_struct.h>
@@ -151,10 +163,28 @@ void DCCTimer::reset() {
    ESP.restart();
 }
 
+void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t f) {
+  if (f >= 16)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, f);
+/*
+  else if (f == 7) // not used on ESP32
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 62500);
+*/
+  else if (f >= 4)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 32000);
+  else if (f >= 3)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 16000);
+  else if (f >= 2)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 3400);
+  else if (f == 1)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 480);
+  else
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 131);
+}
+
 #include "esp32-hal.h"
 #include "soc/soc_caps.h"
 
-
 #ifdef SOC_LEDC_SUPPORT_HS_MODE
 #define LEDC_CHANNELS           (SOC_LEDC_CHANNEL_NUM<<1)
 #else
@@ -164,7 +194,7 @@ void DCCTimer::reset() {
 static int8_t pin_to_channel[SOC_GPIO_PIN_COUNT] = { 0 };
 static int cnt_channel = LEDC_CHANNELS;
 
-void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t frequency) {
+void DCCTimer::DCCEXanalogWriteFrequencyInternal(uint8_t pin, uint32_t frequency) {
   if (pin < SOC_GPIO_PIN_COUNT) {
     if (pin_to_channel[pin] != 0) {
       ledcSetup(pin_to_channel[pin], frequency, 8);
@@ -172,27 +202,113 @@ void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t frequency) {
   }
 }
 
-void DCCTimer::DCCEXanalogWrite(uint8_t pin, int value) {
+void DCCTimer::DCCEXledcDetachPin(uint8_t pin) {
+  DIAG(F("Clear pin %d channel"), pin);
+  pin_to_channel[pin] = 0;
+  pinMatrixOutDetach(pin, false, false);
+}
+
+static byte LEDCToMux[] = {
+  LEDC_HS_SIG_OUT0_IDX,
+  LEDC_HS_SIG_OUT1_IDX,
+  LEDC_HS_SIG_OUT2_IDX,
+  LEDC_HS_SIG_OUT3_IDX,
+  LEDC_HS_SIG_OUT4_IDX,
+  LEDC_HS_SIG_OUT5_IDX,
+  LEDC_HS_SIG_OUT6_IDX,
+  LEDC_HS_SIG_OUT7_IDX,
+  LEDC_LS_SIG_OUT0_IDX,
+  LEDC_LS_SIG_OUT1_IDX,
+  LEDC_LS_SIG_OUT2_IDX,
+  LEDC_LS_SIG_OUT3_IDX,
+  LEDC_LS_SIG_OUT4_IDX,
+  LEDC_LS_SIG_OUT5_IDX,
+  LEDC_LS_SIG_OUT6_IDX,
+  LEDC_LS_SIG_OUT7_IDX,
+};
+
+void DCCTimer::DCCEXledcAttachPin(uint8_t pin, int8_t channel, bool inverted) {
+  DIAG(F("Attaching pin %d to channel %d %c"), pin, channel, inverted ? 'I' : ' ');
+  ledcAttachPin(pin, channel);
+  if (inverted) // we attach again but with inversion
+    gpio_matrix_out(pin, LEDCToMux[channel], inverted, 0);
+}
+
+void DCCTimer::DCCEXanalogCopyChannel(int8_t frompin, int8_t topin) {
+  // arguments are signed depending on inversion of pins
+  DIAG(F("Pin %d copied to %d"), frompin, topin);
+  bool inverted = false;
+  if (frompin<0)
+    frompin = -frompin;
+  if (topin<0) {
+    inverted = true;
+    topin = -topin;
+  }
+  int channel = pin_to_channel[frompin]; // after abs(frompin)
+  pin_to_channel[topin] = channel;
+  DCCTimer::DCCEXledcAttachPin(topin, channel, inverted);
+}
+
+void DCCTimer::DCCEXanalogWrite(uint8_t pin, int value, bool invert) {
+  // This allocates channels 15, 13, 11, ....
+  // so each channel gets its own timer.
   if (pin < SOC_GPIO_PIN_COUNT) {
     if (pin_to_channel[pin] == 0) {
+      int search_channel;
+      int n;
       if (!cnt_channel) {
           log_e("No more PWM channels available! All %u already used", LEDC_CHANNELS);
           return;
       }
-      pin_to_channel[pin] = --cnt_channel;
-      ledcSetup(cnt_channel, 1000, 8);
-      ledcAttachPin(pin, cnt_channel);
+      // search for free channels top down
+      for (search_channel=LEDC_CHANNELS-1; search_channel >=cnt_channel; search_channel -= 2) {
+	bool chanused = false;
+	for (n=0; n < SOC_GPIO_PIN_COUNT; n++) {
+	  if (pin_to_channel[n] == search_channel) { // current search_channel used
+	    chanused = true;
+	    break;
+	  }
+	}
+	if (chanused)
+	  continue;
+	if (n == SOC_GPIO_PIN_COUNT) // current search_channel unused
+	  break;
+      }
+      if (search_channel >= cnt_channel) {
+	pin_to_channel[pin] = search_channel;
+	DIAG(F("Pin %d assigned to search channel %d"), pin, search_channel);
+      } else {
+	pin_to_channel[pin] = --cnt_channel; // This sets 15, 13, ...
+	DIAG(F("Pin %d assigned to new channel %d"), pin, cnt_channel);
+	--cnt_channel;                       // Now we are at 14, 12, ...
+      }
+      ledcSetup(pin_to_channel[pin], 1000, 8);
+      DCCEXledcAttachPin(pin, pin_to_channel[pin], invert);
     } else {
-      ledcAttachPin(pin, pin_to_channel[pin]);
+      // This else is only here so we can enable diag
+      // Pin should be already attached to channel
+      // DIAG(F("Pin %d assigned to old channel %d"), pin, pin_to_channel[pin]);
     }
     ledcWrite(pin_to_channel[pin], value);
   }
 }
 
+void DCCTimer::DCCEXInrushControlOn(uint8_t pin, int duty, bool inverted) {
+  // this uses hardcoded channel 0
+  ledcSetup(0, 62500, 8);
+  DCCEXledcAttachPin(pin, 0, inverted);
+  ledcWrite(0, duty);
+}
+
 int ADCee::init(uint8_t pin) {
   pinMode(pin, ANALOG);
   adc1_config_width(ADC_WIDTH_BIT_12);
+// Espressif deprecated ADC_ATTEN_DB_11 somewhere between 2.0.9 and 2.0.17
+#ifdef ADC_ATTEN_11db
+  adc1_config_channel_atten(pinToADC1Channel(pin),ADC_ATTEN_11db);
+#else
   adc1_config_channel_atten(pinToADC1Channel(pin),ADC_ATTEN_DB_11);
+#endif
   return adc1_get_raw(pinToADC1Channel(pin));
 }
 int16_t ADCee::ADCmax() {
@@ -212,6 +328,5 @@ void ADCee::scan() {
 
 void ADCee::begin() {
 }
-
+#endif //IDF v4
 #endif //ESP32
-

DCCTimerMEGAAVR.cpp

@@ -80,6 +80,15 @@ extern char *__malloc_heap_start;
     interruptHandler();
   }
 
+void DCCTimer::startRailcomTimer(byte brakePin) {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+  (void) brakePin; 
+}
+
+void DCCTimer::ackRailcomTimer() {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+}
+
   bool DCCTimer::isPWMPin(byte pin) {
        (void) pin; 
        return false;  // TODO what are the relevant pins? 
@@ -125,6 +134,11 @@ void DCCTimer::reset() {
   while(true){}
 }
 
+void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t f) {
+}
+void DCCTimer::DCCEXanalogWriteFrequencyInternal(uint8_t pin, uint32_t fbits) {
+}
+
 int16_t ADCee::ADCmax() {
   return 4095;
 }

DCCTimerSAMD.cpp

@@ -76,6 +76,15 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   interrupts();
 }
 
+void DCCTimer::startRailcomTimer(byte brakePin) {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+  (void) brakePin; 
+}
+
+void DCCTimer::ackRailcomTimer() {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+}
+
 // Timer IRQ handlers replace the dummy handlers (in cortex_handlers)
 // copied from rf24 branch
 void TCC0_Handler() {
@@ -156,6 +165,11 @@ void DCCTimer::reset() {
     while(true) {};
 }
 
+void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t f) {
+}
+void DCCTimer::DCCEXanalogWriteFrequencyInternal(uint8_t pin, uint32_t fbits) {
+}
+
 #define NUM_ADC_INPUTS NUM_ANALOG_INPUTS
 
 uint16_t ADCee::usedpins = 0;

DCCTimerSTM32.cpp

@@ -1,6 +1,6 @@
 /*
  *  © 2023 Neil McKechnie
- *  © 2022-2023 Paul M. Antoine
+ *  © 2022-2024 Paul M. Antoine
  *  © 2021 Mike S
  *  © 2021, 2023 Harald Barth
  *  © 2021 Fred Decker
@@ -34,8 +34,22 @@
 #include "TrackManager.h"
 #endif
 #include "DIAG.h"
+#include <wiring_private.h>
 
-#if defined(ARDUINO_NUCLEO_F401RE) || defined(ARDUINO_NUCLEO_F411RE)
+#if defined(ARDUINO_NUCLEO_F401RE)
+// Nucleo-64 boards don't have additional serial ports defined by default
+// Serial1 is available on the F401RE, but not hugely convenient.
+// Rx pin on PB7 is useful, but all the Tx pins map to Arduino digital pins, specifically:
+//   PA9 == D8
+//   PB6 == D10
+// of which D8 is needed by the standard and EX8874 motor shields. D10 would be used if a second
+// EX8874 is stacked. So only disable this if using a second motor shield.
+HardwareSerial Serial1(PB7, PB6);  // Rx=PB7, Tx=PB6 -- CN7 pin 17 and CN10 pin 17
+// Serial2 is defined to use USART2 by default, but is in fact used as the diag console
+// via the debugger on the Nucleo-64. It is therefore unavailable for other DCC-EX uses like WiFi, DFPlayer, etc.
+// Let's define Serial6 as an additional serial port (the only other option for the F401RE)
+HardwareSerial Serial6(PA12, PA11);  // Rx=PA12, Tx=PA11 -- CN10 pins 12 and 14 - F401RE
+#elif defined(ARDUINO_NUCLEO_F411RE)
 // Nucleo-64 boards don't have additional serial ports defined by default
 HardwareSerial Serial1(PB7, PA15);  // Rx=PB7, Tx=PA15 -- CN7 pins 17 and 21 - F411RE
 // Serial2 is defined to use USART2 by default, but is in fact used as the diag console
@@ -50,11 +64,16 @@ HardwareSerial Serial6(PA12, PA11);  // Rx=PA12, Tx=PA11 -- CN10 pins 12 and 14
 // via the debugger on the Nucleo-64. It is therefore unavailable for other DCC-EX uses like WiFi, DFPlayer, etc.
 // On the F446RE, Serial3 and Serial5 are easy to use:
 HardwareSerial Serial3(PC11, PC10);  // Rx=PC11, Tx=PC10 -- USART3 - F446RE
-HardwareSerial Serial5(PD2, PC12);  // Rx=PC7, Tx=PC6 -- UART5 - F446RE
+HardwareSerial Serial5(PD2, PC12);  // Rx=PD2, Tx=PC12 -- UART5 - F446RE
 // On the F446RE, Serial4 and Serial6 also use pins we can't readily map while using the Arduino pins
-#elif defined(ARDUINO_NUCLEO_F412ZG) || defined(ARDUINO_NUCLEO_F413ZH) || defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F446ZE) 
+#elif defined(ARDUINO_NUCLEO_F412ZG) || defined(ARDUINO_NUCLEO_F413ZH) || defined(ARDUINO_NUCLEO_F446ZE) || \
+      defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F439ZI) || defined(ARDUINO_NUCLEO_F4X9ZI)
 // Nucleo-144 boards don't have Serial1 defined by default
 HardwareSerial Serial6(PG9, PG14);  // Rx=PG9, Tx=PG14 -- USART6
+HardwareSerial Serial2(PD6, PD5);  // Rx=PD6, Tx=PD5 -- UART2
+#if !defined(ARDUINO_NUCLEO_F412ZG)  // F412ZG does not have UART5
+  HardwareSerial Serial5(PD2, PC12);  // Rx=PD2, Tx=PC12 -- UART5
+#endif  
 // Serial3 is defined to use USART3 by default, but is in fact used as the diag console
 // via the debugger on the Nucleo-144. It is therefore unavailable for other DCC-EX uses like WiFi, DFPlayer, etc.
 #else
@@ -196,6 +215,15 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   interrupts();
 }
 
+void DCCTimer::startRailcomTimer(byte brakePin) {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+  (void) brakePin; 
+}
+
+void DCCTimer::ackRailcomTimer() {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+}
+
 bool DCCTimer::isPWMPin(byte pin) {
   //TODO: STM32 whilst this call to digitalPinHasPWM will reveal which pins can do PWM,
   //      there's no support yet for High Accuracy, so for now return false
@@ -215,9 +243,9 @@ void DCCTimer::clearPWM() {
 }
 
 void   DCCTimer::getSimulatedMacAddress(byte mac[6]) {
-  volatile uint32_t *serno1 = (volatile uint32_t *)0x1FFF7A10;
-  volatile uint32_t *serno2 = (volatile uint32_t *)0x1FFF7A14;
-  // volatile uint32_t *serno3 = (volatile uint32_t *)0x1FFF7A18;
+  volatile uint32_t *serno1 = (volatile uint32_t *)UID_BASE;
+  volatile uint32_t *serno2 = (volatile uint32_t *)UID_BASE+4;
+  // volatile uint32_t *serno3 = (volatile uint32_t *)UID_BASE+8;
 
   volatile uint32_t m1 = *serno1;
   volatile uint32_t m2 = *serno2;
@@ -252,6 +280,23 @@ void DCCTimer::reset() {
     while(true) {};
 }
 
+void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t f) {
+  if (f >= 16)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, f);
+  else if (f == 7)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 62500);
+  else if (f >= 4)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 32000);
+  else if (f >= 3)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 16000);
+  else if (f >= 2)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 3400);
+  else if (f == 1)
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 480);
+  else
+    DCCTimer::DCCEXanalogWriteFrequencyInternal(pin, 131);
+}
+
 // TODO: rationalise the size of these... could really use sparse arrays etc.
 static HardwareTimer * pin_timer[100] = {0};
 static uint32_t channel_frequency[100] = {0};
@@ -262,7 +307,7 @@ static uint32_t pin_channel[100] = {0};
 // sophisticated about detecting any clash between the timer we'd like to use for PWM and the ones
 // currently used for HA so they don't interfere with one another. For now we'll just make PWM
 // work well... then work backwards to integrate with HA mode if we can.
-void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t frequency)
+void DCCTimer::DCCEXanalogWriteFrequencyInternal(uint8_t pin, uint32_t frequency)
 {
   if (pin_timer[pin] == NULL) {
     // Automatically retrieve TIM instance and channel associated to pin
@@ -283,7 +328,7 @@ void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t frequency)
     if (pin_timer[pin] != NULL)
     {
       pin_timer[pin]->setPWM(pin_channel[pin], pin, frequency, 0); // set frequency in Hertz, 0% dutycycle
-      DIAG(F("DCCEXanalogWriteFrequency::Pin %d on Timer %d, frequency %d"), pin, pin_channel[pin], frequency);
+      DIAG(F("DCCEXanalogWriteFrequency::Pin %d on Timer Channel %d, frequency %d"), pin, pin_channel[pin], frequency);
     }
     else
       DIAG(F("DCCEXanalogWriteFrequency::failed to allocate HardwareTimer instance!"));
@@ -302,7 +347,9 @@ void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t frequency)
   return;
 }
 
-void DCCTimer::DCCEXanalogWrite(uint8_t pin, int value) {
+void DCCTimer::DCCEXanalogWrite(uint8_t pin, int value, bool invert) {
+    if (invert)
+      value = 255-value;
     // Calculate percentage duty cycle from value given
     uint32_t duty_cycle = (value * 100 / 256) + 1;
     if (pin_timer[pin] != NULL) {
@@ -330,9 +377,9 @@ void DCCTimer::DCCEXanalogWrite(uint8_t pin, int value) {
 uint32_t ADCee::usedpins = 0;         // Max of 32 ADC input channels!
 uint8_t ADCee::highestPin = 0;        // Highest pin to scan
 int * ADCee::analogvals = NULL;       // Array of analog values last captured
-uint32_t * analogchans = NULL;        // Array of channel numbers to be scanned
+uint32_t * ADCee::analogchans = NULL;        // Array of channel numbers to be scanned
 // bool adc1configured = false;
-ADC_TypeDef * * adcchans = NULL;      // Array to capture which ADC is each input channel on
+ADC_TypeDef * * ADCee::adcchans = NULL;      // Array to capture which ADC is each input channel on
 
 int16_t ADCee::ADCmax()
 {
@@ -350,9 +397,10 @@ int ADCee::init(uint8_t pin) {
   uint32_t adcchan =  STM_PIN_CHANNEL(pinmap_function(stmpin, PinMap_ADC)); // find ADC input channel
   ADC_TypeDef *adc = (ADC_TypeDef *)pinmap_find_peripheral(stmpin, PinMap_ADC); // find which ADC this pin is on ADC1/2/3 etc.
   int adcnum = 1;
+  // All variants have ADC1
   if (adc == ADC1)
     DIAG(F("ADCee::init(): found pin %d on ADC1"), pin);
-// Checking for ADC2 and ADC3 being defined helps cater for more variants later
+  // Checking for ADC2 and ADC3 being defined helps cater for more variants
 #if defined(ADC2)
   else if (adc == ADC2)
   {
@@ -399,6 +447,18 @@ int ADCee::init(uint8_t pin) {
         RCC->AHB1ENR |= RCC_AHB1ENR_GPIOFEN; //Power up PORTF
         gpioBase = GPIOF;
         break;
+#endif
+#if defined(GPIOG)
+    case 0x06:
+        RCC->AHB1ENR |= RCC_AHB1ENR_GPIOGEN; //Power up PORTG
+        gpioBase = GPIOG;
+        break;
+#endif
+#if defined(GPIOH)
+    case 0x07:
+        RCC->AHB1ENR |= RCC_AHB1ENR_GPIOHEN; //Power up PORTH
+        gpioBase = GPIOH;
+        break;
 #endif
     default:
       return -1023; // some silly value as error

DCCTimerTEENSY.cpp

@@ -39,6 +39,15 @@ void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   myDCCTimer.begin(interruptHandler, DCC_SIGNAL_TIME);
   }
 
+void DCCTimer::startRailcomTimer(byte brakePin) {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+  (void) brakePin; 
+}
+
+void DCCTimer::ackRailcomTimer() {
+  // TODO: for intended operation see DCCTimerAVR.cpp
+}
+
 bool DCCTimer::isPWMPin(byte pin) {
        //Teensy: digitalPinHasPWM, todo
       (void) pin;
@@ -141,6 +150,11 @@ void DCCTimer::reset() {
   SCB_AIRCR = 0x05FA0004;
 }
 
+void DCCTimer::DCCEXanalogWriteFrequency(uint8_t pin, uint32_t f) {
+}
+void DCCTimer::DCCEXanalogWriteFrequencyInternal(uint8_t pin, uint32_t fbits) {
+}
+
 int16_t ADCee::ADCmax() {
   return 4095;
 }

DCCWaveform.cpp

@@ -24,14 +24,13 @@
 #ifndef ARDUINO_ARCH_ESP32
   // This code is replaced entirely on an ESP32
 #include <Arduino.h>
-
 #include "DCCWaveform.h"
 #include "TrackManager.h"
 #include "DCCTimer.h"
 #include "DCCACK.h"
 #include "DIAG.h"
 
-
+bool DCCWaveform::cutoutNextTime=false;
 DCCWaveform  DCCWaveform::mainTrack(PREAMBLE_BITS_MAIN, true);
 DCCWaveform  DCCWaveform::progTrack(PREAMBLE_BITS_PROG, false);
 
@@ -71,9 +70,18 @@ void DCCWaveform::loop() {
 
 #pragma GCC push_options
 #pragma GCC optimize ("-O3")
+
 void DCCWaveform::interruptHandler() {
   // call the timer edge sensitive actions for progtrack and maintrack
   // member functions would be cleaner but have more overhead
+  #if defined(HAS_ENOUGH_MEMORY)
+  if (cutoutNextTime) {
+    cutoutNextTime=false;
+    railcomSampleWindow=false; // about to cutout, stop reading railcom data.
+    railcomCutoutCounter++;
+    DCCTimer::startRailcomTimer(9);
+  }
+  #endif
   byte sigMain=signalTransform[mainTrack.state];
   byte sigProg=TrackManager::progTrackSyncMain? sigMain : signalTransform[progTrack.state];
   
@@ -106,6 +114,7 @@ void DCCWaveform::interruptHandler() {
 DCCWaveform::DCCWaveform( byte preambleBits, bool isMain) {
   isMainTrack = isMain;
   packetPending = false;
+  reminderWindowOpen = false;
   memcpy(transmitPacket, idlePacket, sizeof(idlePacket));
   state = WAVE_START;
   // The +1 below is to allow the preamble generator to create the stop bit
@@ -115,7 +124,26 @@ DCCWaveform::DCCWaveform( byte preambleBits, bool isMain) {
   bits_sent = 0;
 }
 
+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
+volatile byte DCCWaveform::railcomLastAddressHigh=0;
+volatile byte DCCWaveform::railcomLastAddressLow=0;
 
+bool DCCWaveform::setRailcom(bool on, bool debug) {
+  if (on && railcomPossible) {
+    railcomActive=true;
+    railcomDebug=debug;
+  }
+  else {
+    railcomActive=false;
+    railcomDebug=false;
+    railcomSampleWindow=false;
+  } 
+  return railcomActive;
+}
 
 #pragma GCC push_options
 #pragma GCC optimize ("-O3")
@@ -123,13 +151,42 @@ void DCCWaveform::interrupt2() {
   // calculate the next bit to be sent:
   // set state WAVE_MID_1  for a 1=bit
   //        or WAVE_HIGH_0 for a 0 bit.
-
   if (remainingPreambles > 0 ) {
     state=WAVE_MID_1;  // switch state to trigger LOW on next interrupt
+    
     remainingPreambles--;
+  
+    // As we get to the end of the preambles, open the reminder window.
+    // This delays any reminder insertion until the last moment so
+    // that the reminder doesn't block a more urgent packet. 
+    reminderWindowOpen=transmitRepeats==0 && remainingPreambles<12 && remainingPreambles>1;
+    if (remainingPreambles==1)
+      promotePendingPacket();
+
+#if defined(HAS_ENOUGH_MEMORY)   
+    else if (isMainTrack && railcomActive) {
+      if (remainingPreambles==(requiredPreambles-1)) {
+        // First look if we need to start a railcom cutout on next interrupt
+        cutoutNextTime= true;
+      } else if (remainingPreambles==(requiredPreambles-12)) {
+        // cutout has ended so its now possible to poll the railcom detectors
+        // requiredPreambles is one higher that preamble length so
+        // if preamble length is 16 then this evaluates to 5
+        // 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];
+        railcomSampleWindow=true;
+      } else if (remainingPreambles==(requiredPreambles-3)) {
+        // cutout can be ended when read
+        // see above for requiredPreambles
+        DCCTimer::ackRailcomTimer();
+      }
+    }
+#endif    
     // 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.
-    DCCTimer::updateMinimumFreeMemoryISR(22); 
+    else DCCTimer::updateMinimumFreeMemoryISR(22); 
     return;
   }
 
@@ -148,29 +205,8 @@ void DCCWaveform::interrupt2() {
     if (bytes_sent >= transmitLength) {
       // end of transmission buffer... repeat or switch to next message
       bytes_sent = 0;
+      // preamble for next packet will start...
       remainingPreambles = requiredPreambles;
-
-      if (transmitRepeats > 0) {
-        transmitRepeats--;
-      }
-      else if (packetPending) {
-        // Copy pending packet to transmit packet
-        // a fixed length memcpy is faster than a variable length loop for these small lengths
-        // for (int b = 0; b < pendingLength; b++) transmitPacket[b] = pendingPacket[b];
-        memcpy( transmitPacket, pendingPacket, sizeof(pendingPacket));
-        
-        transmitLength = pendingLength;
-        transmitRepeats = pendingRepeats;
-        packetPending = false;
-        clearResets();
-      }
-      else {
-        // Fortunately reset and idle packets are the same length
-        memcpy( transmitPacket, isMainTrack ? idlePacket : resetPacket, sizeof(idlePacket));
-        transmitLength = sizeof(idlePacket);
-        transmitRepeats = 0;
-        if (getResets() < 250) sentResetsSincePacket++; // only place to increment (private!)
-      }
     }
   }  
 }
@@ -193,91 +229,42 @@ void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repea
   packetPending = true;
   clearResets();
 }
-bool DCCWaveform::getPacketPending() {
-  return packetPending;
-}
-#endif
 
-#ifdef ARDUINO_ARCH_ESP32
-#include "DCCWaveform.h"
-#include "DCCACK.h"
-
-DCCWaveform  DCCWaveform::mainTrack(PREAMBLE_BITS_MAIN, true);
-DCCWaveform  DCCWaveform::progTrack(PREAMBLE_BITS_PROG, false);
-RMTChannel *DCCWaveform::rmtMainChannel = NULL;
-RMTChannel *DCCWaveform::rmtProgChannel = NULL;
-
-DCCWaveform::DCCWaveform(byte preambleBits, bool isMain) {
-  isMainTrack = isMain;
-  requiredPreambles = preambleBits;
-}
-void DCCWaveform::begin() {
-  for(const auto& md: TrackManager::getMainDrivers()) {
-    pinpair p = md->getSignalPin();
-    if(rmtMainChannel) {
-      //DIAG(F("added pins %d %d to MAIN channel"), p.pin, p.invpin);
-      rmtMainChannel->addPin(p); // add pin to existing main channel
-    } else {
-      //DIAG(F("new MAIN channel with pins %d %d"), p.pin, p.invpin);
-      rmtMainChannel = new RMTChannel(p, true); /* create new main channel */
-    }
-  }
-  MotorDriver *md = TrackManager::getProgDriver();
-  if (md) {
-    pinpair p = md->getSignalPin();
-    if (rmtProgChannel) {
-      //DIAG(F("added pins %d %d to PROG channel"), p.pin, p.invpin);
-      rmtProgChannel->addPin(p); // add pin to existing prog channel
-    } else {
-      //DIAG(F("new PROGchannel with pins %d %d"), p.pin, p.invpin);
-      rmtProgChannel = new RMTChannel(p, false);
-    }
-  }
+bool DCCWaveform::isReminderWindowOpen() {
+  return reminderWindowOpen && ! packetPending;
 }
 
-void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repeats) {
-  if (byteCount > MAX_PACKET_SIZE) return; // allow for chksum
-  
-  byte checksum = 0;
-  for (byte b = 0; b < byteCount; b++) {
-    checksum ^= buffer[b];
-    pendingPacket[b] = buffer[b];
-  }
-  // buffer is MAX_PACKET_SIZE but pendingPacket is one bigger
-  pendingPacket[byteCount] = checksum;
-  pendingLength = byteCount + 1;
-  pendingRepeats = repeats;
-// DIAG repeated commands (accesories)
-//  if (pendingRepeats > 0)
-//    DIAG(F("Repeats=%d on %s track"), pendingRepeats, isMainTrack ? "MAIN" : "PROG");
-  // The resets will be zero not only now but as well repeats packets into the future
-  clearResets(repeats+1);
-  {
-    int ret;
-    do {
-      if(isMainTrack) {
-	if (rmtMainChannel != NULL)
-	  ret = rmtMainChannel->RMTfillData(pendingPacket, pendingLength, pendingRepeats);
-      } else {
-	if (rmtProgChannel != NULL)
-	  ret = rmtProgChannel->RMTfillData(pendingPacket, pendingLength, pendingRepeats);
+void DCCWaveform::promotePendingPacket() {
+    // fill the transmission packet from the pending packet
+    
+    // Just keep going if repeating  
+    if (transmitRepeats > 0) {
+        transmitRepeats--;
+        return;
       }
-    } while(ret > 0);
-  }
-}
-
-bool DCCWaveform::getPacketPending() {
-  if(isMainTrack) {
-    if (rmtMainChannel == NULL)
-      return true;
-    return rmtMainChannel->busy();
-  } else {
-    if (rmtProgChannel == NULL)
-      return true;
-    return rmtProgChannel->busy();
-  }
-}
-void IRAM_ATTR DCCWaveform::loop() {
-  DCCACK::checkAck(progTrack.getResets());
+    
+    if (packetPending) {
+        // Copy pending packet to transmit packet
+        // a fixed length memcpy is faster than a variable length loop for these small lengths
+        // for (int b = 0; b < pendingLength; b++) transmitPacket[b] = pendingPacket[b];
+        memcpy( transmitPacket, pendingPacket, sizeof(pendingPacket));
+        
+        transmitLength = pendingLength;
+        transmitRepeats = pendingRepeats;
+        packetPending = false;
+        clearResets();
+        return;
+      }
+      
+      // nothing to do, just send idles or resets
+      // Fortunately reset and idle packets are the same length
+      // Note: If railcomDebug is on, then we send resets to the main
+      //       track instead of idles. This means that all data will be zeros
+      //       and only the presets will be ones, making it much
+      //       easier to read on a logic analyser.
+      memcpy( transmitPacket, (isMainTrack && (!railcomDebug)) ? idlePacket : resetPacket, sizeof(idlePacket));
+      transmitLength = sizeof(idlePacket);
+      transmitRepeats = 0;
+      if (getResets() < 250) sentResetsSincePacket++; // only place to increment (private!)
 }
 #endif

DCCWaveform.h

@@ -2,8 +2,8 @@
  *  © 2021 M Steve Todd
  *  © 2021 Mike S
  *  © 2021 Fred Decker
- *  © 2020-2021 Harald Barth
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2024 Harald Barth
+ *  © 2020-2025 Chris Harlow
  *  All rights reserved.
  *  
  *  This file is part of CommandStation-EX
@@ -23,24 +23,28 @@
  */
 #ifndef DCCWaveform_h
 #define DCCWaveform_h
-
-#include "MotorDriver.h"
 #ifdef ARDUINO_ARCH_ESP32
 #include "DCCRMT.h"
-#include "TrackManager.h"
 #endif
 
 
 
 // Number of preamble bits.
-const int   PREAMBLE_BITS_MAIN = 16;
-const int   PREAMBLE_BITS_PROG = 22;
-const byte   MAX_PACKET_SIZE = 5;  // NMRA standard extended packets, payload size WITHOUT checksum.
+const byte PREAMBLE_BITS_MAIN = 16;
+const byte PREAMBLE_BITS_PROG = 22;
+const byte MAX_PACKET_SIZE = 5;     // NMRA standard extended packets, payload size WITHOUT checksum.
 
 
 // The WAVE_STATE enum is deliberately numbered because a change of order would be catastrophic
 // to the transform array.
-enum  WAVE_STATE : byte {WAVE_START=0,WAVE_MID_1=1,WAVE_HIGH_0=2,WAVE_MID_0=3,WAVE_LOW_0=4,WAVE_PENDING=5};
+enum  WAVE_STATE : byte {
+  WAVE_START=0,  // wave going high at start of bit 
+  WAVE_MID_1=1,  // middle of 1 bit 
+  WAVE_HIGH_0=2, // first part of 0 bit high
+  WAVE_MID_0=3,  // middle of 0 bit
+  WAVE_LOW_0=4,  // first part of 0 bit low
+  WAVE_PENDING=5 // next bit not yet known
+  };
 
 // NOTE: static functions are used for the overall controller, then
 // one instance is created for each track.
@@ -76,11 +80,37 @@ class DCCWaveform {
     };
 #endif
     void schedulePacket(const byte buffer[], byte byteCount, byte repeats);
-    bool getPacketPending();
-    
+    bool isReminderWindowOpen();
+    void promotePendingPacket();
+    static bool setRailcom(bool on, bool debug);
+    inline static bool isRailcom() {
+      return railcomActive;
+    };
+    inline static byte getRailcomCutoutCounter() {
+      return railcomCutoutCounter;
+    };
+    inline static bool isRailcomSampleWindow() {
+      return railcomSampleWindow;
+    };
+    inline static bool isRailcomPossible() {
+      return railcomPossible;
+    };
+    inline static void setRailcomPossible(bool yes) {
+      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;
+    volatile bool reminderWindowOpen;
     volatile byte sentResetsSincePacket;
 #else
     volatile uint32_t resetPacketBase;
@@ -101,6 +131,13 @@ class DCCWaveform {
     byte pendingPacket[MAX_PACKET_SIZE+1]; // +1 for checksum
     byte pendingLength;
     byte pendingRepeats;
+    static bool railcomPossible; // High accuracy mode only
+    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 volatile byte railcomLastAddressHigh,railcomLastAddressLow;
+    static bool cutoutNextTime;   // railcom
 #ifdef ARDUINO_ARCH_ESP32
   static RMTChannel *rmtMainChannel;
   static RMTChannel *rmtProgChannel;

DCCWaveformRMT.cpp

@@ -0,0 +1,120 @@
+/*
+ *  © 2021 Neil McKechnie
+ *  © 2021 Mike S
+ *  © 2021 Fred Decker
+ *  © 2020-2022 Harald Barth
+ *  © 2020-2021 Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+// This code is ESP32 ONLY.  
+#ifdef ARDUINO_ARCH_ESP32
+#include "DCCWaveform.h"
+#include "DCCACK.h"
+#include "TrackManager.h"
+
+DCCWaveform  DCCWaveform::mainTrack(PREAMBLE_BITS_MAIN, true);
+DCCWaveform  DCCWaveform::progTrack(PREAMBLE_BITS_PROG, false);
+RMTChannel *DCCWaveform::rmtMainChannel = NULL;
+RMTChannel *DCCWaveform::rmtProgChannel = NULL;
+
+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
+volatile byte DCCWaveform::railcomLastAddressHigh=0;
+volatile byte DCCWaveform::railcomLastAddressLow=0;
+
+DCCWaveform::DCCWaveform(byte preambleBits, bool isMain) {
+  isMainTrack = isMain;
+  requiredPreambles = preambleBits;
+}
+void DCCWaveform::begin() {
+  for(const auto& md: TrackManager::getMainDrivers()) {
+    pinpair p = md->getSignalPin();
+    if(rmtMainChannel) {
+      //DIAG(F("added pins %d %d to MAIN channel"), p.pin, p.invpin);
+      rmtMainChannel->addPin(p); // add pin to existing main channel
+    } else {
+      //DIAG(F("new MAIN channel with pins %d %d"), p.pin, p.invpin);
+      rmtMainChannel = new RMTChannel(p, true); /* create new main channel */
+    }
+  }
+  MotorDriver *md = TrackManager::getProgDriver();
+  if (md) {
+    pinpair p = md->getSignalPin();
+    if (rmtProgChannel) {
+      //DIAG(F("added pins %d %d to PROG channel"), p.pin, p.invpin);
+      rmtProgChannel->addPin(p); // add pin to existing prog channel
+    } else {
+      //DIAG(F("new PROGchannel with pins %d %d"), p.pin, p.invpin);
+      rmtProgChannel = new RMTChannel(p, false);
+    }
+  }
+}
+
+void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repeats) {
+  if (byteCount > MAX_PACKET_SIZE) return; // allow for chksum
+  RMTChannel *rmtchannel = (isMainTrack ? rmtMainChannel : rmtProgChannel);
+  if (rmtchannel == NULL)
+    return; // no idea to prepare packet if we can not send it anyway
+  
+  rmtchannel->waitForDataCopy(); // blocking wait so we can write into buffer
+  byte checksum = 0;
+  for (byte b = 0; b < byteCount; b++) {
+    checksum ^= buffer[b];
+    pendingPacket[b] = buffer[b];
+  }
+  // buffer is MAX_PACKET_SIZE but pendingPacket is one bigger
+  pendingPacket[byteCount] = checksum;
+  pendingLength = byteCount + 1;
+  pendingRepeats = repeats;
+// DIAG repeated commands (accesories)
+//  if (pendingRepeats > 0)
+//    DIAG(F("Repeats=%d on %s track"), pendingRepeats, isMainTrack ? "MAIN" : "PROG");
+  // The resets will be zero not only now but as well repeats packets into the future
+  clearResets(repeats+1);
+  {
+    int ret = 0;
+    do {
+      ret = rmtchannel->RMTfillData(pendingPacket, pendingLength, pendingRepeats);
+    } while(ret > 0);
+  }
+}
+
+bool DCCWaveform::isReminderWindowOpen() {
+  if(isMainTrack) {
+    if (rmtMainChannel == NULL)
+      return false;
+    return !rmtMainChannel->busy();
+  } else {
+    if (rmtProgChannel == NULL)
+      return false;
+    return !rmtProgChannel->busy();
+  }
+}
+void IRAM_ATTR DCCWaveform::loop() {
+  DCCACK::checkAck(progTrack.getResets());
+}
+
+bool DCCWaveform::setRailcom(bool on, bool debug) {
+  // TODO... ESP32 railcom waveform
+  return false;
+}
+
+#endif

Display.h

@@ -37,7 +37,9 @@
 class Display : public DisplayInterface {
 public:
   Display(DisplayDevice *deviceDriver);
+#if !defined (MAX_CHARACTER_ROWS)
   static const int MAX_CHARACTER_ROWS = 8;
+#endif
   static const int MAX_CHARACTER_COLS = MAX_MSG_SIZE;
   static const long DISPLAY_SCROLL_TIME = 3000;  // 3 seconds
 

Display_Implementation.h

@@ -54,7 +54,9 @@
     xxx;  \
     t->refresh();}
 #else
-  #define DISPLAY_START(xxx) {}
+  #define DISPLAY_START(xxx) { \
+  xxx; \
+  }
 
 #endif
 #endif // LCD_Implementation_h

EXRAIL.h

@@ -1,3 +1,23 @@
+/*
+ *  © 2021 Fred Decker
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
 #ifndef EXRAIL_H
 #define EXRAIL_H
 

EXRAIL2.h

@@ -1,8 +1,9 @@
 /*
  *  © 2021 Neil McKechnie
- *  © 2020-2022 Chris Harlow
+ *  © 2020-2025 Chris Harlow
  *  © 2022-2023 Colin Murdoch
  *  © 2023 Harald Barth
+ *  © 2025 Morten Nielsen
  *  All rights reserved.
  *  
  *  This file is part of CommandStation-EX
@@ -33,17 +34,20 @@
 // or more OPCODE_PAD instructions with the subsequent parameters. This wastes a byte but makes 
 // searching easier as a parameter can never be confused with an opcode. 
 // 
-enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,
+enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,OPCODE_TOGGLE_TURNOUT,
              OPCODE_FWD,OPCODE_REV,OPCODE_SPEED,OPCODE_INVERT_DIRECTION,
+             OPCODE_MOMENTUM,
              OPCODE_RESERVE,OPCODE_FREE,
              OPCODE_AT,OPCODE_AFTER,
              OPCODE_AFTEROVERLOAD,OPCODE_AUTOSTART,
              OPCODE_ATGTE,OPCODE_ATLT,
              OPCODE_ATTIMEOUT1,OPCODE_ATTIMEOUT2,
              OPCODE_LATCH,OPCODE_UNLATCH,OPCODE_SET,OPCODE_RESET,
+             OPCODE_BLINK,
              OPCODE_ENDIF,OPCODE_ELSE,
              OPCODE_DELAY,OPCODE_DELAYMINS,OPCODE_DELAYMS,OPCODE_RANDWAIT,
              OPCODE_FON,OPCODE_FOFF,OPCODE_XFON,OPCODE_XFOFF,
+             OPCODE_FTOGGLE,OPCODE_XFTOGGLE,OPCODE_XFWD,OPCODE_XREV,
              OPCODE_RED,OPCODE_GREEN,OPCODE_AMBER,OPCODE_DRIVE,
              OPCODE_SERVO,OPCODE_SIGNAL,OPCODE_TURNOUT,OPCODE_WAITFOR,
              OPCODE_PAD,OPCODE_FOLLOW,OPCODE_CALL,OPCODE_RETURN,
@@ -51,10 +55,10 @@ enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,
              OPCODE_JOIN,OPCODE_UNJOIN,OPCODE_READ_LOCO1,OPCODE_READ_LOCO2,
 #endif
              OPCODE_POM,
-             OPCODE_START,OPCODE_SETLOCO,OPCODE_SENDLOCO,OPCODE_FORGET,
+             OPCODE_START,OPCODE_SETLOCO,OPCODE_SETFREQ,OPCODE_SENDLOCO,OPCODE_FORGET,
              OPCODE_PAUSE, OPCODE_RESUME,OPCODE_POWEROFF,OPCODE_POWERON,
              OPCODE_ONCLOSE, OPCODE_ONTHROW, OPCODE_SERVOTURNOUT, OPCODE_PINTURNOUT,
-             OPCODE_PRINT,OPCODE_DCCACTIVATE,
+             OPCODE_PRINT,OPCODE_DCCACTIVATE,OPCODE_ASPECT,
              OPCODE_ONACTIVATE,OPCODE_ONDEACTIVATE,
              OPCODE_ROSTER,OPCODE_KILLALL,
              OPCODE_ROUTE,OPCODE_AUTOMATION,OPCODE_SEQUENCE,
@@ -64,13 +68,22 @@ enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,
              OPCODE_ONCHANGE,
              OPCODE_ONCLOCKTIME,
              OPCODE_ONTIME,
-#ifndef IO_NO_HAL
              OPCODE_TTADDPOSITION,OPCODE_DCCTURNTABLE,OPCODE_EXTTTURNTABLE,
-             OPCODE_ONROTATE,OPCODE_ROTATE,OPCODE_IFTTPOSITION,OPCODE_WAITFORTT,
-#endif
+             OPCODE_ONROTATE,OPCODE_ROTATE,OPCODE_WAITFORTT,
+             OPCODE_LCC,OPCODE_LCCX,OPCODE_ONLCC,
+             OPCODE_ACON, OPCODE_ACOF, 
+             OPCODE_ONACON, OPCODE_ONACOF, 
              OPCODE_ONOVERLOAD,
-
-             // OPcodes below this point are skip-nesting IF operations
+             OPCODE_ROUTE_ACTIVE,OPCODE_ROUTE_INACTIVE,OPCODE_ROUTE_HIDDEN,
+             OPCODE_ROUTE_DISABLED,
+             OPCODE_STASH,OPCODE_CLEAR_STASH,OPCODE_CLEAR_ALL_STASH,OPCODE_PICKUP_STASH,
+             OPCODE_CLEAR_ANY_STASH,
+             OPCODE_ONBUTTON,OPCODE_ONSENSOR,OPCODE_ONVP_SENSOR,
+             OPCODE_NEOPIXEL,
+             OPCODE_ONBLOCKENTER,OPCODE_ONBLOCKEXIT,
+             OPCODE_ESTOPALL,OPCODE_XPOM,
+             OPCODE_BITMAP_AND,OPCODE_BITMAP_OR,OPCODE_BITMAP_XOR,OPCODE_BITMAP_INC,OPCODE_BITMAP_DEC,OPCODE_ONBITMAP,
+              // OPcodes below this point are skip-nesting IF operations
              // placed here so that they may be skipped as a group
              // see skipIfBlock()
             IF_TYPE_OPCODES, // do not move this... 
@@ -81,7 +94,10 @@ enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,
              OPCODE_IFRANDOM,OPCODE_IFRESERVE,
              OPCODE_IFCLOSED,OPCODE_IFTHROWN,
              OPCODE_IFRE,
-             OPCODE_IFLOCO
+             OPCODE_IFLOCO,
+             OPCODE_IFTTPOSITION,
+             OPCODE_IFSTASH,
+             OPCODE_IFBITMAP_ALL,OPCODE_IFBITMAP_ANY,
              };
 
 // Ensure thrunge_lcd is put last as there may be more than one display, 
@@ -91,11 +107,45 @@ enum thrunger: byte {
   thrunge_serial,thrunge_parse,
   thrunge_serial1, thrunge_serial2, thrunge_serial3,
   thrunge_serial4, thrunge_serial5, thrunge_serial6,
-  thrunge_lcn, 
+  thrunge_lcn,thrunge_message,
   thrunge_lcd,  // Must be last!!
   };
 
 
+enum BlinkState: byte {
+    not_blink_task, 
+    blink_low, // blink task running with pin LOW
+    blink_high, // blink task running with pin high 
+    at_timeout  // ATTIMEOUT timed out flag
+    }; 
+enum SignalType {
+       sigtypeVIRTUAL,
+       sigtypeSIGNAL, 
+       sigtypeSIGNALH, 
+       sigtypeDCC,
+       sigtypeDCCX,
+       sigtypeSERVO,
+       sigtypeNEOPIXEL,
+       sigtypeContinuation,  // neopixels require a second line
+       sigtypeNoMoreSignals
+       }; 
+
+  struct SIGNAL_DEFINITION {
+       SignalType type;
+       VPIN id;  
+       VPIN  redpin,amberpin,greenpin; 
+  };
+
+  // Flag bits for compile time features.
+  static const byte FEATURE_SIGNAL= 0x80;
+  static const byte FEATURE_LCC   = 0x40;
+  static const byte FEATURE_ROSTER= 0x20;
+  static const byte FEATURE_ROUTESTATE= 0x10;
+  // spare = 0x08;
+  static const byte FEATURE_BLINK = 0x04;
+  static const byte FEATURE_SENSOR = 0x02;
+  static const byte FEATURE_BLOCK = 0x01;
+  
  
   // Flag bits for status of hardware and TPL
   static const byte SECTION_FLAG = 0x80;
@@ -115,21 +165,27 @@ enum thrunger: byte {
 class LookList {
   public: 
     LookList(int16_t size);
+    void chain(LookList* chainTo);
     void add(int16_t lookup, int16_t result);
-    int16_t find(int16_t value);
+    int16_t find(int16_t value); // finds result value
+    int16_t findPosition(int16_t value); // finds index 
+    int16_t size();
+    void stream(Print * _stream); 
+    void handleEvent(const FSH* reason,int16_t id, int16_t loco=0);
+
   private:
      int16_t m_size;
      int16_t m_loaded;
      int16_t * m_lookupArray;
-     int16_t * m_resultArray;     
+     int16_t * m_resultArray;
+     LookList* m_chain;     
 };
 
  class RMFT2 {
    public:
     static void begin();
     static void loop();
-    RMFT2(int progCounter);
-    RMFT2(int route, uint16_t cab);
+    RMFT2(int progCounter, int16_t cab=0);
     ~RMFT2();
     static void readLocoCallback(int16_t cv);
     static void createNewTask(int route, uint16_t cab);
@@ -139,11 +195,9 @@ class LookList {
     static void clockEvent(int16_t clocktime, bool change);
     static void rotateEvent(int16_t id, bool change);
     static void powerEvent(int16_t track, bool overload);
-    static const int16_t SERVO_SIGNAL_FLAG=0x4000;
-    static const int16_t ACTIVE_HIGH_SIGNAL_FLAG=0x2000;
-    static const int16_t DCC_SIGNAL_FLAG=0x1000;
-    static const int16_t SIGNAL_ID_MASK=0x0FFF;
- // Throttle Info Access functions built by exrail macros 
+    static void blockEvent(int16_t block, int16_t loco, bool entering);
+    static bool signalAspectEvent(int16_t address, byte aspect );    
+    // Throttle Info Access functions built by exrail macros 
   static const byte rosterNameCount;
   static const int16_t HIGHFLASH routeIdList[];
   static const int16_t HIGHFLASH automationIdList[];
@@ -155,7 +209,11 @@ class LookList {
   static const FSH *  getRosterFunctions(int16_t id);
   static const FSH *  getTurntableDescription(int16_t id);
   static const FSH *  getTurntablePositionDescription(int16_t turntableId, uint8_t positionId);
-    
+  static void startNonRecursiveTask(const FSH* reason, int16_t id,int pc, uint16_t loco=0);
+  static bool readSensor(uint16_t sensorId);
+  static bool isSignal(int16_t id,char rag);
+  static SIGNAL_DEFINITION getSignalSlot(int16_t slotno); 
+   
 private: 
     static void ComandFilter(Print * stream, byte & opcode, byte & paramCount, int16_t p[]);
     static bool parseSlash(Print * stream, byte & paramCount, int16_t p[]) ;
@@ -164,21 +222,17 @@ private:
     static bool getFlag(VPIN id,byte mask); 
     static int16_t progtrackLocoId;
     static void doSignal(int16_t id,char rag); 
-    static bool isSignal(int16_t id,char rag); 
-    static int16_t getSignalSlot(int16_t id);
     static void setTurnoutHiddenState(Turnout * t);
     #ifndef IO_NO_HAL
     static void setTurntableHiddenState(Turntable * tto);
     #endif
     static LookList* LookListLoader(OPCODE op1,
                       OPCODE op2=OPCODE_ENDEXRAIL,OPCODE op3=OPCODE_ENDEXRAIL);
-    static void handleEvent(const FSH* reason,LookList* handlers, int16_t id);
     static uint16_t getOperand(int progCounter,byte n);
+    static void killBlinkOnVpin(VPIN pin,uint16_t count=1);
     static RMFT2 * loopTask;
     static RMFT2 * pausingTask;
     void delayMe(long millisecs);
-    void driveLoco(byte speedo);
-    bool readSensor(uint16_t sensorId);
     bool skipIfBlock();
     bool readLoco();
     void loop2();
@@ -187,12 +241,16 @@ private:
     void printMessage2(const FSH * msg);
     void thrungeString(uint32_t strfar, thrunger mode, byte id=0);
     uint16_t getOperand(byte n); 
+    void pause();
+    void resume();
     
    static bool diag;
-   static const  HIGHFLASH  byte RouteCode[];
-   static const  HIGHFLASH  int16_t SignalDefinitions[];
+   static const  HIGHFLASH3  byte RouteCode[];
+   static const  HIGHFLASH  SIGNAL_DEFINITION SignalDefinitions[];
    static byte flags[MAX_FLAGS];
-   static LookList * sequenceLookup;
+   static Print * LCCSerial;
+   static LookList * routeLookup;
+   static LookList * signalLookup;
    static LookList * onThrowLookup;
    static LookList * onCloseLookup;
    static LookList * onActivateLookup;
@@ -206,6 +264,19 @@ private:
    static LookList * onRotateLookup;
 #endif
    static LookList * onOverloadLookup;
+   static LookList * onBlockEnterLookup;
+   static LookList * onBlockExitLookup;
+   
+   
+   static const int countLCCLookup;
+   static int onLCCLookup[];
+   static const byte compileFeatures;
+   static void manageRouteState(uint16_t id, byte state);
+   static void manageRouteCaption(uint16_t id, const FSH* caption);
+   static byte * routeStateArray;
+   static const FSH ** routeCaptionArray;
+   static int16_t * stashArray;
+   static int16_t maxStashId;
     
   // Local variables - exist for each instance/task 
     RMFT2 *next;   // loop chain 
@@ -215,16 +286,38 @@ private:
     union {
       unsigned long waitAfter; // Used by OPCODE_AFTER
       unsigned long timeoutStart; // Used by OPCODE_ATTIMEOUT
+      VPIN blinkPin;  // Used by blink tasks 
     };
-    bool timeoutFlag;
     byte  taskId;
-    
+    BlinkState blinkState; // includes AT_TIMEOUT flag. 
     uint16_t loco;
-    bool forward;
     bool invert;
-    byte speedo;
+    byte pauseSpeed;
     int onEventStartPosition;
     byte stackDepth;
     int callStack[MAX_STACK_DEPTH];
 };
+
+#define GET_OPCODE GETHIGHFLASH(RMFT2::RouteCode,progCounter)
+#define SKIPOP progCounter+=3
+
+// IO_I2CDFPlayer commands and values
+enum  : uint8_t{
+    DF_PLAY          = 0x0F,
+    DF_VOL           = 0x06,
+    DF_FOLDER        = 0x2B, // Not a DFPlayer command, used to set folder nr where audio file is
+    DF_REPEATPLAY    = 0x08,
+    DF_STOPPLAY      = 0x16,
+    DF_EQ            = 0x07, // Set equaliser, require parameter NORMAL, POP, ROCK, JAZZ, CLASSIC or BASS
+    DF_RESET         = 0x0C,
+    DF_DACON         = 0x1A,
+    DF_SETAM         = 0x2A, // Set audio mixer 1 or 2 for this DFPLayer   
+    DF_NORMAL        = 0x00, // Equalizer parameters
+    DF_POP           = 0x01,
+    DF_ROCK          = 0x02,
+    DF_JAZZ          = 0x03,
+    DF_CLASSIC       = 0x04,
+    DF_BASS          = 0x05,
+  };
+
 #endif

EXRAIL2Parser.cpp

@@ -0,0 +1,342 @@
+/*
+ *  © 2021 Neil McKechnie
+ *  © 2021-2023 Harald Barth
+ *  © 2020-2025 Chris Harlow
+ *  © 2022-2023 Colin Murdoch
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// THIS file is an extension of the RMFT2 class 
+//  normally found in EXRAIL2.cpp
+
+#include <Arduino.h>
+#include "defines.h"
+#include "EXRAIL2.h"
+#include "DCC.h"
+#include "KeywordHasher.h"
+
+// This filter intercepts <> commands to do the following:
+// - Implement RMFT specific commands/diagnostics
+// - Reject/modify JMRI commands that would interfere with RMFT processing
+
+void RMFT2::ComandFilter(Print * stream, byte & opcode, byte & paramCount, int16_t p[]) {
+  (void)stream; // avoid compiler warning if we don't access this parameter
+  
+  switch(opcode) {
+    
+  case 'D':
+    if (p[0]=="EXRAIL"_hk) { // <D EXRAIL ON/OFF>
+      diag = paramCount==2 && (p[1]=="ON"_hk || p[1]==1);
+      opcode=0;
+    }
+    break;
+	
+  case '/':  // New EXRAIL command
+    if (parseSlash(stream,paramCount,p)) opcode=0;
+    break;
+  
+  case 'A': //  <A address aspect>
+    if (paramCount!=2) break; 
+    // Ask exrail if this is just changing the aspect on a 
+    // predefined DCCX_SIGNAL. Because this will handle all 
+    // the IFRED and ONRED type issues at the same time.  
+    if (signalAspectEvent(p[0],p[1])) opcode=0; // all done 
+    break;
+
+  case 'L':
+    // This entire code block is compiled out if LLC macros not used 
+    if (!(compileFeatures & FEATURE_LCC)) return;
+    static int lccProgCounter=0;
+    static int lccEventIndex=0;
+      
+    if (paramCount==0) {  //<L>  LCC adapter introducing self
+      LCCSerial=stream;   // now we know where to send events we raise
+      opcode=0;  // flag command as intercepted
+
+      // loop through all possible sent/waited events 
+      for (int progCounter=lccProgCounter;; SKIPOP) {
+        byte exrailOpcode=GET_OPCODE;
+        switch (exrailOpcode) {
+          case OPCODE_ENDEXRAIL:
+               stream->print(F("<LR>\n")); // ready to roll
+               lccProgCounter=0; // allow a second pass
+               lccEventIndex=0;
+               return;
+
+          case OPCODE_LCC:  
+               StringFormatter::send(stream,F("<LS x%h>\n"),getOperand(progCounter,0));
+               SKIPOP;
+               lccProgCounter=progCounter; 
+               return;
+
+          case OPCODE_LCCX:  // long form LCC
+               StringFormatter::send(stream,F("<LS x%h%h%h%h>\n"),
+                 getOperand(progCounter,1),
+                 getOperand(progCounter,2),
+                 getOperand(progCounter,3),
+                 getOperand(progCounter,0)
+                 );
+               SKIPOP;SKIPOP;SKIPOP;SKIPOP;          
+               lccProgCounter=progCounter; 
+               return;
+
+          case OPCODE_ACON:  // CBUS ACON 
+          case OPCODE_ACOF:  // CBUS ACOF 
+                StringFormatter::send(stream,F("<LS x%c%h%h>\n"),
+                  exrailOpcode==OPCODE_ACOF?'1':'0',
+                  getOperand(progCounter,0),getOperand(progCounter,1)); 
+               SKIPOP;SKIPOP;
+               lccProgCounter=progCounter; 
+               return;
+      
+      // we stream the hex events we wish to listen to
+      // and at the same time build the event index looku.
+      
+        case OPCODE_ONLCC:
+           StringFormatter::send(stream,F("<LL %d x%h%h%h:%h>\n"),
+                 lccEventIndex,
+                 getOperand(progCounter,1),
+                 getOperand(progCounter,2),
+                 getOperand(progCounter,3),
+                 getOperand(progCounter,0)
+                 );   
+           SKIPOP;SKIPOP;SKIPOP;SKIPOP;      
+           // start on handler at next      
+           onLCCLookup[lccEventIndex]=progCounter; 
+           lccEventIndex++;        
+           lccProgCounter=progCounter; 
+           return;
+
+        case OPCODE_ONACON:
+        case OPCODE_ONACOF:
+           StringFormatter::send(stream,F("<LL %d x%c%h%h>\n"),
+                 lccEventIndex,
+                 exrailOpcode==OPCODE_ONACOF?'1':'0',
+                 getOperand(progCounter,0),getOperand(progCounter,1)
+                 ); 
+           SKIPOP;SKIPOP;
+           // start on handler at next      
+           onLCCLookup[lccEventIndex]=progCounter; 
+           lccEventIndex++;        
+           lccProgCounter=progCounter; 
+           return;
+           
+         default:
+           break;
+        }  
+      }
+    }
+    if (paramCount==1) {  // <L eventid> LCC event arrived from adapter
+        int16_t eventid=p[0];
+        bool reject = eventid<0 || eventid>=countLCCLookup;
+        if (!reject) {
+          startNonRecursiveTask(F("LCC"),eventid,onLCCLookup[eventid]);
+          opcode=0;
+        }
+    }
+    break; 
+    
+    case 'J':  // throttle info commands
+        if (paramCount<1) return; 
+        switch(p[0]) {
+          case "A"_hk: // <JA> returns automations/routes
+            if (paramCount==1) {// <JA>
+              StringFormatter::send(stream, F("<jA"));
+              routeLookup->stream(stream);
+              StringFormatter::send(stream, F(">\n"));
+              opcode=0;
+              return; 
+            }
+            if (paramCount==2) {  // <JA id>
+              int16_t id=p[1];
+              StringFormatter::send(stream,F("<jA %d %c \"%S\">\n"), 
+                id, getRouteType(id), getRouteDescription(id));
+              
+              if (compileFeatures & FEATURE_ROUTESTATE) {
+                // Send any non-default button states or captions
+                int16_t statePos=routeLookup->findPosition(id);
+                if (statePos>=0) {
+                 if (routeStateArray[statePos]) 
+                 StringFormatter::send(stream,F("<jB %d %d>\n"), id, routeStateArray[statePos]);
+                  if (routeCaptionArray[statePos]) 
+                  StringFormatter::send(stream,F("<jB %d \"%S\">\n"), id,routeCaptionArray[statePos]);
+                }
+              }
+              opcode=0;
+              return;
+            }
+            break;
+        
+
+  case 'K': // <K blockid loco>  Block enter
+  case 'k': // <k blockid loco>  Block exit
+        if (paramCount!=2) break;
+        blockEvent(p[0],p[1],opcode=='K');
+        opcode=0;
+        break; 
+  
+  default:  // other commands pass through
+    break;
+  }
+}
+}
+
+bool RMFT2::parseSlash(Print * stream, byte & paramCount, int16_t p[]) {
+
+  if (paramCount==0) { // STATUS
+    StringFormatter::send(stream, F("<* EXRAIL STATUS"));
+    RMFT2 * task=loopTask;
+    while(task) {
+      if ((compileFeatures & FEATURE_BLINK)
+       && (task->blinkState==blink_high || task->blinkState==blink_low)) {
+        StringFormatter::send(stream,F("\nID=%d,PC=%d,BLINK=%d"),
+			    (int)(task->taskId),task->progCounter,task->blinkPin
+			    );
+      }
+      else {
+      StringFormatter::send(stream,F("\nID=%d,PC=%d,LOCO=%d %c"),
+			    (int)(task->taskId),task->progCounter,task->loco,
+			    task->invert?'I':' '
+			    );
+      }
+      task=task->next;
+      if (task==loopTask) break;
+    }
+    // Now stream the flags
+    for (int id=0;id<MAX_FLAGS; id++) {
+      byte flag=flags[id];
+      if (flag & ~TASK_FLAG & ~SIGNAL_MASK) { // not interested in TASK_FLAG only. Already shown above
+	      StringFormatter::send(stream,F("\nflags[%d] "),id);
+	      if (flag & SECTION_FLAG) StringFormatter::send(stream,F(" RESERVED"));
+	      if (flag & LATCH_FLAG) StringFormatter::send(stream,F(" LATCHED"));
+      }
+    }
+
+    if (compileFeatures & FEATURE_SIGNAL) {
+      // do the signals
+      // flags[n] represents the state of the nth signal in the table 
+      for (int sigslot=0;;sigslot++) {
+        SIGNAL_DEFINITION slot=getSignalSlot(sigslot);
+        if (slot.type==sigtypeNoMoreSignals) break; // end of signal list
+	      if (slot.type==sigtypeContinuation) continue; // continueation of previous line
+	      byte flag=flags[sigslot] & SIGNAL_MASK; // obtain signal flags for this ids
+        StringFormatter::send(stream,F("\n%S[%d]"), 
+			      (flag == SIGNAL_RED)? F("RED") : (flag==SIGNAL_GREEN) ? F("GREEN") : F("AMBER"),
+			      slot.id);
+      } 
+    }
+    StringFormatter::send(stream,F(" *>\n"));
+    return true;
+  }
+  switch (p[0]) {
+  case "PAUSE"_hk: // </ PAUSE>
+    if (paramCount!=1) return false;
+    { // pause all tasks 
+      RMFT2 * task=loopTask;
+      while(task) {
+	      task->pause();
+	      task=task->next;
+	      if (task==loopTask) break;
+      }
+    }
+    DCC::estopAll();  // pause all locos on the track
+    pausingTask=(RMFT2 *)1; // Impossible task address
+    return true;
+    
+  case "RESUME"_hk: // </ RESUME>
+    if (paramCount!=1) return false;
+    pausingTask=NULL;
+    { // resume all tasks
+      RMFT2 * task=loopTask;
+      while(task) {
+	      task->resume();
+	      task=task->next;
+	      if (task==loopTask) break;
+      }
+    }
+    return true;
+    
+    
+  case "START"_hk: // </ START [cab] route >
+    if (paramCount<2 || paramCount>3) return false;
+    {
+      int route=(paramCount==2) ? p[1] : p[2];
+      uint16_t cab=(paramCount==2)? 0 : p[1];
+      int pc=routeLookup->find(route);
+      if (pc<0) return false;
+      new RMFT2(pc,cab);
+    }
+    return true;
+    
+  default:
+    break;
+  }
+
+  // check KILL ALL here, otherwise the next validation confuses ALL with a flag  
+  if (p[0]=="KILL"_hk && p[1]=="ALL"_hk) {
+    while (loopTask) loopTask->kill(F("KILL ALL")); // destructor changes loopTask
+    return true;   
+  }
+
+  // all other / commands take 1 parameter
+  if (paramCount!=2 ) return false;
+  
+  switch (p[0]) {
+  case "KILL"_hk: // Kill taskid|ALL
+    {
+    if ( p[1]<0  || p[1]>=MAX_FLAGS) return false;
+    RMFT2 * task=loopTask;
+      while(task) {
+	      if (task->taskId==p[1]) {
+	        task->kill(F("KILL"));
+	        return  true;
+	      }
+	      task=task->next;
+	      if (task==loopTask) break;
+      }
+    }
+    return false;
+    
+  case "RESERVE"_hk:  // force reserve a section
+    return setFlag(p[1],SECTION_FLAG);
+    
+  case "FREE"_hk:  // force free a section
+    return setFlag(p[1],0,SECTION_FLAG);
+    
+  case "LATCH"_hk:
+    return setFlag(p[1], LATCH_FLAG);
+    
+  case "UNLATCH"_hk:
+    return setFlag(p[1], 0, LATCH_FLAG);
+ 
+  case "RED"_hk:
+    doSignal(p[1],SIGNAL_RED);
+    return true;
+ 
+  case "AMBER"_hk:
+    doSignal(p[1],SIGNAL_AMBER);
+    return true;
+ 
+  case "GREEN"_hk:
+    doSignal(p[1],SIGNAL_GREEN);
+    return true;
+    
+  default:
+    return false;
+  }
+}

EXRAILAsserts.h

@@ -0,0 +1,165 @@
+/*
+ *  © 2020-2025 Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// This file checks the myAutomation for errors by generating a list of compile time asserts.
+
+// Assert Pass 1 Collect sequence numbers.
+#include "EXRAIL2MacroReset.h"
+#undef AUTOMATION
+#define AUTOMATION(id, description) id,
+#undef ROUTE
+#define ROUTE(id, description) id,
+#undef SEQUENCE
+#define SEQUENCE(id) id,
+constexpr int16_t compileTimeSequenceList[]={
+   #include "myAutomation.h"
+   0
+   };
+constexpr int16_t stuffSize=sizeof(compileTimeSequenceList)/sizeof(int16_t) - 1;
+
+
+// Compile time function to check for sequence number duplication
+constexpr int16_t seqCount(const int16_t value, const int16_t pos=0, const int16_t count=0 ) {
+   return pos>=stuffSize? count :
+             seqCount(value,pos+1,count+((compileTimeSequenceList[pos]==value)?1:0));
+}
+
+
+// Build a compile time blacklist of pin numbers. 
+// Includes those defined in defaults.h for the cpu (PIN_BLACKLIST)
+// and cheats in the motor shield pins from config.h (MOTOR_SHIELD_TYPE)
+// for reference the MotorDriver constructor is:
+// MotorDriver(byte power_pin, byte signal_pin, byte signal_pin2, int8_t brake_pin, byte current_pin,
+//             float senseFactor, unsigned int tripMilliamps, byte faultPin);
+
+// create capture macros to reinterpret MOTOR_SHIELD_TYPE from configuration
+#define new
+#define MotorDriver(power_pin,signal_pin,signal_pin2, \
+   brake_pin,current_pin,senseFactor,tripMilliamps,faultPin) \
+   abs(power_pin),abs(signal_pin),abs(signal_pin2),abs(brake_pin),abs(current_pin),abs(faultPin)
+#ifndef PIN_BLACKLIST 
+  #define PIN_BLACKLIST UNUSED_PIN
+#endif 
+#define MDFURKLE(stuff) MDFURKLE2(stuff)
+#define MDFURKLE2(description,...) REMOVE_TRAILING_COMMA(__VA_ARGS__)
+#define REMOVE_TRAILING_COMMA(...) __VA_ARGS__
+
+
+constexpr int16_t compileTimePinBlackList[]={
+   PIN_BLACKLIST, MDFURKLE(MOTOR_SHIELD_TYPE)
+   };
+constexpr int16_t pbSize=sizeof(compileTimePinBlackList)/sizeof(int16_t) - 1;
+
+
+// remove capture macros
+#undef new
+#undef MotorDriver
+
+// Compile time function to check for dangerous pins.
+constexpr bool unsafePin(const int16_t value, const uint16_t pos=0 ) {
+   return pos>=pbSize? false :
+      compileTimePinBlackList[pos]==value 
+      || unsafePin(value,pos+1); 
+}
+
+
+//pass 2 apply static asserts:
+// check call and follows etc for existing sequence numbers
+// check sequence numbers for duplicates
+// check range on LATCH/UNLATCH
+// check range on RESERVE/FREE
+// check range on SPEED/FWD/REV
+// check range on SET/RESET   (pins that are not safe to use in EXRAIL)
+// 
+// This pass generates no runtime data or code 
+#include "EXRAIL2MacroReset.h"
+#undef ASPECT
+#define ASPECT(address,value) static_assert(address <=2044, "invalid Address"); \
+                              static_assert(address>=-3, "Invalid value");
+
+// check references to sequences/routes/automations
+#undef CALL
+#define CALL(id) static_assert(seqCount(id)>0,"Sequence  not found");
+#undef FOLLOW
+#define FOLLOW(id)  static_assert(seqCount(id)>0,"Sequence not found");
+#undef START
+#define START(id)  static_assert(seqCount(id)>0,"Sequence not found");
+#undef SENDLOCO
+#define SENDLOCO(cab,id) static_assert(seqCount(id)>0,"Sequence not found");
+#undef ROUTE_ACTIVE
+#define ROUTE_ACTIVE(id)  static_assert(seqCount(id)>0,"Route not found");
+#undef ROUTE_INACTIVE
+#define ROUTE_INACTIVE(id)  static_assert(seqCount(id)>0,"Route not found");
+#undef ROUTE_HIDDEN
+#define ROUTE_HIDDEN(id)  static_assert(seqCount(id)>0,"Route not found");
+#undef ROUTE_DISABLED
+#define ROUTE_DISABLED(id)  static_assert(seqCount(id)>0,"Route not found");
+#undef ROUTE_CAPTION 
+#define ROUTE_CAPTION(id,caption) static_assert(seqCount(id)>0,"Route not found");
+
+
+#undef LATCH
+#define LATCH(id) static_assert(id>=0 && id<MAX_FLAGS,"Id out of valid range 0-255" );
+#undef UNLATCH
+#define UNLATCH(id) static_assert(id>=0 && id<MAX_FLAGS,"Id out of valid range 0-255" );
+#undef RESERVE
+#define RESERVE(id) static_assert(id>=0 && id<MAX_FLAGS,"Id out of valid range 0-255" );
+#undef FREE
+#define FREE(id) static_assert(id>=0 && id<MAX_FLAGS,"Id out of valid range 0-255" );
+#undef IFRESERVE
+#define IFRESERVE(id) static_assert(id>=0 && id<MAX_FLAGS,"Id out of valid range 0-255" );
+
+//check speeds
+#undef SPEED
+#define SPEED(speed) static_assert(speed>=0 && speed<128,"\n\nUSER ERROR: Speed out of valid range 0-127\n");
+#undef FWD
+#define FWD(speed) static_assert(speed>=0 && speed<128,"\n\nUSER ERROR: Speed out of valid range 0-127\n");
+#undef REV
+#define REV(speed) static_assert(speed>=0 && speed<128,"\n\nUSER ERROR: Speed out of valid range 0-127\n");
+
+// check duplicate sequences
+#undef SEQUENCE
+#define SEQUENCE(id) static_assert(seqCount(id)==1,"\n\nUSER ERROR: Duplicate ROUTE/AUTOMATION/SEQUENCE(" #id ")\n");
+#undef AUTOMATION
+#define AUTOMATION(id,description) static_assert(seqCount(id)==1,"\n\nUSER ERROR: Duplicate ROUTE/AUTOMATION/SEQUENCE(" #id ")\n");
+#undef ROUTE
+#define ROUTE(id,description) static_assert(seqCount(id)==1,"\n\nUSER ERROR: Duplicate ROUTE/AUTOMATION/SEQUENCE(" #id ")\n");
+
+// check dangerous pins
+#define _PIN_RESERVED_ "\n\nUSER ERROR: Pin is used by Motor Shield or other critical function.\n"
+#undef SET
+#define SET(vpin, ...) static_assert(!unsafePin(vpin),"SET(" #vpin ")" _PIN_RESERVED_);
+#undef RESET
+#define RESET(vpin,...) static_assert(!unsafePin(vpin),"RESET(" #vpin ")" _PIN_RESERVED_);
+#undef BLINK
+#define BLINK(vpin,onDuty,offDuty) static_assert(!unsafePin(vpin),"BLINK(" #vpin ")" _PIN_RESERVED_);
+#undef SIGNAL
+#define SIGNAL(redpin,amberpin,greenpin) \
+      static_assert(!unsafePin(redpin),"Red pin " #redpin _PIN_RESERVED_); \
+      static_assert(amberpin==0 ||!unsafePin(amberpin),"Amber pin " #amberpin _PIN_RESERVED_); \
+      static_assert(!unsafePin(greenpin),"Green pin " #greenpin _PIN_RESERVED_); 
+#undef SIGNALH
+#define SIGNALH(redpin,amberpin,greenpin) \
+      static_assert(!unsafePin(redpin),"Red pin " #redpin _PIN_RESERVED_); \
+      static_assert(amberpin==0 ||!unsafePin(amberpin),"Amber pin " #amberpin _PIN_RESERVED_); \
+      static_assert(!unsafePin(greenpin),"Green pin " #greenpin _PIN_RESERVED_); 
+
+// and run the assert pass.       
+#include "myAutomation.h"

EXRAILMacros.h

@@ -1,8 +1,9 @@
 /*
  *  © 2021 Neil McKechnie
- *  © 2020-2022 Chris Harlow
+ *  © 2020-2025 Chris Harlow
  *  © 2022-2023 Colin Murdoch
  *  © 2023 Harald Barth
+ *  © 2025 Morten Nielsen
  *  All rights reserved.
  *  
  *  This file is part of CommandStation-EX
@@ -23,6 +24,7 @@
 
 #ifndef EXRAILMacros_H
 #define EXRAILMacros_H
+#include "IODeviceList.h"
 
 // remove normal code LCD & SERIAL macros (will be restored later)
 #undef LCD
@@ -59,6 +61,14 @@
 // helper macro for turnout description as HIDDEN 
 #define HIDDEN "\x01"
 
+// PLAYSOUND is alias of ANOUT to make the user experience of a Conductor beter for
+// playing sounds with IO_I2CDFPlayer
+#define PLAYSOUND ANOUT
+
+// SEG7 is a helper to create ANOUT from a 7-segment request
+#define SEG7(vpin,value,format) \
+   ANOUT(vpin,(value & 0xFFFF),TM1638::DF_##format,((uint32_t)value)>>16)
+
 // helper macro to strip leading zeros off time inputs
 // (10#mins)%100)
 #define STRIP_ZERO(value) 10##value%100
@@ -67,11 +77,22 @@
 //const byte TRACK_POWER_0=0, TRACK_POWER_OFF=0;    
 //const byte TRACK_POWER_1=1, TRACK_POWER_ON=1;   
 
+// NEOPIXEL RG generator for NEOPIXEL_SIGNAL 
+#define NeoRGB(red,green,blue) (((uint32_t)(red & 0xff)<<16) | ((uint32_t)(green & 0xff)<<8) | (uint32_t)(blue & 0xff))  
 
 // Pass 1 Implements aliases 
 #include "EXRAIL2MacroReset.h"
 #undef ALIAS
-#define ALIAS(name,value...) const int name= 1##value##0 ==10 ? -__COUNTER__  : value##0/10; 
+#define ALIAS(name,value...) const int name= #value[0] ? value+0: -__COUNTER__ ; 
+#include "myAutomation.h"
+
+// Perform compile time asserts to check the script for errors
+#include "EXRAILAsserts.h"
+
+// Pass 1g Implants STEALTH_GLOBAL in correct place 
+#include "EXRAIL2MacroReset.h"
+#undef STEALTH_GLOBAL
+#define STEALTH_GLOBAL(code...) code
 #include "myAutomation.h"
 
 // Pass 1h Implements HAL macro by creating exrailHalSetup function
@@ -79,17 +100,82 @@
 #include "EXRAIL2MacroReset.h"
 #undef HAL
 #define HAL(haltype,params...)  haltype::create(params);
-#undef EXTT_TURNTABLE
-#define EXTT_TURNTABLE(id,vpin,i2c_address,home,description...) EXTurntable::create(vpin,1,i2c_address);
-void exrailHalSetup() {
+#undef HAL_IGNORE_DEFAULTS
+#define HAL_IGNORE_DEFAULTS ignore_defaults=true;
+#undef JMRI_SENSOR
+#define JMRI_SENSOR(vpin,count...) Sensor::createMultiple(vpin,##count);
+#undef  CONFIGURE_SERVO
+#define CONFIGURE_SERVO(vpin,pos1,pos2,profile) IODevice::configureServo(vpin,pos1,pos2,PCA9685::profile);
+bool exrailHalSetup() {
+   bool ignore_defaults=false;
    #include "myAutomation.h"
+   return ignore_defaults;
 }
 
+// Pass 1c detect compile time featurtes
+#include "EXRAIL2MacroReset.h"
+#undef SIGNAL
+#define SIGNAL(redpin,amberpin,greenpin) | FEATURE_SIGNAL 
+#undef SIGNALH
+#define SIGNALH(redpin,amberpin,greenpin) | FEATURE_SIGNAL 
+#undef SERVO_SIGNAL
+#define SERVO_SIGNAL(vpin,redval,amberval,greenval) | FEATURE_SIGNAL 
+#undef DCC_SIGNAL
+#define DCC_SIGNAL(id,addr,subaddr) | FEATURE_SIGNAL
+#undef DCCX_SIGNAL
+#define DCCX_SIGNAL(id,redAspect,amberAspect,greenAspect) | FEATURE_SIGNAL
+#undef NEOPIXEL_SIGNAL
+#define NEOPIXEL_SIGNAL(sigid,redcolour,ambercolour,greencolour) | FEATURE_SIGNAL
+#undef VIRTUAL_SIGNAL
+#define VIRTUAL_SIGNAL(id) | FEATURE_SIGNAL
+
+#undef LCC
+#define LCC(eventid)  | FEATURE_LCC
+#undef LCCX
+#define LCCX(senderid,eventid) | FEATURE_LCC 
+#undef ONLCC
+#define ONLCC(senderid,eventid) | FEATURE_LCC
+#undef ACON
+#define ACON(eventid) | FEATURE_LCC
+#undef ACOF
+#define ACOF(eventid) | FEATURE_LCC
+#undef ONACON
+#define ONACON(eventid) | FEATURE_LCC
+#undef ONACOF
+#define ONACOF(eventid) | FEATURE_LCC
+#undef ROUTE_ACTIVE
+#define ROUTE_ACTIVE(id) | FEATURE_ROUTESTATE
+#undef ROUTE_INACTIVE
+#define ROUTE_INACTIVE(id) | FEATURE_ROUTESTATE
+#undef ROUTE_HIDDEN
+#define ROUTE_HIDDEN(id) | FEATURE_ROUTESTATE
+#undef ROUTE_DISABLED
+#define ROUTE_DISABLED(id) | FEATURE_ROUTESTATE
+#undef ROUTE_CAPTION
+#define ROUTE_CAPTION(id,caption) | FEATURE_ROUTESTATE
+
+#undef BLINK
+#define BLINK(vpin,onDuty,offDuty) | FEATURE_BLINK
+#undef ONBUTTON
+#define ONBUTTON(vpin) | FEATURE_SENSOR
+#undef ONSENSOR
+#define ONSENSOR(vpin) | FEATURE_SENSOR
+#undef ONBITMAP
+#define ONBITMAP(vpin) | FEATURE_SENSOR
+#undef ONBLOCKENTER
+#define ONBLOCKENTER(blockid) | FEATURE_BLOCK
+#undef ONBLOCKEXIT
+#define ONBLOCKEXIT(blockid) | FEATURE_BLOCK
+
+const byte RMFT2::compileFeatures = 0
+   #include "myAutomation.h"
+;
+
 // Pass 2 create throttle route list 
 #include "EXRAIL2MacroReset.h"
 #undef ROUTE
 #define ROUTE(id, description) id,
-const int16_t HIGHFLASH RMFT2::routeIdList[]= {
+const int16_t HIGHFLASH  RMFT2::routeIdList[]= {
     #include "myAutomation.h"
     INT16_MAX};
 // Pass 2a create throttle automation list 
@@ -131,6 +217,15 @@ const int StringMacroTracker1=__COUNTER__;
 #define PRINT(msg) THRUNGE(msg,thrunge_print)
 #undef LCN
 #define LCN(msg)   THRUNGE(msg,thrunge_lcn)
+#undef MESSAGE
+#define MESSAGE(msg) THRUNGE(msg,thrunge_message)
+
+#undef ROUTE_CAPTION
+#define ROUTE_CAPTION(id,caption) \
+case (__COUNTER__ - StringMacroTracker1) : {\
+   manageRouteCaption(id,F(caption));\
+   return;\
+   }
 #undef SERIAL
 #define SERIAL(msg)   THRUNGE(msg,thrunge_serial)
 #undef SERIAL1
@@ -163,6 +258,8 @@ const int StringMacroTracker1=__COUNTER__;
          lcdid=id;\
          break;\
       } 
+#undef STEALTH
+#define STEALTH(code...) case (__COUNTER__ - StringMacroTracker1) : {code} return; 
 #undef WITHROTTLE
 #define WITHROTTLE(msg) THRUNGE(msg,thrunge_withrottle)
 
@@ -182,6 +279,8 @@ void  RMFT2::printMessage(uint16_t id) {
 #include "EXRAIL2MacroReset.h"
 #undef TURNOUT
 #define TURNOUT(id,addr,subaddr,description...) O_DESC(id,description)
+#undef TURNOUTL
+#define TURNOUTL(id,addr,description...) O_DESC(id,description)
 #undef PIN_TURNOUT
 #define PIN_TURNOUT(id,pin,description...) O_DESC(id,description)
 #undef SERVO_TURNOUT
@@ -202,7 +301,7 @@ const FSH * RMFT2::getTurnoutDescription(int16_t turnoutid) {
 #undef DCC_TURNTABLE
 #define DCC_TURNTABLE(id,home,description...) O_DESC(id,description)
 #undef EXTT_TURNTABLE
-#define EXTT_TURNTABLE(id,vpin,i2c_address,home,description...) O_DESC(id,description)
+#define EXTT_TURNTABLE(id,vpin,home,description...) O_DESC(id,description)
 
 const FSH * RMFT2::getTurntableDescription(int16_t turntableId) {
    switch (turntableId) {
@@ -218,6 +317,8 @@ const FSH * RMFT2::getTurntableDescription(int16_t turntableId) {
 #define TT_ADDPOSITION(turntable_id,position,value,home,description...) T_DESC(turntable_id,position,description)
 
 const FSH * RMFT2::getTurntablePositionDescription(int16_t turntableId, uint8_t positionId) {
+  (void)turntableId;
+  (void)positionId;
    #include "myAutomation.h"
    return NULL;
 }
@@ -264,19 +365,40 @@ const FSH * RMFT2::getRosterFunctions(int16_t id) {
 // Pass 8 Signal definitions
 #include "EXRAIL2MacroReset.h"
 #undef SIGNAL
-#define SIGNAL(redpin,amberpin,greenpin) redpin,redpin,amberpin,greenpin, 
+#define SIGNAL(redpin,amberpin,greenpin) {sigtypeSIGNAL,redpin,redpin,amberpin,greenpin}, 
 #undef SIGNALH
-#define SIGNALH(redpin,amberpin,greenpin) redpin | RMFT2::ACTIVE_HIGH_SIGNAL_FLAG,redpin,amberpin,greenpin, 
+#define SIGNALH(redpin,amberpin,greenpin) {sigtypeSIGNALH,redpin,redpin,amberpin,greenpin}, 
 #undef SERVO_SIGNAL
-#define SERVO_SIGNAL(vpin,redval,amberval,greenval) vpin | RMFT2::SERVO_SIGNAL_FLAG,redval,amberval,greenval, 
+#define SERVO_SIGNAL(vpin,redval,amberval,greenval) {sigtypeSERVO,vpin,redval,amberval,greenval}, 
 #undef DCC_SIGNAL
-#define DCC_SIGNAL(id,addr,subaddr) id | RMFT2::DCC_SIGNAL_FLAG,addr,subaddr,0,
+#define DCC_SIGNAL(id,addr,subaddr) {sigtypeDCC,id,addr,subaddr,0},
+#undef DCCX_SIGNAL
+#define DCCX_SIGNAL(id,redAspect,amberAspect,greenAspect) {sigtypeDCCX,id,redAspect,amberAspect,greenAspect},
+#undef NEOPIXEL_SIGNAL
+#define NEOPIXEL_SIGNAL(id,redRGB,amberRGB,greenRGB) \
+        {sigtypeNEOPIXEL,id,((VPIN)((redRGB)>>8)), ((VPIN)((amberRGB)>>8)), ((VPIN)((greenRGB)>>8))},\
+        {sigtypeContinuation,id,((VPIN)((redRGB) & 0xff)), ((VPIN)((amberRGB) & 0xFF)), ((VPIN)((greenRGB) & 0xFF))},
 #undef VIRTUAL_SIGNAL
-#define VIRTUAL_SIGNAL(id) id,0,0,0,
+#define VIRTUAL_SIGNAL(id) {sigtypeVIRTUAL,id,0,0,0},
 
-const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
+const  HIGHFLASH  SIGNAL_DEFINITION RMFT2::SignalDefinitions[] = {
     #include "myAutomation.h"
-    0,0,0,0 };
+     {sigtypeNoMoreSignals,0,0,0,0}
+    };
+
+// Pass 9 ONLCC/ ONMERG counter and lookup array
+#include "EXRAIL2MacroReset.h"
+#undef ONLCC
+#define ONLCC(sender,event) +1 
+#undef ONACON
+#define ONACON(event) +1 
+#undef ONACOF
+#define ONACOF(event) +1 
+
+const int RMFT2::countLCCLookup=0
+#include "myAutomation.h"
+;
+int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
 
 // Last Pass : create main routes table
 // Only undef the macros, not dummy them.  
@@ -290,20 +412,26 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 
 #define ACTIVATE(addr,subaddr) OPCODE_DCCACTIVATE,V(addr<<3 | subaddr<<1 | 1),
 #define ACTIVATEL(addr) OPCODE_DCCACTIVATE,V((addr+3)<<1 | 1),
-#define AFTER(sensor_id) OPCODE_AT,V(sensor_id),OPCODE_AFTER,V(sensor_id),
+#define AFTER(sensor_id,timer...) OPCODE_AT,V(sensor_id),OPCODE_AFTER,V(sensor_id),OPCODE_PAD,V(#timer[0]?timer+0:500),
 #define AFTEROVERLOAD(track_id) OPCODE_AFTEROVERLOAD,V(TRACK_NUMBER_##track_id),
 #define ALIAS(name,value...) 
 #define AMBER(signal_id) OPCODE_AMBER,V(signal_id),
 #define ANOUT(vpin,value,param1,param2) OPCODE_SERVO,V(vpin),OPCODE_PAD,V(value),OPCODE_PAD,V(param1),OPCODE_PAD,V(param2),
+#define ASPECT(address,value) OPCODE_ASPECT,V((address<<5) | (value & 0x1F)),
 #define AT(sensor_id) OPCODE_AT,V(sensor_id),
 #define ATGTE(sensor_id,value) OPCODE_ATGTE,V(sensor_id),OPCODE_PAD,V(value),  
 #define ATLT(sensor_id,value) OPCODE_ATLT,V(sensor_id),OPCODE_PAD,V(value),  
 #define ATTIMEOUT(sensor_id,timeout) OPCODE_ATTIMEOUT1,0,0,OPCODE_ATTIMEOUT2,V(sensor_id),OPCODE_PAD,V(timeout/100L),
 #define AUTOMATION(id, description)  OPCODE_AUTOMATION, V(id), 
 #define AUTOSTART OPCODE_AUTOSTART,0,0,
+#define BLINK(vpin,onDuty,offDuty) OPCODE_BLINK,V(vpin),OPCODE_PAD,V(onDuty),OPCODE_PAD,V(offDuty),
 #define BROADCAST(msg) PRINT(msg)
 #define CALL(route) OPCODE_CALL,V(route),
+#define CLEAR_STASH(id) OPCODE_CLEAR_STASH,V(id),
+#define CLEAR_ALL_STASH OPCODE_CLEAR_ALL_STASH,V(0),
+#define CLEAR_ANY_STASH OPCODE_CLEAR_ANY_STASH,V(0),
 #define CLOSE(id)  OPCODE_CLOSE,V(id),
+#define CONFIGURE_SERVO(vpin,pos1,pos2,profile)
 #ifndef IO_NO_HAL
 #define DCC_TURNTABLE(id,home,description...) OPCODE_DCCTURNTABLE,V(id),OPCODE_PAD,V(home),
 #endif
@@ -313,6 +441,7 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #define DELAYMINS(mindelay) OPCODE_DELAYMINS,V(mindelay),
 #define DELAYRANDOM(mindelay,maxdelay) DELAY(mindelay) OPCODE_RANDWAIT,V((maxdelay-mindelay)/100L),
 #define DCC_SIGNAL(id,add,subaddr)
+#define DCCX_SIGNAL(id,redAspect,amberAspect,greenAspect)
 #define DONE OPCODE_ENDTASK,0,0,
 #define DRIVE(analogpin) OPCODE_DRIVE,V(analogpin),
 #define ELSE OPCODE_ELSE,0,0,
@@ -320,19 +449,22 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #define ENDIF  OPCODE_ENDIF,0,0,
 #define ENDTASK OPCODE_ENDTASK,0,0,
 #define ESTOP OPCODE_SPEED,V(1), 
+#define ESTOPALL OPCODE_ESTOPALL,0,0, 
 #define EXRAIL
 #ifndef IO_NO_HAL
-#define EXTT_TURNTABLE(id,vpin,i2c_address,home,description...) OPCODE_EXTTTURNTABLE,V(id),OPCODE_PAD,V(vpin),OPCODE_PAD,V(i2c_address),OPCODE_PAD,V(home),
+#define EXTT_TURNTABLE(id,vpin,home,description...) OPCODE_EXTTTURNTABLE,V(id),OPCODE_PAD,V(vpin),OPCODE_PAD,V(home),
 #endif
-#define FADE(pin,value,ms) OPCODE_SERVO,V(pin),OPCODE_PAD,V(value),OPCODE_PAD,V(PCA9685::ProfileType::UseDuration|PCA9685::NoPowerOff),OPCODE_PAD,V(ms/100L),
+#define FADE(pin,value,ms) OPCODE_SERVO,V(pin),OPCODE_PAD,V(value),OPCODE_PAD,V((int16_t)PCA9685::ProfileType::UseDuration|(int16_t)PCA9685::ProfileType::NoPowerOff),OPCODE_PAD,V(ms/100L),
 #define FOFF(func) OPCODE_FOFF,V(func),
 #define FOLLOW(route) OPCODE_FOLLOW,V(route),
 #define FON(func) OPCODE_FON,V(func),
 #define FORGET OPCODE_FORGET,0,0,
 #define FREE(blockid) OPCODE_FREE,V(blockid),
+#define FTOGGLE(func) OPCODE_FTOGGLE,V(func),
 #define FWD(speed) OPCODE_FWD,V(speed),
 #define GREEN(signal_id) OPCODE_GREEN,V(signal_id),
 #define HAL(haltype,params...)
+#define HAL_IGNORE_DEFAULTS
 #define IF(sensor_id) OPCODE_IF,V(sensor_id),
 #define IFAMBER(signal_id) OPCODE_IFAMBER,V(signal_id),
 #define IFCLOSED(turnout_id) OPCODE_IFCLOSED,V(turnout_id),
@@ -344,24 +476,53 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #define IFRANDOM(percent) OPCODE_IFRANDOM,V(percent),
 #define IFRED(signal_id) OPCODE_IFRED,V(signal_id),
 #define IFRESERVE(block) OPCODE_IFRESERVE,V(block),
+#define IFSTASH(stash_id) OPCODE_IFSTASH,V(stash_id),
 #define IFTHROWN(turnout_id) OPCODE_IFTHROWN,V(turnout_id),
 #define IFTIMEOUT OPCODE_IFTIMEOUT,0,0,
 #ifndef IO_NO_HAL
 #define IFTTPOSITION(id,position) OPCODE_IFTTPOSITION,V(id),OPCODE_PAD,V(position),
 #endif
 #define IFRE(sensor_id,value) OPCODE_IFRE,V(sensor_id),OPCODE_PAD,V(value),
+#define IFBITMAP_ALL(vpin,mask) OPCODE_IFBITMAP_ALL,V(vpin),OPCODE_PAD,V(mask),
+#define IFBITMAP_ANY(vpin,mask) OPCODE_IFBITMAP_ANY,V(vpin),OPCODE_PAD,V(mask),
 #define INVERT_DIRECTION OPCODE_INVERT_DIRECTION,0,0,
+#define JMRI_SENSOR(vpin,count...)
 #define JOIN OPCODE_JOIN,0,0,
 #define KILLALL OPCODE_KILLALL,0,0,
 #define LATCH(sensor_id) OPCODE_LATCH,V(sensor_id),
+#define LCC(eventid) OPCODE_LCC,V(eventid),
+#define LCCX(sender,event) OPCODE_LCCX,V(event),\
+        OPCODE_PAD,V((((uint64_t)sender)>>32)&0xFFFF),\
+        OPCODE_PAD,V((((uint64_t)sender)>>16)&0xFFFF),\
+        OPCODE_PAD,V((((uint64_t)sender)>>0)&0xFFFF),  
+#define ACON(eventid) OPCODE_ACON,V(((uint32_t)eventid >>16) & 0xFFFF),OPCODE_PAD,V(eventid & 0xFFFF),
+#define ACOF(eventid) OPCODE_ACOF,V(((uint32_t)eventid >>16) & 0xFFFF),OPCODE_PAD,V(eventid & 0xFFFF),
+#define ONACON(eventid) OPCODE_ONACON,V((uint32_t)(eventid) >>16),OPCODE_PAD,V(eventid & 0xFFFF),
+#define ONACOF(eventid) OPCODE_ONACOF,V((uint32_t)(eventid) >>16),OPCODE_PAD,V(eventid & 0xFFFF),
 #define LCD(id,msg) PRINT(msg)
 #define SCREEN(display,id,msg) PRINT(msg)
+#define STEALTH(code...) PRINT(dummy)
+#define STEALTH_GLOBAL(code...) 
 #define LCN(msg) PRINT(msg)
+#define MESSAGE(msg) PRINT(msg)
+#define MOMENTUM(accel,decel...) OPCODE_MOMENTUM,V(accel),OPCODE_PAD,V(#decel[0]?decel+0:accel),
 #define MOVETT(id,steps,activity) OPCODE_SERVO,V(id),OPCODE_PAD,V(steps),OPCODE_PAD,V(EXTurntable::activity),OPCODE_PAD,V(0),
+#define NEOPIXEL(id,r,g,b,count...) OPCODE_NEOPIXEL,V(id),\
+        OPCODE_PAD,V(((r & 0xff)<<8) | (g & 0xff)),\
+        OPCODE_PAD,V((b & 0xff)),\
+        OPCODE_PAD,V(#count[0]?(count+0):1),
+         
+#define NEOPIXEL_SIGNAL(sigid,redcolour,ambercolour,greencolour)
 #define ONACTIVATE(addr,subaddr) OPCODE_ONACTIVATE,V(addr<<2|subaddr),
 #define ONACTIVATEL(linear) OPCODE_ONACTIVATE,V(linear+3),
 #define ONAMBER(signal_id) OPCODE_ONAMBER,V(signal_id),
+#define ONBLOCKENTER(block_id) OPCODE_ONBLOCKENTER,V(block_id),
+#define ONBLOCKEXIT(block_id) OPCODE_ONBLOCKEXIT,V(block_id),
 #define ONCLOSE(turnout_id) OPCODE_ONCLOSE,V(turnout_id),
+#define ONLCC(sender,event) OPCODE_ONLCC,V(event),\
+        OPCODE_PAD,V((((uint64_t)sender)>>32)&0xFFFF),\
+        OPCODE_PAD,V((((uint64_t)sender)>>16)&0xFFFF),\
+        OPCODE_PAD,V((((uint64_t)sender)>>0)&0xFFFF),        
 #define ONTIME(value) OPCODE_ONTIME,V(value),  
 #define ONCLOCKTIME(hours,mins) OPCODE_ONTIME,V((STRIP_ZERO(hours)*60)+STRIP_ZERO(mins)),
 #define ONCLOCKMINS(mins) ONCLOCKTIME(25,mins)
@@ -375,11 +536,13 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #endif
 #define ONTHROW(turnout_id) OPCODE_ONTHROW,V(turnout_id),
 #define ONCHANGE(sensor_id) OPCODE_ONCHANGE,V(sensor_id),
+#define ONSENSOR(sensor_id) OPCODE_ONSENSOR,V(sensor_id),
+#define ONBITMAP(sensor_id) OPCODE_ONBITMAP,V(sensor_id),
+#define ONBUTTON(sensor_id) OPCODE_ONBUTTON,V(sensor_id),
 #define PAUSE OPCODE_PAUSE,0,0,
+#define PICKUP_STASH(id) OPCODE_PICKUP_STASH,V(id),
 #define PIN_TURNOUT(id,pin,description...) OPCODE_PINTURNOUT,V(id),OPCODE_PAD,V(pin),
-#ifndef DISABLE_PROG
 #define POM(cv,value) OPCODE_POM,V(cv),OPCODE_PAD,V(value),
-#endif
 #define POWEROFF OPCODE_POWEROFF,0,0,
 #define POWERON OPCODE_POWERON,0,0,
 #define PRINT(msg) OPCODE_PRINT,V(__COUNTER__ - StringMacroTracker2),
@@ -387,7 +550,7 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #define READ_LOCO OPCODE_READ_LOCO1,0,0,OPCODE_READ_LOCO2,0,0,
 #define RED(signal_id) OPCODE_RED,V(signal_id),
 #define RESERVE(blockid) OPCODE_RESERVE,V(blockid),
-#define RESET(pin) OPCODE_RESET,V(pin),
+#define RESET(pin,count...) OPCODE_RESET,V(pin),OPCODE_PAD,V(#count[0] ? count+0: 1),
 #define RESUME OPCODE_RESUME,0,0,
 #define RETURN OPCODE_RETURN,0,0,
 #define REV(speed) OPCODE_REV,V(speed),
@@ -397,6 +560,11 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #define ROTATE_DCC(id,position) OPCODE_ROTATE,V(id),OPCODE_PAD,V(position),OPCODE_PAD,V(0),
 #endif
 #define ROUTE(id, description)  OPCODE_ROUTE, V(id), 
+#define ROUTE_ACTIVE(id)  OPCODE_ROUTE_ACTIVE,V(id),
+#define ROUTE_INACTIVE(id)  OPCODE_ROUTE_INACTIVE,V(id),
+#define ROUTE_HIDDEN(id)  OPCODE_ROUTE_HIDDEN,V(id),
+#define ROUTE_DISABLED(id)  OPCODE_ROUTE_DISABLED,V(id),
+#define ROUTE_CAPTION(id,caption) PRINT(caption)
 #define SENDLOCO(cab,route) OPCODE_SENDLOCO,V(cab),OPCODE_PAD,V(route),
 #define SEQUENCE(id)  OPCODE_SEQUENCE, V(id), 
 #define SERIAL(msg) PRINT(msg)
@@ -410,16 +578,19 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #define SERVO2(id,position,ms) OPCODE_SERVO,V(id),OPCODE_PAD,V(position),OPCODE_PAD,V(PCA9685::Instant),OPCODE_PAD,V(ms/100L),
 #define SERVO_SIGNAL(vpin,redpos,amberpos,greenpos)
 #define SERVO_TURNOUT(id,pin,activeAngle,inactiveAngle,profile,description...) OPCODE_SERVOTURNOUT,V(id),OPCODE_PAD,V(pin),OPCODE_PAD,V(activeAngle),OPCODE_PAD,V(inactiveAngle),OPCODE_PAD,V(PCA9685::ProfileType::profile),
-#define SET(pin) OPCODE_SET,V(pin),
+#define SET(pin,count...) OPCODE_SET,V(pin),OPCODE_PAD,V(#count[0] ? count+0: 1),
 #define SET_TRACK(track,mode)  OPCODE_SET_TRACK,V(TRACK_MODE_##mode  <<8 | TRACK_NUMBER_##track),
 #define SET_POWER(track,onoff) OPCODE_SET_POWER,V(TRACK_POWER_##onoff),OPCODE_PAD, V(TRACK_NUMBER_##track),
 #define SETLOCO(loco) OPCODE_SETLOCO,V(loco),
+#define SETFREQ(freq) OPCODE_SETFREQ,V(freq),
 #define SIGNAL(redpin,amberpin,greenpin) 
 #define SIGNALH(redpin,amberpin,greenpin) 
 #define SPEED(speed) OPCODE_SPEED,V(speed),
 #define START(route) OPCODE_START,V(route), 
+#define STASH(id) OPCODE_STASH,V(id), 
 #define STOP OPCODE_SPEED,V(0), 
 #define THROW(id)  OPCODE_THROW,V(id),
+#define TOGGLE_TURNOUT(id)  OPCODE_TOGGLE_TURNOUT,V(id),
 #ifndef IO_NO_HAL
 #define TT_ADDPOSITION(id,position,value,angle,description...) OPCODE_TTADDPOSITION,V(id),OPCODE_PAD,V(position),OPCODE_PAD,V(value),OPCODE_PAD,V(angle),
 #endif
@@ -429,6 +600,11 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #define UNLATCH(sensor_id) OPCODE_UNLATCH,V(sensor_id),
 #define VIRTUAL_SIGNAL(id) 
 #define VIRTUAL_TURNOUT(id,description...) OPCODE_PINTURNOUT,V(id),OPCODE_PAD,V(0), 
+#define BITMAP_AND(vpin,mask) OPCODE_BITMAP_AND,V(vpin),OPCODE_PAD,V(mask),
+#define BITMAP_INC(vpin) OPCODE_BITMAP_INC,V(vpin),
+#define BITMAP_DEC(vpin) OPCODE_BITMAP_DEC,V(vpin),
+#define BITMAP_OR(vpin,mask) OPCODE_BITMAP_OR,V(vpin),OPCODE_PAD,V(mask),
+#define BITMAP_XOR(vpin,mask) OPCODE_BITMAP_XOR,V(vpin),OPCODE_PAD,V(mask),
 #define WITHROTTLE(msg) PRINT(msg)
 #define WAITFOR(pin) OPCODE_WAITFOR,V(pin),
 #ifndef IO_NO_HAL
@@ -436,10 +612,14 @@ const  HIGHFLASH  int16_t RMFT2::SignalDefinitions[] = {
 #endif
 #define XFOFF(cab,func) OPCODE_XFOFF,V(cab),OPCODE_PAD,V(func),
 #define XFON(cab,func) OPCODE_XFON,V(cab),OPCODE_PAD,V(func),
+#define XFTOGGLE(cab,func) OPCODE_XFTOGGLE,V(cab),OPCODE_PAD,V(func),
+#define XFWD(cab,speed) OPCODE_XFWD,V(cab),OPCODE_PAD,V(speed),
+#define XREV(cab,speed) OPCODE_XREV,V(cab),OPCODE_PAD,V(speed),
+#define XPOM(cab,cv,value) OPCODE_XPOM,V(cab),OPCODE_PAD,V(cv),OPCODE_PAD,V(value),
 
 // Build RouteCode
 const int StringMacroTracker2=__COUNTER__;
-const  HIGHFLASH  byte RMFT2::RouteCode[] = {
+const  HIGHFLASH3  byte RMFT2::RouteCode[] = {
     #include "myAutomation.h"
     OPCODE_ENDTASK,0,0,OPCODE_ENDEXRAIL,0,0 };
 

EXRAILSensor.cpp

@@ -0,0 +1,104 @@
+/*
+ *  © 2024 Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**********************************************************************
+EXRAILSensor represents a sensor that should be monitored in order
+to call an exrail ONBUTTON or ONCHANGE handler.
+These are created at EXRAIL startup and thus need no delete or listing
+capability.
+The basic logic is similar to that found in the Sensor class
+except that on the relevant change an EXRAIL thread is started.    
+**********************************************************************/
+
+#include "EXRAILSensor.h"
+#include "EXRAIL2.h"
+
+void EXRAILSensor::checkAll() {
+  if (firstSensor == NULL) return;  // No sensors to be scanned
+  if (readingSensor == NULL) { 
+    // Not currently scanning sensor list
+    unsigned long thisTime = micros();
+    if (thisTime - lastReadCycle < cycleInterval) return;
+    // Required time has elapsed since last read cycle started,
+    // so initiate new scan through the sensor list
+    readingSensor = firstSensor;
+    lastReadCycle = thisTime;
+  }
+  
+  // Loop until either end of list is encountered or we pause for some reason
+  byte sensorCount = 0;
+
+  while (readingSensor != NULL) {
+    bool pause=readingSensor->check();
+    // Move to next sensor in list.
+    readingSensor = readingSensor->nextSensor;
+    // Currently process max of 16 sensors per entry.
+    // Performance measurements taken during development indicate that, with 128 sensors configured
+    // on 8x 16-pin MCP23017 GPIO expanders with polling (no change notification), all inputs can be read from the devices
+    // within 1.4ms (400Mhz I2C bus speed), and a full cycle of checking 128 sensors for changes takes under a millisecond.
+    if (pause || (++sensorCount)>=16) return; 
+  }
+} 
+
+bool EXRAILSensor::check() {
+  // check for debounced change in this sensor 
+  inputState = useAnalog?IODevice::readAnalogue(pin):RMFT2::readSensor(pin);
+
+  // Check if changed since last time, and process changes.
+  if (inputState == active) {// no change
+    latchDelay = minReadCount; // Reset counter
+    return false;  // no change 
+  }
+
+    // Change detected ... has it stayed changed for long enough
+    if (latchDelay > 0) {
+      latchDelay--;
+      return false; 
+    } 
+    
+    // change validated, act on it.
+    active = inputState;
+    latchDelay = minReadCount;  // Reset debounce counter
+    if (onChange || active) {
+      new RMFT2(progCounter);
+      return true;  // Don't check any more sensors on this entry
+    }
+    return false; 
+}
+
+EXRAILSensor::EXRAILSensor(VPIN _pin, int _progCounter, bool _onChange, bool _useAnalog) {
+
+  nextSensor = firstSensor;
+  firstSensor = this;
+
+  pin=_pin;
+  progCounter=_progCounter;
+  onChange=_onChange;
+  useAnalog=_useAnalog;
+
+  IODevice::configureInput(pin, true);   
+  active = useAnalog?IODevice::readAnalogue(pin): IODevice::read(pin);
+  inputState = active;
+  latchDelay = minReadCount;
+}
+
+EXRAILSensor *EXRAILSensor::firstSensor=NULL;
+EXRAILSensor *EXRAILSensor::readingSensor=NULL;
+unsigned long EXRAILSensor::lastReadCycle=0;

EXRAILSensor.h

@@ -0,0 +1,52 @@
+/*
+ *  © 2024 Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef EXRAILSensor_h
+#define EXRAILSensor_h 
+#include "IODevice.h"
+class EXRAILSensor {
+  static EXRAILSensor * firstSensor;
+ static EXRAILSensor * readingSensor;
+ static unsigned long lastReadCycle;
+ 
+  public:
+  static void checkAll();
+  
+  EXRAILSensor(VPIN _pin, int _progCounter, bool _onChange, bool _useAnalog=false);
+  
+  bool check();
+  
+  private:
+  static const unsigned int cycleInterval = 10000; // min time between consecutive reads of each sensor in microsecs.
+                                                   // should not be less than device scan cycle time.
+  static const byte minReadCount = 4; // number of additional scans before acting on change
+                                        // E.g. 1 means that a change is ignored for one scan and actioned on the next.
+                                        // Max value is 63
+  
+  EXRAILSensor* nextSensor;
+  VPIN pin; 
+  int progCounter; 
+  uint16_t active; 
+  uint16_t inputState;
+  bool onChange;
+  bool useAnalog;
+  byte latchDelay;
+};
+#endif

EXmDNS.cpp

@@ -0,0 +1,200 @@
+/*
+ *  © 2024 Harald Barth
+ *  © 2024 Paul M. Antoine
+ *  All rights reserved.
+ *
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <Arduino.h>
+#include "EthernetInterface.h"
+#ifdef DO_MDNS
+#include "EXmDNS.h"
+
+// fixed values for mDNS
+static IPAddress mdnsMulticastIPAddr = IPAddress(224, 0, 0, 251);
+#define MDNS_SERVER_PORT 5353
+
+// dotToLen()
+// converts stings of form ".foo.barbar.x" to a string with the
+// dots replaced with lenght. So string above  would result in
+// "\x03foo\x06barbar\x01x" in C notation. If not NULL, *substr
+// will point to the beginning of the last component, in this
+// example that would be "\x01x".
+//
+static void dotToLen(char *str, char **substr) {
+  char *dotplace = NULL;
+  char *s;
+  byte charcount = 0;
+  for (s = str;/*see break*/ ; s++) {
+    if (*s == '.' || *s == '\0') {
+      // take care of accumulated
+      if (dotplace != NULL && charcount != 0) {
+	*dotplace = charcount;
+      }
+      if (*s == '\0')
+	break;
+      if (substr && *s == '.')
+	*substr = s;
+      // set new values
+      dotplace = s;
+      charcount = 0;
+    } else {
+      charcount++;
+    }
+  }
+}
+
+MDNS::MDNS(EthernetUDP& udp) {
+  _udp = &udp;
+}
+MDNS::~MDNS() {
+  _udp->stop();
+  if (_name) free(_name);
+  if (_serviceName) free(_serviceName);
+  if (_serviceProto) free(_serviceProto);
+}
+int MDNS::begin(const IPAddress& ip, char* name) {
+  // if we were called very soon after the board was booted, we need to give the
+  // EthernetShield (WIZnet) some time to come up. Hence, we delay until millis() is at
+  // least 3000. This is necessary, so that if we need to add a service record directly
+  // after begin, the announce packet does not get lost in the bowels of the WIZnet chip.
+  //while (millis() < 3000) 
+  //  delay(100);
+  
+  _ipAddress = ip;
+  _name = (char *)malloc(strlen(name)+2);
+  byte n;
+  for(n = 0; n<strlen(name); n++)
+    _name[n+1] = name[n];
+  _name[n+1] = '\0';
+  _name[0] = '.';
+  dotToLen(_name, NULL);
+  return _udp->beginMulticast(mdnsMulticastIPAddr, MDNS_SERVER_PORT);
+}
+
+int MDNS::addServiceRecord(const char* name, uint16_t port, MDNSServiceProtocol_t proto) {
+  // we ignore proto, assume TCP
+  (void)proto;
+  _serviceName = (char *)malloc(strlen(name) + 2);
+  byte n;
+  for(n = 0; n<strlen(name); n++)
+    _serviceName[n+1] = name[n];
+  _serviceName[n+1] = '\0';
+  _serviceName[0] = '.';
+  _serviceProto = NULL; //to be filled in
+  dotToLen(_serviceName, &_serviceProto);
+  _servicePort = port;
+  return 1;
+}
+
+static char dns_rr_services[]   = "\x09_services\x07_dns-sd\x04_udp\x05local";
+static char dns_rr_tcplocal[]   = "\x04_tcp\x05local"; 
+static char *dns_rr_local       = dns_rr_tcplocal + dns_rr_tcplocal[0] + 1;
+
+typedef struct _DNSHeader_t 
+{
+  uint16_t    xid;
+  uint16_t  flags; // flags condensed
+  uint16_t    queryCount;
+  uint16_t    answerCount;
+  uint16_t    authorityCount;
+  uint16_t    additionalCount;
+} __attribute__((__packed__)) DNSHeader_t;
+
+//
+// MDNS::run()
+// This broadcasts whatever we got evey BROADCASTTIME seconds.
+// Why? Too much brokenness i all mDNS implementations available
+//
+void MDNS::run() {
+  static long int lastrun = BROADCASTTIME * 1000UL;
+  unsigned long int now = millis();
+  if (!(now - lastrun > BROADCASTTIME * 1000UL)) {
+    return;
+  }
+  lastrun = now;
+  DNSHeader_t dnsHeader = {0, 0, 0, 0, 0, 0};
+  // DNSHeader_t dnsHeader = { 0 };
+
+  _udp->beginPacket(mdnsMulticastIPAddr, MDNS_SERVER_PORT);
+
+  // dns header
+  dnsHeader.flags = HTONS((uint16_t)0x8400); // Response, authorative
+  dnsHeader.answerCount = HTONS(4 /*5 if TXT but we do not do that */);
+  _udp->write((uint8_t*)&dnsHeader, sizeof(DNSHeader_t));
+
+  // rr #1, the PTR record from generic _services.x.local to service.x.local
+  _udp->write((uint8_t*)dns_rr_services, sizeof(dns_rr_services));
+
+  byte buf[10];
+  buf[0] = 0x00;
+  buf[1] = 0x0c;                           //PTR
+  buf[2] = 0x00;
+  buf[3] = 0x01;                           //IN
+  *((uint32_t*)(buf+4)) = HTONL(120); //TTL in sec
+  *((uint16_t*)(buf+8)) = HTONS( _serviceProto[0] + 1 + strlen(dns_rr_tcplocal) + 1);
+  _udp->write(buf, 10);
+
+  _udp->write(_serviceProto,_serviceProto[0]+1);
+  _udp->write(dns_rr_tcplocal, strlen(dns_rr_tcplocal)+1);
+
+  // rr #2, the PTR record from proto.x to name.proto.x
+  _udp->write(_serviceProto,_serviceProto[0]+1);
+  _udp->write(dns_rr_tcplocal, strlen(dns_rr_tcplocal)+1);
+  *((uint16_t*)(buf+8)) = HTONS(strlen(_serviceName) + strlen(dns_rr_tcplocal) + 1); // recycle most of buf
+  _udp->write(buf, 10);
+
+  _udp->write(_serviceName, strlen(_serviceName));
+  _udp->write(dns_rr_tcplocal, strlen(dns_rr_tcplocal)+1);
+  // rr #3, the SRV record for the service that points to local name
+  _udp->write(_serviceName, strlen(_serviceName));
+  _udp->write(dns_rr_tcplocal, strlen(dns_rr_tcplocal)+1);
+
+  buf[1] = 0x21;                                  // recycle most of buf but here SRV
+  buf[2] = 0x80;                                  // cache flush
+  *((uint16_t*)(buf+8)) = HTONS(strlen(_name) + strlen(dns_rr_local) + 1 + 6);
+  _udp->write(buf, 10);
+
+  byte srv[6];
+  // priority and weight
+  srv[0] = srv[1] = srv[2] = srv[3] = 0;
+  // port
+  *((uint16_t*)(srv+4)) = HTONS(_servicePort);
+  _udp->write(srv, 6);
+  // target
+  _udp->write(_name, _name[0]+1);
+  _udp->write(dns_rr_local, strlen(dns_rr_local)+1);
+
+  // rr #4, the A record for the name.local
+  _udp->write(_name, _name[0]+1);
+  _udp->write(dns_rr_local, strlen(dns_rr_local)+1);
+  
+  buf[1] = 0x01;                                  // recycle most of buf but here A
+  *((uint16_t*)(buf+8)) = HTONS(4);
+  _udp->write(buf, 10);
+  byte ip[4];
+  ip[0] = _ipAddress[0];
+  ip[1] = _ipAddress[1];
+  ip[2] = _ipAddress[2];
+  ip[3] = _ipAddress[3];
+  _udp->write(ip, 4);
+  
+  _udp->endPacket();
+  _udp->flush();
+  // 
+}
+#endif //DO_MDNS

EXmDNS.h

@@ -0,0 +1,50 @@
+/*
+ *  © 2024 Harald Barth
+ *  © 2024 Paul M. Antoine
+ *  All rights reserved.
+ *
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#ifdef DO_MDNS
+#define BROADCASTTIME 15 //seconds
+
+// We do this ourselves because every library is different and/or broken...
+#define HTONS(x) ((uint16_t)(((x) << 8) | (((x) >> 8) & 0xFF)))
+#define HTONL(x) ( ((uint32_t)(x) << 24) | (((uint32_t)(x) << 8) & 0xFF0000) | \
+                  (((uint32_t)(x) >> 8) & 0xFF00) | ((uint32_t)(x) >> 24) )
+
+typedef enum _MDNSServiceProtocol_t 
+{
+  MDNSServiceTCP,
+  MDNSServiceUDP
+} MDNSServiceProtocol_t;
+
+class MDNS {
+public:
+  MDNS(EthernetUDP& udp);
+  ~MDNS();
+  int begin(const IPAddress& ip,  char* name);
+  int addServiceRecord(const char* name, uint16_t port, MDNSServiceProtocol_t proto);
+  void run();
+private:
+  EthernetUDP *_udp;
+  IPAddress _ipAddress;
+  char* _name;
+  char* _serviceName;
+  char* _serviceProto;
+  int _servicePort;
+};
+#endif //DO_MDNS

EthernetInterface.cpp

@@ -1,8 +1,10 @@
 /*
+ *  © 2024 Morten "Doc" Nielsen
+ *  © 2023-2024 Paul M. Antoine
  *  © 2022 Bruno Sanches
  *  © 2021 Fred Decker
  *  © 2020-2022 Harald Barth
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2024 Chris Harlow
  *  © 2020 Gregor Baues
  *  All rights reserved.
  *  
@@ -30,71 +32,139 @@
 #include "WiThrottle.h"
 #include "DCCTimer.h"
 
-EthernetInterface * EthernetInterface::singleton=NULL;
+#ifdef DO_MDNS
+#include "EXmDNS.h"
+EthernetUDP udp;
+MDNS mdns(udp);
+#endif
+
+//extern void looptimer(unsigned long timeout, const FSH* message);
+#define looptimer(a,b)
+
+bool EthernetInterface::connected=false;
+EthernetServer * EthernetInterface::server= nullptr;
+EthernetClient EthernetInterface::clients[MAX_SOCK_NUM];                // accept up to MAX_SOCK_NUM client connections at the same time; This depends on the chipset used on the Shield
+bool EthernetInterface::inUse[MAX_SOCK_NUM];                // accept up to MAX_SOCK_NUM client connections at the same time; This depends on the chipset used on the Shield
+uint8_t EthernetInterface::buffer[MAX_ETH_BUFFER+1];                    // buffer used by TCP for the recv
+RingStream * EthernetInterface::outboundRing = nullptr;
+
 /**
  * @brief Setup Ethernet Connection
  * 
  */
-void EthernetInterface::setup()
-{
-  if (singleton!=NULL) {
-    DIAG(F("Prog Error!"));
-    return;
-  }
-  if ((singleton=new EthernetInterface()))
-    return;
-  DIAG(F("Ethernet not initialized"));
-};
 
-
-/**
- * @brief Aquire IP Address from DHCP and start server
- * 
- * @return true 
- * @return false 
- */
-EthernetInterface::EthernetInterface()
+void EthernetInterface::setup() 
 {
+  DIAG(F("Ethernet starting"
+  #ifdef DO_MDNS
+    " (with mDNS)"
+  #endif 
+    " Please be patient, especially if no cable is connected!"
+  ));
+  
+  #ifdef STM32_ETHERNET
+    // Set a HOSTNAME for the DHCP request - a nice to have, but hard it seems on LWIP for STM32
+    // The default is "lwip", which is **always** set in STM32Ethernet/src/utility/ethernetif.cpp
+    // for some reason. One can edit it to instead read:
+    //      #if LWIP_NETIF_HOSTNAME
+    //      /* Initialize interface hostname */
+    //      if (netif->hostname == NULL)
+    //         netif->hostname = "lwip";
+    //      #endif /* LWIP_NETIF_HOSTNAME */
+    // Which seems more useful! We should propose the patch... so the following line actually works!
+    netif_set_hostname(&gnetif, WIFI_HOSTNAME);   // Should probably be passed in the contructor...
+  #endif   
+
     byte mac[6];
     DCCTimer::getSimulatedMacAddress(mac);
-    connected=false;
-   
-    #ifdef IP_ADDRESS
-    Ethernet.begin(mac, IP_ADDRESS);
-    #else
-    if (Ethernet.begin(mac) == 0)
-    {
-        DIAG(F("Ethernet.begin FAILED"));
-        return;
-    } 
-    #endif
-    if (Ethernet.hardwareStatus() == EthernetNoHardware) {
-      DIAG(F("Ethernet shield not found or W5100"));
-    }
   
-    unsigned long startmilli = millis();
-    while ((millis() - startmilli) < 5500) { // Loop to give time to check for cable connection
-        if (Ethernet.linkStatus() == LinkON)
-            break;
-        DIAG(F("Ethernet waiting for link (1sec) "));
-        delay(1000);
-    }
-    // now we either do have link of we have a W5100
-    // where we do not know if we have link. That's
-    // the reason to now run checkLink.
-    // CheckLinks sets up outboundRing if it does
-    // not exist yet as well.
-    checkLink();
+  #ifdef IP_ADDRESS
+    static IPAddress myIP(IP_ADDRESS);
+    Ethernet.begin(mac,myIP);
+  #else
+    if (Ethernet.begin(mac)==0)
+  {
+    LCD(4,F("IP: No DHCP"));
+    return;
+  }
+  #endif
+
+  auto ip = Ethernet.localIP();    // look what IP was obtained (dynamic or static)
+  if (!ip) {
+    LCD(4,F("IP: None"));
+    return;
+  }
+  server = new EthernetServer(IP_PORT); // Ethernet Server listening on default port IP_PORT
+  server->begin();
+
+  // Arrange display of IP address and port
+  #ifdef LCD_DRIVER
+    const byte lcdData[]={LCD_DRIVER};
+    const bool wideDisplay=lcdData[1]>=24; // data[1] is cols. 
+  #else 
+    const bool wideDisplay=true;
+  #endif    
+  if (wideDisplay) {
+    // OLEDS or just usb diag is ok on one line. 
+    LCD(4,F("IP %d.%d.%d.%d:%d"), ip[0], ip[1], ip[2], ip[3], IP_PORT);    
+  } 
+  else { // LCDs generally too narrow, so take 2 lines
+    LCD(4,F("IP %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
+    LCD(5,F("Port %d"), IP_PORT);
+  }
+ 
+  outboundRing=new RingStream(OUTBOUND_RING_SIZE);
+  #ifdef DO_MDNS
+    if (!mdns.begin(Ethernet.localIP(), (char *)WIFI_HOSTNAME))
+      DIAG(F("mdns.begin fail")); // hostname
+    mdns.addServiceRecord(WIFI_HOSTNAME "._withrottle", IP_PORT, MDNSServiceTCP);
+    mdns.run(); // run it right away to get out info ASAP
+  #endif  
+  connected=true;    
 }
 
-/**
- * @brief Cleanup any resources
- * 
- * @return none
- */
-EthernetInterface::~EthernetInterface() {
-  delete server;
-  delete outboundRing;
+#if defined (STM32_ETHERNET)
+void EthernetInterface::acceptClient() { // STM32 version
+  auto client=server->available();
+  if (!client) return;
+  // check for existing client
+  for (byte socket = 0; socket < MAX_SOCK_NUM; socket++)
+    if (inUse[socket] && client == clients[socket]) return;
+      
+  // new client
+  for (byte socket = 0; socket < MAX_SOCK_NUM; socket++)
+  {
+    if (!inUse[socket])
+    {
+      clients[socket] = client;
+      inUse[socket]=true;
+      if (Diag::ETHERNET)
+        DIAG(F("Ethernet: New client socket %d"), socket);
+      return;
+    }
+  }
+  // reached here only if more than MAX_SOCK_NUM clients want to connect
+  DIAG(F("Ethernet more than %d clients, not accepting new connection"), MAX_SOCK_NUM);
+  client.stop();
+}
+#else
+void EthernetInterface::acceptClient() { // non-STM32 version
+  auto client=server->accept();
+  if (!client) return;
+  auto socket=client.getSocketNumber();
+  clients[socket]=client;
+  inUse[socket]=true;
+  if (Diag::ETHERNET)
+    DIAG(F("Ethernet: New client socket %d"), socket);
+}
+#endif
+
+void EthernetInterface::dropClient(byte socket) 
+{ 
+  clients[socket].stop();
+  inUse[socket]=false;
+  CommandDistributor::forget(socket);
+	if (Diag::ETHERNET)  DIAG(F("Ethernet: Disconnect %d "), socket);  
 }
 
 /**
@@ -103,134 +173,109 @@ EthernetInterface::~EthernetInterface() {
  */
 void EthernetInterface::loop()
 {
-    if (!singleton || (!singleton->checkLink()))
-      return;
+    if (!connected) return;
+    looptimer(5000, F("E.loop"));
+	      
+    static bool warnedAboutLink=false;
+    if (Ethernet.linkStatus() == LinkOFF){
+        if (warnedAboutLink) return;
+        DIAG(F("Ethernet link OFF"));
+        warnedAboutLink=true;
+        return;
+    }
+    looptimer(5000, F("E.loop warn"));
+	  
+    // link status must be ok here 
+    if (warnedAboutLink) {
+      DIAG(F("Ethernet link RESTORED"));
+      warnedAboutLink=false;
+    } 
     
+  #ifdef DO_MDNS
+    // Always do this because we don't want traffic to intefere with being found!
+    mdns.run();
+    looptimer(5000, F("E.mdns"));
+	  
+  #endif
+
+    //
     switch (Ethernet.maintain()) {
     case 1:
         //renewed fail
         DIAG(F("Ethernet Error: renewed fail"));
-        singleton=NULL;
+        connected=false;
         return;
     case 3:
         //rebind fail
         DIAG(F("Ethernet Error: rebind fail"));
-        singleton=NULL;
+        connected=false;
         return;
     default:
         //nothing happened
+        //DIAG(F("maintained"));
         break;
     }
-   singleton->loop2();
-}
-
-/**
- * @brief Checks ethernet link cable status and detects when it connects / disconnects
- * 
- * @return true when cable is connected, false otherwise
- */
-bool EthernetInterface::checkLink() {
-  if (Ethernet.linkStatus() != LinkOFF) { // check for not linkOFF instead of linkON as the W5100 does return LinkUnknown
-    //if we are not connected yet, setup a new server
-    if(!connected) {
-      DIAG(F("Ethernet cable connected"));
-      connected=true;
-      #ifdef IP_ADDRESS
-      Ethernet.setLocalIP(IP_ADDRESS);      // for static IP, set it again
-      #endif
-      IPAddress ip = Ethernet.localIP();    // look what IP was obtained (dynamic or static)
-      server = new EthernetServer(IP_PORT); // Ethernet Server listening on default port IP_PORT
-      server->begin();
-      LCD(4,F("IP: %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
-      LCD(5,F("Port:%d"), IP_PORT);
-      // only create a outboundRing it none exists, this may happen if the cable
-      // gets disconnected and connected again
-      if(!outboundRing)
-	outboundRing=new RingStream(OUTBOUND_RING_SIZE);
-    }
-    return true;
-  } else { // connected
-    DIAG(F("Ethernet cable disconnected"));
-    connected=false;
-    //clean up any client
-    for (byte socket = 0; socket < MAX_SOCK_NUM; socket++) {
-      if(clients[socket].connected())
-	clients[socket].stop();
-    }
-    // tear down server
-    delete server;
-    server = nullptr;
-    LCD(4,F("IP: None"));
-  }
-  return false;
-}
-
-void EthernetInterface::loop2() {
-    if (!outboundRing) { // no idea to call loop2() if we can't handle outgoing data in it
-      if (Diag::ETHERNET) DIAG(F("No outboundRing"));
-      return;
-    }
+    looptimer(5000, F("E.maintain"));
+	  
     // get client from the server
-    EthernetClient client = server->accept();
-
-    // check for new client
-    if (client)
+    acceptClient();
+    
+    // handle disconnected sockets because STM32 library doesnt
+    // do the read==0 response.
+    for (byte socket = 0; socket < MAX_SOCK_NUM; socket++)
     {
-        if (Diag::ETHERNET) DIAG(F("Ethernet: New client "));
-        byte socket;
-        for (socket = 0; socket < MAX_SOCK_NUM; socket++)
-        {
-            if (!clients[socket])
-            {
-                // On accept() the EthernetServer doesn't track the client anymore
-                // so we store it in our client array
-                if (Diag::ETHERNET) DIAG(F("Socket %d"),socket);
-                clients[socket] = client;
-                break;
-            }
-        }
-        if (socket==MAX_SOCK_NUM) DIAG(F("new Ethernet OVERFLOW")); 
-    }
+      if (inUse[socket] && !clients[socket].connected()) dropClient(socket);
+    }  
 
     // check for incoming data from all possible clients
     for (byte socket = 0; socket < MAX_SOCK_NUM; socket++)
     {
-        if (clients[socket]) {
-        
-        int available=clients[socket].available();
-        if (available > 0) {
-            if (Diag::ETHERNET)  DIAG(F("Ethernet: available socket=%d,avail=%d"), socket, available);
-            // read bytes from a client
-            int count = clients[socket].read(buffer, MAX_ETH_BUFFER);
-            buffer[count] = '\0'; // terminate the string properly
-            if (Diag::ETHERNET) DIAG(F(",count=%d:%e"), socket,buffer);
-            // execute with data going directly back
-            CommandDistributor::parse(socket,buffer,outboundRing);
-            return; // limit the amount of processing that takes place within 1 loop() cycle. 
-          }
-        }
+      if (!inUse[socket]) continue; // socket is not in use
+	
+	    // read any bytes from this client
+	    auto count = clients[socket].read(buffer, MAX_ETH_BUFFER);
+      
+      if (count<0) continue;  // -1 indicates nothing to read
+	    
+      if (count > 0) {  // we have incoming data 
+	      buffer[count] = '\0'; // terminate the string properly
+	      if (Diag::ETHERNET) DIAG(F("Ethernet s=%d, c=%d b=:%e"), socket, count, buffer);
+	      // execute with data going directly back
+	      CommandDistributor::parse(socket,buffer,outboundRing);
+	      //looptimer(5000, F("Ethloop2 parse"));
+	      return; // limit the amount of processing that takes place within 1 loop() cycle. 
+	    }
+	    
+      // count=0 The client has disconnected
+	    dropClient(socket);
     }
-
-    // stop any clients which disconnect
-   for (int socket = 0; socket<MAX_SOCK_NUM; socket++) {
-     if (clients[socket] && !clients[socket].connected()) {
-      clients[socket].stop();
-      CommandDistributor::forget(socket);          
-      if (Diag::ETHERNET)  DIAG(F("Ethernet: disconnect %d "), socket);             
-     }
-    }
-
+	
     WiThrottle::loop(outboundRing);
-    
+
     // handle at most 1 outbound transmission 
-    int socketOut=outboundRing->read();
+    auto socketOut=outboundRing->read();
+    if (socketOut<0) return;  // no outbound pending
+
     if (socketOut >= MAX_SOCK_NUM) {
-      DIAG(F("Ethernet outboundRing socket=%d error"), socketOut);
-    } else if (socketOut >= 0) {
-      int count=outboundRing->count();
-      if (Diag::ETHERNET) DIAG(F("Ethernet reply socket=%d, count=:%d"), socketOut,count);
-      for(;count>0;count--)  clients[socketOut].write(outboundRing->read());
-      clients[socketOut].flush(); //maybe 
+      // This is a catastrophic code failure and unrecoverable.  
+      DIAG(F("Ethernet outboundRing s=%d error"), socketOut);
+      connected=false;
+      return;
+    } 
+
+    auto count=outboundRing->count();
+    {
+	    char tmpbuf[count+1]; // one extra for '\0'
+	    for(int i=0;i<count;i++) {
+	      tmpbuf[i] = outboundRing->read();
+	    }
+	    tmpbuf[count]=0;
+      if (inUse[socketOut]) {
+  	    if (Diag::ETHERNET) DIAG(F("Ethernet reply s=%d, c=%d, b:%e"),
+                              socketOut,count,tmpbuf);
+	      clients[socketOut].write(tmpbuf,count);
+      }
     }
+    
 }
 #endif

EthernetInterface.h

@@ -1,8 +1,10 @@
 /*
+ *  © 2023-2024 Paul M. Antoine
  *  © 2021 Neil McKechnie
  *  © 2021 Mike S
  *  © 2021 Fred Decker
- *  © 2020-2021 Chris Harlow
+ *  © 2020-2024 Harald Barth
+ *  © 2020-2024 Chris Harlow
  *  © 2020 Gregor Baues
  *  All rights reserved.
  *  
@@ -29,15 +31,32 @@
 #define EthernetInterface_h
 
 #include "defines.h"
+#if ETHERNET_ON == true
 #include "DCCEXParser.h"
 #include <Arduino.h>
 //#include <avr/pgmspace.h>
 #if defined (ARDUINO_TEENSY41)
  #include <NativeEthernet.h>         //TEENSY Ethernet Treiber
  #include <NativeEthernetUdp.h>   
+ #ifndef MAX_SOCK_NUM
+ #define MAX_SOCK_NUM 4
+ #endif
+ // can't use our MDNS because of a namespace clash with Teensy's NativeEthernet library!
+ // #define DO_MDNS
+#elif defined (ARDUINO_NUCLEO_F429ZI) || defined (ARDUINO_NUCLEO_F439ZI) || defined (ARDUINO_NUCLEO_F4X9ZI)
+ #include <LwIP.h>
+ #include <STM32Ethernet.h>
+ #include <lwip/netif.h>
+ extern "C" struct netif gnetif;
+ #define STM32_ETHERNET
+ #define MAX_SOCK_NUM MAX_NUM_TCP_CLIENTS
+ #define DO_MDNS
 #else
  #include "Ethernet.h"
+ #define DO_MDNS
 #endif
+
+
 #include "RingStream.h"
 
 /**
@@ -45,7 +64,7 @@
  * 
  */
 
-#define MAX_ETH_BUFFER 512
+#define MAX_ETH_BUFFER 128
 #define OUTBOUND_RING_SIZE 2048
 
 class EthernetInterface {
@@ -56,16 +75,15 @@ class EthernetInterface {
      static void loop();
    
  private:
-    static EthernetInterface * singleton;
-    bool connected;
-    EthernetInterface();
-    ~EthernetInterface();
-    void loop2();
-    bool checkLink();
-    EthernetServer * server = NULL;
-    EthernetClient clients[MAX_SOCK_NUM];                // accept up to MAX_SOCK_NUM client connections at the same time; This depends on the chipset used on the Shield
-    uint8_t buffer[MAX_ETH_BUFFER+1];                    // buffer used by TCP for the recv
-    RingStream * outboundRing = NULL;
+    static bool connected;
+    static EthernetServer * server;
+    static EthernetClient clients[MAX_SOCK_NUM];                // accept up to MAX_SOCK_NUM client connections at the same time; This depends on the chipset used on the Shield
+    static bool inUse[MAX_SOCK_NUM];                // accept up to MAX_SOCK_NUM client connections at the same time; This depends on the chipset used on the Shield
+    static uint8_t buffer[MAX_ETH_BUFFER+1];                    // buffer used by TCP for the recv
+    static RingStream * outboundRing;
+    static void acceptClient();
+    static void dropClient(byte socketnum);
+    
 };
-
+#endif // ETHERNET_ON
 #endif

FSH.h

@@ -52,20 +52,27 @@ typedef __FlashStringHelper FSH;
 #define STRNCPY_P strncpy_P
 #define STRNCMP_P strncmp_P
 #define STRLEN_P strlen_P
+#define STRCHR_P strchr_P 
 
 #if defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2560)
 // AVR_MEGA memory deliberately placed at end of link may need _far functions
 #define HIGHFLASH __attribute__((section(".fini2")))
+#define HIGHFLASH3 __attribute__((section(".fini3")))
 #define GETFARPTR(data) pgm_get_far_address(data)
 #define GETHIGHFLASH(data,offset) pgm_read_byte_far(GETFARPTR(data)+offset)
 #define GETHIGHFLASHW(data,offset) pgm_read_word_far(GETFARPTR(data)+offset)
+#define COPYHIGHFLASH(target,base,offset,length) \
+  memcpy_PF(target,GETFARPTR(base) + offset,length)  
 #else
 // AVR_UNO/NANO runtime does not support _far functions so just use _near equivalent
 // as there is no progmem above 32kb anyway.
 #define HIGHFLASH PROGMEM
+#define HIGHFLASH3 PROGMEM
 #define GETFARPTR(data) ((uint32_t)(data))
 #define GETHIGHFLASH(data,offset) pgm_read_byte_near(GETFARPTR(data)+(offset))
 #define GETHIGHFLASHW(data,offset) pgm_read_word_near(GETFARPTR(data)+(offset))
+#define COPYHIGHFLASH(target,base,offset,length) \
+  memcpy_P(target,(byte *)base + offset,length)  
 #endif
 
 #else 
@@ -80,14 +87,18 @@ typedef __FlashStringHelper FSH;
 typedef char FSH; 
 #define FLASH
 #define HIGHFLASH
+#define HIGHFLASH3
 #define GETFARPTR(data) ((uint32_t)(data))
 #define GETFLASH(addr) (*(const byte *)(addr))
 #define GETHIGHFLASH(data,offset)  (*(const byte *)(GETFARPTR(data)+offset))
 #define GETHIGHFLASHW(data,offset) (*(const uint16_t *)(GETFARPTR(data)+offset))
+#define COPYHIGHFLASH(target,base,offset,length) \
+  memcpy(target,(byte *)&base + offset,length)  
 #define STRCPY_P strcpy
 #define STRCMP_P strcmp
 #define STRNCPY_P strncpy
 #define STRNCMP_P strncmp
 #define STRLEN_P strlen
+#define STRCHR_P strchr
 #endif
 #endif

GITHUB_SHA.h

@@ -1 +1 @@
-#define GITHUB_SHA "devel-202309241855Z"
+#define GITHUB_SHA "devel-202503250850Z"

I2CManager.cpp

@@ -46,25 +46,39 @@
 
 // Helper function for listing device types
 static const FSH * guessI2CDeviceType(uint8_t address) {
+  if (address >= 0x10 && address <= 0x17)
+    return F("EX-SensorCAM");
+  if (address == 0x1A)
+    // 0x09-0x18 selectable, but for now handle the default
+    return F("Piicodev 865/915MHz Transceiver");
+  if (address == 0x1C)
+    return F("QMC6310 Magnetometer");
   if (address >= 0x20 && address <= 0x26)
     return F("GPIO Expander");
-  else if (address == 0x27)
+  if (address == 0x27)
     return F("GPIO Expander or LCD Display");
-  else if (address == 0x29)
+  if (address == 0x29)
     return F("Time-of-flight sensor");
-  else if (address >= 0x3c && address <= 0x3d)
-    return F("OLED Display");
-  else if (address >= 0x48 && address <= 0x4f)
+  if (address == 0x34)
+    return F("TCA8418 keypad scanner");
+  if (address >= 0x3c && address <= 0x3d)
+    // 0x3c can also be an HMC883L magnetometer
+    return F("OLED Display or HMC583L Magnetometer");
+  if (address >= 0x48 && address <= 0x57) // SC16IS752x UART detection
+    return F("SC16IS75x UART");
+  if (address >= 0x48 && address <= 0x4f)
     return F("Analogue Inputs or PWM");
-  else if (address >= 0x40 && address <= 0x4f)
+  if (address >= 0x40 && address <= 0x4f)
     return F("PWM");
-  else if (address >= 0x50 && address <= 0x5f) 
+  if (address >= 0x50 && address <= 0x5f) 
     return F("EEPROM"); 
-  else if (address == 0x68) 
+  if (address >= 0x60 && address <= 0x68) 
+    return F("Adafruit NeoPixel Driver"); 
+  if (address == 0x68) 
     return F("Real-time clock"); 
-  else if (address >= 0x70 && address <= 0x77)
+  if (address >= 0x70 && address <= 0x77)
     return F("I2C Mux");
-  else
+  // Unknown type
     return F("?");
 }
 
@@ -363,4 +377,4 @@ void I2CAddress::toHex(const uint8_t value, char *buffer) {
 
 /* static */ bool I2CAddress::_addressWarningDone = false;
 
-#endif
+#endif

I2CManager_NonBlocking.h

@@ -384,4 +384,4 @@ void I2CManagerClass::handleInterrupt() {
   }
 }
 
-#endif
+#endif

I2CManager_STM32.h

@@ -1,5 +1,5 @@
 /*
- *  © 2022-23 Paul M Antoine
+ *  © 2022-24 Paul M Antoine
  *  © 2023, Neil McKechnie
  *  All rights reserved.
  *
@@ -38,8 +38,9 @@
  *****************************************************************************/
 #if defined(I2C_USE_INTERRUPTS) && defined(ARDUINO_ARCH_STM32)
 #if defined(ARDUINO_NUCLEO_F401RE) || defined(ARDUINO_NUCLEO_F411RE) || defined(ARDUINO_NUCLEO_F446RE) \
-    || defined(ARDUINO_NUCLEO_F412ZG) || defined(ARDUINO_NUCLEO_F413ZH) \
-    || defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F446ZE)
+    || defined(ARDUINO_NUCLEO_F412ZG) || defined(ARDUINO_NUCLEO_F413ZH) || defined(ARDUINO_NUCLEO_F446ZE) \
+    || defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F439ZI) || defined(ARDUINO_NUCLEO_F4X9ZI)
+
 // Assume I2C1 for now - default I2C bus on Nucleo-F411RE and likely all Nucleo-64
 // and Nucleo-144 variants
 I2C_TypeDef *s = I2C1;
@@ -110,7 +111,6 @@ void I2CManagerClass::I2C_setClock(uint32_t i2cClockSpeed) {
   // Calculate a rise time appropriate to the requested bus speed
   // Use 10x the rise time spec to enable integer divide of 50ns clock period
   uint16_t t_rise;
-  uint32_t ccr_freq;
 
   while (s->CR1 & I2C_CR1_STOP);  // Prevents lockup by guarding further
                                   // writes to CR1 while STOP is being executed!
@@ -185,7 +185,7 @@ void I2CManagerClass::I2C_init()
   GPIOB->OTYPER |= (1<<8) | (1<<9);           // PB8 and PB9 set to open drain output capability
   GPIOB->OSPEEDR |= (3<<(8*2)) | (3<<(9*2));  // PB8 and PB9 set to High Speed mode
   GPIOB->PUPDR &= ~((3<<(8*2)) | (3<<(9*2))); // Clear all PUPDR bits for PB8 and PB9
-  GPIOB->PUPDR |= (1<<(8*2)) | (1<<(9*2));    // PB8 and PB9 set to pull-up capability
+  // GPIOB->PUPDR |= (1<<(8*2)) | (1<<(9*2));    // PB8 and PB9 set to pull-up capability
   // Alt Function High register routing pins PB8 and PB9 for I2C1:
   // Bits (3:2:1:0) = 0:1:0:0 --> AF4 for pin PB8
   // Bits (7:6:5:4) = 0:1:0:0 --> AF4 for pin PB9

I2CManager_Wire.h

@@ -231,4 +231,4 @@ void I2CManagerClass::queueRequest(I2CRB *req) {
  ***************************************************************************/
 void I2CManagerClass::loop() {}
 
-#endif
+#endif

IODevice.cpp

@@ -33,7 +33,7 @@
 
 // Link to halSetup function.  If not defined, the function reference will be NULL.
 extern __attribute__((weak)) void halSetup();
-extern __attribute__((weak)) void exrailHalSetup();
+extern __attribute__((weak)) bool exrailHalSetup();
 
 //==================================================================================================================
 // Static methods
@@ -60,34 +60,31 @@ void IODevice::begin() {
     halSetup();
 
   // include any HAL devices defined in exrail. 
+  bool ignoreDefaults=false;
   if (exrailHalSetup)
-    exrailHalSetup();
-
+    ignoreDefaults=exrailHalSetup();
+  if (ignoreDefaults) return;
+  
   // Predefine two PCA9685 modules 0x40-0x41 if no conflicts
   // Allocates 32 pins 100-131
-  if (checkNoOverlap(100, 16, 0x40)) {
+  const bool silent=true; // no message if these conflict
+  if (checkNoOverlap(100, 16, 0x40, silent)) {
     PCA9685::create(100, 16, 0x40);
-  } else {
-    DIAG(F("Default PCA9685 at I2C 0x40 disabled due to configured user device"));
-  }
-  if (checkNoOverlap(116, 16, 0x41)) {
+  } 
+
+  if (checkNoOverlap(116, 16, 0x41, silent)) {
     PCA9685::create(116, 16, 0x41);
-  } else {
-    DIAG(F("Default PCA9685 at I2C 0x41 disabled due to configured user device"));
-  }
+  } 
   
   // Predefine two MCP23017 module 0x20/0x21 if no conflicts
   // Allocates 32 pins 164-195
-  if (checkNoOverlap(164, 16, 0x20)) {
+  if (checkNoOverlap(164, 16, 0x20, silent)) {
     MCP23017::create(164, 16, 0x20);
-  } else {
-    DIAG(F("Default MCP23017 at I2C 0x20 disabled due to configured user device"));
-  }
-  if (checkNoOverlap(180, 16, 0x21)) {
+  } 
+
+  if (checkNoOverlap(180, 16, 0x21, silent)) {
     MCP23017::create(180, 16, 0x21);
-  } else {
-    DIAG(F("Default MCP23017 at I2C 0x21 disabled due to configured user device"));
-  }
+  } 
 }
 
 // reset() function to reinitialise all devices
@@ -254,6 +251,26 @@ void IODevice::write(VPIN vpin, int value) {
 #endif
 }
 
+// Write value to count virtual pin(s).
+// these may be within one driver or separated over several drivers 
+void IODevice::writeRange(VPIN vpin, int value, int count) {  
+  
+  while(count) {  
+    auto dev = findDevice(vpin);
+    if (dev) {
+      auto vpinBefore=vpin; 
+      // write to driver, driver will return next vpin it cant handle
+      vpin=dev->_writeRange(vpin, value,count);
+      count-= vpin-vpinBefore;  // decrement by number of vpins changed
+    }
+    else {
+      // skip a vpin if no device handler
+      vpin++;
+      count--;
+    }
+  }
+}
+
 // Write analogue value to virtual pin(s).  If multiple devices are allocated
 // the same pin then only the first one found will be used.
 //
@@ -273,6 +290,24 @@ void IODevice::writeAnalogue(VPIN vpin, int value, uint8_t param1, uint16_t para
 #endif
 }
 
+//
+void IODevice::writeAnalogueRange(VPIN vpin, int value, uint8_t param1, uint16_t param2,int count) {
+  while(count) {  
+    auto dev = findDevice(vpin);
+    if (dev) {
+      auto vpinBefore=vpin; 
+      // write to driver, driver will return next vpin it cant handle
+      vpin=dev->_writeAnalogueRange(vpin, value, param1, param2,count);
+      count-= vpin-vpinBefore;  // decrement by number of vpins changed
+    }
+    else {
+      // skip a vpin if no device handler
+      vpin++;
+      count--;
+    }
+  }
+}
+
 // isBusy, when called for a device pin is always a digital output or analogue output,
 //  returns input feedback state of the pin, i.e. whether the pin is busy performing
 //  an animation or fade over a period of time.
@@ -339,7 +374,10 @@ IODevice *IODevice::findDeviceFollowing(VPIN vpin) {
 // returns true if pins DONT overlap with existing device
 // TODO: Move the I2C address reservation and checks into the I2CManager code.
 // That will enable non-HAL devices to reserve I2C addresses too.
-bool IODevice::checkNoOverlap(VPIN firstPin, uint8_t nPins, I2CAddress i2cAddress) {
+// Silent is used by the default setup so that there is no message if the default 
+// device has already been handled by the user setup.
+bool IODevice::checkNoOverlap(VPIN firstPin, uint8_t nPins, 
+      I2CAddress i2cAddress, bool silent) {
 #ifdef DIAG_IO
   DIAG(F("Check no overlap %u %u %s"), firstPin,nPins,i2cAddress.toString());
 #endif
@@ -352,14 +390,14 @@ bool IODevice::checkNoOverlap(VPIN firstPin, uint8_t nPins, I2CAddress i2cAddres
       VPIN lastDevPin=firstDevPin+dev->_nPins-1;
       bool noOverlap= firstPin>lastDevPin || lastPin<firstDevPin;
       if (!noOverlap) {
-          DIAG(F("WARNING HAL Overlap, redefinition of Vpins %u to %u ignored."),
+          if (!silent) DIAG(F("WARNING HAL Overlap, redefinition of Vpins %u to %u ignored."),
               firstPin, lastPin);
           return false;
       } 
     }
     // Check for overlapping I2C address
     if (i2cAddress && dev->_I2CAddress==i2cAddress) {
-      DIAG(F("WARNING HAL Overlap. i2c Addr %s ignored."),i2cAddress.toString());
+      if (!silent) DIAG(F("WARNING HAL Overlap. i2c Addr %s ignored."),i2cAddress.toString());
       return false;
     } 
   }
@@ -589,4 +627,3 @@ bool ArduinoPins::fastReadDigital(uint8_t pin) {
 #endif
   return result;
 }
-

IODevice.h

@@ -38,6 +38,7 @@
 #include "FSH.h"
 #include "I2CManager.h"
 #include "inttypes.h"
+#include "TemplateForEnums.h"
 
 typedef uint16_t VPIN;
 // Limit VPIN number to max 32767.  Above this number, printing often gives negative values.
@@ -128,9 +129,11 @@ public:
 
   // write invokes the IODevice instance's _write method.
   static void write(VPIN vpin, int value);
+  static void writeRange(VPIN vpin, int value,int count);
 
   // write invokes the IODevice instance's _writeAnalogue method (not applicable for digital outputs)
   static void writeAnalogue(VPIN vpin, int value, uint8_t profile=0, uint16_t duration=0);
+  static void writeAnalogueRange(VPIN vpin, int value, uint8_t profile, uint16_t duration, int count);
 
   // isBusy returns true if the device is currently in an animation of some sort, e.g. is changing
   //  the output over a period of time.
@@ -166,7 +169,8 @@ public:
   void setGPIOInterruptPin(int16_t pinNumber);
 
   // Method to check if pins will overlap before creating new device. 
-  static bool checkNoOverlap(VPIN firstPin, uint8_t nPins=1, I2CAddress i2cAddress=0);
+  static bool checkNoOverlap(VPIN firstPin, uint8_t nPins=1, 
+                  I2CAddress i2cAddress=0, bool silent=false);
 
   // Method used by IODevice filters to locate slave pins that may be overlayed by their own
   // pin range.  
@@ -176,11 +180,29 @@ public:
   virtual void _write(VPIN vpin, int value) {
     (void)vpin; (void)value;
   };
+ 
+ // Method to write new state (optionally implemented within device class)
+ // This will, by default just write to one vpin and return whet to do next.
+ // the real power comes where a single driver can update many vpins in one call.
+  virtual VPIN _writeRange(VPIN vpin, int value, int count) {
+    (void)count;
+    _write(vpin,value); 
+    return vpin+1; // try next vpin 
+  };
 
   // Method to write an 'analogue' value (optionally implemented within device class)
   virtual void _writeAnalogue(VPIN vpin, int value, uint8_t param1=0, uint16_t param2=0) {
     (void)vpin; (void)value; (void) param1; (void)param2;
   };
+  
+  // Method to write an 'analogue' value to a VPIN range (optionally implemented within device class)
+  // This will, by default just write to one vpin and return whet to do next.
+  // the real power comes where a single driver can update many vpins in one call.
+  virtual VPIN _writeAnalogueRange(VPIN vpin, int value, uint8_t param1, uint16_t param2, int count) {
+    (void) count;
+    _writeAnalogue(vpin, value,  param1, param2);
+    return vpin+1; 
+  };
 
   // Method to read digital pin state (optionally implemented within device class)
   virtual int _read(VPIN vpin) { 
@@ -538,12 +560,6 @@ protected:
 
 };
 
-#include "IO_MCP23008.h"
-#include "IO_MCP23017.h"
-#include "IO_PCF8574.h"
-#include "IO_PCF8575.h"
-#include "IO_duinoNodes.h"
-#include "IO_EXIOExpander.h"
-
+//#include "IODeviceList.h"
 
 #endif // iodevice_h

IODeviceList.h

@@ -0,0 +1,50 @@
+/*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+/* 
+This is the list of HAL drivers automatically included by IODevice.h
+It has been moved here to be easier to maintain than editing IODevice.h
+*/
+#include "IO_AnalogueInputs.h"
+#include "IO_DFPlayer.h"
+#include "IO_DS1307.h"
+#include "IO_duinoNodes.h"
+#include "IO_EncoderThrottle.h"
+#include "IO_EXFastclock.h"
+#include "IO_EXIOExpander.h"
+#include "IO_EXSensorCAM.h"
+#include "IO_HALDisplay.h"
+#include "IO_HCSR04.h"
+#include "IO_I2CDFPlayer.h"
+#include "IO_I2CRailcom.h"
+#include "IO_MCP23008.h"
+#include "IO_MCP23017.h"
+#include "IO_NeoPixel.h"
+#include "IO_PCA9555.h"
+#include "IO_PCA9685pwm.h"
+#include "IO_PCF8574.h"
+#include "IO_PCF8575.h"
+#include "IO_RotaryEncoder.h"
+#include "IO_Servo.h"
+#include "IO_TCA8418.h"
+#include "IO_TM1638.h"
+#include "IO_TouchKeypad.h"
+#include "IO_trainbrains.h"
+#include "IO_Bitmap.h"
+#include "IO_VL53L0X.h"
+

IO_AnalogueInputs.h

@@ -166,4 +166,4 @@ private:
   uint8_t _nextState;
 };
 
-#endif // io_analogueinputs_h
+#endif // io_analogueinputs_h

IO_Bitmap.h

@@ -0,0 +1,89 @@
+/*
+ *  © 2025, Chris Harlow. All rights reserved.
+ *  
+ *  This file is part of DCC-EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#ifndef IO_Bitmap_h
+ #define IO_Bitmap_h
+#include <Arduino.h>
+#include "defines.h"
+#include "IODevice.h"
+
+/* 
+Bitmap provides a set of virtual pins with no hardware.
+Bitmap pins are able to be output and input and may be set and tested 
+as digital or analogue values.
+When writing a digital value, the analogue value is set to 0 or 1. 
+When reading a digital value, the return is LOW for value 0 or HIGH for any other value
+or analogue.
+
+Bitmap pins may be used for any purpose, this is easier to manage than LATCH in EXRAIL
+as they can be explicitely set and tested without interfering with underlying hardware.
+Bitmap pins may be set, reset and tested in the same way as any other pin.
+They are not persistent across reboots, but are retained in the current session.
+Bitmap pins may also be monitored by JMRI_SENSOR() and <S> as for any other pin.
+   
+*/
+class Bitmap : public IODevice {
+
+public:
+  static void create(VPIN firstVpin, int nPins) {   
+    if (IODevice::checkNoOverlap(firstVpin,nPins))
+         new Bitmap( firstVpin,  nPins);
+  }
+
+  Bitmap(VPIN firstVpin, int nPins) : IODevice(firstVpin, nPins) {
+    _pinValues=(int16_t *) calloc(nPins,sizeof(int16_t));  
+    // Connect to HAL so my _write, _read and _loop will be called as required.
+    IODevice::addDevice(this);  
+  }
+
+// Called by HAL to start handling this device
+  void _begin() override {
+    _deviceState = DEVSTATE_NORMAL;
+    _display();
+  }
+
+  int _read(VPIN vpin) override {
+    int pin=vpin - _firstVpin;
+    return _pinValues[pin]?1:0;
+  }
+
+  void _write(VPIN vpin, int value) override {
+    int pin = vpin - _firstVpin;
+    _pinValues[pin]=value!=0; // this is digital write  
+  }
+
+  int _readAnalogue(VPIN vpin) override {
+    int pin=vpin - _firstVpin;
+    return _pinValues[pin]; // this is analog read  
+  }
+
+  void _writeAnalogue(VPIN vpin, int value, uint8_t profile, uint16_t duration) override {
+    int pin=vpin - _firstVpin;
+    _pinValues[pin]=value; // this is analog write  
+  }
+
+  void _display() override {
+      DIAG(F("Bitmap Configured on Vpins:%u-%u"), 
+      (int)_firstVpin, 
+      (int)_firstVpin+_nPins-1);
+  }
+
+private:
+  int16_t* _pinValues;
+};
+#endif

IO_DCCAccessory.cpp

@@ -65,4 +65,3 @@ void DCCAccessoryDecoder::_display() {
   DIAG(F("DCCAccessoryDecoder Configured on Vpins:%u-%u Addresses %d/%d-%d/%d)"), _firstVpin, _firstVpin+_nPins-1,
       ADDRESS(_packedAddress), SUBADDRESS(_packedAddress), ADDRESS(endAddress), SUBADDRESS(endAddress));
 }
-

IO_DS1307.cpp

@@ -0,0 +1,143 @@
+/*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+/*
+* The IO_DS1307 device driver is used to interface a standalone realtime clock. 
+* The clock will announce every minute (which will trigger EXRAIL ONTIME events).
+* Seconds, and Day/date info is ignored, except that the announced hhmm time
+* will attempt to synchronize with the 0 seconds of the clock. 
+* An analog read in EXRAIL (IFGTE(vpin, value) etc will check against the hh*60+mm time.
+* The clock can be easily set by an analog write to the vpin using 24 hr clock time
+* with the command <z vpin hh mm ss> 
+*/
+
+#include "IO_DS1307.h"
+#include "I2CManager.h"
+#include "DIAG.h"
+#include "CommandDistributor.h"
+
+uint8_t d2b(uint8_t d) {
+     return (d >> 4)*10 + (d & 0x0F);  
+}
+
+void DS1307::create(VPIN vpin, I2CAddress i2cAddress) {
+    if (checkNoOverlap(vpin, 1, i2cAddress)) new DS1307(vpin, i2cAddress);
+  }
+ 
+    
+  // Constructor
+    DS1307::DS1307(VPIN vpin,I2CAddress i2cAddress){
+      _firstVpin = vpin;
+      _nPins = 1;
+     _I2CAddress = i2cAddress;
+     addDevice(this);
+    }
+
+uint32_t DS1307::getTime() {
+    // Obtain ss,mm,hh buffers from device
+    uint8_t readBuffer[3];
+    const uint8_t writeBuffer[1]={0};
+
+    // address register 0 for read. 
+    I2CManager.write(_I2CAddress, writeBuffer, 1);
+    if (I2CManager.read(_I2CAddress, readBuffer, 3) != I2C_STATUS_OK) {
+       _deviceState=DEVSTATE_FAILED;
+       return 0;
+    } 
+    _deviceState=DEVSTATE_NORMAL;
+
+    if (debug) {
+      static const char hexchars[]="0123456789ABCDEF";
+      USB_SERIAL.print(F("<*RTC"));
+        for (int i=2;i>=0;i--) {
+          USB_SERIAL.write(' ');  
+          USB_SERIAL.write(hexchars[readBuffer[i]>>4]);
+          USB_SERIAL.write(hexchars[readBuffer[i]& 0x0F ]);
+        }
+        StringFormatter::send(&USB_SERIAL,F(" %d *>\n"),_deviceState);
+      }
+    
+    if (readBuffer[0] & 0x80) {
+        _deviceState=DEVSTATE_INITIALISING;
+        DIAG(F("DS1307 clock in standby"));
+        return 0; // clock is not running
+    }
+    // convert device format to seconds since midnight
+    uint8_t ss=d2b(readBuffer[0]  & 0x7F);
+    uint8_t mm=d2b(readBuffer[1]);
+    uint8_t hh=d2b(readBuffer[2] & 0x3F);
+    return (hh*60ul +mm)*60ul +ss;     
+}
+
+void DS1307::_begin()  {
+  // Initialise  device and sync loop() to zero seconds
+    I2CManager.begin(); 
+    auto tstamp=getTime();
+    if (_deviceState==DEVSTATE_NORMAL) {
+        byte seconds=tstamp%60;
+        delayUntil(micros() + ((60-seconds) * 1000000));
+    }
+    _display(); 
+}
+
+// Processing loop to obtain clock time.
+// This self-synchronizes to the next minute tickover
+void DS1307::_loop(unsigned long currentMicros) { 
+    auto time=getTime();
+    if (_deviceState==DEVSTATE_NORMAL) {
+       byte ss=time%60;
+       CommandDistributor::setClockTime(time/60, 1, 1);      
+       delayUntil(currentMicros + ((60-ss) * 1000000));  
+    }
+}
+
+
+  // Display device driver info.
+  void DS1307::_display()  {
+    auto tstamp=getTime();
+    byte ss=tstamp%60;
+    tstamp/=60;
+    byte mm=tstamp%60;
+    byte hh=tstamp/60;
+    DIAG(F("DS1307 on I2C:%s vpin %d %d:%d:%d %S"), 
+      _I2CAddress.toString(), _firstVpin,
+      hh,mm,ss,
+     (_deviceState==DEVSTATE_FAILED) ? F("OFFLINE") : F(""));
+  }
+
+  // allow user to set the clock 
+  void DS1307::_writeAnalogue(VPIN vpin, int hh, uint8_t mm, uint16_t ss)  {  
+    (void) vpin;
+    uint8_t writeBuffer[3];
+    writeBuffer[0]=1; // write mm,hh first 
+    writeBuffer[1]=((mm/10)<<4) + (mm % 10);  
+    writeBuffer[2]=((hh/10)<<4) + (hh % 10);  
+    I2CManager.write(_I2CAddress, writeBuffer, 3);
+    writeBuffer[0]=0; // write ss  
+    writeBuffer[1]=((ss/10)<<4) + (ss % 10);  
+    I2CManager.write(_I2CAddress, writeBuffer, 2);
+    _loop(micros()); // resync with seconds rollover
+  }
+   
+  // Method to read analogue hh*60+mm time 
+   int DS1307::_readAnalogue(VPIN vpin) { 
+    (void)vpin; 
+    return getTime()/60;
+  };
+

IO_DS1307.h

@@ -0,0 +1,54 @@
+/*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+/*
+* The IO_DS1307 device driver is used to interface a standalone realtime clock. 
+* The clock will announce every minute (which will trigger EXRAIL ONTIME events).
+* Seconds, and Day/date info is ignored, except that the announced hhmm time
+* will attempt to synchronize with the 0 seconds of the clock. 
+* An analog read in EXRAIL (IFGTE(vpin, value) etc will check against the hh*60+mm time.
+* The clock can be easily set by an analog write to the vpin using 24 hr clock time
+* with the command <z vpin hh mm ss> 
+*/
+
+#ifndef IO_DS1307_h
+#define IO_DS1307_h
+
+
+#include "IODevice.h"
+
+class DS1307 : public IODevice {
+public: 
+  static const bool debug=false; 
+  static void create(VPIN vpin, I2CAddress i2cAddress);
+ 
+    
+private:
+  
+  // Constructor
+    DS1307(VPIN vpin,I2CAddress i2cAddress);
+    uint32_t getTime();
+    void _begin() override;
+    void _display() override;
+    void _loop(unsigned long currentMicros) override;
+    int _readAnalogue(VPIN vpin) override;
+    void _writeAnalogue(VPIN vpin, int hh, uint8_t mm, uint16_t ss)  override;
+};
+ 
+#endif

IO_EXFastclock.h

@@ -51,6 +51,7 @@ static void create(I2CAddress i2cAddress) {
   // Start by assuming we will find the clock
   // Check if specified I2C address is responding (blocking operation)
   // Returns I2C_STATUS_OK (0) if OK, or error code.
+  I2CManager.begin();
   uint8_t _checkforclock = I2CManager.checkAddress(i2cAddress);
   DIAG(F("Clock check result - %d"), _checkforclock);
   // XXXX change thistosave2 bytes

IO_EXIOExpander.h

@@ -1,5 +1,6 @@
 /*
  *  © 2022, Peter Cole. All rights reserved.
+ *  © 2024, Harald Barth. All rights reserved.
  *
  *  This file is part of EX-CommandStation
  *
@@ -22,13 +23,10 @@
 * This device driver will configure the device on startup, along with
 * interacting with the device for all input/output duties.
 *
-* To create EX-IOExpander devices, these are defined in myHal.cpp:
+* To create EX-IOExpander devices, these are defined in myAutomation.h:
 * (Note the device driver is included by default)
 *
-* void halSetup() {
-*   // EXIOExpander::create(vpin, num_vpins, i2c_address);
-*   EXIOExpander::create(800, 18, 0x65);
-* }
+* HAL(EXIOExpander,800,18,0x65)
 * 
 * All pins on an EX-IOExpander device are allocated according to the pin map for the specific
 * device in use. There is no way for the device driver to sanity check pins are used for the
@@ -98,25 +96,45 @@ private:
           _numAnaloguePins = receiveBuffer[2];
 
           // See if we already have suitable buffers assigned
-          size_t digitalBytesNeeded = (_numDigitalPins + 7) / 8;
-          if (_digitalPinBytes < digitalBytesNeeded) {
-            // Not enough space, free any existing buffer and allocate a new one
-            if (_digitalPinBytes > 0) free(_digitalInputStates);
-            _digitalInputStates = (byte*) calloc(_digitalPinBytes, 1);
-            _digitalPinBytes = digitalBytesNeeded;
-          }
-          size_t analogueBytesNeeded = _numAnaloguePins * 2;
-          if (_analoguePinBytes < analogueBytesNeeded) {
-            // Free any existing buffers and allocate new ones.
-            if (_analoguePinBytes > 0) {
-              free(_analogueInputBuffer);
-              free(_analogueInputStates);
-              free(_analoguePinMap);
+          if (_numDigitalPins>0) {
+            size_t digitalBytesNeeded = (_numDigitalPins + 7) / 8;
+            if (_digitalPinBytes < digitalBytesNeeded) {
+              // Not enough space, free any existing buffer and allocate a new one
+              if (_digitalPinBytes > 0) free(_digitalInputStates);
+              if ((_digitalInputStates = (byte*) calloc(digitalBytesNeeded, 1)) != NULL) {
+                _digitalPinBytes = digitalBytesNeeded;
+              } else {
+                DIAG(F("EX-IOExpander I2C:%s ERROR alloc %d bytes"), _I2CAddress.toString(), digitalBytesNeeded);
+                _deviceState = DEVSTATE_FAILED;
+                _digitalPinBytes = 0;
+                return;
+              }
+            }
+          }
+          
+          if (_numAnaloguePins>0) {
+            size_t analogueBytesNeeded = _numAnaloguePins * 2;
+            if (_analoguePinBytes < analogueBytesNeeded) {
+              // Free any existing buffers and allocate new ones.
+              if (_analoguePinBytes > 0) {
+                free(_analogueInputBuffer);
+                free(_analogueInputStates);
+                free(_analoguePinMap);
+              }
+              _analogueInputStates = (uint8_t*) calloc(analogueBytesNeeded, 1);
+              _analogueInputBuffer = (uint8_t*) calloc(analogueBytesNeeded, 1);
+              _analoguePinMap = (uint8_t*) calloc(_numAnaloguePins, 1);
+	      if (_analogueInputStates  != NULL &&
+		  _analogueInputBuffer != NULL &&
+		  _analoguePinMap != NULL) {
+		_analoguePinBytes = analogueBytesNeeded;
+	      } else {
+		DIAG(F("EX-IOExpander I2C:%s ERROR alloc analog pin bytes"), _I2CAddress.toString());
+		_deviceState = DEVSTATE_FAILED;
+		_analoguePinBytes = 0;
+		return;
+	      }
             }
-            _analogueInputStates = (uint8_t*) calloc(analogueBytesNeeded, 1);
-            _analogueInputBuffer = (uint8_t*) calloc(analogueBytesNeeded, 1);
-            _analoguePinMap = (uint8_t*) calloc(_numAnaloguePins, 1);
-            _analoguePinBytes = analogueBytesNeeded;
           }
         } else {
           DIAG(F("EX-IOExpander I2C:%s ERROR configuring device"), _I2CAddress.toString());
@@ -124,8 +142,8 @@ private:
           return;
         }
       } 
-      // We now need to retrieve the analogue pin map
-      if (status == I2C_STATUS_OK) {
+      // We now need to retrieve the analogue pin map if there are analogue pins
+      if (status == I2C_STATUS_OK && _numAnaloguePins>0) {
         commandBuffer[0] = EXIOINITA;
         status = I2CManager.read(_I2CAddress, _analoguePinMap, _numAnaloguePins, commandBuffer, 1);
       }
@@ -239,7 +257,7 @@ private:
 
     // If we're not doing anything now, check to see if a new input transfer is due.
     if (_readState == RDS_IDLE) {
-      if (currentMicros - _lastDigitalRead > _digitalRefresh) { // Delay for digital read refresh
+      if (_numDigitalPins>0 && currentMicros - _lastDigitalRead > _digitalRefresh) { // Delay for digital read refresh
         // Issue new read request for digital states.  As the request is non-blocking, the buffer has to
         // be allocated from heap (object state).
         _readCommandBuffer[0] = EXIORDD;
@@ -247,7 +265,7 @@ private:
                                                                 // non-blocking read
         _lastDigitalRead = currentMicros;
         _readState = RDS_DIGITAL;
-      } else if (currentMicros - _lastAnalogueRead > _analogueRefresh) { // Delay for analogue read refresh
+      } else if (_numAnaloguePins>0 && currentMicros - _lastAnalogueRead > _analogueRefresh) { // Delay for analogue read refresh
         // Issue new read for analogue input states
         _readCommandBuffer[0] = EXIORDAN;
         I2CManager.read(_I2CAddress, _analogueInputBuffer,
@@ -362,14 +380,14 @@ private:
   uint8_t _minorVer = 0;
   uint8_t _patchVer = 0;
 
-  uint8_t* _digitalInputStates;
-  uint8_t* _analogueInputStates;
-  uint8_t* _analogueInputBuffer;  // buffer for I2C input transfers
+  uint8_t* _digitalInputStates  = NULL;
+  uint8_t* _analogueInputStates = NULL;
+  uint8_t* _analogueInputBuffer = NULL;  // buffer for I2C input transfers
   uint8_t _readCommandBuffer[1];
 
-  uint8_t _digitalPinBytes = 0;  // Size of allocated memory buffer (may be longer than needed)
-  uint8_t _analoguePinBytes = 0;  // Size of allocated memory buffers (may be longer than needed)
-  uint8_t* _analoguePinMap;
+  uint8_t _digitalPinBytes = 0;   // Size of allocated memory buffer (may be longer than needed)
+  uint8_t _analoguePinBytes = 0;  // Size of allocated memory buffer (may be longer than needed)
+  uint8_t* _analoguePinMap = NULL;
   I2CRB _i2crb;
 
   enum {RDS_IDLE, RDS_DIGITAL, RDS_ANALOGUE};  // Read operation states

IO_EXSensorCAM.h

@@ -0,0 +1,425 @@
+/*  2024/08/14 
+ *  © 2024, Barry Daniel ESP32-CAM revision 
+ *
+ *  This file is part of EX-CommandStation
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#define driverVer 306
+// v306 Pass vpin to regeister it in CamParser.
+//      Move base vpin to camparser. 
+//      No more need for config.h settings.
+// v305 less debug & alpha ordered switch
+// v304 static oldb0;  t(##[,%%]; 
+// v303 zipped with CS 5.2.76 and uploaded to repo (with debug)
+// v302 SEND=StringFormatter::send, remove Sp(), add 'q', memcpy( .8) -> .7); 
+// v301 improved 'f','p'&'q' code and driver version calc. Correct bsNo calc. for 'a'							 
+// v300 stripped & revised without expander functionality. Needs sensorCAM.h v300 AND CamParser.cpp
+// v222 uses '@'for EXIORDD read.  handles <NB $> and <NN $ ##>
+// v216 includes 'j' command and uses CamParser rather than myFilter.h Incompatible with v203 senorCAM
+// v203 added pvtThreshold to 'i' output
+// v201 deleted code for compatibility with CAM pre v171. Needs CAM ver201 with o06 only
+// v200 rewrite reduces need for double reads of ESP32 slave CAM. Deleted ESP32CAP. 
+//  Inompatible with pre-v170 sensorCAM, unless set S06 to 0 and S07 to 1 (o06 & l07 say)
+/*
+ * The IO_EXSensorCAM.h device driver can integrate with the sensorCAM device.
+ * It is modelled on the IO_EXIOExpander.h device driver to include specific needs of the ESP32 sensorCAM 
+ * This device driver will configure the device on startup, along with CamParser.cpp
+ * interacting with the sensorCAM device for all input/output duties.
+ *
+ * To create EX-SensorCAM devices, 
+ *  use HAL(EXSensorCAM, baseVpin, numpins, i2c_address) in myAutomation.h
+ * e.g.  
+ *   HAL(EXSensorCAM,700, 80, 0x11)
+ * 
+ * or (deprecated) define them in myHal.cpp: with
+ * EXSensorCAM::create(baseVpin,num_vpins,i2c_address);
+ * 
+*/
+#ifndef IO_EX_EXSENSORCAM_H
+#define IO_EX_EXSENSORCAM_H
+#define DIGITALREFRESH 20000UL      // min uSec delay between digital reads of digitalInputStates
+#define SEND StringFormatter::send
+#include "IODevice.h"
+#include "I2CManager.h"
+#include "DIAG.h"
+#include "FSH.h"
+#include "CamParser.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+ * IODevice subclass for EX-SensorCAM.
+*/
+class EXSensorCAM : public IODevice {
+  public:
+    static void create(VPIN vpin, int nPins, I2CAddress i2cAddress) {
+      if (checkNoOverlap(vpin, nPins, i2cAddress)) 
+      new EXSensorCAM(vpin, nPins, i2cAddress);
+    }
+  																
+    					   
+
+  private:
+   // Constructor
+    EXSensorCAM(VPIN firstVpin, int nPins, I2CAddress i2cAddress) {
+      _firstVpin = firstVpin;
+     // Number of pins cannot exceed 255 (1 byte) because of I2C message structure.
+      if (nPins > 80) nPins = 80;
+      _nPins = nPins;
+      _I2CAddress = i2cAddress;
+      addDevice(this);
+      CamParser::addVpin(firstVpin); 
+    }
+//*************************
+void _begin() {
+    uint8_t status;
+    // Initialise EX-SensorCAM device
+    I2CManager.setClock(100000);  // Set speed for I2C operations
+    I2CManager.begin();
+    if (!I2CManager.exists(_I2CAddress)) {
+      DIAG(F("EX-SensorCAM I2C:%s device not found"), _I2CAddress.toString());
+      _deviceState = DEVSTATE_FAILED;
+      return;
+    }else {
+      uint8_t commandBuffer[4]={EXIOINIT,(uint8_t)_nPins,(uint8_t)(_firstVpin & 0xFF),(uint8_t)(_firstVpin>>8)};                                                                                 
+      status = I2CManager.read(_I2CAddress,_inputBuf,sizeof(_inputBuf),commandBuffer,sizeof(commandBuffer));
+        //EXIOINIT needed to trigger and send firstVpin to CAM
+
+      if (status == I2C_STATUS_OK) {
+        // Attempt to get version, non-blocking results in poor placement of response.  Can be blocking here! 
+        commandBuffer[0] = '^';    //new version code
+    
+        status = I2CManager.read(_I2CAddress, _inputBuf, sizeof(_inputBuf), commandBuffer, 1); 
+         // for ESP32 CAM, read again for good immediate response version data
+        status = I2CManager.read(_I2CAddress, _inputBuf, sizeof(_inputBuf), commandBuffer, 1);
+        
+        if (status == I2C_STATUS_OK) {
+          _majorVer= _inputBuf[1]/10;	
+          _minorVer= _inputBuf[1]%10;
+          _patchVer= _inputBuf[2];				
+          DIAG(F("EX-SensorCAM device found, I2C:%s, Version v%d.%d.%d"),
+                       _I2CAddress.toString(),_majorVer, _minorVer,_patchVer);
+        }  	
+      }
+      if (status != I2C_STATUS_OK)
+        reportError(status);
+    } 
+}
+//*************************
+// Digital input pin configuration, used to enable on EX-IOExpander device and set pullups if requested.
+// Configuration isn't done frequently so we can use blocking I2C calls here, and so buffers can
+// be allocated from the stack to reduce RAM allocation.
+bool _configure(VPIN vpin, ConfigTypeEnum configType, int paramCount, int params[]) override { 
+  (void)configType; (void)params; // unused
+  if(_verPrint) DIAG(F("_configure() driver IO_EXSensorCAM v0.%d.%d vpin: %d "), driverVer/100,driverVer%100,vpin);
+  _verPrint=false;           //only give driver versions once
+  if (paramCount != 1) return false;
+  return true; //at least confirm that CAM is (always) configured (no vpin check!)
+}
+//*************************															 
+// Analogue input pin configuration, used to enable an EX-IOExpander device.
+int _configureAnalogIn(VPIN vpin) override { 
+  DIAG(F("_configureAnalogIn() IO_EXSensorCAM vpin %d"),vpin); 
+  return true;     // NOTE: use of EXRAIL IFGTE() etc use "analog" reads.
+}
+//*************************
+// Main loop, collect both digital and "analog" pin states continuously (faster sensor/input reads)
+void _loop(unsigned long currentMicros) override {
+    if (_deviceState == DEVSTATE_FAILED) return;    
+      // Request block is used for "analogue" (cmd. data) and digital reads from the sensorCAM, which 
+      // are performed on a cyclic basis.  Writes are performed synchronously as and when requested.
+    if (_readState != RDS_IDLE) {                  //expecting a return packet
+      if (_i2crb.isBusy()) return;                 // If I2C operation still in progress, return
+      uint8_t status = _i2crb.status;
+      if (status == I2C_STATUS_OK) {               // If device request ok, read input data
+        //apparently the above checks do not guarantee a good packet! error rate about 1 pkt per 1000
+        //there should be a packet in _CAMresponseBuff[32]            
+        if ((_CAMresponseBuff[0] & 0x60) >= 0x60) {   //Buff[0] seems to have ascii cmd header (bit6 high) (o06)    
+            int error = processIncomingPkt( _CAMresponseBuff, _CAMresponseBuff[0]);   // '~' 'i' 'm' 'n' 't' etc
+              if (error>0) DIAG(F("CAM packet header(0x%x) not recognised"),_CAMresponseBuff[0]);                   
+        }else{ // Header not valid - typically replaced by bank 0 data!  To avoid any bad responses set S06 to 0  
+               // Versions of sensorCAM.h after v300 should return header for '@' of '`'(0x60) (not 0xE6)  
+               // followed by digitalInputStates sensor state array
+        }
+      }else   reportError(status, false);   // report i2c eror but don't go offline.
+      _readState = RDS_IDLE;
+    }      
+  
+    // If we're not doing anything now, check to see if a new state table transfer, or for 't' repeat, is due.
+    if (_readState == RDS_IDLE) {    //check if time for digitalRefresh   
+      if ( currentMicros - _lastDigitalRead > _digitalRefresh) { 
+        // Issue new read request for digital states.  
+             
+        _readCommandBuffer[0] = '@';  //start new read of digitalInputStates Table     // non-blocking read 
+        I2CManager.read(_I2CAddress,_CAMresponseBuff, 32,_readCommandBuffer, 1, &_i2crb);     
+        _lastDigitalRead = currentMicros;
+        _readState = RDS_DIGITAL;
+        
+      }else{    //slip in a repeat <NT n> if pending
+        if (currentMicros - _lasttStateRead > _tStateRefresh)  // Delay for "analog" command repetitions
+         if (_savedCmd[2]>1) {   //repeat a 't' command         
+          for (int i=0;i<7;i++)  _readCommandBuffer[i] =_savedCmd[i];
+          int errors = ioESP32(_I2CAddress, _CAMresponseBuff, 32, _readCommandBuffer, 7);    
+          _lasttStateRead = currentMicros;
+          _savedCmd[2] -= 1;     //decrement repeats                  
+          if (errors==0) return;
+          DIAG(F("ioESP32 error %d header 0x%x"),errors,_CAMresponseBuff[0]);  
+          _readState = RDS_TSTATE;  //this should stop further cmd requests until packet read (or timeout)
+        }
+      }   //end repeat 't'
+    }
+  }   
+//*************************
+// Obtain the bank of 8 sensors as an "analog" value
+// can be used to track the position through a sequential sensor bank
+int _readAnalogue(VPIN vpin) override {
+  if (_deviceState == DEVSTATE_FAILED) return 0;        
+  return _digitalInputStates[(vpin - _firstVpin) / 8];
+}
+//*************************
+// Obtain the correct digital sensor input value
+int _read(VPIN vpin) override {
+  if (_deviceState == DEVSTATE_FAILED) return 0;
+  int pin = vpin - _firstVpin;
+  return bitRead(_digitalInputStates[pin / 8], pin % 8);
+}
+//*************************
+// Write digital value.  
+void _write(VPIN vpin, int value) override { 
+  DIAG(F("**_write() vpin %d = %d"),vpin,value);
+  return ;
+}
+//*************************
+// i2cAddr of ESP32 CAM
+// rBuf   buffer for return packet 
+// inbytes number of bytes to request from CAM
+// outBuff holds outbytes to be sent to CAM  
+int ioESP32(uint8_t i2cAddr,uint8_t *rBuf,int inbytes,uint8_t *outBuff,int outbytes) {
+  uint8_t status = _i2crb.status;
+
+ while( _i2crb.status != I2C_STATUS_OK){status = _i2crb.status;}   //wait until bus free
+
+  status = I2CManager.read(i2cAddr, rBuf, inbytes, outBuff, outbytes);
+        
+  if (status != I2C_STATUS_OK){ 
+    DIAG(F("EX-SensorCAM I2C:%s Error:%d %S"), _I2CAddress.toString(), status, I2CManager.getErrorMessage(status));
+    reportError(status); return status;
+  }
+  return 0;  // 0 for no error != 0 for error number.
+}
+//*************************
+//function to interpret packet from sensorCAM.ino
+//i2cAddr to identify CAM# (if # >1)
+//rBuf contains packet of up to 32 bytes usually with (ascii) cmd header in rBuf[0]
+//sensorCmd command header byte from CAM (in rBuf[0]?)
+int processIncomingPkt(uint8_t *rBuf,uint8_t sensorCmd) {
+//static uint8_t oldb0;   //for debug only
+  int k; 
+  int b;
+  char str[] = "11111111";
+ // if (sensorCmd <= '~') DIAG(F("processIncomingPkt %c %d %d %d"),rBuf[0],rBuf[1],rBuf[2],rBuf[3]);
+  switch (sensorCmd){
+    case '`':      //response to request for digitalInputStates[] table  '@'=>'`'  
+      memcpy(_digitalInputStates, rBuf+1, digitalBytesNeeded);
+//      if ( _digitalInputStates[0]!=oldb0) { oldb0=_digitalInputStates[0];  //debug
+//        for (k=0;k<5;k++) {Serial.print(" ");Serial.print(_digitalInputStates[k],HEX);}
+//      }
+      break;                                                 
+
+    case EXIORDY:  //some commands give back acknowledgement only
+      break;
+
+    case CAMERR:   //cmd format error code from CAM
+      DIAG(F("CAM cmd error 0xFE 0x%x"),rBuf[1]); 
+      break;
+
+    case '~':      //information from '^' version request <N v[er]>
+      DIAG(F("EX-SensorCAM device found, I2C:%s,CAM Version v%d.%d.%d vpins %u-%u"),
+              _I2CAddress.toString(), rBuf[1]/10, rBuf[1]%10, rBuf[2],(int) _firstVpin, (int) _firstVpin +_nPins-1);
+      DIAG(F("IO_EXSensorCAM driver  v0.%d.%d vpin: %d "), driverVer/100,driverVer%100,_firstVpin);
+      break;
+ 
+    case 'f':
+      DIAG(F("(f %%%%) frame header 'f' for bsNo %d/%d - showing Quarter sample (1 row) only"), rBuf[1]/8,rBuf[1]%8);  
+      SEND(&USB_SERIAL,F("<n  row: %d  Ref bytes: "),rBuf[2]);
+      for(k=3;k<15;k++)
+        SEND(&USB_SERIAL,F("%x%x%s"), rBuf[k]>>4, rBuf[k]&15, k%3==2 ? "  " : " "); 
+      Serial.print(" latest grab: "); 
+      for(k=16;k<28;k++)
+        SEND(&USB_SERIAL,F("%x%x%s"), rBuf[k]>>4, rBuf[k]&15, (k%3==0) ? "  " : " ");
+      Serial.print(" n>\n");
+      break; 
+
+    case 'i':      //information from i%%
+      k=256*rBuf[5]+rBuf[4];
+      DIAG(F("(i%%%%[,$$]) Info: Sensor 0%o(%d) enabled:%d status:%d row=%d x=%d Twin=0%o pvtThreshold=%d A~%d")
+              ,rBuf[1],rBuf[1],rBuf[3],rBuf[2],rBuf[6],k,rBuf[7],rBuf[9],int(rBuf[8])*16);	 
+      break;
+
+    case 'm':
+      DIAG(F("(m$[,##]) Min/max: $ frames min2flip (trip) %d, maxSensors 0%o, minSensors 0%o, nLED %d,"
+              " threshold %d, TWOIMAGE_MAXBS 0%o"),rBuf[1],rBuf[3],rBuf[2],rBuf[4],rBuf[5],rBuf[6]);
+      break;
+
+    case 'n':
+      DIAG(F("(n$[,##]) Nominate: $ nLED %d, ## minSensors 0%o (maxSensors 0%o threshold %d)")
+                                       ,rBuf[4],rBuf[2],rBuf[3],rBuf[5]);                                                               
+      break;
+
+    case 'p':
+      b=rBuf[1]-2;  
+      if(b<4) { Serial.print("<n (p%%) Bank empty  n>\n"); break; }
+      SEND(&USB_SERIAL,F("<n (p%%) Bank: %d "),(0x7F&rBuf[2])/8);
+      for (int j=2; j<b; j+=3)  
+        SEND(&USB_SERIAL,F(" S[%d%d]: r=%d x=%d"),0x7F&rBuf[j]/8,0x7F&rBuf[j]%8,rBuf[j+1],rBuf[j+2]+2*(rBuf[j]&0x80));
+      Serial.print("  n>\n");
+      break;
+
+    case 'q':
+      for (int i =0; i<8; i++) str[i] = ((rBuf[2] << i) & 0x80 ? '1' : '0');
+      DIAG(F("(q $) Query bank %c ENABLED sensors(S%c7-%c0): %s "), rBuf[1], rBuf[1], rBuf[1], str);
+      break;
+
+    case 't':      //threshold etc. from t##           //bad pkt if 't' FF's
+      if(rBuf[1]==0xFF) {Serial.println("<n bad CAM 't' packet: 74 FF  n>");_savedCmd[2] +=1; return 0;}
+      SEND(&USB_SERIAL,F("<n (t[##[,%%%%]]) Threshold:%d sensor S00:-%d"),rBuf[1],min(rBuf[2]&0x7F,99));
+      if(rBuf[2]>127) Serial.print("##* "); 
+      else{ 
+        if(rBuf[2]>rBuf[1]) Serial.print("-?* "); 
+        else Serial.print("--* ");
+      }
+      for(int i=3;i<31;i+=2){
+        uint8_t valu=rBuf[i];        //get bsn
+        if(valu==80) break;          //80 = end flag
+        else{ 
+          SEND(&USB_SERIAL,F("%d%d:"), (valu&0x7F)/8,(valu&0x7F)%8);
+          if(valu>=128) Serial.print("?-"); 
+          else {if(rBuf[i+1]>=128) Serial.print("oo");else Serial.print("--");}
+          valu=rBuf[i+1]; 
+          SEND(&USB_SERIAL,F("%d%s"),min(valu&0x7F,99),(valu<128) ? "--* ":"##* ");
+        }
+      } 
+      Serial.print(" >\n");
+      break;
+
+    default:        //header not a recognised cmd character
+      DIAG(F("CAM packet header not valid (0x%x) (0x%x) (0x%x)"),rBuf[0],rBuf[1],rBuf[2]);
+      return 1;
+  }			 
+  return 0;  
+}
+//*************************											  
+// Write (analogue) 8bit (command) values.  Write the parameters to the sensorCAM
+void _writeAnalogue(VPIN vpin, int param1, uint8_t camop, uint16_t param3) override {
+    uint8_t outputBuffer[7];
+    int errors=0;
+    outputBuffer[0] = camop;  
+    int pin = vpin - _firstVpin;
+
+    if(camop >= 0x80) {   //case "a" (4p) also (3p) e.g. <N 713 210 310> 
+      camop=param1;        //put row (0-236) in expected place 
+      param1=param3;        //put column in expected place
+      outputBuffer[0] = 'A';
+      pin = (pin/8)*10 + pin%8;   //restore bsNo. as integer
+    }   
+    if (_deviceState == DEVSTATE_FAILED) return;
+   
+    outputBuffer[1] = pin;          //vpin => bsn
+    outputBuffer[2] = param1 & 0xFF;
+    outputBuffer[3] = param1 >> 8;
+    outputBuffer[4] = camop;        //command code
+    outputBuffer[5] = param3 & 0xFF;
+    outputBuffer[6] = param3 >> 8;
+
+    int count=param1+1;
+    if(camop=='Q'){
+      if(param3<=10) {count=param3; camop='B';}
+      //if(param1<10) outputBuffer[2] = param1*10;
+    }
+    if(camop=='B'){   //then 'b'(b%) cmd - can totally deal with that here. (but can't do b%,# (brightSF))
+      if(param1>97) return;
+      if(param1>9) param1 = param1/10;  //accept a bsNo
+      for(int bnk=param1;bnk<count;bnk++) {
+        uint8_t b=_digitalInputStates[bnk];
+        char str[] = "11111111";
+        for (int i=0;i<8;i++) if(((b<<i)&0x80) == 0) str[i]='0';
+        DIAG(F("(b $) Bank: %d activated byte: 0x%x%x (sensors S%d7->%d0) %s"), bnk,b>>4,b&15,bnk,bnk,str ); 
+      }
+      return;
+    } 
+    if (outputBuffer[4]=='T') {   //then 't' cmd
+      if(param1<31) {   //repeated calls if param < 31
+          //for (int i=0;i<7;i++) _savedCmd[i]=outputBuffer[i];
+        memcpy( _savedCmd, outputBuffer, 7);
+      }else _savedCmd[2] = 0;   //no repeats if ##>30 
+    }else _savedCmd[2] = 0;       //no repeats unless 't'
+  
+    _lasttStateRead = micros();    //don't repeat until _tStateRefresh mSec
+
+    errors = ioESP32(_I2CAddress, _CAMresponseBuff, 32 , outputBuffer, 7);  //send to esp32-CAM
+    if (errors==0) return;
+    else {    //       if (_CAMresponseBuff[0] != EXIORDY)   //can't be sure what is inBuff[0] !
+      DIAG(F("ioESP32 i2c error %d header 0x%x"),errors,_CAMresponseBuff[0]);  
+    }
+}
+//*************************
+ // Display device information and status.
+  void _display() override {
+    DIAG(F("EX-SensorCAM I2C:%s v%d.%d.%d Vpins %u-%u %S"),
+              _I2CAddress.toString(), _majorVer, _minorVer, _patchVer,
+              (int)_firstVpin, (int)_firstVpin+_nPins-1,
+              _deviceState == DEVSTATE_FAILED ? F("OFFLINE") : F(""));
+  }
+//*************************
+// Helper function for error handling
+void reportError(uint8_t status, bool fail=true) {
+  DIAG(F("EX-SensorCAM I2C:%s Error:%d (%S)"), _I2CAddress.toString(), 
+        status, I2CManager.getErrorMessage(status));
+  if (fail)  _deviceState = DEVSTATE_FAILED;
+}
+//************************* 
+  uint8_t _numDigitalPins = 80;   
+  size_t  digitalBytesNeeded=10;
+  uint8_t _CAMresponseBuff[34];
+  
+  uint8_t _majorVer = 0;
+  uint8_t _minorVer = 0;
+  uint8_t _patchVer = 0;
+
+  uint8_t _digitalInputStates[10];
+  I2CRB _i2crb;
+  uint8_t _inputBuf[12];
+  byte _outputBuffer[8];
+
+  bool    _verPrint=true;
+
+  uint8_t _readCommandBuffer[8];
+  uint8_t _savedCmd[8];           //for repeat 't' command
+  //uint8_t _digitalPinBytes = 10;  // Size of allocated memory buffer (may be longer than needed)
+
+  enum {RDS_IDLE, RDS_DIGITAL, RDS_TSTATE};  // Read operation states
+  uint8_t _readState = RDS_IDLE;
+  //uint8_t cmdBuffer[7]={0,0,0,0,0,0,0};
+  unsigned long _lastDigitalRead = 0;
+  unsigned long _lasttStateRead = 0;
+  unsigned long _digitalRefresh = DIGITALREFRESH;  // Delay refreshing digital inputs for 10ms
+  const unsigned long _tStateRefresh = 120000UL;   // Delay refreshing repeat "tState" inputs
+
+  enum {
+    EXIOINIT = 0xE0,    // Flag to initialise setup procedure
+    EXIORDY = 0xE1,     // Flag we have completed setup procedure, also for EX-IO to ACK setup
+    CAMERR = 0xFE
+  };
+};
+#endif

IO_EXTurntable.cpp

@@ -83,6 +83,7 @@ void EXTurntable::_loop(unsigned long currentMicros) {
 // Read returns status as obtained in our loop.
 // Return false if our status value is invalid.
 int EXTurntable::_read(VPIN vpin) {
+  (void)vpin; // surpress warning
   if (_deviceState == DEVSTATE_FAILED) return 0;
   if (_stepperStatus > 1) {
     return false;
@@ -127,6 +128,8 @@ void EXTurntable::_writeAnalogue(VPIN vpin, int value, uint8_t activity, uint16_
     vpin, value, activity, duration);
   DIAG(F("I2CManager write I2C Address:%d stepsMSB:%d stepsLSB:%d activity:%d"),
     _I2CAddress.toString(), stepsMSB, stepsLSB, activity);
+#else
+  (void)duration;
 #endif
   if (activity < 4) _stepperStatus = 1;     // Tell the device driver Turntable-EX is busy
   _previousStatus = _stepperStatus;

IO_EncoderThrottle.cpp

@@ -0,0 +1,144 @@
+/*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *
+ *  This file is part of EX-CommandStation
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+/*
+* The IO_EncoderThrottle device driver uses a rotary encoder connected to vpins
+* to drive a loco.
+*  Loco id is selected by writeAnalog.
+*/
+
+#include "IODevice.h"
+#include "IO_EncoderThrottle.h"
+#include "DIAG.h"
+#include "DCC.h"
+
+const byte _DIR_CW = 0x10;  // Clockwise step
+const byte _DIR_CCW = 0x20;  // Counter-clockwise step
+
+const byte transition_table[5][4]= {
+    {0,1,3,0},            // 0: 00
+    {1,1,1,2 | _DIR_CW},  // 1: 00->01
+    {2,2,0,2},            // 2: 00->01->11
+    {3,3,3,4 | _DIR_CCW}, // 3: 00->10
+    {4,0,4,4}             // 4: 00->10->11
+};
+
+const byte _STATE_MASK = 0x07;
+const byte _DIR_MASK = 0x30;
+
+
+
+  void EncoderThrottle::create(VPIN firstVpin, int dtPin, int clkPin, int clickPin, byte notch) {
+    if (checkNoOverlap(firstVpin)) new EncoderThrottle(firstVpin, dtPin,clkPin,clickPin,notch);
+  }
+
+
+  // Constructor
+  EncoderThrottle::EncoderThrottle(VPIN firstVpin, int dtPin, int clkPin, int clickPin, byte notch){
+    _firstVpin = firstVpin;
+    _nPins = 1;
+    _I2CAddress = 0;
+    _dtPin=dtPin;
+    _clkPin=clkPin;
+    _clickPin=clickPin;
+    _notch=notch;
+    _locoid=0;
+    _stopState=xrSTOP;
+    _rocoState=0; 
+    _prevpinstate=4; // not 01..11 
+    IODevice::configureInput(dtPin,true);
+    IODevice::configureInput(clkPin,true);
+    IODevice::configureInput(clickPin,true);
+    addDevice(this);
+    _display();
+  }
+
+  
+
+  void EncoderThrottle::_loop(unsigned long currentMicros)  {
+    if (_locoid==0) return;  // not in use
+    
+    // Clicking down on the roco, stops the loco and sets the direction as unknown.
+  if (IODevice::read(_clickPin)) {
+    if (_stopState==xrSTOP) return; // debounced multiple stops
+    DCC::setThrottle(_locoid,1,DCC::getThrottleDirection(_locoid));
+    _stopState=xrSTOP;
+    DIAG(F("DRIVE %d STOP"),_locoid);
+    return; 
+  }
+
+  // read roco pins and detect state change 
+  byte pinstate = (IODevice::read(_dtPin) << 1) | IODevice::read(_clkPin);
+  if (pinstate==_prevpinstate) return;
+  _prevpinstate=pinstate;
+
+  _rocoState = transition_table[_rocoState & _STATE_MASK][pinstate];
+  if ((_rocoState & _DIR_MASK) == 0) return; // no value change 
+
+  int change=(_rocoState & _DIR_CW)?+1:-1;
+  // handle roco change -1 or +1 (clockwise)
+  
+  if (_stopState==xrSTOP) {
+      // first move after button press sets the direction. (clockwise=fwd)
+      _stopState=change>0?xrFWD:xrREV;
+    }
+
+    // when going fwd, clockwise increases speed. 
+    // but when reversing, anticlockwise increases speed.
+    // This is similar to a center-zero pot control but with
+    // the added safety that you cant panic-spin into the other
+    // direction.
+    if (_stopState==xrREV) change=-change; 
+    //  manage limits
+    int oldspeed=DCC::getThrottleSpeed(_locoid);
+    if (oldspeed==1)oldspeed=0; // break out of estop
+    int  newspeed=change>0 ?  (min((oldspeed+_notch),126)) : (max(0,(oldspeed-_notch)));
+    if (newspeed==1) newspeed=0; // normal decelereated stop. 
+    if (oldspeed!=newspeed) {
+        DIAG(F("DRIVE %d notch %S %d %S"),_locoid,
+             change>0?F("UP"):F("DOWN"),_notch,
+             _stopState==xrFWD?F("FWD"):F("REV"));
+        DCC::setThrottle(_locoid,newspeed,_stopState==xrFWD);
+        }
+}
+
+  // Selocoid as analog value to start drive
+  // use <z vpin locoid [notch]>
+  void EncoderThrottle::_writeAnalogue(VPIN vpin, int value, uint8_t param1, uint16_t param2)  {  
+    (void) param2;
+    _locoid=value;
+    if (param1>0) _notch=param1;
+    _rocoState=0;
+    
+    // If loco is moving, we inherit direction from it.
+    _stopState=xrSTOP;
+    if (_locoid>0) {
+        auto speedbyte=DCC::getThrottleSpeedByte(_locoid);
+        if ((speedbyte & 0x7f) >1) {
+            // loco is moving
+            _stopState= (speedbyte & 0x80)?xrFWD:xrREV;
+        } 
+    }
+    _display();
+  }
+
+  
+  void EncoderThrottle::_display() {
+    DIAG(F("DRIVE vpin %d loco %d notch %d"),_firstVpin,_locoid,_notch);
+  }

IO_EncoderThrottle.h

@@ -0,0 +1,53 @@
+/*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *
+ *  This file is part of EX-CommandStation
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+/*
+* The IO_EncoderThrottle device driver uses a rotary encoder connected to vpins
+* to drive a loco.
+*  Loco id is selected by writeAnalog.
+*/
+
+#ifndef IO_EncoderThrottle_H
+#define IO_EncoderThrottle_H
+#include "IODevice.h"
+
+class EncoderThrottle : public IODevice {
+public:
+  
+  static void create(VPIN firstVpin, int dtPin, int clkPin, int clickPin, byte notch=10);
+ 
+private:
+  int _dtPin,_clkPin,_clickPin, _locoid, _notch,_prevpinstate; 
+  enum {xrSTOP,xrFWD,xrREV} _stopState;
+  byte _rocoState;  
+
+  // Constructor
+  EncoderThrottle(VPIN firstVpin, int dtPin, int clkPin, int clickPin, byte notch);
+  
+  void _loop(unsigned long currentMicros) override ;
+
+  // Selocoid as analog value to start drive
+  // use <z vpin locoid [notch]>
+  void _writeAnalogue(VPIN vpin, int value, uint8_t param1, uint16_t param2) override;
+  
+  void _display() override ;
+
+ };
+
+#endif

IO_ExampleSerial.h

@@ -162,4 +162,4 @@ protected:
 
 };
 
-#endif // IO_EXAMPLESERIAL_H
+#endif // IO_EXAMPLESERIAL_H

IO_HALDisplay.h

@@ -1,7 +1,9 @@
 /*
- *  © 2023, Neil McKechnie. All rights reserved.
+ *  © 2024, Paul Antoine
+ *  © 2023, Neil McKechnie
+ *  All rights reserved.
  *  
- *  This file is part of DCC++EX API
+ *  This file is part of DCC-EX API
  *
  *  This is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -112,13 +114,14 @@ protected:
     // Fill buffer with spaces
     memset(_buffer, ' ', _numCols*_numRows);
 
-    _displayDriver->clearNative();
-
     // Add device to list of HAL devices (not necessary but allows
     // status to be displayed using <D HAL SHOW> and device to be
     // reinitialised using <D HAL RESET>).
     IODevice::addDevice(this);
 
+    // Moved after addDevice() to ensure I2CManager.begin() has been called fisrt
+    _displayDriver->clearNative();
+
     // Also add this display to list of display handlers
     DisplayInterface::addDisplay(displayNo);
 
@@ -259,4 +262,4 @@ public:
 
 };
 
-#endif // IO_HALDisplay_H
+#endif // IO_HALDisplay_H

IO_I2CDFPlayer.h

@@ -0,0 +1,814 @@
+   /*
+ *  © 2023, Neil McKechnie. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * DFPlayer is an MP3 player module with an SD card holder.  It also has an integrated
+ * amplifier, so it only needs a power supply and a speaker.
+ * This driver is a modified version of the IO_DFPlayer.h file
+ * *********************************************************************************************
+ * 
+ * Dec 2023, Added NXP SC16IS752 I2C Dual UART to enable the DFPlayer connection over the I2C bus
+ * The SC16IS752 has 64 bytes TX & RX FIFO buffer
+ * First version without interrupts from I2C UART and only RX/TX are used, interrupts may not be
+ * needed as the RX Fifo holds the reply 
+ * 
+ * Jan 2024, Issue with using both UARTs simultaniously, the secod uart seems to work  but the first transmit 
+ * corrupt data. This need more analysis and experimenatation. 
+ * Will push this driver to the dev branch with the uart fixed to 0 
+ * Both SC16IS750 (single uart) and SC16IS752 (dual uart, but only uart 0 is enable)
+ * 
+ * myHall.cpp configuration syntax:
+ * 
+ * I2CDFPlayer::create(1st vPin, vPins, I2C address, xtal);
+ * 
+ * Parameters:
+ * 1st vPin     : First virtual pin that EX-Rail can control to play a sound, use PLAYSOUND command (alias of ANOUT)
+ * vPins        : Total number of virtual pins allocated (2 vPins are supported, one for each UART)
+ *                1st vPin for UART 0, 2nd for UART 1
+ * I2C Address  : I2C address of the serial controller, in 0x format
+ * xtal         : 0 for 1,8432Mhz, 1 for 14,7456Mhz
+ * 
+ * The vPin is also a pin that can be read, it indicate if the DFPlayer has finished playing a track
+ *
+ */
+
+#ifndef IO_I2CDFPlayer_h
+#define IO_I2CDFPlayer_h
+
+#include "IODevice.h"
+#include "I2CManager.h"
+#include "DIAG.h"
+
+// Debug and diagnostic defines, enable too many will result in slowing the driver
+//#define DIAG_I2CDFplayer
+//#define DIAG_I2CDFplayer_data
+//#define DIAG_I2CDFplayer_reg
+//#define DIAG_I2CDFplayer_playing
+
+class I2CDFPlayer : public IODevice {
+private: 
+  const uint8_t MAXVOLUME=30;
+  uint8_t RETRYCOUNT = 0x03;
+  bool _playing = false;
+  uint8_t _inputIndex = 0;
+  unsigned long _commandSendTime; // Time (us) that last transmit took place.
+  unsigned long _timeoutTime;
+  uint8_t _recvCMD;  // Last received command code byte
+  bool _awaitingResponse = false;  
+  uint8_t _retryCounter = RETRYCOUNT; // Max retries before timing out
+  uint8_t _requestedVolumeLevel = MAXVOLUME;
+  uint8_t _currentVolume = MAXVOLUME;
+  int _requestedSong = -1;  // -1=none, 0=stop, >0=file number
+  bool _repeat = false; // audio file is repeat playing
+  uint8_t _previousCmd = true;
+  // SC16IS752 defines
+  I2CAddress _I2CAddress;
+  I2CRB _rb;
+  uint8_t _UART_CH=0x00;  // Fix uart ch to 0 for now
+  // Communication parameters for the DFPlayer are fixed at 8 bit, No parity, 1 stopbit
+  uint8_t WORD_LEN = 0x03;    // Value LCR bit 0,1
+  uint8_t STOP_BIT = 0x00;    // Value LCR bit 2 
+  uint8_t PARITY_ENA = 0x00;  // Value LCR bit 3
+  uint8_t PARITY_TYPE = 0x00; // Value LCR bit 4
+  uint32_t BAUD_RATE = 9600;
+  uint8_t PRESCALER = 0x01;   // Value MCR bit 7
+  uint8_t TEMP_REG_VAL = 0x00;
+  uint8_t FIFO_RX_LEVEL = 0x00;
+  uint8_t RX_BUFFER = 0x00; // nr of bytes copied into _inbuffer
+  uint8_t FIFO_TX_LEVEL = 0x00;  
+  bool _playCmd = false;
+  bool _volCmd = false;
+  bool _folderCmd = false;
+  uint8_t _requestedFolder = 0x01; // default to folder 01
+  uint8_t _currentFolder = 0x01; // default to folder 01
+  bool _repeatCmd = false;
+  bool _stopplayCmd = false;
+  bool _resetCmd = false;
+  bool _eqCmd = false;
+  uint8_t _requestedEQValue = DF_NORMAL;
+  uint8_t _currentEQvalue = DF_NORMAL; // start equalizer value
+  bool _daconCmd = false;
+  uint8_t _audioMixer = 0x01; // Default to output amplifier 1
+  bool _setamCmd = false; // Set the Audio mixer channel
+  uint8_t _outbuffer [11]; // DFPlayer command is 10 bytes + 1 byte register address & UART channel
+  uint8_t _inbuffer[10]; // expected DFPlayer return 10 bytes
+   
+  unsigned long _sc16is752_xtal_freq;
+  unsigned long SC16IS752_XTAL_FREQ_LOW = 1843200; // To support cheap eBay/AliExpress SC16IS752 boards
+  unsigned long SC16IS752_XTAL_FREQ_HIGH = 14745600; // Support for higher baud rates, standard for modular EX-IO system
+   
+public:
+  // Constructor
+   I2CDFPlayer(VPIN firstVpin, int nPins, I2CAddress i2cAddress, uint8_t xtal){
+    _firstVpin = firstVpin;
+    _nPins = nPins;
+    _I2CAddress = i2cAddress;
+    if (xtal == 0){
+      _sc16is752_xtal_freq = SC16IS752_XTAL_FREQ_LOW;
+    } else { // should be 1
+        _sc16is752_xtal_freq = SC16IS752_XTAL_FREQ_HIGH;
+      }
+    addDevice(this);
+   } 
+  
+public:
+  static void create(VPIN firstVpin, int nPins, I2CAddress i2cAddress, uint8_t xtal) {
+    if (checkNoOverlap(firstVpin, nPins, i2cAddress)) new I2CDFPlayer(firstVpin, nPins, i2cAddress, xtal); 
+    }
+
+  void _begin() override {
+    // check if SC16IS752 exist first, initialize and then resume DFPlayer init via SC16IS752
+    I2CManager.begin();
+    I2CManager.setClock(1000000);
+    if (I2CManager.exists(_I2CAddress)){
+      DIAG(F("SC16IS752 I2C:%s UART detected"), _I2CAddress.toString());
+      Init_SC16IS752(); // Initialize UART
+      if (_deviceState == DEVSTATE_FAILED){
+        DIAG(F("SC16IS752 I2C:%s UART initialization failed"), _I2CAddress.toString());
+        }
+      } else {
+         DIAG(F("SC16IS752 I2C:%s UART not detected"), _I2CAddress.toString());
+        }
+      #if defined(DIAG_IO)
+      _display();
+      #endif
+      // Now init DFPlayer
+      // Send a query to the device to see if it responds
+      _deviceState = DEVSTATE_INITIALISING; 
+      sendPacket(0x42,0,0);
+      _timeoutTime = micros() + 5000000UL;  // 5 second timeout      
+      _awaitingResponse = true; 
+     }
+  
+  
+  void _loop(unsigned long currentMicros) override {
+    // Read responses from device
+    uint8_t status = _rb.status;
+    if (status == I2C_STATUS_PENDING) return;  // Busy, so don't do anything
+    if (status == I2C_STATUS_OK) { 
+      processIncoming(currentMicros);
+          // Check if a command sent to device has timed out.  Allow 0.5 second for response
+          // added retry counter, sometimes we do not sent keep alive due to other commands sent to DFPlayer
+      if (_awaitingResponse && (int32_t)(currentMicros - _timeoutTime) > 0) { // timeout triggered
+        if(_retryCounter == 0){ // retry counter out of luck, must take the device to failed state     
+          DIAG(F("I2CDFPlayer:%s, DFPlayer not responding on UART channel: 0x%x"), _I2CAddress.toString(), _UART_CH);
+          _deviceState = DEVSTATE_FAILED;
+          _awaitingResponse = false;
+          _playing = false;
+          _retryCounter = RETRYCOUNT;
+        } else { // timeout and retry protection and recovery of corrupt data frames from DFPlayer
+            #ifdef DIAG_I2CDFplayer_playing
+              DIAG(F("I2CDFPlayer: %s, DFPlayer timout, retry counter: %d on UART channel: 0x%x"), _I2CAddress.toString(), _retryCounter, _UART_CH);
+            #endif
+            _timeoutTime = currentMicros + 5000000UL;  // Timeout if no response within 5 seconds// reset timeout
+            _awaitingResponse = false; // trigger sending a keep alive 0x42 in processOutgoing()
+            _retryCounter --; // decrement retry counter                        
+            resetRX_fifo(); // reset the RX fifo as it has corrupt data            
+          }
+      }      
+    }
+
+    status = _rb.status;
+    if (status == I2C_STATUS_PENDING) return;  // Busy, try next time
+    if (status == I2C_STATUS_OK) {
+     // Send any commands that need to go.
+      processOutgoing(currentMicros);
+     }
+    delayUntil(currentMicros + 10000); // Only enter every 10ms    
+  }
+
+ 
+  // Check for incoming data, and update busy flag and other state accordingly
+ 
+  void processIncoming(unsigned long currentMicros) {
+    // Expected message is in the form "7E FF 06 3D xx xx xx xx xx EF"
+    RX_fifo_lvl();
+    if (FIFO_RX_LEVEL >= 10) {      
+      #ifdef DIAG_I2CDFplayer
+        DIAG(F("I2CDFPlayer: %s Retrieving data from RX Fifo on UART_CH: 0x%x FIFO_RX_LEVEL: %d"),_I2CAddress.toString(), _UART_CH, FIFO_RX_LEVEL); 
+      #endif
+      _outbuffer[0] = REG_RHR << 3 | _UART_CH << 1;
+      // Only copy 10 bytes from RX FIFO, there maybe additional partial return data after a track is finished playing in the RX FIFO
+      I2CManager.read(_I2CAddress, _inbuffer, 10, _outbuffer, 1); // inbuffer[] has the data now
+      //delayUntil(currentMicros + 10000); // Allow time to get the data
+      RX_BUFFER = 10; // We have copied 10 bytes from RX FIFO to _inbuffer
+        #ifdef DIAG_I2CDFplayer_data
+          DIAG(F("SC16IS752: At I2C: %s, UART channel: 0x%x, RX FIFO Data"), _I2CAddress.toString(), _UART_CH);
+          for (int i = 0; i < sizeof _inbuffer; i++){
+            DIAG(F("SC16IS752: Data _inbuffer[0x%x]: 0x%x"), i, _inbuffer[i]);  
+          }
+        #endif       
+    } else {
+        FIFO_RX_LEVEL = 0; //set to 0, we'll read a fresh FIFO_RX_LEVEL next time
+        return; // No data or not enough data in rx fifo, check again next time around
+      }
+
+    
+    bool ok = false;
+    //DIAG(F("I2CDFPlayer: RX_BUFFER: %d"), RX_BUFFER);
+    while (RX_BUFFER != 0) {
+      int c = _inbuffer[_inputIndex]; // Start at 0, increment to FIFO_RX_LEVEL
+      switch (_inputIndex) {
+        case 0:
+          if (c == 0x7E) ok = true;
+          break;
+        case 1:
+          if (c == 0xFF) ok = true;
+          break;
+        case 2:
+          if (c== 0x06) ok = true;
+          break;
+        case 3:
+          _recvCMD = c; // CMD byte
+          ok = true;
+          break;
+        case 6:
+          switch (_recvCMD) {
+            //DIAG(F("I2CDFPlayer: %s, _recvCMD: 0x%x _awaitingResponse: 0x0%x"),_I2CAddress.toString(), _recvCMD, _awaitingResponse);
+            case 0x42:
+              // Response to status query
+              _playing = (c != 0);              
+              // Mark the device online and cancel timeout
+              if (_deviceState==DEVSTATE_INITIALISING) {
+                _deviceState = DEVSTATE_NORMAL;
+                #ifdef DIAG_I2CDFplayer
+                 DIAG(F("I2CDFPlayer: %s, UART_CH: 0x0%x, _deviceState: 0x0%x"),_I2CAddress.toString(), _UART_CH, _deviceState);
+                #endif 
+                #ifdef DIAG_IO
+                _display();
+                #endif
+              }
+              _awaitingResponse = false;
+              break;
+            case 0x3d:            
+              // End of play
+              if (_playing) {
+                #ifdef DIAG_IO
+                  DIAG(F("I2CDFPlayer: Finished"));
+                #endif
+                _playing = false;
+              }
+              break;
+            case 0x40:
+              // Error codes; 1: Module Busy
+              DIAG(F("I2CDFPlayer: Error %d returned from device"), c);
+              _playing = false;
+              break;
+          }
+          ok = true;
+          break;
+        case 4: case 5: case 7: case 8: 
+          ok = true;  // Skip over these bytes in message.
+          break;
+        case 9:
+          if (c==0xef) {
+            // Message finished
+            _retryCounter = RETRYCOUNT; // reset the retry counter as we have received a valid packet
+          }
+          break;
+        default:
+          break;
+      }
+      if (ok){
+        _inputIndex++;  // character as expected, so increment index
+        RX_BUFFER --; // Decrease FIFO_RX_LEVEL with each character read from _inbuffer[_inputIndex]
+      } else {
+        _inputIndex = 0;  // otherwise reset.
+        RX_BUFFER = 0;
+      }
+    }
+    RX_BUFFER = 0; //Set to 0, we'll read a new RX FIFO level again
+  }
+
+
+  // Send any commands that need to be sent
+  void processOutgoing(unsigned long currentMicros) {
+    // When two commands are sent in quick succession, the device will often fail to 
+    // execute one.  Testing has indicated that a delay of 100ms or more is required
+    // between successive commands to get reliable operation.
+    // If 100ms has elapsed since the last thing sent, then check if there's some output to do.
+    if (((int32_t)currentMicros - _commandSendTime) > 100000) {
+      if ( _resetCmd == true){
+          sendPacket(0x0C,0,0);
+          _resetCmd = false;          
+      } else if(_volCmd == true) { // do the volme before palying a track
+         if(_requestedVolumeLevel >= 0 && _requestedVolumeLevel <= 30){         
+         _currentVolume = _requestedVolumeLevel; // If _requestedVolumeLevel is out of range, sent _currentV1olume      
+         }
+         sendPacket(0x06, 0x00, _currentVolume);
+        _volCmd = false;
+      } else if (_playCmd == true) {
+        // Change song
+        if (_requestedSong != -1) {
+          #ifdef DIAG_I2CDFplayer_playing
+           DIAG(F("I2CDFPlayer: _requestedVolumeLevel: %u, _requestedSong: %u, _currentFolder: %u _playCmd: 0x%x"), _requestedVolumeLevel, _requestedSong, _currentFolder, _playCmd);
+          #endif               
+          sendPacket(0x0F, _currentFolder, _requestedSong);  // audio file in folder          
+          _requestedSong = -1; 
+          _playCmd = false;
+        }           
+      } //else if (_requestedSong == 0) {
+        else if (_stopplayCmd == true) {
+          #ifdef DIAG_I2CDFplayer_playing
+           DIAG(F("I2CDFPlayer: Stop playing: _stopplayCmd: 0x%x"), _stopplayCmd);
+          #endif
+        sendPacket(0x16, 0x00, 0x00);  // Stop playing        
+        _requestedSong = -1;
+        _repeat = false; // reset repeat        
+        _stopplayCmd = false;
+        } else if (_folderCmd == true) {
+          #ifdef DIAG_I2CDFplayer_playing
+           DIAG(F("I2CDFPlayer: Folder: _folderCmd: 0x%x, _requestedFolder: %d"), _stopplayCmd, _requestedFolder);
+          #endif
+          if (_currentFolder != _requestedFolder){
+            _currentFolder = _requestedFolder;
+          }
+          _folderCmd = false;
+      } else if (_repeatCmd == true) {
+        if(_repeat == false) { // No repeat play currently
+          #ifdef DIAG_I2CDFplayer_playing
+           DIAG(F("I2CDFPlayer: Repeat: _repeatCmd: 0x%x, _requestedSong: %d, _repeat: 0x0%x"), _repeatCmd, _requestedSong, _repeat);
+          #endif 
+          sendPacket(0x08, 0x00, _requestedSong);  // repeat playing audio file in root folder          
+          _requestedSong = -1;
+          _repeat = true; 
+        }
+        _repeatCmd= false;      
+      } else if (_daconCmd == true) { // Always turn DAC on
+        #ifdef DIAG_I2CDFplayer_playing
+          DIAG(F("I2CDFPlayer: DACON: _daconCmd: 0x%x"), _daconCmd);
+        #endif 
+        sendPacket(0x1A,0,0x00);
+        _daconCmd = false;
+      } else if (_eqCmd == true){ // Set Equalizer, values 0x00 - 0x05        
+        if (_currentEQvalue != _requestedEQValue){
+          #ifdef DIAG_I2CDFplayer_playing
+           DIAG(F("I2CDFPlayer: EQ: _eqCmd: 0x%x, _currentEQvalue: 0x0%x, _requestedEQValue: 0x0%x"), _eqCmd, _currentEQvalue, _requestedEQValue);
+          #endif 
+          _currentEQvalue = _requestedEQValue;
+          sendPacket(0x07,0x00,_currentEQvalue);
+        }
+        _eqCmd = false;
+      } else if (_setamCmd == true){ // Set Audio mixer channel
+         setGPIO(); // Set the audio mixer channel
+         /*        
+          if (_audioMixer == 1){ // set to audio mixer 1       
+            if (_UART_CH == 0){ 
+              TEMP_REG_VAL |= (0x01 << _UART_CH); //Set GPIO pin 0 to high
+            } else { // must be UART 1
+              TEMP_REG_VAL |= (0x01 << _UART_CH); //Set GPIO pin 1 to high
+              }
+           //_setamCmd = false;
+           //UART_WriteRegister(REG_IOSTATE, TEMP_REG_VAL);
+          } else { // set to audio mixer 2
+              if (_UART_CH == 0){ 
+                TEMP_REG_VAL &= (0x00 << _UART_CH); //Set GPIO pin 0 to Low
+              } else { // must be UART 1
+                TEMP_REG_VAL &= (0x00 << _UART_CH); //Set GPIO pin 1 to Low
+                }
+              //_setamCmd = false;
+              //UART_WriteRegister(REG_IOSTATE, TEMP_REG_VAL);
+            }*/
+        _setamCmd = false;        
+      } else if ((int32_t)currentMicros - _commandSendTime > 1000000) {
+        // Poll device every second that other commands aren't being sent,
+        // to check if it's still connected and responding.
+          #ifdef DIAG_I2CDFplayer_playing
+           DIAG(F("I2CDFPlayer: Send keepalive") );
+          #endif
+        sendPacket(0x42,0,0); 
+        if (!_awaitingResponse) {
+          #ifdef DIAG_I2CDFplayer_playing
+           DIAG(F("I2CDFPlayer: Send keepalive, _awaitingResponse: 0x0%x"), _awaitingResponse );
+          #endif
+          _timeoutTime = currentMicros + 5000000UL;  // Timeout if no response within 5 seconds
+          _awaitingResponse = true;
+        }
+      }
+    }  
+  }
+
+
+  // Write to a vPin will do nothing
+  void _write(VPIN vpin, int value) override {
+    if (_deviceState == DEVSTATE_FAILED) return;
+      #ifdef DIAG_IO
+        DIAG(F("I2CDFPlayer: Writing to any vPin not supported"));
+      #endif
+  }
+
+
+  // WriteAnalogue on first pin uses the nominated value as a file number to start playing, if file number > 0.
+  // Volume may be specified as second parameter to writeAnalogue.
+  // If value is zero, the player stops playing.  
+  // WriteAnalogue on second pin sets the output volume.
+  //
+  // WriteAnalogue to be done on first vpin
+  //
+  //void _writeAnalogue(VPIN vpin, int value, uint8_t volume=0, uint16_t=0) override { 
+  void _writeAnalogue(VPIN vpin, int value, uint8_t volume=0, uint16_t cmd=0) override { 
+    if (_deviceState == DEVSTATE_FAILED) return;    
+    #ifdef DIAG_IO
+      DIAG(F("I2CDFPlayer: VPIN:%u FileNo:%d Volume:%d Command:0x%x"), vpin, value, volume, cmd);
+    #endif
+    uint8_t pin = vpin - _firstVpin;
+    if (pin == 0) { // Enhanced DFPlayer commands, do nothing if not vPin 0     
+     // Read command and value
+      switch (cmd){
+       //case NONE:
+       // DFPlayerCmd = cmd;
+       // break;
+       case DF_PLAY:
+        _playCmd = true;
+        _volCmd = true;        
+        _requestedSong = value;
+        _requestedVolumeLevel = volume; 
+        _playing = true;        
+        break;
+        case DF_VOL:
+          _volCmd = true;          
+          _requestedVolumeLevel = volume;
+        break;
+       case DF_FOLDER:
+        _folderCmd = true;
+        if (volume <= 0 || volume > 99){ // Range checking, valid values 1-99, else default to 1
+          _requestedFolder = 0x01; // if outside range, default to folder 01  
+        } else {
+          _requestedFolder = volume;
+        }        
+        break;
+       case DF_REPEATPLAY: // Need to check if _repeat == true, if so do nothing        
+        if (_repeat == false) {
+           #ifdef DIAG_I2CDFplayer_playing
+              DIAG(F("I2CDFPlayer: WriteAnalog Repeat: _repeat: 0x0%x, value: %d _repeatCmd: 0x%x"), _repeat, value, _repeatCmd);
+           #endif
+          _repeatCmd = true;          
+          _requestedSong = value;
+          _requestedVolumeLevel = volume;
+          _playing = true;         
+        }
+        break;
+       case DF_STOPPLAY:
+        _stopplayCmd = true;        
+        break;
+       case DF_EQ:
+        #ifdef DIAG_I2CDFplayer_playing
+          DIAG(F("I2CDFPlayer: WriteAnalog EQ: cmd: 0x%x, EQ value: 0x%x"), cmd, volume);
+        #endif
+        _eqCmd = true;        
+        if (volume <= 0 || volume > 5) { // If out of range, default to NORMAL
+          _requestedEQValue = DF_NORMAL;            
+        } else { // Valid EQ parameter range
+          _requestedEQValue = volume;     
+          }
+        break;        
+       case DF_RESET:
+        _resetCmd = true;      
+        break; 
+       case DF_DACON: // Works, but without the DACOFF command limited value, except when not relying on DFPlayer default to turn the DAC on
+        #ifdef DIAG_I2CDFplayer_playing
+          DIAG(F("I2CDFPlayer: WrtieAnalog DACON: cmd: 0x%x"), cmd);
+        #endif
+        _daconCmd = true;
+        break;
+        case DF_SETAM: // Set the audio mixer channel to 1 or 2
+          _setamCmd = true;
+          #ifdef DIAG_I2CDFplayer_playing
+            DIAG(F("I2CDFPlayer: WrtieAnalog SETAM: cmd: 0x%x"), cmd);
+          #endif
+          if (volume <= 0 || volume > 2) { // If out of range, default to 1
+            _audioMixer = 1;            
+          } else { // Valid SETAM parameter in range
+              _audioMixer = volume; // _audioMixer valid values 1 or 2
+            }          
+        break;
+       default:
+        break;
+      }
+    }    
+  }
+
+  // A read on any pin indicates if the player is still playing.
+  int _read(VPIN vpin) override {
+    if (_deviceState == DEVSTATE_FAILED) return false;
+    uint8_t pin = vpin - _firstVpin;
+      if (pin == 0) { // Do nothing if not vPin 0
+        return _playing;
+      }
+      return _playing; // fix for compile error: "control reaches end of non-void function [-Wreturn-type]"
+    }
+
+  void _display() override {
+    DIAG(F("I2CDFPlayer Configured on Vpins:%u-%u %S"), _firstVpin, _firstVpin+_nPins-1,
+      (_deviceState==DEVSTATE_FAILED) ? F("OFFLINE") : F(""));
+  }
+  
+private: 
+  // DFPlayer command frame
+  // 7E FF 06 0F 00 01 01 xx xx EF
+  // 0	  ->	7E is start code
+  // 1	  ->	FF is version
+  // 2	  ->	06 is length
+  // 3	  ->	0F is command
+  // 4	  ->	00 is no receive
+  // 5~6	->	01 01 is argument
+  // 7~8	->	checksum = 0 - ( FF+06+0F+00+01+01 )
+  // 9	  ->	EF is end code
+
+  void sendPacket(uint8_t command, uint8_t arg1 = 0, uint8_t arg2 = 0) {
+    FIFO_TX_LEVEL = 0; // Reset FIFO_TX_LEVEL    
+    uint8_t out[] = {
+        0x7E,
+        0xFF,
+        06,
+        command,
+        00,
+        //static_cast<uint8_t>(arg >> 8),
+        //static_cast<uint8_t>(arg & 0x00ff),
+        arg1,
+        arg2,
+        00,
+        00,
+        0xEF };
+
+    setChecksum(out);
+
+      // Prepend the DFPlayer command with REG address and UART Channel in _outbuffer
+      _outbuffer[0] = REG_THR << 3 | _UART_CH << 1; //TX FIFO and UART Channel            
+      for ( uint8_t i = 1; i < sizeof(out)+1 ; i++){
+        _outbuffer[i] = out[i-1];
+      }
+
+      #ifdef DIAG_I2CDFplayer_data
+       DIAG(F("SC16IS752: I2C: %s Sent packet function"), _I2CAddress.toString());
+       for (int i = 0; i < sizeof _outbuffer; i++){
+        DIAG(F("SC16IS752: Data _outbuffer[0x%x]: 0x%x"), i, _outbuffer[i]);  
+       }
+      #endif
+      
+    TX_fifo_lvl();
+    if(FIFO_TX_LEVEL > 0){ //FIFO is empty
+      I2CManager.write(_I2CAddress, _outbuffer, sizeof(_outbuffer), &_rb);
+      //I2CManager.write(_I2CAddress, _outbuffer, sizeof(_outbuffer));
+      #ifdef DIAG_I2CDFplayer
+       DIAG(F("SC16IS752: I2C: %s data transmit complete on UART: 0x%x"), _I2CAddress.toString(), _UART_CH);
+      #endif
+    } else {
+      DIAG(F("I2CDFPlayer at: %s, TX FIFO not empty on UART: 0x%x"), _I2CAddress.toString(), _UART_CH);
+      _deviceState = DEVSTATE_FAILED; // This should not happen      
+    }
+    _commandSendTime = micros();
+  }
+
+  uint16_t calcChecksum(uint8_t* packet)
+  {
+    uint16_t sum = 0;
+    for (int i = 1; i < 7; i++)
+    {
+      sum += packet[i];
+    }
+    return -sum;
+  }
+
+  void setChecksum(uint8_t* out)
+  {
+    uint16_t sum = calcChecksum(out);
+    out[7] = (sum >> 8);
+    out[8] = (sum & 0xff);
+  }
+
+  // SC16IS752 functions
+  // Initialise SC16IS752 only for this channel
+  // First a software reset
+  // Enable FIFO and clear TX & RX FIFO
+  // Need to set the following registers
+  // IOCONTROL set bit 1 and 2 to 0 indicating that they are GPIO
+  // IODIR set all bit to 1 indicating al are output
+  // IOSTATE set only bit 0 to 1 for UART 0, or only bit 1 for UART 1  // 
+  // LCR bit 7=0 divisor latch (clock division registers DLH & DLL, they store 16 bit divisor), 
+  //     WORD_LEN, STOP_BIT, PARITY_ENA and PARITY_TYPE
+  // MCR bit 7=0 clock divisor devide-by-1 clock input
+  // DLH most significant part of divisor
+  // DLL least significant part of divisor
+  //
+  // BAUD_RATE, WORD_LEN, STOP_BIT, PARITY_ENA and PARITY_TYPE have been defined and initialized
+  // 
+  void Init_SC16IS752(){ // Return value is in _deviceState
+    #ifdef DIAG_I2CDFplayer
+      DIAG(F("SC16IS752: Initialize I2C: %s , UART Ch: 0x%x"), _I2CAddress.toString(),  _UART_CH);      
+    #endif
+    //uint16_t _divisor = (SC16IS752_XTAL_FREQ / PRESCALER) / (BAUD_RATE * 16);
+    uint16_t _divisor = (_sc16is752_xtal_freq/PRESCALER)/(BAUD_RATE * 16);  // Calculate _divisor for baudrate
+    TEMP_REG_VAL = 0x08; // UART Software reset
+    UART_WriteRegister(REG_IOCONTROL, TEMP_REG_VAL);
+
+    // Extra delay when using low frequency xtal after soft reset
+    // Test when using 1.8432 Mhz xtal
+    if(_sc16is752_xtal_freq == SC16IS752_XTAL_FREQ_LOW){
+      _timeoutTime = micros() + 10000UL;  // 10mS timeout      
+      _awaitingResponse = true;
+    }
+
+    TEMP_REG_VAL = 0x00; // Set pins to GPIO mode
+    UART_WriteRegister(REG_IOCONTROL, TEMP_REG_VAL);
+    TEMP_REG_VAL = 0xFF; //Set all pins as output
+    UART_WriteRegister(REG_IODIR, TEMP_REG_VAL);
+    UART_ReadRegister(REG_IOSTATE); // Read current state as not to overwrite the other GPIO pins
+    TEMP_REG_VAL = _inbuffer[0];
+    setGPIO(); // Set the audio mixer channel
+    /*
+    if (_UART_CH == 0){ // Set Audio mixer channel
+      TEMP_REG_VAL |= (0x01 << _UART_CH); //Set GPIO pin 0 to high
+    } else { // must be UART 1
+      TEMP_REG_VAL |= (0x01 << _UART_CH); //Set GPIO pin 1 to high
+    }
+    UART_WriteRegister(REG_IOSTATE, TEMP_REG_VAL);
+    */
+    TEMP_REG_VAL = 0x07; // Reset FIFO, clear RX & TX FIFO
+    UART_WriteRegister(REG_FCR, TEMP_REG_VAL);
+    TEMP_REG_VAL = 0x00; // Set MCR to all 0, includes Clock divisor
+    UART_WriteRegister(REG_MCR, TEMP_REG_VAL);
+    TEMP_REG_VAL = 0x80 | WORD_LEN | STOP_BIT | PARITY_ENA | PARITY_TYPE;
+    UART_WriteRegister(REG_LCR, TEMP_REG_VAL); // Divisor latch enabled
+    UART_WriteRegister(REG_DLL, (uint8_t)_divisor);  // Write DLL
+    UART_WriteRegister(REG_DLH, (uint8_t)(_divisor >> 8)); // Write DLH
+    UART_ReadRegister(REG_LCR);
+    TEMP_REG_VAL = _inbuffer[0] & 0x7F; // Disable Divisor latch enabled bit
+    UART_WriteRegister(REG_LCR, TEMP_REG_VAL); // Divisor latch disabled  
+
+    uint8_t status = _rb.status;
+    if (status != I2C_STATUS_OK) {
+      DIAG(F("SC16IS752: I2C: %s failed %S"), _I2CAddress.toString(), I2CManager.getErrorMessage(status));
+      _deviceState = DEVSTATE_FAILED;
+    } else {
+      #ifdef DIAG_IO
+       DIAG(F("SC16IS752: I2C: %s, _deviceState: %S"), _I2CAddress.toString(), I2CManager.getErrorMessage(status));
+      #endif
+     _deviceState = DEVSTATE_NORMAL; // If I2C state is OK, then proceed to initialize DFPlayer 
+    }
+  }
+
+  
+  // Read the Receive FIFO Level register (RXLVL), return a single unsigned integer
+  // of nr of characters in the RX FIFO, bit 6:0, 7 not used, set to zero
+  // value from 0 (0x00) to 64 (0x40) Only display if RX FIFO has data
+  // The RX fifo level is used to check if there are enough bytes to process a frame
+  void RX_fifo_lvl(){
+    UART_ReadRegister(REG_RXLV);
+    FIFO_RX_LEVEL = _inbuffer[0];
+    #ifdef DIAG_I2CDFplayer
+     if (FIFO_RX_LEVEL > 0){
+     //if (FIFO_RX_LEVEL > 0 && FIFO_RX_LEVEL < 10){
+      DIAG(F("SC16IS752: At I2C: %s, UART channel: 0x%x, FIFO_RX_LEVEL: 0d%d"), _I2CAddress.toString(), _UART_CH, _inbuffer[0]);
+    }
+    #endif   
+  }
+
+  // When a frame is transmitted from the DFPlayer to the serial port, and at the same time the CS is sending a 42 query
+  // the following two frames from the DFPlayer are corrupt. This result in the receive buffer being out of sync and the 
+  // CS will complain and generate a timeout.
+  // The RX fifo has corrupt data and need to be flushed, this function does that
+  // 
+  void resetRX_fifo(){
+    #ifdef DIAG_I2CDFplayer
+      DIAG(F("SC16IS752: At I2C: %s, UART channel: 0x%x, RX fifo reset"), _I2CAddress.toString(), _UART_CH);
+    #endif    
+    TEMP_REG_VAL = 0x03; // Reset RX fifo
+    UART_WriteRegister(REG_FCR, TEMP_REG_VAL);
+  }
+
+  // Set or reset GPIO pin 0 and 1 depending on the UART ch
+  // This function may be modified in a future release to enable all 8 pins to be set or reset with EX-Rail
+  // for various auxilary functions
+  void setGPIO(){
+    UART_ReadRegister(REG_IOSTATE); // Get the current GPIO pins state from the IOSTATE register
+    TEMP_REG_VAL = _inbuffer[0];
+    if (_audioMixer == 1){ // set to audio mixer 1
+      if (_UART_CH == 0){ 
+        TEMP_REG_VAL |= (0x01 << _UART_CH); //Set GPIO pin 0 to high
+      } else { // must be UART 1
+         TEMP_REG_VAL |= (0x01 << _UART_CH); //Set GPIO pin 1 to high
+        }
+    } else { // set to audio mixer 2
+        if (_UART_CH == 0){ 
+          TEMP_REG_VAL &= ~(0x01 << _UART_CH); //Set GPIO pin 0 to Low
+        } else { // must be UART 1
+           TEMP_REG_VAL &= ~(0x01 << _UART_CH); //Set GPIO pin 1 to Low
+          }
+      }    
+    UART_WriteRegister(REG_IOSTATE, TEMP_REG_VAL);
+    _setamCmd = false;  
+  }
+  
+
+  // Read the Tranmit FIFO Level register (TXLVL), return a single unsigned integer
+  // of nr characters free in the TX FIFO, bit 6:0, 7 not used, set to zero
+  // value from 0 (0x00) to 64 (0x40)
+  //
+  void TX_fifo_lvl(){
+    UART_ReadRegister(REG_TXLV);
+    FIFO_TX_LEVEL = _inbuffer[0];
+    #ifdef DIAG_I2CDFplayer
+    //  DIAG(F("SC16IS752: At I2C: %s, UART channel: 0x%x, FIFO_TX_LEVEL: 0d%d"), _I2CAddress.toString(), _UART_CH, FIFO_TX_LEVEL);
+    #endif 
+  }
+
+
+  //void UART_WriteRegister(I2CAddress _I2CAddress, uint8_t _UART_CH, uint8_t UART_REG, uint8_t Val, I2CRB &_rb){
+  void UART_WriteRegister(uint8_t UART_REG, uint8_t Val){
+    _outbuffer[0] = UART_REG << 3 | _UART_CH << 1;
+    _outbuffer[1] = Val;
+    #ifdef DIAG_I2CDFplayer_reg
+      DIAG(F("SC16IS752: Write register at I2C: %s, UART channel: 0x%x, Register: 0x%x, Data: 0b%b"), _I2CAddress.toString(), _UART_CH, UART_REG, _outbuffer[1]);
+    #endif
+    I2CManager.write(_I2CAddress, _outbuffer, 2);
+  }
+
+ 
+  void UART_ReadRegister(uint8_t UART_REG){
+     _outbuffer[0] = UART_REG << 3 | _UART_CH << 1; // _outbuffer[0] has now UART_REG and UART_CH
+     I2CManager.read(_I2CAddress, _inbuffer, 1, _outbuffer, 1);    
+    // _inbuffer has the REG data
+    #ifdef DIAG_I2CDFplayer_reg
+      DIAG(F("SC16IS752: Read register at I2C: %s, UART channel: 0x%x, Register: 0x%x, Data: 0b%b"), _I2CAddress.toString(), _UART_CH, UART_REG, _inbuffer[0]);
+    #endif
+  }
+
+// SC16IS752 General register set (from the datasheet)
+enum : uint8_t{
+    REG_RHR       = 0x00, // FIFO Read
+    REG_THR       = 0x00, // FIFO Write
+    REG_IER       = 0x01, // Interrupt Enable Register R/W
+    REG_FCR       = 0x02, // FIFO Control Register Write
+    REG_IIR       = 0x02, // Interrupt Identification Register Read
+    REG_LCR       = 0x03, // Line Control Register R/W
+    REG_MCR       = 0x04, // Modem Control Register R/W
+    REG_LSR       = 0x05, // Line Status Register Read
+    REG_MSR       = 0x06, // Modem Status Register Read
+    REG_SPR       = 0x07, // Scratchpad Register R/W
+    REG_TCR       = 0x06, // Transmission Control Register R/W
+    REG_TLR       = 0x07, // Trigger Level Register R/W    
+    REG_TXLV      = 0x08, // Transmitter FIFO Level register Read
+    REG_RXLV      = 0x09, // Receiver FIFO Level register Read
+    REG_IODIR     = 0x0A, // Programmable I/O pins Direction register R/W
+    REG_IOSTATE   = 0x0B, // Programmable I/O pins State register R/W
+    REG_IOINTENA  = 0x0C, // I/O Interrupt Enable register R/W
+    REG_IOCONTROL = 0x0E, // I/O Control register R/W
+    REG_EFCR      = 0x0F, // Extra Features Control Register R/W
+  };
+
+// SC16IS752 Special register set
+enum : uint8_t{
+    REG_DLL       = 0x00, // Division registers R/W
+    REG_DLH       = 0x01, // Division registers R/W
+  };
+
+// SC16IS752 Enhanced regiter set
+enum : uint8_t{
+    REG_EFR       = 0X02, // Enhanced Features Register R/W
+    REG_XON1      = 0x04, // R/W
+    REG_XON2      = 0x05, // R/W
+    REG_XOFF1     = 0x06, // R/W
+    REG_XOFF2     = 0x07, // R/W
+  };
+
+
+// DFPlayer commands and values
+// Declared in this scope
+enum  : uint8_t{
+    DF_PLAY          = 0x0F,
+    DF_VOL           = 0x06,
+    DF_FOLDER        = 0x2B, // Not a DFPlayer command, used to set folder nr where audio file is
+    DF_REPEATPLAY    = 0x08,
+    DF_STOPPLAY      = 0x16,
+    DF_EQ            = 0x07, // Set equaliser, require parameter NORMAL, POP, ROCK, JAZZ, CLASSIC or BASS
+    DF_RESET         = 0x0C,
+    DF_DACON         = 0x1A,
+    DF_SETAM         = 0x2A, // Set audio mixer 1 or 2 for this DFPLayer   
+    DF_NORMAL        = 0x00, // Equalizer parameters
+    DF_POP           = 0x01,
+    DF_ROCK          = 0x02,
+    DF_JAZZ          = 0x03,
+    DF_CLASSIC       = 0x04,
+    DF_BASS          = 0x05,    
+  };
+
+};
+
+#endif // IO_I2CDFPlayer_h

IO_I2CRailcom.cpp

@@ -0,0 +1,121 @@
+   /*
+ *  © 2024, Henk Kruisbrink & Chris Harlow. All rights reserved.
+ *  © 2023, Neil McKechnie. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * 
+ * Dec 2023, Added NXP SC16IS752 I2C Dual UART
+ * The SC16IS752 has 64 bytes TX & RX FIFO buffer
+ * First version without interrupts from I2C UART and only RX/TX are used, interrupts may not be
+ * needed as the RX Fifo holds the reply 
+ * 
+ * Jan 2024, Issue with using both UARTs simultaniously, the secod uart seems to work  but the first transmit 
+ * corrupt data. This need more analysis and experimenatation. 
+ * Will push this driver to the dev branch with the uart fixed to 0 
+ * Both SC16IS750 (single uart) and SC16IS752 (dual uart, but only uart 0 is enable)
+ * 
+ * myHall.cpp configuration syntax:
+ * 
+ * I2CRailcom::create(1st vPin, vPins, I2C address);
+ * 
+ * myAutomation configuration
+ *  HAL(I2CRailcom, 1st vPin, vPins, I2C address)
+ * Parameters:
+ * 1st vPin     : First virtual pin that EX-Rail can control to play a sound, use PLAYSOUND command (alias of ANOUT)
+ * vPins        : Total number of virtual pins allocated (to prevent overlaps)
+ * I2C Address  : I2C address of the serial controller, in 0x format
+ */
+
+#include "IODevice.h"
+#include "IO_I2CRailcom.h"
+#include "I2CManager.h"
+#include "DIAG.h"
+#include "DCC.h"
+#include "DCCWaveform.h"
+#include "Railcom.h"
+
+
+I2CRailcom::I2CRailcom(VPIN firstVpin, int nPins, I2CAddress i2cAddress){
+    _firstVpin = firstVpin;
+    _nPins = nPins;
+    _I2CAddress = i2cAddress;
+    addDevice(this);
+   } 
+  
+void I2CRailcom::create(VPIN firstVpin, int nPins, I2CAddress i2cAddress) {
+    if (checkNoOverlap(firstVpin, nPins, i2cAddress)) 
+    new I2CRailcom(firstVpin,nPins,i2cAddress); 
+    }
+
+  void I2CRailcom::_begin() {
+    I2CManager.setClock(1000000); // TODO do we need this?
+    I2CManager.begin();
+    auto exists=I2CManager.exists(_I2CAddress);
+    DIAG(F("I2CRailcom: %s RailcomCollector %S detected"), 
+           _I2CAddress.toString(), exists?F(""):F(" NOT"));
+    if (!exists) return;
+  
+    _deviceState=DEVSTATE_NORMAL;
+    _display();
+    }
+  
+  
+  void I2CRailcom::_loop(unsigned long currentMicros) {
+    // Read responses from device
+    if (_deviceState!=DEVSTATE_NORMAL) return;
+    
+    // have we read this cutout already?
+    // basically we only poll once per packet when railcom cutout is working
+    auto cut=DCCWaveform::getRailcomCutoutCounter();
+    if (cutoutCounter==cut) return; 
+    cutoutCounter=cut; 
+    Railcom::loop(); // in case a csv read has timed out 
+    
+    // Obtain data length from the collector
+    byte inbuf[1];
+    byte queryLength[]={'?'};
+    auto state=I2CManager.read(_I2CAddress, inbuf, 1,queryLength,sizeof(queryLength)); 
+    if (state) {
+      DIAG(F("RC ? state=%d"),state);
+      return;
+    }
+    auto length=inbuf[0];
+    if (length==0) return;  // nothing to report 
+
+    // Build a buffer and import the data from the collector
+    byte inbuf2[length];
+    byte queryData[]={'>'};
+    state=I2CManager.read(_I2CAddress, inbuf2, length,queryData,sizeof(queryData)); 
+    if (state) {
+      DIAG(F("RC > %d state=%d"),length,state);
+      return;
+    }
+    
+    // process incoming data buffer 
+    Railcom::process(_firstVpin,inbuf2,length);
+     
+  }
+          
+ 
+  void I2CRailcom::_display() {
+    DIAG(F("I2CRailcom: %s blocks %d-%d  %S"), _I2CAddress.toString(), _firstVpin, _firstVpin+_nPins-1,
+      (_deviceState!=DEVSTATE_NORMAL) ? F("OFFLINE") : F(""));
+  }
+  
+  

IO_I2CRailcom.h

@@ -0,0 +1,58 @@
+/*
+ *  © 2024, Henk Kruisbrink & Chris Harlow. All rights reserved.
+ *  © 2023, Neil McKechnie. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This polls the RailcomCollecter device once per dcc packet
+ * and obtains an abbreviated list of block occupancy changes which
+ * are fortunately very rare compared with Railcom raw data. 
+ *
+ * myAutomation configuration
+ *  HAL(I2CRailcom, 1st vPin, vPins, I2C address)
+ * Parameters:
+ * 1st vPin     : First virtual pin that EX-Rail can control to play a sound, use PLAYSOUND command (alias of ANOUT)
+ * vPins        : Total number of virtual pins allocated 
+ * I2C Address  : I2C address of the Railcom Collector, in 0x format
+ */
+
+#ifndef IO_I2CRailcom_h
+#define IO_I2CRailcom_h
+#include "Arduino.h"
+#include "IODevice.h"
+
+class I2CRailcom : public IODevice {
+private: 
+  byte cutoutCounter;
+  public:
+  // Constructor
+  I2CRailcom(VPIN firstVpin, int nPins, I2CAddress i2cAddress);
+  
+  static void create(VPIN firstVpin, int nPins, I2CAddress i2cAddress) ;
+  
+  void _begin() ;
+  void _loop(unsigned long currentMicros) override ;
+  void _display() override ;
+  
+private: 
+
+
+  
+};
+
+#endif // IO_I2CRailcom_h

IO_MCP23008.h

@@ -98,4 +98,4 @@ private:
 
 };
 
-#endif
+#endif

IO_MCP23017.h

@@ -108,4 +108,4 @@ private:
 
 };
 
-#endif
+#endif

IO_NeoPixel.h

@@ -0,0 +1,334 @@
+/*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *
+ *  This file is part of EX-CommandStation
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+/*
+* The IO_NEOPIXEL.h device driver integrates with one or more Adafruit neopixel drivers.
+* This device driver will configure the device on startup, along with
+* interacting with the device for all input/output duties.
+*
+* To create NEOPIXEL devices, these are defined in myAutomation.h:
+* (Note the device driver is included by default)
+*
+* HAL(NEOPIXEL,first vpin, number of pixels,mode, i2c address) 
+* e.g. HAL(NEOPIXEL,1000,64,NEO_RGB,0x60)
+* This gives each pixel in the chain an individual vpin
+* The number of pixels must match the physical pixels in the chain. 
+* 
+* This driver maintains a colour (rgb value in 5,5,5 bits only) plus an ON bit.
+* This can be written/read with an analog write/read call. 
+* The ON bit can be set on and off with a digital write. This allows for 
+* a pixel to be preset a colour and then turned on and off like any other light. 
+*/
+
+#ifndef IO_EX_NeoPixel_H
+#define IO_EX_NeoPixel_H
+
+#include "IODevice.h"
+#include "I2CManager.h"
+#include "DIAG.h"
+#include "FSH.h"
+
+
+// The following macros to define the Neopixel String type
+// have been copied from the Adafruit Seesaw Library under the 
+// terms of the GPL. 
+// Credit to: https://github.com/adafruit/Adafruit_Seesaw
+
+// The order of primary colors in the NeoPixel data stream can vary
+// among device types, manufacturers and even different revisions of
+// the same item.  The third parameter to the seesaw_NeoPixel
+// constructor encodes the per-pixel byte offsets of the red, green
+// and blue primaries (plus white, if present) in the data stream --
+// the following #defines provide an easier-to-use named version for
+// each permutation.  e.g. NEO_GRB indicates a NeoPixel-compatible
+// device expecting three bytes per pixel, with the first byte
+// containing the green value, second containing red and third
+// containing blue.  The in-memory representation of a chain of
+// NeoPixels is the same as the data-stream order; no re-ordering of
+// bytes is required when issuing data to the chain.
+
+// Bits 5,4 of this value are the offset (0-3) from the first byte of
+// a pixel to the location of the red color byte.  Bits 3,2 are the
+// green offset and 1,0 are the blue offset.  If it is an RGBW-type
+// device (supporting a white primary in addition to R,G,B), bits 7,6
+// are the offset to the white byte...otherwise, bits 7,6 are set to
+// the same value as 5,4 (red) to indicate an RGB (not RGBW) device.
+// i.e. binary representation:
+// 0bWWRRGGBB for RGBW devices
+// 0bRRRRGGBB for RGB
+
+// RGB NeoPixel permutations; white and red offsets are always same
+// Offset:         W          R          G          B
+#define NEO_RGB ((0 << 6) | (0 << 4) | (1 << 2) | (2))
+#define NEO_RBG ((0 << 6) | (0 << 4) | (2 << 2) | (1))
+#define NEO_GRB ((1 << 6) | (1 << 4) | (0 << 2) | (2))
+#define NEO_GBR ((2 << 6) | (2 << 4) | (0 << 2) | (1))
+#define NEO_BRG ((1 << 6) | (1 << 4) | (2 << 2) | (0))
+#define NEO_BGR ((2 << 6) | (2 << 4) | (1 << 2) | (0))
+
+// RGBW NeoPixel permutations; all 4 offsets are distinct
+// Offset:         W          R          G          B
+#define NEO_WRGB ((0 << 6) | (1 << 4) | (2 << 2) | (3))
+#define NEO_WRBG ((0 << 6) | (1 << 4) | (3 << 2) | (2))
+#define NEO_WGRB ((0 << 6) | (2 << 4) | (1 << 2) | (3))
+#define NEO_WGBR ((0 << 6) | (3 << 4) | (1 << 2) | (2))
+#define NEO_WBRG ((0 << 6) | (2 << 4) | (3 << 2) | (1))
+#define NEO_WBGR ((0 << 6) | (3 << 4) | (2 << 2) | (1))
+
+#define NEO_RWGB ((1 << 6) | (0 << 4) | (2 << 2) | (3))
+#define NEO_RWBG ((1 << 6) | (0 << 4) | (3 << 2) | (2))
+#define NEO_RGWB ((2 << 6) | (0 << 4) | (1 << 2) | (3))
+#define NEO_RGBW ((3 << 6) | (0 << 4) | (1 << 2) | (2))
+#define NEO_RBWG ((2 << 6) | (0 << 4) | (3 << 2) | (1))
+#define NEO_RBGW ((3 << 6) | (0 << 4) | (2 << 2) | (1))
+
+#define NEO_GWRB ((1 << 6) | (2 << 4) | (0 << 2) | (3))
+#define NEO_GWBR ((1 << 6) | (3 << 4) | (0 << 2) | (2))
+#define NEO_GRWB ((2 << 6) | (1 << 4) | (0 << 2) | (3))
+#define NEO_GRBW ((3 << 6) | (1 << 4) | (0 << 2) | (2))
+#define NEO_GBWR ((2 << 6) | (3 << 4) | (0 << 2) | (1))
+#define NEO_GBRW ((3 << 6) | (2 << 4) | (0 << 2) | (1))
+
+#define NEO_BWRG ((1 << 6) | (2 << 4) | (3 << 2) | (0))
+#define NEO_BWGR ((1 << 6) | (3 << 4) | (2 << 2) | (0))
+#define NEO_BRWG ((2 << 6) | (1 << 4) | (3 << 2) | (0))
+#define NEO_BRGW ((3 << 6) | (1 << 4) | (2 << 2) | (0))
+#define NEO_BGWR ((2 << 6) | (3 << 4) | (1 << 2) | (0))
+#define NEO_BGRW ((3 << 6) | (2 << 4) | (1 << 2) | (0))
+
+// If 400 KHz support is enabled, the third parameter to the constructor
+// requires a 16-bit value (in order to select 400 vs 800 KHz speed).
+// If only 800 KHz is enabled (as is default on ATtiny), an 8-bit value
+// is sufficient to encode pixel color order, saving some space.
+
+#define NEO_KHZ800 0x0000 // 800 KHz datastream
+#define NEO_KHZ400 0x0100 // 400 KHz datastream
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+ * IODevice subclass for NeoPixel.
+ */
+
+class NeoPixel : public IODevice {
+public:
+  
+  static void create(VPIN vpin, int nPins, uint16_t mode=(NEO_GRB | NEO_KHZ800), I2CAddress i2cAddress=0x60) {
+    if (checkNoOverlap(vpin, nPins, i2cAddress)) new NeoPixel(vpin, nPins, mode, i2cAddress);
+  }
+
+private:
+  
+  static const byte SEESAW_NEOPIXEL_BASE=0x0E;
+  static const byte SEESAW_NEOPIXEL_STATUS = 0x00;
+  static const byte SEESAW_NEOPIXEL_PIN = 0x01;
+  static const byte SEESAW_NEOPIXEL_SPEED = 0x02;
+  static const byte SEESAW_NEOPIXEL_BUF_LENGTH = 0x03;
+  static const byte SEESAW_NEOPIXEL_BUF=0x04;
+  static const byte SEESAW_NEOPIXEL_SHOW=0x05;
+
+  // all adafruit examples say this pin. Presumably its hard wired 
+  // in the adapter anyway. 
+  static const byte SEESAW_PIN15 = 15;
+  
+  // Constructor
+  NeoPixel(VPIN firstVpin, int nPins, uint16_t mode, I2CAddress i2cAddress) {
+    _firstVpin = firstVpin;
+    _nPins=nPins;
+    _I2CAddress = i2cAddress;
+    
+    // calculate the offsets into the seesaw buffer for each colour depending
+    // on the pixel strip type passed in mode.
+
+    _redOffset=4+(mode >> 4 & 0x03);
+    _greenOffset=4+(mode >> 2 & 0x03); 
+    _blueOffset=4+(mode & 0x03); 
+    if (4+(mode >>6 & 0x03) == _redOffset) _bytesPerPixel=3; 
+    else _bytesPerPixel=4; // string has a white byte.
+    
+    _kHz800=(mode & NEO_KHZ400)==0;
+    _showPendimg=false;
+    
+    // Each pixel requires 3 bytes RGB memory.
+    // Although the driver device can remember this, it cant do off/on without
+    // forgetting what the on colour was!
+    pixelBuffer=(RGB *) malloc(_nPins*sizeof(RGB)); 
+    stateBuffer=(byte *) calloc((_nPins+7)/8,sizeof(byte)); // all pixels off  
+    if (pixelBuffer==nullptr || stateBuffer==nullptr) {
+      DIAG(F("NeoPixel I2C:%s not enough RAM"), _I2CAddress.toString());
+      return;
+    }
+    // preset all pins to white so a digital on/off will do something even if no colour set.
+    memset(pixelBuffer,0xFF,_nPins*sizeof(RGB));
+    addDevice(this);
+  }
+
+  void _begin() {
+    
+    // Initialise Neopixel device
+    I2CManager.begin();
+    if (!I2CManager.exists(_I2CAddress)) {
+      DIAG(F("NeoPixel I2C:%s device not found"), _I2CAddress.toString());
+      _deviceState = DEVSTATE_FAILED;
+      return;
+    }
+    
+    byte speedBuffer[]={SEESAW_NEOPIXEL_BASE, SEESAW_NEOPIXEL_SPEED,_kHz800};
+    I2CManager.write(_I2CAddress, speedBuffer, sizeof(speedBuffer));
+    
+    // In the driver there are 3 of 4 byts per pixel
+    auto numBytes=_bytesPerPixel * _nPins; 
+    byte setbuffer[] = {SEESAW_NEOPIXEL_BASE, SEESAW_NEOPIXEL_BUF_LENGTH,
+                  (byte)(numBytes >> 8), (byte)(numBytes & 0xFF)};
+    I2CManager.write(_I2CAddress, setbuffer, sizeof(setbuffer));
+    
+    const byte pinbuffer[] = {SEESAW_NEOPIXEL_BASE, SEESAW_NEOPIXEL_PIN,SEESAW_PIN15};
+    I2CManager.write(_I2CAddress, pinbuffer, sizeof(pinbuffer));
+    
+    for (auto pin=0;pin<_nPins;pin++) transmit(pin);
+     _display();
+  }
+  
+ // loop called by HAL supervisor 
+  void _loop(unsigned long currentMicros) override {
+    (void)currentMicros;
+    if (!_showPendimg) return;
+    byte showBuffer[]={SEESAW_NEOPIXEL_BASE,SEESAW_NEOPIXEL_SHOW};
+    I2CManager.write(_I2CAddress,showBuffer,sizeof(showBuffer));
+    _showPendimg=false;
+  }  
+  
+  
+  // read back pixel on/off
+  int _read(VPIN vpin) override {
+    if (_deviceState == DEVSTATE_FAILED) return 0;
+    return isPixelOn(vpin-_firstVpin);
+  }
+
+  // Write digital value. Sets pixel on or off
+  void _write(VPIN vpin, int value) override {
+    if (_deviceState == DEVSTATE_FAILED) return;
+    auto pixel=vpin-_firstVpin;
+    if (value) {
+      if (isPixelOn(pixel)) return;
+      setPixelOn(pixel);
+    }
+    else { // set off
+      if (!isPixelOn(pixel)) return;
+      setPixelOff(pixel);
+     }
+     transmit(pixel);
+  }
+   
+  VPIN _writeRange(VPIN vpin,int value, int count) {
+    // using write range cuts out the constant vpin to driver lookup so
+    // we can update multiple pixels much faster.
+    VPIN nextVpin=vpin +  (count>_nPins ? _nPins : count);
+    if (_deviceState != DEVSTATE_FAILED) while(vpin<nextVpin) {
+      _write(vpin,value);
+      vpin++;
+    }
+    return nextVpin;  // next pin we cant 
+  }  
+  // Write analogue value.
+  // The convoluted parameter mashing here is to allow passing the RGB and on/off
+  // information through the generic HAL _writeAnalog interface which was originally
+  // designed for servos and short integers  
+  void _writeAnalogue(VPIN vpin, int colour_RG, uint8_t onoff, uint16_t colour_B) override {
+    if (_deviceState == DEVSTATE_FAILED) return;
+    RGB newColour={(byte)((colour_RG>>8) & 0xFF), (byte)(colour_RG & 0xFF), (byte)(colour_B & 0xFF)};
+    auto pixel=vpin-_firstVpin;
+    if (pixelBuffer[pixel]==newColour && isPixelOn(pixel)==(bool)onoff) return; // no change  
+      
+    if (onoff) setPixelOn(pixel); else setPixelOff(pixel);
+    pixelBuffer[pixel]=newColour;
+    transmit(pixel);
+  }
+ VPIN _writeAnalogueRange(VPIN vpin, int colour_RG, uint8_t onoff, uint16_t colour_B, int count) override {
+    // using write range cuts out the constant vpin to driver lookup so
+    VPIN nextVpin=vpin +  (count>_nPins ? _nPins : count); 
+    if (_deviceState != DEVSTATE_FAILED) while(vpin<nextVpin) {
+      _writeAnalogue(vpin,colour_RG, onoff,colour_B);
+      vpin++;
+    }
+    return nextVpin;  // next pin we cant 
+ }
+ 
+  // Display device information and status.
+  void _display() override {
+    DIAG(F("NeoPixel I2C:%s Vpins %u-%u %S"),
+              _I2CAddress.toString(), 
+              (int)_firstVpin, (int)_firstVpin+_nPins-1,
+              _deviceState == DEVSTATE_FAILED ? F("OFFLINE") : F(""));
+  }
+
+
+  
+  bool isPixelOn(int16_t pixel) {return stateBuffer[pixel/8] & (0x80>>(pixel%8));}
+  void setPixelOn(int16_t pixel) {stateBuffer[pixel/8] |= (0x80>>(pixel%8));}
+  void setPixelOff(int16_t pixel) {stateBuffer[pixel/8] &= ~(0x80>>(pixel%8));}
+  
+  // Helper function for error handling
+  void reportError(uint8_t status, bool fail=true) {
+    DIAG(F("NeoPixel I2C:%s Error:%d (%S)"), _I2CAddress.toString(), 
+      status, I2CManager.getErrorMessage(status));
+    if (fail)
+    _deviceState = DEVSTATE_FAILED;
+  }
+
+  
+  void transmit(uint16_t pixel) { 
+    byte buffer[]={SEESAW_NEOPIXEL_BASE,SEESAW_NEOPIXEL_BUF,0x00,0x00,0x00,0x00,0x00};
+    uint16_t offset= pixel * _bytesPerPixel;
+    buffer[2]=(byte)(offset>>8);
+    buffer[3]=(byte)(offset & 0xFF);
+    
+    if (isPixelOn(pixel)) {
+      auto colour=pixelBuffer[pixel];    
+      buffer[_redOffset]=colour.red;
+      buffer[_greenOffset]=colour.green;
+      buffer[_blueOffset]=colour.blue;
+    } // else leave buffer black (in buffer preset to zeros above)
+    
+    // Transmit pixel to driver
+    I2CManager.write(_I2CAddress,buffer,4 +_bytesPerPixel);
+    _showPendimg=true;
+  
+  }
+  struct RGB { 
+      byte red; 
+      byte green; 
+      byte blue; 
+      bool operator==(const RGB& other) const {
+        return red == other.red && green == other.green && blue == other.blue;
+      }
+    };
+
+  RGB*   pixelBuffer = nullptr;
+  byte*  stateBuffer = nullptr;  // 1 bit per pixel
+  bool _showPendimg;
+  
+  // mapping of RGB onto pixel buffer for seesaw.
+  byte _bytesPerPixel;
+  byte _redOffset;
+  byte _greenOffset;
+  byte _blueOffset;
+  bool _kHz800; 
+};
+
+#endif

IO_PCA9685pwm.h

@@ -167,4 +167,4 @@ private:
 
 };
 
-#endif
+#endif

IO_PCF8574.h

@@ -1,4 +1,5 @@
 /*
+ *  © 2025 Herb Morton
  *  © 2022 Paul M Antoine
  *  © 2021, Neil McKechnie. All rights reserved.
  *  
@@ -43,15 +44,21 @@
 
 class PCF8574 : public GPIOBase<uint8_t> {
 public:
-  static void create(VPIN firstVpin, uint8_t nPins, I2CAddress i2cAddress, int interruptPin=-1) {
-    if (checkNoOverlap(firstVpin, nPins, i2cAddress)) new PCF8574(firstVpin, nPins, i2cAddress, interruptPin);
+  static void create(VPIN firstVpin, uint8_t nPins, I2CAddress i2cAddress, int interruptPin=-1, int initPortState=-1) {
+    if (checkNoOverlap(firstVpin, nPins, i2cAddress)) new PCF8574(firstVpin, nPins, i2cAddress, interruptPin, initPortState);
   }
 
 private:
-  PCF8574(VPIN firstVpin, uint8_t nPins, I2CAddress i2cAddress, int interruptPin=-1)
+  PCF8574(VPIN firstVpin, uint8_t nPins, I2CAddress i2cAddress, int interruptPin=-1, int initPortState=-1)
     : GPIOBase<uint8_t>((FSH *)F("PCF8574"), firstVpin, nPins, i2cAddress, interruptPin) 
   {
     requestBlock.setReadParams(_I2CAddress, inputBuffer, 1);
+    if (initPortState>=0) {
+      _portMode = 255;         // set all pins to output mode
+      _portInUse = 255;        // 8 ports in use 
+      _portOutputState = initPortState;  // initialize pins low-high 0-255
+      I2CManager.write(_I2CAddress, 1, initPortState);
+    }
   }
   
   // The PCF8574 handles inputs by applying a weak pull-up when output is driven to '1'.
@@ -101,4 +108,4 @@ private:
   uint8_t inputBuffer[1];
 };
 
-#endif
+#endif

IO_PCF8575.h

@@ -106,4 +106,4 @@ private:
   uint8_t inputBuffer[2];
 };
 
-#endif
+#endif

IO_RotaryEncoder.h

@@ -42,9 +42,9 @@
 * Defining in myAutomation.h requires the device driver to be included in addition to the HAL() statement. Examples:
 *
 * #include "IO_RotaryEncoder.h"
-* HAL(RotaryEncoder, 700, 1, 0x70)    // Define single Vpin, no feedback or position sent to rotary encoder software
-* HAL(RotaryEncoder, 700, 2, 0x70)    // Define two Vpins, feedback only sent to rotary encoder software
-* HAL(RotaryEncoder, 700, 3, 0x70)    // Define three Vpins, can send feedback and position update to rotary encoder software
+* HAL(RotaryEncoder, 700, 1, 0x67)    // Define single Vpin, no feedback or position sent to rotary encoder software
+* HAL(RotaryEncoder, 700, 2, 0x67)    // Define two Vpins, feedback only sent to rotary encoder software
+* HAL(RotaryEncoder, 700, 3, 0x67)    // Define three Vpins, can send feedback and position update to rotary encoder software
 *
 * Refer to the documentation for further information including the valid activities and examples.
 */

IO_Servo.cpp

@@ -30,4 +30,3 @@
 //
 const uint8_t FLASH Servo::_bounceProfile[30] = 
     {0,2,3,7,13,33,50,83,100,83,75,70,65,60,60,65,74,84,100,83,75,70,70,72,75,80,87,92,97,100};
-

IO_Servo.h

@@ -295,4 +295,4 @@ private:
   }
 };
 
-#endif
+#endif

IO_TCA8418.h

@@ -0,0 +1,371 @@
+/*
+ *  © 2023-2024, Paul M. Antoine
+ *  © 2021, Neil McKechnie. All rights reserved.
+ *  
+ *  This file is part of DCC-EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef io_tca8418_h
+#define io_tca8418_h
+
+#include "IODevice.h"
+#include "I2CManager.h"
+#include "DIAG.h"
+#include "FSH.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+ * IODevice subclass for TCA8418 80-key keypad encoder, which we'll treat as 80 available VPINs where
+ * key down == 1 and key up == 0 by configuring just as an 8x10 keyboard matrix. Users can opt to use
+ * up to all 80 of the available VPINs for now, allowing memory to be saved if not all events are required.
+ * 
+ * The datasheet says:
+ * 
+ * The TCA8418 can be configured to support many different configurations of keypad setups.
+ * All 18 GPIOs for the rows and columns can be used to support up to 80 keys in an 8x10 key pad
+ * array. Another option is that all 18 GPIOs be used for GPIs to read 18 buttons which are
+ * not connected in an array. Any combination in between is also acceptable (for example, a
+ * 3x4 keypad matrix and using the remaining 11 GPIOs as a combination of inputs and outputs).
+ * 
+ * With an 8x10 key event matrix, the events are numbered as such:
+ * 
+ *     C0  C1  C2  C3  C4  C5  C6  C7  C8  C9
+ *    ========================================
+ * R0|  0   1   2   3   4   5   6   7   8   9
+ * R1| 10  11  12  13  14  15  16  17  18  19
+ * R2| 20  21  22  23  24  25  26  27  28  29
+ * R3| 30  31  32  33  34  35  36  37  38  39
+ * R4| 40  41  42  43  44  45  46  47  48  49
+ * R5| 50  51  52  53  54  55  56  57  58  59
+ * R6| 60  61  62  63  64  65  66  67  68  69
+ * R7| 70  71  72  73  74  75  76  77  78  79
+ * 
+ * So if you start with VPIN 300, R0/C0 will be 300, and R7/C9 will be 379.
+ * 
+ * HAL declaration for myAutomation.h is:
+ * HAL(TCA8418, firstVpin, numPins, I2CAddress, interruptPin)
+ * 
+ * Where numPins can be 1-80, and interruptPin can be any spare Arduino pin.
+ * 
+ * Configure using the following on the main I2C bus:
+ * HAL(TCA8418, 300, 80, 0x34)
+ * 
+ * Use something like this on a multiplexor, and with up to 8 of the 8-way multiplexors you could have 64 different TCA8418 boards:
+ * HAL(TCA8418, 400, 80, {SubBus_1, 0x34})
+ * 
+ * And if needing an Interrupt pin to speed up operations:
+ * HAL(TCA8418, 300, 80, 0x34, D21)
+ * 
+ * Note that using an interrupt pin speeds up button press acquisition considerably (less than a millisecond vs 10-100),
+ * but even with interrupts enabled the code presently checks every 100ms in case the interrupt pin becomes disconnected.
+ * Use any available Arduino pin for interrupt monitoring.
+ */
+ 
+class TCA8418 : public IODevice {
+public:
+
+  static void create(VPIN firstVpin, uint8_t nPins, I2CAddress i2cAddress, int interruptPin=-1) {
+    if (checkNoOverlap(firstVpin, nPins, i2cAddress))
+      new TCA8418(firstVpin, (nPins = (nPins > 80) ? 80 : nPins), i2cAddress, interruptPin);
+  }
+
+private:  
+
+  uint8_t* _digitalInputStates = NULL;  // Array of pin states
+  uint8_t _digitalPinBytes = 0;         // Number of bytes in pin state array
+
+  uint8_t _numKeyEvents = 0;            // Number of outsanding key events waiting for us
+
+  unsigned long _lastEventRead = 0;
+  unsigned long _eventRefresh = 10000UL;    // Delay refreshing events for 10ms
+  const unsigned long _eventRefreshSlow = 100000UL;   // Delay refreshing events for 100ms
+  bool _gpioInterruptsEnabled = false;
+
+  uint8_t _inputBuffer[1];
+  uint8_t _commandBuffer[1];
+  I2CRB _i2crb;
+
+  enum {RDS_IDLE, RDS_EVENT, RDS_KEYCODE};  // Read operation states
+  uint8_t _readState = RDS_IDLE;
+
+  // Constructor
+  TCA8418(VPIN firstVpin, uint8_t nPins, I2CAddress i2cAddress, int interruptPin=-1) {
+    if (nPins > 0)
+    {
+      _firstVpin = firstVpin;
+      _nPins = nPins;
+      _I2CAddress = i2cAddress;
+      _gpioInterruptPin = interruptPin;
+      addDevice(this);
+    }
+  }
+
+  void _begin() {
+
+    I2CManager.begin();
+
+    if (I2CManager.exists(_I2CAddress)) {
+      // Default all GPIO pins to INPUT
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_DIR_1, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_DIR_2, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_DIR_3, 0x00);
+
+      // Remove all GPIO pins from events
+      I2CManager.write(_I2CAddress, 2, REG_GPI_EM_1, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPI_EM_2, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPI_EM_3, 0x00);
+
+      // Set all pins to FALLING interrupts
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_INT_LVL_1, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_INT_LVL_2, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_INT_LVL_3, 0x00);
+
+      // Remove all GPIO pins from interrupts
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_INT_EN_1, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_INT_EN_2, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_GPIO_INT_EN_3, 0x00);
+
+      // Set up an 8 x 10 matrix by writing 0xFF to all the row and column configs
+      // Row config is maximum of 8, and in REG_KP_GPIO_1
+      I2CManager.write(_I2CAddress, 2, REG_KP_GPIO_1, 0xFF);
+      // Column config is maximum of 10, lower 8 bits in REG_KP_GPIO_2, upper in REG_KP_GPIO_3
+      // Set first 8 columns
+      I2CManager.write(_I2CAddress, 2, REG_KP_GPIO_2, 0xFF);
+      // Turn on cols 9/10
+      I2CManager.write(_I2CAddress, 2, REG_KP_GPIO_3, 0x03);
+
+      // // Set all pins to Enable Debounce
+      I2CManager.write(_I2CAddress, 2, REG_DEBOUNCE_DIS_1, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_DEBOUNCE_DIS_2, 0x00);
+      I2CManager.write(_I2CAddress, 2, REG_DEBOUNCE_DIS_3, 0x00);
+
+      // Let's assume an 8x10 matrix for now, and configure 
+      _digitalPinBytes = (_nPins + 7) / 8;
+      if ((_digitalInputStates = (byte *)calloc(_digitalPinBytes, 1)) == NULL) {
+        DIAG(F("TCA8418 I2C: Unable to alloc %d bytes"), _digitalPinBytes);
+        return;
+      }
+
+    // Configure pin used for GPIO extender notification of change (if allocated)
+    // and configure TCA8418 to produce key event interrupts
+    if (_gpioInterruptPin >= 0) {
+      DIAG(F("TCA8418 I2C: interrupt pin configured on %d"), _gpioInterruptPin);
+      _gpioInterruptsEnabled = true;
+      _eventRefresh = _eventRefreshSlow; // Switch to slower manual refreshes in case the INT pin isn't connected!
+      pinMode(_gpioInterruptPin, INPUT_PULLUP);
+      I2CManager.write(_I2CAddress, 2, REG_CFG, REG_CFG_KE_IEN);
+      // Clear any pending interrupts
+      I2CManager.write(_I2CAddress, 2, REG_INT_STAT, REG_STAT_K_INT);
+    }
+
+#ifdef DIAG_IO
+      _display();
+#endif
+    }
+  }
+
+  int _read(VPIN vpin) override {
+    if (_deviceState == DEVSTATE_FAILED)
+      return 0;
+    int pin = vpin - _firstVpin;
+    bool result = _digitalInputStates[pin / 8] & (1 << (pin % 8));
+    return result;
+  }
+
+
+  // Main loop, collect both digital and analogue pin states continuously (faster sensor/input reads)
+  void _loop(unsigned long currentMicros) override {
+    if (_deviceState == DEVSTATE_FAILED) return;    // If device failed, return
+
+    // Request block is used for key event reads from the TCA8418, which are performed
+    // on a cyclic basis.
+
+    if (_readState != RDS_IDLE) {
+      if (_i2crb.isBusy()) return;                // If I2C operation still in progress, return
+
+      uint8_t status = _i2crb.status;
+      if (status == I2C_STATUS_OK) {             // If device request ok, read input data
+
+        // First check if we have any key events waiting
+        if (_readState == RDS_EVENT) {
+          if ((_numKeyEvents = (_inputBuffer[0] & 0x0F)) != 0) {
+            // We could read each key event waiting in a synchronous loop, which may prove preferable
+            // but for now, schedule an async read of the first key event in the queue
+            _commandBuffer[0] = REG_KEY_EVENT_A;
+            I2CManager.read(_I2CAddress, _inputBuffer, 1, _commandBuffer, 1, &_i2crb);  // non-blocking read
+            _readState = RDS_KEYCODE; // Shift to reading key events!
+          }
+          else // We found no key events waiting, return to IDLE
+            _readState = RDS_IDLE;
+        }
+         else {
+          // RDS_KEYCODE
+          uint8_t key = _inputBuffer[0] & 0x7F;
+          bool keyDown = _inputBuffer[0] & 0x80;
+          // Check for just keypad events
+          key--; // R0/C0 is key #1, so subtract 1 to create an array offset
+          // We only want to record key events we're configured for, as we have calloc'd an
+          // appropriately sized _digitalInputStates array!
+          if (key < _nPins) {
+            if (keyDown)
+              _digitalInputStates[key / 8] |= (1 << (key % 8));
+            else
+              _digitalInputStates[key / 8] &= ~(1 << (key % 8));
+          }
+          else
+            DIAG(F("TCA8418 I2C: key event %d discarded, outside Vpin range"), key);
+          _numKeyEvents--; // One less key event to get
+          if (_numKeyEvents != 0)
+          {
+            // DIAG(F("TCA8418 I2C: more keys in read event queue, # waiting is: %x"), _numKeyEvents);
+            // We could read each key event waiting in a synchronous loop, which may prove preferable
+            // but for now, schedule an async read of the first key event in the queue
+            _commandBuffer[0] = REG_KEY_EVENT_A;
+            I2CManager.read(_I2CAddress, _inputBuffer, 1, _commandBuffer, 1, &_i2crb); // non-blocking read
+          }
+          else {
+            // DIAG(F("TCA8418 I2C: no more keys in read event queue"));
+            // Clear any pending interrupts
+            I2CManager.write(_I2CAddress, 2, REG_INT_STAT, REG_STAT_K_INT);
+            _readState = RDS_IDLE; // Shift to IDLE
+            return;
+          }
+         }
+      } else
+        reportError(status, false);   // report eror but don't go offline.
+    }
+
+    // If we're not doing anything now, check to see if we have an interrupt pin configured and it is low,
+    // or if our timer has elapsed and we should check anyway in case the interrupt pin is disconnected.
+    if (_readState == RDS_IDLE) {
+      if ((_gpioInterruptsEnabled && !digitalRead(_gpioInterruptPin)) ||
+        ((currentMicros - _lastEventRead) > _eventRefresh))
+      {
+        _commandBuffer[0] = REG_KEY_LCK_EC;
+        I2CManager.read(_I2CAddress, _inputBuffer, 1, _commandBuffer, 1, &_i2crb);  // non-blocking read
+        _lastEventRead = currentMicros;
+        _readState = RDS_EVENT; // Shift to looking for key events!
+      }
+    }
+  }
+
+  // Display device information and status
+  void _display() override {
+    DIAG(F("TCA8418 I2C:%s Vpins %u-%u%S"),
+              _I2CAddress.toString(),
+              _firstVpin, (_firstVpin+_nPins-1),
+              _deviceState == DEVSTATE_FAILED ? F(" OFFLINE") : F(""));
+    if (_gpioInterruptsEnabled)
+      DIAG(F("TCA8418 I2C:Interrupt on pin %d"), _gpioInterruptPin);
+  }
+
+  // Helper function for error handling
+  void reportError(uint8_t status, bool fail=true) {
+    DIAG(F("TCA8418 I2C:%s Error:%d (%S)"), _I2CAddress.toString(), 
+      status, I2CManager.getErrorMessage(status));
+    if (fail)
+    _deviceState = DEVSTATE_FAILED;
+  }
+
+  enum tca8418_registers
+  {
+    // REG_RESERVED = 0x00
+    REG_CFG = 0x01,             // Configuration register
+    REG_INT_STAT = 0x02,        // Interrupt status
+    REG_KEY_LCK_EC = 0x03,      // Key lock and event counter
+    REG_KEY_EVENT_A = 0x04,     // Key event register A
+    REG_KEY_EVENT_B = 0x05,     // Key event register B
+    REG_KEY_EVENT_C = 0x06,     // Key event register C
+    REG_KEY_EVENT_D = 0x07,     // Key event register D
+    REG_KEY_EVENT_E = 0x08,     // Key event register E
+    REG_KEY_EVENT_F = 0x09,     // Key event register F
+    REG_KEY_EVENT_G = 0x0A,     // Key event register G
+    REG_KEY_EVENT_H = 0x0B,     // Key event register H
+    REG_KEY_EVENT_I = 0x0C,     // Key event register I
+    REG_KEY_EVENT_J = 0x0D,     // Key event register J
+    REG_KP_LCK_TIMER = 0x0E,    // Keypad lock1 to lock2 timer
+    REG_UNLOCK_1 = 0x0F,        // Unlock register 1
+    REG_UNLOCK_2 = 0x10,        // Unlock register 2
+    REG_GPIO_INT_STAT_1 = 0x11, // GPIO interrupt status 1
+    REG_GPIO_INT_STAT_2 = 0x12, // GPIO interrupt status 2
+    REG_GPIO_INT_STAT_3 = 0x13, // GPIO interrupt status 3
+    REG_GPIO_DAT_STAT_1 = 0x14, // GPIO data status 1
+    REG_GPIO_DAT_STAT_2 = 0x15, // GPIO data status 2
+    REG_GPIO_DAT_STAT_3 = 0x16, // GPIO data status 3
+    REG_GPIO_DAT_OUT_1 = 0x17,  // GPIO data out 1
+    REG_GPIO_DAT_OUT_2 = 0x18,  // GPIO data out 2
+    REG_GPIO_DAT_OUT_3 = 0x19,  // GPIO data out 3
+    REG_GPIO_INT_EN_1 = 0x1A,   // GPIO interrupt enable 1
+    REG_GPIO_INT_EN_2 = 0x1B,   // GPIO interrupt enable 2
+    REG_GPIO_INT_EN_3 = 0x1C,   // GPIO interrupt enable 3
+    REG_KP_GPIO_1 = 0x1D,       // Keypad/GPIO select 1
+    REG_KP_GPIO_2 = 0x1E,       // Keypad/GPIO select 2
+    REG_KP_GPIO_3 = 0x1F,       // Keypad/GPIO select 3
+    REG_GPI_EM_1 = 0x20,        // GPI event mode 1
+    REG_GPI_EM_2 = 0x21,        // GPI event mode 2
+    REG_GPI_EM_3 = 0x22,        // GPI event mode 3
+    REG_GPIO_DIR_1 = 0x23,      // GPIO data direction 1
+    REG_GPIO_DIR_2 = 0x24,      // GPIO data direction 2
+    REG_GPIO_DIR_3 = 0x25,      // GPIO data direction 3
+    REG_GPIO_INT_LVL_1 = 0x26,  // GPIO edge/level detect 1
+    REG_GPIO_INT_LVL_2 = 0x27,  // GPIO edge/level detect 2
+    REG_GPIO_INT_LVL_3 = 0x28,  // GPIO edge/level detect 3
+    REG_DEBOUNCE_DIS_1 = 0x29,  // Debounce disable 1
+    REG_DEBOUNCE_DIS_2 = 0x2A,  // Debounce disable 2
+    REG_DEBOUNCE_DIS_3 = 0x2B,  // Debounce disable 3
+    REG_GPIO_PULL_1 = 0x2C,     // GPIO pull-up disable 1
+    REG_GPIO_PULL_2 = 0x2D,     // GPIO pull-up disable 2
+    REG_GPIO_PULL_3 = 0x2E,     // GPIO pull-up disable 3
+    // REG_RESERVED = 0x2F
+  };
+
+  enum tca8418_config_reg_fields
+  {
+    //  Config Register #1 fields
+    REG_CFG_AI = 0x80,           // Auto-increment for read/write
+    REG_CFG_GPI_E_CGF = 0x40,    // Event mode config
+    REG_CFG_OVR_FLOW_M = 0x20,   // Overflow mode enable
+    REG_CFG_INT_CFG = 0x10,      // Interrupt config
+    REG_CFG_OVR_FLOW_IEN = 0x08, // Overflow interrupt enable
+    REG_CFG_K_LCK_IEN = 0x04,    // Keypad lock interrupt enable
+    REG_CFG_GPI_IEN = 0x02,      // GPI interrupt enable
+    REG_CFG_KE_IEN = 0x01,       // Key events interrupt enable
+  };
+
+  enum tca8418_int_status_fields
+  {
+    //  Interrupt Status Register #2 fields
+    REG_STAT_CAD_INT = 0x10,      // Ctrl-alt-del seq status
+    REG_STAT_OVR_FLOW_INT = 0x08, // Overflow interrupt status
+    REG_STAT_K_LCK_INT = 0x04,    // Key lock interrupt status
+    REG_STAT_GPI_INT = 0x02,      // GPI interrupt status
+    REG_STAT_K_INT = 0x01,        // Key events interrupt status
+  };
+
+  enum tca8418_lock_ec_fields
+  {
+    // Key Lock Event Count Register #3
+    REG_LCK_EC_K_LCK_EN = 0x40, // Key lock enable
+    REG_LCK_EC_LCK_2 = 0x20,    // Keypad lock status 2
+    REG_LCK_EC_LCK_1 = 0x10,    // Keypad lock status 1
+    REG_LCK_EC_KLEC_3 = 0x08,   // Key event count bit 3
+    REG_LCK_EC_KLEC_2 = 0x04,   // Key event count bit 2
+    REG_LCK_EC_KLEC_1 = 0x02,   // Key event count bit 1
+    REG_LCK_EC_KLEC_0 = 0x01,   // Key event count bit 0
+  };
+};
+
+#endif

IO_TM1638.cpp

@@ -0,0 +1,216 @@
+/*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/* Credit to https://github.com/dvarrel/TM1638 for the basic formulae.*/
+
+
+#include <Arduino.h>
+#include "IODevice.h"
+#include "IO_TM1638.h"
+#include "DIAG.h"
+
+   
+const uint8_t HIGHFLASH _digits[16]={
+      0b00111111,0b00000110,0b01011011,0b01001111,
+      0b01100110,0b01101101,0b01111101,0b00000111,
+      0b01111111,0b01101111,0b01110111,0b01111100,
+      0b00111001,0b01011110,0b01111001,0b01110001
+    };
+
+  // Constructor
+   TM1638::TM1638(VPIN firstVpin, byte clk_pin,byte dio_pin,byte stb_pin){
+    _firstVpin = firstVpin;
+    _nPins = 8;
+    _clk_pin = clk_pin;
+    _stb_pin = stb_pin;
+    _dio_pin = dio_pin;
+    pinMode(clk_pin,OUTPUT);
+    pinMode(stb_pin,OUTPUT);
+    pinMode(dio_pin,OUTPUT);
+    _pulse = PULSE1_16;
+      
+    _buttons=0;
+    _leds=0;
+    _lastLoop=micros();
+    addDevice(this);
+   } 
+
+    
+  void TM1638::create(VPIN firstVpin, byte clk_pin,byte dio_pin,byte stb_pin) {
+    if (checkNoOverlap(firstVpin,8)) 
+     new TM1638(firstVpin, clk_pin,dio_pin,stb_pin); 
+  }
+
+  void TM1638::_begin()  {
+    displayClear();
+    test();
+    _display();
+  }
+  
+ 
+  void TM1638::_loop(unsigned long currentMicros)  {
+     if (currentMicros - _lastLoop > (1000000UL/LoopHz)) {
+         _buttons=getButtons();// Read the buttons
+         _lastLoop=currentMicros;   
+     } 
+  }
+           
+  void TM1638::_display()  {
+    DIAG(F("TM1638 Configured on Vpins:%u-%u"), _firstVpin, _firstVpin+_nPins-1);
+  }
+
+// digital read gets button state 
+int TM1638::_read(VPIN vpin)  {
+  byte pin=vpin - _firstVpin;
+  bool result=bitRead(_buttons,pin);
+  // DIAG(F("TM1638 read (%d) buttons %x = %d"),pin,_buttons,result);  
+  return result;
+}
+
+// digital write sets led state 
+void TM1638::_write(VPIN vpin, int value)  {
+  // TODO.. skip if no state change  
+  writeLed(vpin - _firstVpin + 1,value!=0);
+  }
+
+// Analog write sets digit displays 
+
+void TM1638::_writeAnalogue(VPIN vpin, int lowBytes, uint8_t mode, uint16_t highBytes)  {  
+   // mode is in DataFormat defined above.
+   byte formatLength=mode & 0x0F;  // last 4 bits 
+   byte formatType=mode & 0xF0;         //           
+   int8_t leftDigit=vpin-_firstVpin; // 0..7 from left
+   int8_t rightDigit=leftDigit+formatLength-1; // 0..7 from left
+   
+   // loading is done right to left startDigit first
+   int8_t startDigit=7-rightDigit; // reverse as 7 on left
+   int8_t lastDigit=7-leftDigit; // reverse as 7 on left
+   uint32_t value=highBytes;
+   value<<=16;
+   value |= (uint16_t)lowBytes;
+   
+   //DIAG(F("TM1638 fl=%d ft=%x sd=%d ld=%d v=%l vx=%X"),
+   // formatLength,formatType,startDigit,lastDigit,value,value);
+    while(startDigit<=lastDigit) {
+        switch (formatType) {
+            case _DF_DECIMAL:// decimal (leading zeros)
+                displayDig(startDigit,GETHIGHFLASH(_digits,(value%10))); 
+                value=value/10;
+                break; 
+            case _DF_HEX:// HEX (leading zeros)
+                displayDig(startDigit,GETHIGHFLASH(_digits,(value & 0x0F))); 
+                value>>=4;
+                break;  
+            case _DF_RAW:// Raw 7-segment pattern 
+                displayDig(startDigit,value & 0xFF); 
+                value>>=8;
+                break;
+            default:
+                DIAG(F("TM1368 invalid mode 0x%x"),mode);
+                return;
+            }
+    startDigit++;
+    } 
+}
+     
+uint8_t TM1638::getButtons(){
+  ArduinoPins::fastWriteDigital(_stb_pin, LOW);
+  writeData(INSTRUCTION_READ_KEY);
+  pinMode(_dio_pin, INPUT);
+  ArduinoPins::fastWriteDigital(_clk_pin, LOW);
+  uint8_t buttons=0;
+  for (uint8_t eachByte=0; eachByte<4;eachByte++) {
+    uint8_t value = 0;
+	  for (uint8_t eachBit = 0; eachBit < 8; eachBit++) {
+		  ArduinoPins::fastWriteDigital(_clk_pin, HIGH);
+			value |= ArduinoPins::fastReadDigital(_dio_pin) << eachBit;
+		  ArduinoPins::fastWriteDigital(_clk_pin, LOW);
+	  }
+    buttons |= value << eachByte; 
+    delayMicroseconds(1);
+  }
+  pinMode(_dio_pin, OUTPUT);
+  ArduinoPins::fastWriteDigital(_stb_pin, HIGH);
+  return buttons;
+}
+
+
+void TM1638::displayDig(uint8_t digitId, uint8_t pgfedcba){
+  if (digitId>7) return;
+  setDataInstruction(DISPLAY_TURN_ON | _pulse);
+  setDataInstruction(INSTRUCTION_WRITE_DATA| INSTRUCTION_ADDRESS_FIXED);
+  writeDataAt(FIRST_DISPLAY_ADDRESS+14-(digitId*2), pgfedcba);
+}
+
+void TM1638::displayClear(){
+  setDataInstruction(DISPLAY_TURN_ON | _pulse);
+  setDataInstruction(INSTRUCTION_WRITE_DATA | INSTRUCTION_ADDRESS_FIXED);
+  for (uint8_t i=0;i<15;i+=2){
+    writeDataAt(FIRST_DISPLAY_ADDRESS+i,0x00);
+  }
+}
+
+void TM1638::writeLed(uint8_t num,bool state){
+  if ((num<1) | (num>8)) return;
+  setDataInstruction(DISPLAY_TURN_ON | _pulse);
+  setDataInstruction(INSTRUCTION_WRITE_DATA | INSTRUCTION_ADDRESS_FIXED);
+  writeDataAt(FIRST_DISPLAY_ADDRESS + (num*2-1), state);
+}
+
+
+void TM1638::writeData(uint8_t data){
+	for (uint8_t i = 0; i < 8; i++)  {
+		ArduinoPins::fastWriteDigital(_dio_pin, data & 1);
+		data >>= 1;
+		ArduinoPins::fastWriteDigital(_clk_pin, HIGH);
+		ArduinoPins::fastWriteDigital(_clk_pin, LOW);		
+	}
+} 
+
+void TM1638::writeDataAt(uint8_t displayAddress, uint8_t data){
+    ArduinoPins::fastWriteDigital(_stb_pin, LOW);
+    writeData(displayAddress);
+    writeData(data);
+    ArduinoPins::fastWriteDigital(_stb_pin, HIGH);
+    delayMicroseconds(1);
+}
+
+void TM1638::setDataInstruction(uint8_t dataInstruction){
+  ArduinoPins::fastWriteDigital(_stb_pin, LOW);
+  writeData(dataInstruction);
+  ArduinoPins::fastWriteDigital(_stb_pin, HIGH);
+  delayMicroseconds(1);  
+}
+
+void TM1638::test(){
+  DIAG(F("TM1638 test"));
+  uint8_t val=0;
+  for(uint8_t i=0;i<5;i++){
+    setDataInstruction(DISPLAY_TURN_ON | _pulse);
+    setDataInstruction(INSTRUCTION_WRITE_DATA| INSTRUCTION_ADDRESS_AUTO);
+    ArduinoPins::fastWriteDigital(_stb_pin, LOW);
+    writeData(FIRST_DISPLAY_ADDRESS);
+    for(uint8_t i=0;i<16;i++)
+      writeData(val);
+    ArduinoPins::fastWriteDigital(_stb_pin, HIGH);
+    delay(1000);
+    val = ~val;
+  }
+
+}

IO_TM1638.h

@@ -0,0 +1,134 @@
+   /*
+ *  © 2024, Chris Harlow. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef IO_TM1638_h
+#define IO_TM1638_h
+#include <Arduino.h>
+#include "IODevice.h"
+#include "DIAG.h"
+
+class TM1638 : public IODevice {
+private: 
+      
+    uint8_t _buttons;
+    uint8_t _leds;
+    unsigned long _lastLoop;
+    static const int LoopHz=20; 
+
+    static const byte 
+    INSTRUCTION_WRITE_DATA=0x40,
+    INSTRUCTION_READ_KEY=0x42,
+    INSTRUCTION_ADDRESS_AUTO=0x40,
+    INSTRUCTION_ADDRESS_FIXED=0x44,
+    INSTRUCTION_NORMAL_MODE=0x40,
+    INSTRUCTION_TEST_MODE=0x48,
+
+    FIRST_DISPLAY_ADDRESS=0xC0,
+
+    DISPLAY_TURN_OFF=0x80,
+    DISPLAY_TURN_ON=0x88;
+
+        
+    uint8_t _clk_pin;
+    uint8_t _stb_pin;
+    uint8_t _dio_pin;
+    uint8_t _pulse;
+    bool _isOn;
+
+    
+  // Constructor
+   TM1638(VPIN firstVpin, byte clk_pin,byte dio_pin,byte stb_pin);
+
+public:
+  enum DigitFormat : byte {
+    // last 4 bits are length.
+    // DF_1.. DF_8 decimal 
+    DF_1=0x01,DF_2=0x02,DF_3=0x03,DF_4=0x04,
+    DF_5=0x05,DF_6=0x06,DF_7=0x07,DF_8=0x08,
+    // DF_1X.. DF_8X HEX 
+    DF_1X=0x11,DF_2X=0x12,DF_3X=0x13,DF_4X=0x14,
+    DF_5X=0x15,DF_6X=0x16,DF_7X=0x17,DF_8X=0x18,
+    // DF_1R .. DF_4R raw 7 segmnent data 
+    // only 4 because HAL analogWrite only passes 4 bytes 
+    DF_1R=0x21,DF_2R=0x22,DF_3R=0x23,DF_4R=0x24,
+    
+    //  bits of data conversion type  (ored with length) 
+    _DF_DECIMAL=0x00,// right adjusted decimal unsigned leading zeros
+    _DF_HEX=0x10,    // right adjusted hex leading zeros 
+    _DF_RAW=0x20 // bytes are raw 7-segment pattern (max length 4)
+  };
+
+  static void create(VPIN firstVpin, byte clk_pin,byte dio_pin,byte stb_pin);
+  
+  // Functions overridden in IODevice
+  void _begin();
+  void _loop(unsigned long currentMicros) override ;
+  void _writeAnalogue(VPIN vpin, int value, uint8_t param1, uint16_t param2) override;
+  void _display() override ;
+  int _read(VPIN pin) override;
+  void _write(VPIN pin,int value) override;
+
+  // Device driving functions 
+  private:
+   enum pulse_t {
+      PULSE1_16,
+      PULSE2_16,
+      PULSE4_16,
+      PULSE10_16,
+      PULSE11_16,
+      PULSE12_16,
+      PULSE13_16,
+      PULSE14_16
+    };
+
+  /**
+    * @fn getButtons
+    * @return state of 8 buttons
+    */
+    uint8_t getButtons();
+
+    /**
+    * @fn writeLed
+    * @brief put led ON or OFF
+    * @param num num of led(1-8)
+    * @param state (true or false)
+    */
+    void writeLed(uint8_t num, bool state);
+    
+    
+    /**
+    * @fn displayDig
+    * @brief set 7 segment display + dot
+    * @param digitId num of digit(0-7)
+    * @param val value 8 bits
+    */
+    void displayDig(uint8_t digitId, uint8_t pgfedcba);
+
+    /**
+    * @fn displayClear
+    * @brief switch off all leds and segment display
+    */
+    void displayClear();
+    void test();
+    void writeData(uint8_t data);
+    void writeDataAt(uint8_t displayAddress, uint8_t data);
+    void setDisplayMode(uint8_t displayMode);
+    void setDataInstruction(uint8_t dataInstruction);
+};
+#endif

IO_TouchKeypad.h

@@ -131,4 +131,4 @@ protected:
 
 };
 
-#endif // IO_TOUCHKEYPAD_H
+#endif // IO_TOUCHKEYPAD_H

IO_duinoNodes.h

@@ -170,4 +170,4 @@ public:
   }
 
 };
-#endif
+#endif

IO_trainbrains.h

@@ -0,0 +1,98 @@
+/*
+ *  © 2023, Chris Harlow. All rights reserved.
+ *  © 2021, Neil McKechnie. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef io_trainbrains_h
+#define io_trainbrains_h
+
+#include "IO_GPIOBase.h"
+#include "FSH.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+ * IODevice subclass for trainbrains 3-block occupancy detector.
+ * For details see http://trainbrains.eu
+ */
+ 
+ enum TrackUnoccupancy
+{
+    TRACK_UNOCCUPANCY_UNKNOWN = 0,
+    TRACK_OCCUPIED = 1,
+    TRACK_UNOCCUPIED = 2
+};
+
+class Trainbrains02 : public GPIOBase<uint16_t> {
+public:
+  static void create(VPIN vpin, uint8_t nPins, I2CAddress i2cAddress) {
+    if (checkNoOverlap(vpin, nPins, i2cAddress)) new Trainbrains02(vpin, nPins, i2cAddress);
+  }
+
+private:  
+  // Constructor
+  Trainbrains02(VPIN vpin, uint8_t nPins, I2CAddress i2cAddress, int interruptPin=-1) 
+    : GPIOBase<uint16_t>((FSH *)F("Trainbrains02"), vpin, nPins, i2cAddress, interruptPin) 
+  {
+    requestBlock.setRequestParams(_I2CAddress, inputBuffer, sizeof(inputBuffer),
+      outputBuffer, sizeof(outputBuffer));
+    
+     outputBuffer[0] = (uint8_t)_I2CAddress; // strips away the mux part.
+     outputBuffer[1] =14;
+     outputBuffer[2] =1;
+     outputBuffer[3] =0;  // This is the channel updated at each poling call
+     outputBuffer[4] =0;
+     outputBuffer[5] =0;
+     outputBuffer[6] =0;
+     outputBuffer[7] =0;
+     outputBuffer[8] =0;
+     outputBuffer[9] =0;
+  }
+  
+  void _writeGpioPort() override {}
+
+  void _readGpioPort(bool immediate) override {
+    // cycle channel on device each time 
+    outputBuffer[3]=channelInProgress+1; // 1-origin 
+    channelInProgress++;
+    if(channelInProgress>=_nPins) channelInProgress=0; 
+    
+    if (immediate) {
+      _processCompletion(I2CManager.read(_I2CAddress, inputBuffer, sizeof(inputBuffer), 
+                                   outputBuffer, sizeof(outputBuffer)));
+    } else {
+      // Queue new request
+      requestBlock.wait(); // Wait for preceding operation to complete
+      // Issue new request to read GPIO register
+      I2CManager.queueRequest(&requestBlock);
+    }
+  }
+
+  // This function is invoked when an I/O operation on the requestBlock completes.
+  void _processCompletion(uint8_t status) override {
+    if (status != I2C_STATUS_OK) inputBuffer[6]=TRACK_UNOCCUPANCY_UNKNOWN;  
+    if (inputBuffer[6] == TRACK_UNOCCUPIED ) _portInputState |=  0x01 <<channelInProgress;
+    else _portInputState &=  ~(0x01 <<channelInProgress);
+  }
+
+  uint8_t channelInProgress=0; 
+  uint8_t outputBuffer[10];
+  uint8_t inputBuffer[10];
+  
+};
+
+#endif

KeywordHasher.h

@@ -0,0 +1,96 @@
+/*
+ *  © 2024 Vincent Hamp and Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of CommandStation-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+/* Reader be aware: 
+ This function implements the _hk data type so that a string keyword
+ is hashed to the same value as the DCCEXParser uses to hash incoming 
+ keywords. 
+ Thus  "MAIN"_hk  generates exactly the same run time vakue 
+ as   const int16_t HASH_KEYWORD_MAIN=11339  
+*/
+#ifndef KeywordHasher_h
+#define KeywordHasher_h
+
+#include <Arduino.h>
+constexpr uint16_t CompiletimeKeywordHasher(const char *  sv, uint16_t running=0) {
+    return (*sv==0) ? running : CompiletimeKeywordHasher(sv+1,
+          (*sv >= '0' && *sv <= '9') 
+            ? (10*running+*sv-'0')  // Numeric hash  
+            : ((running << 5) + running) ^ *sv
+            );  // 
+}
+
+constexpr int16_t operator""_hk(const char * keyword, size_t len) 
+{
+    return (int16_t) CompiletimeKeywordHasher(keyword,len*0);
+}
+
+/* Some historical values for testing:
+const int16_t HASH_KEYWORD_MAIN = 11339;
+const int16_t HASH_KEYWORD_SLOW = -17209;
+const int16_t HASH_KEYWORD_SPEED28 = -17064;
+const int16_t HASH_KEYWORD_SPEED128 = 25816;
+*/
+
+static_assert("MAIN"_hk == 11339,"Keyword hasher error");
+static_assert("SLOW"_hk == -17209,"Keyword hasher error");
+static_assert("SPEED28"_hk == -17064,"Keyword hasher error");
+static_assert("SPEED128"_hk == 25816,"Keyword hasher error");
+
+// Compile time converter from "abcd"_s7  to the 7 segment nearest equivalent
+
+constexpr uint8_t seg7Digits[]={
+      0b00111111,0b00000110,0b01011011,0b01001111, // 0..3
+      0b01100110,0b01101101,0b01111101,0b00000111, // 4..7
+      0b01111111,0b01101111 // 8..9
+    };
+    
+constexpr uint8_t seg7Letters[]={
+        0b01110111,0b01111100,0b00111001,0b01011110, // ABCD
+        0b01111001,0b01110001,0b00111101,0b01110110, // EFGH 
+        0b00000100,0b00011110,0b01110010,0b00111000,  //IJKL
+        0b01010101,0b01010100,0b01011100,0b01110011, // MNOP
+        0b10111111,0b01010000,0b01101101,0b01111000, // QRST
+        0b00111110,0b00011100,0b01101010,0b01001001,  //UVWX
+        0b01100110,0b01011011  //YZ
+    };
+constexpr uint8_t seg7Space=0b00000000;
+constexpr uint8_t seg7Minus=0b01000000;
+constexpr uint8_t seg7Equals=0b01001000;
+    
+
+constexpr uint32_t CompiletimeSeg7(const char *  sv, uint32_t running, size_t rlen) {
+    return (*sv==0 || rlen==0) ? running << (8*rlen) : CompiletimeSeg7(sv+1,
+          (*sv >= '0' && *sv <= '9') ? (running<<8) | seg7Digits[*sv-'0'] : 
+          (*sv >= 'A' && *sv <= 'Z') ? (running<<8) | seg7Letters[*sv-'A'] : 
+          (*sv >= 'a' && *sv <= 'z') ? (running<<8) | seg7Letters[*sv-'a'] : 
+          (*sv == '-') ? (running<<8) | seg7Minus : 
+          (*sv == '=') ? (running<<8) | seg7Equals : 
+                         (running<<8) | seg7Space,
+          rlen-1               
+        );  // 
+}
+
+constexpr uint32_t operator""_s7(const char * keyword, size_t len) 
+{
+    return  CompiletimeSeg7(keyword,0*len,4);
+}
+#endif

LiquidCrystal_I2C.cpp

@@ -221,4 +221,4 @@ void LiquidCrystal_I2C::expanderWrite(uint8_t value) {
   rb.wait();
   outputBuffer[0] = value | _backlightval;
   I2CManager.write(_Addr, outputBuffer, 1, &rb);  // Write command asynchronously
-}
+}

MotorDriver.cpp

@@ -1,5 +1,6 @@
 /*
- *  © 2022-2023 Paul M Antoine
+ *  © 2022-2024 Paul M Antoine
+ *  © 2024 Herb Morton
  *  © 2021 Mike S
  *  © 2021 Fred Decker
  *  © 2020-2023 Harald Barth
@@ -38,6 +39,8 @@ volatile portreg_t shadowPORTC;
 volatile portreg_t shadowPORTD;
 volatile portreg_t shadowPORTE;
 volatile portreg_t shadowPORTF;
+volatile portreg_t shadowPORTG;
+volatile portreg_t shadowPORTH;
 #endif
 
 MotorDriver::MotorDriver(int16_t power_pin, byte signal_pin, byte signal_pin2, int16_t brake_pin,
@@ -88,6 +91,16 @@ MotorDriver::MotorDriver(int16_t power_pin, byte signal_pin, byte signal_pin2, i
     fastSignalPin.shadowinout = fastSignalPin.inout;
     fastSignalPin.inout = &shadowPORTF;
   }
+  if (HAVE_PORTG(fastSignalPin.inout == &PORTG)) {
+    DIAG(F("Found PORTG pin %d"),signalPin);
+    fastSignalPin.shadowinout = fastSignalPin.inout;
+    fastSignalPin.inout = &shadowPORTG;
+  }
+  if (HAVE_PORTH(fastSignalPin.inout == &PORTH)) {
+    DIAG(F("Found PORTH pin %d"),signalPin);
+    fastSignalPin.shadowinout = fastSignalPin.inout;
+    fastSignalPin.inout = &shadowPORTH;
+  }
 
   signalPin2=signal_pin2;
   if (signalPin2!=UNUSED_PIN) {
@@ -126,6 +139,16 @@ MotorDriver::MotorDriver(int16_t power_pin, byte signal_pin, byte signal_pin2, i
       fastSignalPin2.shadowinout = fastSignalPin2.inout;
       fastSignalPin2.inout = &shadowPORTF;
     }
+    if (HAVE_PORTG(fastSignalPin2.inout == &PORTG)) {
+      DIAG(F("Found PORTG pin %d"),signalPin2);
+      fastSignalPin2.shadowinout = fastSignalPin2.inout;
+      fastSignalPin2.inout = &shadowPORTG;
+    }
+    if (HAVE_PORTH(fastSignalPin2.inout == &PORTH)) {
+      DIAG(F("Found PORTH pin %d"),signalPin2);
+      fastSignalPin2.shadowinout = fastSignalPin2.inout;
+      fastSignalPin2.inout = &shadowPORTH;
+    }
   }
   else dualSignal=false; 
   
@@ -204,7 +227,7 @@ MotorDriver::MotorDriver(int16_t power_pin, byte signal_pin, byte signal_pin2, i
 }
 
 bool MotorDriver::isPWMCapable() {
-    return (!dualSignal) && DCCTimer::isPWMPin(signalPin); 
+    return (!dualSignal) && DCCTimer::isPWMPin(signalPin);
 }
 
 
@@ -325,49 +348,21 @@ uint16_t taurustones[28] = { 165, 175, 196, 220,
 			     220, 196, 175, 165 };
 #endif
 #endif
-void MotorDriver::setDCSignal(byte speedcode) {
+void MotorDriver::setDCSignal(byte speedcode, uint8_t frequency /*default =0*/) {
   if (brakePin == UNUSED_PIN)
     return;
-  switch(brakePin) {
-#if defined(ARDUINO_AVR_UNO)
-    // Not worth doin something here as:
-    // If we are on pin 9 or 10 we are on Timer1 and we can not touch Timer1 as that is our DCC source.
-    // If we are on pin 5 or 6 we are on Timer 0 ad we can not touch Timer0 as that is millis() etc.
-    // We are most likely not on pin 3 or 11 as no known motor shield has that as brake.
-#endif
-#if defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2560)
-  case 9:
-  case 10:
-    // Timer2 (is differnet)
-    TCCR2A = (TCCR2A & B11111100) | B00000001; // set WGM1=0 and WGM0=1 phase correct PWM
-    TCCR2B = (TCCR2B & B11110000) | B00000110; // set WGM2=0 ; set divisor on timer 2 to 1/256 for 122.55Hz
-    //DIAG(F("2 A=%x B=%x"), TCCR2A, TCCR2B);
-    break;
-  case 6:
-  case 7:
-  case 8:
-    // Timer4
-    TCCR4A = (TCCR4A & B11111100) | B00000001; // set WGM0=1 and WGM1=0 for normal PWM 8-bit
-    TCCR4B = (TCCR4B & B11100000) | B00000100; // set WGM2=0 and WGM3=0 for normal PWM 8 bit and div 1/256 for 122.55Hz
-    break;
-  case 46:
-  case 45:
-  case 44:
-    // Timer5
-    TCCR5A = (TCCR5A & B11111100) | B00000001; // set WGM0=1 and WGM1=0 for normal PWM 8-bit
-    TCCR5B = (TCCR5B & B11100000) | B00000100; // set WGM2=0 and WGM3=0 for normal PWM 8 bit and div 1/256 for 122.55Hz
-    break;
-#endif
-  default:
-    break;
-  }
   // spedcoode is a dcc speed & direction
   byte tSpeed=speedcode & 0x7F; // DCC Speed with 0,1 stop and speed steps 2 to 127
   byte tDir=speedcode & 0x80;
   byte brake;
+
+  if (tSpeed <= 1) brake = 255;
+  else if (tSpeed >= 127) brake = 0;
+  else  brake = 2 * (128-tSpeed);
+
+  { // new block because of variable f
 #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_STM32)
-  {
-    int f = 131;
+    int f = frequency;
 #ifdef VARIABLE_TONES
     if (tSpeed > 2) {
       if (tSpeed <= 58) {
@@ -375,19 +370,15 @@ void MotorDriver::setDCSignal(byte speedcode) {
       }
     }
 #endif
-    DCCTimer::DCCEXanalogWriteFrequency(brakePin, f); // set DC PWM frequency to 100Hz XXX May move to setup
+    //DIAG(F("Brake pin %d value %d freqency %d"), brakePin, brake, f);
+    DCCTimer::DCCEXanalogWrite(brakePin, brake, invertBrake);
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, f); // set DC PWM frequency
+#else // all AVR here
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, frequency); // frequency steps
+    analogWrite(brakePin, invertBrake ? 255-brake : brake);
+#endif
   }
-#endif
-  if (tSpeed <= 1) brake = 255;
-  else if (tSpeed >= 127) brake = 0;
-  else  brake = 2 * (128-tSpeed);
-  if (invertBrake)
-    brake=255-brake;
-#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_STM32)
-  DCCTimer::DCCEXanalogWrite(brakePin,brake);
-#else
-  analogWrite(brakePin,brake);
-#endif
+
   //DIAG(F("DCSignal %d"), speedcode);
   if (HAVE_PORTA(fastSignalPin.shadowinout == &PORTA)) {
     noInterrupts();
@@ -425,6 +416,18 @@ void MotorDriver::setDCSignal(byte speedcode) {
     setSignal(tDir);
     HAVE_PORTF(PORTF=shadowPORTF);
     interrupts();
+  } else if (HAVE_PORTG(fastSignalPin.shadowinout == &PORTG)) {
+    noInterrupts();
+    HAVE_PORTG(shadowPORTG=PORTG);
+    setSignal(tDir);
+    HAVE_PORTG(PORTG=shadowPORTG);
+    interrupts();
+  } else if (HAVE_PORTH(fastSignalPin.shadowinout == &PORTH)) {
+    noInterrupts();
+    HAVE_PORTH(shadowPORTH=PORTH);
+    setSignal(tDir);
+    HAVE_PORTH(PORTH=shadowPORTH);
+    interrupts();
   } else {
     noInterrupts();
     setSignal(tDir);
@@ -434,60 +437,28 @@ void MotorDriver::setDCSignal(byte speedcode) {
 void MotorDriver::throttleInrush(bool on) {
   if (brakePin == UNUSED_PIN)
     return;
-  if ( !(trackMode & (TRACK_MODE_MAIN | TRACK_MODE_PROG | TRACK_MODE_EXT)))
+  if ( !(trackMode & (TRACK_MODE_MAIN | TRACK_MODE_PROG | TRACK_MODE_EXT | TRACK_MODE_BOOST)))
     return;
-  byte duty = on ? 208 : 0;
-  if (invertBrake)
-    duty = 255-duty;
+  byte duty = on ? 207 : 0; // duty of 81% at 62500Hz this gives pauses of 3usec
 #if defined(ARDUINO_ARCH_ESP32)
   if(on) {
-    DCCTimer::DCCEXanalogWrite(brakePin,duty);
-    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 62500);
+    DCCTimer::DCCEXInrushControlOn(brakePin, duty, invertBrake);
   } else {
-    ledcDetachPin(brakePin);
+    ledcDetachPin(brakePin); // not DCCTimer::DCCEXledcDetachPin() as we have not
+                             // registered the pin in the pin to channel array
   }
 #elif defined(ARDUINO_ARCH_STM32)
   if(on) {
-    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 62500);
-    DCCTimer::DCCEXanalogWrite(brakePin,duty);
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 7); // 7 means max
+    DCCTimer::DCCEXanalogWrite(brakePin,duty,invertBrake);
   } else {
     pinMode(brakePin, OUTPUT);
   }
-#else
+#else // all AVR here
+  if (invertBrake)
+    duty = 255-duty;
   if(on){
-    switch(brakePin) {
-#if defined(ARDUINO_AVR_UNO)
-      // Not worth doin something here as:
-      // If we are on pin 9 or 10 we are on Timer1 and we can not touch Timer1 as that is our DCC source.
-      // If we are on pin 5 or 6 we are on Timer 0 ad we can not touch Timer0 as that is millis() etc.
-      // We are most likely not on pin 3 or 11 as no known motor shield has that as brake.
-#endif
-#if defined(ARDUINO_AVR_MEGA) || defined(ARDUINO_AVR_MEGA2560)
-    case 9:
-    case 10:
-      // Timer2 (is different)
-      TCCR2A = (TCCR2A & B11111100) | B00000011; // set WGM0=1 and WGM1=1 for fast PWM
-      TCCR2B = (TCCR2B & B11110000) | B00000001; // set WGM2=0 and prescaler div=1 (max)
-      DIAG(F("2 A=%x B=%x"), TCCR2A, TCCR2B);
-      break;
-    case 6:
-    case 7:
-    case 8:
-      // Timer4
-      TCCR4A = (TCCR4A & B11111100) | B00000001; // set WGM0=1 and WGM1=0 for fast PWM 8-bit
-      TCCR4B = (TCCR4B & B11100000) | B00001001; // set WGM2=1 and WGM3=0 for fast PWM 8 bit and div=1 (max)
-      break;
-    case 46:
-    case 45:
-    case 44:
-      // Timer5
-      TCCR5A = (TCCR5A & B11111100) | B00000001; // set WGM0=1 and WGM1=0 for fast PWM 8-bit
-      TCCR5B = (TCCR5B & B11100000) | B00001001; // set WGM2=1 and WGM3=0 for fast PWM 8 bit and div=1 (max)
-      break;
-#endif
-    default:
-      break;
-    }
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 7); // 7 means max
   }
   analogWrite(brakePin,duty);
 #endif
@@ -605,6 +576,10 @@ void MotorDriver::checkPowerOverload(bool useProgLimit, byte trackno) {
 	DIAG(F("TRACK %c ALERT FAULT"), trackno + 'A');
       }
       setPower(POWERMODE::ALERT);
+      if ((trackMode & TRACK_MODIFIER_AUTO) && (trackMode & (TRACK_MODE_MAIN|TRACK_MODE_EXT|TRACK_MODE_BOOST))){
+	DIAG(F("TRACK %c INVERT"), trackno + 'A');
+	invertOutput();
+      }
       break;
     }
     // all well
@@ -664,6 +639,10 @@ void MotorDriver::checkPowerOverload(bool useProgLimit, byte trackno) {
       }
       throttleInrush(false);
       setPower(POWERMODE::ON);
+      break;
+    }
+    if (goodtime > POWER_SAMPLE_ALERT_GOOD/2) {
+      throttleInrush(false);
     }
     break;
   }
@@ -676,8 +655,10 @@ void MotorDriver::checkPowerOverload(bool useProgLimit, byte trackno) {
       power_sample_overload_wait *= 2;
       if (power_sample_overload_wait > POWER_SAMPLE_RETRY_MAX)
 	      power_sample_overload_wait = POWER_SAMPLE_RETRY_MAX;
+  #ifdef EXRAIL_ACTIVE
       DIAG(F("Calling EXRAIL"));
       RMFT2::powerEvent(trackno, true); // Tell EXRAIL we have an overload
+  #endif
       // power on test
       DIAG(F("TRACK %c POWER RESTORE (after %4M)"), trackno + 'A', mslpc);
       setPower(POWERMODE::ALERT);

MotorDriver.h

@@ -1,9 +1,9 @@
 /*
- *  © 2022-2023 Paul M. Antoine
+ *  © 2022-2024 Paul M. Antoine
  *  © 2021 Mike S
  *  © 2021 Fred Decker
  *  © 2020 Chris Harlow
- *  © 2022 Harald Barth
+ *  © 2022,2023 Harald Barth
  *  All rights reserved.
  *  
  *  This file is part of CommandStation-EX
@@ -26,10 +26,33 @@
 #include "FSH.h"
 #include "IODevice.h"
 #include "DCCTimer.h"
+#include <wiring_private.h>
 
+#include "TemplateForEnums.h"
 // use powers of two so we can do logical and/or on the track modes in if clauses.
-enum TRACK_MODE : byte {TRACK_MODE_NONE = 1, TRACK_MODE_MAIN = 2, TRACK_MODE_PROG = 4,
-                        TRACK_MODE_DC = 8, TRACK_MODE_DCX = 16, TRACK_MODE_EXT = 32};
+// For example TRACK_MODE_DC_INV is (TRACK_MODE_DC|TRACK_MODIFIER_INV)
+enum TRACK_MODE : byte {
+  // main modes
+  TRACK_MODE_NONE = 1, TRACK_MODE_MAIN = 2, TRACK_MODE_PROG = 4,
+  TRACK_MODE_DC = 8, TRACK_MODE_EXT = 16,
+  // modifiers
+  TRACK_MODIFIER_INV = 64, TRACK_MODIFIER_AUTO = 128,
+#ifdef ARDUINO_ARCH_ESP32
+  TRACK_MODE_BOOST = 32,
+  TRACK_MODE_BOOST_INV = TRACK_MODE_BOOST|TRACK_MODIFIER_INV,
+  TRACK_MODE_BOOST_AUTO = TRACK_MODE_BOOST|TRACK_MODIFIER_AUTO,
+#else
+  TRACK_MODE_BOOST = 0,
+  TRACK_MODE_BOOST_INV = 0,
+  TRACK_MODE_BOOST_AUTO = 0,
+#endif
+  // derived modes; TRACK_ALL is calles that so it does not match TRACK_MODE_*
+  TRACK_ALL = TRACK_MODE_MAIN|TRACK_MODE_PROG|TRACK_MODE_DC|TRACK_MODE_EXT|TRACK_MODE_BOOST,
+  TRACK_MODE_MAIN_INV  =  TRACK_MODE_MAIN|TRACK_MODIFIER_INV,
+  TRACK_MODE_MAIN_AUTO =  TRACK_MODE_MAIN|TRACK_MODIFIER_AUTO,
+  TRACK_MODE_DC_INV =  TRACK_MODE_DC|TRACK_MODIFIER_INV,
+  TRACK_MODE_DCX = TRACK_MODE_DC_INV // DCX is other name for historical reasons
+};
 
 #define setHIGH(fastpin)  *fastpin.inout |= fastpin.maskHIGH
 #define setLOW(fastpin)   *fastpin.inout &= fastpin.maskLOW
@@ -70,6 +93,14 @@ enum TRACK_MODE : byte {TRACK_MODE_NONE = 1, TRACK_MODE_MAIN = 2, TRACK_MODE_PRO
 #define PORTF GPIOF->ODR
 #define HAVE_PORTF(X) X
 #endif
+#if defined(GPIOG)
+#define PORTG GPIOG->ODR
+#define HAVE_PORTG(X) X
+#endif
+#if defined(GPIOH)
+#define PORTH GPIOH->ODR
+#define HAVE_PORTH(X) X
+#endif
 #endif
 
 // if macros not defined as pass-through we define
@@ -93,6 +124,12 @@ enum TRACK_MODE : byte {TRACK_MODE_NONE = 1, TRACK_MODE_MAIN = 2, TRACK_MODE_PRO
 #ifndef HAVE_PORTF
 #define HAVE_PORTF(X) byte TOKENPASTE2(Unique_, __LINE__) __attribute__((unused)) =0
 #endif
+#ifndef HAVE_PORTG
+#define HAVE_PORTG(X) byte TOKENPASTE2(Unique_, __LINE__) __attribute__((unused)) =0
+#endif
+#ifndef HAVE_PORTH
+#define HAVE_PORTH(X) byte TOKENPASTE2(Unique_, __LINE__) __attribute__((unused)) =0
+#endif
 
 // Virtualised Motor shield 1-track hardware Interface
 
@@ -132,6 +169,8 @@ extern volatile portreg_t shadowPORTC;
 extern volatile portreg_t shadowPORTD;
 extern volatile portreg_t shadowPORTE;
 extern volatile portreg_t shadowPORTF;
+extern volatile portreg_t shadowPORTG;
+extern volatile portreg_t shadowPORTH;
 
 enum class POWERMODE : byte { OFF, ON, OVERLOAD, ALERT };
 
@@ -148,7 +187,11 @@ class MotorDriver {
     // otherwise the call from interrupt context can undo whatever we do
     // from outside interrupt
     void setBrake( bool on, bool interruptContext=false);
-  __attribute__((always_inline)) inline void setSignal( bool high) {
+    __attribute__((always_inline)) inline void setSignal( bool high) {
+#ifndef ARDUINO_ARCH_ESP32
+      if (invertPhase)
+	high = !high;
+#endif
       if (trackPWM) {
 	DCCTimer::setPWM(signalPin,high);
       }
@@ -168,15 +211,22 @@ class MotorDriver {
 	pinMode(signalPin, OUTPUT);
       else
 	pinMode(signalPin, INPUT);
+      if (signalPin2 != UNUSED_PIN) {
+	if (on)
+	  pinMode(signalPin2, OUTPUT);
+	else
+	  pinMode(signalPin2, INPUT);
+      }
     };
     inline pinpair getSignalPin() { return pinpair(signalPin,signalPin2); };
-    void setDCSignal(byte speedByte);
+    inline int8_t getBrakePinSigned() { return invertBrake ? -brakePin : brakePin; };
+    void setDCSignal(byte speedByte, uint8_t frequency=0);
     void throttleInrush(bool on);
     inline void detachDCSignal() {
 #if defined(__arm__)
       pinMode(brakePin, OUTPUT);
 #elif defined(ARDUINO_ARCH_ESP32)
-      ledcDetachPin(brakePin);
+      DCCTimer::DCCEXledcDetachPin(brakePin);
 #else
       setDCSignal(128);
 #endif
@@ -232,6 +282,32 @@ class MotorDriver {
 #endif
   inline void setMode(TRACK_MODE m) {
     trackMode = m;
+    invertOutput(trackMode & TRACK_MODIFIER_INV);
+  };
+  inline void invertOutput() {               // toggles output inversion
+    invertPhase = !invertPhase;
+    invertOutput(invertPhase);
+  };
+  inline void invertOutput(bool b) {         // sets output inverted or not
+    if (b)
+      invertPhase = 1;
+    else
+      invertPhase = 0;
+#if defined(ARDUINO_ARCH_ESP32)
+    pinpair p = getSignalPin();
+    uint32_t *outreg = (uint32_t *)(GPIO_FUNC0_OUT_SEL_CFG_REG + 4*p.pin);
+    if (invertPhase) // set or clear the invert bit in the gpio out register
+      *outreg |=  ((uint32_t)0x1 << GPIO_FUNC0_OUT_INV_SEL_S);
+    else
+      *outreg &= ~((uint32_t)0x1 << GPIO_FUNC0_OUT_INV_SEL_S);
+    if (p.invpin != UNUSED_PIN) {
+      outreg = (uint32_t *)(GPIO_FUNC0_OUT_SEL_CFG_REG + 4*p.invpin);
+      if (invertPhase) // clear or set the invert bit in the gpio out register
+	*outreg &= ~((uint32_t)0x1 << GPIO_FUNC0_OUT_INV_SEL_S);
+      else
+	*outreg |=  ((uint32_t)0x1 << GPIO_FUNC0_OUT_INV_SEL_S);
+    }
+#endif
   };
   inline TRACK_MODE getMode() {
     return trackMode;
@@ -263,7 +339,7 @@ class MotorDriver {
     bool invertBrake;       // brake pin passed as negative means pin is inverted
     bool invertPower;       // power pin passed as negative means pin is inverted
     bool invertFault;       // fault pin passed as negative means pin is inverted
-    
+    bool invertPhase = 0;   // phase of out pin is inverted
     // Raw to milliamp conversion factors avoiding float data types.
     // Milliamps=rawADCreading * sensefactorInternal / senseScale
     //

MotorDrivers.h

@@ -1,7 +1,7 @@
 /*
  *  © 2022-2023 Paul M. Antoine
  *  © 2021 Fred Decker
- *  © 2020-2023 Harald Barth
+ *  © 2020-2024 Harald Barth
  *  (c) 2020 Chris Harlow. All rights reserved.
  *  (c) 2021 Fred Decker.  All rights reserved.
  *  (c) 2020 Harald Barth. All rights reserved.
@@ -57,6 +57,10 @@
 // of the brake pin on the motor bridge is inverted
 // (HIGH == release brake)
 
+// You can have a CS wihout any possibility to do any track signal.
+// That's strange but possible.
+#define NO_SHIELD F("No shield at all")
+
 // Arduino STANDARD Motor Shield, used on different architectures:
 
 #if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_STM32)
@@ -71,11 +75,19 @@
 #define SAMD_STANDARD_MOTOR_SHIELD STANDARD_MOTOR_SHIELD
 #define STM32_STANDARD_MOTOR_SHIELD STANDARD_MOTOR_SHIELD
 
+#if defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F439ZI) || defined(ARDUINO_NUCLEO_F4X9ZI)
+// EX 8874 based shield connected to a 3V3 system with 12-bit (4096) ADC
+// The Ethernet capable STM32 models cannot use Channel B BRAKE on D8, and must use the ALT pin of D6,
+// AND cannot use Channel B PWN on D11, but must use the ALT pin of D5
+#define EX8874_SHIELD F("EX8874"), \
+ new MotorDriver( 3, 12, UNUSED_PIN, 9, A0, 1.27, 5000, A4), \
+ new MotorDriver( 5, 13, UNUSED_PIN, 6, A1, 1.27, 5000, A5)
+#else
 // EX 8874 based shield connected to a 3V3 system with 12-bit (4096) ADC
 #define EX8874_SHIELD F("EX8874"), \
  new MotorDriver( 3, 12, UNUSED_PIN, 9, A0, 1.27, 5000, A4), \
  new MotorDriver(11, 13, UNUSED_PIN, 8, A1, 1.27, 5000, A5)
-
+#endif
 
 #elif defined(ARDUINO_ARCH_ESP32)
 // STANDARD shield on an ESPDUINO-32 (ESP32 in Uno form factor). The shield must be eiter the
@@ -93,6 +105,18 @@
  new MotorDriver(25/* 3*/, 19/*12*/, UNUSED_PIN, 13/*9*/, 35/*A2*/, 1.27, 5000, 36 /*A4*/), \
  new MotorDriver(23/*11*/, 18/*13*/, UNUSED_PIN, 12/*8*/, 34/*A3*/, 1.27, 5000, 39 /*A5*/)
 
+// EX-CSB1 with integrated motor driver definition
+#define EXCSB1 F("EXCSB1"),\
+ new MotorDriver(25,  0, UNUSED_PIN, -14, 34, 2.23, 5000, 19), \
+ new MotorDriver(27, 15, UNUSED_PIN,  -2, 35, 2.23, 5000, 23)
+
+// EX-CSB1 with EX-8874 stacked on top for 4 outputs
+#define EXCSB1_WITH_EX8874 F("EXCSB1_WITH_EX8874"),\
+ new MotorDriver(25,  0, UNUSED_PIN, -14, 34, 2.23, 5000, 19), \
+ new MotorDriver(27, 15, UNUSED_PIN,  -2, 35, 2.23, 5000, 23), \
+ new MotorDriver(26,  5, UNUSED_PIN,  13, 36, 1.52, 5000, 18), \
+ new MotorDriver(16,  4, UNUSED_PIN,  12, 39, 1.52, 5000, 17)
+
 #else
 // STANDARD shield on any Arduino Uno or Mega compatible with the original specification.
 #define STANDARD_MOTOR_SHIELD F("STANDARD_MOTOR_SHIELD"),                                                 \

README.md

@@ -1,77 +1,39 @@
-# What is DCC++ EX?
-DCC++ EX is the organization maintaining several codebases that together represent a fully open source DCC system. Currently, this includes the following:
+# What is DCC-EX?
+DCC-EX is a team of dedicated enthusiasts producing open source DCC & DC solutions for you to run your complete model railroad layout. Our easy to use, do-it-yourself, and free open source products run on off-the-shelf Arduino technology and are supported by numerous third party hardware and apps like JMRI, Engine Driver, wiThrottle, Rocrail and more. 
 
-* [CommandStation-EX](https://github.com/DCC-EX/CommandStation-EX/releases) - the latest take on the DCC++ command station for controlling your trains. Runs on an Arduino board, and includes advanced features such as a WiThrottle server implementation, turnout operation, general purpose inputs and outputs (I/O), and JMRI integration.
-* [exWebThrottle](https://github.com/DCC-EX/exWebThrottle) - a simple web based controller for your DCC++ command station.
-* [BaseStation-installer](https://github.com/DCC-EX/BaseStation-Installer) - an installer executable that takes care of downloading and installing DCC++ firmware onto your hardware setup.
-* [BaseStation-Classic](https://github.com/DCC-EX/BaseStation-Classic) - the original DCC++ software, packaged in a stable release. No active development, bug fixes only.
+Currently, our products include the following:
 
-A basic DCC++ EX hardware setup can use easy to find, widely avalable Arduino boards that you can assemble yourself.
-
-Both CommandStation-EX and BaseStation-Classic support much of the NMRA Digital Command Control (DCC) [standards](http://www.nmra.org/dcc-working-group "NMRA DCC Working Group"), including:
-
-* simultaneous control of multiple locomotives
-* 2-byte and 4-byte locomotive addressing
-* 28 or 128-step speed throttling
-* Activate/de-activate all accessory function addresses 0-2048
-* Control of all cab functions F0-F28 and F29-F68
-* Main Track: Write configuration variable bytes and set/clear specific configuration variable (CV) bits (aka Programming on Main or POM)
-* Programming Track: Same as the main track with the addition of reading configuration variable bytes
-* And many more custom features. see [What's new in CommandStation-EX?](#whats-new-in-commandstation-ex)
+* [EX-CommandStation](https://github.com/DCC-EX/CommandStation-EX/releases)
+* [EX-WebThrottle](https://github.com/DCC-EX/exWebThrottle)
+* [EX-Installer](https://github.com/DCC-EX/EX-Installer)
+* [EX-MotoShield8874](https://dcc-ex.com/reference/hardware/motorboards/ex-motor-shield-8874.html#gsc.tab=0)
+* [EX-DCCInspector](https://github.com/DCC-EX/DCCInspector-EX)
+* [EX-Toolbox](https://github.com/DCC-EX/EX-Toolbox)
+* [EX-Turntable](https://github.com/DCC-EX/EX-Turntable)
+* [EX-IOExpander](https://github.com/DCC-EX/EX-IOExpander)
+* [EX-FastClock](https://github.com/DCC-EX/EX-FastClock)
+* [DCCEXProtocol](https://github.com/DCC-EX/DCCEXProtocol)
 
+Details of these projects can be found on [our web site](https://dcc-ex.com/).
 
 # What’s in this Repository?
 
-This repository, CommandStation-EX, contains a complete DCC++ EX Commmand Station sketch designed for compiling and uploading into an Arduino Uno, Mega, or Nano.
+This repository, CommandStation-EX, contains a complete DCC-EX *EX-CommmandStation* sketch designed for compiling and uploading into an Arduino Uno, Mega, or Nano.
 
 To utilize this sketch, you can use the following: 
 
-1. (beginner) our [automated installer](https://github.com/DCC-EX/BaseStation-Installer)
+1. (recommended for all levels of user) our [automated installer](https://github.com/DCC-EX/EX-Installer)
 2. (intermediate) download the latest version from the [releases page](https://github.com/DCC-EX/CommandStation-EX/releases)
 3. (advanced) use git clone on this repository 
 
-Not using the installer? Open the file "CommandStation-EX.ino" in the
-Arduino IDE. Please do not rename the folder containing the sketch
-code, nor add any files in that folder. The Arduino IDE relies on the
-structure and name of the folder to properly display and compile the
-code. Rename or copy config.example.h to config.h. If you do not have 
-the standard setup, you must edit config.h according to the help texts 
-in config.h.
+Refer to [our web site](https://https://dcc-ex.com/ex-commandstation/get-started/index.html#/) for the hardware required for this project.
 
-## What's new in CommandStation-EX?
+**We seriously recommend using the EX-Installer**, however if you choose not to use the installer... 
 
-* WiThrottle server built in. Connect Engine Driver or WiThrottle clients directly to your Command Station (or through JMRI as before)
-* WiFi and Ethernet shield support
-* No more jumpers or soldering!
-* Direct support for all the most popular motor control boards including single pin (Arduino) or dual pin (IBT_2) type PWM inputs without the need for an adapter circuit
-* I2C Display support (LCD and OLED)
-* Improved short circuit detection and automatic reset from an overload
-* Current reading, sensing and ACK detection settings in milliAmps instead of just pin readings
-* Improved adherence to the NMRA DCC specification
-* Complete support for all the old commands and front ends like JMRI
-* Railcom cutout (beta)
-* Simpler, modular, faster code with an API Library for developers for easy expansion
-* New features and functions in JMRI
-* Ability to join MAIN and PROG tracks into one MAIN track to run your locos
-* "Drive-Away" feature - Throttles with support, like Engine Driver, can allow a loco to be programmed on a usable, electrically isolated programming track and then drive off onto the main track
-* Diagnostic commands to test decoders that aren't reading or writing correctly
-* Support for Uno, Nano, Mega, Nano Every and Teensy microcontrollers
-* User Functions: Filter regular commands (like a turnout or output command) and pass it to your own function or accessory
-* Support for LCN (layout control nodes)
-* mySetup.h file that acts like an Autoexec.Bat command to send startup commands to the CS
-* High Accuracty Waveform option for rock steady DCC signals
-* New current response outputs current in mA, overlimit current, and maximum board capable current. Support for new current meter in JMRI
-* USB Browser based EX-WebThrottle
-* New, simpler, function control command
-* Number of locos discovery command `<#>`
-* Emergency stop command <!>
-* Release cabs from memory command <-> all cabs, <- CAB> for just one loco address
-* Automatic slot (register) management 
-* Automation (coming soon)
-
-NOTE: DCC-EX is a major rewrite to the code. We started over and rebuilt it from the ground up! For what that means, you can read [HERE](https://dcc-ex.com/about/rewrite.html).
+* Open the file ``CommandStation-EX.ino`` in the Arduino IDE or Visual Studio Code (VSC). Please do not rename the folder containing the sketch code, nor add any files in that folder. The Arduino IDE relies on the structure and name of the folder to properly display and compile the code. 
+* Rename or copy ``config.example.h`` to ``config.h``. 
+* You must edit ``config.h`` according to the help texts in ``config.h``.
 
 # More information
-You can learn more at the [DCC++ EX website](https://dcc-ex.com/)
+You can learn more at the [DCC-EX website](https://dcc-ex.com/)
 
-- November 14, 2020

Railcom.cpp

@@ -0,0 +1,82 @@
+/*
+ *  © 2025 Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of DCC-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "Railcom.h"
+#include "DCC.h"
+#include "DCCWaveform.h"
+
+uint16_t Railcom::expectLoco=0;
+uint16_t Railcom::expectCV=0;
+unsigned long Railcom::expectWait=0;
+ACK_CALLBACK Railcom::expectCallback=0;
+
+// 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;
+    expectCV=cv;
+    expectWait=millis(); // start of timeout 
+    expectCallback=callback;
+}
+
+// process is called to handle data buffer sent by collector
+void Railcom::process(int16_t firstVpin,byte * buffer, byte length) { 
+    //  block,locohi,locolow
+    //  block|0x80,data pom read cv
+    byte i=0; 
+    while (i<length) {
+        byte block=buffer[i] & 0x3f;
+        byte type=buffer[i]>>6;
+
+        switch (type) {
+            // a type=0 record has block,locohi,locolow
+            case 0: {
+                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);
+                i+=3;
+            }
+            break;
+       case 2: { // 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);
+          return;
+        }
+      }
+    }
+
+
+// loop() is called to detect timeouts waiting for a POM read result
+void Railcom::loop() {
+    if (expectCV && (millis()-expectWait)> POM_READ_TIMEOUT) { // still waiting 
+                expectCallback(-1);
+                expectCV=0;
+    }
+}

Railcom.h

@@ -0,0 +1,40 @@
+/*
+ *  © 202 5Chris Harlow
+ *  All rights reserved.
+ *  
+ *  This file is part of DCC-EX
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef Railcom_h
+#define Railcom_h
+#include "Arduino.h"
+
+typedef void (*ACK_CALLBACK)(int16_t result);
+
+class Railcom {
+  public:
+    static void anticipate(uint16_t loco, uint16_t cv, ACK_CALLBACK callback);
+    static void process(int16_t firstVpin,byte * buffer, byte length );
+    static void loop();
+  private:
+    static const unsigned long POM_READ_TIMEOUT=500; // as per spec
+    static uint16_t expectCV,expectLoco;
+    static unsigned long expectWait;
+    static ACK_CALLBACK expectCallback;
+    static const byte MAX_WAIT_FOR_GLITCH=20; // number of dead or empty packets before assuming loco=0 
+};
+
+#endif

Release_Notes/Exrail mods.txt

@@ -0,0 +1,119 @@
+// 5.2.49 
+
+Which is a more efficient than the AT/AFTER/IF methods 
+of handling buttons and switches, especially on MIMIC panels. 
+
+ONBUTTON(vpin) 
+  handles debounce and starts a task if a button is used to 
+  short a pin to ground. 
+
+  for example:
+     ONBUTTON(30) TOGGLE_TURNOUT(30) DONE
+
+ONSENSOR(vpin) 
+   handles debounce and starts a task if the pin changes.
+   You may want to check the pin state with an IF ...
+
+Note the ONBUTTON and ONSENSOR are not generally useful 
+for track sensors and running trains, because you dont know which
+train triggered the sensor.  
+
+// 5.2.47
+
+BLINK(vpin, onMs,offMs)
+
+which will start a vpin blinking until such time as it is SET, RESET or set by a signal operation such as RED, AMBER, GREEN. 
+
+BLINK returns immediately, the blinking is autonomous. 
+
+This means a signal that always blinks amber could be done like this:
+
+SIGNAL(30,31,32)
+ONAMBER(30) BLINK(31,500,500) DONE
+
+The RED or GREEN calls will turn off the amber blink automatically.
+
+Alternatively a signal that has normal AMBER and flashing AMBER could be like this:
+
+#define FLASHAMBER(signal) \
+                AMBER(signal) \
+                BLINK(signal+1,500,500)
+  
+  (Caution: this assumes that the amber pin is redpin+1)
+
+  ==
+
+  FTOGGLE(function)
+   Toggles the current loco function (see FON and FOFF)
+
+  XFTOGGLE(loco,function)
+     Toggles the function on given loco. (See XFON, XFOFF)
+
+  TOGGLE_TURNOUT(id) 
+      Toggles the turnout (see CLOSE, THROW)
+
+  STEALTH_GLOBAL(code) 
+      ADVANCED C++ users only.
+      Inserts code such as static variables and functions that
+      may be utilised by multiple STEALTH operations.
+
+
+// 5.2.34 - <A address aspect> Command fopr DCC Extended Accessories.
+This command sends an extended accessory packet to the track, Normally used to set
+a signal aspect. Aspect numbers are undefined as sdtandards except for 0 which is
+always considered a stop.
+
+//        - Exrail ASPECT(address,aspect) for above.
+     The ASPECT command sents an aspect to a DCC accessory using the same logic as 
+     <A aspect address>.
+     
+//        - EXRAIL DCCX_SIGNAL(Address,redAspect,amberAspect,greenAspect)
+      This defines a signal (with id same as dcc address) that can be operated
+      by the RED/AMBER/GREEN commands.   In each case the command uses the signal
+      address to refer to the signal and the aspect chosen depends on the use of the RED
+      AMBER or GREEN command sent. Other aspects may be sent but will require the
+      direct use of the ASPECT command.
+      The IFRED/IFAMBER/IFGREEN  and ONRED/ONAMBER/ONGREEN commands contunue to operate
+      as for any other signal type. It is important to be aware that use of the ASPECT
+      or <A> commands will correctly set the IF flags and call the ON handlers if ASPECT
+      is used to set one of the three aspects defined in the DCCX_SIGNAL command. 
+      Direct use of other aspects does not affect the signal flags.
+      ASPECT and <A> can be used withput defining any signal if tyhe flag management or
+      ON event handlers are not required.    
+
+// 5.2.33 - Exrail CONFIGURE_SERVO(vpin,pos1,pos2,profile)
+   This macro offsers a more convenient way of performing the HAL call in halSetup.h
+    In halSetup.h --- IODevice::configureServo(101,300,400,PCA9685::slow);
+    In myAutomation.h --- CONFIGURE_SERVO(101,300,400,slow)
+
+// 5.2.32 - Railcom Cutout (Initial trial Mega2560 only)
+    This cutout will only work on a Mega2560 with a single EX8874 motor shield
+    configured in the normal way with the main track brake pin on pin 9.
+    <C RAILCOM ON>    Turns on the cutout mechanism.
+    <C RAILCOM OFF>   Tirns off the cutout. (This is the default)
+    <C RAILCOM DEBUG> ONLY to be used by developers used for waveform diagnostics.
+       (In DEBUG mode the main track idle packets are replaced with reset packets, This
+       makes it far easier to see the preambles and cutouts on a logic analyser or scope.)
+
+// 5.2.31 - Exrail JMRI_SENSOR(vpin [,count]) creates <S> types.
+       This Macro causes the creation of JMRI <S> type sensors in a way that is 
+       simpler than repeating lines of <S> commands.
+         JMRI_SENSOR(100)   is equenvelant to <S 100 100 1>
+         JMRI_SENSOR(100,16) will create <S> type sensors for vpins 100-115.
+
+// 5.2.26 - Silently ignore overridden HAL defaults
+//        - include HAL_IGNORE_DEFAULTS macro in EXRAIL
+            The HAL_IGNORE_DEFAULTS command, anywhere in myAutomation.h will 
+            prevent the startup code from trying the default I2C sensors/servos.  
+// 5.2.24 - Exrail macro asserts to catch 
+//            : duplicate/missing automation/route/sequence/call ids
+//            : latches and reserves out of range
+//            : speeds out of range
+            Causes compiler time messages for EXRAIL issues that would normally
+            only be discovered by things going wrong at run time. 
+// 5.2.13 - EXRAIL STEALTH
+            Permits a certain level of C++ code to be embedded as a single step in
+            an exrail sequence. Serious engineers only.
+
+// 5.2.9  - EXRAIL STASH feature 
+//        - Added ROUTE_DISABLED macro in EXRAIL

Release_Notes/IO_Bitmap.md

@@ -0,0 +1,58 @@
+Virtual Bitmap device pins.
+
+a Bitmap device pin is a software representation of a virtual hardware device that has the ability to store a 16bit value.
+
+This this is easier to manage than LATCH in EXRAIL as they can be explicitely set and tested without interfering with underlying hardware or breaching the 255 limit.
+
+Virtual pins may be set, reset and tested in the same way as any other pin. Unlike sensors and leds, these device pins are both INPUT and OUTPUT  These can be used in many ways:
+
+  As a simple digital flag to assist in inter-thread communication.
+  A flag or value that can be set from commands and tested in EXRAIL.(e.g. to stop a sequence)
+  As a counter for looping or occupancy counts such as trains passing over a multi track road crossing.
+  As a collection of 16 digital bits that can be set, reset, toggled, masked and tested.
+  
+  Existing <> and exrail commands for vpins work on these pins.  
+
+  Virtual pin creation:
+    HAL(Bitmap,firstpin,npins) 
+       creates 1 or more virtual pins in software. (RAM requirement approximately 2 bytes per pin)
+       e.g. HAL(Bitmap,1000,20)  creates pins 1000..1019
+
+  Simple use as flags:
+    This uses the traditional digital pin commands
+       SET(1013) RESET(1013)  sets value 1 or 0
+       SET(1000,20) RESET(1000,20)  sets/resets a range of pins  
+       IF(1000) tests if pin value!=0
+
+       Commands can set 1/0 values using <z 1010> <z -1010> as for any digital output.
+       BLINK can be used to set them on/off on a time pattern. 
+
+       In addition, Exrail sensor comands work as if these pins were sensors
+          ONBUTTON(1013) triggers when value changes from 0 to something.
+          ONSENSOR(1013) triggers when value changes to or from 0.
+          <S 1013 1013 1> and JMRI_SENSOR(1013) report <Q/q responses when changing to or from 0.
+
+    Use as analog values:
+          Analog values may be set into the virtual pins and tested using the existing analog value commands and exrail macros.
+          <z vpin value>  <D ANIN vpin> etc.
+
+    Use as counters:
+        For loop counting, counters can be incremented by BITMAP_INC(1013) and decremented by BITMAP_DEC(1013) and tested with IF/IFNOT/IFGTE etc.
+        Counters be used to automate a multi track crossing where each train entering increments the counter and decrements it on clearing the crossing. Crossing gate automation can be started when the value changes from 0, and be stopped when the counter returns to 0.  Detecting the first increment from 0 to 1 can be done with ONBUTTON(1013) and the automation can use IF(1013) or IFNOT(1013) to detect when it needs to reopen the road gates. 
+
+Use as binary flag groups: 
+    Virtual pins (and others that respond to an analog read in order to provide bitmapped digital data, such as SensorCam) can be set and tested with new special EXRAIL commands
+
+    IFBITMAP_ALL(vpin,mask)   Bitwise ANDs the  the vpin value with the mask value and is true if ALL the 1 bits in the mask are also 1 bits in the value. 
+    e.g.    IFBITMAP_ALL(1013,0x0f)  would be true if ALL the last 4 bits of the value are 1s.
+ 
+    IFBITMAP_ANY(1013,0x0f) would be true if ANY of the last 4 bits are 1s.
+
+
+     Modifying bitmap values:
+      BITMAP_AND(vpin,mask) performs a bitwise AND operation.
+      BITMAP_OR(vpin,mask)  performa a bitwise OR operation
+      BITMAP_XOR(vpin,mask) performs a bitwise EXCLUSIVE OR (which is basically a toggle)   
+
+
+                      

Release_Notes/NeoPixel.md

@@ -0,0 +1,77 @@
+NeoPixel support
+
+The IO_NeoPixel.h driver supports the adafruit neopixel seesaw board. It turns each pixel into an individual VPIN which can be given a colour and turned on or off using the new <o> command or the NEOPIXEL Exrail macro. Exrail SIGNALS can also drive a single pixel signal or multiple separate pixels.
+
+
+1.  Defining the hardware driver:
+    Add a driver definition in myAutomation.h for each adafruit I2C driver.
+
+    HAL(neoPixel, firstVpin, numberOfPixels [, mode [, i2caddress])
+      Where mode is selected from the various pixel string types which have varying
+      colour order or refresh frequency. For MOST strings this mode will be NEO_GRB but for others refer to the comments in IO_NeoPixel.h
+      If omitted the node and i2caddress default to NEO_GRB, 0x60.
+
+    HAL(NeoPixel,1000,20)
+       This is a NeoPixel driver defaulting to I2C aqddress 0x60 for a GRB pixel string. Pixels are given vpin numbers from 1000 to 1019. 
+    HAL(NeoPixel,1020,20,NEO_GRB,0x61)
+       This is a NeoPixel driver on i2c address 0x61    
+
+2. Setting pixels from the < > commands.
+    By default, each pixel in the string is created as white but switched off.
+    Each pixel has a vpin starting from the first vpin in the HAL definitions.
+
+    <o vpin>   switches pixel on  (same as <z vpin>) e.g. <o 1005>
+    <o -vpin> switches pixel off (same as <z -vpin>) e.g. <o -1003>
+    (the z commands work on pixels the same as other gpio pins.)
+
+    <o [-]vpin count> switches on/off count pixels starting at vpin. e.g <o 1000 5>
+    Note: it IS acceptable to switch across 2 strings of pixels if they are contiguous vpin ranges.  It is also interesting that this command doesnt care if the vpins are NeoPixel or any other type, so it can be used to switch a range of other pin types. 
+
+    <o [-]vpin red green blue [count]> sets the colour and on/off status of a pin or pins. Each colour is 0..255 e.g. <o 1005 255 255 0>  sets pin 1005 to bright yellow and ON, <0 -1006 0 0 255 10>  sets pins 1006 to 1015 (10 pins) to bright blue but OFF.     
+    Note: If you set a pin to a colour, you can turn it on and off without having to reset the colour every time. This is something the adafruit seesaw library can't do and is just one of several reasons why we dont use it.  
+
+3. Setting pixels from EXRAIL
+    The new NEOPIXEL macro provides the same functionality as the    <o [-]vpin red green blue [count]> command above. 
+    NEOPIXEL([-]vpin, red, green, blue [,count])
+    
+    Setting pixels on or off (without colour change) can be done with SET/RESET [currently there is no set range facility but that may be added as a general exrail thing... watch this space]
+
+    Because the pixels obey set/reset, the BLINK command can also be used to control blinking a pixel.
+
+4. EXRAIL pixel signals.
+    There are two types possible, a mast with separate fixed colour pixels for each aspect, or a mast with one multiple colour pixel for all aspects.
+
+    For separate pixels, the colours should be established at startup and a normal SIGNALH macro used.
+    
+  AUTOSTART 
+    SIGNALH(1010,1011,1012)
+    NEOPIXEL(1010,255,0,0)       
+    NEOPIXEL(1011,128,128,0)
+    NEOPIXEL(1012,0,255,0)
+    RED(1010)  // force signal state otherwise all 3 lights will be on
+    DONE 
+
+    For signals with 1 pixel, the NEOPIXEL_SIGNAL macro will create a signal 
+    NEOPIXEL_SIGNAL(vpin,redfx,amberfx,greenfx)
+
+    ** Changed... ****
+    The fx values above can be created by the NeoRGB macro so a bright red would be NeoRGB(255,0,0)  bright green NeoRGB(0,255,0) and amber something like NeoRGB(255,100,0)
+    NeoRGB creates a single int32_t value so it can be used in several ways as convenient.
+
+// create 1-lamp signal with NeoRGB colours
+NEOPIXEL_SIGNAL(1000,NeoRGB(255,0,0),NeoRGB(255,100,0),NeoRGB(0,255,0))
+
+// Create 1-lamp signal with named colours.
+// This is better if you have multiple signals.
+// (Note: ALIAS is not suitable due to word length defaults) 
+#define REDLAMP NeoRGB(255,0,0)
+#define AMBERLAMP NeoRGB(255,100,0)
+#define GREENLAMP NeoRGB(0,255,0)
+NEOPIXEL_SIGNAL(1001,REDLAMP,AMBERLAMP,GREENLAMP)
+
+// Create 1-lamp signal with web type RGB colours 
+// (Using blue for the amber  signal , just testing) 
+NEOPIXEL_SIGNAL(1002,0xFF0000,0x0000FF,0x00FF00)
+
+      
+  

Release_Notes/Railcom.md

@@ -0,0 +1,71 @@
+Railcom implementation notes, Chris Harlow Oct 2024
+
+Railcom support is in 3 parts
+1. Generation of the DCC waveform with a Railcom cutout.
+2. Accessing the railcom feedback from a loco using hardware detectors
+3. Utilising the feedback to do something useful.
+
+DCC Waveform Railcom cutout depends on using suitable motor shields (EX8874 primarily) as the standard Arduino shield is not suitable. (Too high resistance during cutout)
+The choice of track management also depends on wiring all the MAIN tracks to use the same signal and brake pins. This allows separate track power management but prevents switching a single track from MAIN to PROG or DC... 
+Some CPUs require very specific choice of brake pins etc to match their internal timer register architecture.
+
+- MEGA.. The default shield setting for an EX8874 is suitable for Railcom on Channel A (MAIN) 
+- ESP32 .. not yet supported.
+- Nucleo ... TBA 
+
+Enabling the Railcom Cutout requires a `<C RAILCOM ON>` command. This can be added to myAutomation using `PARSE("<C RAILCOM ON>")`
+Code to calculate the cutout position and provide synchronization for the sampling is in `DCCWaveform.cpp` (not ESP32)
+and in general a global search for "railcom" will show all code changes that have been made to support this.
+
+Code to actually implement the timing of the cutout is highly cpu dependent and can be found in the various implementations of `DCCTimer.h`. At this time only `DCCTimerAVR.cpp`has implemented this.  
+
+
+Reading Railcom data:
+  A new HAL handler (`IO_I2CRailcom.h`) has been added to process input from a 32-block railcom collecter which operates over I2C. The collector and its readers  sit between the CS and the track and collect railcom data from locos during the cutout.
+  The Collector device removes 99.9% of the railcom traffic and returns just a summary of what has changed since the last cutout.
+  After the cutout the HAL driver reads the Collector summary over I2C and passes the raw data to the CS logic (`Railcom.cpp`) for analysis.
+
+  Each 32-block reader is described in myAutomation like `HAL(I2CRailcom,10000,32,0x08)`  which will assign 32 blocks on i2c address 0x08 with vpin numbers 10000 and 10031. If you only use fewer channel in the collector, you can assign fewer pins here.
+  (Implementation notes.. you may have multiple collectors, each one will requite a HAL line to define its i2c address and vpins to represent block numbers.)
+
+Making use of Railcom data
+
+ Exrail has two additional event handlers which can capture locos entering and exiting blocks. These handlers are started with the loco information already set, so for example:
+ ```
+ ONBLOCKENTER(10000) 
+    // a loco has entered block 10000 
+    FON(0)  // turn the light on
+    FON(1)  // make a lot of noise
+    SPEED(20) // slow down
+    DONE 
+ 
+ ONBLOCKEXIT(10000) 
+    // a loco has left block 10000 
+    FOFF(0)  // turn the light off
+    FOFF(1)  // stop the noise
+    SPEED(50) // speed up again
+    DONE 
+    ```
+
+    Note that the Railcom interpretation code is capable of detecting multiple locos in the same block at the same time and will create separate exrail tasks for each one.
+     There is however one minor loophole in the block exit logic...
+      If THREE or more locos are in the same block and ONE of them leaves, then ONBLOCKEXIT will not fire until 
+      EITHER - The leaving loco enters another railcom block
+      OR     - only ONE loco remains in the block just left.
+
+      To further support block management in railcom, two additional serial commands are available
+
+      `<K block loco >` to simulate a loco entering a block, and trigger any ONBLOCKENTER
+      `<k block loco >` to simulate a loco leaving a block, and trigger and ONBLOCKEXIT
+
+
+   Reading CV values on MAIN.
+
+      Railcom allows for the facility to read loco cv values while on the main track. This is considerably faster than PROG track access but depends on the loco being in a Railcom monitored block. 
+
+      To read from PROG Track we use `<R cv>` response is `<r value>` 
+
+      To read from MAIN track use `<r loco cv>`
+        response is `<r loco cv value>`  
+
+     

Release_Notes/Stash.md

@@ -0,0 +1,21 @@
+# The STASH feature of exrail.
+
+STASH is used for scenarios where it is helpful to relate a loco id to where it is parked. For example a fiddle yard may have 10 tracks and it's much easier for the operator to select a train to depart by using the track number, or pressing a button relating to that track, rather than by knowing the loco id which may be difficult to see.
+
+Automated yard parking can use the stash to determine which tracks are empty without the need for block occupancy detectors.
+
+Note that a negative locoid may be stashed to indicate that the loco will operate with inverted direction. For example a loco facing backwards, with the INVERT_DRECTION state may be stashed by exrail and the invert state will be restored along with the loco id when using the PICKUP_STASH.  CLEAR_ANY_STASH will clear all references to the loco regardless of direction. 
+
+The following Stash  commands are available:
+ | EXRAIL command | Serial protocol | function |
+ | -------------- | --------------- | -------- | 
+ | STASH(s) | `<JM s locoid>` | Save the current loco id in the stash array element s. |
+ | CLEAR_STASH(s) | `<JM s 0>` | Sets stash array element s to zero. |  
+ | CLEAR_ALL_STASH | `<JM CLEAR ALL>` | sets all stash entries to zero |
+ | CLEAR_ANY_STASH | `<JM CLEAR ANY locoid>` | removes current loco from all stash elements | 
+ | PICKUP_STASH(s) | N/A | sets current loco to stash element s |
+ | IFSTASH(s)  | N/A | True if stash element s is not zero |
+ | N/A | `<JM>`  | query all stashes (returns `<jM s loco>` where loco is not zero)
+ | N/A | `<JM stash>` | Query loco in stash (returns `<jM s loco>`)  
+
+

Release_Notes/TCA8418.md

@@ -0,0 +1,44 @@
+## TCA8418 ##
+
+The TCA8418 IC from Texas Instruments is a low cost and very capable GPIO and keyboard scanner. Used as a keyboard scanner, it has 8 rows of 10 columns of IO pins which allow encoding of up to 80 buttons. The IC is available on an Adafruit board with Qwiic I2C interconnect called the "Adafruit TCA8418 Keypad Matrix and GPIO Expander Breakout" and available here for the modest sum of $US6 or so: https://www.adafruit.com/product/4918
+
+The great advantage of this IC is that the keyboard scanning is done continuously, and it has a 10-element event queue, so even if you don't get to the interrupt immediately, keypress and release events will be held for you. Since it's I2C its very easy to use with any DCC-EX command station.
+
+The TCA8418 driver presently configures the IC in the full 8x10 keyboard scanning mode, and then maps each key down/key up event to the state of a single vpin for extremely easy use from within EX-RAIL and JMRI as each key looks like an individual sensor.
+
+This is ideal for mimic panels where you may need a lot of buttons, but with this board you can use just 18 wires to handle as many as 80 buttons.
+
+By adding a simple HAL statement to myAutomation.h it creates between 1 and 80 buttons it will report back.
+
+`HAL(TCA8418, firstVpin, numPins, I2CAddress, interruptPin)`
+
+For example:
+
+`HAL(TCA8418, 300, 80, 0x34)`
+
+Creates VPINs 300-379 which you can monitor with EX-RAIL, JMRI sensors etc.
+
+With an 8x10 key event matrix, the events are numbered using the Rn row pins and Cn column pins as such:
+
+     C0  C1  C2  C3  C4  C5  C6  C7  C8  C9
+    ========================================
+ R0|  0   1   2   3   4   5   6   7   8   9
+ R1| 10  11  12  13  14  15  16  17  18  19
+ R2| 20  21  22  23  24  25  26  27  28  29
+ R3| 30  31  32  33  34  35  36  37  38  39
+ R4| 40  41  42  43  44  45  46  47  48  49
+ R5| 50  51  52  53  54  55  56  57  58  59
+ R6| 60  61  62  63  64  65  66  67  68  69
+ R7| 70  71  72  73  74  75  76  77  78  79
+
+So if you start with the first pin definition being VPIN 300, R0/C0 will be 300 + 0, and R7/C9 will be 300+79 or 379.
+
+Use something like this on a multiplexor, and with up to 8 of the 8-way multiplexors you could have 64 different TCA8418 boards:
+
+`HAL(TCA8418, 400, 80, {SubBus_1, 0x34})`
+
+And if needing an Interrupt pin to speed up operations:
+`HAL(TCA8418, 300, 80, 0x34, 21)`
+
+Note that using an interrupt pin speeds up button press acquisition considerably (less than a millisecond vs 10-100), but even with interrupts enabled the code presently checks every 100ms in case the interrupt pin becomes disconnected. Use any available Arduino pin for interrupt monitoring.
+

Release_Notes/TM1638.md

@@ -0,0 +1,84 @@
+## TM1638 ##
+
+The TM1638 board provides a very cheap way of implementing 8 buttons, 8 leds and an 8 digit 7segment display in a package requiring just 5 Dupont wires (vcc, gnd + 3 GPIO pins) from the command station without soldering.
+
+
+This is ideal for prototyping and testing, simulating sensors and signals, displaying states etc. For a built layout, this could provide a control for things that are not particularly suited to throttle 'route' buttons, perhaps lineside automations or fiddle yard lane selection.  
+
+By adding a simple HAL statement to myAutomation.h it creates 8 buttons/sensors and 8 leds.
+
+`HAL(TM1638,500,29,31,33)`
+Creates VPINs 500-507 And desscribes the GPIO pins used to connect the clk,dio,stb pins on the TM1638 board. 
+
+Setting each of the VPINs will control the associated LED (using for example SET, RESET or BLINK in Exrail or `<z 500> <z -501>  from a command).
+
+Unlike most pins, you can also read the same pin number and get the button state, using Exrail IF/AT/ONBUTTON etc.
+
+For example:
+`
+HAL(TM1638,500,29,31,33)
+`
+All the folowing examples assume you are using VPIN 500 as the first, leftmost,  led/button on the TM1638 board.
+
+ 
+`ONBUTTON(500) 
+  SET(500)     // light the first led
+  BLINK(501,500,500) // blink the second led
+  SETLOCO(3) FWD(50) // set a loco going   
+  AT(501) STOP // press second button to stop
+  RESET(500) RESET(501)  // turn leds off
+  DONE
+`
+
+Buttons behave like any other sensor, so using `<S 500 500 1>`  will cause the command station to issue `<Q 500>` and `<q 500>` messages when the first button is pressed or released.
+
+Exrail `JMRI_SENSOR(500,8)` will create `<S` commands for all 8 buttons.  
+
+## Using the 7 Segment display ##
+
+The 8 digit display can be treated as 8 separate digits (left most being the same VPIN as the leftmost button and led) or be written to in sections of any length. Writing uses the existing analogue interface to the common HAL but is awkward to use directly.  To make this easier from Exrail, a SEG7 macro provides a remapping to the ANOUT facility that makes more sense. 
+
+SEG7(vpin,value,format)
+
+The vpin determins which digit to start writing at. 
+The value can be a 32bit unsigned integer but is interpreted differentlky according to the format.
+
+Format values:
+ 1..8  give the length (number of display digits) to fill, and defaults to decimal number with leading zeros.
+
+ 1X..8X give the length but display in hex.
+
+ 1R..4R treats each byte of the value as raw 7-segment patterns so that it can write letters and symbols using any compination of the 7segments and deciml point.
+
+ There is a useful description here:
+ https://jetpackacademy.com/wp-content/uploads/2018/06/TM1638_cheat_sheet_download.pdf
+
+
+ e.g.  SEG7(500,3,4)
+        writes 0003 to first 4 digits of the display
+       SEG7(504,0xcafe,4X)
+        writes CAFE to the last 4 digits
+       SEG7(500,0xdeadbeef,8X) 
+        writes dEAdbEEF to all 8 digits. 
+
+    Writing raw segment patters requires knowledge of the bit pattern to segment relationship:
+`      0
+    == 0 ==
+   5|     | 1
+    == 6 ==
+  4 |     | 2
+    == 3 ==  
+            7=decimal point
+
+            Thus Letter A is segments  6 5 4 2 1 0, in bits  that is (0 bit on right)          
+               0b01110111  or 0x77
+    This is not easy to do my hand and thus a new string type suffix has been introduced to make simple text messages. Note that the HAL interface only has width for 32 bits which is only 4 symbols so writing 8 digits requires two calls.
+
+    e.g.  SEG7(500,"Hell"_s7,4R) SEG7(504,"o"_s7,4R)
+          DELAY(1000)
+          SEG7(500,"Worl"_s7,4R) SEG7(504,"d"_s7,4R)
+
+    Note that some letters like k,m,v,x do not have particularly readable 7-segment representations. 
+                     
+    Credit to https://github.com/dvarrel/TM1638 for the basic formulae.
+

Release_Notes/momentum.md

@@ -0,0 +1,29 @@
+New Momentum feature notes:
+
+The command station can apply momentum to throttle movements in the same way that a standards compliant DCC decoder can be set to do. This momentum can be defaulted system wide and overridden on individual locos. It does not use or alter the loco CV values and so it also works when driving DC locos.
+The momentum is applied regardless of the throttle type used (or even EXRAIL). 
+
+Momentum is specified in mS / throttle_step.
+
+There is a new command `<m cabid accelerating [brake]>`
+where the brake value defaults to the accelerating value.
+
+For example: 
+`<m 3 0>`   sets loco 3 to no momentum.
+`<m 3 21>`   sets loco 3 to 21 mS/step.
+`<m 3 21 42>`   sets loco 3 to 21 mS/step accelerating and 42 mS/step when decelerating.
+
+`<m 0 21>`  sets the default momentum to 21mS/Step for all current and future locos that have not been specifically set.
+`<m 3 -1>`   sets loco 3 to track the default momentum value. 
+
+EXRAIL
+  A new macro `MOMENTUM(accel [, decel])` sets the momentum value of the current tasks loco ot the global default if loco=0. 
+
+Note: Setting Momentum 7,14,21 etc is similar in effect to setting a decoder CV03/CV04 to 1,2,3.   
+
+As an additional option, the momentum calculation is based on the 
+difference in throttle setting and actual speed. For example, the time taken to reach speed 50 from a standing start would be less if the throttle were set to speed 100, thus increasing the acceleration. 
+
+`<m LINEAR>` - acceleration is uniform up to selected throttle speed.
+`<m POWER>`  - acceleration depends on difference between loco speed and selected throttle speed.
+ 

Release_Notes/websocketTester.html

@@ -0,0 +1,41 @@
+<html>
+  <!-- Minimalist test page for the DCCEX websocket API.-->
+<head>
+  <script>
+  let socket = new WebSocket("ws://192.168.1.242:2560","DCCEX");
+  
+  // send message from the form
+  var sender = function() {
+    var msg=document.getElementById('message').value;
+    socket.send(msg);
+  }
+  // message received - show the message in div#messages
+  socket.onmessage = function(event) {
+    let message = event.data;
+  
+    let messageElem = document.createElement('div');
+    messageElem.textContent = message;
+    document.getElementById('messages').prepend(messageElem);
+  }
+  socket.onerror = function(event) {
+    let message = event.data;
+    let messageElem = document.createElement('div');
+    messageElem.textContent = message;
+    document.getElementById('messages').prepend(messageElem);
+  }
+  </script>
+</head>
+<body>
+  This is a minimalist test page for the DCCEX websocket API.
+   It demonstrates the Websocket connection and how to send
+   or receive websocket traffic.
+   The connection string must be edited to address your command station 
+   correctly.<p>
+<!-- message form -->
+
+  <input type="text" id="message">
+  <input type="button" value="Send" onclick="sender();">
+<!-- div with messages -->
+<div id="messages"></div>
+</body>
+</html>