Merge b36fb352b6 into f39fd89fbd

CommandDistributor.cpp

@@ -207,9 +207,13 @@ int16_t CommandDistributor::retClockTime() {
   return lastclocktime;
 }
 
-void  CommandDistributor::broadcastLoco(byte slot) {
+void  CommandDistributor::broadcastLoco(DCC::LOCO*  sp) {
-  DCC::LOCO * sp=&DCC::speedTable[slot];
+  if (!sp) {
-  broadcastReply(COMMAND_TYPE, F("<l %d %d %d %l>\n"), sp->loco,slot,sp->speedCode,sp->functions);
+    broadcastReply(COMMAND_TYPE,F("<l 0 -1 128 0>\n"));
+    return;
+	}
+  broadcastReply(COMMAND_TYPE, F("<l %d 0 %d %l>\n"), 
+    sp->loco,sp->targetSpeed,sp->functions);
 #ifdef SABERTOOTH
   if (Serial2 && sp->loco == SABERTOOTH) {
     static uint8_t rampingmode = 0;

CommandDistributor.h

@@ -28,6 +28,7 @@
 #include "StringBuffer.h"
 #include "defines.h"
 #include "EXRAIL2.h"
+#include "DCC.h"
 
 #if WIFI_ON | ETHERNET_ON 
   // Command Distributor must handle a RingStream of clients
@@ -46,7 +47,7 @@ private:
   #endif
 public :
   static void parse(byte clientId,byte* buffer, RingStream * ring);
-  static void broadcastLoco(byte slot);
+  static void broadcastLoco(DCC::LOCO * slot);
   static void broadcastForgetLoco(int16_t loco);
   static void broadcastSensor(int16_t id, bool value);
   static void broadcastTurnout(int16_t id, bool isClosed);

DCC.cpp

@@ -60,6 +60,8 @@ const byte FN_GROUP_5=0x10;
 FSH* DCC::shieldName=NULL;
 byte DCC::globalSpeedsteps=128;
 
+#define SLOTLOOP for (auto slot=&speedTable[0];slot!=&speedTable[MAX_LOCOS];slot++)
+
 void DCC::begin() {
   StringFormatter::send(&USB_SERIAL,F("<iDCC-EX V-%S / %S / %S G-%S>\n"), F(VERSION), F(ARDUINO_TYPE), shieldName, F(GITHUB_SHA));
 #ifndef DISABLE_EEPROM
@@ -72,13 +74,29 @@ void DCC::begin() {
 #endif
 }
 
+int16_t DCC::defaultMomentum=0;
 
 void DCC::setThrottle( uint16_t cab, uint8_t tSpeed, bool tDirection)  {
+  if (cab==0) {
+    if (tSpeed==1) estopAll(); // ESTOP broadcast fix 
+    return;
+  } 
   byte speedCode = (tSpeed & 0x7F)  + tDirection * 128;
-  setThrottle2(cab, speedCode);
+  LOCO * slot=lookupSpeedTable(cab);
-  TrackManager::setDCSignal(cab,speedCode); // in case this is a dcc track on this addr
+  if (slot->targetSpeed==speedCode) return; 
-  // retain speed for loco reminders
+  slot->targetSpeed=speedCode;
-  updateLocoReminder(cab, speedCode );
+  auto momentum=slot->millis_per_notch;
+  if (momentum<0) momentum=defaultMomentum;
+  if (momentum>0 && tSpeed!=1) { // not ESTOP
+    // we dont throttle speed, we just let the reminders take it to target
+    slot->momentum_base=millis();
+  } 
+  else {  // Momentum not involved, throttle now.
+    slot->speedCode = speedCode;
+    setThrottle2(cab, speedCode);
+    TrackManager::setDCSignal(cab,speedCode); // in case this is a dcc track on this addr
+  }
+  CommandDistributor::broadcastLoco(slot);
 }
 
 void DCC::setThrottle2( uint16_t cab, byte speedCode)  {
@@ -139,18 +157,22 @@ void DCC::setFunctionInternal(int cab, byte byte1, byte byte2, byte count) {
 // returns speed steps 0 to 127 (1 == emergency stop)
 // or -1 on "loco not found"
 int8_t DCC::getThrottleSpeed(int cab) {
-  int reg=lookupSpeedTable(cab);
+  return getThrottleSpeedByte(cab) & 0x7F;
-  if (reg<0) return -1;
-  return speedTable[reg].speedCode & 0x7F;
 }
 
 // returns speed code byte
 // or 128 (speed 0, dir forward) on "loco not found".
+// This is the throttle set speed
 uint8_t DCC::getThrottleSpeedByte(int cab) {
-  int reg=lookupSpeedTable(cab);
+  LOCO * slot=lookupSpeedTable(cab,false);
-  if (reg<0)
+  return slot?slot->targetSpeed:128;
-    return 128;
+}
-  return speedTable[reg].speedCode;
+// returns speed code byte for loco. 
+// This is the most recently send DCC speed packet byte
+// or 128 (speed 0, dir forward) on "loco not found".
+uint8_t DCC::getLocoSpeedByte(int cab) {
+  LOCO* slot=lookupSpeedTable(cab,false);
+  return slot?slot->speedCode:128;
 }
 
 // returns 0 to 7 for frequency
@@ -159,12 +181,11 @@ uint8_t DCC::getThrottleFrequency(int cab) {
   (void)cab;
   return 0;
 #else
-  int reg=lookupSpeedTable(cab);
+  LOCO* slot=lookupSpeedTable(cab);
-  if (reg<0)
+  if (!slot)  return 0; // use default frequency
-    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);
+  uint8_t res = (uint8_t)(slot->functions >>29);
-  //DIAG(F("Speed table %d functions %l shifted %d"), reg, speedTable[reg].functions, res);
+  //DIAG(F("Speed table %d functions %l shifted %d"), reg, slot->functions, res);
   return res;
 #endif
 }
@@ -172,9 +193,7 @@ uint8_t DCC::getThrottleFrequency(int cab) {
 // returns direction on loco
 // or true/forward on "loco not found"
 bool DCC::getThrottleDirection(int cab) {
-  int reg=lookupSpeedTable(cab);
+  return getThrottleSpeedByte(cab) % 0x80;
-  if (reg<0) return true;
-  return (speedTable[reg].speedCode & 0x80) !=0;
 }
 
 // Set function to value on or off
@@ -207,22 +226,21 @@ bool DCC::setFn( int cab, int16_t functionNumber, bool on) {
   if (functionNumber > 31)
     return true;
   
-  int reg = lookupSpeedTable(cab);
+  LOCO * slot = lookupSpeedTable(cab);
-  if (reg<0) return false;
+  
-
   // Take care of functions:
   // Set state of function
-  uint32_t previous=speedTable[reg].functions;
+  uint32_t previous=slot->functions;
   uint32_t funcmask = (1UL<<functionNumber);
   if (on) {
-      speedTable[reg].functions |= funcmask;
+      slot->functions |= funcmask;
   } else {
-      speedTable[reg].functions &= ~funcmask;
+      slot->functions &= ~funcmask;
   }
-  if (speedTable[reg].functions != previous) {
+  if (slot->functions != previous) {
     if (functionNumber <= 28)
-      updateGroupflags(speedTable[reg].groupFlags, functionNumber);
+      updateGroupflags(slot->groupFlags, functionNumber);
-    CommandDistributor::broadcastLoco(reg);
+    CommandDistributor::broadcastLoco(slot);
   }
   return true;
 }
@@ -230,14 +248,13 @@ bool DCC::setFn( int cab, int16_t functionNumber, bool on) {
 // Flip function state (used from withrottle protocol)
 void DCC::changeFn( int cab, int16_t functionNumber) {
   if (cab<=0 || functionNumber>31) return;
-  int reg = lookupSpeedTable(cab);
+  auto slot=lookupSpeedTable(cab);
-  if (reg<0) return;
   unsigned long funcmask = (1UL<<functionNumber);
-  speedTable[reg].functions ^= funcmask;
+  slot->functions ^= funcmask;
   if (functionNumber <= 28) {
-    updateGroupflags(speedTable[reg].groupFlags, functionNumber);
+    updateGroupflags(slot->groupFlags, functionNumber);
   }
-  CommandDistributor::broadcastLoco(reg);
+  CommandDistributor::broadcastLoco(slot);
 }
 
 // Report function state (used from withrottle protocol)
@@ -245,12 +262,10 @@ void DCC::changeFn( int cab, int16_t functionNumber) {
 int8_t DCC::getFn( int cab, int16_t functionNumber) {
   if (cab<=0 || functionNumber>31)
     return -1;  // unknown
-  int reg = lookupSpeedTable(cab);
+  auto slot = lookupSpeedTable(cab);
-  if (reg<0)
+  
-    return -1;
-
   unsigned long funcmask = (1UL<<functionNumber);
-  return  (speedTable[reg].functions & funcmask)? 1 : 0;
+  return  (slot->functions & funcmask)? 1 : 0;
 }
 
 // Set the group flag to say we have touched the particular group.
@@ -267,22 +282,22 @@ void DCC::updateGroupflags(byte & flags, int16_t functionNumber) {
 
 uint32_t DCC::getFunctionMap(int cab) {
   if (cab<=0) return 0;  // unknown pretend all functions off
-  int reg = lookupSpeedTable(cab);
+  auto slot = lookupSpeedTable(cab,false);
-  return (reg<0)?0:speedTable[reg].functions;
+  return slot?slot->functions:0;
 }
 
 // saves DC frequency (0..3) in spare functions 29,30,31
 void DCC::setDCFreq(int cab,byte freq) {
   if (cab==0 || freq>3) return;
-  auto reg=lookupSpeedTable(cab,true);
+  auto slot=lookupSpeedTable(cab,true);
   // drop and replace F29,30,31 (top 3 bits) 
-  auto newFunctions=speedTable[reg].functions & 0x1FFFFFFFUL;
+  auto newFunctions=slot->functions & 0x1FFFFFFFUL;
   if (freq==1)      newFunctions |= (1UL<<29); // F29
   else if (freq==2) newFunctions |= (1UL<<30); // F30
   else if (freq==3) newFunctions |= (1UL<<31); // F31
-  if (newFunctions==speedTable[reg].functions) return; // no change 
+  if (newFunctions==slot->functions) return; // no change 
-  speedTable[reg].functions=newFunctions;
+  slot->functions=newFunctions;
-  CommandDistributor::broadcastLoco(reg);
+  CommandDistributor::broadcastLoco(slot);
 }
 
 void DCC::setAccessory(int address, byte port, bool gate, byte onoff /*= 2*/) {
@@ -738,10 +753,9 @@ void DCC::setConsistId(int id,bool reverse,ACK_CALLBACK callback) {
 
 void DCC::forgetLoco(int cab) {  // removes any speed reminders for this loco
   setThrottle2(cab,1); // ESTOP this loco if still on track
-  int reg=lookupSpeedTable(cab, false);
+  auto slot=lookupSpeedTable(cab, false);
-  if (reg>=0) {
+  if (slot) {
-    speedTable[reg].loco=0;
+    slot->loco=-1;  // no longer used but not end of world
-    setThrottle2(cab,1); // ESTOP if this loco still on track
     CommandDistributor::broadcastForgetLoco(cab);
   }
 }
@@ -749,7 +763,7 @@ void DCC::forgetAllLocos() {  // removes all speed reminders
   setThrottle2(0,1); // ESTOP all locos still on track
   for (int i=0;i<MAX_LOCOS;i++) {
     if (speedTable[i].loco) CommandDistributor::broadcastForgetLoco(speedTable[i].loco);
-    speedTable[i].loco=0;
+    speedTable[i].loco=0;  // no longer used and looks like end
   }
 }
 
@@ -764,26 +778,68 @@ void DCC::issueReminders() {
   // if the main track transmitter still has a pending packet, skip this time around.
   if (!DCCWaveform::mainTrack.isReminderWindowOpen()) return;
   // Move to next loco slot.  If occupied, send a reminder.
-  int reg = lastLocoReminder+1;
+  auto slot = nextLocoReminder;
-  if (reg > highestUsedReg) reg = 0;  // Go to start of table
+  if (slot >= &speedTable[MAX_LOCOS]) slot=&speedTable[0];  // Go to start of table
-  if (speedTable[reg].loco > 0) {
+  if (slot->loco > 0) 
-    // have found loco to remind
+    if (!issueReminder(slot)) 
-    if (issueReminder(reg))
+      return;
-      lastLocoReminder = reg;
+  // a loco=0 is at the end of the list, a loco <0 is deleted
-  } else
+  if (slot->loco==0) nextLocoReminder = &speedTable[0];
-    lastLocoReminder = reg;
+  else nextLocoReminder=slot+1;
 }
 
-bool DCC::issueReminder(int reg) {
+int16_t normalize(byte speed) {
-  unsigned long functions=speedTable[reg].functions;
+   if (speed & 0x80) return speed & 0x7F;
-  int loco=speedTable[reg].loco;
+   return 0-1-speed; 
-  byte flags=speedTable[reg].groupFlags;
+}
+byte dccalize(int16_t speed) {
+   if (speed>127) return 0xFF;  // 127 forward
+   if (speed<-127) return 0x7F;  // 127 reverse
+   if (speed >=0) return speed | 0x80;
+   // negative speeds... -1==dcc 0, -2==dcc 1 
+   return (int16_t)-1 - speed; 
+}
+
+bool DCC::issueReminder(LOCO * slot) {
+  unsigned long functions=slot->functions;
+  int loco=slot->loco;
+  byte flags=slot->groupFlags;
 
   switch (loopStatus) {
-        case 0:
+        case 0: {
-      //   DIAG(F("Reminder %d speed %d"),loco,speedTable[reg].speedCode);
+         // calculate any momentum change going on
-         setThrottle2(loco, speedTable[reg].speedCode);
+         auto sc=slot->speedCode;
-         break;
+         if (slot->targetSpeed!=sc) {
+            // calculate new speed code 
+            auto now=millis();
+            int16_t delay=now-slot->momentum_base;
+            auto millisPerNotch=slot->millis_per_notch;
+            if (millisPerNotch<0) millisPerNotch=defaultMomentum;
+            // allow for momentum change to 0 while accelerating/slowing
+            auto ticks=(millisPerNotch>0)?(delay/millisPerNotch):500;
+            if (ticks>0) {
+              auto current=normalize(sc);  // -128..+127
+              auto target=normalize(slot->targetSpeed);
+              // DIAG(F("Momentum l=%d ti=%d sc=%d c=%d t=%d"),loco,ticks,sc,current,target);
+              if (current<target) { // accelerate
+                current+=ticks;
+                if (current>target) current=target;
+              }
+              else  { // slow
+                current-=ticks;
+                if (current<target) current=target;
+              }
+              sc=dccalize(current);
+              //DIAG(F("c=%d newsc=%d"),current,sc);
+              slot->speedCode=sc;
+              TrackManager::setDCSignal(loco,sc); // in case this is a dcc track on this addr
+              slot->momentum_base=now;  
+            }
+          }
+          // DIAG(F("Reminder %d speed %d"),loco,slot->speedCode);
+          setThrottle2(loco, sc);
+        }
+        break;
        case 1: // remind function group 1 (F0-F4)
           if (flags & FN_GROUP_1)
 #ifndef DISABLE_FUNCTION_REMINDERS
@@ -844,70 +900,75 @@ byte DCC::cv2(int cv)  {
   return lowByte(cv);
 }
 
-int DCC::lookupSpeedTable(int locoId, bool autoCreate) {
+DCC::LOCO *  DCC::lookupSpeedTable(int locoId, bool autoCreate) {
   // determine speed reg for this loco
-  int firstEmpty = MAX_LOCOS;
+  LOCO * firstEmpty=nullptr;
-  int reg;
+  SLOTLOOP {
-  for (reg = 0; reg < MAX_LOCOS; reg++) {
+    if (firstEmpty==nullptr && slot->loco<=0) firstEmpty=slot;
-    if (speedTable[reg].loco == locoId) break;
+    if (slot->loco == locoId) return slot;
-    if (speedTable[reg].loco == 0 && firstEmpty == MAX_LOCOS) firstEmpty = reg;
+    if (slot->loco==0) break; 
   }
-
+  if (!autoCreate) return nullptr;
-  // return -1 if not found and not auto creating
+  if (firstEmpty==nullptr) { 
-  if (reg== MAX_LOCOS && !autoCreate) return -1; 
+    // return last slot if full
-  if (reg == MAX_LOCOS) reg = firstEmpty;
+    DIAG(F("Too many locos, reusing last slot"));
-  if (reg >= MAX_LOCOS) {
+    firstEmpty=&speedTable[MAX_LOCOS-1];
-    DIAG(F("Too many locos"));
-    return -1;
   }
-  if (reg==firstEmpty){
+  // fill first empty slot with new entry
-        speedTable[reg].loco = locoId;
+  firstEmpty->loco = locoId;
-        speedTable[reg].speedCode=128;  // default direction forward
+  firstEmpty->speedCode=128;  // default direction forward
-        speedTable[reg].groupFlags=0;
+  firstEmpty->targetSpeed=128;  // default direction forward
-        speedTable[reg].functions=0;
+  firstEmpty->groupFlags=0;
-  }
+  firstEmpty->functions=0;
-  if (reg > highestUsedReg) highestUsedReg = reg;
+  firstEmpty->millis_per_notch=-1; // use default
-  return reg;
+  return firstEmpty;
 }
 
-void  DCC::updateLocoReminder(int loco, byte speedCode) {
+bool DCC::setMomentum(int locoId,int16_t millis_per_notch) {
-
+  if (locoId==0 && millis_per_notch>=0) {
-  if (loco==0) {
+    defaultMomentum=millis_per_notch;
-     // broadcast stop/estop but dont change direction
+    return true;
-     for (int reg = 0; reg <= highestUsedReg; reg++) {
-       if (speedTable[reg].loco==0) continue;
-       byte newspeed=(speedTable[reg].speedCode & 0x80) |  (speedCode & 0x7f);
-       if (speedTable[reg].speedCode != newspeed) {
-         speedTable[reg].speedCode = newspeed;
-         CommandDistributor::broadcastLoco(reg);
-       }
-     }
-     return;
   }
+  // millis=-1 is ok and means this loco should use the default.
+  // We dont copy the default here because it can be changed 
+  // while running and have immediate effect on all locos using -1.
+  if (locoId<=0 || millis_per_notch<-1) return false;
+  lookupSpeedTable(locoId,true)->millis_per_notch=millis_per_notch;
+  return true; 
+}
 
-  // determine speed reg for this loco
+
-  int reg=lookupSpeedTable(loco);
+void  DCC::estopAll() {
-  if (reg>=0 && speedTable[reg].speedCode!=speedCode) {
+  setThrottle2(0,1); // estop all locos
-    speedTable[reg].speedCode = speedCode;
+  TrackManager::setDCSignal(0,1); 
-    CommandDistributor::broadcastLoco(reg);
+    
+  // remind stop/estop but dont change direction
+  SLOTLOOP {
+    if (slot->loco<=0) continue;
+    byte newspeed=(slot->targetSpeed & 0x80) |  0x01;
+    slot->speedCode = newspeed;
+    slot->targetSpeed = newspeed;
+    CommandDistributor::broadcastLoco(slot);  
   }
 }
 
+
 DCC::LOCO DCC::speedTable[MAX_LOCOS];
-int DCC::lastLocoReminder = 0;
+DCC::LOCO *  DCC::nextLocoReminder = &DCC::speedTable[0];
-int DCC::highestUsedReg = 0;
 
 
 void DCC::displayCabList(Print * stream) {
-
+    StringFormatter::send(stream,F("<*\n")); 
     int used=0;
-    for (int reg = 0; reg <= highestUsedReg; reg++) {
+    SLOTLOOP {
-       if (speedTable[reg].loco>0) {
+       if (slot->loco==0) break;  // no more locos
+       if (slot->loco>0) {
         used ++;
-        StringFormatter::send(stream,F("cab=%d, speed=%d, dir=%c \n"),
+        StringFormatter::send(stream,F("cab=%d, speed=%d, target=%d momentum=%d\n"),
-           speedTable[reg].loco,  speedTable[reg].speedCode & 0x7f,(speedTable[reg].speedCode & 0x80) ? 'F':'R');
+           slot->loco,  slot->speedCode, slot->targetSpeed,
+           slot->millis_per_notch);
        }
      }
-     StringFormatter::send(stream,F("Used=%d, max=%d\n"),used,MAX_LOCOS);
+     StringFormatter::send(stream,F("Used=%d, max=%d, momentum=%d *>\n"),
-
+                            used,MAX_LOCOS, DCC::defaultMomentum);
 }

DCC.h

@@ -59,8 +59,10 @@ public:
 
   // Public DCC API functions
   static void setThrottle(uint16_t cab, uint8_t tSpeed, bool tDirection);
+  static void estopAll();
   static int8_t getThrottleSpeed(int cab);
   static uint8_t getThrottleSpeedByte(int cab);
+  static uint8_t getLocoSpeedByte(int cab); // may lag throttle 
   static uint8_t getThrottleFrequency(int cab);
   static bool getThrottleDirection(int cab);
   static void writeCVByteMain(int cab, int cv, byte bValue);
@@ -102,20 +104,24 @@ public:
     byte speedCode;
     byte groupFlags;
     uint32_t functions;
+    // Momentum management variables
+    uint32_t momentum_base;     // millis() when speed modified under momentum
+    int16_t  millis_per_notch;  // 0=no momentum, -1=defaultMomentum
+    byte targetSpeed;           // speed set by throttle
   };
  static LOCO speedTable[MAX_LOCOS];
- static int lookupSpeedTable(int locoId, bool autoCreate=true);
+ static LOCO * lookupSpeedTable(int locoId, bool autoCreate=true);
  static byte cv1(byte opcode, int cv);
  static byte cv2(int cv);
+ static bool setMomentum(int locoId,int16_t millis_per_notch);
  
 private:
   static byte loopStatus;
+  static int16_t defaultMomentum;  // Millis per speed step
   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, byte count);
-  static bool issueReminder(int reg);
+  static bool issueReminder(LOCO * slot);
-  static int lastLocoReminder;
+  static LOCO* nextLocoReminder;
-  static int highestUsedReg;
   static FSH *shieldName;
   static byte globalSpeedsteps;
 

DCCEXParser.cpp

@@ -68,7 +68,8 @@ Once a new OPCODE is decided upon, update this list.
   K, Reserved for future use - Potentially Railcom
   l, Loco speedbyte/function map broadcast
   L, Reserved for LCC interface (implemented in EXRAIL)
-  m, message to throttles broadcast 
+  m, message to throttles (broadcast output) 
+  m, set momentum  
   M, Write DCC packet
   n, Reserved for SensorCam
   N, Reserved for Sensorcam 
@@ -288,12 +289,9 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
         int16_t direction;
 
         if (params==1) {  // <t cab>  display state
-	  int16_t slot=DCC::lookupSpeedTable(p[0],false);
+         if (p[0]<=0) break;
-	  if (slot>=0)
+	     CommandDistributor::broadcastLoco(DCC::lookupSpeedTable(p[0],false));
-	    CommandDistributor::broadcastLoco(slot);
+	     return;
-	  else // send dummy state speed 0 fwd no functions.
-            StringFormatter::send(stream,F("<l %d -1 128 0>\n"),p[0]);
-	  return;
         }
 
         if (params == 4)
@@ -431,6 +429,11 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
       DCC::writeCVBitMain(p[0], p[1], p[2], p[3]);
       return;
 #endif
+    
+    case 'm': // <m cabid momentum>
+      if (params!=2) break;
+      if (DCC::setMomentum(p[0],p[1])) return; 
+      break; 
 
     case 'M': // WRITE TRANSPARENT DCC PACKET MAIN <M REG X1 ... X9>
 #ifndef DISABLE_PROG
@@ -580,7 +583,7 @@ void DCCEXParser::parseOne(Print *stream, byte *com, RingStream * ringStream)
 	}
 
     case '!': // ESTOP ALL  <!>
-        DCC::setThrottle(0,1,1); // this broadcasts speed 1(estop) and sets all reminders to speed 1.
+        DCC::estopAll(); // this broadcasts speed 1(estop) and sets all reminders to speed 1.
         return;
 
 #ifdef HAS_ENOUGH_MEMORY

EXRAIL2.cpp

@@ -566,6 +566,10 @@ void RMFT2::loop2() {
     forward=DCC::getThrottleDirection(loco)^invert;
     driveLoco(operand);
     break;
+  
+  case OPCODE_MOMENTUM:
+    DCC::setMomentum(loco,operand);
+    break;
     
   case OPCODE_FORGET:
     if (loco!=0) {
@@ -679,7 +683,7 @@ void RMFT2::loop2() {
      break; 
 
   case OPCODE_PAUSE:
-    DCC::setThrottle(0,1,true);  // pause all locos on the track
+    DCC::estopAll();  // pause all locos on the track
     pausingTask=this;
     break;
 

EXRAIL2.h

@@ -35,6 +35,7 @@
 // 
 enum OPCODE : byte {OPCODE_THROW,OPCODE_CLOSE,OPCODE_TOGGLE_TURNOUT,
              OPCODE_FWD,OPCODE_REV,OPCODE_SPEED,OPCODE_INVERT_DIRECTION,
+             OPCODE_MOMENTUM,
              OPCODE_RESERVE,OPCODE_FREE,
              OPCODE_AT,OPCODE_AFTER,
              OPCODE_AFTEROVERLOAD,OPCODE_AUTOSTART,

EXRAIL2MacroReset.h

@@ -98,6 +98,7 @@
 #undef LCC 
 #undef LCCX 
 #undef LCN 
+#undef MOMENTUM
 #undef MOVETT
 #undef ACON
 #undef ACOF
@@ -265,6 +266,7 @@
 #define LCC(eventid) 
 #define LCCX(senderid,eventid) 
 #define LCD(row,msg)
+#define MOMENTUM(mspertick)
 #define SCREEN(display,row,msg)
 #define LCN(msg) 
 #define MESSAGE(msg)

EXRAIL2Parser.cpp

@@ -276,7 +276,7 @@ bool RMFT2::parseSlash(Print * stream, byte & paramCount, int16_t p[]) {
   switch (p[0]) {
   case "PAUSE"_hk: // </ PAUSE>
     if (paramCount!=1) return false;
-    DCC::setThrottle(0,1,true);  // pause all locos on the track
+    DCC::estopAll();  // pause all locos on the track
     pausingTask=(RMFT2 *)1; // Impossible task address
     return true;
     

EXRAILMacros.h

@@ -551,6 +551,7 @@ int RMFT2::onLCCLookup[RMFT2::countLCCLookup];
 #define STEALTH_GLOBAL(code...) 
 #define LCN(msg) PRINT(msg)
 #define MESSAGE(msg) PRINT(msg)
+#define MOMENTUM(mspertick) OPCODE_MOMENTUM,V(mspertick),
 #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),
 #define ONACTIVATEL(linear) OPCODE_ONACTIVATE,V(linear+3),

GITHUB_SHA.h

@@ -1 +1 @@
-#define GITHUB_SHA "devel-202408080849Z"
+#define GITHUB_SHA "devel-202406182019Z"

Release_Notes/momentum.md

@@ -0,0 +1,20 @@
+New Momentum feature notes:
+
+The command station can apply momentum to throttle movements in the same way that a standards compliant DCC decoder can be set to do. This momentum can be defaulted system wide and overridden on individual locos. It does not use or alter the loco CV values and so it also works when driving DC locos.
+The momentum is applied regardless of the throttle type used (or even EXRAIL). 
+
+Momentum is specified in mS / throttle_step.
+
+There is a new command `<m cabid mS>`
+
+For example: 
+`<m 3 0>`   sets loco 3 to no momentum.
+`<m 3 21>`   sets loco 3 to 21 mS/step.
+`<m 0 21>`  sets the default momentum to 21mS/Step for all current and future locos that have not been specifically set.
+`<m 3 -1>`   sets loco 3 to track the default momentum value. 
+
+EXRAIL
+  A new macro `MOMENTUM(mSecPerStep)` sets the momentum value of the current tasks loco. 
+
+Note: Setting Momentum 7,14,21 etc is similar in effect to setting a decoder CV03 to 1,2,3. At present the same momentum value is used for acceleration and deceleration. The `<m>` command may be extended in future to separate these values. 
+

TrackManager.cpp

@@ -151,8 +151,8 @@ void TrackManager::setDCCSignal( bool on) {
   HAVE_PORTD(shadowPORTD=PORTD);
   HAVE_PORTE(shadowPORTE=PORTE);
   HAVE_PORTF(shadowPORTF=PORTF);
-  HAVE_PORTG(shadowPORTF=PORTG);
+  HAVE_PORTF(shadowPORTF=PORTG);
-  HAVE_PORTH(shadowPORTF=PORTH);
+  HAVE_PORTF(shadowPORTF=PORTH);
   APPLY_BY_MODE(TRACK_MODE_MAIN,setSignal(on));
   HAVE_PORTA(PORTA=shadowPORTA);
   HAVE_PORTB(PORTB=shadowPORTB);
@@ -160,8 +160,8 @@ void TrackManager::setDCCSignal( bool on) {
   HAVE_PORTD(PORTD=shadowPORTD);
   HAVE_PORTE(PORTE=shadowPORTE);
   HAVE_PORTF(PORTF=shadowPORTF);
-  HAVE_PORTG(shadowPORTF=PORTG);
+  HAVE_PORTF(shadowPORTF=PORTG);
-  HAVE_PORTH(shadowPORTF=PORTH);
+  HAVE_PORTF(shadowPORTF=PORTH);
 }
 
 // setPROGSignal(), called from interrupt context
@@ -173,8 +173,8 @@ void TrackManager::setPROGSignal( bool on) {
   HAVE_PORTD(shadowPORTD=PORTD);
   HAVE_PORTE(shadowPORTE=PORTE);
   HAVE_PORTF(shadowPORTF=PORTF);
-  HAVE_PORTG(shadowPORTF=PORTG);
+  HAVE_PORTF(shadowPORTF=PORTG);
-  HAVE_PORTH(shadowPORTF=PORTH);
+  HAVE_PORTF(shadowPORTF=PORTH);
   APPLY_BY_MODE(TRACK_MODE_PROG,setSignal(on));
   HAVE_PORTA(PORTA=shadowPORTA);
   HAVE_PORTB(PORTB=shadowPORTB);
@@ -182,8 +182,8 @@ void TrackManager::setPROGSignal( bool on) {
   HAVE_PORTD(PORTD=shadowPORTD);
   HAVE_PORTE(PORTE=shadowPORTE);
   HAVE_PORTF(PORTF=shadowPORTF);
-  HAVE_PORTG(shadowPORTF=PORTG);
+  HAVE_PORTF(shadowPORTF=PORTG);
-  HAVE_PORTH(shadowPORTF=PORTH);
+  HAVE_PORTF(shadowPORTF=PORTH);
 }
 
 // setDCSignal(), called from normal context
@@ -368,7 +368,7 @@ bool TrackManager::setTrackMode(byte trackToSet, TRACK_MODE mode, int16_t dcAddr
 }
 
 void TrackManager::applyDCSpeed(byte t) {
-  track[t]->setDCSignal(DCC::getThrottleSpeedByte(trackDCAddr[t]),
+  track[t]->setDCSignal(DCC::getLocoSpeedByte(trackDCAddr[t]),
 			DCC::getThrottleFrequency(trackDCAddr[t]));
 }
 
@@ -641,25 +641,23 @@ void TrackManager::setJoinRelayPin(byte joinRelayPin) {
 
 void TrackManager::setJoin(bool joined) {
 #ifdef ARDUINO_ARCH_ESP32
-  if (joined) {                                          // if we go into joined mode (PROG acts as MAIN)
+  if (joined) {
     FOR_EACH_TRACK(t) {
-      if (track[t]->getMode() & TRACK_MODE_PROG) {       // find PROG track
+      if (track[t]->getMode() & TRACK_MODE_PROG) {
-	tempProgTrack = t;                               // remember PROG track
+	tempProgTrack = t;
 	setTrackMode(t, TRACK_MODE_MAIN);
-	track[t]->setPower(POWERMODE::ON);               // if joined, always on
+	break;
-	break;                                           // there is only one prog track, done
       }
     }
   } else {
     if (tempProgTrack != MAX_TRACKS+1) {
-      // setTrackMode defaults to power off, so we
+      // as setTrackMode with TRACK_MODE_PROG defaults to
-      // need to preserve that state.
+      // power off, we will take the current power state
-      POWERMODE tPTmode = track[tempProgTrack]->getPower(); // get current power status of this track
+      // of our track and then preserve that state.
-      setTrackMode(tempProgTrack, TRACK_MODE_PROG);         // set track mode back to prog
+      POWERMODE tPTmode = track[tempProgTrack]->getPower(); //get current power status of this track
-      track[tempProgTrack]->setPower(tPTmode);              // set power status as it was before
+      setTrackMode(tempProgTrack, TRACK_MODE_PROG);
+      track[tempProgTrack]->setPower(tPTmode);              //set track status as it was before
       tempProgTrack = MAX_TRACKS+1;
-    } else {
-      DIAG(F("Unjoin but no remembered prog track"));
     }
   }
 #endif

version.h

@@ -3,9 +3,7 @@
 
 #include "StringFormatter.h"
 
-#define VERSION "5.2.74"
+#define VERSION "5.2.72"
-// 5.2.74 - Bugfix: ESP32 turn on the joined prog (as main) again after a prog operation
-// 5.2.73 - Bugfix: STM32 further fixes to shadowPORT entries in TrackManager.cpp for PORTG and PORTH
 // 5.2.72 - Bugfix: added shadowPORT entries in TrackManager.cpp for PORTG and PORTH on STM32, fixed typo in MotorDriver.cpp
 // 5.2.71 -  Broadcasts of loco forgets. 
 // 5.2.70 -  IO_RocoDriver renamed to IO_EncoderThrottle.