tag

eliminate warning
To make usage easier, use F29 to F31 for frequencies
2025-07-29 02:13:45 +02:00 · 2024-01-20 23:36:11 +01:00 · 2024-01-20 23:35:30 +01:00 · 2024-01-20 23:34:17 +01:00 · 2024-01-20 18:09:03 +00:00 · 2024-01-03 02:44:15 +01:00
38 changed files with 845 additions and 337 deletions
--- a/CommandDistributor.cpp
+++ b/CommandDistributor.cpp
@@ -209,7 +209,9 @@ int16_t CommandDistributor::retClockTime() {

 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);
+  uint32_t func = sp->functions;
+  func = func & 0x1fffffff; // mask out bits 0-28
+  broadcastReply(COMMAND_TYPE, F("<l %d %d %d %l>\n"), sp->loco,slot,sp->speedCode,func);
 #ifdef SABERTOOTH
  if (Serial2 && sp->loco == SABERTOOTH) {
    static uint8_t rampingmode = 0;
@@ -254,29 +256,64 @@ void  CommandDistributor::broadcastPower() {
    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';
+  }
+
+  // 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"));
+    }
+  }
+
+  if (state != '2')
+    broadcastReply(COMMAND_TYPE, F("<p%c>\n"),state);
 #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::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 ) {
@@ -330,7 +367,7 @@ void CommandDistributor::setVirtualLCDSerial(Print * stream) {
  virtualLCDSerial=stream;
 }

-Print* CommandDistributor::virtualLCDSerial=nullptr;
+Print* CommandDistributor::virtualLCDSerial=&USB_SERIAL;
 byte CommandDistributor::virtualLCDClient=0xFF;
 byte CommandDistributor::rememberVLCDClient=0;

--- a/CommandDistributor.h
+++ b/CommandDistributor.h
@@ -55,7 +55,7 @@ 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);
--- a/CommandStation-EX.ino
+++ b/CommandStation-EX.ino
@@ -87,7 +87,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"));
  );

--- a/DCC.cpp
+++ b/DCC.cpp
@@ -122,7 +122,7 @@ void DCC::setThrottle2( uint16_t cab, byte speedCode)  {
  DCCWaveform::mainTrack.schedulePacket(b, nB, 0);
 }

-void DCC::setFunctionInternal(int cab, byte byte1, byte byte2) {
+void DCC::setFunctionInternal(int cab, byte byte1, byte byte2, byte count) {
  // DIAG(F("setFunctionInternal %d %x %x"),cab,byte1,byte2);
  byte b[4];
  byte nB = 0;
@@ -133,7 +133,7 @@ void DCC::setFunctionInternal(int cab, byte byte1, byte byte2) {
  if (byte1!=0) b[nB++] = byte1;
  b[nB++] = byte2;

-  DCCWaveform::mainTrack.schedulePacket(b, nB, 0);
+  DCCWaveform::mainTrack.schedulePacket(b, nB, count);
 }

 // returns speed steps 0 to 127 (1 == emergency stop)
@@ -153,6 +153,22 @@ uint8_t DCC::getThrottleSpeedByte(int cab) {
  return speedTable[reg].speedCode;
 }

+// returns 0 to 7 for frequency
+uint8_t DCC::getThrottleFrequency(int cab) {
+#if defined(ARDUINO_AVR_UNO)
+  (void)cab;
+  return 0;
+#else
+  int reg=lookupSpeedTable(cab);
+  if (reg<0)
+    return 0; // use default frequency
+  // shift out first 29 bits so we have the 3 "frequency bits" left
+  uint8_t res = (uint8_t)(speedTable[reg].functions >>29);
+  //DIAG(F("Speed table %d functions %l shifted %d"), reg, speedTable[reg].functions, res);
+  return res;
+#endif
+}
+
 // returns direction on loco
 // or true/forward on "loco not found"
 bool DCC::getThrottleDirection(int cab) {
@@ -183,43 +199,54 @@ bool DCC::setFn( int cab, int16_t functionNumber, bool on) {
       b[nB++] = functionNumber >>7 ;  // high order bits
    }
    DCCWaveform::mainTrack.schedulePacket(b, nB, 4);
-    return true;
  }
-
+  // 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;
+  
  int reg = lookupSpeedTable(cab);
  if (reg<0) return false;

  // Take care of functions:
  // Set state of function
-  unsigned long previous=speedTable[reg].functions;
-  unsigned long funcmask = (1UL<<functionNumber);
+  uint32_t previous=speedTable[reg].functions;
+  uint32_t funcmask = (1UL<<functionNumber);
  if (on) {
      speedTable[reg].functions |= funcmask;
  } else {
      speedTable[reg].functions &= ~funcmask;
  }
-  if (speedTable[reg].functions != previous) {
+  if (speedTable[reg].functions != previous && functionNumber <= 28) {
    updateGroupflags(speedTable[reg].groupFlags, functionNumber);
    CommandDistributor::broadcastLoco(reg);
  }
  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;
+  if (cab<=0 || functionNumber>31) 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);
+  if (functionNumber <= 28) {
+    updateGroupflags(speedTable[reg].groupFlags, functionNumber);
+    CommandDistributor::broadcastLoco(reg);
+  }
 }

-int DCC::getFn( int cab, int16_t functionNumber) {
-  if (cab<=0 || functionNumber>28) return -1;  // unknown
+// 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>28)
+    return -1;  // unknown
  int reg = lookupSpeedTable(cab);
-  if (reg<0) return -1;
+  if (reg<0)
+    return -1;

  unsigned long funcmask = (1UL<<functionNumber);
  return  (speedTable[reg].functions & funcmask)? 1 : 0;
@@ -595,7 +622,7 @@ void DCC::loop()  {

 void DCC::issueReminders() {
  // if the main track transmitter still has a pending packet, skip this time around.
-  if ( DCCWaveform::mainTrack.getPacketPending()) return;
+  if (!DCCWaveform::mainTrack.isReminderWindowOpen()) return;
  // Move to next loco slot.  If occupied, send a reminder.
  int reg = lastLocoReminder+1;
  if (reg > highestUsedReg) reg = 0;  // Go to start of table
@@ -619,24 +646,39 @@ bool DCC::issueReminder(int reg) {
         break;
       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
+#ifndef DISABLE_FUNCTION_REMINDERS
+	    setFunctionInternal(loco,0, 128 | ((functions>>1)& 0x0F) | ((functions & 0x01)<<4),0); // 100D DDDD
+#else
+	    setFunctionInternal(loco,0, 128 | ((functions>>1)& 0x0F) | ((functions & 0x01)<<4),2);
+          flags&= ~FN_GROUP_1;  // dont send them again
+#endif
          break;
       case 2: // remind function group 2 F5-F8
          if (flags & FN_GROUP_2)
-              setFunctionInternal(loco,0, 176 | ((functions>>5)& 0x0F));                           // 1011 DDDD
+#ifndef DISABLE_FUNCTION_REMINDERS
+  	    setFunctionInternal(loco,0, 176 | ((functions>>5)& 0x0F),0);                           // 1011 DDDD
+#else
+	    setFunctionInternal(loco,0, 176 | ((functions>>5)& 0x0F),2);
+          flags&= ~FN_GROUP_2;  // dont send them again
+#endif
          break;
       case 3: // remind function group 3 F9-F12
          if (flags & FN_GROUP_3)
-              setFunctionInternal(loco,0, 160 | ((functions>>9)& 0x0F));                           // 1010 DDDD
+#ifndef DISABLE_FUNCTION_REMINDERS
+	    setFunctionInternal(loco,0, 160 | ((functions>>9)& 0x0F),0);                           // 1010 DDDD
+#else
+	    setFunctionInternal(loco,0, 160 | ((functions>>9)& 0x0F),2);
+          flags&= ~FN_GROUP_3;  // dont send them again
+#endif
          break;
       case 4: // remind function group 4 F13-F20
          if (flags & FN_GROUP_4)
-              setFunctionInternal(loco,222, ((functions>>13)& 0xFF));
+	    setFunctionInternal(loco,222, ((functions>>13)& 0xFF),2);
          flags&= ~FN_GROUP_4;  // dont send them again
          break;
       case 5: // remind function group 5 F21-F28
          if (flags & FN_GROUP_5)
-              setFunctionInternal(loco,223, ((functions>>21)& 0xFF));
+	    setFunctionInternal(loco,223, ((functions>>21)& 0xFF),2);
          flags&= ~FN_GROUP_5;  // dont send them again
          break;
      }
--- a/DCC.h
+++ b/DCC.h
@@ -61,13 +61,14 @@ public:
  static void setThrottle(uint16_t cab, uint8_t tSpeed, bool tDirection);
  static int8_t getThrottleSpeed(int cab);
  static uint8_t getThrottleSpeedByte(int cab);
+  static uint8_t getThrottleFrequency(int cab);
  static bool getThrottleDirection(int cab);
  static void writeCVByteMain(int cab, int cv, byte bValue);
  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 updateGroupflags(byte &flags, int16_t functionNumber);
  static void setAccessory(int address, byte port, bool gate, byte onoff = 2);
@@ -98,7 +99,7 @@ public:
    int loco;
    byte speedCode;
    byte groupFlags;
-    unsigned long functions;
+    uint32_t functions;
  };
 static LOCO speedTable[MAX_LOCOS];
 static int lookupSpeedTable(int locoId, bool autoCreate=true);
@@ -109,7 +110,7 @@ private:
  static byte loopStatus;
  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 void setFunctionInternal(int cab, byte fByte, byte eByte, byte count);
  static bool issueReminder(int reg);
  static int lastLocoReminder;
  static int highestUsedReg;
--- a/DCCEXParser.cpp
+++ b/DCCEXParser.cpp
@@ -115,6 +115,7 @@ Once a new OPCODE is decided upon, update this list.
 #include "DCCTimer.h"
 #include "EXRAIL2.h"
 #include "Turntables.h"
+#include "version.h"

 // This macro can't be created easily as a portable function because the
 // flashlist requires a far pointer for high flash access. 
@@ -159,6 +160,7 @@ const int16_t HASH_KEYWORD_C='C';
 const int16_t HASH_KEYWORD_G='G';
 const int16_t HASH_KEYWORD_H='H';
 const int16_t HASH_KEYWORD_I='I';
+const int16_t HASH_KEYWORD_M='M';
 const int16_t HASH_KEYWORD_O='O';
 const int16_t HASH_KEYWORD_P='P';
 const int16_t HASH_KEYWORD_R='R';
@@ -585,7 +587,6 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
            }
 	    else break; // will reply <X>
 	  }
-	  CommandDistributor::broadcastPower();
 	  //TrackManager::streamTrackState(NULL,t);
          
 	  return;
@@ -617,7 +618,6 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
 	    }
 	    else break; // will reply <X>
 	  }
