├── library.properties
├── keywords.txt
├── readme.md
├── readme.txt
├── examples
    ├── DCC_Monitor
    │   └── DCC_Monitor.pde
    └── DCC_Basic_Acc_Decoder
    │   └── DCC_Basic_Acc_Decoder.pde
├── DCC_Decoder.h
└── DCC_Decoder.cpp


/library.properties:
--------------------------------------------------------------------------------
 1 | name=DCC Decoder
 2 | author=MynaBay
 3 | maintainer=MynaBay <contact@mynabay.com>
 4 | sentence=An Arduino library for creating NMRA DCC decoding devices. 
 5 | paragraph=Use this library to decode model railroad DCC signals.
 6 | category=Communication
 7 | url=https://github.com/MynaBay/DCC_Decoder
 8 | architectures=*
 9 | version=1.6
10 | core-dependencies=arduino (>=1.6.0)
11 | 


--------------------------------------------------------------------------------
/keywords.txt:
--------------------------------------------------------------------------------
 1 | #######################################
 2 | # Syntax Coloring Map For Matrix
 3 | #######################################
 4 | 
 5 | #######################################
 6 | # Datatypes (KEYWORD1)
 7 | #######################################
 8 | 
 9 | DCC_Decoder	KEYWORD1
10 | 
11 | #######################################
12 | # Methods and Functions (KEYWORD2)
13 | #######################################
14 | 
15 | SetupDecoder	KEYWORD2
16 | SetupMonitor	KEYWORD2
17 | SetIdlePacketHandler	KEYWORD2
18 | SetResetPacketHandler	KEYWORD2
19 | SetRawPacketHandler	KEYWORD2
20 | SetBasicAccessoryDecoderPacketHandler	KEYWORD2
21 | SetExtendedAccessoryDecoderPacketHandler	KEYWORD2
22 | SetBaselineControlPacketHandler	KEYWORD2
23 | SetDecodingEngineCompletionStatusHandler	KEYWORD2
24 | ReadCV	KEYWORD2
25 | WriteCV	KEYWORD2
26 | MakePacketString	KEYWORD2
27 | ResultString	KEYWORD2
28 | loop	KEYWORD2
29 | Address	KEYWORD2
30 | 
31 | #######################################
32 | # Constants (LITERAL1)
33 | #######################################
34 | 
35 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | This is a library for Arduino for decoding dcc signals.
 2 | Uses Arduino 1.6 IDE.
 3 | 
 4 | Installation
 5 | --------------------------------------------------------------------------------
 6 | 
 7 | To install this library, just place this entire folder as a subfolder in your
 8 | Arduino/lib/targets/libraries folder.
 9 | 
