Changed how INPUT_PULLUP is done to be compatibile with ESP32

Bumped version to 2.0.6
bumped NMRADCC_VERSION to 205
2020-10-20 09:42:00 +13:00 · 2020-06-02 09:50:12 +12:00 · 2020-06-01 19:04:56 +12:00 · 2020-06-01 18:49:00 +12:00 · 2020-05-31 20:14:28 +12:00 · 2020-05-30 16:14:27 +12:00
6 changed files with 862 additions and 207 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,2 @@
+.development
+*.zip
--- a/NmraDcc.cpp
+++ b/NmraDcc.cpp
@@ -2,11 +2,21 @@
 //
 // Model Railroading with Arduino - NmraDcc.cpp 
 //
-// Copyright (c) 2008 - 2017 Alex Shepherd
+// Copyright (c) 2008 - 2020 Alex Shepherd
 //
-// This source file is subject of the GNU general public license 2,
-// that is available at the world-wide-web at
-// http://www.gnu.org/licenses/gpl.txt
+// 	This library is free software; you can redistribute it and/or
+// 	modify it under the terms of the GNU Lesser General Public
+// 	License as published by the Free Software Foundation; either
+// 	version 2.1 of the License, or (at your option) any later version.
+// 
+// 	This library 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
+// 	Lesser General Public License for more details.
+// 
+// 	You should have received a copy of the GNU Lesser General Public
+// 	License along with this library; if not, write to the Free Software
+// 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 // 
 //------------------------------------------------------------------------
 //
@@ -25,7 +35,9 @@
 //			  2017-01-19 added STM32F1 support by Franz-Peter
 //            2017-11-29 Ken West (kgw4449@gmail.com):
 //                       Minor fixes to pass NMRA Baseline Conformance Tests.
-//
+//            2018-12-17 added ESP32 support by Trusty (thierry@lapajaparis.net)
+//            2019-02-17 added ESP32 specific changes by Hans Tanner
+//            2020-05-15 changes to pass NMRA Tests ( always search for preamble )
 //------------------------------------------------------------------------
 //
 // purpose:   Provide a simplified interface to decode NMRA DCC packets
@@ -34,12 +46,10 @@
 //------------------------------------------------------------------------

 #include "NmraDcc.h"
-#ifdef __AVR_MEGA__
-#include <avr/eeprom.h>
-#endif
+#include "EEPROM.h"

 // Uncomment to print DEBUG messages
-//#define DEBUG_PRINT		
+// #define DEBUG_PRINT		

 //------------------------------------------------------------------------
 // DCC Receive Routine
@@ -72,26 +82,33 @@
 //           DCC 1: _________XXXXXXXXX_________XXXXXXXXX_________
 //                           |<--------146us------>|
 //                           ^-INTx            ^-INTx
-//                           less than 138us: its a one-Bit
+//                           less than 146us: its a one-Bit
 //                                        
 //
 //                           |<-----------------232us----------->|
 //           DCC 0: _________XXXXXXXXXXXXXXXXXX__________________XXXXXXXX__________
 //                           |<--------146us------->|
 //                           ^-INTx                              ^-INTx
-//                           greater than 138us: its a zero bit
+//                           greater than 146us: its a zero bit
 //                                        
 //                                        
 //                                           
 //           
+
 //------------------------------------------------------------------------
+// if this is commented out, bit synchronisation is only done after a wrong checksum
+#define SYNC_ALWAYS
+
+// if this is commented out, Zero-Bit_Stretching is not supported
+// ( Bits longer than 2* MAX ONEBIT are treated as error )
+#define SUPPORT_ZERO_BIT_STRETCHING

 #define MAX_ONEBITFULL  146
 #define MAX_PRAEAMBEL   146 
 #define MAX_ONEBITHALF  82
 #define MIN_ONEBITFULL  82
 #define MIN_ONEBITHALF  35
-#define MAX_BITDIFF     18
+#define MAX_BITDIFF     24


 // Debug-Ports
@@ -174,9 +191,22 @@
        #define MODE_TP3 pinMode( D7,OUTPUT ) ; // GPIO 13
        #define SET_TP3  GPOS = (1 << D7);
        #define CLR_TP3  GPOC = (1 << D7);
-        #define MODE_TP4 pinMode( D7,OUTPUT ); // GPIO 15
-        #define SET_TP4  GPOC = (1 << D8);
+        #define MODE_TP4 pinMode( D8,OUTPUT ) ; // GPIO 15
+        #define SET_TP4  GPOS = (1 << D8);
        #define CLR_TP4  GPOC = (1 << D8);
+    #elif defined(ESP32)
+        #define MODE_TP1 pinMode( 33,OUTPUT ) ; // GPIO 33
+        #define SET_TP1  GPOS = (1 << 33);
+        #define CLR_TP1  GPOC = (1 << 33);
+        #define MODE_TP2 pinMode( 25,OUTPUT ) ; // GPIO 25
+        #define SET_TP2  GPOS = (1 << 25);
+        #define CLR_TP2  GPOC = (1 << 25);
+        #define MODE_TP3 pinMode( 26,OUTPUT ) ; // GPIO 26
+        #define SET_TP3  GPOS = (1 << 26);
+        #define CLR_TP3  GPOC = (1 << 26);
+        #define MODE_TP4 pinMode( 27,OUTPUT ) ; // GPIO 27
+        #define SET_TP4  GPOS = (1 << 27);
+        #define CLR_TP4  GPOC = (1 << 27);
        
        
    //#elif defined(__AVR_ATmega128__) ||defined(__AVR_ATmega1281__)||defined(__AVR_ATmega2561__)
@@ -202,18 +232,12 @@
    #define MODE_TP2 
    #define SET_TP2 
    #define CLR_TP2 
-        //#define MODE_TP2 DDRC |= (1<<2) // A2
-        //#define SET_TP2 PORTC |= (1<<2)
-        //#define CLR_TP2 PORTC &= ~(1<<2)
    #define MODE_TP3 
    #define SET_TP3 
    #define CLR_TP3 
    #define MODE_TP4 
    #define SET_TP4 
    #define CLR_TP4 
-        //#define MODE_TP4 DDRC |= (1<<4) //A4 
-        //#define SET_TP4 PORTC |= (1<<4) 
-        //#define CLR_TP4 PORTC &= ~(1<<4) 
    
 #endif
 #ifdef DEBUG_PRINT
@@ -230,15 +254,24 @@ struct countOf_t countOf;

 #if defined ( __STM32F1__ )
 static ExtIntTriggerMode ISREdge;
+#elif defined ( ESP32 )
+static byte  ISREdge;   // Holder of the Next Edge we're looking for: RISING or FALLING
+static byte  ISRWatch;  // Interrupt Handler Edge Filter 
 #else
-static byte  ISREdge;   // RISING or FALLING
+static byte  ISREdge;   // Holder of the Next Edge we're looking for: RISING or FALLING
+static byte  ISRWatch;  // Interrupt Handler Edge Filter 
 #endif
+byte ISRLevel;          // expected Level at DCC input during ISR ( to detect glitches )
+byte ISRChkMask;       // Flag if Level must be checked
 static word  bitMax, bitMin;

 typedef enum
 {
  WAIT_PREAMBLE = 0,
  WAIT_START_BIT,
+  #ifndef SYNC_ALWAYS
+  WAIT_START_BIT_FULL,
+  #endif
  WAIT_DATA,
  WAIT_END_BIT
 } 
@@ -259,6 +292,7 @@ struct DccRx_t
  uint8_t         DataReady ;
  uint8_t         BitCount ;
  uint8_t         TempByte ;
+  uint8_t         chkSum;
  DCC_MSG         PacketBuf;
  DCC_MSG         PacketCopy;
 } 
@@ -275,8 +309,11 @@ typedef struct
  DCC_MSG   LastMsg ;
  uint8_t	ExtIntNum; 
  uint8_t	ExtIntPinNum;
+  volatile uint8_t   *ExtIntPort;     // use port and bitmask to read input at AVR in ISR
+  uint8_t   ExtIntMask;     // digitalRead is too slow on AVR
  int16_t   myDccAddress;	// Cached value of DCC Address from CVs
  uint8_t   inAccDecDCCAddrNextReceivedMode;
+  uint8_t	cv29Value; 
 #ifdef DCC_DEBUG
  uint8_t	IntCount;
  uint8_t	TickCount;
@@ -287,14 +324,48 @@ DCC_PROCESSOR_STATE ;

 DCC_PROCESSOR_STATE DccProcState ;

+#ifdef ESP32
+portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
+
+void IRAM_ATTR ExternalInterruptHandler(void)
+#elif defined(ESP8266)
+void ICACHE_RAM_ATTR ExternalInterruptHandler(void)
+#else
 void ExternalInterruptHandler(void)