-	  CommandDistributor::broadcastPower();
 	  return;
 	}

@@ -625,12 +625,13 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
        DCC::setThrottle(0,1,1); // this broadcasts speed 1(estop) and sets all reminders to speed 1.
        return;

+#ifdef HAS_ENOUGH_MEMORY
    case 'c': // SEND METER RESPONSES <c>
        // No longer useful because of multiple tracks See <JG> and <JI>
        if (params>0) break;
        TrackManager::reportObsoleteCurrent(stream);
        return;
-
+#endif
    case 'Q': // SENSORS <Q>
        Sensor::printAll(stream);
        return;
@@ -667,7 +668,7 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
        break;
 #endif
    case '=': // TRACK MANAGER CONTROL <= [params]>
-        if (TrackManager::parseJ(stream, params, p))
+        if (TrackManager::parseEqualSign(stream, params, p))
            return;
        break;

@@ -728,6 +729,12 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
                    StringFormatter::send(stream, F("<jA>\n"));
                    return;
 
+                case HASH_KEYWORD_M: // <JM> intercepted by EXRAIL
+                    if (params>1) break; // invalid cant do
+                    // <JM> requests stash size so say none.
+                    StringFormatter::send(stream,F("<jM 0>\n")); 
+                    return;
+ 
            case HASH_KEYWORD_R: // <JR> returns rosters 
                StringFormatter::send(stream, F("<jR"));
 #ifdef EXRAIL_ACTIVE
@@ -839,10 +846,14 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
    case 'L': // LCC interface implemented in EXRAIL parser
        break; // Will <X> if not intercepted by EXRAIL 

+#ifndef DISABLE_VDPY
    case '@': // JMRI saying "give me virtual LCD msgs"
        CommandDistributor::setVirtualLCDSerial(stream);
+        StringFormatter::send(stream,
+            F("<@ 0 0 \"DCC-EX v" VERSION "\">\n"
+               "<@ 0 1 \"Lic GPLv3\">\n"));
        return; 
-
+#endif
    default: //anything else will diagnose and drop out to <X>
      if (opcode >= ' ' && opcode <= '~') {
        DIAG(F("Opcode=%c params=%d"), opcode, params);
@@ -1053,6 +1064,7 @@ bool DCCEXParser::parseS(Print *stream, int16_t params, int16_t p[])
 }

 bool DCCEXParser::parseC(Print *stream, int16_t params, int16_t p[]) {
+    (void)stream; // arg not used, maybe later?
    if (params == 0)
        return false;
    switch (p[0])
--- a/DCCTimer.h
+++ b/DCCTimer.h
@@ -85,6 +85,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 
--- a/DCCTimerAVR.cpp
+++ b/DCCTimerAVR.cpp
@@ -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
@@ -125,6 +126,81 @@ void DCCTimer::reset() {

 }

+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)
+      // 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
--- a/DCCTimerESP.cpp
+++ b/DCCTimerESP.cpp
@@ -151,10 +151,26 @@ 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)
+    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 +180,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);
--- a/DCCTimerMEGAAVR.cpp
+++ b/DCCTimerMEGAAVR.cpp
@@ -125,6 +125,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;
 }
--- a/DCCTimerSAMD.cpp
+++ b/DCCTimerSAMD.cpp
@@ -156,6 +156,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;
--- a/DCCTimerSTM32.cpp
+++ b/DCCTimerSTM32.cpp
@@ -50,11 +50,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)
 // Nucleo-144 boards don't have Serial1 defined by default
 HardwareSerial Serial6(PG9, PG14);  // Rx=PG9, Tx=PG14 -- USART6
+HardwareSerial Serial5(PD2, PC12);  // Rx=PD2, Tx=PC12 -- UART5
+#if !defined(ARDUINO_NUCLEO_F412ZG)
+  HardwareSerial Serial2(PD6, PD5);  // Rx=PD6, Tx=PD5 -- 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
@@ -215,9 +220,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 +257,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 +284,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
--- a/DCCTimerTEENSY.cpp
+++ b/DCCTimerTEENSY.cpp
@@ -141,6 +141,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;
 }
--- a/DCCWaveform.cpp
+++ b/DCCWaveform.cpp
@@ -106,6 +106,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
@@ -127,9 +128,15 @@ void DCCWaveform::interrupt2() {
  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<4 && remainingPreambles>1;
+    if (remainingPreambles==1) promotePendingPacket();
    // 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,30 +155,9 @@ 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!)
-      }
-    }
  }  
 }
 #pragma GCC pop_options
@@ -193,8 +179,39 @@ void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repea
  packetPending = true;
  clearResets();
 }
-bool DCCWaveform::getPacketPending() {
-  return packetPending;
+
+bool DCCWaveform::isReminderWindowOpen() {
+  return reminderWindowOpen && ! packetPending;
+}
+
+void DCCWaveform::promotePendingPacket() {
+    // fill the transmission packet from the pending packet
+    
+    // Just keep going if repeating  
+    if (transmitRepeats > 0) {
+        transmitRepeats--;
+        return;
+      }
+
+    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
+      memcpy( transmitPacket, isMainTrack ? idlePacket : resetPacket, sizeof(idlePacket));
+      transmitLength = sizeof(idlePacket);
+      transmitRepeats = 0;
+      if (getResets() < 250) sentResetsSincePacket++; // only place to increment (private!)
 }
 #endif

@@ -266,15 +283,15 @@ void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repea
  }
 }