10 | When installed, this library should look like:
11 | 
12 | libraries/DCC_Decoder              		(this library's folder)
13 | libraries/DCC_Decoder/DCC_Decoder.cpp       	(the library implementation file)
14 | libraries/DCC_Decoder/DCC_Decoder.h    	        (the library header file)
15 | libraries/DCC_Decoder/keywords.txt 		(the syntax coloring file)
16 | libraries/DCC_Decoder/examples     		(the examples in the "open" menu)
17 | libraries/DCC_Decoder/readme.txt   		(this file)
18 | 
19 | Building
20 | --------------------------------------------------------------------------------
21 | 
22 | After this library is installed, you just have to start the Arduino application.
23 | 
24 | To use this library in a sketch, go to the Sketch | Import Library menu and
25 | select DCC_Decoder.  This will add a corresponding line to the top of your sketch:
26 | 
27 | #include <DCC_Decoder.h>
28 | 
29 | To stop using this library, delete that line from your sketch.
30 | 


--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
 1 | This is a library for Arduino for decoding dcc signals.
 2 | Uses Arduino 1.6 IDE. 
 3 | 
 4 | Installation
 5 | --------------------------------------------------------------------------------
 6 | 
 7 | To install this library, just place this entire folder as a subfolder in your
 8 | Arduino/lib/targets/libraries folder.
 9 | 
10 | When installed, this library should look like:
11 | 
12 | libraries/DCC_Decoder              		(this library's folder)
13 | libraries/DCC_Decoder/DCC_Decoder.cpp       	(the library implementation file)
14 | libraries/DCC_Decoder/DCC_Decoder.h    	        (the library header file)
15 | libraries/DCC_Decoder/keywords.txt 		(the syntax coloring file)
16 | libraries/DCC_Decoder/examples     		(the examples in the "open" menu)
17 | libraries/DCC_Decoder/readme.txt   		(this file)
18 | 
19 | Building
20 | --------------------------------------------------------------------------------
21 | 
22 | After this library is installed, you just have to start the Arduino application.
23 | 
24 | To use this library in a sketch, go to the Sketch | Import Library menu and
25 | select DCC_Decoder.  This will add a corresponding line to the top of your sketch:
26 | 
27 | #include <DCC_Decoder.h>
28 | 
29 | To stop using this library, delete that line from your sketch.
30 | 


--------------------------------------------------------------------------------
/examples/DCC_Monitor/DCC_Monitor.pde:
--------------------------------------------------------------------------------
  1 | #include <DCC_Decoder.h>
  2 | 
  3 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  4 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  5 | //
  6 | // Defines and structures
  7 | //
  8 | #define kDCC_INTERRUPT            0
  9 | 
 10 | typedef struct
 11 | {
 12 |     int count;
 13 |     byte validBytes;
 14 |     byte data[6];
 15 | } DCCPacket;
 16 | 
 17 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 18 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 19 | //
 20 | // The dcc decoder object and global data
 21 | //
 22 | int gPacketCount = 0;
 23 | int gIdlePacketCount = 0;
 24 | int gLongestPreamble = 0;
 25 | 
 26 | DCCPacket gPackets[25];
 27 | 
 28 | static unsigned long lastMillis = millis();
 29 |     
 30 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 31 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 32 | //
 33 | // Packet handlers
 34 | //
 35 | 
 36 | // ALL packets are sent to the RawPacket handler. Returning true indicates that packet was handled. DCC library starts watching for 
 37 | // next preamble. Returning false and library continue parsing packet and finds another handler to call.
 38 | boolean RawPacket_Handler(byte byteCount, byte* packetBytes)
 39 | {
 40 |         // Bump global packet count
 41 |     ++gPacketCount;
 42 |     
 43 |     int thisPreamble = DCC.LastPreambleBitCount();
 44 |     if( thisPreamble > gLongestPreamble )
 45 |     {
 46 |         gLongestPreamble = thisPreamble;
 47 |     }
 48 |     
 49 |         // Walk table and look for a matching packet
 50 |     for( int i=0; i<(int)(sizeof(gPackets)/sizeof(gPackets[0])); ++i )
 51 |     {
 52 |         if( gPackets[i].validBytes )
 53 |         {
 54 |                 // Not an empty slot. Does this slot match this packet? If so, bump count.
 55 |             if( gPackets[i].validBytes==byteCount )
 56 |             {
 57 |                 char isPacket = true;
 58 |                 for( int j=0; j<byteCount; j++)
 59 |                 {
 60 |                     if( gPackets[i].data[j] != packetBytes[j] )
 61 |                     {
 62 |                         isPacket = false;
 63 |                         break;
 64 |                     } 
 65 |                 }
 66 |                 if( isPacket )
 67 |                 {
 68 |                    gPackets[i].count++;
 69 |                    return false;
 70 |                 }
 71 |             }
 72 |         }else{
 73 |                 // Empty slot, just copy over data
 74 |             gPackets[i].count++;
 75 |             gPackets[i].validBytes = byteCount;
 76 |             for( int j=0; j<byteCount; j++)
 77 |             {
 78 |                 gPackets[i].data[j] = packetBytes[j];
 79 |             }
 80 |             return false;
 81 |         }
 82 |     }    
 83 |     
 84 |     return false;
 85 | }
 86 | 
 87 | // Idle packets are sent here (unless handled in rawpacket handler). 
 88 | void IdlePacket_Handler(byte byteCount, byte* packetBytes)
 89 | {
 90 |     ++gIdlePacketCount;
 91 | }
 92 | 
 93 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 94 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 95 | //
 96 | // Setup
 97 | //
 98 | void setup() 
 99 | { 
100 |    Serial.begin(9600);
101 |     
102 |    DCC.SetRawPacketHandler(RawPacket_Handler);   
103 |    DCC.SetIdlePacketHandler(IdlePacket_Handler);
104 |             
105 |    DCC.SetupMonitor( kDCC_INTERRUPT );   
106 | }
107 | 
108 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
109 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
110 | 
111 | void DumpAndResetTable()
112 | {
113 |     char buffer60Bytes[60];
114 |     
115 |     Serial.print("Total Packet Count: ");
116 |     Serial.println(gPacketCount, DEC);
117 |     
118 |     Serial.print("Idle Packet Count:  ");
119 |     Serial.println(gIdlePacketCount, DEC);
120 |         
121 |     Serial.print("Longest Preamble:  ");
122 |     Serial.println(gLongestPreamble, DEC);
123 |     
124 |     Serial.println("Count    Packet_Data");
125 |     for( int i=0; i<(int)(sizeof(gPackets)/sizeof(gPackets[0])); ++i )
126 |     {
127 |         if( gPackets[i].validBytes > 0 )
128 |         {
129 |             Serial.print(gPackets[i].count, DEC);
130 |             if( gPackets[i].count < 10 )
131 |             {
132 |                 Serial.print("        ");
133 |             }else{
134 |                 if( gPackets[i].count < 100 )
135 |                 {
136 |                     Serial.print("       ");
137 |                 }else{
138 |                     Serial.print("      ");
139 |                 }
140 |             }
141 |             Serial.println( DCC.MakePacketString(buffer60Bytes, gPackets[i].validBytes, &gPackets[i].data[0]) );
142 |         }
143 |         gPackets[i].validBytes = 0;
144 |         gPackets[i].count = 0;
145 |     }
146 |     Serial.println("============================================");
147 |     
148 |     gPacketCount = 0;
149 |     gIdlePacketCount = 0;
150 |     gLongestPreamble = 0;
151 | }
152 | 
153 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
154 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
155 | //
156 | // Main loop
157 | //
158 | void loop()
159 | {
160 |     DCC.loop();
161 |     
162 |     if( millis()-lastMillis > 2000 )
163 |     {
164 |         DumpAndResetTable();
165 |         lastMillis = millis();
166 |     }
167 | }
168 | 
169 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
170 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
171 | 
172 | 


--------------------------------------------------------------------------------
/examples/DCC_Basic_Acc_Decoder/DCC_Basic_Acc_Decoder.pde:
--------------------------------------------------------------------------------
  1 | #include <DCC_Decoder.h>
  2 | 
  3 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  4 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  5 | //
  6 | // Defines and structures
  7 | //
  8 | #define kDCC_INTERRUPT            0
  9 | 
 10 | typedef struct
 11 | {
 12 |     int               address;                // Address to respond to
 13 |     byte              output;                 // State of output 1=on, 0=off
 14 |     int               outputPin;              // Arduino output pin to drive
 15 |     boolean           isDigital;              // true=digital, false=analog. If analog must also set analogValue field
 16 |     boolean           isFlasher;              // true=flash output, false=no time, no flash.
 17 |     byte              analogValue;            // Value to use with analog type.
 18 |     int               durationMilli;          // Milliseconds to leave output on for.  0 means don't auto off
 19 |     
 20 |     unsigned long     onMilli;                // Used internally for timing
 21 |     unsigned long     offMilli;               // 
 22 | } DCCAccessoryAddress;
 23 | 
 24 | DCCAccessoryAddress gAddresses[8];
 25 | 
 26 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 27 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 28 | //
 29 | // Decoder Init 
 30 | //
 31 | void ConfigureDecoder()
 32 | {
 33 |     gAddresses[0].address = 714;
 34 |     gAddresses[0].output = 0;
 35 |     gAddresses[0].outputPin = 5;
 36 |     gAddresses[0].isDigital = false;
 37 |     gAddresses[0].isFlasher = false;
 38 |     gAddresses[0].analogValue = 250;
 39 |     gAddresses[0].durationMilli = 500;
 40 |     
 41 |     gAddresses[1].address = 715;
 42 |     gAddresses[1].output = 0;
 43 |     gAddresses[1].outputPin = 6;
 44 |     gAddresses[1].isDigital = true;
 45 |     gAddresses[1].isFlasher = false;
 46 |     gAddresses[1].analogValue = 0;
 47 |     gAddresses[1].durationMilli = 500;
 48 |         
 49 |     gAddresses[2].address = 814;
 50 |     gAddresses[2].output = 0;
 51 |     gAddresses[2].outputPin = 5;
 52 |     gAddresses[2].isDigital = false;
 53 |     gAddresses[2].isFlasher = true;
 54 |     gAddresses[2].analogValue = 250;
 55 |     gAddresses[2].durationMilli = 500;
 56 |     
 57 |     gAddresses[3].address = 815;
 58 |     gAddresses[3].output = 0;
 59 |     gAddresses[3].outputPin = 6;
 60 |     gAddresses[3].isDigital = true;
 61 |     gAddresses[3].isFlasher = true;
 62 |     gAddresses[3].analogValue = 0;
 63 |     gAddresses[3].durationMilli = 500;
 64 |     
 65 |     gAddresses[4].address = 914;
 66 |     gAddresses[4].output = 0;
 67 |     gAddresses[4].outputPin = 5;
 68 |     gAddresses[4].isDigital = false;
 69 |     gAddresses[4].isFlasher = false;
 70 |     gAddresses[4].analogValue = 250;
 71 |     gAddresses[4].durationMilli = 0;
 72 |     
 73 |     gAddresses[5].address = 915;
 74 |     gAddresses[5].output = 0;
 75 |     gAddresses[5].outputPin = 6;
 76 |     gAddresses[5].isDigital = true;
 77 |     gAddresses[5].isFlasher = false;
 78 |     gAddresses[5].analogValue = 0;
 79 |     gAddresses[5].durationMilli = 0;
 80 |     
 81 |     gAddresses[6].address = 0;
 82 |     gAddresses[6].output = 0;
 83 |     gAddresses[6].outputPin = 0;
 84 |     gAddresses[6].isDigital = false;
 85 |     gAddresses[6].isFlasher = false;
 86 |     gAddresses[6].analogValue = 0;
 87 |     gAddresses[6].durationMilli = 0;
 88 |     
 89 |     gAddresses[7].address = 0;
 90 |     gAddresses[7].output = 0;
 91 |     gAddresses[7].outputPin = 0;
 92 |     gAddresses[7].isDigital = false;
 93 |     gAddresses[7].isFlasher = false;
 94 |     gAddresses[7].analogValue = 0;
 95 |     gAddresses[7].durationMilli = 0;
 96 |     
 97 |         // Setup output pins
 98 |     for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
 99 |     {
100 |         if( gAddresses[i].outputPin )
101 |         {
102 |             pinMode( gAddresses[i].outputPin, OUTPUT );
103 |         }
104 |         gAddresses[i].onMilli = 0;
105 |         gAddresses[i].offMilli = 0;
106 |     }
107 | }
108 | 
109 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
110 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
111 | //
112 | // Basic accessory packet handler 
113 | //
114 | void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
115 | {
116 |         // Convert NMRA packet address format to human address
117 |     address -= 1;
118 |     address *= 4;
119 |     address += 1;
120 |     address += (data & 0x06) >> 1;
121 |     
122 |     boolean enable = (data & 0x01) ? 1 : 0;
123 |     
124 |     for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
125 |     {
126 |         if( address == gAddresses[i].address )
127 |         {
128 |             Serial.print("Basic addr: ");
129 |             Serial.print(address,DEC);
130 |             Serial.print("   activate: ");
131 |             Serial.println(enable,DEC);
132 |             
133 |             if( enable )
134 |             {
135 |                 gAddresses[i].output = 1;
136 |                 gAddresses[i].onMilli = millis();
137 |                 gAddresses[i].offMilli = 0;
138 |             }else{
139 |                 gAddresses[i].output = 0;
140 |                 gAddresses[i].onMilli = 0;
141 |                 gAddresses[i].offMilli = millis();
142 |             }
143 |         }
144 |     }
145 |     
146 | }
147 | 
148 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
149 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
150 | //
151 | // Setup
152 | //
153 | void setup() 
154 | { 
155 |    Serial.begin(9600);
156 |    DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
157 |    ConfigureDecoder();
158 |    DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
159 | }
160 | 
161 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
162 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
163 | //
164 | // Main loop
165 | //
166 | void loop()
167 | {
168 |     static int addr = 0;
169 |     
170 |         ////////////////////////////////////////////////////////////////
171 |         // Loop DCC library
172 |     DCC.loop();
173 |     
174 |         ////////////////////////////////////////////////////////////////
175 |         // Bump to next address to test
176 |     if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) )
177 |     {
178 |         addr = 0;
179 |     }
180 |     
181 |         ////////////////////////////////////////////////////////////////
182 |         // Turn off output?
183 |     if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() )
184 |     {
185 |             // Clear off time
186 |         gAddresses[addr].offMilli = 0;
187 |         
188 |             // Disable output
189 |         if( gAddresses[addr].isDigital )
190 |         {
191 |             digitalWrite( gAddresses[addr].outputPin, LOW);
192 |         }else{
193 |             analogWrite( gAddresses[addr].outputPin, 0);
194 |         }
195 |         
196 |             // If still enabled and a flash type, set on time
197 |         if( gAddresses[addr].output && gAddresses[addr].isFlasher)
198 |         {
199 |             gAddresses[addr].onMilli = millis() + gAddresses[addr].durationMilli;
200 |         }else{
201 |             gAddresses[addr].output = 0;
202 |         }
203 |         
204 |         return;
205 |     }
206 |         
207 |         ////////////////////////////////////////////////////////////////
208 |         // Turn on output?
209 |     if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() )
210 |     {
211 |             // Clear off time
212 |         gAddresses[addr].onMilli = 0;
213 |         
214 |             // Enable output
215 |         if( gAddresses[addr].isDigital )
216 |         {
217 |             digitalWrite( gAddresses[addr].outputPin, HIGH);
218 |         }else{
219 |             analogWrite( gAddresses[addr].outputPin, gAddresses[addr].analogValue);
220 |         }
221 |         
222 |             // If still enabled and a flash type, set off time
223 |         if( gAddresses[addr].durationMilli )
224 |         {
225 |             gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
226 |         }
227 |         
228 |         return;
229 |     }
230 |     
231 | }
232 | 
233 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
234 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
235 | 
236 | 