+#endif
 {
+    SET_TP3;
+
+#ifdef ESP32
+//   switch (ISRWatch)
+//   {
+//     case RISING: if (digitalRead(DccProcState.ExtIntPinNum)) break; 
+//     case FALLING: if (digitalRead(DccProcState.ExtIntPinNum)) return; break; 
+//   }
+	// First compare the edge we're looking for to the pin state 
+	switch (ISRWatch)
+	{
+		case CHANGE:
+			break;
+				
+		case RISING:
+			if (digitalRead(DccProcState.ExtIntPinNum) != HIGH)
+				return; 
+			break;
+				
+		case FALLING:
+			if (digitalRead(DccProcState.ExtIntPinNum) != LOW)
+				return;
+			break; 
+	}
+#endif
 // Bit evaluation without Timer 0 ------------------------------
    uint8_t DccBitVal;
    static int8_t  bit1, bit2 ;
-    static word  lastMicros;
-    static byte halfBit, DCC_IrqRunning;
+    static unsigned int  lastMicros = 0;
+    static byte halfBit, DCC_IrqRunning, preambleBitCount;
    unsigned int  actMicros, bitMicros;
+    #ifdef ALLOW_NESTED_IRQ
    if ( DCC_IrqRunning ) {
        // nested DCC IRQ - obviously there are glitches
        // ignore this interrupt and increment glitchcounter
@@ -305,57 +376,94 @@ void ExternalInterruptHandler(void)
        SET_TP3;
        return; //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort IRQ
    }
-    SET_TP3;
+    #endif
    actMicros = micros();
    bitMicros = actMicros-lastMicros;
-    if ( bitMicros < bitMin ) {
-        // too short - my be false interrupt due to glitch or false protocol -> ignore
+
+        CLR_TP3; SET_TP3;
+#ifdef __AVR_MEGA__
+    if ( bitMicros < bitMin || ( DccRx.State != WAIT_START_BIT && (*DccProcState.ExtIntPort & DccProcState.ExtIntMask) != (ISRLevel) ) ) {
+#else
+    if ( bitMicros < bitMin || ( DccRx.State != WAIT_START_BIT && digitalRead( DccProcState.ExtIntPinNum ) != (ISRLevel) ) ) {
+#endif
+        // too short - my be false interrupt due to glitch or false protocol  or level does not match RISING / FALLING edge -> ignore this IRQ
        CLR_TP3;
-        SET_TP4; CLR_TP4;
+        SET_TP4; /*delayMicroseconds(1); */ CLR_TP4;
        return; //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort IRQ
    }
-    DccBitVal = ( bitMicros < bitMax );
+        CLR_TP3;  SET_TP3;
+
    lastMicros = actMicros;
-    #ifdef debug
-    if(DccBitVal) {SET_TP2;} else {CLR_TP2;};
-    #endif
+#ifndef SUPPORT_ZERO_BIT_STRETCHING
+    //if ( bitMicros > MAX_ZEROBITFULL ) {
+    if ( bitMicros > (bitMax*2) ) {
+        // too long - my be false protocol -> start over
+        DccRx.State = WAIT_PREAMBLE ;
+        DccRx.BitCount = 0 ;
+        preambleBitCount = 0;
+        // SET_TP2; CLR_TP2;
+        bitMax = MAX_PRAEAMBEL;
+        bitMin = MIN_ONEBITFULL;
+        #if defined ( __STM32F1__ )
+        detachInterrupt( DccProcState.ExtIntNum );
+        #endif
+        #ifdef ESP32
+        ISRWatch = ISREdge;
+        #else
+        attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, ISREdge );
+        #endif
+        // enable level-checking
+        ISRChkMask = DccProcState.ExtIntMask;
+        ISRLevel = (ISREdge==RISING)? DccProcState.ExtIntMask : 0 ;
+        CLR_TP3;
+        //CLR_TP3;
+        return; //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort IRQ
+    }
+        CLR_TP3;
+        SET_TP3;
+#endif
+    
+    DccBitVal = ( bitMicros < bitMax );
+    
+    #ifdef ALLOW_NESTED_IRQ
    DCC_IrqRunning = true;
    interrupts();  // time critical is only the micros() command,so allow nested irq's
+    #endif
+    
 #ifdef DCC_DEBUG
    DccProcState.TickCount++;
 #endif
-
  switch( DccRx.State )
  {
  case WAIT_PREAMBLE:
-    if( DccBitVal )
-    {
-        SET_TP1;
-      DccRx.BitCount++;
-     if( DccRx.BitCount > 10 ) {
-        DccRx.State = WAIT_START_BIT ;
-        // While waiting for the start bit, detect halfbit lengths. We will detect the correct
-        // sync and detect whether we see a false (e.g. motorola) protocol
-		#if defined ( __STM32F1__ )
-		detachInterrupt( DccProcState.ExtIntNum );
-		#endif
-        attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, CHANGE);
-        halfBit = 0;
-        bitMax = MAX_ONEBITHALF;
-        bitMin = MIN_ONEBITHALF;
-        CLR_TP1;
-      }
-    } else {
-        SET_TP1;
-        DccRx.BitCount = 0 ;
-        CLR_TP1;
-    }
+    // We don't have to do anything special - looking for a preamble condition is done always
+    SET_TP2;
    break;

+#ifndef SYNC_ALWAYS
+  case WAIT_START_BIT_FULL:
+    // wait for startbit without level checking
+    if ( !DccBitVal ) {
+        // we got the startbit
+        CLR_TP2;CLR_TP1;
+        DccRx.State = WAIT_DATA ;
+        CLR_TP1;
+        // initialize packet buffer
+        DccRx.PacketBuf.Size = 0;
+        /*for(uint8_t i = 0; i< MAX_DCC_MESSAGE_LEN; i++ )
+            DccRx.PacketBuf.Data[i] = 0;*/
+        DccRx.PacketBuf.PreambleBits = preambleBitCount;
+        DccRx.BitCount = 0 ;
+        DccRx.chkSum = 0 ;
+        DccRx.TempByte = 0 ;
+        //SET_TP1;
+    }
+    break;
+#endif    
  case WAIT_START_BIT:
    // we are looking for first half "0" bit after preamble
    switch ( halfBit ) {
-      case 0:  //SET_TP1;
+      case 0: 
        // check first part
        if ( DccBitVal ) {
            // is still 1-bit (Preamble)
@@ -363,108 +471,135 @@ void ExternalInterruptHandler(void)
            bit1=bitMicros;
        } else {
            // was "0" half bit, maybe the startbit
-			SET_TP1;
-            halfBit = 4;
-			CLR_TP1;
-        }
+			halfBit = 4;
+		}
        break;
-      case 1: //SET_TP1; // previous halfbit was '1'
+      case 1: // previous halfbit was '1'
        if ( DccBitVal ) {
            // its a '1' halfBit -> we are still in the preamble
            halfBit = 0;
            bit2=bitMicros;
-            DccRx.BitCount++;
+            preambleBitCount++;
            if( abs(bit2-bit1) > MAX_BITDIFF ) {
                // the length of the 2 halfbits differ too much -> wrong protokoll
-                CLR_TP2;
-                CLR_TP3;
                DccRx.State = WAIT_PREAMBLE;
                bitMax = MAX_PRAEAMBEL;
                bitMin = MIN_ONEBITFULL;
-                DccRx.BitCount = 0;
-				SET_TP4;
-				#if defined ( __STM32F1__ )
+                preambleBitCount = 0;
+                // SET_TP2; CLR_TP2;
+                #if defined ( __STM32F1__ )
 				detachInterrupt( DccProcState.ExtIntNum );
 				#endif
+                #ifdef ESP32
+				ISRWatch = ISREdge;
+                #else
                attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, ISREdge );
+                // enable level checking ( with direct port reading @ AVR )
+                ISRChkMask = DccProcState.ExtIntMask;       
+                ISRLevel = (ISREdge==RISING)? DccProcState.ExtIntMask : 0 ;
+                #endif
 				SET_TP3;
-				CLR_TP4;
+                CLR_TP4;
            }
        } else {
            // first '0' half detected in second halfBit
            // wrong sync or not a DCC protokoll
-			CLR_TP3;
-            halfBit = 3;
-			SET_TP3;
+            CLR_TP3;
+			halfBit = 3;
+            SET_TP3;
        }
        break;
-      case 3: //SET_TP1;  // previous halfbit was '0'  in second halfbit  
+      case 3: // previous halfbit was '0'  in second halfbit  
        if ( DccBitVal ) {
            // its a '1' halfbit -> we got only a half '0' bit -> cannot be DCC
            DccRx.State = WAIT_PREAMBLE;
            bitMax = MAX_PRAEAMBEL;
            bitMin = MIN_ONEBITFULL;
-            DccRx.BitCount = 0;
+            preambleBitCount = 0;
+            // SET_TP2; CLR_TP2;
        } else {
            // we got two '0' halfbits -> it's the startbit
            // but sync is NOT ok, change IRQ edge.
+            CLR_TP2;CLR_TP1;
            if ( ISREdge == RISING ) ISREdge = FALLING; else ISREdge = RISING;
            DccRx.State = WAIT_DATA ;
+            CLR_TP1;
            bitMax = MAX_ONEBITFULL;
            bitMin = MIN_ONEBITFULL;
            DccRx.PacketBuf.Size = 0;
-            DccRx.PacketBuf.PreambleBits = 0;
-            for(uint8_t i = 0; i< MAX_DCC_MESSAGE_LEN; i++ )
-            DccRx.PacketBuf.Data[i] = 0;
-
-            DccRx.PacketBuf.PreambleBits = DccRx.BitCount;
+            /*for(uint8_t i = 0; i< MAX_DCC_MESSAGE_LEN; i++ )
+            DccRx.PacketBuf.Data[i] = 0;*/
+            DccRx.PacketBuf.PreambleBits = preambleBitCount;
            DccRx.BitCount = 0 ;
+            DccRx.chkSum = 0 ;
            DccRx.TempByte = 0 ;
+            //SET_TP1;
        }
-		SET_TP4;
-			#if defined ( __STM32F1__ )
-			detachInterrupt( DccProcState.ExtIntNum );
-			#endif
-			attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, ISREdge );
-        CLR_TP1;
-		CLR_TP4;
+		//SET_TP4;
+
+        #if defined ( __STM32F1__ )
+        detachInterrupt( DccProcState.ExtIntNum );
+        #endif
+        #ifdef ESP32
+        ISRWatch = ISREdge;
+        #else
+        attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, ISREdge );
+        #endif
+        // enable level-checking
+        ISRChkMask = DccProcState.ExtIntMask;
+        ISRLevel = (ISREdge==RISING)? DccProcState.ExtIntMask : 0 ;
+        //CLR_TP4;
        break;