-bool DCCWaveform::getPacketPending() {
+bool DCCWaveform::isReminderWindowOpen() {
  if(isMainTrack) {
    if (rmtMainChannel == NULL)
-      return true;
-    return rmtMainChannel->busy();
+      return false;
+    return !rmtMainChannel->busy();
  } else {
    if (rmtProgChannel == NULL)
-      return true;
-    return rmtProgChannel->busy();
+      return false;
+    return !rmtProgChannel->busy();
  }
 }
 void IRAM_ATTR DCCWaveform::loop() {
--- a/DCCWaveform.h
+++ b/DCCWaveform.h
@@ -76,11 +76,13 @@ class DCCWaveform {
    };
 #endif
    void schedulePacket(const byte buffer[], byte byteCount, byte repeats);
-    bool getPacketPending();
+    bool isReminderWindowOpen();
+    void promotePendingPacket();
    
  private:
 #ifndef ARDUINO_ARCH_ESP32
    volatile bool packetPending;
+    volatile bool reminderWindowOpen;
    volatile byte sentResetsSincePacket;
 #else
    volatile uint32_t resetPacketBase;
--- a/Display_Implementation.h
+++ b/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
--- a/EXRAIL2.cpp
+++ b/EXRAIL2.cpp
@@ -86,6 +86,8 @@ LookList *  RMFT2::onRotateLookup=NULL;
 LookList *  RMFT2::onOverloadLookup=NULL;
 byte * RMFT2::routeStateArray=nullptr; 
 const FSH  * * RMFT2::routeCaptionArray=nullptr; 
+int16_t * RMFT2::stashArray=nullptr;
+int16_t RMFT2::maxStashId=0;

 // getOperand instance version, uses progCounter from instance.
 uint16_t RMFT2::getOperand(byte n) {
@@ -232,6 +234,12 @@ if (compileFeatures & FEATURE_SIGNAL) {
      IODevice::configureInput((VPIN)pin,true);
      break;
    }
+    case OPCODE_STASH:
+    case OPCODE_CLEAR_STASH:
+    case OPCODE_PICKUP_STASH: {
+      maxStashId=max(maxStashId,((int16_t)operand));
+      break;
+    }

    case OPCODE_ATGTE:
    case OPCODE_ATLT:
@@ -311,8 +319,14 @@ if (compileFeatures & FEATURE_SIGNAL) {
    }
  }
  SKIPOP; // include ENDROUTES opcode
-
-  DIAG(F("EXRAIL %db, fl=%d"),progCounter,MAX_FLAGS);
+  
+  if (compileFeatures & FEATURE_STASH) {
+    // create the stash array from the highest id found
+    if (maxStashId>0) stashArray=(int16_t*)calloc(maxStashId+1, sizeof(int16_t));
+     //TODO check EEPROM and fetch stashArray
+  }
+  
+  DIAG(F("EXRAIL %db, fl=%d, stash=%d"),progCounter,MAX_FLAGS, maxStashId);

  // Removed for 4.2.31  new RMFT2(0); // add the startup route
  diag=saved_diag;
@@ -400,7 +414,6 @@ void RMFT2::driveLoco(byte speed) {
 power on appropriate track if DC or main if dcc
  if (TrackManager::getMainPowerMode()==POWERMODE::OFF) {
    TrackManager::setMainPower(POWERMODE::ON);
-    CommandDistributor::broadcastPower();
  }
  **********/

@@ -628,7 +641,6 @@ void RMFT2::loop2() {
  case OPCODE_POWEROFF:
    TrackManager::setPower(POWERMODE::OFF);
    TrackManager::setJoin(false);
-    CommandDistributor::broadcastPower();
    break;
  
  case OPCODE_SET_POWER:
@@ -655,6 +667,45 @@ void RMFT2::loop2() {
      }
      break; 

+  case OPCODE_SETFREQ:
+      // Frequency is default 0, or 1, 2,3
+      //if (loco) DCC::setFn(loco,operand,true);
+      switch (operand) {
+        case 0:  // default - all F-s off
+            if (loco) {
+                DCC::setFn(loco,29,false);
+                DCC::setFn(loco,30,false);
+                DCC::setFn(loco,31,false);
+            }
+        break;
+        case 1:
+            if (loco) {
+	      DCC::setFn(loco,29,true);
+              DCC::setFn(loco,30,false);
+              DCC::setFn(loco,31,false);
+            }
+        break;
+        case 2:
+            if (loco) {
+	      DCC::setFn(loco,29,false);
+              DCC::setFn(loco,30,true);
+              DCC::setFn(loco,31,false);
+            }
+        break;
+        case 3:
+            if (loco) {
+	      DCC::setFn(loco,29,false);
+              DCC::setFn(loco,30,false);
+              DCC::setFn(loco,31,true);
+            }
+        break;
+      default:
+	; // do nothing
+	break;
+      }
+
+      break;
+
  case OPCODE_RESUME:
    pausingTask=NULL;
    driveLoco(speedo);
@@ -823,12 +874,10 @@ void RMFT2::loop2() {
  case OPCODE_JOIN:
    TrackManager::setPower(POWERMODE::ON);
    TrackManager::setJoin(true);
-    CommandDistributor::broadcastPower();
    break;

  case OPCODE_UNJOIN:
    TrackManager::setJoin(false);
-    CommandDistributor::broadcastPower();
    break;

  case OPCODE_READ_LOCO1: // READ_LOCO is implemented as 2 separate opcodes
@@ -856,7 +905,6 @@ void RMFT2::loop2() {
  case OPCODE_POWERON:
    TrackManager::setMainPower(POWERMODE::ON);
    TrackManager::setJoin(false);
-    CommandDistributor::broadcastPower();
    break;
    
  case OPCODE_START:
@@ -932,6 +980,37 @@ void RMFT2::loop2() {
  case OPCODE_ROUTE_ACTIVE:
    manageRouteState(operand,1);
    break;   
+  case OPCODE_ROUTE_DISABLED:
+    manageRouteState(operand,4);
+    break;   
+
+  case OPCODE_STASH:
+    if (compileFeatures & FEATURE_STASH) 
+      stashArray[operand] = invert? -loco : loco;
+    break; 
+
+  case OPCODE_CLEAR_STASH:
+    if (compileFeatures & FEATURE_STASH) 
+      stashArray[operand] = 0;
+    break; 
+       
+  case OPCODE_CLEAR_ALL_STASH:
+    if (compileFeatures & FEATURE_STASH) 
+      for (int i=0;i<=maxStashId;i++) stashArray[operand]=0;
+    break;
+
+  case OPCODE_PICKUP_STASH:
+    if (compileFeatures & FEATURE_STASH) {
+      int16_t x=stashArray[operand];
+      if (x>=0) {
+        loco=x;
+        invert=false;
+        break;
+      }
+      loco=-x;
+      invert=true;
+    }
+    break;
  
  case OPCODE_ROUTE:
  case OPCODE_AUTOMATION:
--- a/EXRAIL2.h
+++ b/EXRAIL2.h
@@ -51,7 +51,7 @@ 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,
@@ -69,6 +69,8 @@ enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,
             OPCODE_LCC,OPCODE_LCCX,OPCODE_ONLCC,
             OPCODE_ONOVERLOAD,
             OPCODE_ROUTE_ACTIVE,OPCODE_ROUTE_INACTIVE,OPCODE_ROUTE_HIDDEN,
+             OPCODE_ROUTE_DISABLED,
+             OPCODE_STASH,OPCODE_CLEAR_STASH,OPCODE_CLEAR_ALL_STASH,OPCODE_PICKUP_STASH,

             // OPcodes below this point are skip-nesting IF operations
             // placed here so that they may be skipped as a group
@@ -101,6 +103,7 @@ enum thrunger: byte {
  static const byte FEATURE_LCC   = 0x40;
  static const byte FEATURE_ROSTER= 0x20;
  static const byte FEATURE_ROUTESTATE= 0x10;
+  static const byte FEATURE_STASH = 0x08;
  
 
  // Flag bits for status of hardware and TPL
@@ -202,7 +205,7 @@ private:
    uint16_t getOperand(byte n); 
    
   static bool diag;
-   static const  HIGHFLASH  byte RouteCode[];
+   static const  HIGHFLASH3  byte RouteCode[];
   static const  HIGHFLASH  int16_t SignalDefinitions[];
   static byte flags[MAX_FLAGS];
   static Print * LCCSerial;
@@ -228,6 +231,8 @@ private:
   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 
--- a/EXRAIL2MacroReset.h
+++ b/EXRAIL2MacroReset.h
@@ -39,6 +39,8 @@
 #undef AUTOSTART
 #undef BROADCAST
 #undef CALL 
+#undef CLEAR_STASH
+#undef CLEAR_ALL_STASH
 #undef CLOSE 
 #undef DCC_SIGNAL
 #undef DCC_TURNTABLE
@@ -108,6 +110,7 @@
 #undef ONCHANGE
 #undef PARSE
 #undef PAUSE
+#undef PICKUP_STASH
 #undef PIN_TURNOUT 
 #undef PRINT
 #ifndef DISABLE_PROG
@@ -129,6 +132,7 @@
 #undef ROUTE_ACTIVE
 #undef ROUTE_INACTIVE
 #undef ROUTE_HIDDEN
+#undef ROUTE_DISABLED
 #undef ROUTE_CAPTION
 #undef SENDLOCO 
 #undef SEQUENCE 
@@ -147,10 +151,13 @@
 #undef SET_TRACK
 #undef SET_POWER
 #undef SETLOCO 
+#undef SETFREQ
 #undef SIGNAL 
 #undef SIGNALH 
 #undef SPEED 
 #undef START 
+#undef STASH
+#undef STEALTH
 #undef STOP 
 #undef THROW
 #undef TT_ADDPOSITION
@@ -183,7 +190,9 @@
 #define AUTOMATION(id,description) 
 #define AUTOSTART
 #define BROADCAST(msg)
-#define CALL(route) 
+#define CALL(route)
+#define CLEAR_STASH(id)
+#define CLEAR_ALL_STASH(id)
 #define CLOSE(id) 
 #define DCC_SIGNAL(id,add,subaddr)
 #define DCC_TURNTABLE(id,home,description)
@@ -255,6 +264,7 @@
 #define PIN_TURNOUT(id,pin,description...) 
 #define PRINT(msg) 
 #define PARSE(msg)
+#define PICKUP_STASH(id)
 #ifndef DISABLE_PROG
 #define POM(cv,value)
 #endif
@@ -274,6 +284,7 @@
 #define ROUTE_ACTIVE(id)
 #define ROUTE_INACTIVE(id)
 #define ROUTE_HIDDEN(id)
+#define ROUTE_DISABLED(id)
 #define ROUTE_CAPTION(id,caption)
 #define SENDLOCO(cab,route) 
 #define SEQUENCE(id) 
@@ -292,10 +303,13 @@
 #define SET_TRACK(track,mode)
 #define SET_POWER(track,onoff)
 #define SETLOCO(loco) 
+#define SETFREQ(loco,freq)
 #define SIGNAL(redpin,amberpin,greenpin) 
 #define SIGNALH(redpin,amberpin,greenpin) 
 #define SPEED(speed) 
-#define START(route) 
+#define START(route)
+#define STASH(id) 
+#define STEALTH(code...)
 #define STOP 
 #define THROW(id)
 #define TT_ADDPOSITION(turntable_id,position,value,angle,description...)
--- a/EXRAIL2Parser.cpp
+++ b/EXRAIL2Parser.cpp
@@ -44,7 +44,9 @@ 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';
+const int16_t HASH_KEYWORD_A='A';   
+const int16_t HASH_KEYWORD_M='M';
+

 // This filter intercepts <> commands to do the following:
 // - Implement RMFT specific commands/diagnostics
@@ -149,7 +151,33 @@ void RMFT2::ComandFilter(Print * stream, byte & opcode, byte & paramCount, int16
              opcode=0;
              return;
            }
-            break;  
+            break;
+        case HASH_KEYWORD_M:
+            // NOTE: we only need to handle valid calls here because 
+            // DCCEXParser has to have code to handle the <J<> cases where
+            // exrail isnt involved anyway. 
+            // This entire code block is compiled out if STASH macros not used 
+          if (!(compileFeatures & FEATURE_STASH)) return;
+          if (paramCount==1) { // <JM>
+              StringFormatter::send(stream,F("<jM %d>\n"),maxStashId);
+              opcode=0;
+              break;
+            } 
+          if (paramCount==2) {  // <JM id>
+              if (p[1]<=0 || p[1]>maxStashId) break;
+              StringFormatter::send(stream,F("<jM %d %d>\n"),
+                    p[1],stashArray[p[1]]);
+               opcode=0;     
+               break;    
+          } 
+          if (paramCount==3) {  // <JM id cab>
+              if (p[1]<=0 || p[1]>maxStashId) break;
+              stashArray[p[1]]=p[2];
+              opcode=0;
+              break;      
+          }
+          break; 
+
        default:
            break;
        }
@@ -195,6 +223,15 @@ bool RMFT2::parseSlash(Print * stream, byte & paramCount, int16_t p[]) {
          sigid & SIGNAL_ID_MASK); 
      } 
    }
+
+    if (compileFeatures & FEATURE_STASH) {
+      for (int i=1;i<=maxStashId;i++) {
+        if (stashArray[i])
+          StringFormatter::send(stream,F("\nSTASH[%d] Loco=%d"),
+              i, stashArray[i]); 
+      } 
+    }
+    
    StringFormatter::send(stream,F(" *>\n"));
    return true;
  }
--- a/EXRAILMacros.h
+++ b/EXRAILMacros.h
@@ -108,9 +108,20 @@ void exrailHalSetup() {
 #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 CLEAR_STASH
+#define CLEAR_STASH(id) | FEATURE_STASH
+#undef CLEAR_ALL_STASH
+#define CLEAR_ALL_STASH | FEATURE_STASH
+#undef PICKUP_STASH
+#define PICKUP_STASH(id) | FEATURE_STASH
+#undef STASH
+#define STASH(id) | FEATURE_STASH
+
 const byte RMFT2::compileFeatures = 0
   #include "myAutomation.h"
 ;
@@ -119,7 +130,7 @@ const byte RMFT2::compileFeatures = 0
 #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 
@@ -199,6 +210,8 @@ case (__COUNTER__ - StringMacroTracker1) : {\
         lcdid=id;\
         break;\
      } 
+#undef STEALTH
+#define STEALTH(code...) case (__COUNTER__ - StringMacroTracker1) : {code} return; 
 #undef WITHROTTLE
 #define WITHROTTLE(msg) THRUNGE(msg,thrunge_withrottle)

@@ -351,6 +364,8 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
 #define AUTOSTART OPCODE_AUTOSTART,0,0,
 #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 CLOSE(id)  OPCODE_CLOSE,V(id),
 #ifndef IO_NO_HAL
 #define DCC_TURNTABLE(id,home,description...) OPCODE_DCCTURNTABLE,V(id),OPCODE_PAD,V(home),
@@ -409,6 +424,7 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
        OPCODE_PAD,V((((uint64_t)sender)>>0)&0xFFFF),  
 #define LCD(id,msg) PRINT(msg)
 #define SCREEN(display,id,msg) PRINT(msg)
+#define STEALTH(code...) PRINT(dummy)
 #define LCN(msg) PRINT(msg)
 #define MOVETT(id,steps,activity) OPCODE_SERVO,V(id),OPCODE_PAD,V(steps),OPCODE_PAD,V(EXTurntable::activity),OPCODE_PAD,V(0),
 #define ONACTIVATE(addr,subaddr) OPCODE_ONACTIVATE,V(addr<<2|subaddr),
@@ -433,6 +449,7 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
 #define ONTHROW(turnout_id) OPCODE_ONTHROW,V(turnout_id),
 #define ONCHANGE(sensor_id) OPCODE_ONCHANGE,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),
@@ -457,6 +474,7 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
 #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), 
@@ -475,10 +493,12 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
 #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(loco,freq) OPCODE_SETLOCO,V(loco), 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),
 #ifndef IO_NO_HAL
@@ -500,7 +520,7 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];

 // 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 };

--- a/FSH.h
+++ b/FSH.h
@@ -56,6 +56,7 @@ typedef __FlashStringHelper FSH;
 #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)
@@ -63,6 +64,7 @@ typedef __FlashStringHelper FSH;
 // 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))
@@ -80,6 +82,7 @@ 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))
--- a/GITHUB_SHA.h
+++ b/GITHUB_SHA.h
@@ -1 +1 @@
-#define GITHUB_SHA "devel-202311160737Z"
+#define GITHUB_SHA "devel-202401202235Z"
--- a/I2CManager_STM32.h
+++ b/I2CManager_STM32.h
@@ -110,7 +110,7 @@ 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;
+  //uint32_t ccr_freq;

  while (s->CR1 & I2C_CR1_STOP);  // Prevents lockup by guarding further
                                  // writes to CR1 while STOP is being executed!
--- a/IODevice.h
+++ b/IODevice.h
@@ -542,8 +542,10 @@ protected:
 #include "IO_MCP23017.h"
 #include "IO_PCF8574.h"
 #include "IO_PCF8575.h"
+#include "IO_PCA9555.h"
 #include "IO_duinoNodes.h"
 #include "IO_EXIOExpander.h"
+#include "IO_trainbrains.h"


 #endif // iodevice_h
--- a/IO_EXIOExpander.h
+++ b/IO_EXIOExpander.h
@@ -22,13 +22,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 +95,30 @@ 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);
+              _digitalInputStates = (byte*) calloc(_digitalPinBytes, 1);
+              _digitalPinBytes = digitalBytesNeeded;
+            }
+          }
+          
+          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);
+              _analoguePinBytes = analogueBytesNeeded;
            }