--------------------------------------------------------------------------------
/DCC_Decoder.h:
--------------------------------------------------------------------------------
  1 | //
  2 | // DCC_Decoder.h - Arduino library for NMRA DCC Decoding.
  3 | // Written by Kevin Snow, MynaBay.com, November, 2011. 
  4 | // Questions: dcc@mynabay.com
  5 | // Released into the public domain.
  6 | //
  7 | 
  8 | #ifndef __DCC_DECODER_H__
  9 | #define __DCC_DECODER_H__
 10 | 
 11 | #include "Arduino.h"
 12 | 
 13 | ///////////////////////////////////////////////////////////////////////////////////////
 14 | 
 15 | #define kDCC_STOP_SPEED     0xFE
 16 | #define kDCC_ESTOP_SPEED    0xFF
 17 | 
 18 |     // Multifunction Decoders
 19 | #define kCV_PrimaryAddress            1
 20 | #define kCV_Vstart                    2
 21 | #define kCV_AccelerationRate          3
 22 | #define kCV_Deceleration Rate         4
 23 | #define kCV_ManufacturerVersionNo     7 
 24 | #define kCV_ManufacturedID            8
 25 | #define kCV_ExtendedAddress1          17
 26 | #define kCV_ExtendedAddress2          18
 27 | #define kCV_ConfigurationData1        29
 28 | 
 29 |     // Accessory Decoders
 30 | #define kCV_AddressLSB                1
 31 | #define kCV_AddressMSB                9
 32 | 
 33 | 
 34 |     // DCC_Decoder results/errors
 35 | #define kDCC_OK                       0
 36 | #define kDCC_OK_UNHANDLED             1
 37 | #define kDCC_OK_BOOT                  2
 38 | #define kDCC_OK_IDLE                  3
 39 | #define kDCC_OK_RESET                 4
 40 | #define kDCC_OK_RAW                   5
 41 | #define kDCC_OK_BASELINE              6 
 42 | #define kDCC_OK_BASIC_ACCESSORY       7 
 43 | #define kDCC_OK_EXTENDED_ACCESSORY    8
 44 | #define kDCC_OK_MAX                   99
 45 | 
 46 | #define kDCC_ERR_DETECTION_FAILED     100
 47 | #define kDCC_ERR_BASELINE_ADDR        101             
 48 | #define kDCC_ERR_BASELINE_INSTR       102         // Baseline packet instruction isn't 0x01DCSSSS
 49 | #define kDCC_ERR_MISSED_BITS          103
 50 | #define kDCC_ERR_NOT_0_OR_1           104
 51 | #define kDCC_ERR_INVALID_LENGTH       105
 52 | #define kDCC_ERR_MISSING_END_BIT      106
 53 | 
 54 |     // Min and max valid packet lengths
 55 | #define kPACKET_LEN_MIN               3
 56 | #define kPACKET_LEN_MAX               6
 57 | 
 58 |     // CV 1..256 are supported
 59 | #define kCV_MAX                       257
 60 | 
 61 | ///////////////////////////////////////////////////////////////////////////////////////
 62 | 
 63 | typedef boolean (*RawPacket)(byte byteCount, byte* packetBytes);
 64 | 
 65 | typedef void (*IdleResetPacket)(byte byteCount, byte* packetBytes);
 66 | 
 67 | typedef void (*BaselineControlPacket)(int address, int speed, int direction);
 68 | 
 69 | typedef void (*BasicAccDecoderPacket)(int address, boolean activate, byte data);
 70 | typedef void (*ExtendedAccDecoderPacket)(int address, byte data);
 71 | 
 72 | typedef void (*DecodingEngineCompletion)(byte resultOfLastPacket);
 73 | 
 74 | ///////////////////////////////////////////////////////////////////////////////////////
 75 | 
 76 | typedef void(*StateFunc)();
 77 | 
 78 | ///////////////////////////////////////////////////////////////////////////////////////
 79 | 
 80 | class DCC_Decoder
 81 | {
 82 | public:
 83 |     DCC_Decoder();
 84 |     
 85 |         // Called from setup in Arduino Sketch. Set mfgID, mfgVers and interrupt. Call one SetupXXX
 86 |     void SetupDecoder(byte mfgID, byte mfgVers, byte interrupt);    // Used for Decoder
 87 |     void SetupMonitor(byte interrupt);                              // Used when building a monitor
 88 |     
 89 |         // All packets are sent to RawPacketHandler. Return true to stop dispatching to other handlers.
 90 |     void SetRawPacketHandler(RawPacket func);
 91 |     
 92 |         // S 9.2 defines two special packets. Idle and reset.
 93 |     void SetIdlePacketHandler(IdleResetPacket func);
 94 |     void SetResetPacketHandler(IdleResetPacket func);
 95 |     
 96 |         // Handler for S 9.2 baseline packets. Speed value will be 1-14, 1-28, kDCC_STOP_SPEED or kDCC_ESTOP_SPEED
 97 |     void SetBaselineControlPacketHandler(BaselineControlPacket func, boolean allPackets);
 98 |     
 99 |         // Handler for RP 9.2.1 Accessory Decoders.
100 |     void SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket func, boolean allPackets);
101 |     void SetExtendedAccessoryDecoderPacketHandler(ExtendedAccDecoderPacket func, boolean allPackets);
102 |                 
103 |         // Read/Write CVs
104 |     byte ReadCV(int cv);
105 |     void WriteCV(int cv, byte data);
106 |     
107 |         // Helper function to read decoder address
108 |     int Address();
109 |     
110 |         // Call at least once from mainloop. Not calling frequently enough and library will miss data bits!
111 |     void loop();
112 |     
113 |         // Returns the packet data in string form.
114 |     char* MakePacketString(char* buffer60Bytes, byte packetByteCount, byte* packet);
115 |         
116 |         // Returns the number of bits in last preamble 
117 |     int LastPreambleBitCount();
118 |     
119 |         // Timing functions. These return MS since various packets
120 |     unsigned long MillisecondsSinceLastValidPacket();
121 |     unsigned long MillisecondsSinceLastPacketToThisDecoder();
122 |     unsigned long MillisecondsSinceLastIdlePacket();
123 |     unsigned long MillisecondsSinceLastResetPacket();
124 |     
125 |     
126 |     //=======================   Debugging   =======================//    
127 |         // Everytime the DCC Decoder engine starts looking for preamble bits this will be 
128 |         // called with result of last packet. (Debugging)
129 |     void SetDecodingEngineCompletionStatusHandler(DecodingEngineCompletion func);
130 |         // Converts code passed into completionStatusHandler to human readable string.
131 |     const char PROGMEM* ResultString(byte resultCode);
132 |     
133 |     //======================= Library Internals =======================//
134 | private:
135 |         // State machine functions
136 |     static void State_Boot();
137 |     static void State_ReadPreamble();
138 |     static void State_ReadPacket();
139 |     static void State_Execute();
140 |     static void State_Reset();
141 |     
142 |         // Function pointers for the library callbacks
143 |     static RawPacket                func_RawPacket;
144 |     static IdleResetPacket          func_IdlePacket;
145 |     static IdleResetPacket          func_ResetPacket;
146 |         
147 |     static BasicAccDecoderPacket    func_BasicAccPacket;
148 |     static boolean                  func_BasicAccPacket_All_Packets;
149 |     static ExtendedAccDecoderPacket func_ExtdAccPacket;
150 |     static boolean                  func_ExtdAccPacket_All_Packets;
151 |     
152 |     static BaselineControlPacket    func_BaselineControlPacket;
153 |     static boolean                  func_BaselineControlPacket_All_Packets;
154 |     
155 |     static DecodingEngineCompletion func_DecodingEngineCompletion;
156 |     
157 |         // Current state function pointer
158 |     static StateFunc                gState;                      // Current state function pointer
159 |     
160 |         // Timing data from last interrupt
161 |     static unsigned int             gLastChaos;                  // Interrupt chaos count we processed
162 |     
163 |         // Preamble bit count
164 |     static int                      gPreambleCount;              // Bit count for reading preamble
165 |     
166 |         // Reset reason 
167 |     static byte                     gResetReason;                // Result code of last reason decoder was reset
168 |     static boolean                  gHandledAsRawPacket;
169 |     
170 |         // Packet data
171 |     static byte                     gPacket[kPACKET_LEN_MAX];    // The packet data.
172 |     static byte                     gPacketIndex;                // Byte index to write to.
173 |     static byte                     gPacketMask;                 // Bit index to write to. 0x80,0x40,0x20,...0x01
174 |     static boolean                  gPacketEndedWith1;           // Set true if packet ended on 1. Spec requires that the 
175 |                                                                  // packet end bit can count as a bit in next preamble. 
176 |                                                                  // CV Storage
177 |     static byte                     gCV[kCV_MAX];                // CV Storage (TODO - Storage in PROGMEM)
178 |     
179 |         // Packet arrival timing
180 |     static unsigned long            gThisPacketMS;               // Milliseconds of this packet being parsed
181 |     static boolean                  gLastPacketToThisAddress;    // Was last pack processed to this decoder's address?
182 |     
183 |     static unsigned long            gLastValidPacketMS;          // Milliseconds of last valid packet
184 |     static unsigned long            gLastValidPacketToAddressMS; // Milliseconds of last valid packet to this decoder
185 |     static unsigned long            gLastValidIdlePacketMS;      // Milliseconds of last valid idle packet
186 |     static unsigned long            gLastValidResetPacketMS;     // Milliseconds of last valid reset packet
187 | 
188 |         //////////////////////////////////////////////////////
189 |         // Interrupt Support
190 |     static void StartInterrupt(byte interrupt);    
191 |     static void DCC_Interrupt();
192 |     static void ShiftInterruptAlignment();
193 |     
194 |     static unsigned long          gInterruptMicros;
195 |     static byte                   gInterruptTimeIndex;
196 |     static volatile unsigned int  gInterruptTime[2];
197 |     static volatile unsigned int  gInterruptChaos;
198 | };
199 | 
200 | ///////////////////////////////////////////////////////////////////////////////////////
201 | 
202 | extern DCC_Decoder DCC;
203 | 
204 | ///////////////////////////////////////////////////////////////////////////////////////
205 | 
206 | #endif
207 | 