-      case 4: SET_TP1; // previous (first) halfbit was 0
+      case 4: // previous (first) halfbit was 0
        // if this halfbit is 0 too, we got the startbit
        if ( DccBitVal ) {
            // second halfbit is 1 -> unknown protokoll
            DccRx.State = WAIT_PREAMBLE;
            bitMax = MAX_PRAEAMBEL;
            bitMin = MIN_ONEBITFULL;
+            preambleBitCount = 0;
+            CLR_TP2;CLR_TP1;
            DccRx.BitCount = 0;
        } else {
            // we got the startbit
+            CLR_TP2;CLR_TP1;
            DccRx.State = WAIT_DATA ;
+            CLR_TP1;
            bitMax = MAX_ONEBITFULL;
            bitMin = MIN_ONEBITFULL;
+            // initialize packet buffer
            DccRx.PacketBuf.Size = 0;
-            DccRx.PacketBuf.PreambleBits = 0;
-            for(uint8_t i = 0; i< MAX_DCC_MESSAGE_LEN; i++ )
-            DccRx.PacketBuf.Data[i] = 0;
-
-            DccRx.PacketBuf.PreambleBits = DccRx.BitCount;
+            /*for(uint8_t i = 0; i< MAX_DCC_MESSAGE_LEN; i++ )
+            DccRx.PacketBuf.Data[i] = 0;*/
+            DccRx.PacketBuf.PreambleBits = preambleBitCount;
            DccRx.BitCount = 0 ;
+            DccRx.chkSum = 0 ;
            DccRx.TempByte = 0 ;
+            //SET_TP1;
        }
 		
-        CLR_TP1;
-		SET_TP4;
+        //SET_TP4;
+
 		#if defined ( __STM32F1__ )
 		detachInterrupt( DccProcState.ExtIntNum );
 		#endif
+        #ifdef ESP32
+        ISRWatch = ISREdge;
+        #else
 		attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, ISREdge );
-		CLR_TP4;
+        #endif
+        // enable level-checking
+        ISRChkMask = DccProcState.ExtIntMask;
+        ISRLevel = (ISREdge==RISING)? DccProcState.ExtIntMask : 0 ;
+
+		//CLR_TP4;
        break;
            
    }        
    break;

  case WAIT_DATA:
+    CLR_TP2;
    DccRx.BitCount++;
    DccRx.TempByte = ( DccRx.TempByte << 1 ) ;
    if( DccBitVal )
@@ -483,23 +618,44 @@ void ExternalInterruptHandler(void)
      {
        DccRx.State = WAIT_END_BIT ;
        DccRx.PacketBuf.Data[ DccRx.PacketBuf.Size++ ] = DccRx.TempByte ;
+        DccRx.chkSum ^= DccRx.TempByte;
      }
    }
    break;

  case WAIT_END_BIT:
+    SET_TP2;CLR_TP2;
    DccRx.BitCount++;
-    if( DccBitVal ) // End of packet?
-    {
-      CLR_TP3;
+    if( DccBitVal ) { // End of packet?
+      CLR_TP3; SET_TP4;
      DccRx.State = WAIT_PREAMBLE ;
+      DccRx.BitCount = 0 ;
      bitMax = MAX_PRAEAMBEL;
      bitMin = MIN_ONEBITFULL;
-      DccRx.PacketCopy = DccRx.PacketBuf ;
-      DccRx.DataReady = 1 ;
-      SET_TP3;
-    }
-    else  // Get next Byte
+      SET_TP1;
+      if ( DccRx.chkSum == 0 ) { 
+        // Packet is valid
+        #ifdef ESP32
+        portENTER_CRITICAL_ISR(&mux);
+        #endif
+        DccRx.PacketCopy = DccRx.PacketBuf ;
+        DccRx.DataReady = 1 ;
+        #ifdef ESP32
+        portEXIT_CRITICAL_ISR(&mux);
+        #endif
+        // SET_TP2; CLR_TP2;
+        preambleBitCount = 0 ;
+      } else {
+        // Wrong checksum
+        CLR_TP1;
+        #ifdef DCC_DBGVAR
+        DB_PRINT("Cerr");
+        countOf.Err++;
+        #endif
+      }
+
+      SET_TP3; CLR_TP4;
+    } else  { // Get next Byte
      // KGW - Abort immediately if packet is too long.
      if( DccRx.PacketBuf.Size == MAX_DCC_MESSAGE_LEN ) // Packet is too long - abort
      {
@@ -515,38 +671,109 @@ void ExternalInterruptHandler(void)
        DccRx.BitCount = 0 ;
        DccRx.TempByte = 0 ;
      }
+    }
  }
-  CLR_TP1;
-  CLR_TP3;
+
+  // unless we're already looking for the start bit 
+  // we always search for a preamble ( ( 10 or more consecutive 1 bits )
+  // if we found it within a packet, the packet decoding is aborted because
+  // that much one bits cannot be valid in a packet.
+  if ( DccRx.State != WAIT_START_BIT ) {
+    if( DccBitVal )
+    {
+      preambleBitCount++;
+      //SET_TP2;
+      if( preambleBitCount > 10 ) {
+        CLR_TP2;
+#ifndef SYNC_ALWAYS
+        if ( DccRx.chkSum == 0 ) { 
+            // sync must be correct if chksum was ok, no need to check sync
+            DccRx.State = WAIT_START_BIT_FULL;
+        } else {
+#endif
+        DccRx.State = WAIT_START_BIT ;
+            SET_TP2;
+            // While waiting for the start bit, detect halfbit lengths. We will detect the correct
+            // sync and detect whether we see a false (e.g. motorola) protocol
+
+            #if defined ( __STM32F1__ )
+            detachInterrupt( DccProcState.ExtIntNum );
+            #endif
+            #ifdef ESP32
+            ISRWatch = CHANGE;
+            #else
+            attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, CHANGE);
+            #endif
+            ISRChkMask = 0;         // AVR level check is always true with this settings
+            ISRLevel = 0;           // ( there cannot be false edge IRQ's with CHANGE )
+            halfBit = 0;
+            bitMax = MAX_ONEBITHALF;
+            bitMin = MIN_ONEBITHALF;
+            //CLR_TP1;
+#ifndef SYNC_ALWAYS
+        }
+#endif
+      }
+    } else {
+        CLR_TP1;
+        preambleBitCount = 0 ;
+        // SET_TP2; CLR_TP2;
+    }
+  }
+
+  #ifdef ALLOW_NESTED_IRQ
  DCC_IrqRunning = false;
+  #endif
+  //CLR_TP1;
+  CLR_TP3;
 }

 void ackCV(void)
 {
  if( notifyCVAck )
+  {
+    DB_PRINT("ackCV: Send Basic ACK");
    notifyCVAck() ;
+  }
 }