-            _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 +126,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 +241,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 (currentMicros - _lastDigitalRead > _digitalRefresh && _numDigitalPins>0) { // 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 +249,7 @@ private:
                                                                // non-blocking read
        _lastDigitalRead = currentMicros;
        _readState = RDS_DIGITAL;
-      } else if (currentMicros - _lastAnalogueRead > _analogueRefresh) { // Delay for analogue read refresh
+      } else if (currentMicros - _lastAnalogueRead > _analogueRefresh && _numAnaloguePins>0) { // Delay for analogue read refresh
        // Issue new read for analogue input states
        _readCommandBuffer[0] = EXIORDAN;
        I2CManager.read(_I2CAddress, _analogueInputBuffer,
--- a/IO_trainbrains.h
+++ b/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
--- a/MotorDriver.cpp
+++ b/MotorDriver.cpp
@@ -325,49 +325,23 @@ 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);
+  if (invertBrake)
+    brake=255-brake;
+
+  { // 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 +349,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 freqency %d"), brakePin, f);
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, f); // set DC PWM frequency
+    DCCTimer::DCCEXanalogWrite(brakePin,brake);
+#else // all AVR here
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, frequency); // frequency steps
+    analogWrite(brakePin,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();
@@ -436,58 +406,26 @@ void MotorDriver::throttleInrush(bool on) {
    return;
  if ( !(trackMode & (TRACK_MODE_MAIN | TRACK_MODE_PROG | TRACK_MODE_EXT)))
    return;
-  byte duty = on ? 208 : 0;
+  byte duty = on ? 207 : 0; // duty of 81% at 62500Hz this gives pauses of 3usec
  if (invertBrake)
    duty = 255-duty;
 #if defined(ARDUINO_ARCH_ESP32)
  if(on) {
    DCCTimer::DCCEXanalogWrite(brakePin,duty);
-    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 62500);
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 7); // 7 means max
  } else {
    ledcDetachPin(brakePin);
  }
 #elif defined(ARDUINO_ARCH_STM32)
  if(on) {
-    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 62500);
+    DCCTimer::DCCEXanalogWriteFrequency(brakePin, 7); // 7 means max
    DCCTimer::DCCEXanalogWrite(brakePin,duty);
  } else {
    pinMode(brakePin, OUTPUT);
  }