--------------------------------------------------------------------------------
/DCC_Decoder.cpp:
--------------------------------------------------------------------------------
  1 | //
  2 | // DCC_Decoder.cpp - Arduino library for NMRA DCC Decoding.
  3 | // Written by Kevin Snow, MynaBay.com, November, 2011. 
  4 | // Questions: dcc@mynabay.com
  5 | // Released into the public domain.
  6 | //
  7 | 
  8 | #include "Arduino.h"
  9 | #include "DCC_Decoder.h"
 10 | 
 11 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 12 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 13 | //
 14 | // Global Decoder object
 15 | //
 16 | 
 17 | DCC_Decoder DCC;
 18 | 
 19 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 20 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 21 | //
 22 | // NMRA DCC Definitions
 23 | //
 24 |     // Microsecond 0 & 1 timings 
 25 | #define    kONE_Min         52
 26 | #define    kONE_Max         64
 27 | 
 28 | #define    kZERO_Min        90
 29 | #define    kZERO_Max        10000
 30 | 
 31 |     // Minimum preamble length
 32 | #define    kPREAMBLE_MIN    10
 33 | 
 34 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 35 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 36 | //
 37 | // Interrupt handling
 38 | //
 39 | unsigned long          DCC_Decoder::gInterruptMicros = 0;
 40 | byte                   DCC_Decoder::gInterruptTimeIndex = 0;
 41 | volatile unsigned int  DCC_Decoder::gInterruptTime[2];
 42 | volatile unsigned int  DCC_Decoder::gInterruptChaos;
 43 | 
 44 | ///////////////////////////////////////////////////
 45 | 
 46 | void DCC_Decoder::DCC_Interrupt()
 47 | {
 48 |     unsigned long ms = micros();
 49 |     gInterruptTime[gInterruptTimeIndex] = ms - gInterruptMicros;
 50 |     gInterruptMicros = ms;
 51 |     gInterruptChaos += gInterruptTimeIndex;
 52 |     gInterruptTimeIndex ^= 0x01;    
 53 | }
 54 | 
 55 | ///////////////////////////////////////////////////
 56 | 
 57 | void DCC_Decoder::ShiftInterruptAlignment()
 58 | {
 59 |     noInterrupts();
 60 |     gInterruptTime[0] = gInterruptTime[1];
 61 |     gInterruptTimeIndex = 1;
 62 |     interrupts();
 63 | }
 64 | 
 65 | ///////////////////////////////////////////////////
 66 | 
 67 | void DCC_Decoder::StartInterrupt(byte interrupt)
 68 | {
 69 |     gInterruptTimeIndex = 0;
 70 |     gInterruptTime[0] = gInterruptTime[1] = 0;
 71 |     gInterruptChaos = 0;
 72 |     gInterruptMicros = micros();
 73 |     
 74 |     attachInterrupt( interrupt, DCC_Interrupt, CHANGE );
 75 | }
 76 | 
 77 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 78 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 79 | //
 80 | // Globals
 81 | //
 82 | typedef void(*StateFunc)();
 83 | 
 84 |     // Current state function pointer
 85 | StateFunc       DCC_Decoder::gState;                   // Current state function pointer
 86 | 
 87 |     // Timing data from last interrupt
 88 | unsigned int    DCC_Decoder::gLastChaos;                  // Interrupt chaos count we processed
 89 | 
 90 |     // Preamble bit count
 91 | int             DCC_Decoder::gPreambleCount;              // Bit count for reading preamble
 92 | 
 93 |     // Reset reason 
 94 | byte            DCC_Decoder::gResetReason;                // Result code of last reason decoder was reset
 95 | boolean         DCC_Decoder::gHandledAsRawPacket;
 96 | 
 97 |     // Packet data
 98 | byte            DCC_Decoder::gPacket[kPACKET_LEN_MAX];    // The packet data.
 99 | byte            DCC_Decoder::gPacketIndex;                // Byte index to write to.
