Merge branch 'devel-stm32EC-Ash' into devel-Ash

DCCTimerSTM32.cpp

@@ -56,9 +56,9 @@ HardwareSerial Serial5(PD2, PC12);  // Rx=PD2, Tx=PC12 -- UART5 - F446RE
       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
+HardwareSerial Serial2(PD6, PD5);  // Rx=PD6, Tx=PD5 -- UART2
-#if !defined(ARDUINO_NUCLEO_F412ZG)
+#if !defined(ARDUINO_NUCLEO_F412ZG)  // F412ZG does not have UART5
-  HardwareSerial Serial2(PD6, PD5);  // Rx=PD6, Tx=PD5 -- UART5
+  HardwareSerial Serial5(PD2, PC12);  // Rx=PD2, Tx=PC12 -- UART5
 #endif  
 // Serial3 is defined to use USART3 by default, but is in fact used as the diag console
 // via the debugger on the Nucleo-144. It is therefore unavailable for other DCC-EX uses like WiFi, DFPlayer, etc.

EthernetInterface.cpp

@@ -1,4 +1,6 @@
 /*
+ *  © 2024 Morten "Doc" Nielsen
+ *  © 2023-2024 Paul M. Antoine
  *  © 2022 Bruno Sanches
  *  © 2021 Fred Decker
  *  © 2020-2022 Harald Barth
@@ -29,6 +31,10 @@
 #include "CommandDistributor.h"
 #include "WiThrottle.h"
 #include "DCCTimer.h"
+#include "MDNS_Generic.h"
+
+EthernetUDP udp;
+MDNS mdns(udp);
 
 EthernetInterface * EthernetInterface::singleton=NULL;
 /**
@@ -41,8 +47,11 @@ void EthernetInterface::setup()
     DIAG(F("Prog Error!"));
     return;
   }
-  if ((singleton=new EthernetInterface()))
+  DIAG(F("Ethernet starting... please be patient, especially if no cable is connected!"));
+  if ((singleton=new EthernetInterface())) {
+    // DIAG(F("Ethernet Class initialized"));
     return;
+  }
   DIAG(F("Ethernet not initialized"));
 };
 
@@ -59,36 +68,62 @@ static IPAddress myIP(IP_ADDRESS);
  */
 EthernetInterface::EthernetInterface()
 {
-    byte mac[6];
-    DCCTimer::getSimulatedMacAddress(mac);
     connected=false;
-   
+#if defined(STM32_ETHERNET)
-#ifdef IP_ADDRESS
+    // Set a HOSTNAME for the DHCP request - a nice to have, but hard it seems on LWIP for STM32
+    // The default is "lwip", which is **always** set in STM32Ethernet/src/utility/ethernetif.cpp
+    // for some reason. One can edit it to instead read:
+    //      #if LWIP_NETIF_HOSTNAME
+    //      /* Initialize interface hostname */
+    //      if (netif->hostname == NULL)
+    //         netif->hostname = "lwip";
+    //      #endif /* LWIP_NETIF_HOSTNAME */
+    // Which seems more useful! We should propose the patch... so the following line actually works!
+    netif_set_hostname(&gnetif, WIFI_HOSTNAME);   // Should probably be passed in the contructor...
+  #ifdef IP_ADDRESS
+    Ethernet.begin(myIP);
+  #else
+    Ethernet.begin();
+  #endif // IP_ADDRESS
+#else // All other architectures
+    byte mac[6]= { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+    DIAG(F("Ethernet attempting to get MAC address"));
+    DCCTimer::getSimulatedMacAddress(mac);
+    DIAG(F("Ethernet got MAC address"));
+  #ifdef IP_ADDRESS
     Ethernet.begin(mac, myIP);
-#else
+  #else
     if (Ethernet.begin(mac) == 0)
     {
         DIAG(F("Ethernet.begin FAILED"));
         return;
-    } 
+    }
-#endif
+  #endif // IP_ADDRESS
     if (Ethernet.hardwareStatus() == EthernetNoHardware) {
       DIAG(F("Ethernet shield not found or W5100"));
     }
-  
+#endif // STM32_ETHERNET
-    unsigned long startmilli = millis();
+
+    uint32_t startmilli = millis();
     while ((millis() - startmilli) < 5500) { // Loop to give time to check for cable connection
         if (Ethernet.linkStatus() == LinkON)
             break;
-        DIAG(F("Ethernet waiting for link (1sec) "));
+        DIAG(F("Ethernet cable connected? Waiting for link (1sec) "));
         delay(1000);
     }
-    // now we either do have link of we have a W5100
+    // Now we either do have link or we have a W5100 where we do not know if we have link.
-    // where we do not know if we have link. That's
+    // So now run checkLink() which also sets up outboundRing if it does not exist.
-    // the reason to now run checkLink.
+    // A false returned means we know we booted without an Ethernet cable, or perhaps there
-    // CheckLinks sets up outboundRing if it does
+    // is no W5100 and we should say so
-    // not exist yet as well.
+    if (!checkLink())
-    checkLink();
+    {
+      #if defined(STM32_ETHERNET)
+      DIAG(F("Ethernet cable disconnected!"));
+      #else
+      DIAG(F("Ethernet cable disconnected, or W5100 hardware not present"));
+      #endif
+      LCD(4,F("Ethernet DOWN"));
+    }
 }
 
 /**
@@ -140,31 +175,63 @@ bool EthernetInterface::checkLink() {
       DIAG(F("Ethernet cable connected"));
       connected=true;
       #ifdef IP_ADDRESS
+      #ifndef STM32_ETHERNET
       Ethernet.setLocalIP(myIP);      // for static IP, set it again
       #endif
-      IPAddress ip = Ethernet.localIP();    // look what IP was obtained (dynamic or static)
+      #endif
+      #if defined (STM32_ETHERNET)
+      netif_set_hostname(&gnetif, WIFI_HOSTNAME);   // Should probably be passed in the contructor...
+      #ifdef IP_ADDRESS
+      Ethernet.begin(myIP);
+      #else
+      Ethernet.begin();
+      #endif // IP_ADDRESS
+      #endif // STM32_ETHERNET
+
       server = new EthernetServer(IP_PORT); // Ethernet Server listening on default port IP_PORT
       server->begin();
-      LCD(4,F("IP: %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
+      #ifndef IP_ADDRESS
-      LCD(5,F("Port:%d"), IP_PORT);
+      LCD(4,F("Awaiting DHCP..."));
+      IPAddress ip = Ethernet.localIP(); // look what IP was obtained (dynamic or static)
+      if (ip[0] == 0) {
+        DIAG(F("Awaiting DHCP... ip was %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
+      }
+      while (ip[0] == 0) {        // wait until we are given an IP address from the DHCP server
+        DIAG(F("Awaiting DHCP... ip was %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
+        ip = Ethernet.localIP(); // look what IP was obtained (dynamic or static)
+      }
+      #else
+      IPAddress ip = Ethernet.localIP(); // look what IP was obtained (dynamic or static)
+      #endif
+      if (MAX_MSG_SIZE < 20) {
+        LCD(4,F("%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
+        LCD(5,F("Port:%d  Eth"), IP_PORT);
+      } else {
+        LCD(4,F("%d.%d.%d.%d:%d"), ip[0], ip[1], ip[2], ip[3], IP_PORT);
+      }
+      mdns.begin(Ethernet.localIP(), WIFI_HOSTNAME); // hostname
+      mdns.addServiceRecord(WIFI_HOSTNAME "._withrottle", IP_PORT, MDNSServiceTCP);
       // only create a outboundRing it none exists, this may happen if the cable
       // gets disconnected and connected again
       if(!outboundRing)
-	outboundRing=new RingStream(OUTBOUND_RING_SIZE);
+      	outboundRing=new RingStream(OUTBOUND_RING_SIZE);
     }
     return true;
-  } else { // connected
+  } else { // LinkOFF
-    DIAG(F("Ethernet cable disconnected"));
+    if (connected) {  // Were connected, but no longer without a LINK!
-    connected=false;
+      DIAG(F("Ethernet cable disconnected"));
-    //clean up any client
+      connected=false;
-    for (byte socket = 0; socket < MAX_SOCK_NUM; socket++) {
+      //clean up any client
-      if(clients[socket].connected())
+      for (byte socket = 0; socket < MAX_SOCK_NUM; socket++) {
-	clients[socket].stop();
+        if(clients[socket].connected())
+          clients[socket].stop();
+      }
+      mdns.removeServiceRecord(IP_PORT, MDNSServiceTCP);
+      // tear down server
+      delete server;
+      server = nullptr;
+      LCD(4,F("Ethernet DOWN"));
     }
-    // tear down server
-    delete server;
-    server = nullptr;
-    LCD(4,F("IP: None"));
   }
   return false;
 }
@@ -175,23 +242,34 @@ void EthernetInterface::loop2() {
       return;
     }
     // get client from the server
+  #if defined (STM32_ETHERNET)
+    // STM32Ethernet doesn't use accept(), just available()
+    EthernetClient client = server->available();
+  #else
     EthernetClient client = server->accept();
-
+  #endif
     // check for new client
     if (client)
     {
-        if (Diag::ETHERNET) DIAG(F("Ethernet: New client "));
         byte socket;
-        for (socket = 0; socket < MAX_SOCK_NUM; socket++)
+	bool sockfound = false;
-        {
+        for (socket = 0; socket < MAX_SOCK_NUM; socket++) {
-            if (!clients[socket])
+          if (clients[socket] && (clients[socket] == client)) {
-            {
+	    sockfound = true;
-                // On accept() the EthernetServer doesn't track the client anymore
+	    if (Diag::ETHERNET) DIAG(F("Ethernet: Old client socket %d"),socket);
-                // so we store it in our client array
+	    break;
-                if (Diag::ETHERNET) DIAG(F("Socket %d"),socket);
+          }
-                clients[socket] = client;
+	}
-                break;
+	if (!sockfound) { // new client
+	  for (socket = 0; socket < MAX_SOCK_NUM; socket++) {
+	    if (!clients[socket]) {
+	      // On accept() the EthernetServer doesn't track the client anymore
+	      // so we store it in our client array
+	      clients[socket] = client;
+	      if (Diag::ETHERNET) DIAG(F("Ethernet: New client socket %d"),socket);
+	      break;
             }
+	  }
         }
         if (socket==MAX_SOCK_NUM) DIAG(F("new Ethernet OVERFLOW")); 
     }
@@ -199,30 +277,35 @@ void EthernetInterface::loop2() {
     // check for incoming data from all possible clients
     for (byte socket = 0; socket < MAX_SOCK_NUM; socket++)
     {
-        if (clients[socket]) {
+      if (clients[socket]) {
+	if (!clients[socket].connected()) { // stop any clients which disconnect
+	  CommandDistributor::forget(socket);
+	  clients[socket].stop();
+  #if defined(ARDUINO_ARCH_AVR)
+	  clients[socket]=NULL;
+  #else
+	  clients[socket]=(EthernetClient)nullptr;
+  #endif
+	  //if (Diag::ETHERNET)
+	  DIAG(F("Ethernet: disconnect %d "), socket);
+	  return; // Trick: So that we do not continue in this loop with client that is NULL
+	}
         
-        int available=clients[socket].available();
+	int available=clients[socket].available();
-        if (available > 0) {
+	if (available > 0) {
-            if (Diag::ETHERNET)  DIAG(F("Ethernet: available socket=%d,avail=%d"), socket, available);
+	  if (Diag::ETHERNET)  DIAG(F("Ethernet: available socket=%d,avail=%d"), socket, available);
-            // read bytes from a client
+	  // read bytes from a client
-            int count = clients[socket].read(buffer, MAX_ETH_BUFFER);
+	  int count = clients[socket].read(buffer, MAX_ETH_BUFFER);
-            buffer[count] = '\0'; // terminate the string properly
+	  buffer[count] = '\0'; // terminate the string properly
-            if (Diag::ETHERNET) DIAG(F(",count=%d:%e"), socket,buffer);
+	  if (Diag::ETHERNET) DIAG(F(",count=%d:%e"), socket,buffer);
-            // execute with data going directly back
+	  // execute with data going directly back
-            CommandDistributor::parse(socket,buffer,outboundRing);
+	  CommandDistributor::parse(socket,buffer,outboundRing);
-            return; // limit the amount of processing that takes place within 1 loop() cycle. 
+	  return; // limit the amount of processing that takes place within 1 loop() cycle.
-          }
+	}
-        }
+      }
     }
 
-    // stop any clients which disconnect
+    mdns.run();
-   for (int socket = 0; socket<MAX_SOCK_NUM; socket++) {
-     if (clients[socket] && !clients[socket].connected()) {
-      clients[socket].stop();
-      CommandDistributor::forget(socket);          
-      if (Diag::ETHERNET)  DIAG(F("Ethernet: disconnect %d "), socket);             
-     }
-    }
 
     WiThrottle::loop(outboundRing);
     

EthernetInterface.h

@@ -35,8 +35,18 @@
 #if defined (ARDUINO_TEENSY41)
  #include <NativeEthernet.h>         //TEENSY Ethernet Treiber
  #include <NativeEthernetUdp.h>   
+ #define MAX_SOCK_NUM 4
+#elif defined (ARDUINO_NUCLEO_F429ZI) || defined (ARDUINO_NUCLEO_F439ZI)
+ #include <LwIP.h>
+//  #include "STM32lwipopts.h"
+ #include <STM32Ethernet.h>
+ #include <lwip/netif.h>
+ extern "C" struct netif gnetif;
+ #define STM32_ETHERNET
+ #define MAX_SOCK_NUM 10
 #else
  #include "Ethernet.h"
+//  #define MAX_SOCK_NUM 4
 #endif
 #include "RingStream.h"
 

GITHUB_SHA.h

@@ -1 +1 @@
-#define GITHUB_SHA "devel-202404061747Z"
+#define GITHUB_SHA "devel-stm32ECa-202404070538Z"

I2CManager.cpp

@@ -66,8 +66,9 @@ static const FSH * guessI2CDeviceType(uint8_t address) {
     return F("Real-time clock"); 
   else if (address >= 0x70 && address <= 0x77)
     return F("I2C Mux");
-  else
+  else if (address >= 0x90 && address <= 0xAE)
-    return F("?");
+    return F("UART");
+  return F("?");
 }
 
 // If not already initialised, initialise I2C

I2CManager_STM32.h

@@ -39,7 +39,7 @@
 #if defined(I2C_USE_INTERRUPTS) && defined(ARDUINO_ARCH_STM32)
 #if defined(ARDUINO_NUCLEO_F401RE) || defined(ARDUINO_NUCLEO_F411RE) || defined(ARDUINO_NUCLEO_F446RE) \
     || defined(ARDUINO_NUCLEO_F412ZG) || defined(ARDUINO_NUCLEO_F413ZH) \
-    || defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F446ZE)
+    || defined(ARDUINO_NUCLEO_F429ZI) || defined(ARDUINO_NUCLEO_F439ZI) || defined(ARDUINO_NUCLEO_F446ZE)
 // Assume I2C1 for now - default I2C bus on Nucleo-F411RE and likely all Nucleo-64
 // and Nucleo-144 variants
 I2C_TypeDef *s = I2C1;
@@ -184,7 +184,7 @@ void I2CManagerClass::I2C_init()
   GPIOB->OTYPER |= (1<<8) | (1<<9);           // PB8 and PB9 set to open drain output capability
   GPIOB->OSPEEDR |= (3<<(8*2)) | (3<<(9*2));  // PB8 and PB9 set to High Speed mode
   GPIOB->PUPDR &= ~((3<<(8*2)) | (3<<(9*2))); // Clear all PUPDR bits for PB8 and PB9
-  GPIOB->PUPDR |= (1<<(8*2)) | (1<<(9*2));    // PB8 and PB9 set to pull-up capability
+  // GPIOB->PUPDR |= (1<<(8*2)) | (1<<(9*2));    // PB8 and PB9 set to pull-up capability
   // Alt Function High register routing pins PB8 and PB9 for I2C1:
   // Bits (3:2:1:0) = 0:1:0:0 --> AF4 for pin PB8
   // Bits (7:6:5:4) = 0:1:0:0 --> AF4 for pin PB9

IODevice.h

@@ -22,7 +22,8 @@
 #define iodevice_h
 
 // Define symbol DIAG_IO to enable diagnostic output
-//#define DIAG_IO Y
+//#define DIAG_IO
+
 
 // Define symbol DIAG_LOOPTIMES to enable CS loop execution time to be reported
 //#define DIAG_LOOPTIMES

IO_CMRI.cpp

@@ -0,0 +1,316 @@
+/*
+ *  © 2023, Neil McKechnie. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "IO_CMRI.h"
+#include "defines.h"
+
+/************************************************************
+ * CMRIbus implementation
+ ************************************************************/
+
+// Constructor for CMRIbus
+CMRIbus::CMRIbus(uint8_t busNo, HardwareSerial &serial, unsigned long baud, uint16_t cycleTimeMS, VPIN transmitEnablePin) {
+  _busNo = busNo;
+  _serial = &serial;
+  _baud = baud;
+  _cycleTime = cycleTimeMS * 1000UL; // convert from milliseconds to microseconds.
+  _transmitEnablePin = transmitEnablePin;
+  if (_transmitEnablePin != VPIN_NONE) {
+    pinMode(_transmitEnablePin, OUTPUT);
+    ArduinoPins::fastWriteDigital(_transmitEnablePin, 0); // transmitter initially off
+  }
+
+  // Max message length is 256+6=262 bytes.  
+  // Each byte is one start bit, 8 data bits and 1 or 2 stop bits, assume 11 bits per byte.  
+  // Calculate timeout based on treble this time.
+  _timeoutPeriod = 3 * 11 * 262 * 1000UL / (_baud / 1000UL);
+#if defined(ARDUINOCMRI_COMPATIBLE)
+  // NOTE: The ArduinoCMRI library, unless modified, contains a 'delay(50)' between 
+  // receiving the end of the prompt message and starting to send the response.  This
+  // is allowed for below.
+  _timeoutPeriod += 50000UL;
+#endif
+  
+  // Calculate the time in microseconds to transmit one byte (11 bits max).
+  _byteTransmitTime = 1000000UL * 11 / _baud;
+  // Postdelay is only required if we need to allow for data still being sent when
+  // we want to switch off the transmitter.  The flush() method of HardwareSerial
+  // ensures that the data has completed being sent over the line.
+  _postDelay = 0;
+  
+  // Add device to HAL device chain
+  IODevice::addDevice(this);
+
+  // Add bus to CMRIbus chain.
+  _nextBus = _busList;
+  _busList = this;
+}
+
+
+// Main loop function for CMRIbus.
+// Work through list of nodes.  For each node, in separate loop entries
+// send initialisation message (once only);  then send
+// output message;  then send prompt for input data, and 
+// process any response data received.
+// When the slot time has finished, move on to the next device.
+void CMRIbus::_loop(unsigned long currentMicros) {
+  
+  _currentMicros = currentMicros;
+
+  while (_serial->available())
+    processIncoming();
+
+  // Send any data that needs sending.
+  processOutgoing();
+
+}
+
+// Send output data to the bus for nominated CMRInode
+uint16_t CMRIbus::sendData(CMRInode *node) {
+  uint16_t numDataBytes = (node->getNumOutputs()+7)/8;
+  _serial->write(SYN);
+  _serial->write(SYN);
+  _serial->write(STX);
+  _serial->write(node->getAddress() + 65);
+  _serial->write('T'); // T for Transmit data message
+  uint16_t charsSent = 6; // include header and trailer
+  for (uint8_t index=0; index<numDataBytes; index++) {
+    uint8_t value = node->getOutputStates(index);
+    if (value == DLE || value == STX || value == ETX) {
+      _serial->write(DLE); 
+      charsSent++;
+    }
+    _serial->write(value);
+    charsSent++;
+  }
+  _serial->write(ETX);
+  return charsSent;  // number of characters sent
+}
+
+// Send request for input data to nominated CMRInode.
+uint16_t CMRIbus::requestData(CMRInode *node) {
+  _serial->write(SYN);
+  _serial->write(SYN);
+  _serial->write(STX);
+  _serial->write(node->getAddress() + 65);
+  _serial->write('P'); // P for Poll message
+  _serial->write(ETX);
+  return 6;  // number of characters sent
+}
+
+// Send initialisation message
+uint16_t CMRIbus::sendInitialisation(CMRInode *node) {
+  _serial->write(SYN);
+  _serial->write(SYN);
+  _serial->write(STX);
+  _serial->write(node->getAddress() + 65);
+  _serial->write('I'); // I for initialise message
+  _serial->write(node->getType());  // NDP
+  _serial->write((uint8_t)0);  // dH
+  _serial->write((uint8_t)0);  // dL
+  _serial->write((uint8_t)0);  // NS
+  _serial->write(ETX);
+  return 10;  // number of characters sent
+}
+
+void CMRIbus::processOutgoing() {
+  uint16_t charsSent = 0;
+  if (_currentNode == NULL) {
+    // If we're between read/write cycles then don't do anything else.
+    if (_currentMicros - _cycleStartTime < _cycleTime) return;
+    // ... otherwise start processing the first node in the list
+    _currentNode = _nodeListStart;
+    _transmitState = TD_INIT;
+    _cycleStartTime = _currentMicros;
+  }
+  if (_currentNode == NULL) return;
+  switch (_transmitState) {
+    case TD_IDLE:
+    case TD_INIT:
+      enableTransmitter();
+      if (!_currentNode->isInitialised()) {
+        charsSent = sendInitialisation(_currentNode);
+        _currentNode->setInitialised();
+        _transmitState = TD_TRANSMIT;
+        delayUntil(_currentMicros+_byteTransmitTime*charsSent);
+        break;
+      }
+      /* fallthrough */
+    case TD_TRANSMIT:
+      charsSent = sendData(_currentNode);
+      _transmitState = TD_PROMPT;
+      // Defer next entry for as long as it takes to transmit the characters, 
+      // to allow output queue to empty.  Allow 2 bytes extra.
+      delayUntil(_currentMicros+_byteTransmitTime*(charsSent+2));
+      break;
+    case TD_PROMPT:
+      charsSent = requestData(_currentNode);
+      disableTransmitter();
+      _transmitState = TD_RECEIVE;
+      _timeoutStart = _currentMicros; // Start timeout on response
+      break;
+    case TD_RECEIVE: // Waiting for response / timeout
+      if (_currentMicros - _timeoutStart > _timeoutPeriod) { 
+        // End of time slot allocated for responses.
+        _transmitState = TD_IDLE;
+        // Reset state of receiver
+        _receiveState = RD_SYN1;
+        // Move to next node
+        _currentNode = _currentNode->getNext();
+      }
+      break;
+  }
+}
+
+// Process any data bytes received from a CMRInode.
+void CMRIbus::processIncoming() {
+  int data = _serial->read();
+  if (data < 0) return;     // No characters to read
+
+  if (_transmitState != TD_RECEIVE || !_currentNode) return;   // Not waiting for input, so ignore.
+
+  uint8_t nextState = RD_SYN1;  // default to resetting state machine
+  switch(_receiveState) {
+    case RD_SYN1: 
+      if (data == SYN) nextState = RD_SYN2; 
+      break;
+    case RD_SYN2:
+      if (data == SYN) nextState = RD_STX; else nextState = RD_SYN2;
+      break;
+    case RD_STX:
+      if (data == STX) nextState = RD_ADDR;
+      break;
+    case RD_ADDR:
+      // If address doesn't match, then ignore everything until next SYN-SYN-STX.
+      if (data == _currentNode->getAddress() + 65) nextState = RD_TYPE;
+      break;
+    case RD_TYPE:
+      _receiveDataIndex = 0;  // Initialise data pointer
+      if (data == 'R') nextState = RD_DATA;
+      break;
+    case RD_DATA: // data body
+      if (data == DLE) // escape next character
+        nextState = RD_ESCDATA;
+      else if (data == ETX) { // end of data
+        // End of data message.  Protocol has all data in one
+        // message, so we don't need to wait any more.  Allow
+        // transmitter to proceed with next node in list.
+        _currentNode = _currentNode->getNext();
+        _transmitState = TD_IDLE;
+      } else {
+        // Not end yet, so save data byte
+        _currentNode->saveIncomingData(_receiveDataIndex++, data);
+        nextState = RD_DATA; // wait for more data
+      }
+      break;
+    case RD_ESCDATA: // escaped data byte
+      _currentNode->saveIncomingData(_receiveDataIndex++, data);
+      nextState = RD_DATA;
+      break;
+  }
+  _receiveState = nextState;
+}
+
+// If configured for half duplex RS485, switch RS485 interface
+// into transmit mode.
+void CMRIbus::enableTransmitter() {
+  if (_transmitEnablePin != VPIN_NONE) 
+    ArduinoPins::fastWriteDigital(_transmitEnablePin, 1);
+  // If we need a delay before we start the packet header, 
+  // we can send a character or two to synchronise the 
+  // transmitter and receiver.
+  // SYN characters should be used, but a bug in the
+  // ArduinoCMRI library causes it to ignore the packet if
+  // it's preceded by an odd number of SYN characters.
+  // So send a SYN followed by a NUL in that case.
+  _serial->write(SYN);
+#if defined(ARDUINOCMRI_COMPATIBLE)
+  _serial->write(NUL);  // Reset the ArduinoCMRI library's parser
+#endif
+}
+
+// If configured for half duplex RS485, switch RS485 interface
+// into receive mode.
+void CMRIbus::disableTransmitter() {
+  // Wait until all data has been transmitted.  On the standard
+  // AVR driver, this waits until the FIFO is empty and all
+  // data has been sent over the link.
+  _serial->flush();
+  // If we don't trust the 'flush' function and think the 
+  // data's still in transit, then wait a bit longer.
+  if (_postDelay > 0)
+    delayMicroseconds(_postDelay);
+  // Hopefully, we can now safely switch off the transmitter.
+  if (_transmitEnablePin != VPIN_NONE) 
+    ArduinoPins::fastWriteDigital(_transmitEnablePin, 0);
+}    
+
+// Link to chain of CMRI bus instances
+CMRIbus *CMRIbus::_busList = NULL;
+
+
+/************************************************************
+ * CMRInode implementation
+ ************************************************************/
+
+// Constructor for CMRInode object
+CMRInode::CMRInode(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t address, char type, uint16_t inputs, uint16_t outputs) {
+  _firstVpin = firstVpin;
+  _nPins = nPins;
+  _busNo = busNo;
+  _address = address;
+  _type = type;
+
+  switch (_type) {
+    case 'M': // SMINI, fixed 24 inputs and 48 outputs
+      _numInputs = 24;
+      _numOutputs = 48;
+      break;
+    case 'C': // CPNODE with 16 to 144 inputs/outputs using 8-bit cards
+      _numInputs = inputs;
+      _numOutputs = outputs;
+      break;
+    case 'N': // Classic USIC and SUSIC using 24 bit i/o cards
+    case 'X': // SUSIC using 32 bit i/o cards
+    default:
+      DIAG(F("CMRInode: bus:%d address:%d ERROR unsupported type %c"), _busNo, _address, _type);
+      return; // Don't register device.
+  }
+  if ((unsigned int)_nPins < _numInputs + _numOutputs)
+    DIAG(F("CMRInode: bus:%d address:%d WARNING number of Vpins does not cover all inputs and outputs"), _busNo, _address);
+
+  // Allocate memory for states
+  _inputStates = (uint8_t *)calloc((_numInputs+7)/8, 1);
+  _outputStates = (uint8_t *)calloc((_numOutputs+7)/8, 1);
+  if (!_inputStates || !_outputStates) {
+    DIAG(F("CMRInode: ERROR insufficient memory"));
+    return;
+  }
+
+  // Add this device to HAL device list
+  IODevice::addDevice(this);
+
+  // Add CMRInode to CMRIbus object.
+  CMRIbus *bus = CMRIbus::findBus(_busNo);
+  if (bus != NULL) {
+    bus->addNode(this);
+    return;
+  }
+}
+