-#else
+#else // all AVR here
  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
--- a/MotorDriver.h
+++ b/MotorDriver.h
@@ -156,8 +156,10 @@ class MotorDriver {
    // from outside interrupt
    void setBrake( bool on, bool interruptContext=false);
    __attribute__((always_inline)) inline void setSignal( bool high) {
+#ifndef ARDUINO_ARCH_ESP32
      if (invertPhase)
 	high = !high;
+#endif
      if (trackPWM) {
 	DCCTimer::setPWM(signalPin,high);
      }
@@ -185,7 +187,7 @@ class MotorDriver {
      }
    };
    inline pinpair getSignalPin() { return pinpair(signalPin,signalPin2); };
-    void setDCSignal(byte speedByte);
+    void setDCSignal(byte speedByte, uint8_t frequency=0);
    void throttleInrush(bool on);
    inline void detachDCSignal() {
 #if defined(__arm__)
--- a/StringFormatter.cpp
+++ b/StringFormatter.cpp
@@ -39,21 +39,28 @@ void StringFormatter::diag( const FSH* input...) {

 void StringFormatter::lcd(byte row, const FSH* input...) {
  va_list args;
-
-  // Issue the LCD as a diag first
-  send(&USB_SERIAL,F("<* LCD%d:"),row);
-  va_start(args, input);
-  send2(&USB_SERIAL,input,args);
-  send(&USB_SERIAL,F(" *>\n"));
-  
-  // send to virtual LCD collector (if any) 
+#ifndef DISABLE_VDPY
  Print * virtualLCD=CommandDistributor::getVirtualLCDSerial(0,row);
+#else
+  Print * virtualLCD=NULL;
+#endif
+  // Issue the LCD as a diag first
+  // Unless the same serial is asking for the virtual @ respomnse
+  if (virtualLCD!=&USB_SERIAL) {
+    send(&USB_SERIAL,F("<* LCD%d:"),row);
+    va_start(args, input);
+    send2(&USB_SERIAL,input,args);
+    send(&USB_SERIAL,F(" *>\n"));
+  }
+  
+#ifndef DISABLE_VDPY
+  // send to virtual LCD collector (if any) 
  if (virtualLCD) {
    va_start(args, input);
    send2(virtualLCD,input,args);
    CommandDistributor::commitVirtualLCDSerial();
  }
-
+#endif
  DisplayInterface::setRow(row);    
  va_start(args, input);
  send2(DisplayInterface::getDisplayHandler(),input,args);
@@ -63,12 +70,14 @@ void StringFormatter::lcd2(uint8_t display, byte row, const FSH* input...) {
  va_list args;
  
   // send to virtual LCD collector (if any) 
+#ifndef DISABLE_VDPY
  Print * virtualLCD=CommandDistributor::getVirtualLCDSerial(display,row);
  if (virtualLCD) {
    va_start(args, input);
    send2(virtualLCD,input,args);
    CommandDistributor::commitVirtualLCDSerial();
  }
+#endif

  DisplayInterface::setRow(display, row);    
  va_start(args, input);
@@ -247,4 +256,3 @@ void StringFormatter::printHex(Print * stream,uint16_t value) {
    result[4]='\0';
     stream->print(result);
 }
- 
--- a/TrackManager.cpp
+++ b/TrackManager.cpp
@@ -19,6 +19,7 @@
 *  You should have received a copy of the GNU General Public License
 *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
 */
+#include "defines.h"
 #include "TrackManager.h"
 #include "FSH.h"
 #include "DCCWaveform.h"
@@ -54,7 +55,6 @@ const int16_t HASH_KEYWORD_INV = 11857;
 MotorDriver * TrackManager::track[MAX_TRACKS];
 int16_t TrackManager::trackDCAddr[MAX_TRACKS];

-POWERMODE TrackManager::mainPowerGuess=POWERMODE::OFF;
 byte TrackManager::lastTrack=0;
 bool TrackManager::progTrackSyncMain=false; 
 bool TrackManager::progTrackBoosted=false; 
@@ -203,13 +203,16 @@ 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);
+      track[t]->setDCSignal(speedbyte, DCC::getThrottleFrequency(trackDCAddr[t]));
  }
 }    

 bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr) {
    if (trackToSet>lastTrack || track[trackToSet]==NULL) return false;

+    // Remember track mode we came from for later
+    TRACK_MODE oldmode = track[trackToSet]->getMode();
+
    //DIAG(F("Track=%c Mode=%d"),trackToSet+'A', mode);
    // DC tracks require a motorDriver that can set brake!
    if (mode & TRACK_MODE_DC) {
@@ -262,7 +265,7 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
 	  track[t]->setPower(POWERMODE::OFF);
 	  track[t]->setMode(TRACK_MODE_NONE);
 	  track[t]->makeProgTrack(false);     // revoke prog track special handling
-    streamTrackState(NULL,t);
+	  streamTrackState(NULL,t);
 	}
      track[trackToSet]->makeProgTrack(true); // set for prog track special handling
    } else {
@@ -270,7 +273,6 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
    }
    track[trackToSet]->setMode(mode);
    trackDCAddr[trackToSet]=dcAddr;
-    streamTrackState(NULL,trackToSet);

    // When a track is switched, we must clear any side effects of its previous 
    // state, otherwise trains run away or just dont move.
@@ -337,20 +339,21 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
        applyDCSpeed(trackToSet);
    }

-    // Normal running tracks are set to the global power state 
-    track[trackToSet]->setPower(
-      (mode & (TRACK_MODE_MAIN | TRACK_MODE_DC | TRACK_MODE_EXT | TRACK_MODE_BOOST)) ?
-        mainPowerGuess : POWERMODE::OFF);
+    // Turn off power if we changed the mode of this track
+    if (mode != oldmode)
+      track[trackToSet]->setPower(POWERMODE::OFF);
+    streamTrackState(NULL,trackToSet);
+
    //DIAG(F("TrackMode=%d"),mode);
    return true; 
 }

 void TrackManager::applyDCSpeed(byte t) {
-  uint8_t speedByte=DCC::getThrottleSpeedByte(trackDCAddr[t]);
-  track[t]->setDCSignal(speedByte);
+  track[t]->setDCSignal(DCC::getThrottleSpeedByte(trackDCAddr[t]),
+			DCC::getThrottleFrequency(trackDCAddr[t]));
 }