100 | byte            DCC_Decoder::gPacketMask;                 // Bit index to write to. 0x80,0x40,0x20,...0x01
101 | boolean         DCC_Decoder::gPacketEndedWith1;           // Set true if packet ended on 1. Spec requires that the 
102 |                                                           // packet end bit can count as a bit in next preamble. 
103 |     // CV Storage
104 | byte            DCC_Decoder::gCV[kCV_MAX];                // CV Storage (TODO - Move to PROGMEM)
105 | 
106 |     // Packet arrival timing
107 | unsigned long   DCC_Decoder::gThisPacketMS;               // Milliseconds of this packet being parsed
108 | boolean         DCC_Decoder::gLastPacketToThisAddress;    // Was last pack processed to this decoder's address?
109 | 
110 | unsigned long   DCC_Decoder::gLastValidPacketMS;          // Milliseconds of last valid packet
111 | unsigned long   DCC_Decoder::gLastValidPacketToAddressMS; // Milliseconds of last valid packet to this decoder
112 | unsigned long   DCC_Decoder::gLastValidIdlePacketMS;      // Milliseconds of last valid idle packet
113 | unsigned long   DCC_Decoder::gLastValidResetPacketMS;     // Milliseconds of last valid reset packet
114 | 
115 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
116 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
117 | //
118 | // Packet Timing Support
119 | //
120 | unsigned long DCC_Decoder::MillisecondsSinceLastValidPacket()
121 | {
122 |     return millis() - gLastValidPacketMS;
123 | }
124 | 
125 | unsigned long DCC_Decoder::MillisecondsSinceLastPacketToThisDecoder()
126 | {
127 |     return millis() - gLastValidPacketToAddressMS;
128 | }
129 | 
130 | unsigned long DCC_Decoder::MillisecondsSinceLastIdlePacket()
131 | {
132 |     return millis() - gLastValidIdlePacketMS;
133 | }
134 | 
135 | unsigned long DCC_Decoder::MillisecondsSinceLastResetPacket()
136 | {
137 |     return millis() - gLastValidResetPacketMS;
138 | }
139 | 
140 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
141 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
142 | //
143 | // CV Support
144 | //
145 | byte DCC_Decoder::ReadCV(int cv)
146 | {
147 |     if( cv>=kCV_PrimaryAddress && cv<kCV_MAX )
148 |     {
149 |         return gCV[cv];
150 |     }
151 |     return -1;        
152 | }
153 | 
154 | void DCC_Decoder::WriteCV(int cv, byte data)
155 | {
156 |     if( cv>=kCV_PrimaryAddress && cv<kCV_MAX && cv!=kCV_ManufacturerVersionNo && cv!=kCV_ManufacturerVersionNo )
157 |     {
158 |         gCV[cv] = data;
159 |     }
160 | }
161 | 
162 | int DCC_Decoder::Address()
163 | {
164 |     int address;
165 | 
166 |     byte cv29 = DCC_Decoder::ReadCV(kCV_ConfigurationData1);
167 | 
168 |     if( cv29 & 0x80 )   // Is this an accessory decoder?
169 |     {
170 |         address = DCC_Decoder::ReadCV(kCV_AddressMSB)<<6 | DCC_Decoder::ReadCV(kCV_AddressMSB);        
171 |     }else{
172 |         if( cv29 & 0x20 )   // Multifunction using extended addresses?
173 |         {
174 |             address = DCC_Decoder::ReadCV(kCV_ExtendedAddress1)<<8 | DCC_Decoder::ReadCV(kCV_ExtendedAddress2);        
175 |         }else{
176 |             address = DCC_Decoder::ReadCV(kCV_PrimaryAddress);
177 |         }
178 |     }
179 | 
180 |     return address;
181 | }
182 | 
183 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
184 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
185 | //
186 | // Handlers
187 | //
188 | BaselineControlPacket DCC_Decoder::func_BaselineControlPacket = NULL;
189 | boolean               DCC_Decoder::func_BaselineControlPacket_All_Packets = false;
190 | 
191 | void DCC_Decoder::SetBaselineControlPacketHandler(BaselineControlPacket func, boolean allPackets)
192 | {
193 |     func_BaselineControlPacket = func;
194 |     func_BaselineControlPacket_All_Packets = allPackets;
195 | }
196 | 
197 | //////////////////////////////////////////////////////////////
198 | 
199 | RawPacket DCC_Decoder::func_RawPacket = NULL;
200 | 
201 | void DCC_Decoder::SetRawPacketHandler(RawPacket func)
202 | {
203 |     func_RawPacket = func;
204 | }
205 | 
206 | //////////////////////////////////////////////////////////////
207 | 
208 | BasicAccDecoderPacket DCC_Decoder::func_BasicAccPacket = NULL;
209 | boolean               DCC_Decoder::func_BasicAccPacket_All_Packets = false;
210 | 
211 | void DCC_Decoder::SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket func, boolean allPackets)
212 | {
213 |     func_BasicAccPacket = func;
214 |     func_BasicAccPacket_All_Packets = allPackets;
215 | }
216 | 
217 | //////////////////////////////////////////////////////////////
218 | 
219 | ExtendedAccDecoderPacket DCC_Decoder::func_ExtdAccPacket = NULL;
220 | boolean                  DCC_Decoder::func_ExtdAccPacket_All_Packets = false;
221 | 
222 | void DCC_Decoder::SetExtendedAccessoryDecoderPacketHandler(ExtendedAccDecoderPacket func, boolean allPackets)
223 | {
224 |     func_ExtdAccPacket = func;
225 |     func_ExtdAccPacket_All_Packets = allPackets;
226 | }
227 | 
228 | //////////////////////////////////////////////////////////////
229 | 
230 | IdleResetPacket DCC_Decoder::func_IdlePacket = NULL;
231 | 
232 | void DCC_Decoder::SetIdlePacketHandler(IdleResetPacket func)
233 | {
234 |     func_IdlePacket = func;
235 | }
236 | 
237 | //////////////////////////////////////////////////////////////
238 | 
239 | IdleResetPacket DCC_Decoder::func_ResetPacket = NULL;
240 | 
241 | void DCC_Decoder::SetResetPacketHandler(IdleResetPacket func)
242 | {
243 |     func_ResetPacket = func;
244 | }
245 | 
246 | //////////////////////////////////////////////////////////////
247 | 
248 | DecodingEngineCompletion DCC_Decoder::func_DecodingEngineCompletion = NULL;
249 | 
250 | void DCC_Decoder::SetDecodingEngineCompletionStatusHandler(DecodingEngineCompletion func)
251 | {
252 |     func_DecodingEngineCompletion = func;
253 | }
254 | 
255 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
256 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
257 | //
258 | // State Change Macros
259 | //
260 | #define GOTO_DecoderReset(reason) { gState = DCC_Decoder::State_Reset; gResetReason = reason; return; }
261 | #define GOTO_ExecutePacket()      { gState = DCC_Decoder::State_Execute; return; }
262 | #define GOTO_ReadPacketState()    { gState = DCC_Decoder::State_ReadPacket; return; }
263 | #define GOTO_PreambleState()      { gState = DCC_Decoder::State_ReadPreamble; return; }
264 | 
265 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
266 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
267 | //
268 | // Execute packet
269 | //
270 | void DCC_Decoder::State_Execute()
271 | {
272 |     int address;
273 |     
274 |         ///////////////////////////////////////////////////////////
275 |         // Test error dectection
276 |     byte errorDectection = gPacket[0] ^ gPacket[1];
277 |     if( gPacketIndex > 3 ) errorDectection ^= gPacket[2];
278 |     if( gPacketIndex > 4 ) errorDectection ^= gPacket[3];
279 |     if( gPacketIndex > 5 ) errorDectection ^= gPacket[4];
280 |     if( errorDectection != gPacket[gPacketIndex-1] )
281 |     {
282 |         GOTO_DecoderReset( kDCC_ERR_DETECTION_FAILED );
283 |     }
284 |     
285 |         // Save off milliseconds of this valid packet
286 |     gThisPacketMS = millis();
287 |     gLastPacketToThisAddress = false;
288 |     
289 |         ///////////////////////////////////////////////////////////
290 |         // Dispatch to RawPacketHandler - All packets go to raw (except idle and reset above)
291 |         // 
292 |         // gHandledAsRawPacket cleared in Reset. If packet is handled here this flag avoids
293 |         // sending to another dispatch routine. We don't just return here because we need to 
294 |         // figure out packet type and update time fields.
295 |     if( func_RawPacket )
296 |     {
297 |         gHandledAsRawPacket = (func_RawPacket)(gPacketIndex,gPacket);
298 |     }
299 | 
300 |         ///////////////////////////////////////////////////////////
301 |         ///////////////////////////////////////////////////////////
302 |         // Handle 3 byte packets
303 |     if( gPacketIndex == 3 )
304 |     {
305 |             ///////////////////////////////////////////////////////////
306 |             // Decoder idle & reset packets as defined in 9.2.
307 |         if( gPacket[1]==0x00 )
308 |         {
309 |                 // Broadcast idle packet
310 |             if( gPacket[0]==0xFF ) 
311 |             {
312 |                 if( !gHandledAsRawPacket && func_IdlePacket )
313 |                 {
314 |                     (func_IdlePacket)(gPacketIndex,gPacket);
315 |                 }
316 |                 GOTO_DecoderReset( kDCC_OK_IDLE );
317 |             }else{
318 |                 // Broadcast reset packet
319 |                 if( gPacket[0]==0x00 )
320 |                 {
321 |                     if( !gHandledAsRawPacket && func_ResetPacket )
322 |                     {
323 |                         (func_ResetPacket)(gPacketIndex,gPacket);
324 |                     }
325 |                     GOTO_DecoderReset( kDCC_OK_RESET );
326 |                 }
327 |             }
328 |         }
329 |         
330 |             ///////////////////////////////////////////////////////////
331 |             // Handle as a basic accessory decoder packet
332 |         if( ((gPacket[0] & 0xC0) == 0x80)  &&  ((gPacket[1] & 0x80) == 0x80) )
333 |         {
334 |             address = ~gPacket[1] & 0x70;
335 |             address = (address<<2) + (gPacket[0] & 0x3F);
336 |             gLastPacketToThisAddress = (address==DCC.Address());
337 |             if( gLastPacketToThisAddress || address == 0x003F || func_BasicAccPacket_All_Packets )    // 0x003F is broadcast packet
338 |             {
339 |                 if( !gHandledAsRawPacket && func_BasicAccPacket )
340 |                 {
341 |                         // Call BasicAccHandler           Activate bit                         data bits
342 |                     (func_BasicAccPacket)( address, ((gPacket[1] & 0x08) ? true : false), (gPacket[1] & 0x07));
343 |                 }
344 |             }
345 |             GOTO_DecoderReset( kDCC_OK_BASIC_ACCESSORY );
346 |         }
347 |             
348 |             ///////////////////////////////////////////////////////////
349 |             // Handle as a baseline packet
350 |        
351 |             // What decoder is this addressed to?
352 |         if( gPacket[0] & 0x80 )
353 |         {
354 |             GOTO_DecoderReset( kDCC_ERR_BASELINE_ADDR );
355 |         }
356 |         
357 |             // Baseline instruction packet?
358 |         if( (gPacket[1] & 0xC0) != 0x40 )
359 |         {
360 |             GOTO_DecoderReset( kDCC_ERR_BASELINE_INSTR );
361 |         }
362 |         
363 |         // bits as defined in 9.2
364 |         byte addressByte =  gPacket[0] & 0x7F;
365 |         byte directionBit = gPacket[1] & 0x20;
366 |         byte cBit =         gPacket[1] & 0x10;
367 |         byte speedBits =    gPacket[1] & 0x0F;
368 |         
369 |         // Stop or estop??
370 |         if( speedBits==0 )
371 |         {
372 |             speedBits = kDCC_STOP_SPEED;    
373 |         }else{
374 |             if( speedBits== 1 )
375 |             {
376 |                 speedBits = kDCC_ESTOP_SPEED;
377 |             }else{            
378 |                 if( gCV[kCV_ConfigurationData1] & 0x02 )  // Bit 1 of CV29: 0=14speeds, 1=28Speeds
379 |                 {
380 |                     speedBits = ((speedBits << 1 ) & (cBit ? 1 : 0)) - 3;   // speedBits = 1..28
381 |                 }else{
382 |                     speedBits -= 1;                                         // speedBits = 1..14
383 |                 }
384 |             }
385 |         }
386 |     
387 |             // Make callback
388 |         gLastPacketToThisAddress = (addressByte==DCC.ReadCV(kCV_PrimaryAddress));
389 |         if( func_BaselineControlPacket_All_Packets || gLastPacketToThisAddress )
390 |         {
391 |             if( !gHandledAsRawPacket && func_BaselineControlPacket )
392 |             {
393 |                 (*func_BaselineControlPacket)(addressByte,speedBits,directionBit);
394 |             }
395 |         }
396 |         GOTO_DecoderReset( kDCC_OK_BASELINE );      
397 |     }
398 |     
399 |         ///////////////////////////////////////////////////////////
400 |         ///////////////////////////////////////////////////////////
401 |         // Handle 4 byte packets
402 |     if( gPacketIndex == 4 )
403 |     {
404 |             ///////////////////////////////////////////////////////////
405 |             // Handle as a extd accessory decoder packet  (4 bytes)
406 |         if( ((gPacket[0] & 0xC0) == 0x80)  &&  ((gPacket[1] & 0x85) == 0x01) )
407 |         {
408 |             int msb = (gPacket[1] & 0x06);            
409 |             address = (gPacket[1] & 0x70);
410 |             address = (msb<<8) + (address<<2) + (gPacket[0] & 0x3F);
411 |             gLastPacketToThisAddress = (address==DCC.Address());
412 |             if( gLastPacketToThisAddress || address == 0x033F || func_ExtdAccPacket_All_Packets )    // 0x033F is broadcast packet
413 |             {
414 |                 if( !gHandledAsRawPacket && func_ExtdAccPacket )
415 |                 {
416 |                         // Call ExtAccHandler             data bits
417 |                     (*func_ExtdAccPacket)( address, gPacket[2] & 0x1F);
418 |                 }
419 |             }
420 |             GOTO_DecoderReset( kDCC_OK_EXTENDED_ACCESSORY );
421 |         }
422 |     }
423 |     
424 |         ///////////////////////////////////////////////////////////
425 |         ///////////////////////////////////////////////////////////
426 |         // Handle 5 byte packets
427 |     if( gPacketIndex == 5  )
428 |     {
429 |         // TODO - Implement
430 |     }          
431 |         
432 |         ///////////////////////////////////////////////////////////
433 |         ///////////////////////////////////////////////////////////
434 |         // Handle 6 byte packets
435 |     if( gPacketIndex == 6 )
436 |     {
437 |         // TODO - Implement
438 |     }    
439 |     
440 |         ///////////////////////////////////////////////////////////
441 |         // Done!
442 |     GOTO_DecoderReset( kDCC_OK );
443 | }
444 | 
445 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
446 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
447 | //
448 | // Standard interrupt reader - If a complete bit has been read it places timing in periodA & periodB and flows out bottom.
449 | //
450 | #define StandardInterruptHeader(behalfOf)                                   \
451 |             noInterrupts();                                                 \
452 |             if( gInterruptChaos == gLastChaos )                             \
453 |             {                                                               \
454 |                 interrupts();                                               \
455 |                 return;                                                     \
456 |             }                                                               \
457 |             if( gInterruptChaos-gLastChaos > 1 )                            \
458 |             {                                                               \
459 |                 interrupts();                                               \
460 |                 GOTO_DecoderReset( kDCC_ERR_MISSED_BITS );                  \
461 |             }                                                               \
462 |             unsigned int periodA = gInterruptTime[0];                       \
463 |             unsigned int periodB = gInterruptTime[1];                       \
464 |             gLastChaos = gInterruptChaos;                                   \
465 |             interrupts();                                                   \
466 |             boolean aIs1 = ( periodA >= kONE_Min && periodA <= kONE_Max );  \
467 |             if( !aIs1 && (periodA < kZERO_Min || periodA > kZERO_Max) )     \
468 |             {                                                               \
469 |                 GOTO_DecoderReset( kDCC_ERR_NOT_0_OR_1 );                   \
470 |             }                                                               \
471 |             boolean bIs1 = ( periodB >= kONE_Min && periodB <= kONE_Max );  \
472 |             if( !bIs1 && (periodB < kZERO_Min || periodB > kZERO_Max) )     \
473 |             {                                                               \
474 |                 GOTO_DecoderReset( kDCC_ERR_NOT_0_OR_1 );                   \
475 |             }                                                               \
476 | 
477 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
478 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
479 | //
480 | // Read packet bytes
481 | //
482 | void DCC_Decoder::State_ReadPacket()
483 | {
484 |     // Interrupt header
485 |     StandardInterruptHeader();
486 |     
487 |     // Normally the two halves match. If not, reset
488 |     if( aIs1 == bIs1 )
489 |     {
490 |         // 8 out of 9 times through we'll have a mask and be writing bits
491 |         if( gPacketMask )
492 |         {
493 |             // Write the bit.
494 |             if( aIs1 )
495 |             {
496 |                 gPacket[gPacketIndex] |= gPacketMask;
497 |             }
498 |             // advance the bit mask
499 |             gPacketMask = gPacketMask >> 1;
500 |             
501 |         }else{        
502 |             // Getting here is the 9th time and the it's the data start bit between bytes. 
503 |             // Zero indicates more data, 1 indicates end of packet
504 |             
505 |             // Advance index and reset mask
506 |             gPacketIndex++;
507 |             gPacketMask = 0x80;
508 |             
509 |             // Data start bit is a 1, that's the end of packet! Execute.
510 |             if( aIs1 )
511 |             {
512 |                 gPacketEndedWith1 = true;
513 |                 if( gPacketIndex>=kPACKET_LEN_MIN && gPacketIndex<=kPACKET_LEN_MAX )
514 |                 {
515 |                     GOTO_ExecutePacket();
516 |                 }
517 |                 GOTO_DecoderReset( kDCC_ERR_INVALID_LENGTH );
518 |             }else{
519 |                 // Data start bit is a 0. Do we have room for more data?
520 |                 if( gPacketIndex >= kPACKET_LEN_MAX )
521 |                 {
522 |                     GOTO_DecoderReset( kDCC_ERR_MISSING_END_BIT );
523 |                 }
524 |             }
525 |         }
526 |     }else{
527 |         GOTO_DecoderReset( kDCC_ERR_NOT_0_OR_1 );
528 |     }
529 | }
530 | 
531 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
532 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
533 | //
534 | // Watch for Preamble
535 | //
536 | void DCC_Decoder::State_ReadPreamble()
537 | {     
538 |     // Interrupt header
539 |     StandardInterruptHeader();
540 |     
541 |     // If we get here, booleans aIs1 and bIs1 are set to the two halves of the next bit.
542 |     
543 |     // If both are 1, it's a 1 bit.
544 |     if( aIs1 && bIs1 )
545 |     {
546 |         // Increment preamble bit count
547 |         ++gPreambleCount;
548 |     }else{
549 |         // If they equal it's a 0.
550 |         if( aIs1 == bIs1 )
551 |         {    
552 |             if( gPreambleCount >= kPREAMBLE_MIN )
553 |             { 
554 |                 // BANG! Read preamble plus trailing 0. Go read the packet.
555 |                 GOTO_ReadPacketState();
556 |             }
557 |         }else{
558 |             // One is 0 the other 1. Shift alignment.
559 |             ShiftInterruptAlignment();  
560 |         }
561 |         // Not enough bits in preamble or shifted alignment. Start over at zero preamble.
562 |         gPreambleCount = 0;
563 |     }  
564 | }
565 | 
566 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
567 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
568 | //
569 | // Reset handling (Part 2)
570 | //
571 | void DCC_Decoder::State_Reset()
572 | {    
573 |         // EngineReset Handler  (Debugging)
574 |     if( func_DecodingEngineCompletion )
575 |     {
576 |         (func_DecodingEngineCompletion)(gHandledAsRawPacket ? kDCC_OK_MAX : gResetReason);
577 |     }
578 |     gHandledAsRawPacket = false;
579 |     
580 |         // If reset with an OK code, this was a valid packet. Save off times
581 |     if( gResetReason < kDCC_OK_MAX )
582 |     {
583 |         // Save MS of last valid packet
584 |         gLastValidPacketMS = gThisPacketMS;
585 |         
586 |         // Save off other times
587 |         switch( gResetReason )
588 |         {
589 |             case kDCC_OK_IDLE:
590 |                 gLastValidIdlePacketMS = gThisPacketMS;
591 |                 break;
592 |             case kDCC_OK_RESET:
593 |                 gLastValidResetPacketMS = gThisPacketMS;
594 |                 break;
595 |             case kDCC_OK_BASELINE:
596 |             case kDCC_OK_BASIC_ACCESSORY:
597 |             case kDCC_OK_EXTENDED_ACCESSORY:
598 |                 if(gLastPacketToThisAddress)
599 |                 {
600 |                     gLastValidPacketToAddressMS = gThisPacketMS;
601 |                 }
602 |                 break;
603 |             default:
604 |                 break;
605 |         }
606 |     }
607 |     
608 |         // Reset packet data
609 |     gPacket[0] = gPacket[1] = gPacket[2] = gPacket[3] = gPacket[4] = gPacket[5] = 0;
610 |     gPacketIndex = 0;
611 |     gPacketMask = 0x80;
612 |     
613 |         // Copy last time and reset chaos
614 |     noInterrupts();
615 |     gPreambleCount = (gPacketEndedWith1 && gLastChaos==gInterruptChaos) ? 1 : 0;
616 |     gLastChaos = gInterruptChaos = 0;
617 |     interrupts();
618 |     
619 |         // Clear packet ended 1 flag
620 |     gPacketEndedWith1 = false;
621 |     
622 |         // Go find preamble 
623 |     GOTO_PreambleState();
624 | }
625 | 
626 | void DCC_Decoder::State_Boot()
627 | {   
628 | }
629 | 
630 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
631 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
632 | //
633 | // SetupDecoder
634 | //
635 | void DCC_Decoder::SetupDecoder(byte mfgID, byte mfgVers, byte interrupt)  
636 | {
637 |     if( gInterruptMicros == 0 )
638 |     {        
639 |             // Save mfg info
640 |         gCV[kCV_ManufacturerVersionNo] = mfgID;
641 |         gCV[kCV_ManufacturedID] = mfgVers;
642 |         
643 |             // Attach the DCC interrupt
644 |         StartInterrupt(interrupt);
645 |     
646 |             // Start decoder in reset state
647 |         GOTO_DecoderReset( kDCC_OK_BOOT );
648 |     }
649 | }
650 | 
651 | void DCC_Decoder::SetupMonitor(byte interrupt)
652 | {
653 |     if( gInterruptMicros == 0 )
654 |     {        
655 |             // Attach the DCC interrupt
656 |         StartInterrupt(interrupt);
657 |         
658 |             // Start decoder in reset state
659 |         GOTO_DecoderReset( kDCC_OK_BOOT );    
660 |     }
661 | }
662 | 
663 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
664 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
665 | //
666 | // Hearbeat function. Dispatch the dcc_decoder library state machine.
667 | //
668 | void DCC_Decoder::loop()
669 | {
670 |     (gState)();
671 | }
672 | 
673 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
674 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
675 | //
676 | // Constructor (Not really).
677 | //
678 | DCC_Decoder::DCC_Decoder() 
679 | {
680 |     gState = DCC_Decoder::State_Boot;
681 | }
682 | 
683 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
684 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
685 | //
686 | // Human readable error strings
687 | //
688 | 
689 | const char PROGMEM*
690 | DCC_Decoder::ResultString(byte resultCode)
691 | {
692 |     static const char PROGMEM* const gResults[] =
693 |     {
694 |         "OK",
695 |         "OK - Unhandled",
696 |         "OK - Boot",
697 |         "OK - Idle packet",
698 |         "OK - Reset packet",
699 |         "OK - Handled raw",
700 |         "OK - Handled baseline",
701 |         "OK - Handled basic accessory",
702 |         "OK - Handled extended accessory",
703 |     };
704 | 
705 |     static const char PROGMEM* const gErrors[] =
706 |     {
707 |         "ERROR - Detection failed",
708 |         "ERROR - Baseline address",
709 |         "ERROR - Baseline instruction",
710 |         "ERROR - Missed bits",
711 |         "ERROR - Not 0 or 1",
712 |         "ERROR - Invalid packet length",
713 |         "ERROR - Missing packet end bits",
714 |     };
715 | 
716 |     static const char PROGMEM* const gErrorsBadCode = "ERROR - Bad result code";
717 | 
718 |     if( resultCode>=0 && resultCode<(sizeof(gResults)/sizeof(gResults[0])) )
719 |     {
720 |         return gResults[resultCode];
721 |     }
722 |     if( resultCode>=100 && (resultCode-100)<(byte)(sizeof(gErrors)/sizeof(gErrors[0])) )
723 |     {
724 |         return gErrors[resultCode-100];
725 |     }
726 |     return gErrorsBadCode;
727 | }
728 | 
729 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
730 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
731 | //
732 | // Helper to make packet strings
733 | //
734 | char* DCC_Decoder::MakePacketString(char* buffer60Bytes, byte byteCount, byte* packet)
735 | {
736 |     buffer60Bytes[0] = 0;
737 |     if( byteCount>=kPACKET_LEN_MIN && byteCount<=kPACKET_LEN_MAX )
738 |     {
739 |         int i = 0;
740 |         for(byte byt=0; byt<byteCount; ++byt)
741 |         {
742 |             byte bit=0x80;
743 |             while(bit)
744 |             {
745 |                 buffer60Bytes[i++] = (packet[byt] & bit) ? '1' : '0';
746 |                 bit=bit>>1;
747 |             }
748 |             buffer60Bytes[i++] = ' ';
749 |         }
750 |         buffer60Bytes[--i] = 0;
751 |     }
752 |     return buffer60Bytes;
753 | }
754 | 
755 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
756 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
757 | //
758 | // Helper to return preamble length
759 | //
760 | int DCC_Decoder::LastPreambleBitCount()
761 | {
762 |     return gPreambleCount;
763 | }
764 | 
765 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
766 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
767 | 


--------------------------------------------------------------------------------