Merge 2afb5f3d6c into 1af5132e6a

CommandDistributor.cpp

@@ -248,6 +248,11 @@ void  CommandDistributor::broadcastLoco(byte slot) {
 }
 
 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);
+
   bool main=TrackManager::getMainPower()==POWERMODE::ON;
   bool prog=TrackManager::getProgPower()==POWERMODE::ON;
   bool join=TrackManager::isJoined();
@@ -270,5 +275,13 @@ void CommandDistributor::broadcastRaw(clientType type, char * msg) {
 }
 
 void CommandDistributor::broadcastTrackState(const FSH* format,byte trackLetter, int16_t dcAddr) {
-  broadcastReply(COMMAND_TYPE, format,trackLetter, dcAddr);
+  broadcastReply(COMMAND_TYPE, format, trackLetter, 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);
 }

CommandDistributor.h

@@ -58,6 +58,9 @@ public :
   static void broadcastTrackState(const FSH* format,byte trackLetter, 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);
+
   
 };
 

DCCEXParser.cpp

@@ -553,131 +553,66 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
 
     case '1': // POWERON <1   [MAIN|PROG|JOIN]>
         {
-            bool main=false;
-            bool prog=false;
-            bool join=false;
-            bool singletrack=false;
-            //byte t=0;
 	  if (params > 1) break;
 	  if (params==0) { // All
-                main=true;
+	    TrackManager::setTrackPower(TRACK_MODE_ALL, POWERMODE::ON);
-                prog=true;
 	  }
 	  if (params==1) {
 	    if (p[0]==HASH_KEYWORD_MAIN) { // <1 MAIN>
-                        main=true;
+	      TrackManager::setTrackPower(TRACK_MODE_MAIN, POWERMODE::ON);
             }
 #ifndef DISABLE_PROG
             else if (p[0] == HASH_KEYWORD_JOIN) {  // <1 JOIN>
-                main=true;
+	      TrackManager::setJoin(true);
-                prog=true;
+	      TrackManager::setTrackPower(TRACK_MODE_MAIN|TRACK_MODE_PROG, POWERMODE::ON);
-                join=true;
             }
             else if (p[0]==HASH_KEYWORD_PROG) { // <1 PROG>
-                prog=true;
+	      TrackManager::setJoin(false);
+	      TrackManager::setTrackPower(TRACK_MODE_PROG, POWERMODE::ON);
             }
 #endif
-            //else if (p[0] >= 'A' && p[0] <= 'H') { // <1 A-H>
             else if (p[0] >= HASH_KEYWORD_A && p[0] <= HASH_KEYWORD_H) { // <1 A-H>
 	      byte t = (p[0] - 'A');
-                    //DIAG(F("Processing track - %d "), t);
+	      TrackManager::setTrackPower(POWERMODE::ON, t);
-                    if (TrackManager::isProg(t)) {
+	      //StringFormatter::send(stream, F("<p1 %c>\n"), t+'A');
-                        main = false;
-                        prog = true;
             }
-                    else
-                    {
-                        main=true;
-                        prog=false;
-                    }
-                singletrack=true;
-                if (main) TrackManager::setTrackPower(false, false, POWERMODE::ON, t);
-                if (prog) TrackManager::setTrackPower(true, false, POWERMODE::ON, t);
-                
-                StringFormatter::send(stream, F("<1 %c>\n"), t+'A');
-                //CommandDistributor::broadcastPower();
-                //TrackManager::streamTrackState(NULL,t);
-                return;
-            }
-
 	    else break; // will reply <X>
 	  }
-
-        if (!singletrack) {
-            TrackManager::setJoin(join);
-            if (join) TrackManager::setJoinPower(POWERMODE::ON);
-            else {
-                if (main) TrackManager::setMainPower(POWERMODE::ON);
-                if (prog) TrackManager::setProgPower(POWERMODE::ON);
-            }
 	  CommandDistributor::broadcastPower();
+	  //TrackManager::streamTrackState(NULL,t);
           
 	  return;
 	}
             
-        }
-
     case '0': // POWEROFF <0 [MAIN | PROG] >
         {
-            bool main=false;
-            bool prog=false;
-            bool singletrack=false;
-            //byte t=0;
 	  if (params > 1) break;
 	  if (params==0) { // All
-                main=true;
+	    TrackManager::setJoin(false);
-                prog=true;
+	    TrackManager::setTrackPower(TRACK_MODE_ALL, POWERMODE::OFF);
 	  }
 	  if (params==1) {
 	    if (p[0]==HASH_KEYWORD_MAIN) { // <0 MAIN>
-                    main=true;
+	      TrackManager::setJoin(false);
+	      TrackManager::setTrackPower(TRACK_MODE_MAIN, POWERMODE::OFF);
 	    }
 #ifndef DISABLE_PROG
             else if (p[0]==HASH_KEYWORD_PROG) { // <0 PROG>
-                prog=true;
+	      TrackManager::progTrackBoosted=false;  // Prog track boost mode will not outlive prog track off
+	      TrackManager::setTrackPower(TRACK_MODE_PROG, POWERMODE::OFF);
             }
 #endif
-            //else if (p[0] >= 'A' && p[0] <= 'H') { // <1 A-H>
 	    else if (p[0] >= HASH_KEYWORD_A && p[0] <= HASH_KEYWORD_H) { // <1 A-H>
 	      byte t = (p[0] - 'A');
-                //DIAG(F("Processing track - %d "), t);
-                if (TrackManager::isProg(t)) {
-                    main = false;
-                    prog = true;
-                }
-                else
-                {
-                    main=true;
-                    prog=false;
-                }
-                singletrack=true;  
 	      TrackManager::setJoin(false);
-                if (main) TrackManager::setTrackPower(false, false, POWERMODE::OFF, t);
+	      TrackManager::setTrackPower(POWERMODE::OFF, t);
-                if (prog) {
+	      //StringFormatter::send(stream, F("<p0 %c>\n"), t+'A');
-                    TrackManager::progTrackBoosted=false;  // Prog track boost mode will not outlive prog track off
-                    TrackManager::setTrackPower(true, false, POWERMODE::OFF, t);                 
 	    }
-                StringFormatter::send(stream, F("<0 %c>\n"), t+'A');
-                //CommandDistributor::broadcastPower();
-                //TrackManager::streamTrackState(NULL, t);
-                return;
-            }    
-
 	    else break; // will reply <X>
 	  }
-
-        if (!singletrack) {
-            TrackManager::setJoin(false);
-            
-            if (main) TrackManager::setMainPower(POWERMODE::OFF);
-            if (prog) {
-                    TrackManager::progTrackBoosted=false;  // Prog track boost mode will not outlive prog track off
-                    TrackManager::setProgPower(POWERMODE::OFF);
-                }
 	  CommandDistributor::broadcastPower();
 	  return;
 	}
-    }
 
     case '!': // ESTOP ALL  <!>
         DCC::setThrottle(0,1,1); // this broadcasts speed 1(estop) and sets all reminders to speed 1.
@@ -781,27 +716,11 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
                     TrackManager::reportCurrent(stream);   // <g limit...limit>     
                     return;
 
-                case HASH_KEYWORD_A: // <JA> returns automations/routes
+                case HASH_KEYWORD_A: // <JA> intercepted by EXRAIL// <JA> returns automations/routes
-                    StringFormatter::send(stream, F("<jA"));
+                    if (params!=1) break; // <JA>
-                    if (params==1) {// <JA>
+                    StringFormatter::send(stream, F("<jA>\n"));
-#ifdef EXRAIL_ACTIVE
-                        SENDFLASHLIST(stream,RMFT2::routeIdList)
-                        SENDFLASHLIST(stream,RMFT2::automationIdList)
-#endif
-                    }
-                    else {  // <JA id>
-                        StringFormatter::send(stream,F(" %d %c \"%S\""), 
-                                        id, 
-#ifdef EXRAIL_ACTIVE
-                                        RMFT2::getRouteType(id), // A/R
-                                        RMFT2::getRouteDescription(id)
-#else  
-                                        'X',F("")
-#endif                                        
-                                        );
-                    }
-                    StringFormatter::send(stream, F(">\n"));      
                     return;
+ 
             case HASH_KEYWORD_R: // <JR> returns rosters 
                 StringFormatter::send(stream, F("<jR"));
 #ifdef EXRAIL_ACTIVE