-bool TrackManager::parseJ(Print *stream, int16_t params, int16_t p[])
+bool TrackManager::parseEqualSign(Print *stream, int16_t params, int16_t p[])
 {
    
    if (params==0) { // <=>  List track assignments
@@ -397,46 +400,60 @@ bool TrackManager::parseJ(Print *stream, int16_t params, int16_t p[])
    return false;
 }

-void TrackManager::streamTrackState(Print* stream, byte t) {
-  // null stream means send to commandDistributor for broadcast
-  if (track[t]==NULL) return;
-  auto format=F("<= %d XXX>\n");
-  TRACK_MODE tm = track[t]->getMode();
+const FSH* TrackManager::getModeName(TRACK_MODE tm) {
+  const FSH *modename=F("---");
+  
  if (tm & TRACK_MODE_MAIN) {
    if(tm & TRACK_MODE_AUTOINV)
-      format=F("<= %c MAIN A>\n");
+      modename=F("MAIN A");
    else if (tm & TRACK_MODE_INV)
-      format=F("<= %c MAIN I>\n");
+      modename=F("MAIN I>\n");
    else
-      format=F("<= %c MAIN>\n");
+      modename=F("MAIN");
  }
 #ifndef DISABLE_PROG
  else if (tm & TRACK_MODE_PROG)
-    format=F("<= %c PROG>\n");
+    modename=F("PROG");
 #endif
  else if (tm & TRACK_MODE_NONE)
-    format=F("<= %c NONE>\n");
+    modename=F("NONE");
  else if(tm & TRACK_MODE_EXT)
-    format=F("<= %c EXT>\n");
+    modename=F("EXT");
  else if(tm & TRACK_MODE_BOOST) {
        if(tm & TRACK_MODE_AUTOINV)
-      format=F("<= %c B A>\n");
+      modename=F("B A");
    else if (tm & TRACK_MODE_INV)
-      format=F("<= %c B I>\n");
+      modename=F("B I");
    else
-      format=F("<= %c B>\n");
+      modename=F("B");
  }
  else if (tm & TRACK_MODE_DC) {
    if (tm & TRACK_MODE_INV)
-      format=F("<= %c DCX %d>\n");
+      modename=F("DCX");
    else
-      format=F("<= %c DC %d>\n");
+      modename=F("DC");
  }
+  return modename;
+}

-  if (stream)
-    StringFormatter::send(stream,format,'A'+t, trackDCAddr[t]);
+// null stream means send to commandDistributor for broadcast
+void TrackManager::streamTrackState(Print* stream, byte t) {
+  const FSH *format;
+  
+  if (track[t]==NULL) return;
+  TRACK_MODE tm = track[t]->getMode();
+  if (tm & TRACK_MODE_DC)
+    format=F("<= %c %S %d>\n");
  else
-    CommandDistributor::broadcastTrackState(format,'A'+t, trackDCAddr[t]);
+    format=F("<= %c %S>\n");
+
+  const FSH *modename=getModeName(tm);
+  if (stream) {  // null stream means send to commandDistributor for broadcast
+    StringFormatter::send(stream,format,'A'+t, modename, trackDCAddr[t]);
+  } else {
+    CommandDistributor::broadcastTrackState(format,'A'+t, modename, trackDCAddr[t]);
+    CommandDistributor::broadcastPower();
+  }
  
 }

@@ -472,12 +489,16 @@ std::vector<MotorDriver *>TrackManager::getMainDrivers() {
 #endif

 // Set track power for all tracks with this mode
-void TrackManager::setTrackPower(TRACK_MODE trackmode, POWERMODE powermode) {
+void TrackManager::setTrackPower(TRACK_MODE trackmodeToMatch, POWERMODE powermode) {
+  bool didChange=false;
  FOR_EACH_TRACK(t) {
-    MotorDriver *driver=track[t]; 
-    if (trackmode & driver->getMode()) {
+    MotorDriver *driver=track[t];
+    TRACK_MODE trackmodeOfTrack = driver->getMode();
+    if (trackmodeToMatch & trackmodeOfTrack) {
+      if (powermode != driver->getPower())
+	didChange=true;
      if (powermode == POWERMODE::ON) {
-	if (trackmode & TRACK_MODE_DC) {
+	if (trackmodeOfTrack & TRACK_MODE_DC) {
 	  driver->setBrake(true);   // DC starts with brake on
 	  applyDCSpeed(t);          // speed match DCC throttles
 	} else {
@@ -490,18 +511,24 @@ void TrackManager::setTrackPower(TRACK_MODE trackmode, POWERMODE powermode) {
      driver->setPower(powermode);
    }
  }
+  if (didChange)
+    CommandDistributor::broadcastPower();
 }

 // 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) {
+  POWERMODE oldpower = driver->getPower();
+  if (trackmode & TRACK_MODE_NONE) {
+    driver->setBrake(true);     // Track is unused. Brake is good to have.
+    powermode = POWERMODE::OFF; // Track is unused. Force it to OFF
+  } else if (trackmode & TRACK_MODE_DC) { // includes inverted DC (called DCX)
    if (powermode == POWERMODE::ON) {
      driver->setBrake(true);   // DC starts with brake on
      applyDCSpeed(t);          // speed match DCC throttles
    }
-  } else {
+  } else /* MAIN PROG EXT BOOST */ {
    if (powermode == POWERMODE::ON) {
      // toggle brake before turning power on - resets overcurrent error
      // on the Pololu board if brake is wired to ^D2.
@@ -510,15 +537,8 @@ void TrackManager::setTrackPower(POWERMODE powermode, byte t) {
    }
  }
  driver->setPower(powermode);
-}
-
-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>
-  int maxCurrent=track[0]->raw2mA(track[0]->getRawCurrentTripValue());
-  StringFormatter::send(stream, F("<c CurrentMAIN %d C Milli 0 %d 1 %d>\n"), 
-            track[0]->raw2mA(track[0]->getCurrentRaw(false)), maxCurrent, maxCurrent);                  
+  if (oldpower != driver->getPower())
+    CommandDistributor::broadcastPower();
 }

 // returns state of the one and only prog track
@@ -555,14 +575,17 @@ bool TrackManager::getPower(byte t, char s[]) {
  return false;
 }

-
 void TrackManager::reportObsoleteCurrent(Print* stream) {
  // 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>
+#ifdef HAS_ENOUGH_MEMORY
  int maxCurrent=track[0]->raw2mA(track[0]->getRawCurrentTripValue());
  StringFormatter::send(stream, F("<c CurrentMAIN %d C Milli 0 %d 1 %d>\n"), 
-            track[0]->raw2mA(track[0]->getCurrentRaw(false)), maxCurrent, maxCurrent);                  
+            track[0]->raw2mA(track[0]->getCurrentRaw(false)), maxCurrent, maxCurrent);
+#else
+  (void)stream;
+#endif
 }

 void TrackManager::reportCurrent(Print* stream) {
@@ -630,7 +653,7 @@ bool TrackManager::isProg(byte t) {
    return false;
 }

-byte TrackManager::returnMode(byte t) {
+TRACK_MODE TrackManager::getMode(byte t) {
    return (track[t]->getMode());
 }

@@ -638,18 +661,3 @@ int16_t TrackManager::returnDCAddr(byte t) {
    return (trackDCAddr[t]);
 }

-const char* TrackManager::getModeName(byte Mode) {
-  
-  //DIAG(F("PowerMode %d"), Mode);
-
-switch (Mode)
-  {
-  case 1: return "NONE";
-  case 2: return "MAIN";
-  case 4: return "PROG";
-  case 8: return "DC";
-  case 16: return "DCX";
-  case 32: return "EXT";
-  default: return "----";
-  }
-}
--- a/TrackManager.h
+++ b/TrackManager.h
@@ -73,25 +73,28 @@ class TrackManager {

    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 bool parseEqualSign(Print * stream,  int16_t params, int16_t p[]);
    static void loop();
    static POWERMODE getMainPower();
    static POWERMODE getProgPower();
+    static inline POWERMODE getPower(byte t) { return track[t]->getPower(); }
    static bool getPower(byte t, char s[]);
    static void setJoin(bool join);
    static bool isJoined() { return progTrackSyncMain;}
+    static inline bool isActive (byte tr) {
+      if (tr > lastTrack) return false;
+      return track[tr]->getMode() & (TRACK_MODE_MAIN|TRACK_MODE_PROG|TRACK_MODE_DC|TRACK_MODE_BOOST|TRACK_MODE_EXT);}
    static void setJoinRelayPin(byte joinRelayPin);
    static void sampleCurrent();
    static void reportGauges(Print* stream);
    static void reportCurrent(Print* stream);
-    static void reportPowerChange(Print* stream, byte thistrack);
    static void reportObsoleteCurrent(Print* stream); 
    static void streamTrackState(Print* stream, byte t);
    static bool isPowerOn(byte t);
    static bool isProg(byte t);
-    static byte returnMode(byte t);
+    static TRACK_MODE getMode(byte t);
    static int16_t returnDCAddr(byte t);
-    static const char* getModeName(byte Mode);
+    static const FSH* getModeName(TRACK_MODE Mode);

    static int16_t joinRelay;
    static bool progTrackSyncMain;  // true when prog track is a siding switched to main
@@ -108,7 +111,6 @@ class TrackManager {
    static void addTrack(byte t, MotorDriver* driver);
    static byte lastTrack;
    static byte nextCycleTrack;
-    static POWERMODE mainPowerGuess;
    static void applyDCSpeed(byte t);

    static int16_t trackDCAddr[MAX_TRACKS];  // dc address if TRACK_MODE_DC
--- a/WiThrottle.cpp
+++ b/WiThrottle.cpp
@@ -150,7 +150,6 @@ void WiThrottle::parse(RingStream * stream, byte * cmdx) {
 	  DCCWaveform::progTrack.setPowerMode(cmd[3]=='1'?POWERMODE::ON:POWERMODE::OFF);
 */

-	CommandDistributor::broadcastPower();
      }
 #if defined(EXRAIL_ACTIVE)
      else if (cmd[1]=='R' && cmd[2]=='A' && cmd[3]=='2' ) { // Route activate
@@ -496,7 +495,6 @@ void WiThrottle::getLocoCallback(int16_t locoid) {
  TrackManager::setJoin(true);          // <1 JOIN> so we can drive loco away
  DIAG(F("LocoCallback commit success"));
  stashStream->commit();
-  CommandDistributor::broadcastPower();
 }

 void WiThrottle::sendIntro(Print* stream) {
@@ -620,7 +618,7 @@ void WiThrottle::sendFunctions(Print* stream, byte loco) {
 #endif
 	
 	for(int fKey=0; fKey<fkeys; fKey++) { 
-      int fstate=DCC::getFn(locoid,fKey);
+      int8_t fstate=DCC::getFn(locoid,fKey);
      if (fstate>=0) StringFormatter::send(stream,F("M%cA%c%d<;>F%d%d\n"),myLocos[loco].throttle,LorS(locoid),locoid,fstate,fKey);                     
 	}
 }
--- a/WifiESP32.cpp
+++ b/WifiESP32.cpp
@@ -74,25 +74,39 @@ class NetworkClient {
 public:
  NetworkClient(WiFiClient c) {
    wifi = c;
-  };
-  bool ok() {
-    return (inUse && wifi.connected());
-  };
-  bool recycle(WiFiClient c) {
-
-    if (inUse == true) return false;
-
-    // return false here until we have
-    // implemented a LRU timer
-    // if (LRU too recent) return false;
-    return false;
-
-    wifi = c;
    inUse = true;
+  };
+  bool active(byte clientId) {
+    if (!inUse)
+      return false;
+    if(!wifi.connected()) {
+      DIAG(F("Remove client %d"), clientId);
+      CommandDistributor::forget(clientId);
+      wifi.stop();
+      inUse = false;
+      return false;
+    }
    return true;
+  }
+  bool recycle(WiFiClient c) {
+    if (wifi == c) {
+      if (inUse == true)
+	DIAG(F("WARNING: Duplicate"));
+      else
+	DIAG(F("Returning"));
+      inUse = true;
+      return true;
+    }
+    if (inUse == false) {
+      wifi = c;
+      inUse = true;
+      return true;
+    }
+    return false;
  };
  WiFiClient wifi;
-  bool inUse = true;
+private:
+  bool inUse;
 };

 static std::vector<NetworkClient> clients; // a list to hold all clients
@@ -163,7 +177,9 @@ bool WifiESP::setup(const char *SSid,
      delay(500);
    }
    if (WiFi.status() == WL_CONNECTED) {
-      DIAG(F("Wifi STA IP %s"),WiFi.localIP().toString().c_str());
+      // DIAG(F("Wifi STA IP %s"),WiFi.localIP().toString().c_str());
+      DIAG(F("Wifi in STA mode"));
+      LCD(7, F("IP: %s"), WiFi.localIP().toString().c_str());
      wifiUp = true;
    } else {
      DIAG(F("Could not connect to Wifi SSID %s"),SSid);
@@ -209,8 +225,12 @@ bool WifiESP::setup(const char *SSid,
    if (WiFi.softAP(strSSID.c_str(),
 		    havePassword ? password : strPass.c_str(),
 		    channel, false, 8)) {
-      DIAG(F("Wifi AP SSID %s PASS %s"),strSSID.c_str(),havePassword ? password : strPass.c_str());
-      DIAG(F("Wifi AP IP %s"),WiFi.softAPIP().toString().c_str());
+      // DIAG(F("Wifi AP SSID %s PASS %s"),strSSID.c_str(),havePassword ? password : strPass.c_str());
+      DIAG(F("Wifi in AP mode"));
+      LCD(5, F("Wifi: %s"), strSSID.c_str());
+      LCD(6, F("PASS: %s"),havePassword ? password : strPass.c_str());
+      // DIAG(F("Wifi AP IP %s"),WiFi.softAPIP().toString().c_str());
+      LCD(7, F("IP: %s"),WiFi.softAPIP().toString().c_str());
      wifiUp = true;
      APmode = true;
    } else {
@@ -276,37 +296,26 @@ void WifiESP::loop() {
  // really no good way to check for LISTEN especially in AP mode?
  wl_status_t wlStatus;
  if (APmode || (wlStatus = WiFi.status()) == WL_CONNECTED) {
-    // loop over all clients and remove inactive
-    for (clientId=0; clientId<clients.size(); clientId++){
-      // check if client is there and alive
-      if(clients[clientId].inUse && !clients[clientId].wifi.connected()) {
-	DIAG(F("Remove client %d"), clientId);
-	CommandDistributor::forget(clientId);
-	clients[clientId].wifi.stop();
-	clients[clientId].inUse = false;
-	//Do NOT clients.erase(clients.begin()+clientId) as
-	//that would mix up clientIds for later.
-      }
-    }
    if (server->hasClient()) {
      WiFiClient client;
      while (client = server->available()) {
 	for (clientId=0; clientId<clients.size(); clientId++){
 	  if (clients[clientId].recycle(client)) {
-	    DIAG(F("Recycle client %d %s"), clientId, client.remoteIP().toString().c_str());
+	    DIAG(F("Recycle client %d %s:%d"), clientId, client.remoteIP().toString().c_str(),client.remotePort());
 	    break;
 	  }
 	}
 	if (clientId>=clients.size()) {
 	  NetworkClient nc(client);
 	  clients.push_back(nc);
-	  DIAG(F("New client %d, %s"), clientId, client.remoteIP().toString().c_str());
+	  DIAG(F("New client %d, %s:%d"), clientId, client.remoteIP().toString().c_str(),client.remotePort());
 	}
      }
    }
    // loop over all connected clients
+    // this removes as a side effect inactive clients when checking ::active()
    for (clientId=0; clientId<clients.size(); clientId++){
-      if(clients[clientId].ok()) {
+      if(clients[clientId].active(clientId)) {
 	int len;
 	if ((len = clients[clientId].wifi.available()) > 0) {
 	  // read data from client
@@ -344,7 +353,7 @@ void WifiESP::loop() {
 	}
 	// buffer filled, end with '\0' so we can use it as C string
 	buffer[count]='\0';
-	if((unsigned int)clientId <= clients.size() && clients[clientId].ok()) {
+	if((unsigned int)clientId <= clients.size() && clients[clientId].active(clientId)) {
 	  if (Diag::CMD || Diag::WITHROTTLE)
 	    DIAG(F("SEND %d:%s"), clientId, buffer);
 	  clients[clientId].wifi.write(buffer,count);
@@ -377,8 +386,9 @@ void WifiESP::loop() {
  // prio task. On core1 this is not a problem
  // as there the wdt is disabled by the
  // arduio IDE startup routines.
-  if (xPortGetCoreID() == 0)
+  if (xPortGetCoreID() == 0) {
    feedTheDog0();
-  yield();
+    yield();
+  }
 }
 #endif //ESP32
--- a/WifiInterface.cpp
+++ b/WifiInterface.cpp
@@ -68,7 +68,9 @@ Stream * WifiInterface::wifiStream;
 #define NUM_SERIAL 3
 #define SERIAL1 Serial3
 #define SERIAL3 Serial5
-#elif defined(ARDUINO_NUCLEO_F413ZH) || defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F446ZE) || defined(ARDUINO_NUCLEO_F412ZG)
+#elif defined(ARDUINO_NUCLEO_F413ZH) || defined(ARDUINO_NUCLEO_F429ZI) \
+    || defined(ARDUINO_NUCLEO_F446ZE) || defined(ARDUINO_NUCLEO_F412ZG) \
+    || defined(ARDUINO_NUCLEO_F439ZI)
 #define NUM_SERIAL 2
 #define SERIAL1 Serial6
 #else
--- a/config.example.h
+++ b/config.example.h
@@ -199,6 +199,18 @@ The configuration file for DCC-EX Command Station
 //
 // #define DISABLE_PROG

+/////////////////////////////////////////////////////////////////////////////////////
+// DISABLE / ENABLE VDPY
+//
+// The Virtual display "VDPY" feature is by default enabled everywhere
+// but on Uno and Nano. If you think you can fit it (for example
+// having disabled some of the features above) you can enable it with
+// ENABLE_VDPY. You can even disable it on all other CPUs with
+// DISABLE_VDPY
+//
+// #define DISABLE_VDPY
+// #define ENABLE_VDPY
+
 /////////////////////////////////////////////////////////////////////////////////////
 // REDEFINE WHERE SHORT/LONG ADDR break is. According to NMRA the last short address
 // is 127 and the first long address is 128. There are manufacturers which have
--- a/defines.h
+++ b/defines.h
@@ -219,11 +219,10 @@
 // The HAL is disabled by default on Nano and Uno platforms, because of limited flash space.
 // 
 #if defined(ARDUINO_AVR_NANO) || defined(ARDUINO_AVR_UNO)
-  #if defined(DISABLE_DIAG) && defined(DISABLE_EEPROM) && defined(DISABLE_PROG)
-    #warning you have sacrificed DIAG for HAL
-  #else
-    #define IO_NO_HAL
-  #endif
+#define IO_NO_HAL // HAL too big whatever you disable otherwise
+#ifndef ENABLE_VDPY
+#define DISABLE_VDPY
+#endif
 #endif

 #if __has_include ( "myAutomation.h")
--- a/version.h
+++ b/version.h
@@ -3,7 +3,33 @@

 #include "StringFormatter.h"

-#define VERSION "5.2.3"
+#define VERSION "5.2.XX"
+// 5.2.XX - Variable frequency for DC mode
+// 5.2.18 - Display network IP fix
+// 5.2.17 - ESP32 simplify network logic
+// 5.2.16 - Bugfix to allow for devices using the EX-IOExpander protocol to have no analogue or no digital pins
+// 5.2.15 - move call to CommandDistributor::broadcastPower() into the TrackManager::setTrackPower(*) functions
+//        - add repeats to function packets that are not reminded in accordance with accessory packets
+// 5.2.14 - Reminder window DCC packet optimization
+//        - Optional #define DISABLE_FUNCTION_REMINDERS 
+// 5.2.13 - EXRAIL STEALTH 
+// 5.2.12 - ESP32 add AP mode LCD messages with SSID/PW for
+//        - STM32 change to UID_BASE constants in DCCTimerSTM32 rather than raw hex addresses for UID registers
+//        - STM32 extra UART/USARTs for larger Nucleo models
+// 5.2.11 - Change from TrackManager::returnMode to TrackManager::getMode
+// 5.2.10 - Include trainbrains.eu block unoccupancy driver
+//        - include IO_PCA9555  
+// 5.2.9  - Bugfix LCD startup with no LCD, uses <@
+// 5.2.9  - EXRAIL STASH feature 
+// 5.2.8  - Bugfix: Do not turn off all tracks on change
+//          give better power messages
+// 5.2.7  - Bugfix: EXRAIL ling segment
+//        - Bugfix: Back out wrongly added const
+//        - Bugfix ESP32: Do not inverse DCX direction signal twice
+// 5.2.6  - Trackmanager broadcast power state on track mode change
+// 5.2.5  - Trackmanager: Do not treat TRACK_MODE_ALL as TRACK_MODE_DC
+// 5.2.4  - LCD macro will not do diag if that duplicates @ to same target.
+//        - Added ROUTE_DISABLED macro in EXRAIL
 // 5.2.3  - Bugfix: Catch stange input to parser
 // 5.2.2  - Added option to allow MAX_CHARACTER_ROWS to be defined in config.h
 // 5.2.1  - Trackmanager rework for simpler structure
Author	SHA1	Message	Date
Harald Barth	daa2ffc459	tag	2024-01-20 23:36:11 +01:00
Harald Barth	9728d19b19	eliminate warning	2024-01-20 23:35:30 +01:00
Harald Barth	99a09c713f	To make usage easier, use F29 to F31 for frequencies	2024-01-20 23:34:17 +01:00
Colin Murdoch	a5b73c823a	Added SETFREQ command Added SETFREQ command to EXRAIL	2024-01-20 18:09:03 +00:00
Harald Barth	8036ba1c48	temp version tag	2024-01-03 02:44:15 +01:00
Harald Barth	6f076720f7	temp version tag	2024-01-01 22:17:47 +01:00
Harald Barth	d899da5898	Make return type of DCC::getFn int8_t	2024-01-01 22:08:59 +01:00
Harald Barth	3ce9d2ec88	DC frequency fix broadcast messages step #7	2024-01-01 22:08:04 +01:00
Harald Barth	9ebb1c5fb1	less debug diag	2024-01-01 21:25:43 +01:00
Harald Barth	19efa749b8	Typo fix HAS vs HAVE	2023-12-31 17:57:30 +01:00
Harald Barth	36cc46e88d	DC frequency dummy functions for odd architectures step #6	2023-12-31 13:52:37 +01:00
Harald Barth	bba74a08f6	Do not support obsolete <c> on memory tight arch	2023-12-31 13:22:42 +01:00
Harald Barth	ab58c38e7b	motordriver frequency diag	2023-12-31 13:22:34 +01:00
Harald Barth	d4f0a7c8f3	DC frequency uno does not have timers anyway step #5	2023-12-31 13:18:28 +01:00
Harald Barth	ba0a41b6f2	DC frequency fix bit shifting (debug code) step #4	2023-12-31 10:48:48 +01:00
Harald Barth	bf17f2018b	fix type and static warning step #3	2023-12-30 22:20:41 +01:00
Harald Barth	67387d2dc3	function bits to freqency step #2	2023-12-30 22:09:01 +01:00
Harald Barth	adb8b56c92	variable frequency step #1	2023-12-30 21:23:44 +01:00
Harald Barth	bd44184f57	version 5.2.17	2023-12-25 17:49:16 +01:00
Harald Barth	e7d3d92c23	as no other tasks run on core1, yield() not necessary	2023-12-25 17:40:29 +01:00
Harald Barth	e3bab887a2	simplify WifiESP32	2023-12-25 17:32:39 +01:00
Harald Barth	041a6534da	more diag and inUse tests	2023-12-24 12:03:42 +01:00
pmantoine	198d762a21	Add F439ZI serial setup in WifiInterface	2023-12-22 12:29:17 +08:00
peteGSX	1398cf1999	Merge pull request #373 from DCC-EX:ex-ioexpander-no-analogue-pins-fix Ex-ioexpander-no-analogue-pins-fix	2023-12-19 18:49:18 +10:00
peteGSX	797028b223	Ready to test	2023-12-19 07:30:15 +10:00
Harald Barth	1881d4c9ad	version 5.2.15	2023-12-13 11:41:57 +01:00
Harald Barth	18116a391c	move call to CommandDistributor::broadcastPower() into the TrackManager::setTrackPower(*) functions	2023-12-13 11:40:15 +01:00
Harald Barth	a1accec79a	add repeats to function packets that are not reminded in accordance with accessory packets	2023-12-13 10:55:58 +01:00
Asbelos	08f0a2b37d	5.2.13	2023-11-30 19:56:58 +00:00
Asbelos	6637ea6fe7	Merge branch 'devel_reminders' into devel	2023-11-30 19:54:20 +00:00
Asbelos	a69017f8bb	Optional DISABLE_FUNCTION_REMINDERS	2023-11-30 19:48:02 +00:00
Asbelos	763c9d8ae6	STEALTH	2023-11-30 11:32:39 +00:00
pmantoine	753567427e	ESP32 LCD messages, STM32 minor updates	2023-11-30 14:38:16 +08:00
Asbelos	3f4099520a	ESP32 update for reminders	2023-11-28 19:57:14 +00:00
Asbelos	07fd4bc309	Window	2023-11-27 16:49:02 +00:00
Harald Barth	1f05ef42d2	Change from TrackManager::returnMode to TrackManager::getMode	2023-11-27 08:15:07 +01:00
Asbelos	96fdbfdc89	Trainbrains block occupancy	2023-11-26 12:31:41 +00:00
Harald Barth	ebaf1b984e	version tag	2023-11-23 22:15:03 +01:00
Harald Barth	697f228a05	Save progmem with DISABLE_VDPY on Uno	2023-11-23 22:14:24 +01:00
Harald Barth	c8e307db7a	remove unused TrackManager::reportPowerChange(...)	2023-11-23 22:11:00 +01:00
Asbelos	a5ccb2e29e	EXRAIL STASH	2023-11-23 14:15:58 +00:00
Asbelos	42e2e69f5f	Merge branch 'devel' of https://github.com/DCC-EX/CommandStation-EX into devel	2023-11-23 10:41:40 +00:00
Asbelos	2075bc50e8	EXRAIL basic stash implementation	2023-11-23 10:41:35 +00:00
Harald Barth	a16214790e	version 5.2.8	2023-11-23 10:49:15 +01:00
Harald Barth	784934024e	Bugfix: Do not turn off all tracks on change ; give better power messages	2023-11-23 10:47:43 +01:00
Asbelos	b478056a9f	Fix @ reporting on startup	2023-11-23 09:00:49 +00:00
Harald Barth	ef47257d67	version tag	2023-11-22 10:54:01 +01:00
Harald Barth	03db06f2ee	Bugfix: Do not turn on track with trackmode NONE	2023-11-22 10:53:34 +01:00
Harald Barth	4308739c2b	version 5.2.7	2023-11-21 23:04:05 +01:00
Harald Barth	0cfea3e1a5	Merge branch 'devel' of https://github.com/DCC-EX/CommandStation-EX into devel	2023-11-21 22:48:54 +01:00
Harald Barth	d0df9f3c33	version tag	2023-11-21 22:48:35 +01:00
Harald Barth	ac4af407aa	On ESP32, the inversion is already done in HW	2023-11-21 22:47:48 +01:00
Asbelos	a236a205fe	Merge branch 'devel' of https://github.com/DCC-EX/CommandStation-EX into devel	2023-11-21 21:18:11 +00:00
Asbelos	478e9661bb	EXRAIL ling segment	2023-11-21 21:14:54 +00:00
Harald Barth	2c1b3e0a8f	version tag	2023-11-21 21:16:42 +01:00
Harald Barth	e7c4af5d4a	back out wrong const change	2023-11-21 21:16:20 +01:00
Harald Barth	263ed18b25	version tag	2023-11-21 15:37:47 +01:00
Harald Barth	4e1fad4832	Trackmanager consolidate getModeName	2023-11-21 15:37:08 +01:00
Harald Barth	29ea746062	version 5.2.6	2023-11-21 11:54:43 +01:00
Harald Barth	e6f33cfdee	Trackmanager broadcast power state on track mode change	2023-11-21 11:51:26 +01:00
Harald Barth	a7096e782c	version 5.2.5	2023-11-20 09:32:22 +01:00
Harald Barth	f935756538	Merge branch 'devel' of https://github.com/DCC-EX/CommandStation-EX into devel	2023-11-20 09:28:02 +01:00
Harald Barth	74d11ccb1e	Trackmanager: Do not treat TRACK_MODE_ALL as TRACK_MODE_DC	2023-11-20 09:27:57 +01:00
Asbelos	2ba5adc8b4	5.2.3 @ and ROUTE_DISABLED	2023-11-17 10:45:36 +00:00