-uint8_t readEEPROM( unsigned int CV ) {
+void ackAdvancedCV(void)
+{
+  if( notifyAdvancedCVAck && (DccProcState.cv29Value & CV29_RAILCOM_ENABLE) )
+  {
+    DB_PRINT("ackAdvancedCV: Send RailCom ACK");
+    notifyAdvancedCVAck() ;
+  }
+}
+
+
+uint8_t readEEPROM( unsigned int CV )
+{
    return EEPROM.read(CV) ;
 }

-void writeEEPROM( unsigned int CV, uint8_t Value ) {
+void writeEEPROM( unsigned int CV, uint8_t Value )
+{
    EEPROM.write(CV, Value) ;
  #if defined(ESP8266)
    EEPROM.commit();
  #endif
+  #if defined(ESP32)
+    EEPROM.commit();
+  #endif
 }

-bool readyEEPROM() {
-    #ifdef __AVR_MEGA__
-        return eeprom_is_ready();
-    #else
-        return true;
-    #endif
+bool readyEEPROM()
+{
+#if defined ARDUINO_ARCH_MEGAAVR
+	return bit_is_clear(NVMCTRL.STATUS,NVMCTRL_EEBUSY_bp);
+#elif defined __AVR_MEGA__
+	return eeprom_is_ready();
+#else
+	return true;
+#endif
 }

-
 uint8_t validCV( uint16_t CV, uint8_t Writable )
 {
  if( notifyCVResetFactoryDefault && (CV == CV_MANUFACTURER_ID )  && Writable )
@@ -583,6 +810,9 @@ uint8_t writeCV( unsigned int CV, uint8_t Value)
  {
    case CV_29_CONFIG:
      // copy addressmode Bit to Flags
+      Value = Value &  ~CV29_RAILCOM_ENABLE;   // Bidi (RailCom) Bit must not be enabled, 
+                                            // because you cannot build a Bidi decoder with this lib.
+      DccProcState.cv29Value = Value;
      DccProcState.Flags = ( DccProcState.Flags & ~FLAGS_CV29_BITS) | (Value & FLAGS_CV29_BITS);
      // no break, because myDccAdress must also be reset
    case CV_ACCESSORY_DECODER_ADDRESS_LSB:	// Also same CV for CV_MULTIFUNCTION_PRIMARY_ADDRESS
@@ -611,23 +841,19 @@ uint8_t writeCV( unsigned int CV, uint8_t Value)

 uint16_t getMyAddr(void)
 {
-  uint8_t   CV29Value ;
-  
  if( DccProcState.myDccAddress != -1 )	// See if we can return the cached value 
  	return( DccProcState.myDccAddress );

-  CV29Value = readCV( CV_29_CONFIG ) ;
-
-  if( CV29Value & CV29_ACCESSORY_DECODER )  // Accessory Decoder?
+  if( DccProcState.cv29Value & CV29_ACCESSORY_DECODER )  // Accessory Decoder?
  {
-    if( CV29Value & CV29_OUTPUT_ADDRESS_MODE ) 
+    if( DccProcState.cv29Value & CV29_OUTPUT_ADDRESS_MODE ) 
      DccProcState.myDccAddress = ( readCV( CV_ACCESSORY_DECODER_ADDRESS_MSB ) << 8 ) | readCV( CV_ACCESSORY_DECODER_ADDRESS_LSB );
    else
      DccProcState.myDccAddress = ( ( readCV( CV_ACCESSORY_DECODER_ADDRESS_MSB ) & 0b00000111) << 6 ) | ( readCV( CV_ACCESSORY_DECODER_ADDRESS_LSB ) & 0b00111111) ;
  }
  else   // Multi-Function Decoder?
  {
-    if( CV29Value & CV29_EXT_ADDRESSING )  // Two Byte Address?
+    if( DccProcState.cv29Value & CV29_EXT_ADDRESSING )  // Two Byte Address?
      DccProcState.myDccAddress = ( ( readCV( CV_MULTIFUNCTION_EXTENDED_ADDRESS_MSB ) - 192 ) << 8 ) | readCV( CV_MULTIFUNCTION_EXTENDED_ADDRESS_LSB ) ;

    else
@@ -637,7 +863,7 @@ uint16_t getMyAddr(void)
  return DccProcState.myDccAddress ;
 }

-void processDirectOpsOperation( uint8_t Cmd, uint16_t CVAddr, uint8_t Value )
+void processDirectCVOperation( uint8_t Cmd, uint16_t CVAddr, uint8_t Value, void (*ackFunction)() )
 {
  // is it a Byte Operation
  if( Cmd & 0x04 )
@@ -647,8 +873,9 @@ void processDirectOpsOperation( uint8_t Cmd, uint16_t CVAddr, uint8_t Value )
    {
      if( validCV( CVAddr, 1 ) )
      {
+        DB_PRINT("CV: %d Byte Write: %02X", CVAddr, Value)
        if( writeCV( CVAddr, Value ) == Value )
-          ackCV();
+          ackFunction();
      }
    }

@@ -656,8 +883,9 @@ void processDirectOpsOperation( uint8_t Cmd, uint16_t CVAddr, uint8_t Value )
    {  
      if( validCV( CVAddr, 0 ) )
      {
+        DB_PRINT("CV: %d Byte Read: %02X", CVAddr, Value)
        if( readCV( CVAddr ) == Value )
-          ackCV();
+          ackFunction();
      }
    }
  }
@@ -670,6 +898,8 @@ void processDirectOpsOperation( uint8_t Cmd, uint16_t CVAddr, uint8_t Value )

    uint8_t tempValue = readCV( CVAddr ) ;  // Read the Current CV Value

+    DB_PRINT("CV: %d Current Value: %02X  Bit-Wise Mode: %s  Mask: %02X  Value: %02X", CVAddr, tempValue, BitWrite ? "Write":"Read", BitMask, BitValue);
+
    // Perform the Bit Write Operation
    if( BitWrite )
    {
@@ -682,7 +912,7 @@ void processDirectOpsOperation( uint8_t Cmd, uint16_t CVAddr, uint8_t Value )
          tempValue &= ~BitMask ;  // Turn the Bit Off

        if( writeCV( CVAddr, tempValue ) == tempValue )
-          ackCV() ;
+          ackFunction() ;
      }
    }

@@ -694,12 +924,12 @@ void processDirectOpsOperation( uint8_t Cmd, uint16_t CVAddr, uint8_t Value )
        if( BitValue ) 
        {
          if( tempValue & BitMask )
-            ackCV() ;
+            ackFunction() ;
        }
        else
        {
          if( !( tempValue & BitMask)  )
-            ackCV() ;
+            ackFunction() ;
        }
      }
    }
@@ -742,9 +972,8 @@ void processMultiFunctionMessage( uint16_t Addr, DCC_ADDR_TYPE AddrType, uint8_t
    switch( Cmd & 0b00001110 )
    {
    case 0b00000000:  
-      if( notifyDccReset && ( Cmd & 0b00000001 ) ) // Hard Reset
-        if( notifyDccReset)
-          notifyDccReset( 1 ) ;
+      if( notifyDccReset)
+        notifyDccReset( Cmd & 0b00000001 ) ;
      break ;

    case 0b00000010:  // Factory Test
@@ -793,7 +1022,7 @@ void processMultiFunctionMessage( uint16_t Addr, DCC_ADDR_TYPE AddrType, uint8_t
  case 0b01100000:
    //TODO should we cache this info in DCC_PROCESSOR_STATE.Flags ?
 #ifdef NMRA_DCC_ENABLE_14_SPEED_STEP_MODE
-    speedSteps = (readCV( CV_29_CONFIG ) & CV29_F0_LOCATION) ? SPEED_STEP_28 : SPEED_STEP_14 ;
+    speedSteps = (DccProcState.cv29Value & CV29_F0_LOCATION) ? SPEED_STEP_28 : SPEED_STEP_14 ;
 #else
    speedSteps = SPEED_STEP_28 ;
 #endif    
@@ -877,7 +1106,7 @@ void processMultiFunctionMessage( uint16_t Addr, DCC_ADDR_TYPE AddrType, uint8_t
  case 0b11100000:  // CV Access
    CVAddr = ( ( ( Cmd & 0x03 ) << 8 ) | Data1 ) + 1 ;

-    processDirectOpsOperation( Cmd, CVAddr, Data2 ) ;
+    processDirectCVOperation( Cmd, CVAddr, Data2, ackAdvancedCV) ;
    break;
  }
 }
@@ -892,7 +1121,7 @@ void processServiceModeOperation( DCC_MSG * pDccMsg )
  if( pDccMsg->Size == 3) // 3 Byte Packets are for Address Only, Register and Paged Mode
  {
    uint8_t RegisterAddr ;
-    DB_PRINT("3-BytePkt");
+    DB_PRINT("CV Address, Register & Paged Mode Operation");
    RegisterAddr = pDccMsg->Data[0] & 0x07 ;
    Value = pDccMsg->Data[1] ;

@@ -935,11 +1164,11 @@ void processServiceModeOperation( DCC_MSG * pDccMsg )

  else if( pDccMsg->Size == 4) // 4 Byte Packets are for Direct Byte & Bit Mode
  {
-    DB_PRINT("BB-Mode");
+    DB_PRINT("CV Direct Byte and Bit Mode Mode Operation");
    CVAddr = ( ( ( pDccMsg->Data[0] & 0x03 ) << 8 ) | pDccMsg->Data[1] ) + 1 ;
    Value = pDccMsg->Data[2] ;
    
-    processDirectOpsOperation( pDccMsg->Data[0] & 0b00001100, CVAddr, Value ) ;
+    processDirectCVOperation( pDccMsg->Data[0] & 0b00001100, CVAddr, Value, ackCV) ;
  }
 }
 #endif
@@ -1016,12 +1245,13 @@ void execDccProcessor( DCC_MSG * pDccMsg )
    {
      resetServiceModeTimer( 1 ) ;

-      if( memcmp( pDccMsg, &DccProcState.LastMsg, sizeof( DCC_MSG ) ) )
+	//Only check the DCC Packet "Size" and "Data" fields and ignore the "PreambleBits" as they can be different to the previous packet
+      if(pDccMsg->Size != DccProcState.LastMsg.Size || memcmp( pDccMsg->Data, &DccProcState.LastMsg.Data, pDccMsg->Size ) != 0 )	      
      {
        DccProcState.DuplicateCount = 0 ;
        memcpy( &DccProcState.LastMsg, pDccMsg, sizeof( DCC_MSG ) ) ;
      }
-      // Wait until you see 2 identicle packets before acting on a Service Mode Packet 
+      // Wait until you see 2 identical packets before acting on a Service Mode Packet 
      else
      {
        DccProcState.DuplicateCount++ ;
@@ -1277,14 +1507,30 @@ void NmraDcc::pin( uint8_t ExtIntNum, uint8_t ExtIntPinNum, uint8_t EnablePullup
 #if defined ( __STM32F1__ )
  // with STM32F1 the interuptnumber is equal the pin number
  DccProcState.ExtIntNum = ExtIntPinNum;
+  // because STM32F1 has a NVIC we must set interuptpriorities
+  const nvic_irq_num irqNum2nvic[] = { NVIC_EXTI0, NVIC_EXTI1, NVIC_EXTI2, NVIC_EXTI3, NVIC_EXTI4, 
+            NVIC_EXTI_9_5, NVIC_EXTI_9_5, NVIC_EXTI_9_5, NVIC_EXTI_9_5, NVIC_EXTI_9_5, 
+            NVIC_EXTI_15_10, NVIC_EXTI_15_10, NVIC_EXTI_15_10, NVIC_EXTI_15_10, NVIC_EXTI_15_10, NVIC_EXTI_15_10 };
+  exti_num irqNum =  (exti_num)(PIN_MAP[ExtIntPinNum].gpio_bit); 
+
+// DCC-Input IRQ must be able to interrupt other long low priority ( level15 ) IRQ's  
+  nvic_irq_set_priority ( irqNum2nvic[irqNum], PRIO_DCC_IRQ); 
+  
+// Systic must be able to interrupt DCC-IRQ to always get correct micros() values  
+  nvic_irq_set_priority(NVIC_SYSTICK, PRIO_SYSTIC); 
 #else
  DccProcState.ExtIntNum = ExtIntNum;
 #endif
  DccProcState.ExtIntPinNum = ExtIntPinNum;
-	
-  pinMode( ExtIntPinNum, INPUT );
-  if( EnablePullup )
-    digitalWrite(ExtIntPinNum, HIGH);
+#ifdef __AVR_MEGA__
+    // because digitalRead at AVR is slow, we will read the dcc input in the ISR
+    // by direct port access.
+    DccProcState.ExtIntPort = portInputRegister( digitalPinToPort(ExtIntPinNum) );
+    DccProcState.ExtIntMask = digitalPinToBitMask( ExtIntPinNum );
+#else
+    DccProcState.ExtIntMask = 1;
+#endif	
+  pinMode( ExtIntPinNum, EnablePullup ? INPUT_PULLUP : INPUT );
 }

 ////////////////////////////////////////////////////////////////////////
@@ -1299,6 +1545,9 @@ void NmraDcc::init( uint8_t ManufacturerId, uint8_t VersionId, uint8_t Flags, ui
  #if defined(ESP8266)
    EEPROM.begin(MAXCV);
  #endif
+  #if defined(ESP32)
+    EEPROM.begin(MAXCV);
+  #endif
  // Clear all the static member variables
  memset( &DccRx, 0, sizeof( DccRx) );

@@ -1306,20 +1555,30 @@ void NmraDcc::init( uint8_t ManufacturerId, uint8_t VersionId, uint8_t Flags, ui
  MODE_TP2;
  MODE_TP3;
  MODE_TP4;
-  ISREdge = RISING;
  bitMax = MAX_ONEBITFULL;
  bitMin = MIN_ONEBITFULL;
-  attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, RISING);

  DccProcState.Flags = Flags ;
  DccProcState.OpsModeAddressBaseCV = OpsModeAddressBaseCV ;
  DccProcState.myDccAddress = -1;
  DccProcState.inAccDecDCCAddrNextReceivedMode = 0;

+  ISREdge = RISING;
+  // level checking to detect false IRQ's fired by glitches
+  ISRLevel = DccProcState.ExtIntMask;
+  ISRChkMask = DccProcState.ExtIntMask;
+
+  #ifdef ESP32
+  ISRWatch = ISREdge;
+  attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, CHANGE);
+  #else
+  attachInterrupt( DccProcState.ExtIntNum, ExternalInterruptHandler, RISING);
+  #endif
+
  // Set the Bits that control Multifunction or Accessory behaviour
  // and if the Accessory decoder optionally handles Output Addressing 
  // we need to peal off the top two bits
-  writeCV( CV_29_CONFIG, ( readCV( CV_29_CONFIG ) & ~FLAGS_CV29_BITS ) | (Flags & FLAGS_CV29_BITS) ) ; 
+  DccProcState.cv29Value = writeCV( CV_29_CONFIG, ( readCV( CV_29_CONFIG ) & ~FLAGS_CV29_BITS ) | (Flags & FLAGS_CV29_BITS) ) ; 

  uint8_t doAutoFactoryDefault = 0;
  if((Flags & FLAGS_AUTO_FACTORY_DEFAULT) && (readCV(CV_VERSION_ID) == 255) && (readCV(CV_MANUFACTURER_ID) == 255))
@@ -1418,30 +1677,29 @@ uint8_t NmraDcc::process()
  if( DccRx.DataReady )
  {
    // We need to do this check with interrupts disabled
-    //SET_TP4;
+#ifdef ESP32
+    portENTER_CRITICAL(&mux);
+#else
    noInterrupts();
+#endif
    Msg = DccRx.PacketCopy ;
    DccRx.DataReady = 0 ;
+
+#ifdef ESP32
+    portEXIT_CRITICAL(&mux);
+#else
    interrupts();
-      #ifdef DCC_DBGVAR
-      countOf.Tel++;
-      #endif
+#endif
+    // Checking of the XOR-byte is now done in the ISR already
+    #ifdef DCC_DBGVAR
+    countOf.Tel++;
+    #endif
+    // Clear trailing bytes
+    for ( byte i=Msg.Size; i< MAX_DCC_MESSAGE_LEN; i++ ) Msg.Data[i] = 0;
    
-    uint8_t xorValue = 0 ;
+	if( notifyDccMsg ) 	notifyDccMsg( &Msg );
 		
-    for(uint8_t i = 0; i < DccRx.PacketCopy.Size; i++)
-      xorValue ^= DccRx.PacketCopy.Data[i];
-    if(xorValue) {
-      #ifdef DCC_DBGVAR
-      DB_PRINT("Cerr");
-      countOf.Err++;
-      #endif
-      return 0 ;
-    } else {
-		if( notifyDccMsg ) 	notifyDccMsg( &Msg );
-		
-        execDccProcessor( &Msg );
-    }
+     execDccProcessor( &Msg );
    return 1 ;
  }

--- a/NmraDcc.h
+++ b/NmraDcc.h
@@ -2,11 +2,21 @@
 //
 // Model Railroading with Arduino - NmraDcc.h 
 //
-// Copyright (c) 2008 - 2018 Alex Shepherd
+// Copyright (c) 2008 - 2020 Alex Shepherd
 //
-// This source file is subject of the GNU general public license 2,
-// that is available at the world-wide-web at
-// http://www.gnu.org/licenses/gpl.txt
+// 	This library is free software; you can redistribute it and/or
+// 	modify it under the terms of the GNU Lesser General Public
+// 	License as published by the Free Software Foundation; either
+// 	version 2.1 of the License, or (at your option) any later version.
+// 
+// 	This library 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
+// 	Lesser General Public License for more details.
+// 
+// 	You should have received a copy of the GNU Lesser General Public
+// 	License along with this library; if not, write to the Free Software
+// 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 // 
 //------------------------------------------------------------------------
 //
@@ -32,7 +42,7 @@
 // Uncomment the following Line to Enable Service Mode CV Programming
 #define NMRA_DCC_PROCESS_SERVICEMODE

-// Uncomment the following line to Enable MutliFunction Decoder Operations
+// Uncomment the following line to Enable MultiFunction Decoder Operations
 #define NMRA_DCC_PROCESS_MULTIFUNCTION

 // Uncomment the following line to Enable 14 Speed Step Support
@@ -44,15 +54,15 @@
 #include "WProgram.h"
 #endif

-#include "EEPROM.h"
-
 #ifndef NMRADCC_IS_IN
 #define NMRADCC_IS_IN

-#define NMRADCC_VERSION     200     // Version 2.0.0
+#define NMRADCC_VERSION     206     // Version 2.0.6

 #define MAX_DCC_MESSAGE_LEN 6    // including XOR-Byte

+//#define ALLOW_NESTED_IRQ      // uncomment to enable nested IRQ's ( only for AVR! )
+
 typedef struct
 {
 	uint8_t	Size ;
@@ -96,21 +106,27 @@ typedef struct
 #define CV_MANUFACTURER_ID                     8
 #define CV_29_CONFIG                          29

-#if defined(ESP8266)
-#include <spi_flash.h>
-#define MAXCV     SPI_FLASH_SEC_SIZE
+#if defined(ESP32)
+	#include <esp_spi_flash.h>
+	#define MAXCV     SPI_FLASH_SEC_SIZE
+#elif defined(ESP8266)
+	#include <spi_flash.h>
+	#define MAXCV     SPI_FLASH_SEC_SIZE
 #elif defined( __STM32F1__)
-#define MAXCV	(EEPROM_PAGE_SIZE/4 - 1)	// number of storage places (CV address could be larger
+	#define MAXCV	(EEPROM_PAGE_SIZE/4 - 1)	// number of storage places (CV address could be larger
 											// because STM32 uses virtual adresses)
+    #undef ALLOW_NESTED_IRQ                 // This is done with NVIC on STM32
+    #define PRIO_DCC_IRQ    9
+    #define PRIO_SYSTIC     8               // MUST be higher priority than DCC Irq
 #else
-#define MAXCV    E2END     					// the upper limit of the CV value currently defined to max memory.
+	#define MAXCV    E2END     					// the upper limit of the CV value currently defined to max memory.
 #endif

 typedef enum {
    CV29_LOCO_DIR            = 0b00000001,	/** bit 0: Locomotive Direction: "0" = normal, "1" = reversed */
    CV29_F0_LOCATION         = 0b00000010,	/** bit 1: F0 location: "0" = bit 4 in Speed and Direction instructions, "1" = bit 4 in function group one instruction */
    CV29_APS                 = 0b00000100,	/** bit 2: Alternate Power Source (APS) "0" = NMRA Digital only, "1" = Alternate power source set by CV12 */
-    CV29_ADV_ACK             = 0b00001000, 	/** bit 3: ACK, Advanced Acknowledge mode enabled if 1, disabled if 0 */
+	CV29_RAILCOM_ENABLE      = 0b00001000, 	/** bit 3: BiDi ( RailCom ) is active */
    CV29_SPEED_TABLE_ENABLE  = 0b00010000, 	/** bit 4: STE, Speed Table Enable, "0" = values in CVs 2, 4 and 6, "1" = Custom table selected by CV 25 */
    CV29_EXT_ADDRESSING      = 0b00100000,	/** bit 5: "0" = one byte addressing, "1" = two byte addressing */
    CV29_OUTPUT_ADDRESS_MODE = 0b01000000,	/** bit 6: "0" = Decoder Address Mode "1" = Output Address Mode */
@@ -651,7 +667,7 @@ extern uint8_t notifyIsSetCVReady(void) __attribute__ ((weak));
 *  notifyCVChange()  Called when a CV value is changed.
 *                    This is called whenever a CV's value is changed.
 *  notifyDccCVChange()  Called only when a CV value is changed by a Dcc packet or a internal lib function.
- *                    it is NOT called if the CV is chaged by means of the setCV() method.
+ *                    it is NOT called if the CV is changed by means of the setCV() method.
 *                    Note: It is not called if notifyCVWrite() is defined
 *                    or if the value in the EEPROM is the same as the value
 *                    in the write command. 
@@ -695,6 +711,17 @@ extern void    notifyCVResetFactoryDefault(void) __attribute__ ((weak));
 *    None
 */
 extern void    notifyCVAck(void) __attribute__ ((weak));
+/*+
+ *  notifyAdvancedCVAck() Called when a CV write must be acknowledged via Advanced Acknowledgement.
+ *                This callback must send the Advanced Acknowledgement via RailComm.
+ *
+ *  Inputs:
+ *    None
+ *                                                                                                        *
+ *  Returns:
+ *    None
+ */
+extern void    notifyAdvancedCVAck(void) __attribute__ ((weak));
 /*+
 *  notifyServiceMode(bool) Called when state of 'inServiceMode' changes
 *
--- a/examples/DCCInterface_TurntableControl/DCCInterface_TurntableControl.ino
+++ b/examples/DCCInterface_TurntableControl/DCCInterface_TurntableControl.ino
@@ -1,8 +1,8 @@
 // DCC Stepper Motor Controller ( A4988 ) Example for Model Railroad Turntable Control
 //
-// See: https://www.dccinterface.com/how-to/assemblyguide/
+// See: https://www.dccinterface.com/product/arduino-model-railway-dcc-stepper-motor-controller-a4988-assembled/
 // 
-// Author: Alex Shepherd 2017-12-04
+// Author: Alex Shepherd 2020-06-01
 // 
 // This example requires two Arduino Libraries:
 //
@@ -22,12 +22,22 @@
 // The lines below define the pins used to connect to the A4988 driver module
 #define A4988_STEP_PIN      4
 #define A4988_DIRECTION_PIN 5
-// Uncomment the next line to enable Powering-Off the Stepper when its not running to reduce heating the motor and driver
 #define A4988_ENABLE_PIN    6

+#ifdef A4988_ENABLE_PIN
+// Uncomment the next line to enable Powering-Off the Stepper when its not running to reduce heating the motor and driver
+#define DISABLE_OUTPUTS_IDLE
+#endif
+
+// By default the stepper motor will move the shortest distance to the desired position.
+// If you need the turntable to only move in the Positive/Increasing or Negative/Decreasing step numbers to better handle backlash in the mechanism
+// Then uncomment the appropriate line below
+//#define ALWAYS_MOVE_POSITIVE
+//#define ALWAYS_MOVE_NEGATIVE
+
 // The lines below define the stepping speed and acceleration, which you may need to tune for your application
 #define STEPPER_MAX_SPEED     800   // Sets the maximum permitted speed
-#define STEPPER_ACCELARATION  1000   // Sets the acceleration/deceleration rate
+#define STEPPER_ACCELARATION  1000  // Sets the acceleration/deceleration rate
 #define STEPPER_SPEED         300   // Sets the desired constant speed for use with runSpeed()

 // The line below defines the number of "Full Steps" your stepper motor does for a full rotation
@@ -92,6 +102,9 @@ TurnoutPosition turnoutPositions[] = {
 // --------------------------------------------------------------------------------------------
 // You shouldn't need to edit anything below this line unless you're needing to make big changes... ;)
 // --------------------------------------------------------------------------------------------
+#if defined(ALWAYS_MOVE_POSITIVE) && defined(ALWAYS_MOVE_NEGATIVE)
+#error ONLY uncomment one of ALWAYS_MOVE_POSITIVE or ALWAYS_MOVE_NEGATIVE but NOT both
+#endif

 #define MAX_TURNOUT_POSITIONS (sizeof(turnoutPositions) / sizeof(TurnoutPosition))

@@ -104,11 +117,12 @@ NmraDcc  Dcc ;
 // Variables to store the last DCC Turnout message Address and Direction  
 uint16_t lastAddr = 0xFFFF ;
 uint8_t lastDirection = 0xFF;
+int     lastStep = 0;

 // This function is called whenever a normal DCC Turnout Packet is received
 void notifyDccAccTurnoutOutput( uint16_t Addr, uint8_t Direction, uint8_t OutputPower )
 {
-  Serial.print("notifyDccAccTurnoutOutput: ") ;
+  Serial.print(F("notifyDccAccTurnoutOutput: "));
  Serial.print(Addr,DEC) ;
  Serial.print(',');
  Serial.print(Direction,DEC) ;
@@ -131,23 +145,50 @@ void notifyDccAccTurnoutOutput( uint16_t Addr, uint8_t Direction, uint8_t Output
 #ifdef A4988_ENABLE_PIN
      stepper1.enableOutputs();
 #endif
-      if (Direction)
-      {
-        Serial.println(turnoutPositions[i].positionFront, DEC);
-        stepper1.moveTo(turnoutPositions[i].positionFront);
-        break;
-      }
+
+      int newStep;
+      if(Direction)
+        newStep = turnoutPositions[i].positionFront;
      else
-      {
-        Serial.println(turnoutPositions[i].positionBack, DEC);
-        stepper1.moveTo(turnoutPositions[i].positionBack);
-        break;
-      }
+        newStep = turnoutPositions[i].positionBack;
+
+      Serial.print(newStep, DEC);
+      
+      Serial.print(F("  Last Step: "));
+      Serial.print(lastStep, DEC);
+      
+      int diffStep = newStep - lastStep;
+      Serial.print(F("  Diff Step: "));
+      Serial.print(diffStep, DEC);
+
+#if defined ALWAYS_MOVE_POSITIVE
+      Serial.print(F("  Positive"));       
+      if(diffStep < 0)
+        diffStep += FULL_TURN_STEPS;
+        
+#elif defined ALWAYS_MOVE_NEGATIVE
+      Serial.print(F("  Negative"));       
+      if(diffStep > 0)
+        diffStep -= FULL_TURN_STEPS;
+#else
+      if(diffStep > HALF_TURN_STEPS)
+        diffStep = diffStep - FULL_TURN_STEPS;
+        
+      else if(diffStep < -HALF_TURN_STEPS)
+        diffStep = diffStep + FULL_TURN_STEPS;
+#endif
+
+      Serial.print(F("  Move: "));
+      Serial.println(diffStep, DEC);
+      stepper1.move(diffStep);
+
+      lastStep = newStep;
+      break;
    }
  }
 };

-#ifdef A4988_ENABLE_PIN
+#ifdef DISABLE_OUTPUTS_IDLE
 bool lastIsRunningState ;
 #endif 

@@ -163,6 +204,10 @@ void setupStepperDriver()
  stepper1.setSpeed(STEPPER_SPEED);               // Sets the desired constant speed for use with runSpeed()

 #ifdef A4988_ENABLE_PIN
+  stepper1.enableOutputs();
+#endif
+
+#ifdef DISABLE_OUTPUTS_IDLE
  lastIsRunningState = stepper1.isRunning();
 #endif
 }
@@ -173,14 +218,19 @@ bool moveToHomePosition()

  pinMode(HOME_SENSOR_PIN, INPUT_PULLUP);

+#ifdef ALWAYS_MOVE_NEGATIVE
+  stepper1.move(0 - (FULL_TURN_STEPS * 2));
+#else
  stepper1.move(FULL_TURN_STEPS * 2);
+#endif  
  while(digitalRead(HOME_SENSOR_PIN) != HOME_SENSOR_ACTIVE_STATE)
    stepper1.run();

  if(digitalRead(HOME_SENSOR_PIN) == HOME_SENSOR_ACTIVE_STATE)
  {
-    Serial.println(F("Found Home Position - Setting Current Position to 0"));
+    stepper1.stop();
    stepper1.setCurrentPosition(0);
+    Serial.println(F("Found Home Position - Setting Current Position to 0"));
    return true;
  }
  else
@@ -210,28 +260,32 @@ void setup()
  Serial.print(F("Full Rotation Steps: "));
  Serial.println(FULL_TURN_STEPS);

+  Serial.print(F("Movement Strategy: "));
+#if defined ALWAYS_MOVE_POSITIVE
+  Serial.println(F("Positive Direction Only"));
+#elif defined ALWAYS_MOVE_NEGATIVE
+  Serial.println(F("Negative Direction Only"));
+#else
+  Serial.println(F("Shortest Distance"));
+#endif
+
  for(uint8_t i = 0; i < MAX_TURNOUT_POSITIONS; i++)
  {
-    Serial.print("DCC Addr: ");
+    Serial.print(F("DCC Addr: "));
    Serial.print(turnoutPositions[i].dccAddress);

-    Serial.print(" Front: ");
+    Serial.print(F(" Front: "));
    Serial.print(turnoutPositions[i].positionFront);

-    Serial.print(" Back: ");
+    Serial.print(F(" Back: "));
    Serial.println(turnoutPositions[i].positionBack);
  }
  
  setupStepperDriver();
-
  if(moveToHomePosition());
  { 
    setupDCCDecoder();

-  #ifdef A4988_ENABLE_PIN
-    stepper1.enableOutputs();
-  #endif
-
    // Fake a DCC Packet to cause the Turntable to move to Position 1
    notifyDccAccTurnoutOutput(POSITION_01_DCC_ADDRESS, 1, 1);
  }
@@ -245,7 +299,7 @@ void loop()
  // Process the Stepper Library
  stepper1.run();

-#ifdef A4988_ENABLE_PIN
+#ifdef DISABLE_OUTPUTS_IDLE
  if(stepper1.isRunning() != lastIsRunningState)
  {
    lastIsRunningState = stepper1.isRunning();
--- a/examples/NmraDccMultiFunctionMotorDecoder/NmraDccMultiFunctionMotorDecoder.ino
+++ b/examples/NmraDccMultiFunctionMotorDecoder/NmraDccMultiFunctionMotorDecoder.ino
@@ -0,0 +1,314 @@
+// NMRA Dcc Multifunction Motor Decoder Demo
+//
+// Author: Alex Shepherd 2019-03-30
+// 
+// This example requires these Arduino Libraries:
+//
+// 1) The NmraDcc Library from: http://mrrwa.org/download/
+//
+// These libraries can be found and installed via the Arduino IDE Library Manager
+//
+// This is a simple demo of how to drive and motor speed and direction using PWM and a motor H-Bridge
+// It uses vStart and vHigh CV values to customise the PWM values to the motor response 
+// It also uses the Headling Function to drive 2 LEDs for Directional Headlights
+// Apart from that there's nothing fancy like Lighting Effects or a function matrix or Speed Tables - its just the basics...
+//
+
+#include <NmraDcc.h>
+// Uncomment any of the lines below to enable debug messages for different parts of the code
+//#define DEBUG_FUNCTIONS
+//#define DEBUG_SPEED
+//#define DEBUG_PWM
+//#define DEBUG_DCC_ACK
+//#define DEBUG_DCC_MSG
+
+#if defined(DEBUG_FUNCTIONS) or defined(DEBUG_SPEED) or defined(DEBUG_PWM) or defined(DEBUG_DCC_ACK) or defined(DEBUG_DCC_MSG)
+#define DEBUG_PRINT
+#endif
+
+// This is the default DCC Address
+#define DEFAULT_DECODER_ADDRESS 3
+
+// This section defines the Arduino UNO Pins to use 
+#ifdef __AVR_ATmega328P__ 
+
+#define DCC_PIN     2
+
+#define LED_PIN_FWD 5
+#define LED_PIN_REV 6
+#define MOTOR_DIR_PIN 12
+#define MOTOR_PWM_PIN 3
+
+// This section defines the Arduino ATTiny85 Pins to use 
+#elif ARDUINO_AVR_ATTINYX5 
+
+#define DCC_PIN     2
+
+#define LED_PIN_FWD 0
+#define LED_PIN_REV 1
+#define MOTOR_DIR_PIN 3
+#define MOTOR_PWM_PIN 4
+
+#else
+#error "Unsupported CPU, you need to add another configuration section for your CPU"
+#endif 
+
+// Some global state variables
+uint8_t newLedState = 0;
+uint8_t lastLedState = 0;
+
+uint8_t newDirection = 0;
+uint8_t lastDirection = 0;
+
+uint8_t newSpeed = 0;
+uint8_t lastSpeed = 0;
+uint8_t numSpeedSteps = SPEED_STEP_128;
+
+uint8_t vStart;
+uint8_t vHigh;
+
+// Structure for CV Values Table
+struct CVPair
+{
+  uint16_t  CV;
+  uint8_t   Value;
+};
+
+// CV Addresses we will be using
+#define CV_VSTART  2
+#define CV_VHIGH   5
+
+// Default CV Values Table
+CVPair FactoryDefaultCVs [] =
+{
+	// The CV Below defines the Short DCC Address
+  {CV_MULTIFUNCTION_PRIMARY_ADDRESS, DEFAULT_DECODER_ADDRESS},
+
+  // Three Step Speed Table
+  {CV_VSTART, 120},
+  {CV_VHIGH, 255},
+
+  // These two CVs define the Long DCC Address
+  {CV_MULTIFUNCTION_EXTENDED_ADDRESS_MSB, 0},
+  {CV_MULTIFUNCTION_EXTENDED_ADDRESS_LSB, DEFAULT_DECODER_ADDRESS},
+
+// ONLY uncomment 1 CV_29_CONFIG line below as approprate
+//  {CV_29_CONFIG,                                      0}, // Short Address 14 Speed Steps
+  {CV_29_CONFIG,                       CV29_F0_LOCATION}, // Short Address 28/128 Speed Steps
+//  {CV_29_CONFIG, CV29_EXT_ADDRESSING | CV29_F0_LOCATION}, // Long  Address 28/128 Speed Steps  
+};
+
+NmraDcc  Dcc ;
+
+uint8_t FactoryDefaultCVIndex = 0;
+
+// This call-back function is called when a CV Value changes so we can update CVs we're using
+void notifyCVChange( uint16_t CV, uint8_t Value)
+{
+  switch(CV)
+  {
+    case CV_VSTART:
+      vStart = Value;
+      break;
+      
+    case CV_VHIGH:
+      vHigh = Value;
+      break;
+  }
+}
+
+void notifyCVResetFactoryDefault()
+{
+  // Make FactoryDefaultCVIndex non-zero and equal to num CV's to be reset 
+  // to flag to the loop() function that a reset to Factory Defaults needs to be done
+  FactoryDefaultCVIndex = sizeof(FactoryDefaultCVs)/sizeof(CVPair);
+};
+
+// This call-back function is called whenever we receive a DCC Speed packet for our address 
+void notifyDccSpeed( uint16_t Addr, DCC_ADDR_TYPE AddrType, uint8_t Speed, DCC_DIRECTION Dir, DCC_SPEED_STEPS SpeedSteps )
+{
+  #ifdef DEBUG_SPEED
+  Serial.print("notifyDccSpeed: Addr: ");
+  Serial.print(Addr,DEC);
+  Serial.print( (AddrType == DCC_ADDR_SHORT) ? "-S" : "-L" );
+  Serial.print(" Speed: ");
+  Serial.print(Speed,DEC);
+  Serial.print(" Steps: ");
+  Serial.print(SpeedSteps,DEC);
+  Serial.print(" Dir: ");
+  Serial.println( (Dir == DCC_DIR_FWD) ? "Forward" : "Reverse" );
+  #endif
+
+  newDirection = Dir;
+  newSpeed = Speed;
+  numSpeedSteps = SpeedSteps;
+};
+
+// This call-back function is called whenever we receive a DCC Function packet for our address 
+void notifyDccFunc(uint16_t Addr, DCC_ADDR_TYPE AddrType, FN_GROUP FuncGrp, uint8_t FuncState)
+{
+  #ifdef DEBUG_FUNCTIONS
+  Serial.print("notifyDccFunc: Addr: ");
+  Serial.print(Addr,DEC);
+  Serial.print( (AddrType == DCC_ADDR_SHORT) ? 'S' : 'L' );
+  Serial.print("  Function Group: ");
+  Serial.print(FuncGrp,DEC);
+  #endif
+
+  if(FuncGrp == FN_0_4)
+  {
+    newLedState = (FuncState & FN_BIT_00) ? 1 : 0;
+    #ifdef DEBUG_FUNCTIONS
+    Serial.print(" FN 0: ");
+    Serial.print(newLedState);
+    #endif
+  }
+  #ifdef DEBUG_FUNCTIONS
+  Serial.println();
+  #endif
+}
+
+// This call-back function is called whenever we receive a DCC Packet
+#ifdef  DEBUG_DCC_MSG
+void notifyDccMsg( DCC_MSG * Msg)
+{
+  Serial.print("notifyDccMsg: ") ;
+  for(uint8_t i = 0; i < Msg->Size; i++)
+  {
+    Serial.print(Msg->Data[i], HEX);
+    Serial.write(' ');
+  }
+  Serial.println();
+}
+#endif
+
+// This call-back function is called by the NmraDcc library when a DCC ACK needs to be sent
+// Calling this function should cause an increased 60ma current drain on the power supply for 6ms to ACK a CV Read
+// So we will just turn the motor on for 8ms and then turn it off again.
+
+void notifyCVAck(void)
+{
+  #ifdef DEBUG_DCC_ACK
+  Serial.println("notifyCVAck") ;
+  #endif
+
+  digitalWrite(MOTOR_DIR_PIN, HIGH);
+  digitalWrite(MOTOR_PWM_PIN, HIGH);
+
+  delay( 8 );  
+
+  digitalWrite(MOTOR_DIR_PIN, LOW);
+  digitalWrite(MOTOR_PWM_PIN, LOW);
+}
+
+void setup()
+{
+  #ifdef DEBUG_PRINT
+  Serial.begin(115200);
+  Serial.println("NMRA Dcc Multifunction Motor Decoder Demo");
+  #endif
+
+  // Setup the Pins for the Fwd/Rev LED for Function 0 Headlight
+  pinMode(LED_PIN_FWD, OUTPUT);
+  pinMode(LED_PIN_REV, OUTPUT);
+
+  // Setup the Pins for the Motor H-Bridge Driver
+  pinMode(MOTOR_DIR_PIN, OUTPUT);
+  pinMode(MOTOR_PWM_PIN, OUTPUT);
+
+  
+  // Setup which External Interrupt, the Pin it's associated with that we're using and enable the Pull-Up 
+  Dcc.pin(DCC_PIN, 0);
+  
+  Dcc.init( MAN_ID_DIY, 10, FLAGS_MY_ADDRESS_ONLY | FLAGS_AUTO_FACTORY_DEFAULT, 0 );
+
+  // Uncomment to force CV Reset to Factory Defaults
+//  notifyCVResetFactoryDefault();
+
+  // Read the current CV values for vStart and vHigh
+  vStart = Dcc.getCV(CV_VSTART);
+  vHigh = Dcc.getCV(CV_VHIGH);
+}
+
+void loop()
+{
+  // You MUST call the NmraDcc.process() method frequently from the Arduino loop() function for correct library operation
+  Dcc.process();
+
+  // Handle Speed changes
+  if(lastSpeed != newSpeed)
+  {
+    lastSpeed = newSpeed;
+
+    // Stop if speed = 0 or 1
+    
+    if(newSpeed <= 1)
+      digitalWrite(MOTOR_PWM_PIN, LOW);
+
+    // Calculate PWM value in the range 1..255   
+    else
+    {
+      uint8_t vScaleFactor;
+      
+      if((vHigh > 1) && (vHigh > vStart))
+        vScaleFactor = vHigh - vStart;
+      else
+        vScaleFactor = 255 - vStart;
+
+      uint8_t modSpeed = newSpeed - 1;
+      uint8_t modSteps = numSpeedSteps - 1;
+      
+      uint8_t newPwm = (uint8_t) vStart + modSpeed * vScaleFactor / modSteps;
+
+      #ifdef DEBUG_PWM
+      Serial.print("New Speed: vStart: ");
+      Serial.print(vStart);
+      Serial.print(" vHigh: ");
+      Serial.print(vHigh);
+      Serial.print(" modSpeed: ");
+      Serial.print(modSpeed);
+      Serial.print(" vScaleFactor: ");
+      Serial.print(vScaleFactor);
+      Serial.print(" modSteps: ");
+      Serial.print(modSteps);
+      Serial.print(" newPwm: ");
+      Serial.println(newPwm);
+      #endif
+            
+      analogWrite(MOTOR_PWM_PIN, newPwm);
+    }
+  }
+  
+  // Handle Direction and Headlight changes
+  if((lastDirection != newDirection) || (lastLedState != newLedState))
+  {
+    lastDirection = newDirection;
+    lastLedState = newLedState;
+
+    digitalWrite(MOTOR_DIR_PIN, newDirection);
+
+    if(newLedState)
+    {
+      #ifdef DEBUG_FUNCTIONS
+      Serial.println("LED On");
+      #endif
+      digitalWrite(LED_PIN_FWD, newDirection ? LOW : HIGH);
+      digitalWrite(LED_PIN_REV, newDirection ? HIGH : LOW);
+    }
+    else
+    {
+      #ifdef DEBUG_FUNCTIONS
+      Serial.println("LED Off");
+      #endif
+      digitalWrite(LED_PIN_FWD, LOW);
+      digitalWrite(LED_PIN_REV, LOW);
+    }
+  }
+
+  // Handle resetting CVs back to Factory Defaults
+  if( FactoryDefaultCVIndex && Dcc.isSetCVReady())
+  {
+    FactoryDefaultCVIndex--; // Decrement first as initially it is the size of the array 
+    Dcc.setCV( FactoryDefaultCVs[FactoryDefaultCVIndex].CV, FactoryDefaultCVs[FactoryDefaultCVIndex].Value);
+  }
+}
--- a/library.properties
+++ b/library.properties
@@ -1,6 +1,6 @@
 name=NmraDcc
-version=2.0.0
-author=Alex Shepherd, Wolfgang Kuffer, Geoff Bunza, Martin Pischky, Franz-Peter Müller, Sven (littleyoda)
+version=2.0.6
+author=Alex Shepherd, Wolfgang Kuffer, Geoff Bunza, Martin Pischky, Franz-Peter Müller, Sven (littleyoda), Hans Tanner
 maintainer=Alex Shepherd <kiwi64ajs@gmail.com>
 sentence=Enables NMRA DCC Communication 
 paragraph=This library allows you to interface to a NMRA DCC track signal and receive DCC commands. The library has been tested on AVR ATTiny84/85 & ATMega88/168/328/32u4, ESP8266 and Teensy 3.x using the INT0/1 Hardware Interrupt and micros() ONLY and no longer uses Timer0 Compare Match B, which makes it much more portable to other platforms.
Author	SHA1	Message	Date
Alex Shepherd	7e3b3e3469	Changed how INPUT_PULLUP is done to be compatibile with ESP32 Bumped version to 2.0.6	2020-10-20 09:42:00 +13:00
Alex Shepherd	a09c6b1002	bumped NMRADCC_VERSION to 205	2020-06-02 09:50:12 +12:00
Alex Shepherd	29bc2aa1c0	default to DISABLE_OUTPUTS_IDLE uncommented	2020-06-01 19:04:56 +12:00
Alex Shepherd	3abb683d8d	improved DCCInterface_TurntableControl example to: - Added selectable Movement Strategy: Positive Direction Only, Negative Direction Only, Shortest Distance - Made Disabling Output on Idle optional	2020-06-01 18:49:00 +12:00
Alex Shepherd	f3da07c739	added Franz-Peter's changes to pass NMRA Tests ( always search for preamble )	2020-05-31 20:14:28 +12:00
Alex Shepherd	dead808af2	added work-around for ATtiny1614 range of chips that have a bug in: eeprom_is_ready()	2020-05-30 16:14:27 +12:00
Alex Shepherd	38194c0148	Correct the inconsistent license text in the source files to be the Lesser GPL as was intended by the LICENSE file and the repo classification	2020-02-03 22:16:00 +13:00
Alex Shepherd	7819716ac0	manually merged in Franz-Peter's changes as his PR#30 pull-request had too many differences to merge once I'd already solved the advancedAck issue. This commit contains the remaining relevant changes after doing a manual diff of the library files	2020-01-10 17:33:09 +13:00
Alex Shepherd	5349a21e2e	fix bug caused when AdvancedCVAck logic was added as the CV Programming code was shared between Service Mode and Ops Mode programming.	2020-01-10 15:30:30 +13:00
Alex Shepherd	36418f4d66	fixed a bug with the Extended DCC Packet Decoder Reset command was only handling the Hard Reset but not the Soft Reset	2019-11-23 14:25:28 +13:00
Alex Shepherd	a8081526ba	Merge commit '71bb657e3a7d80edc096094564f5d279e8a1fb69' * commit '71bb657e3a7d80edc096094564f5d279e8a1fb69': Esp32 iram attr (#26) The merge adds extra STM32 handling Als manually resolved the conflict around the type for lastMicros, to now be: static unsigned int lastMicros = 0; Howefully this does the right thing on each platform	2019-10-28 18:58:02 +13:00
Alex Shepherd	7063e4e7e7	Merge branch 'master' of https://github.com/mrrwa/NmraDcc * 'master' of https://github.com/mrrwa/NmraDcc: Update NmraDcc.cpp Update NmraDcc.cpp (#28)	2019-08-19 19:08:28 +12:00
Alex Shepherd	d8fb99ed91	Update NmraDcc.cpp Added some more comments to the ServiceMode programming DCC Packet comparison logic	2019-08-19 19:04:51 +12:00
Roeland	794128fe4b	Update NmraDcc.cpp (#28 ) Changed the Service Mode duplicate packet comparison to only compare the packet Size and Data fields and ignore the number of Preamble bits as some command stations appear to send different numbers of preamble bits for otherwise duplicated packets, so we detecting the required two identical packets in sequence and performing the ServiceMode Operation	2019-08-19 18:59:29 +12:00
Alex Shepherd	1542a6fe6c	Merge branch 'AdvancedCVAck' * AdvancedCVAck: corrected method description split out ServiceMode ackCV from Ops Mode AdvancedCVAck as doing a ackCV in Ops Mode is wrong and adds 6ms busy delay add cache of CV29 value	2019-08-09 08:20:45 +12:00
Alex Shepherd	828b1feaba	corrected method description	2019-08-09 08:19:53 +12:00
Bob Jacobsen	462025b9fe	Comment update (#27 ) Incredibly trivial update to comment noticed while reading code.	2019-08-06 09:10:21 +12:00
Franz-Peter	71bb657e3a	Esp32 iram attr (#26 ) * changed the version to 201 in the header * added conditional compilation for ESP8266 to add ICACHE_RAM_ATTR to ExternalInterruptHandler changed storage for Micros to unsigned long * some tuning to bit recognition and nested IRQ (STM32)	2019-08-06 01:14:58 +12:00
Alex Shepherd	f3a2b87693	split out ServiceMode ackCV from Ops Mode AdvancedCVAck as doing a ackCV in Ops Mode is wrong and adds 6ms busy delay add cache of CV29 value	2019-08-06 00:22:04 +12:00
Alex Shepherd	e06f6b3bce	bumped version to 2.0.2	2019-08-05 21:34:48 +12:00
Alex Shepherd	6a7e206032	reverted changes around lastMicros	2019-08-05 21:30:39 +12:00
Alex Shepherd	6d12e6cd3f	added conditional compilation for ESP8266 to add ICACHE_RAM_ATTR to ExternalInterruptHandler changed storage for Micros to unsigned long	2019-05-25 15:52:55 +12:00
Alex Shepherd	b249762550	changed the version to 201 in the header	2019-05-02 21:42:59 +12:00
Alex Shepherd	5cee0d28ed	Merge branch 'master' into ESP32-IRAM_ATTR	2019-05-02 19:11:05 +12:00
Alex Shepherd	5ba1ee3e8e	added another example of s simple DCC Multifunction (Locomotive) decoder	2019-05-02 11:13:22 +12:00
Franz-Peter	bb2a659ebe	Esp32 processor specific (#23 ) * outputaddressing corrected declared notifyDccAccState for backward compatibility * version define in NmraDcc.h * DB_PRINT introduced Changed debug printing to a macro. Added cv29 to CV-addresses that reset caching of myAddress * Corrections regarding Outputaddressing OutputAddress must be a signed variable * Changes/additions regarding output addressing and CVChange callback Change Flag FLAGS_OUTPUT_ADDRESS_MODE accordingly, when CV29 Bit 6 (output addressing) is changed. New callback 'notifyDccCVChange' which is NOT called if the CV is changed by means of the setCV() method * Shorten Debug Messages Because of Buffer overrun in the serial output. This leads to blocking Serial.write() calls * notifyDccSigState restored Restore the old callback notifyDccSigState for compatibiltity to version 1.4.2 * switch off debug printing * ESP32 specific changes insert ESP32 specific changes reagarding the ISR by Hans Tanner	2019-02-22 08:42:34 +13:00
Alex Shepherd	865d919802	Added IRAM_ATTR changes for the ESP32 from Hans Tanner bumped version to 2.0.1	2019-02-16 22:09:19 +13:00
Thierry Paris	ff3e24dff4	Add ESP32 support (#21 ) * Update README.md * Added ESP32 support.	2019-01-23 14:15:46 +13:00