IO_CMRI.h

@@ -0,0 +1,293 @@
+/*
+ *  © 2023, Neil McKechnie. All rights reserved.
+ *  
+ *  This file is part of DCC++EX API
+ *
+ *  This is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  It is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CommandStation.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * CMRIbus
+ * =======
+ * To define a CMRI bus, example syntax:
+ *    CMRIbus::create(bus, serial, baud[, cycletime[, pin]]);
+ * 
+ * bus = 0-255
+ * serial = serial port to be used (e.g. Serial3)
+ * baud = baud rate (9600, 19200, 28800, 57600 or 115200)
+ * cycletime = minimum time between successive updates/reads of a node in millisecs (default 500ms)
+ * pin = pin number connected to RS485 module's DE and !RE terminals for half-duplex operation (default VPIN_NONE)
+ * 
+ * Each bus must use a different serial port.
+ * 
+ * IMPORTANT: If you are using ArduinoCMRI library code by Michael Adams, at the time of writing this library
+ * is not compliant with the LCS-9.10.1 specification for CMRInet protocol.  
+ * Various work-arounds may be enabled within the driver by adding the following line to your config.h file,
+ * to allow nodes running the ArduinoCMRI library to communicate:
+ * 
+ *  #define ARDUINOCMRI_COMPATIBLE
+ * 
+ * CMRINode
+ * ========
+ * To define a CMRI node and associate it with a CMRI bus,
+ *    CMRInode::create(firstVPIN, numVPINs, bus, address, type [, inputs, outputs]);
+ * 
+ * firstVPIN = first vpin in block allocated to this device
+ * numVPINs = number of vpins (e.g. 72 for an SMINI node)
+ * bus = 0-255
+ * address = 0-127
+ * type = 'M' for SMINI (fixed 24 inputs and 48 outputs)
+ *        'C' for CPNODE (16 to 144 inputs/outputs in groups of 8)
+ *        (other types are not supported at this time).
+ * inputs = number of inputs (CPNODE only)
+ * outputs = number of outputs (CPNODE only)
+ * 
+ * Reference: "LCS-9.10.1
+ *             Layout Control Specification: CMRInet Protocol
+ *             Version 1.1 December 2014."
+ */
+
+#ifndef IO_CMRI_H
+#define IO_CMRI_H
+
+#include "IODevice.h"
+
+/**********************************************************************
+ * CMRInode class
+ * 
+ * This encapsulates the state associated with a single CMRI node, 
+ * which includes the address type, number of inputs and outputs, and
+ * the states of the inputs and outputs.
+ **********************************************************************/
+class CMRInode : public IODevice {
+private:
+  uint8_t _busNo;
+  uint8_t _address;
+  char _type;
+  CMRInode *_next = NULL;
+  uint8_t *_inputStates = NULL;
+  uint8_t *_outputStates = NULL;
+  uint16_t _numInputs = 0;
+  uint16_t _numOutputs = 0;
+  bool _initialised = false;
+
+public:
+  static void create(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t address, char type, uint16_t inputs=0, uint16_t outputs=0) {
+    if (checkNoOverlap(firstVpin, nPins)) new CMRInode(firstVpin, nPins, busNo, address, type, inputs, outputs);
+  }
+  CMRInode(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t address, char type, uint16_t inputs=0, uint16_t outputs=0);
+
+  uint8_t getAddress() {
+    return _address;
+  }
+  CMRInode *getNext() {
+    return _next;
+  }
+  void setNext(CMRInode *node) {
+    _next = node;
+  }
+  bool isInitialised() {
+    return _initialised;
+  }
+  void setInitialised() {
+    _initialised = true;
+  }
+
+  void _begin() {
+    _initialised = false;
+  }
+
+  int _read(VPIN vpin) {
+    // Return current state from this device
+    uint16_t pin = vpin - _firstVpin;
+    if (pin < _numInputs) {
+      uint8_t mask = 1 << (pin & 0x7);
+      int index = pin / 8;
+      return (_inputStates[index] & mask) != 0;
+    } else
+      return 0;
+  }
+
+  void _write(VPIN vpin, int value) {
+    // Update current state for this device, in preparation the bus transmission
+    uint16_t pin = vpin - _firstVpin - _numInputs;
+    if (pin < _numOutputs) {
+      uint8_t mask = 1 << (pin & 0x7);
+      int index = pin / 8;
+      if (value)
+        _outputStates[index] |= mask;
+      else
+        _outputStates[index] &= ~mask;
+    }
+  }
+
+  void saveIncomingData(uint8_t index, uint8_t data) {
+    if (index < (_numInputs+7)/8)
+      _inputStates[index] = data;
+  }
+
+  uint8_t getOutputStates(uint8_t index) {
+    if (index < (_numOutputs+7)/8)
+      return _outputStates[index];
+    else
+      return 0;
+  }
+
+  uint16_t getNumInputs() {
+    return _numInputs;
+  }
+
+  uint16_t getNumOutputs() {
+    return _numOutputs;
+  }
+
+  char getType() {
+    return _type; 
+  }
+
+  uint8_t getBusNumber() {
+    return _busNo;
+  }
+
+  void _display() override {
+    DIAG(F("CMRInode type:'%c' configured on bus:%d address:%d VPINs:%u-%u (in) %u-%u (out)"),
+      _type, _busNo, _address, _firstVpin, _firstVpin+_numInputs-1,
+      _firstVpin+_numInputs, _firstVpin+_numInputs+_numOutputs-1);
+  }
+
+};
+
+/**********************************************************************
+ * CMRIbus class
+ * 
+ * This encapsulates the properties state of the bus and the
+ * transmission and reception of data across that bus.  Each CMRIbus
+ * object owns a set of CMRInode objects which represent the nodes
+ * attached to that bus.
+ **********************************************************************/
+class CMRIbus : public IODevice {
+private:
+  // Here we define the device-specific variables.  
+  uint8_t _busNo;
+  HardwareSerial *_serial;
+  unsigned long _baud;
+  VPIN _transmitEnablePin = VPIN_NONE;
+  CMRInode *_nodeListStart = NULL, *_nodeListEnd = NULL;
+  CMRInode *_currentNode = NULL;
+
+  // Transmitter state machine states
+  enum {TD_IDLE, TD_PRETRANSMIT, TD_INIT, TD_TRANSMIT, TD_PROMPT, TD_RECEIVE};
+  uint8_t _transmitState = TD_IDLE;
+  // Receiver state machine states.
+  enum {RD_SYN1, RD_SYN2, RD_STX, RD_ADDR, RD_TYPE, 
+      RD_DATA, RD_ESCDATA, RD_SKIPDATA, RD_SKIPESCDATA, RD_ETX};
+  uint8_t _receiveState = RD_SYN1;
+  uint16_t _receiveDataIndex = 0;  // Index of next data byte to be received.
+  CMRIbus *_nextBus = NULL;  // Pointer to next bus instance in list.
+  unsigned long _cycleStartTime = 0;
+  unsigned long _timeoutStart = 0;
+  unsigned long _cycleTime; // target time between successive read/write cycles, microseconds
+  unsigned long _timeoutPeriod; // timeout on read responses, in microseconds.
+  unsigned long _currentMicros;  // last value of micros() from _loop function.
+  unsigned long _postDelay; // delay time after transmission before switching off transmitter (in us)
+  unsigned long _byteTransmitTime; // time in us for transmission of one byte
+
+  static CMRIbus *_busList; // linked list of defined bus instances
+
+  // Definition of special characters in CMRInet protocol
+  enum : uint8_t {
+    NUL = 0x00,
+    STX = 0x02,
+    ETX = 0x03,
+    DLE = 0x10,
+    SYN = 0xff,
+  };
+
+public:
+  static void create(uint8_t busNo, HardwareSerial &serial, unsigned long baud, uint16_t cycleTimeMS=500, VPIN transmitEnablePin=VPIN_NONE) {
+    new CMRIbus(busNo, serial, baud, cycleTimeMS, transmitEnablePin);
+  } 
+
+  // Device-specific initialisation
+  void _begin() override {
+    // CMRInet spec states one stop bit, JMRI and ArduinoCMRI use two stop bits
+#if defined(ARDUINOCMRI_COMPATIBLE)
+    _serial->begin(_baud, SERIAL_8N2);
+#else
+    _serial->begin(_baud, SERIAL_8N1);
+#endif
+  #if defined(DIAG_IO)
+    _display();
+  #endif
+  }
+
+  // Loop function (overriding IODevice::_loop(unsigned long))
+  void _loop(unsigned long currentMicros) override;
+
+  // Display information about the device
+  void _display() override {
+    DIAG(F("CMRIbus %d configured, speed=%d baud, cycle=%d ms"), _busNo, _baud, _cycleTime/1000);
+  }
+
+  // Locate CMRInode object with specified address.
+  CMRInode *findNode(uint8_t address) {
+    for (CMRInode *node = _nodeListStart; node != NULL; node = node->getNext()) {
+      if (node->getAddress() == address) 
+        return node;
+    }
+    return NULL;
+  }
+
+  // Add new CMRInode to the list of nodes for this bus.
+  void addNode(CMRInode *newNode) {
+    if (!_nodeListStart)
+      _nodeListStart = newNode;
+    if (!_nodeListEnd) 
+      _nodeListEnd = newNode;
+    else {
+      _nodeListEnd->setNext(newNode);
+      _nodeListEnd = newNode;
+    }
+  }
+
+protected:
+  CMRIbus(uint8_t busNo, HardwareSerial &serial, unsigned long baud, uint16_t cycleTimeMS, VPIN transmitEnablePin);
+  uint16_t sendData(CMRInode *node);
+  uint16_t requestData(CMRInode *node);
+  uint16_t sendInitialisation(CMRInode *node);
+
+  // Process any data bytes received from a CMRInode.
+  void processIncoming();
+  // Process any outgoing traffic that is due.
+  void processOutgoing();
+  // Enable transmitter
+  void enableTransmitter();
+  // Disable transmitter and enable receiver
+  void disableTransmitter();
+
+
+public:
+  uint8_t getBusNumber() {
+    return _busNo;
+  }
+
+  static CMRIbus *findBus(uint8_t busNo) {
+    for (CMRIbus *bus=_busList; bus!=NULL; bus=bus->_nextBus) {
+      if (bus->_busNo == busNo) return bus;
+    }
+    return NULL;
+  }
+};
+
+#endif // IO_CMRI_H