@@ -1121,7 +1040,6 @@ bool DCCEXParser::parseS(Print *stream, int16_t params, int16_t p[])
 bool DCCEXParser::parseC(Print *stream, int16_t params, int16_t p[]) {
     if (params == 0)
         return false;
-    bool onOff = (params > 0) && (p[1] == 1 || p[1] == HASH_KEYWORD_ON); // dont care if other stuff or missing... just means off
     switch (p[0])
     {
 #ifndef DISABLE_PROG
@@ -1159,6 +1077,8 @@ bool DCCEXParser::parseC(Print *stream, int16_t params, int16_t p[]) {
 	      LCD(0, F("Ack Retry=%d Sum=%d"), p[2], DCCACK::setAckRetry(p[2]));  //   <D ACK RETRY 2>
 	    }
 	} else {
+      bool onOff = (params > 0) && (p[1] == 1 || p[1] == HASH_KEYWORD_ON); // dont care if other stuff or missing... just means off
+    
 	  DIAG(F("Ack diag %S"), onOff ? F("on") : F("off"));
 	  Diag::ACK = onOff;
 	}

EXRAIL2.cpp

@@ -55,22 +55,6 @@
 #include "Turntables.h"
 #include "IODevice.h"
 
-// Command parsing keywords
-const int16_t HASH_KEYWORD_EXRAIL=15435;    
-const int16_t HASH_KEYWORD_ON = 2657;
-const int16_t HASH_KEYWORD_START=23232;
-const int16_t HASH_KEYWORD_RESERVE=11392;
-const int16_t HASH_KEYWORD_FREE=-23052;
-const int16_t HASH_KEYWORD_LATCH=1618;  
-const int16_t HASH_KEYWORD_UNLATCH=1353;
-const int16_t HASH_KEYWORD_PAUSE=-4142;
-const int16_t HASH_KEYWORD_RESUME=27609;
-const int16_t HASH_KEYWORD_KILL=5218;
-const int16_t HASH_KEYWORD_ALL=3457;
-const int16_t HASH_KEYWORD_ROUTES=-3702;
-const int16_t HASH_KEYWORD_RED=26099;
-const int16_t HASH_KEYWORD_AMBER=18713;
-const int16_t HASH_KEYWORD_GREEN=-31493;
 
 // One instance of RMFT clas is used for each "thread" in the automation.
 // Each thread manages a loco on a journey through the layout, and/or may manage a scenery automation.
@@ -86,7 +70,7 @@ RMFT2 * RMFT2::pausingTask=NULL; // Task causing a PAUSE.
  // and all others will have their locos stopped, then resumed after the pausing task resumes.
 byte RMFT2::flags[MAX_FLAGS];
 Print * RMFT2::LCCSerial=0;
-LookList *  RMFT2::sequenceLookup=NULL;
+LookList *  RMFT2::routeLookup=NULL;
 LookList *  RMFT2::onThrowLookup=NULL;
 LookList *  RMFT2::onCloseLookup=NULL;
 LookList *  RMFT2::onActivateLookup=NULL;
@@ -100,9 +84,8 @@ LookList *  RMFT2::onClockLookup=NULL;
 LookList *  RMFT2::onRotateLookup=NULL;
 #endif
 LookList *  RMFT2::onOverloadLookup=NULL;
-
+byte * RMFT2::routeStateArray=nullptr; 
-#define GET_OPCODE GETHIGHFLASH(RMFT2::RouteCode,progCounter)
+const FSH  * * RMFT2::routeCaptionArray=nullptr; 
-#define SKIPOP progCounter+=3
 
 // getOperand instance version, uses progCounter from instance.
 uint16_t RMFT2::getOperand(byte n) {
@@ -120,6 +103,7 @@ uint16_t RMFT2::getOperand(int progCounter,byte n) {
 LookList::LookList(int16_t size) {
   m_size=size;
   m_loaded=0;
+  m_chain=nullptr;
   if (size) {
     m_lookupArray=new int16_t[size];
     m_resultArray=new int16_t[size];
@@ -137,8 +121,35 @@ int16_t LookList::find(int16_t value) {
   for (int16_t i=0;i<m_size;i++) {
     if (m_lookupArray[i]==value) return m_resultArray[i];
   }
+  return m_chain ?  m_chain->find(value)  :-1;
+}
+void LookList::chain(LookList * chain) {
+  m_chain=chain;
+}
+void LookList::handleEvent(const FSH* reason,int16_t id) {
+  // New feature... create multiple ONhandlers
+  for (int i=0;i<m_size;i++) 
+    if (m_lookupArray[i]==id)
+       RMFT2::startNonRecursiveTask(reason,id,m_resultArray[i]);
+}
+
+
+void LookList::stream(Print * _stream) {
+  for (int16_t i=0;i<m_size;i++) {
+    _stream->print(" ");
+    _stream->print(m_lookupArray[i]);
+  }
+}
+
+int16_t LookList::findPosition(int16_t value) {
+  for (int16_t i=0;i<m_size;i++) {
+    if (m_lookupArray[i]==value) return i;
+  }
   return -1;
 }
+int16_t LookList::size() {
+   return m_size;
+}
 
 LookList* RMFT2::LookListLoader(OPCODE op1, OPCODE op2, OPCODE op3) {
   int progCounter;
@@ -171,7 +182,12 @@ LookList* RMFT2::LookListLoader(OPCODE op1, OPCODE op2, OPCODE op3) {
   for (int f=0;f<MAX_FLAGS;f++) flags[f]=0;
   
   // create lookups
-  sequenceLookup=LookListLoader(OPCODE_ROUTE, OPCODE_AUTOMATION,OPCODE_SEQUENCE);
+  routeLookup=LookListLoader(OPCODE_ROUTE, OPCODE_AUTOMATION);
+  routeLookup->chain(LookListLoader(OPCODE_SEQUENCE));
+  if (compileFeatures && FEATURE_ROUTESTATE) {
+    routeStateArray=(byte *)calloc(routeLookup->size(),sizeof(byte));
+    routeCaptionArray=(const FSH * *)calloc(routeLookup->size(),sizeof(const FSH *));
+  }
   onThrowLookup=LookListLoader(OPCODE_ONTHROW);
   onCloseLookup=LookListLoader(OPCODE_ONCLOSE);
   onActivateLookup=LookListLoader(OPCODE_ONACTIVATE);
@@ -314,238 +330,15 @@ void RMFT2::setTurntableHiddenState(Turntable * tto) {
 #endif
 
 char RMFT2::getRouteType(int16_t id) {
-  for (int16_t i=0;;i+=2) {
+  int16_t progCounter=routeLookup->find(id);
-    int16_t rid= GETHIGHFLASHW(routeIdList,i);
+  if (progCounter>=0) {
-    if (rid==INT16_MAX) break;
+    byte type=GET_OPCODE; 
-    if (rid==id) return 'R';
+    if (type==OPCODE_ROUTE) return 'R';
-  }
+    if (type==OPCODE_AUTOMATION) return 'A';
-  for (int16_t i=0;;i+=2) {
-    int16_t rid= GETHIGHFLASHW(automationIdList,i);
-    if (rid==INT16_MAX) break;
-    if (rid==id) return 'A';
   }
   return 'X';
 }
 
-// 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
-  bool reject=false;
-  switch(opcode) {
-    
-  case 'D':
-    if (p[0]==HASH_KEYWORD_EXRAIL) { // <D EXRAIL ON/OFF>
-      diag = paramCount==2 && (p[1]==HASH_KEYWORD_ON || p[1]==1);
-      opcode=0;
-    }
-        break;
-	
-  case '/':  // New EXRAIL command
-    reject=!parseSlash(stream,paramCount,p);
-    opcode=0;
-    break;
-  case 'L':
-    if (compileFeatures & FEATURE_LCC) { 
-      // This entire code block is compiled out if LLC macros not used 
-    if (paramCount==0) {  //<L>  LCC adapter introducing self
-      LCCSerial=stream;   // now we know where to send events we raise
-
-      // loop through all possible sent events 
-      for (int progCounter=0;; SKIPOP) {
-        byte opcode=GET_OPCODE;
-        if (opcode==OPCODE_ENDEXRAIL) break;
-        if (opcode==OPCODE_LCC)  StringFormatter::send(stream,F("<LS x%h>\n"),getOperand(progCounter,0));   
-        if (opcode==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)
-                 );        
-        }}
-      
-      // we stream the hex events we wish to listen to
-      // and at the same time build the event index looku.
-      
-      
-      int eventIndex=0;
-      for (int progCounter=0;; SKIPOP) {
-        byte opcode=GET_OPCODE;
-        if (opcode==OPCODE_ENDEXRAIL) break;
-        if (opcode==OPCODE_ONLCC) {
-           onLCCLookup[eventIndex]=progCounter; // TODO skip...
-           StringFormatter::send(stream,F("<LL %d x%h%h%h:%h>\n"),
-                 eventIndex,
-                 getOperand(progCounter,1),
-                 getOperand(progCounter,2),
-                 getOperand(progCounter,3),
-                 getOperand(progCounter,0)
-                 );   
-           eventIndex++;      
-        }
-      }
-      StringFormatter::send(stream,F("<LR>\n")); // Ready to rumble
-      opcode=0;
-      break;
-    }
-    if (paramCount==1) {  // <L eventid> LCC event arrived from adapter
-        int16_t eventid=p[0];
-        reject=eventid<0 || eventid>=countLCCLookup;
-        if (!reject)  startNonRecursiveTask(F("LCC"),eventid,onLCCLookup[eventid]);
-        opcode=0;
-    }
-    }
-    break; 
-
-  default:  // other commands pass through
-    break;
-  }
-  if (reject) {
-    opcode=0;
-    StringFormatter::send(stream,F("<X>\n"));
-  }
-}
-
-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) {
-      StringFormatter::send(stream,F("\nID=%d,PC=%d,LOCO=%d%c,SPEED=%d%c"),
-			    (int)(task->taskId),task->progCounter,task->loco,
-			    task->invert?'I':' ',
-			    task->speedo,
-			    task->forward?'F':'R'
-			    );
-      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++) {
-        VPIN sigid=GETHIGHFLASHW(RMFT2::SignalDefinitions,sigslot*8);
-        if (sigid==0) break; // end of signal list 
-        byte flag=flags[sigslot] & SIGNAL_MASK; // obtain signal flags for this id
-        StringFormatter::send(stream,F("\n%S[%d]"), 
-          (flag == SIGNAL_RED)? F("RED") : (flag==SIGNAL_GREEN) ? F("GREEN") : F("AMBER"),
-          sigid & SIGNAL_ID_MASK); 
-      } 
-    }
-    StringFormatter::send(stream,F(" *>\n"));
-    return true;
-  }
-  switch (p[0]) {
-  case HASH_KEYWORD_PAUSE: // </ PAUSE>
-    if (paramCount!=1) return false;
-    DCC::setThrottle(0,1,true);  // pause all locos on the track
-    pausingTask=(RMFT2 *)1; // Impossible task address
-    return true;
-    
-  case HASH_KEYWORD_RESUME: // </ RESUME>
-    if (paramCount!=1) return false;
-    pausingTask=NULL;
-    {
-      RMFT2 * task=loopTask;
-      while(task) {
-	if (task->loco) task->driveLoco(task->speedo);
-	task=task->next;
-	if (task==loopTask) break;
-      }
-    }
-    return true;
-    
-    
-  case HASH_KEYWORD_START: // </ 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=sequenceLookup->find(route);
-      if (pc<0) return false;
-      RMFT2* task=new RMFT2(pc);
-      task->loco=cab;
-    }
-    return true;
-    
-  default:
-    break;
-  }
-
-  // check KILL ALL here, otherwise the next validation confuses ALL with a flag  
-  if (p[0]==HASH_KEYWORD_KILL && p[1]==HASH_KEYWORD_ALL) {
-    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 HASH_KEYWORD_KILL: // 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 HASH_KEYWORD_RESERVE:  // force reserve a section
-    return setFlag(p[1],SECTION_FLAG);
-    
-  case HASH_KEYWORD_FREE:  // force free a section
-    return setFlag(p[1],0,SECTION_FLAG);
-    
-  case HASH_KEYWORD_LATCH:
-    return setFlag(p[1], LATCH_FLAG);
-    
-  case HASH_KEYWORD_UNLATCH:
-    return setFlag(p[1], 0, LATCH_FLAG);
- 
-  case HASH_KEYWORD_RED:
-    doSignal(p[1],SIGNAL_RED);
-    return true;
- 
-  case HASH_KEYWORD_AMBER:
-    doSignal(p[1],SIGNAL_AMBER);
-    return true;
- 
-  case HASH_KEYWORD_GREEN:
-    doSignal(p[1],SIGNAL_GREEN);
-    return true;
-    
-  default:
-    return false;
-  }
-}
-
-
-// This emits Routes and Automations to Withrottle
-// Automations are given a state to set the button to "handoff" which implies
-// handing over the loco to the automation.
-// Routes are given "Set" buttons and do not cause the loco to be handed over.
-
-
 
 RMFT2::RMFT2(int progCtr) {
   progCounter=progCtr;
@@ -594,7 +387,7 @@ RMFT2::~RMFT2() {
 }
 
 void RMFT2::createNewTask(int route, uint16_t cab) {
-      int pc=sequenceLookup->find(route);
+      int pc=routeLookup->find(route);
       if (pc<0) return;
       RMFT2* task=new RMFT2(pc);
       task->loco=cab;
@@ -843,10 +636,10 @@ void RMFT2::loop2() {
         //byte thistrack=getOperand(1);
         switch (operand) {
           case TRACK_POWER_0:
-            TrackManager::setTrackPower(TrackManager::isProg(getOperand(1)), false, POWERMODE::OFF, getOperand(1));
+            TrackManager::setTrackPower(POWERMODE::OFF, getOperand(1));
           break;
           case TRACK_POWER_1:
-            TrackManager::setTrackPower(TrackManager::isProg(getOperand(1)), false, POWERMODE::ON, getOperand(1));
+            TrackManager::setTrackPower(POWERMODE::ON, getOperand(1));
           break;
         }
 
@@ -857,7 +650,7 @@ void RMFT2::loop2() {
       // If DC/DCX use  my loco for DC address 
       {
         TRACK_MODE mode = (TRACK_MODE)(operand>>8);
-        int16_t cab=(mode==TRACK_MODE_DC || mode==TRACK_MODE_DCX) ? loco : 0;
+        int16_t cab=(mode & TRACK_MODE_DC) ? loco : 0;
         TrackManager::setTrackMode(operand & 0x0F, mode, cab);
       }
       break; 
@@ -995,7 +788,7 @@ void RMFT2::loop2() {
   }
     
   case OPCODE_FOLLOW:
-    progCounter=sequenceLookup->find(operand);
+    progCounter=routeLookup->find(operand);
     if (progCounter<0) kill(F("FOLLOW unknown"), operand);
     return;
     
@@ -1005,7 +798,7 @@ void RMFT2::loop2() {
       return;
     }
     callStack[stackDepth++]=progCounter+3;
-    progCounter=sequenceLookup->find(operand);
+    progCounter=routeLookup->find(operand);
     if (progCounter<0) kill(F("CALL unknown"),operand);
     return;
     
@@ -1068,7 +861,7 @@ void RMFT2::loop2() {
     
   case OPCODE_START:
     {
-      int newPc=sequenceLookup->find(operand);
+      int newPc=routeLookup->find(operand);
       if (newPc<0) break;
       new RMFT2(newPc);
     }
@@ -1076,7 +869,7 @@ void RMFT2::loop2() {
     
   case OPCODE_SENDLOCO:  // cab, route
     {
-      int newPc=sequenceLookup->find(getOperand(1));
+      int newPc=routeLookup->find(getOperand(1));
       if (newPc<0) break;
       RMFT2* newtask=new RMFT2(newPc); // create new task
       newtask->loco=operand;
@@ -1130,6 +923,15 @@ void RMFT2::loop2() {
   case OPCODE_PRINT:
     printMessage(operand);
     break;
+  case OPCODE_ROUTE_HIDDEN:
+    manageRouteState(operand,2);
+    break;   
+  case OPCODE_ROUTE_INACTIVE:
+    manageRouteState(operand,0);
+    break;   
+  case OPCODE_ROUTE_ACTIVE:
+    manageRouteState(operand,1);
+    break;   
   
   case OPCODE_ROUTE:
   case OPCODE_AUTOMATION:
@@ -1218,9 +1020,9 @@ int16_t RMFT2::getSignalSlot(int16_t id) {
   
   // Schedule any event handler for this signal change.
   // Thjis will work even without a signal definition. 
-  if (rag==SIGNAL_RED) handleEvent(F("RED"),onRedLookup,id);
+  if (rag==SIGNAL_RED) onRedLookup->handleEvent(F("RED"),id);
-  else if (rag==SIGNAL_GREEN) handleEvent(F("GREEN"), onGreenLookup,id);
+  else if (rag==SIGNAL_GREEN) onGreenLookup->handleEvent(F("GREEN"),id);
-  else handleEvent(F("AMBER"), onAmberLookup,id);
+  else onAmberLookup->handleEvent(F("AMBER"),id);
   
   int16_t sigslot=getSignalSlot(id);
   if (sigslot<0) return; 
@@ -1289,26 +1091,26 @@ int16_t RMFT2::getSignalSlot(int16_t id) {
 
 void RMFT2::turnoutEvent(int16_t turnoutId, bool closed) {
   // Hunt for an ONTHROW/ONCLOSE for this turnout
-  if (closed)  handleEvent(F("CLOSE"),onCloseLookup,turnoutId);
+  if (closed)  onCloseLookup->handleEvent(F("CLOSE"),turnoutId);
-  else handleEvent(F("THROW"),onThrowLookup,turnoutId);
+  else onThrowLookup->handleEvent(F("THROW"),turnoutId);
 }
 
 
 void RMFT2::activateEvent(int16_t addr, bool activate) {
   // Hunt for an ONACTIVATE/ONDEACTIVATE for this accessory
-  if (activate)  handleEvent(F("ACTIVATE"),onActivateLookup,addr);
+  if (activate)  onActivateLookup->handleEvent(F("ACTIVATE"),addr);
-  else handleEvent(F("DEACTIVATE"),onDeactivateLookup,addr);
+  else onDeactivateLookup->handleEvent(F("DEACTIVATE"),addr);
 }
 
 void RMFT2::changeEvent(int16_t vpin, bool change) {
   // Hunt for an ONCHANGE for this sensor
-  if (change)  handleEvent(F("CHANGE"),onChangeLookup,vpin);
+  if (change)  onChangeLookup->handleEvent(F("CHANGE"),vpin);
 }
 
 #ifndef IO_NO_HAL
 void RMFT2::rotateEvent(int16_t turntableId, bool change) {
   // Hunt or an ONROTATE for this turntable
-  if (change) handleEvent(F("ROTATE"),onRotateLookup,turntableId);
+  if (change) onRotateLookup->handleEvent(F("ROTATE"),turntableId);
 }
 #endif
 
@@ -1317,8 +1119,8 @@ void RMFT2::clockEvent(int16_t clocktime, bool change) {
   if (Diag::CMD)
    DIAG(F("Looking for clock event at : %d"), clocktime);
   if (change) {
-    handleEvent(F("CLOCK"),onClockLookup,clocktime);
+    onClockLookup->handleEvent(F("CLOCK"),clocktime);
-    handleEvent(F("CLOCK"),onClockLookup,25*60+clocktime%60);
+    onClockLookup->handleEvent(F("CLOCK"),25*60+clocktime%60);
   }
 } 
 
@@ -1327,16 +1129,10 @@ void RMFT2::powerEvent(int16_t track, bool overload) {
   if (Diag::CMD)
    DIAG(F("Looking for Power event on track : %c"), track);
   if (overload) {
-    handleEvent(F("POWER"),onOverloadLookup,track);
+    onOverloadLookup->handleEvent(F("POWER"),track);
   }
 }
 
-
-void RMFT2::handleEvent(const FSH* reason,LookList* handlers, int16_t id) {
-  int pc= handlers->find(id);
-  if (pc>=0) startNonRecursiveTask(reason,id,pc);
-}
-
 void RMFT2::startNonRecursiveTask(const FSH* reason, int16_t id,int pc) {  
   // Check we dont already have a task running this handler
   RMFT2 * task=loopTask;
@@ -1453,3 +1249,29 @@ void RMFT2::thrungeString(uint32_t strfar, thrunger mode, byte id) {
       break;       
     }
 }
+
+void RMFT2::manageRouteState(uint16_t id, byte state) {
+  if (compileFeatures && FEATURE_ROUTESTATE) {
+    // Route state must be maintained for when new throttles connect.
+    // locate route id in the Routes lookup
+    int16_t position=routeLookup->findPosition(id);
+    if (position<0) return; 
+    // set state beside it 
+    if (routeStateArray[position]==state) return; 
+    routeStateArray[position]=state;
+    CommandDistributor::broadcastRouteState(id,state);
+  }
+}
+void RMFT2::manageRouteCaption(uint16_t id,const FSH* caption) {
+  if (compileFeatures && FEATURE_ROUTESTATE) {
+    // Route state must be maintained for when new throttles connect.
+    // locate route id in the Routes lookup
+    int16_t position=routeLookup->findPosition(id);
+    if (position<0) return; 
+    // set state beside it 
+    if (routeCaptionArray[position]==caption) return; 
+    routeCaptionArray[position]=caption;
+    CommandDistributor::broadcastRouteCaption(id,caption);
+  }
+}
+  

EXRAIL2.h

@@ -68,6 +68,7 @@ enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,
              OPCODE_ONROTATE,OPCODE_ROTATE,OPCODE_WAITFORTT,
              OPCODE_LCC,OPCODE_LCCX,OPCODE_ONLCC,
              OPCODE_ONOVERLOAD,
+             OPCODE_ROUTE_ACTIVE,OPCODE_ROUTE_INACTIVE,OPCODE_ROUTE_HIDDEN,
 
              // OPcodes below this point are skip-nesting IF operations
              // placed here so that they may be skipped as a group
@@ -99,6 +100,7 @@ enum thrunger: byte {
   static const byte FEATURE_SIGNAL= 0x80;
   static const byte FEATURE_LCC   = 0x40;
   static const byte FEATURE_ROSTER= 0x20;
+  static const byte FEATURE_ROUTESTATE= 0x10;
   
  
   // Flag bits for status of hardware and TPL
@@ -119,13 +121,20 @@ 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);
+
   private:
      int16_t m_size;
      int16_t m_loaded;
      int16_t * m_lookupArray;
      int16_t * m_resultArray;
+     LookList* m_chain;     
 };
 
  class RMFT2 {
@@ -159,6 +168,7 @@ 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);
       
 private: 
     static void ComandFilter(Print * stream, byte & opcode, byte & paramCount, int16_t p[]);
@@ -176,9 +186,7 @@ private:
     #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 startNonRecursiveTask(const FSH* reason, int16_t id,int pc);
     static RMFT2 * loopTask;
     static RMFT2 * pausingTask;
     void delayMe(long millisecs);
@@ -198,7 +206,7 @@ private:
    static const  HIGHFLASH  int16_t SignalDefinitions[];
    static byte flags[MAX_FLAGS];
    static Print * LCCSerial;
-   static LookList * sequenceLookup;
+   static LookList * routeLookup;
    static LookList * onThrowLookup;
    static LookList * onCloseLookup;
    static LookList * onActivateLookup;
@@ -216,6 +224,10 @@ private:
    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;
     
   // Local variables - exist for each instance/task 
     RMFT2 *next;   // loop chain 
@@ -237,4 +249,8 @@ private:
     byte stackDepth;
     int callStack[MAX_STACK_DEPTH];
 };
+
+#define GET_OPCODE GETHIGHFLASH(RMFT2::RouteCode,progCounter)
+#define SKIPOP progCounter+=3
+
 #endif

EXRAIL2MacroReset.h

@@ -126,6 +126,10 @@
 #undef ROTATE
 #undef ROTATE_DCC
 #undef ROUTE
+#undef ROUTE_ACTIVE
+#undef ROUTE_INACTIVE
+#undef ROUTE_HIDDEN
+#undef ROUTE_CAPTION
 #undef SENDLOCO 
 #undef SEQUENCE 
 #undef SERIAL 
@@ -267,6 +271,10 @@
 #define ROTATE_DCC(turntable_id,position)
 #define ROSTER(cab,name,funcmap...)
 #define ROUTE(id,description)
+#define ROUTE_ACTIVE(id)
+#define ROUTE_INACTIVE(id)
+#define ROUTE_HIDDEN(id)
+#define ROUTE_CAPTION(id,caption)
 #define SENDLOCO(cab,route) 
 #define SEQUENCE(id) 
 #define SERIAL(msg) 

EXRAIL2Parser.cpp

@@ -0,0 +1,291 @@
+/*
+ *  © 2021 Neil McKechnie
+ *  © 2021-2023 Harald Barth
+ *  © 2020-2023 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"
+// Command parsing keywords
+const int16_t HASH_KEYWORD_EXRAIL=15435;    
+const int16_t HASH_KEYWORD_ON = 2657;
+const int16_t HASH_KEYWORD_START=23232;
+const int16_t HASH_KEYWORD_RESERVE=11392;
+const int16_t HASH_KEYWORD_FREE=-23052;
+const int16_t HASH_KEYWORD_LATCH=1618;  
+const int16_t HASH_KEYWORD_UNLATCH=1353;
+const int16_t HASH_KEYWORD_PAUSE=-4142;
+const int16_t HASH_KEYWORD_RESUME=27609;
+const int16_t HASH_KEYWORD_KILL=5218;
+const int16_t HASH_KEYWORD_ALL=3457;
+const int16_t HASH_KEYWORD_ROUTES=-3702;
+const int16_t HASH_KEYWORD_RED=26099;
+const int16_t HASH_KEYWORD_AMBER=18713;
+const int16_t HASH_KEYWORD_GREEN=-31493;
+const int16_t HASH_KEYWORD_A='A';
+
+// 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
+  bool reject=false;
+  switch(opcode) {
+    
+  case 'D':
+    if (p[0]==HASH_KEYWORD_EXRAIL) { // <D EXRAIL ON/OFF>
+      diag = paramCount==2 && (p[1]==HASH_KEYWORD_ON || p[1]==1);
+      opcode=0;
+    }
+    break;
+	
+  case '/':  // New EXRAIL command
+    reject=!parseSlash(stream,paramCount,p);
+    opcode=0;
+    break;
+  
+  case 'L':
+    // This entire code block is compiled out if LLC macros not used 
+    if (!(compileFeatures & FEATURE_LCC)) return;
+
+    if (paramCount==0) {  //<L>  LCC adapter introducing self
+      LCCSerial=stream;   // now we know where to send events we raise
+
+      // loop through all possible sent events 
+      for (int progCounter=0;; SKIPOP) {
+        byte opcode=GET_OPCODE;
+        if (opcode==OPCODE_ENDEXRAIL) break;
+        if (opcode==OPCODE_LCC)  StringFormatter::send(stream,F("<LS x%h>\n"),getOperand(progCounter,0));   
+        if (opcode==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)
+                 );        
+        }}
+      
+      // we stream the hex events we wish to listen to
+      // and at the same time build the event index looku.
+      
+      
+      int eventIndex=0;
+      for (int progCounter=0;; SKIPOP) {
+        byte opcode=GET_OPCODE;
+        if (opcode==OPCODE_ENDEXRAIL) break;
+        if (opcode==OPCODE_ONLCC) {
+           onLCCLookup[eventIndex]=progCounter; // TODO skip...
+           StringFormatter::send(stream,F("<LL %d x%h%h%h:%h>\n"),
+                 eventIndex,
+                 getOperand(progCounter,1),
+                 getOperand(progCounter,2),
+                 getOperand(progCounter,3),
+                 getOperand(progCounter,0)
+                 );   
+           eventIndex++;      
+        }
+      }
+      StringFormatter::send(stream,F("<LR>\n")); // Ready to rumble
+      opcode=0;
+      break;
+    }
+    if (paramCount==1) {  // <L eventid> LCC event arrived from adapter
+        int16_t eventid=p[0];
+        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 HASH_KEYWORD_A: // <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>
+              uint16_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;  
+        default:
+            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) {
+      StringFormatter::send(stream,F("\nID=%d,PC=%d,LOCO=%d%c,SPEED=%d%c"),
+			    (int)(task->taskId),task->progCounter,task->loco,
+			    task->invert?'I':' ',
+			    task->speedo,
+			    task->forward?'F':'R'
+			    );
+      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++) {
+        VPIN sigid=GETHIGHFLASHW(RMFT2::SignalDefinitions,sigslot*8);
+        if (sigid==0) break; // end of signal list 
+        byte flag=flags[sigslot] & SIGNAL_MASK; // obtain signal flags for this id
+        StringFormatter::send(stream,F("\n%S[%d]"), 
+          (flag == SIGNAL_RED)? F("RED") : (flag==SIGNAL_GREEN) ? F("GREEN") : F("AMBER"),
+          sigid & SIGNAL_ID_MASK); 
+      } 
+    }
+    StringFormatter::send(stream,F(" *>\n"));
+    return true;
+  }
+  switch (p[0]) {
+  case HASH_KEYWORD_PAUSE: // </ PAUSE>
+    if (paramCount!=1) return false;
+    DCC::setThrottle(0,1,true);  // pause all locos on the track
+    pausingTask=(RMFT2 *)1; // Impossible task address
+    return true;
+    
+  case HASH_KEYWORD_RESUME: // </ RESUME>
+    if (paramCount!=1) return false;
+    pausingTask=NULL;
+    {
+      RMFT2 * task=loopTask;
+      while(task) {
+	if (task->loco) task->driveLoco(task->speedo);
+	task=task->next;
+	if (task==loopTask) break;
+      }
+    }
+    return true;
+    
+    
+  case HASH_KEYWORD_START: // </ 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;
+      RMFT2* task=new RMFT2(pc);
+      task->loco=cab;
+    }
+    return true;
+    
+  default:
+    break;
+  }
+
+  // check KILL ALL here, otherwise the next validation confuses ALL with a flag  
+  if (p[0]==HASH_KEYWORD_KILL && p[1]==HASH_KEYWORD_ALL) {
+    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 HASH_KEYWORD_KILL: // 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 HASH_KEYWORD_RESERVE:  // force reserve a section
+    return setFlag(p[1],SECTION_FLAG);
+    
+  case HASH_KEYWORD_FREE:  // force free a section
+    return setFlag(p[1],0,SECTION_FLAG);
+    
+  case HASH_KEYWORD_LATCH:
+    return setFlag(p[1], LATCH_FLAG);
+    
+  case HASH_KEYWORD_UNLATCH:
+    return setFlag(p[1], 0, LATCH_FLAG);
+ 
+  case HASH_KEYWORD_RED:
+    doSignal(p[1],SIGNAL_RED);
+    return true;
+ 
+  case HASH_KEYWORD_AMBER:
+    doSignal(p[1],SIGNAL_AMBER);
+    return true;
+ 
+  case HASH_KEYWORD_GREEN:
+    doSignal(p[1],SIGNAL_GREEN);
+    return true;
+    
+  default:
+    return false;
+  }
+}
+

EXRAILMacros.h

@@ -102,6 +102,14 @@ void exrailHalSetup() {
 #define LCCX(senderid,eventid) | FEATURE_LCC 
 #undef ONLCC
 #define ONLCC(senderid,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_CAPTION
+#define ROUTE_CAPTION(id,caption) | FEATURE_ROUTESTATE
 
 const byte RMFT2::compileFeatures = 0
    #include "myAutomation.h"
@@ -153,6 +161,12 @@ const int StringMacroTracker1=__COUNTER__;
 #define PRINT(msg) THRUNGE(msg,thrunge_print)
 #undef LCN
 #define LCN(msg)   THRUNGE(msg,thrunge_lcn)
+#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
@@ -440,6 +454,10 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
 #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_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)

GITHUB_SHA.h

@@ -1 +1 @@
-#define GITHUB_SHA "devel-202310230944Z"
+#define GITHUB_SHA "devel-202311141013Z"

MotorDriver.cpp

@@ -605,6 +605,10 @@ void MotorDriver::checkPowerOverload(bool useProgLimit, byte trackno) {
 	DIAG(F("TRACK %c ALERT FAULT"), trackno + 'A');
       }
       setPower(POWERMODE::ALERT);
+      if ((trackMode & TRACK_MODE_AUTOINV) && (trackMode & (TRACK_MODE_MAIN|TRACK_MODE_EXT|TRACK_MODE_BOOST))){
+	DIAG(F("TRACK %c INVERT"), trackno + 'A');
+	invertOutput();
+      }
       break;
     }
     // all well
@@ -676,8 +680,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

@@ -3,7 +3,7 @@
  *  © 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
@@ -28,8 +28,15 @@
 #include "DCCTimer.h"
 
 // use powers of two so we can do logical and/or on the track modes in if clauses.
+// RACK_MODE_DCX is (TRACK_MODE_DC|TRACK_MODE_INV)
+template<class T> inline T operator~ (T a) { return (T)~(int)a; }
+template<class T> inline T operator| (T a, T b) { return (T)((int)a | (int)b); }
+template<class T> inline T operator& (T a, T b) { return (T)((int)a & (int)b); }
+template<class T> inline T operator^ (T a, T b) { return (T)((int)a ^ (int)b); }
 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};
+                        TRACK_MODE_DC = 8, TRACK_MODE_EXT = 16, TRACK_MODE_BOOST = 32,
+                        TRACK_MODE_ALL = 62, // only to operate all tracks
+                        TRACK_MODE_INV = 64, TRACK_MODE_DCX = 72 /*DC + INV*/, TRACK_MODE_AUTOINV = 128};
 
 #define setHIGH(fastpin)  *fastpin.inout |= fastpin.maskHIGH
 #define setLOW(fastpin)   *fastpin.inout &= fastpin.maskLOW
@@ -149,6 +156,8 @@ class MotorDriver {
     // from outside interrupt
     void setBrake( bool on, bool interruptContext=false);
     __attribute__((always_inline)) inline void setSignal( bool high) {
+      if (invertPhase)
+	high = !high;
       if (trackPWM) {
 	DCCTimer::setPWM(signalPin,high);
       }
@@ -168,6 +177,12 @@ 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);
@@ -232,6 +247,32 @@ class MotorDriver {
 #endif
   inline void setMode(TRACK_MODE m) {
     trackMode = m;
+    invertOutput(trackMode & TRACK_MODE_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 +304,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
     //

TrackManager.cpp

@@ -1,6 +1,6 @@
 /*
  *  © 2022 Chris Harlow
- *  © 2022 Harald Barth
+ *  © 2022,2023 Harald Barth
  *  © 2023 Colin Murdoch
  *  All rights reserved.
  *  
@@ -45,6 +45,11 @@ const int16_t HASH_KEYWORD_DC = 2183;
 const int16_t HASH_KEYWORD_DCX = 6463; // DC reversed polarity 
 const int16_t HASH_KEYWORD_EXT = 8201; // External DCC signal
 const int16_t HASH_KEYWORD_A = 65; // parser makes single chars the ascii.   
+const int16_t HASH_KEYWORD_AUTO = -5457;
+#ifdef BOOSTER_INPUT
+const int16_t HASH_KEYWORD_BOOST = 11269;
+#endif
+const int16_t HASH_KEYWORD_INV = 11857;
 
 MotorDriver * TrackManager::track[MAX_TRACKS];
 int16_t TrackManager::trackDCAddr[MAX_TRACKS];
@@ -87,7 +92,7 @@ void TrackManager::sampleCurrent() {
   if (!waiting) {
     // look for a valid track to sample or until we are around
     while (true) {
-      if (track[tr]->getMode() & ( TRACK_MODE_MAIN|TRACK_MODE_PROG|TRACK_MODE_DC|TRACK_MODE_DCX|TRACK_MODE_EXT )) {
+      if (track[tr]->getMode() & ( TRACK_MODE_MAIN|TRACK_MODE_PROG|TRACK_MODE_DC|TRACK_MODE_BOOST|TRACK_MODE_EXT )) {
 	track[tr]->startCurrentFromHW();
 	// for scope debug track[1]->setBrake(1);
 	waiting = true;
@@ -197,8 +202,8 @@ void TrackManager::setPROGSignal( bool on) {
 void TrackManager::setDCSignal(int16_t cab, byte speedbyte) {
   FOR_EACH_TRACK(t) {
     if (trackDCAddr[t]!=cab && cab != 0) continue;
-    if (track[t]->getMode()==TRACK_MODE_DC) track[t]->setDCSignal(speedbyte);
+    if (track[t]->getMode() & TRACK_MODE_DC)
-    else if (track[t]->getMode()==TRACK_MODE_DCX) track[t]->setDCSignal(speedbyte ^ 128);
+      track[t]->setDCSignal(speedbyte);
   }
 }    
 
@@ -207,7 +212,7 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
 
     //DIAG(F("Track=%c Mode=%d"),trackToSet+'A', mode);
     // DC tracks require a motorDriver that can set brake!
-    if (mode==TRACK_MODE_DC || mode==TRACK_MODE_DCX) {
+    if (mode & TRACK_MODE_DC) {
 #if defined(ARDUINO_AVR_UNO)
       DIAG(F("Uno has no PWM timers available for DC"));
       return false;
@@ -223,21 +228,37 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
     pinpair p = track[trackToSet]->getSignalPin();
     //DIAG(F("Track=%c remove  pin %d"),trackToSet+'A', p.pin);
     gpio_reset_pin((gpio_num_t)p.pin);
-    pinMode(p.pin, OUTPUT); // gpio_reset_pin may reset to input
     if (p.invpin != UNUSED_PIN) {
       //DIAG(F("Track=%c remove ^pin %d"),trackToSet+'A', p.invpin);
       gpio_reset_pin((gpio_num_t)p.invpin);
-      pinMode(p.invpin, OUTPUT); // gpio_reset_pin may reset to input
     }
+#ifdef BOOSTER_INPUT
+    if (mode & TRACK_MODE_BOOST) {
+      //DIAG(F("Track=%c mode boost pin %d"),trackToSet+'A', p.pin);
+      pinMode(BOOSTER_INPUT, INPUT);
+      gpio_matrix_in(26, SIG_IN_FUNC228_IDX, false); //pads 224 to 228 available as loopback
+      gpio_matrix_out(p.pin, SIG_IN_FUNC228_IDX, false, false);
+      if (p.invpin != UNUSED_PIN) {
+	gpio_matrix_out(p.invpin, SIG_IN_FUNC228_IDX, true /*inverted*/, false);
+      }
+    } else // elseif clause continues
+#endif
+    if (mode & (TRACK_MODE_MAIN | TRACK_MODE_PROG | TRACK_MODE_DC)) {
+      // gpio_reset_pin may reset to input
+      pinMode(p.pin, OUTPUT);
+      if (p.invpin != UNUSED_PIN)
+	pinMode(p.invpin, OUTPUT);
+    }
+
 #endif
 #ifndef DISABLE_PROG
-    if (mode==TRACK_MODE_PROG) {
+    if (mode & TRACK_MODE_PROG) {
 #else
     if (false) {
 #endif
       // only allow 1 track to be prog
       FOR_EACH_TRACK(t)
-	if (track[t]->getMode()==TRACK_MODE_PROG && t != trackToSet) {
+	if ( (track[t]->getMode() & TRACK_MODE_PROG) && t != trackToSet) {
 	  track[t]->setPower(POWERMODE::OFF);
 	  track[t]->setMode(TRACK_MODE_NONE);
 	  track[t]->makeProgTrack(false);     // revoke prog track special handling
@@ -255,16 +276,20 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
     // state, otherwise trains run away or just dont move.
 
     // This can be done BEFORE the PWM-Timer evaluation (methinks)
-    if (!(mode==TRACK_MODE_DC || mode==TRACK_MODE_DCX)) {
+    if (!(mode & TRACK_MODE_DC)) {
       // DCC tracks need to have set the PWM to zero or they will not work.
       track[trackToSet]->detachDCSignal();
       track[trackToSet]->setBrake(false);
     }
 
+    // BOOST:
+    //  Leave it as is
+    // otherwise:
     //  EXT is a special case where the signal pin is
     //  turned off. So unless that is set, the signal
     //  pin should be turned on
-    track[trackToSet]->enableSignal(mode != TRACK_MODE_EXT);
+    if (!(mode & TRACK_MODE_BOOST))
+      track[trackToSet]->enableSignal(!(mode & TRACK_MODE_EXT));
 
 #ifndef ARDUINO_ARCH_ESP32
     // re-evaluate HighAccuracy mode
@@ -274,7 +299,7 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
       // DC tracks must not have the DCC PWM switched on
       // so we globally turn it off if one of the PWM
       // capable tracks is now DC or DCX.
-      if (track[t]->getMode()==TRACK_MODE_DC || track[t]->getMode()==TRACK_MODE_DCX) {
+      if (track[t]->getMode() & TRACK_MODE_DC) {
 	if (track[t]->isPWMCapable()) {
 	  canDo=false;    // this track is capable but can not run PWM
 	  break;          // in this mode, so abort and prevent globally below
@@ -282,7 +307,7 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
 	  track[t]->trackPWM=false; // this track sure can not run with PWM
 	  //DIAG(F("Track %c trackPWM 0 (not capable)"), t+'A');
 	}
-      } else if (track[t]->getMode()==TRACK_MODE_MAIN || track[t]->getMode()==TRACK_MODE_PROG) {
+      } else if (track[t]->getMode() & (TRACK_MODE_MAIN |TRACK_MODE_PROG)) {
 	track[t]->trackPWM = track[t]->isPWMCapable(); // trackPWM is still a guess here
 	//DIAG(F("Track %c trackPWM %d"), t+'A', track[t]->trackPWM);
 	canDo &= track[t]->trackPWM;
@@ -300,10 +325,12 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
 #else
     // For ESP32 we just reinitialize the DCC Waveform
     DCCWaveform::begin();
+    // setMode() again AFTER Waveform::begin() of ESP32 fixes INVERTED signal
+    track[trackToSet]->setMode(mode);
 #endif
 
     // This block must be AFTER the PWM-Timer modifications
-    if (mode==TRACK_MODE_DC || mode==TRACK_MODE_DCX) {
+    if (mode & TRACK_MODE_DC) {
         // DC tracks need to be given speed of the throttle for that cab address
         // otherwise will not match other tracks on same cab.
         // This also needs to allow for inverted DCX
@@ -312,7 +339,7 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
 
     // Normal running tracks are set to the global power state 
     track[trackToSet]->setPower(
-        (mode==TRACK_MODE_MAIN || mode==TRACK_MODE_DC || mode==TRACK_MODE_DCX || mode==TRACK_MODE_EXT) ?
+      (mode & (TRACK_MODE_MAIN | TRACK_MODE_DC | TRACK_MODE_EXT | TRACK_MODE_BOOST)) ?
         mainPowerGuess : POWERMODE::OFF);
     //DIAG(F("TrackMode=%d"),mode);
     return true; 
@@ -320,8 +347,6 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
 
 void TrackManager::applyDCSpeed(byte t) {
   uint8_t speedByte=DCC::getThrottleSpeedByte(trackDCAddr[t]);
-  if (track[t]->getMode()==TRACK_MODE_DCX)
-    speedByte = speedByte ^ 128; // reverse direction bit
   track[t]->setDCSignal(speedByte);
 }
 
@@ -353,12 +378,21 @@ bool TrackManager::parseJ(Print *stream, int16_t params, int16_t p[])
 
     if (params==2  && p[1]==HASH_KEYWORD_EXT) // <= id EXT>
         return setTrackMode(p[0],TRACK_MODE_EXT);
+#ifdef BOOSTER_INPUT
+    if (params==2  && p[1]==HASH_KEYWORD_BOOST) // <= id BOOST>
+        return setTrackMode(p[0],TRACK_MODE_BOOST);
+#endif
+    if (params==2  && p[1]==HASH_KEYWORD_AUTO) // <= id AUTO>
+      return setTrackMode(p[0], track[p[0]]->getMode() | TRACK_MODE_AUTOINV);
+
+    if (params==2  && p[1]==HASH_KEYWORD_INV) // <= id AUTO>
+      return setTrackMode(p[0], track[p[0]]->getMode() | TRACK_MODE_INV);
 
     if (params==3  && p[1]==HASH_KEYWORD_DC && p[2]>0) // <= id DC cab>
         return setTrackMode(p[0],TRACK_MODE_DC,p[2]);
     
     if (params==3  && p[1]==HASH_KEYWORD_DCX && p[2]>0) // <= id DCX cab>
-        return setTrackMode(p[0],TRACK_MODE_DCX,p[2]);
+        return setTrackMode(p[0],TRACK_MODE_DC|TRACK_MODE_INV,p[2]);
 
     return false;
 }
@@ -366,36 +400,43 @@ bool TrackManager::parseJ(Print *stream, int16_t params, int16_t p[])
 void TrackManager::streamTrackState(Print* stream, byte t) {
   // null stream means send to commandDistributor for broadcast
   if (track[t]==NULL) return;
-  auto format=F("");
+  auto format=F("<= %d XXX>\n");
-  bool pstate = TrackManager::isPowerOn(t);
+  TRACK_MODE tm = track[t]->getMode();
-  
+  if (tm & TRACK_MODE_MAIN) {
-  switch(track[t]->getMode()) {
+    if(tm & TRACK_MODE_AUTOINV)
-  case TRACK_MODE_MAIN:
+      format=F("<= %c MAIN A>\n");
-      if (pstate) {format=F("<= %c MAIN ON>\n");} else {format = F("<= %c MAIN OFF>\n");}
+    else if (tm & TRACK_MODE_INV)
-      break;
+      format=F("<= %c MAIN I>\n");
+    else
+      format=F("<= %c MAIN>\n");
+  }
 #ifndef DISABLE_PROG
-  case TRACK_MODE_PROG:
+  else if (tm & TRACK_MODE_PROG)
-      if (pstate) {format=F("<= %c PROG ON>\n");} else {format=F("<= %c PROG OFF>\n");}
+    format=F("<= %c PROG>\n");
-      break;
 #endif
-  case TRACK_MODE_NONE:
+  else if (tm & TRACK_MODE_NONE)
-      if (pstate) {format=F("<= %c NONE ON>\n");} else {format=F("<= %c NONE OFF>\n");}
+    format=F("<= %c NONE>\n");
-      break;
+  else if(tm & TRACK_MODE_EXT)
-  case TRACK_MODE_EXT:
+    format=F("<= %c EXT>\n");
-      if (pstate) {format=F("<= %c EXT ON>\n");} else {format=F("<= %c EXT OFF>\n");}
+  else if(tm & TRACK_MODE_BOOST) {
-      break;
+        if(tm & TRACK_MODE_AUTOINV)
-  case TRACK_MODE_DC:
+      format=F("<= %c B A>\n");
-      if (pstate) {format=F("<= %c DC %d ON>\n");} else {format=F("<= %c DC %d OFF>\n");}
+    else if (tm & TRACK_MODE_INV)
-      break;
+      format=F("<= %c B I>\n");
-  case TRACK_MODE_DCX:
+    else
-      if (pstate) {format=F("<= %c DCX %d ON>\n");} else {format=F("<= %c DCX %d OFF>\n");}
+      format=F("<= %c B>\n");
-      break;
+  }
-  default:
+  else if (tm & TRACK_MODE_DC) {
-      break; // unknown, dont care    
+    if (tm & TRACK_MODE_INV)
+      format=F("<= %c DCX %d>\n");
+    else
+      format=F("<= %c DC %d>\n");
   }
 
-  if (stream) StringFormatter::send(stream,format,'A'+t, trackDCAddr[t]);   
+  if (stream)
-    else CommandDistributor::broadcastTrackState(format,'A'+t, trackDCAddr[t]);
+    StringFormatter::send(stream,format,'A'+t, trackDCAddr[t]);
+  else
+    CommandDistributor::broadcastTrackState(format,'A'+t, trackDCAddr[t]);
   
 }
 
@@ -411,13 +452,13 @@ void TrackManager::loop() {
     if (nextCycleTrack>lastTrack) nextCycleTrack=0;
     if (track[nextCycleTrack]==NULL) return;
     MotorDriver * motorDriver=track[nextCycleTrack];
-    bool useProgLimit=dontLimitProg? false: track[nextCycleTrack]->getMode()==TRACK_MODE_PROG;
+    bool useProgLimit=dontLimitProg ? false : (bool)(track[nextCycleTrack]->getMode() & TRACK_MODE_PROG);
     motorDriver->checkPowerOverload(useProgLimit, nextCycleTrack);   
 }
 
 MotorDriver * TrackManager::getProgDriver() {
     FOR_EACH_TRACK(t)
-      if (track[t]->getMode()==TRACK_MODE_PROG) return track[t];
+      if (track[t]->getMode() & TRACK_MODE_PROG) return track[t];
     return NULL;
 } 
 
@@ -425,63 +466,53 @@ MotorDriver * TrackManager::getProgDriver() {
 std::vector<MotorDriver *>TrackManager::getMainDrivers() {
   std::vector<MotorDriver *>  v;
   FOR_EACH_TRACK(t)
-    if (track[t]->getMode()==TRACK_MODE_MAIN) v.push_back(track[t]);
+    if (track[t]->getMode() & TRACK_MODE_MAIN) v.push_back(track[t]);
   return v;
 }
 #endif
 
-void TrackManager::setPower2(bool setProg,bool setJoin, POWERMODE mode) {
+// Set track power for all tracks with this mode
-    if (!setProg) mainPowerGuess=mode; 
+void TrackManager::setTrackPower(TRACK_MODE trackmode, POWERMODE powermode) {
   FOR_EACH_TRACK(t) {
-
+    MotorDriver *driver=track[t]; 
-      TrackManager::setTrackPower(setProg, setJoin, mode, t);
+    if (trackmode & driver->getMode()) {
-      
+      if (powermode == POWERMODE::ON) {
-    }
+	if (trackmode & TRACK_MODE_DC) {
-    return;
+	  driver->setBrake(true);   // DC starts with brake on
-}
+	  applyDCSpeed(t);          // speed match DCC throttles
-
+	} else {
-void TrackManager::setTrackPower(bool setProg, bool setJoin, POWERMODE mode, byte thistrack) {
-
-      //DIAG(F("SetTrackPower Processing Track %d"), thistrack);
-      MotorDriver * driver=track[thistrack]; 
-      if (!driver) return; 
-
-      switch (track[thistrack]->getMode()) {
-          case TRACK_MODE_MAIN:
-              if (setProg) break; 
 	  // toggle brake before turning power on - resets overcurrent error
 	  // on the Pololu board if brake is wired to ^D2.
-              // XXX see if we can make this conditional
 	  driver->setBrake(true);
 	  driver->setBrake(false); // DCC runs with brake off
-              driver->setPower(mode);  
+	}
-              break; 
+      }
-          case TRACK_MODE_DC:
+      driver->setPower(powermode);
-          case TRACK_MODE_DCX:
+    }
-              //DIAG(F("Processing track - %d setProg %d"), thistrack, setProg);
+  }
-              if (setProg || setJoin)  break; 
+}
+
+// Set track power for this track, inependent of mode
+void TrackManager::setTrackPower(POWERMODE powermode, byte t) {
+  MotorDriver *driver=track[t]; 
+  TRACK_MODE trackmode = driver->getMode();
+  if (trackmode & TRACK_MODE_DC) {
+    if (powermode == POWERMODE::ON) {
       driver->setBrake(true);   // DC starts with brake on
-              applyDCSpeed(thistrack);        // speed match DCC throttles
+      applyDCSpeed(t);          // speed match DCC throttles
-              driver->setPower(mode);
-              break;  
-          case TRACK_MODE_PROG:
-              if (!setProg && !setJoin) break; 
-              driver->setBrake(true);
-              driver->setBrake(false);
-              driver->setPower(mode);
-              break;  
-          case TRACK_MODE_EXT:
-              driver->setBrake(true);
-              driver->setBrake(false);
-              driver->setPower(mode);
-        break;
-          case TRACK_MODE_NONE:
-              break;
     }
-
+  } else {
+    if (powermode == POWERMODE::ON) {
+      // toggle brake before turning power on - resets overcurrent error
+      // on the Pololu board if brake is wired to ^D2.
+      driver->setBrake(true);
+      driver->setBrake(false); // DCC runs with brake off
     }
+  }
+  driver->setPower(powermode);
+}
 
- void TrackManager::reportPowerChange(Print* stream, byte thistrack) {
+void TrackManager::reportPowerChange(Print* stream, byte thistrack) {
   // This function is for backward JMRI compatibility only
   // It reports the first track only, as main, regardless of track settings.
   //  <c MeterName value C/V unit min max res warn>
@@ -490,12 +521,40 @@ void TrackManager::setTrackPower(bool setProg, bool setJoin, POWERMODE mode, byt
             track[0]->raw2mA(track[0]->getCurrentRaw(false)), maxCurrent, maxCurrent);                  
 }
 
+// returns state of the one and only prog track
 POWERMODE TrackManager::getProgPower() {
   FOR_EACH_TRACK(t)
-      if (track[t]->getMode()==TRACK_MODE_PROG) 
+    if (track[t]->getMode() & TRACK_MODE_PROG)
-	  return track[t]->getPower();
+      return track[t]->getPower(); // optimize: there is max one prog track
   return POWERMODE::OFF;
+}
+
+// returns on if all are on. returns off otherwise
+POWERMODE TrackManager::getMainPower() {
+  POWERMODE result = POWERMODE::OFF;
+  FOR_EACH_TRACK(t) {
+    if (track[t]->getMode() & TRACK_MODE_MAIN) {
+      POWERMODE p = track[t]->getPower();
+      if (p == POWERMODE::OFF)
+	return POWERMODE::OFF; // done and out
+      if (p == POWERMODE::ON)
+	result = POWERMODE::ON;
     }
+  }
+  return result;
+}
+
+bool TrackManager::getPower(byte t, char s[]) {
+  if (t > lastTrack)
+    return false;
+  if (track[t]) {
+    s[0] = track[t]->getPower() == POWERMODE::ON ? '1' : '0';
+    s[2] = t + 'A';
+    return true;
+  }
+  return false;
+}
+
 
 void TrackManager::reportObsoleteCurrent(Print* stream) {
   // This function is for backward JMRI compatibility only
@@ -537,7 +596,7 @@ void TrackManager::setJoin(bool joined) {
 #ifdef ARDUINO_ARCH_ESP32
   if (joined) {
     FOR_EACH_TRACK(t) {
-      if (track[t]->getMode()==TRACK_MODE_PROG) {
+      if (track[t]->getMode() & TRACK_MODE_PROG) {
 	tempProgTrack = t;
 	setTrackMode(t, TRACK_MODE_MAIN);
 	break;
@@ -566,7 +625,7 @@ bool TrackManager::isPowerOn(byte t) {
   }
 
 bool TrackManager::isProg(byte t) {
-    if (track[t]->getMode()==TRACK_MODE_PROG)
+    if (track[t]->getMode() & TRACK_MODE_PROG)
         return true;
     return false;
 }

TrackManager.h

@@ -65,20 +65,19 @@ class TrackManager {
     static std::vector<MotorDriver *>getMainDrivers();
 #endif
   
-    static void setPower2(bool progTrack,bool joinTrack,POWERMODE mode);
     static void setPower(POWERMODE mode) {setMainPower(mode); setProgPower(mode);}
-    static void setMainPower(POWERMODE mode) {setPower2(false,false,mode);}
+    static void setTrackPower(POWERMODE mode, byte t);
-    static void setProgPower(POWERMODE mode) {setPower2(true,false,mode);}
+    static void setTrackPower(TRACK_MODE trackmode, POWERMODE powermode);
-    static void setJoinPower(POWERMODE mode) {setPower2(false,true,mode);}
+    static void setMainPower(POWERMODE mode) {setTrackPower(TRACK_MODE_MAIN, mode);}
-    static void setTrackPower(bool setProg, bool setJoin, POWERMODE mode, byte thistrack);
+    static void setProgPower(POWERMODE mode) {setTrackPower(TRACK_MODE_PROG, mode);}
-   
 
     static const int16_t MAX_TRACKS=8;
     static bool setTrackMode(byte track, TRACK_MODE mode, int16_t DCaddr=0);
     static bool parseJ(Print * stream,  int16_t params, int16_t p[]);
     static void loop();
-    static POWERMODE getMainPower() {return mainPowerGuess;}
+    static POWERMODE getMainPower();
     static POWERMODE getProgPower();
+    static bool getPower(byte t, char s[]);
     static void setJoin(bool join);
     static bool isJoined() { return progTrackSyncMain;}
     static void setJoinRelayPin(byte joinRelayPin);
@@ -112,7 +111,7 @@ class TrackManager {
     static POWERMODE mainPowerGuess;
     static void applyDCSpeed(byte t);
 
-    static int16_t trackDCAddr[MAX_TRACKS];  // dc address if TRACK_MODE_DC or TRACK_MODE_DCX
+    static int16_t trackDCAddr[MAX_TRACKS];  // dc address if TRACK_MODE_DC
 #ifdef ARDUINO_ARCH_ESP32
     static byte tempProgTrack; // holds the prog track number during join
 #endif

config.example.h

@@ -266,6 +266,12 @@ The configuration file for DCC-EX Command Station
 //
 //#define SERIAL_BT_COMMANDS
 
+// BOOSTER PIN INPUT ON ESP32
+// On ESP32 you have the possibility to define a pin as booster input
+// Arduio pin D2 is GPIO 26 on ESPDuino32
+//
+//#define BOOSTER_INPUT 26
+
 // SABERTOOTH
 //
 // This is a very special option and only useful if you happen to have a

version.h

@@ -3,7 +3,11 @@
 
 #include "StringFormatter.h"
 
-#define VERSION "5.1.19"
+#define VERSION "5.2.1"
+// 5.2.1  - Trackmanager rework for simpler structure
+// 5.2.0  - ESP32: Autoreverse and booster mode support
+// 5.1.21 - EXRAIL invoke multiple ON handlers for same event
+// 5.1.20 - EXRAIL Tidy and ROUTE_STATE, ROUTE_CAPTION 
 // 5.1.19 - Only flag 2.2.0.0-dev as broken, not 2.2.0.0
 // 5.1.18 - TURNOUTL bugfix
 // 5.1.17 - Divide out C for config and D for diag commands