IO_Template.h

@@ -0,0 +1,69 @@
+
+/*
+* Creation - a create() function and constructor are required;
+* Initialisation - a _begin() function is written (optional);
+* Background operations - a _loop() function is written (optional);
+* Operations - you can optionally supply any of _write() (digital) function, _writeAnalogue() function, _read() (digital) function and _readAnalogue() function.
+*
+*
+*
+*
+*
+*
+*/
+
+
+#ifndef IO_MYDEVICE_H
+#define IO_MYDEVICE_H
+
+#include "IODevice.h"
+#include "DIAG.h"  // for DIAG calls
+
+class MyDevice: public IODevice {
+public:
+  // Constructor
+  MyDevice(VPIN firstVpin, int nPins) {
+    _firstVpin = firstVpin;
+    _nPins = min(nPins,16);
+    // Other object initialisation here
+    // ...
+    addDevice(this);
+  }
+  static void create(VPIN firstVpin, int nPins, uint8_t i2cAddress) {
+    new MyDevice(firstVpin, nPins);
+  }
+private:
+  void _begin() override {
+    // Initialise device
+    // ...
+  }
+  void _loop(unsigned long currentMicros) override {
+    // Regular operations, e.g. acquire data
+    // ...
+    delayUntil(currentMicros + 10*1000UL);  // 10ms till next entry
+  }
+  int _readAnalogue(VPIN vpin) override {
+    // Return acquired data value, e.g.
+    int pin = vpin - _firstVpin;
+    return _value[pin];
+  }
+  int _read(VPIN vpin) override {
+    // Return acquired data value, e.g.
+    int pin = vpin - _firstVpin;
+    return _value[pin];
+  }
+  void write(VPIN vpin, int value) override {
+    // Do something with value , e.g. write to device.
+    // ...
+  }
+  void writeAnalogue(VPIN vpin, int value) override {
+    // Do something with value, e.g. write to device.
+    // ...
+  }
+  void _display() override {
+    DIAG(F("MyDevice Configured on Vpins:%d-%d %S"), _firstVpin, _firstVpin+_nPins-1,
+      _deviceState == DEVSTATE_FAILED ? F("OFFLINE") : F(""));
+  }
+  uint16_t _value[16];
+};
+#endif // IO_MYDEVICE_H

WiThrottle.cpp

@@ -134,7 +134,7 @@ void WiThrottle::parse(RingStream * stream, byte * cmdx) {
         StringFormatter::send(stream,F("*%d\nHMConnected\n"),HEARTBEAT_SECONDS);
 
     }
-  }
+  }  else sendIntro(stream);
   
   while (cmd[0]) {
     switch (cmd[0]) {

WifiESP32.cpp

@@ -181,7 +181,13 @@ bool WifiESP::setup(const char *SSid,
     if (WiFi.status() == WL_CONNECTED) {
       // 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());
+      //
+      if (MAX_MSG_SIZE < 20) {
+        LCD(4, F("%s"), WiFi.localIP().toString().c_str());
+        LCD(5,F("Port: %d"), IP_PORT);
+      } else {
+        LCD(4, F("%s:%d"), WiFi.localIP().toString().c_str(), IP_PORT);
+      }  
       wifiUp = true;
     } else {
       DIAG(F("Could not connect to Wifi SSID %s"),SSid);
@@ -228,12 +234,17 @@ bool WifiESP::setup(const char *SSid,
 		    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 in AP mode"));
+      DIAG(F("WiFi in AP mode"));
-      LCD(5, F("Wifi: %s"), strSSID.c_str());
+      if (MAX_MSG_SIZE < 20) {
+        LCD(4, F("%s"), WiFi.softAPIP().toString().c_str());
+        LCD(5, F("Port: %d"), IP_PORT);
+      } else {
+        LCD(4, F("%s:%d"), WiFi.softAPIP().toString().c_str(), IP_PORT);
+      }
+      LCD(6, F("WiFi: %s"), strSSID.c_str());
       if (!havePassword)
-	LCD(6, F("PASS: %s"),strPass.c_str());
+	      LCD(7, F("Pass: %s"),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 {

WifiInterface.cpp

@@ -71,8 +71,9 @@ Stream * WifiInterface::wifiStream;
 #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 NUM_SERIAL 3
 #define SERIAL1 Serial6
+#define SERIAL3 Serial2
 #else
 #warning This variant of Nucleo not yet explicitly supported
 #endif
@@ -165,10 +166,10 @@ wifiSerialState WifiInterface::setup(Stream & setupStream,  const FSH* SSid, con
   if (wifiState == WIFI_CONNECTED) {
     StringFormatter::send(wifiStream, F("ATE0\r\n")); // turn off the echo 
     checkForOK(200, true);
-    DIAG(F("WiFi CONNECTED"));
+    DIAG(F("WiFi UP"));
     // LCD already shows IP
   } else {
-    LCD(4,F("WiFi DISCON."));
+    LCD(4,F("WiFi DOWN"));
   }
   return wifiState;
 }
@@ -365,11 +366,14 @@ wifiSerialState WifiInterface::setup2(const FSH* SSid, const FSH* password,
       }
       ipString[ipLen]=ipChar;
     }
-    LCD(4,F("%s"),ipString);  // There is not enough room on some LCDs to put a title to this      
+    if (MAX_MSG_SIZE < 20) {
-  }
+      LCD(4,F("%s"),ipString);  // There is not enough room on some LCDs to put a title to this
-  // suck up anything after the IP. 
+      LCD(5,F("Port: %d"),port);
+    } else {
+      LCD(4,F("%s:%d"), ipString, port);
+    }        
+  } 
   if (!checkForOK(1000, true, false)) return WIFI_DISCONNECTED;
-  LCD(5,F("PORT=%d"),port);
    
   return WIFI_CONNECTED;
 }

myHal.cpp_example.txt

@@ -26,6 +26,16 @@
 //#include "IO_EXFastClock.h"  // FastClock driver
 //#include "IO_PCA9555.h"     // 16-bit I/O expander (NXP & Texas Instruments).
 //#include "IO_I2CDFPlayer.h" // DFPlayer over I2C
+//#include "IO_CMRI.h"      //  CMRI nodes
+
+//==========================================================================
+//  also for CMRI connection using RS485 TTL module
+//==========================================================================
+//  define UARt2 pins for ESP32 Rx=16, Tx=17 -- can conflict if sabertooth defined
+//HardwareSerial mySerial2(2); // use UART2
+//
+//  for SERIAL_8N2 include this in config.h  
+//              #define ARDUINOCMRI_COMPATIBLE
 
 //==========================================================================
 // The function halSetup() is invoked from CS if it exists within the build.
@@ -35,6 +45,36 @@
 
 void halSetup() {
 
+//==========================================================================
+//   CMRI bus and nodes defined
+//==========================================================================
+// further explanation in IO_CMRI.h
+// this example is being used to test connection of existing CMRI device
+// add lines to myHal.cpp within halSetup()
+
+// for ESP32
+//mySerial2.begin(9600, SERIAL_8N2, 16, 17);  // ESP32 to define pins  also check DCCTimerESP.cpp
+//CMRIbus::create(0, mySerial2, 9600, 500, 4);  // for ESP32
+
+// for Mega
+//CMRIbus::create(0, Serial3, 9600, 500, 38);  // for Mega - Serial3 already defined
+ // bus=0 always, unless multiple serial ports are used
+ // baud=9600 to match setting in existing CMRI nodes
+ // cycletime.. 500ms is default -- more frequent might be needed on master
+ // pin..  DE/!RE pins tied together on TTL RS485 module.
+ // pin 38 should work on Mega and F411RE (pin D38 aka PB12 on CN10_16)
+ 
+//CMRInode::create(900, 72, 0, 4, 'M');
+//CMRInode::create(1000, 72, 0, 5, 'M');
+ // bus=0 must agree with bus in CMRIbus
+ // node=4 number to agree with node numbering
+ // 'M' is for SMINI.
+ // Starting VPin, Number of VPins=72 for SMINI
+//==========================================================================
+//         end of CMRI
+//==========================================================================
+
+
   //=======================================================================
   // The following directives define auxiliary display devices.
   // These can be defined in addition to the system display (display

mySetup_h_cmri.txt

@@ -0,0 +1,128 @@
+// mySetup.h
+// defining CMRI accessories
+// CMRI connections defined in myHal.cpp
+//
+// this is for testing.
+SETUP("D CMD 1");
+//  Turnouts defined in myAutomation.h can include descriptions which will appear in Engine Driver
+//  Sensors and digital outputs do not require pre-definition for use in EXRAIL automation
+//
+// SMINI emulation node 24-input/48-outputs
+// the sketch I use
+// 16 or 24 input pins
+// 32 or 48 output pins 
+//
+// Define 16 input pins 1000-1015
+SETUP("S 1000 1000 1");
+SETUP("S 1001 1001 1");
+SETUP("S 1002 1002 1");
+SETUP("S 1003 1003 1");
+SETUP("S 1004 1004 1");
+SETUP("S 1005 1005 1");
+SETUP("S 1006 1006 1");
+SETUP("S 1007 1007 1");
+SETUP("S 1008 1008 1");
+SETUP("S 1009 1009 1");
+SETUP("S 1010 1010 1");
+SETUP("S 1011 1011 1");
+SETUP("S 1012 1012 1");
+SETUP("S 1013 1013 1");
+SETUP("S 1014 1014 1");
+SETUP("S 1015 1015 1");
+//
+//  define 16 turnouts using VPIN (for Throw/Close commands via CMRI)
+SETUP("T 1024 VPIN 1024");
+SETUP("T 1025 VPIN 1025");
+SETUP("T 1026 VPIN 1026");
+SETUP("T 1027 VPIN 1027");
+SETUP("T 1028 VPIN 1028");
+SETUP("T 1029 VPIN 1029");
+SETUP("T 1030 VPIN 1030");
+SETUP("T 1031 VPIN 1031");
+SETUP("T 1032 VPIN 1032");
+SETUP("T 1033 VPIN 1033");
+SETUP("T 1034 VPIN 1034");
+SETUP("T 1035 VPIN 1035");
+SETUP("T 1036 VPIN 1036");
+SETUP("T 1037 VPIN 1037");
+SETUP("T 1038 VPIN 1038");
+SETUP("T 1039 VPIN 1039");
+//
+//  define 16 pins for digital outputs
+SETUP("Z 1040 1040 0");
+SETUP("Z 1041 1041 0");
+SETUP("Z 1042 1042 0");
+SETUP("Z 1043 1043 0");
+SETUP("Z 1044 1044 0");
+SETUP("Z 1045 1045 0");
+SETUP("Z 1046 1046 0");
+SETUP("Z 1047 1047 0");
+SETUP("Z 1048 1048 0");
+SETUP("Z 1049 1049 0");
+SETUP("Z 1050 1050 0");
+SETUP("Z 1051 1051 0");
+SETUP("Z 1052 1052 0");
+SETUP("Z 1053 1053 0");
+SETUP("Z 1054 1054 0");
+SETUP("Z 1055 1055 0");
+//
+//  additional 16 outputs available 1056-1071
+//SETUP("Z 1056 1056 0");
+//
+//  CMRI sketch used for testing available here
+//  https://www.trainboard.com/highball/index.php?threads/24-in-48-out-card-for-jmri.116454/page-2#post-1141569
+//
+
+// Define 16 input pins 900-915
+SETUP("S 900 900 1");
+SETUP("S 901 901 1");
+SETUP("S 902 902 1");
+SETUP("S 903 903 1");
+SETUP("S 904 904 1");
+SETUP("S 905 905 1");
+SETUP("S 906 906 1");
+SETUP("S 907 907 1");
+SETUP("S 908 908 1");
+SETUP("S 909 909 1");
+SETUP("S 910 910 1");
+SETUP("S 911 911 1");
+SETUP("S 912 912 1");
+SETUP("S 913 913 1");
+SETUP("S 914 914 1");
+SETUP("S 915 915 1");
+//
+//  define 16 turnouts using VPIN (for Throw/Close commands via CMRI)
+SETUP("T 924 VPIN 924");
+SETUP("T 925 VPIN 925");
+SETUP("T 926 VPIN 926");
+SETUP("T 927 VPIN 927");
+SETUP("T 928 VPIN 928");
+SETUP("T 929 VPIN 929");
+SETUP("T 930 VPIN 930");
+SETUP("T 931 VPIN 931");
+SETUP("T 932 VPIN 932");
+SETUP("T 933 VPIN 933");
+SETUP("T 934 VPIN 934");
+SETUP("T 935 VPIN 935");
+SETUP("T 936 VPIN 936");
+SETUP("T 937 VPIN 937");
+SETUP("T 938 VPIN 938");
+SETUP("T 939 VPIN 939");
+//
+//  define 16 pins for digital outputs
+SETUP("Z 940 940 0");
+SETUP("Z 941 941 0");
+SETUP("Z 942 942 0");
+SETUP("Z 943 943 0");
+SETUP("Z 944 944 0");
+SETUP("Z 945 945 0");
+SETUP("Z 946 946 0");
+SETUP("Z 947 947 0");
+SETUP("Z 948 948 0");
+SETUP("Z 949 949 0");
+SETUP("Z 950 950 0");
+SETUP("Z 951 951 0");
+SETUP("Z 952 952 0");
+SETUP("Z 953 953 0");
+SETUP("Z 954 954 0");
+SETUP("Z 955 955 0");

platformio.ini

@@ -29,7 +29,6 @@ include_dir = .
 
 [env]
 build_flags = -Wall -Wextra
-; monitor_filters = time
 
 [env:samd21-dev-usb]
 platform = atmelsam
@@ -103,6 +102,7 @@ framework = arduino
 lib_deps = 
 	${env.lib_deps}
 	arduino-libraries/Ethernet
+	MDNS_Generic
 	SPI
 monitor_speed = 115200
 monitor_echo = yes
@@ -242,18 +242,44 @@ monitor_echo = yes
 
 ; Experimental - Ethernet work still in progress
 ;
-; [env:Nucleo-F429ZI]
+[env:Nucleo-F429ZI]
-; platform = ststm32
+platform = ststm32
-; board = nucleo_f429zi
+board = nucleo_f429zi
-; framework = arduino
+framework = arduino
-; lib_deps = ${env.lib_deps}
+lib_deps = ${env.lib_deps}
-; 			arduino-libraries/Ethernet @ ^2.0.1
+			stm32duino/STM32Ethernet @ ^1.3.0
-; 			stm32duino/STM32Ethernet @ ^1.3.0
+			stm32duino/STM32duino LwIP @ ^2.1.2
-; 			stm32duino/STM32duino LwIP @ ^2.1.2
+			MDNS_Generic
-; build_flags = -std=c++17 -Os -g2 -Wunused-variable
+lib_ignore = WiFi101
-; monitor_speed = 115200
+			WiFi101_Generic
-; monitor_echo = yes
+			WiFiEspAT
-; upload_protocol = stlink
+			WiFiMulti_Generic
+			WiFiNINA_Generic
+build_flags = -std=c++17 -Os -g2 -Wunused-variable
+monitor_speed = 115200
+monitor_echo = yes
+upload_protocol = stlink
+
+; Experimental - Ethernet work still in progress
+; Commented out as the F439ZI also needs variant files
+;
+[env:Nucleo-F439ZI]
+platform = ststm32
+board = nucleo_f439zi
+framework = arduino
+lib_deps = ${env.lib_deps}
+			stm32duino/STM32Ethernet @ ^1.3.0
+			stm32duino/STM32duino LwIP @ ^2.1.2
+			MDNS_Generic
+lib_ignore = WiFi101
+			WiFi101_Generic
+			WiFiEspAT
+			WiFiMulti_Generic
+			WiFiNINA_Generic
+build_flags = -std=c++17 -Os -g2 -Wunused-variable
+monitor_speed = 115200
+monitor_echo = yes
+upload_protocol = stlink
 
 [env:Teensy3_2]
 platform = teensy

version.h

@@ -3,13 +3,12 @@
 
 #include "StringFormatter.h"
 
-#define VERSION "5.2.46"
+#define VERSION "5.3.8"
 // 5.2.46 - Support for extended consist CV20 in <R> and <W id>
 //        - New cmd <W CONSIST id [REVERSE]> to handle long/short consist ids
 // 5.2.45 - ESP32 Trackmanager reset cab number to 0 when track is not DC
 //          ESP32 fix PWM LEDC inverted pin mode
 //          ESP32 rewrite PWM LEDC to use pin mux
-// 5.2.42 - ESP32 Bugfix: Uninitialized stack variable
 // 5.2.41 - Update rotary encoder default address to 0x67
 // 5.2.40 - Allow no shield
 // 5.2.39 - Functions for DC frequency: Use func up to F31
@@ -26,6 +25,17 @@
 // 5.2.32 - Railcom Cutout (Initial trial Mega2560 only)
 // 5.2.31 - Exrail JMRI_SENSOR(vpin [,count]) creates <S> types.  
 // 5.2.30 - Bugfix: WiThrottle sendIntro after initial N message as well
+//
+//
+// 5.3.5e - Fixes to ethernet cable handling, and STM32 related handling as well
+// 5.3.5  - Exrail JMRI_SENSORS(vpin [,count]) creates <S> types.
+// 5.3.4  - Bugfix: WiThrottle sendIntro after initial N message as well
+// 5.3.3  - Fix Ethernet cable disconnected message, wait for DHCP
+// 5.3.2  - MDNS Generic library integration for Ethernet
+// 5.3.1  - Variable frequency for DC mode
+// 5.2.40 - Bugfix: WiThrottle sendIntro after initial N message as well
+// 5.2.31 - included in stm32EC as 5.3.5  
+//  -- some duplicates in above list
 // 5.2.29 - Added IO_I2CDFPlayer.h to support DFPLayer over I2C connected to NXP SC16IS750/SC16IS752 (currently only single UART for SC16IS752)
 //        - Added enhanced IO_I2CDFPLayer enum commands to EXRAIL2.h
 //        - Added PLAYSOUND alias of ANOUT to EXRAILMacros.h
@@ -48,8 +58,11 @@
 // 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
+//       df - I2C DFPlayper capability in stm32 branch
 // 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.14eth - Initial ethernet code for STM32F429ZI and F439ZI boards
+//        C - CMRI RS485 connection
 // 5.2.14 - Reminder window DCC packet optimization
 //        - Optional #define DISABLE_FUNCTION_REMINDERS 
 // 5.2.13 - EXRAIL STEALTH