NCE Bus Interface Development

NCE_Bus_Interface: Code Development.

This page illustrates the development of the Class/Library NCE_Bus_Interface.

The code is developed using the private variable "_debug" that will be initialized using the begin() method.
(i) With no parameter of begin(0) the program will execute continuously with the minimum of debug messages. That is minimum number of Serial.print( ) statements.
(ii) With a valid parameter the program will either display debug messages or halt at at specified statement in the code to enable the debug messages to be annualized.

A high level diagram of the system is shown below. The NCE Twin Controller generates DCC signals that will control model trains and accessories.

The NCE Twin also has a RS485 connection designed to interface with other NCE devices. This project will duplicate another NCE device on the bus commonly known as a CAB or throttle.

The NCE Twin

The front and rear views of the NCE Twin controller used in this project. Note the Twin is only a light version of the professional NCE Controllers.

The NCE Controller Operation

The basic operation of the NCE Controller is illustrated below. In the case of the NCE Twin it pings the addresses 80 through 8A excluding 81 in turn. If there is a device at that address it should acknowledge the ping or send a request for service

Note originally this project was developed for address 85. When tested on a larger layout address 85 was used so the project was changed to address 86. This diagram has not been changed.

The NCE Bus Waveforms

The NCE Bus Activity is given below.

The NCE_Bus_Interface class will monitor the activity and when my_address occurs (Initially 85 but later changed to 86) it will acknowledge to say "I'm Here" or to make a request. (The example used in this project is a macro)

Code Development: The Code Development Steps

For educational purposes this project is developed in a number of steps defined by the begin(x) method. Depending upon x the program will send messages to the Serial monitor or may even halt to verify the program reached that point.

begin(1) or _debug ==1: Probing the NCE Bus

This is the initial code and will basically probe what is happening on the NCE_Bus (RS485).

//NCE_Bus_Interface.h Header File

The notable features of the header file are
(i) the inclusion of the SoftwareSerial library that will be part of the interface to the NCE RS485 bus.
(ii) the declaration of the class NCE_Bus_Interface (uint8_t my_address ) that has a parameter the bus address. This page will assume address 6,
(iii) Two begin methods that will perform any initialization. With a parameter debugging options will be included.
(iv) The program loop that continuously reads the NCE bus until my_address

#ifndef NCE_Bus_Interface_H#define NCE_Bus_Interface_H#include "Arduino.h"
#include <SoftwareSerial.h> //Included SoftwareSerial Library
class NCE_Bus_Interface { public: NCE_Bus_Interface (uint8_t my_address ); void begin( ); void begin(uint8_t); void do_my_address(); private: uint8_t _my_address; uint8_t _debug; };#endif

//NCE_Bus_Interface,cpp Implementaion File

Features of the implementation code include(i) Creating a SoftwareSerial object RS485 associated with the microcontroller pins 11 and 12
(ii) Defining the NCE_Bus_Interface constructor that assigns the parameter to the private variable _my_address.For this project my_address will be 0x86
(iii) Define the two begin( ) methods where the first has no parameters and simply initiates the RS485 operation while the second assigns the private variable _debug.
(iv) Codes the method do_my_address( ). This basically reads the RS485 bus but if the _debug variable is set it displays the results.
#include "NCE_Bus_Interface.h"
SoftwareSerial RS485(12,11); //Rx Tx
NCE_Bus_Interface :: NCE_Bus_Interface ( uint8_t my_address)       {_my_address = 0x80+my_address; };
uint8_t rxByte;
void NCE_Bus_Interface::begin ( ){  RS485.begin(9600);  }void NCE_Bus_Interface::begin (uint8_t a ){     _debug = a;     begin();}
void NCE_Bus_Interface::do_my_address( ) {  if (RS485.available( ))       {            rxByte = RS485.read();            if (_debug){                if (rxByte == 0x80) Serial.println(); //sync to broadcast                  if (rxByte < 16) Serial.print('0');                Serial.print(rxByte,HEX);                Serial.print(' ');            }       }}

NCE_Bus_Inteface.ino

The test of client code will(i) Creates a NCE_Bus_Interface object "bus" associated with address 6. Note constructor adds 0x80 so for this page the address becomes 0x86.
(ii) Initialises the bus object with parameter "1". That is debug mode
(iii) Continuously call the method do_my_ adddress that at this point simply reads (and displays) the NCE_Bus activity.

#include "NCE_Bus_Interface.h"
NCE_Bus_Interface bus(6);
void setup(){ Serial.begin(115200); Serial.println("\n-NCE Twin Probe-"); bus.begin(1);}void loop() { bus.do_my_address(); }

Trace for DEBUG==1

These results are for a NCE_Twin
11:58:37.300 -> 80 82 83 84 85 86 87 88 89 8A 11:58:37.347 -> 80 82 83 84 85 86 87 88 89 8A 11:58:37.347 -> 80 D4 0A 82 83 84 85 86 87 88 89 8A 11:58:37.394 -> 80 82 83 84 85 86 87 88 89 8A 11:58:37.441 -> 80 82 83 84 85 86 87 88 89 8A
11:58:40.331 -> 80 82 83 84 85 86 87 88 89 8A 11:58:40.378 -> 80 C1 E0 F0 F4 FA F5 F7 C1 CD 82 83 84 85 86 87 88 89 8A 11:58:40.425 -> 80 82 83 84 85 86 87 88 89 8A 11:58:40.472 -> 80 82 83 84 85 86 87 88 89 8A
Trace shows looping through every ping address - cycle time 47mS. Note there is no address0x81.Two broadcast messages/commands have been captured - these do not impact cycle time

The waveforms below illustrate a captured message.

begin(2) or _debug ==2: Adding a state machine

This step will introduce a 2 state flow chart
The only change in the *.ino or client code will be to specify the level of the debug.ie

bus.begin(2);

_debug == 2 Header File modifications.

The program will be testing for a ping address. The ping address can be in the range 0x60 through 0xBF For convenience while testing a statement BUS_PING is defined.

#define BUS_PING ((rxByte >= 0x80)&&(rxByte <0xC0))
A enumerator NCE_STATE is declared that contains the 4 possible states.ie
enum NCE_STATE {START,BROADCAST,ITS_ME,OTHER};

To specify the current state a private variable is declared as part of the class definition
private: ......... NCE_STATE BUS_STATE;

_debug == 2 Implmentation File modifications.

At start up everything will be in the state START. This should be included i the begin method. i.e.
void NCE_Bus_Interface::begin ( ) {  RS485.begin(9600);  BUS_STATE = START;}
For this step the method do_my_address is extensively modified to define the various states.
The implementation file now contains a switch statement where each state is tested.
The code includes a "do-while" that will loop until my_address is found void NCE_Bus_Interface::do_my_address( ) {  bool found =0;    do {      if (RS485.available( ))       {            rxByte = RS485.read();            .........           switch (BUS_STATE) {                      case START : if (rxByte==0x80)                                      {                                       BUS_STATE = BROADCAST;                                       } }                                 break;                                        case BROADCAST :                             BUS_STATE = OTHER; //does assume my_address != 0x82                                        break;                   case OTHER : if (rxByte==0x80)                                           {                                            BUS_STATE = BROADCAST; _BusPtr = 0;                                           }                                                                else if ( rxByte == _my_address)                                            {                                            BUS_STATE = ITS_ME; //                                         }                                                                                                   break;              case ITS_ME      :                                      BUS_STATE= OTHER; //does assume my_address != 0x8A                                     found = 1; //get out of loop                               // }                                       break;                                                       default : Serial.print("State-Unknown");                                } //switch                    }     while(!found);
  if (_debug==2) Serial.print('.');}
In the state START the code will loop until the BROADCAST Address is found.
In the BROADCASE the state will move to the OTHER state
In the OTHER state the received byte will be tested. If the received data is 0x80 it will return to the BROADCAST state where as if the data is my_address it will change to the ITS_ME state.
In the ITS_ME state the next state is declared as OTHER and a variable found is set.
The do-while loop will now exit. With _debug == 2 the serial monitor will print a full stop.

Trace for DEBUG==2

12:34:56.161 -> 80 82 83 84 85 86 87 .88 89 8A 12:34:56.207 -> 80 82 83 84 85 86 87 .88 89 8A 12:34:56.207 -> 80 82 83 84 85 86 87 .88 89 8A
The code as given will:
Wait for the address 0x85. In that state the next reading will be 0x86 or my_address.
In the state ITS_ME the found variable is set. But the next byte 0x87 is read before the exit.
Thus the trace reads 85 86 87 .88 where the full stop is after capturing the address 0x87.
The trace has painted a picture of the bus activity. Later code will need to be included in the state diagram at the appropriate places
----------------

begin(3) or _debug ==3: Detecting Broadcast Messages

The object here is to run until a broadcast message is detected. Note for _debug==1 and _debug = 2 he program will continue to run. For _debug == 3 the program will halt. That is in the BROADCAST state if anything that is not a ping address the program will halt

void NCE_Bus_Interface::do_my_address( ) { bool found =0; do { ..... switch (BUS_STATE) { case START : .... case BROADCAST : if ((rxByte & 0xf0)!= 0x80) { if (_debug ==3) { Serial.print(" BC-mess "); while(1); } } else BUS_STATE = OTHER; //does assume my_address != 0x82 break; case OTHER ..... case ITS_ME .... default : Serial.print("State-Unknown"); } //switch } ..... while(!found); if (_debug==2) Serial.print('.'); while(!found);}

Trace for debug == 3

16:18:45.702 -> 80 82 83 84 85 86 87 88 89 8A 16:18:45.749 -> 80 82 83 84 85 86 87 88 89 8A 16:18:45.796 -> 80 82 83 84 85 86 87 88 89 8A 16:18:45.843 -> 80 C1 BC-mess
The results are as before until in the BROADCAST state 0xC1 the statrt of a message is found.
The following steps will handle the broadcast messages.

=================

begin(4) or _debug ==4. Lenghts of Broadcast Messages

This small step will enhance the code to determine the lengths of the messages.
In the header file two new private variables will be declared. along with a method build_message().
private:             uint8_t _BusPtr;        uint8_t _bufflen;        void build_message( )

The method do_my_address() will now call a method build_message() to (start to) handle messages.
void NCE_Bus_Interface::do_my_address( ) {      ......                 case BROADCAST :                           if ((rxByte & 0xf0)!= 0x80) {                            if (_debug ==3) {                                 Serial.print(" BC-mess "); while(1);                              }                                 build_message( ); //should loop through until next ping                          }                          else                            BUS_STATE = OTHER; //does assume my_address != 0x82                                         break;              ....}
By observation of the traces in _debug== 2 it can be seen that there are two messages of length 2 or 9.
At this point the build_message( ) method will specify the length of the messages from the trace of _debug==1.
At this point the only messages received start with either 0xC1 or 0xD4. The tests are expanded to include other messages that will occur during later development of this code.
With _debug == 4 the code will print out a message and halt at the end of the build_message( ) method

void NCE_Bus_Interface:: build_message( ){     if (_BusPtr == 0) {    if ((rxByte >= 0xC0)&& (rxByte <= 0xC7)) _bufflen=9;     else if ((rxByte ==0xCE)||(rxByte==0xCF)) _bufflen= 1;       else _bufflen = 2;  }    if (_debug == 4){                  Serial.print("Build Message Length = ");                  Serial.print(_bufflen);                 while(1) ;          }  }

Trace for debug ==4

17:13:11.440 -> 80 82 83 84 85 86 87 88 89 8A 17:13:11.440 -> 80 82 83 84 85 86 87 88 89 8A 17:13:11.487 -> 80 D4 Build Message Length = 2
17:14:27.631 -> 80 82 83 84 85 86 87 88 89 8A 17:14:27.678 -> 80 82 83 84 85 86 87 88 89 8A 17:14:27.725 -> 80 C1 Build Message Length = 9
The trace has halted when the start of a (broadcast) message is received .

==========================================

begin(5) or _debug ==5: Decoding Messages

This step will decode the bus messages.
The class definition will be enhanced with a private array to store the message uint8_t _BusBuffer[10];and a method to convert the code used by NCE into standard ASCII uint8_t NCE_ASCII(uint8_t);

In the implementation file the build-message method places each received byte into a buffer and calls the routine NCE_ASCII() to translate the received data into standard ASCII.
For _debug == 5 the resultant message is displayed on the monitor and the program halted.
void NCE_Bus_Interface:: build_message( ){ ........ if (_bufflen==9) //an ASCII string _BusBuffer[_BusPtr] = NCE_ASCII(rxByte); //modified ASCII -don't modify first char else _BusBuffer[_BusPtr] = rxByte; //save new byte _BusPtr++; if ((_BusPtr == _bufflen)) { //message complete if (_debug==5) { Serial.print("\nMessage "); for (int i =0; i< _bufflen; i++){ if (_BusBuffer[i]<16) Serial.print('0'); Serial.print(_BusBuffer[i],HEX); Serial.print(' '); } while(1); } } } //NCE does not use straight ASCII code - this routine adjustsuint8_t NCE_Bus_Interface::NCE_ASCII(uint8_t rr){ if (rr & 0x20) return (rr & 0x3F); else return (rr & 0x7F);}

trace for _debug == 5

With the message starting with D4 nothing happens
17:40:01.617 -> 80 82 83 84 85 86 87 88 89 8A 17:40:01.664 -> 80 D4 0A 17:40:01.664 -> Message D4 0A
whereas the message starting with "C1" the result after translation is displayed. It is the NCE time. With an NCE controller this would be displayed on the top right half of the screen
17:42:37.114 -> 80 82 83 84 85 86 87 88 89 8A 17:42:37.114 -> 80 C1 E0 F0 F3 FA F5 F7 D0 CD 17:42:37.161 -> Message C1 20 30 33 3A 35 37 50 4D 03:57PM
==========================================

begin(6) or _debug ==6: Callback Operations

The NCE_Bus_Interface class will not use the NCE messages but will include the code to transfer the messages to the client if required.

_debug == 6 Header File Upgrade

In order to create a link between the library and the client code need to define a type (in the header file)
typedef void (*MessHandler)   (uint8_t _ping,uint8_t loc, uint8_t a, uint8_t b,uint8_t c,uint8_t d,uint8_t e, uint8_t f, uint8_t g, uint8_t h);
MessHandler has 10 parameters. The ping address that gives the source or destination of the message. _ping is defined below. Loc is the first byte of the message (0xC1) in previous examples and "a".."h" the remaining 8 bytes of the message. 20,30,33,3A,35,37,50 in the trace from the previous section that is the ASCII for space followed by 03:57PM.
To transfer the message from theNCE_Bus_Interface to the client need a public routine that client can call to setup link
......class NCE_Bus_Interface {     public: NCE_Bus_Interface (uint8_t my_address );       ......       void setMessHandler(MessHandler funcPtr);
There needs to be a private link of the type MessHandler that will do the actual transfer.
class NCE_Bus_Interface ...private:             ..        MessHandler MessHandlerFn;        uint8_t _ping;        The private variable _ping is also added.

_debug==6 Implementation File Upgrade

    The NCE_Bus_Interface includes a public routine that the client can call to assign where any messages can go, ie
void NCE_Bus_Interface::setMessHandler(MessHandler clientPtr){      MessHandlerFn = clientPtr;  }
There will now need to be a method that actually implements the transfer. This will be handle message and will be called from the build_message method.
void NCE_Bus_Interface:: build_message( ){     .............              handle_message( );             _BusPtr = 0;        }     void NCE_Bus_Interface::handle_message( ){    //This will be part of the Broadcast State and part of ItsMe state.  if (MessHandlerFn) //if client has not set up link this code is skipped        { MessHandlerFn(_ping, _BusBuffer[0],_BusBuffer[1],             _BusBuffer[2],_BusBuffer[3],_BusBuffer[4],             _BusBuffer[5],_BusBuffer[6], _BusBuffer[7],             _BusBuffer[8]);          }          if (_debug ==6){    Serial.print("Message transferred to client");    while(1);  }}   The function has 10 parameters. If the client has not set up the link this step will be bypassed.
The message also contains the _ping address. This will be done in the do_my_address( ) method.
void NCE_Bus_Interface::do_my_address( ) {  ........            if (BUS_PING) _ping = rxByte;            if (_debug ==1) return;           switch (BUS_STATE) { .........}   --------------------------------------

_debug == 6 Client Code

To receive the mesage the client code includes a method that receives all 10 parameters.
void NCE_Message(uint8_t ping, uint8_t loc, uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f, uint8_t g, uint8_t h) { if (loc==0xD2) return; Serial.println(); Serial.print("PingAddr = "); Serial.print(ping,HEX); Serial.print(" Mess: "); if ((loc >=0xc1)&&(loc<= 0xC4)){ Serial.print(char(a)); Serial.print(char(b)); Serial.print(char(c)); Serial.print(char(d)); Serial.print(char(e)); Serial.print(char(f)); Serial.print(char(g)); Serial.print(char(h)); } else { if (loc<16) Serial.print('0'); Serial.print(loc,HEX); Serial.print(" "); if (a<16) Serial.print('0'); Serial.print(a,HEX); } Serial.print("\n"); }
In this example all parameters are displayed on screen .
To let the class know there is a method ready to receive the messages the setup() routine sets up the link. ie
void setup(){ ...... bus.setMessHandler(&NCE_Message);} No other actions are required. When there is a new message it will be display on the monitor.

_debug == 6 Trace Results

(These results were obtained on a different layout but still show the transferred message
14:24:48.156 -> 80 81 82 83 8A 8B 7D 7F 8C 91 7D 7F 95 A7 AA 14:24:48.203 -> 80 C1 E0 F0 F2 FA F1 F4 D0 CD 114:24:48.250 -> PingAddr = 80 Mess: 02:14PM14:24:48.250 -> Message transferred to client

Broadcast Messages

At this point the project has captured the data from a NCE DCC Twin. The only messages are (i) at the broadcast address (0x80), and (ii) are a two-byte 0xD4 0x0A which is telling all controllers to turn on a green light (this will be ignored) and a 9-byte message where the first byte is 0xC1.
NCE controllers have a 2 x16 LCD display. The 0xC1 tells the controller to display the following 8 bytes starting at character 8 in the top row.

From the document NCE Cab bus protocol-2006.pdf lists other possible messages:

0xc7 print next 8 chars to 4th line right of LCD (addr = D8h)
0xc6 print next 8 chars to 4th line left of LCD (addr = D0h)
0xc5 print next 8 chars to 3rd line right of LCD (addr= 98h)
0xc4 print next 8 chars to 3rd line left of LCD (addr = 90h)
0xc3 print next 8 chars to 2nd line right of LCD (addr = C8h)
0xc2 print next 8 chars to 2nd line left of LCD (addr = C0h)
0xc1 print next 8 chars to 1st line right of LCD (addr = 88h) Note: this is where the clock prints
0xc0 print next 8 chars to 1st line left LCD (addr = 80h)

From another project the display shows how the message may be displayed on an LCD screen. The "C1" says the display starts in the top row column 8. There is a space and in this case 12:04AM

begin(7) or _debug ==7: Talking to the bus-

The previous sections considered the information read from the NCE_Bus. The remaining sections will look writing information to the bus.
This section includes in the begin( ) method code that waits until the NCE_Bus (RS485) is available and prints message to screen,
void NCE_Bus_Interface::begin ( ){ int count; RS485.begin(9600); BUS_STATE = START; if (_debug >= 7) while (!RS485.available( )) {if (count<50) //do not saturate screen with dots. {Serial.print("."); count++;}} Serial.println("\nRS485 Available");

_debug == 7 trace

A start up trace is shown. The "NCE Twin Probe" is part of the client code and will display regardless.The class then waits until the RS485 device (The NCE Controller) is available before continuingThe results will then synchronize with the broadcast address (0x80) as per the previous sections
4:38:49.765 -> 14:38:49.765 -> -NCE Twin Probe-14:38:49.765 -> .........................14:38:49.765 -> RS485 Available14:38:49.765 -> FC 91 7D 7F 95 A6 AA 14:38:49.796 -> 80 81 82 83 8A 8B 7D 7F 8C 91 7D 7F 95 A7 AA 14:38:49.842 -> 80 81 82 83 8A 8B 7D 7F 8C 91 7D 7F 95 A8 AA
==========================================================

begin(8) or _debug ==8. "I'm here"

The next job is to let the NCE_Bus controller know there is a client on the bus.
The begin method will wait for my address and then transmit two bytes 0x7E and 0x7F
if (_debug >= 7) while (!RS485.available( )) {if (count<50) //do not saturate screen with dots. {Serial.print("."); count++;}} Serial.println("\nRS485 Available"); if (_debug >=8){ do_my_address(); if (_debug ==8) {Serial.println("My address found");} Send2Bytes485(0x7E,0x7F); if (_debug ==8) { Serial.print("Send 7E-7F: "); while(1); }
The code must now include methods that write to the bus:
A delay of 200 microseconds is required. 100 will not work
void NCE_Bus_Interface::SendByteRS485(uint8_t mess){ delayMicroseconds(200); RS485.write(mess);}void NCE_Bus_Interface::Send2Bytes485(uint8_t m1,uint8_t m2) { delayMicroseconds(200); RS485.write(m1); RS485.write(m2);}
These new routines must be included in the class declaration
void Send2Bytes485(uint8_t m1,uint8_t m2); void SendByteRS485(uint8_t mess);

debug==8 trace

The trace illustrates that after detecting my address the message 7E/7F is sent20:27:08.362 -> 20:27:08.362 -> RS485 Available20:27:08.362 -> 83 84 85 86 87 88 89 8A 20:27:08.408 -> 80 82 83 84 85 86 87 My address found20:27:08.408 -> Send 7E-7F: =====================================

begin(9) or _debug ==9. What type of device are you?

The previous section has sent the message 7E/7F which tells the controller I have joined the bus.
The controller will then send the byte 0xD2 asking what type of terminal. The response is "a" for a dumb terminal (All I will do is issue requests not tell the NCE_Controller what to do)
if (_debug >=9 ){uint8_t rxByte = RS485.read(); if (rxByte == 0xD2) {SendByteRS485('a'); //dumb terminal Serial.println("\nResponse 'a' == Dumb terminal. ");} // else handle_message(rxByte); } if (_debug ==9) while(1); }

debug==9 trace

There will be two responses. One from a cold start.
Cold start20:42:04.980 -> -NCE Twin Probe-20:42:10.933 -> 20:42:10.933 -> RS485 Available20:42:10.933 -> 20:42:10.933 -> 80 82 83 84 85 86 87 20:42:10.980 -> Response 'a' == Dumb terminal.
From a hot start the controller will already know its a dumb terminal so willl not repeat the question
Hot start20:32:49.157 -> -NCE Twin Probe-20:32:49.157 -> 20:32:49.157 -> RS485 Available20:32:49.157 -> 87 88 89 8A 20:32:49.157 -> 80 82 83 84 85 86 87 =======================

begin(10) or _debug ==10. Messages to me.

The client (this project) needs to react with the controller (That is sent requests) . The timing will be important. If in the state OTHER and my address occurs the client must respond immediately. That is there must be a routine to handle_my_address.
case OTHER : if (rxByte==0x80) { BUS_STATE = BROADCAST; _BusPtr = 0; } else if ( rxByte == _my_address) { if (_debug==10) {Serial.print("Handle My Address"); while(1); } BUS_STATE = ITS_ME; // } break; case ITS_ME :

debug==10 trace

Note that the response follows immediately my address (0x86) occurs. It does no wit for the state ITS_ME
21:00:47.794 -> -NCE Twin Probe-21:00:47.794 -> 21:00:47.794 -> RS485 Available21:00:47.794 -> 83 84 85 86 87 88 89 8A 21:00:47.840 -> 80 82 83 84 85 86 Handle My Address
=====================================================

begin(11) or _debug ==11. I'm still here!

This section adds the response its_me_start() when my_addres is received.This method will need to be addd to the class declration.
case OTHER : if (rxByte==0x80)                                           {                                            BUS_STATE = BROADCAST; _BusPtr = 0;                                                                                    }                                                                else if ( rxByte == _my_address)                                       {
                                      its_me_start( );                                        if (_debug==10)                                      {Serial.print("Handle My Address");                                         while(1);                                        }                                         BUS_STATE = ITS_ME; //                                         }                                                                                                   break;              case ITS_ME :
The implementation for its_me_start() becomes
void NCE_Bus_Interface::its_me_start( ){ if (!_mess_count) { //send 7E 7F once            Send2Bytes485(0x7E,0x7F);              if (_debug)Serial.println("'7E' '7F'");            _mess_count++;                                          }            else                       {                Send2Bytes485(0x7D,0x7F);                if (_debug) Serial.print("'7D' '7F' ");                }      }
The code duplicates the code noted earlier where the first message from the client is 7E/7F.
The subsequent messages will be 0x7D and 0x7F that advises the controller that the client is still present.

debug==11 trace

The trace shows the 7D/7F bytes being sent after my_address (0x86) is received.
Note the trace has also captured a broadcast message
21:19:00.386 -> 80 82 83 84 85 86 '7D' '7F' D2 87 88 89 8A 21:19:00.433 -> 80 82 83 84 85 86 '7D' '7F' D2 87 88 89 8A 21:19:00.480 -> 80 C1 E0 F0 F6 FA F0 F1 C1 CD 21:19:00.480 -> PingAddr = 80 Mess: 06:01AM21:19:00.527 -> 82 83 84 85 86 '7D' '7F' D2 87 88 89 8A 21:19:00.527 -> 80 82 83 84 85 86 '7D' '7F' D2 87 88 89 8A

The waveforms below show the captured activity. The top channel is the received data and the lower channel the response or transmitted data. (ie 7D/7F)

begin(12) or _debug ==12: Messages for me

This section will illustrate capturing a message from the controller to the client.
The code is included in the ITS_ME state. If the received data is other than a ping address the program will halt after printing out the received byte
case ITS_ME : if (!BUS_PING){ if (_debug ==12) { Serial.print(" Not a ping "); Serial.print(rxByte,HEX); while (1); }

debug==12 trace

From reset following receipt of my_address (0x86) the client advises the controller that there is a new device on the bus (Message 7E/7F)The controller then responds immediately with the one-byte message 0xD2 requesting the type of terminal.

21:33:10.192 -> 21:33:10.192 -> -NCE Twin Probe-21:33:10.192 -> 21:33:10.192 -> RS485 Available21:33:10.192 -> 83 84 85 86 87 88 89 8A 21:33:10.192 -> 80 82 83 84 85 86 '7E' '7F'21:33:10.239 -> D2 Not a ping D2===================================

begin(13) or _debug ==13: Display my messages

This section looks at messages sent by the controller to my address.
This will require populating the method handle_me(), This method will need to be included in the class declaration.
case ITS_ME : if (!BUS_PING){ if (_debug ==12) { Serial.print(" Not a ping "); Serial.print(rxByte,HEX); while (1); } handle_me( ); //this will be messages } else { BUS_STATE= OTHER; //does assume my_address != 0x8A found = 1; //get out of loop } break;
Note above a variable found is set which will be tested to exit the loop.

The handle_me () method first checks for the Message 0xD2 and responds with the byte 'a" indicating a dumb terminal.
If the message is not D2 the build_message() routine is executed. This was developed earlier as part of broadcast messages. void NCE_Bus_Interface::handle_me( ){ if ((rxByte == 0xD2)&& (_BusPtr ==0)){ SendByteRS485('a'); //a dumb terminal _BusPtr = 0; //clear buffer _BusBuffer[0] = ' '; if (_debug>=13){ Serial.print("'a'"); } } else { build_message( ); } }

debug==13 trace

A full trace is shown below. The client tells the controller that it is present (7E/7F). Subsequent responses will be '7D' '7F'

The controller will then send the message CE 40 to my address. This will be a cursor command.

The controller then sends the messages LOCO:000, FWD:000 and -------. This is getting the client ready to set the loco number and speed/direction

17:18:43.261 -> RS485 Available17:18:43.261 -> 17:18:43.261 -> 80 82 83 84 85 86 '7E' '7F'17:18:43.308 -> DB E0 C0 C0 C0 87 17:18:43.308 -> Response 'a' == Dumb terminal. 17:18:43.308 -> 88 89 8A 17:18:43.308 -> 80 82 83 84 85 86 '7D' '7F' CE 17:18:43.355 -> PingAddr = 86 Mess: CE 4017:18:43.355 -> 87 88 89 8A 17:18:43.355 -> 80 82 83 84 85 86 '7D' '7F' C0 CC CF C3 FA E0 F0 F0 F0 17:18:43.402 -> PingAddr = 86 Mess: LOC: 00017:18:43.402 -> 87 88 89 8A 17:18:43.402 -> 80 82 83 84 85 86 '7D' '7F' C2 C6 D7 C4 FA E0 F0 F0 F0 17:18:43.449 -> PingAddr = 86 Mess: FWD: 00017:18:43.449 -> 87 88 89 8A 17:18:43.449 -> 80 D4 0A 17:18:43.449 -> PingAddr = 80 Mess: D4 0A17:18:43.449 -> 82 83 84 85 86 '7D' '7F' C3 E0 ED ED ED ED ED ED ED 17:18:43.496 -> PingAddr = 86 Mess: -------17:18:43.496 -> 87 88 89 8A 17:18:43.496 -> 80 C1 E0 F0 F9 FA F2 F8 C1 CD 17:18:43.496 -> PingAddr = 80 Mess: 09:28AM17:18:43.496 -> 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:18:43.543 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:18:43.589 -> 80 82 83 84 85 8
========================================================================

begin(14) or _debug ==14: Requesting a macro

This section looks at loading a macro request into the NCE_Bus_Interface Class.

An additional statement if (bus.free2send()) bus.setMacro(161); will be added to the client code

void loop( ) {
bus.do_my_address( );
if (bus.free2send() bus.setMacro(161);
}

The header file must include these two additional public methods bool free2send(); and void setMacro(int);

As part of sending data to the bus a sendBuffer will be necessary. A boolean variable _sendbuffer_full will store the status of the buffer. The public method free2send() will send the status of the buffer. That is

bool NCE_Bus_Interface ::free2send(){

     return !(_sendbuffer_full);}
The setMacro( ) method will load the appropriatevalues into the _sendBuffer[]. That is // Code to handle a macro request.
void NCE_Bus_Interface:: setMacro(uint8_t mac){     _sendBuffer[0] = 0x5C;  _sendBuffer[1] = 0x50+ mac/100; mac %= 100;  _sendBuffer[2] = 0x50+ mac/10; mac %= 10;  _sendBuffer[3] = 0x50+ mac;     _sendBuffer[4] = 0x40;  _sendBufferPtr = 0;  _sendBufferSize = 5;
if (_debug == 14) {Serial.print(" Set Macro "); for (int i = 0; i<5 ; i++) {    Serial.print(_sendBuffer[i],HEX);    Serial.print(' ');   }    Serial.println();   }

debug==14 trace

The resultant trace from start up is as before. The NCE Controller first asks for type of terminal and then sends out messages to disable the cursor followed by a message indicating LOC: 000. (See previous section),

In-between is the message Request Macro 161: Set Macro 5C 51 56 51 40 that indicate the data has been placed in the send buffer.

15:29:50.809 -> 8A 15:29:50.809 -> 80 82 83 84 85 86 '7E' '7F'15:29:50.856 -> DB E0 C0 C0 C0 87 15:29:50.856 -> Response 'a' == Dumb terminal. 15:29:50.856 -> 88 89 8A 15:29:50.856 -> 80 82 83 84 85 86 '7D' '7F' CE 15:29:50.903 -> PingAddr = 86 Mess: Disable cursor15:29:50.903 -> 87 15:29:50.903 -> Request Macro 161: Set Macro 5C 51 56 51 40 15:29:50.903 -> 88 89 8A 15:29:50.903 -> 80 82 83 84 85 86 '7D' '7F' C0 CC CF C3 FA E0 F0 F0 F0 15:29:50.981 -> PingAddr = 86 Mess: LOC: 00015:29:50.981 -> 87 88 89 8A =========================

begin(15) or _debug ==15: Sending the Macro Request.

When in the state OTHER when my address occurs except for the first time the response has been 7D/7F. On the first pass it is 7E/7F.
If there is something in the buffer (ie _sendbuffer_full) this takes precedence over the 7D/7F. ie Send2Bytes485(_sendBuffer[_sendBufferPtr],0x7F); For a macro the first pass will send 5C/7F the 0x5C being a macro request

if (!_mess_count) { //send 7E 7F once Send2Bytes485(0x7E,0x7F); if (_debug)Serial.println("'7E' '7F'"); _mess_count++; } else if (_sendbuffer_full) { //code for a macro if (_mess_count >SEND_DELAY){ if (_sendBufferPtr<5) { Send2Bytes485(_sendBuffer[_sendBufferPtr],0x7F); Serial.print(" Send "); Serial.println(_sendBuffer[_sendBufferPtr],HEX); _sendBufferPtr++; } _mess_count = 1; if (_sendBufferPtr ==_sendBufferSize){ _sendBufferPtr = 0; _sendbuffer_full =0; } } else { //not first response on start up and no requests in pipeline Send2Bytes485(0x7D,0x7F); if (_debug) Serial.print("'7D' '7F' "); _mess_count++; } } else { Send2Bytes485(0x7D,0x7F); if (_debug) Serial.print("'7D' '7F' "); } }
There are some complications with the code. The code must check when the buffer is empty. In addition it was found that sending the next byte of the buffer on the next cycle created problems. So a counter _mess_count was included to add a delay between each transfer. In practice the code will transfer the first byte of then macro request then send 7D/7F for SAVE_DELAY cycles.

debug==14 trace

17:33:37.119 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:33:37.166 -> 80 82 83 84 85 86 Send 5C17:33:37.213 -> CF 17:33:37.213 -> PingAddr = 86 Mess: Enable cursor 17:33:37.213 -> 17:33:37.213 -> 87 88 89 8A 17:33:37.213 -> 80 82 83 84 85 86 '7D' '7F' C0 CC CF C3 FA E0 F0 F0 F0 17:33:37.260 -> PingAddr = 86 Mess: LOC: 00017:33:37.260 -> 87 88 89 8A 17:33:37.260 -> 80 82 83 84 85 86 '7D' '7F' C2 CD C1 C3 D2 CF E0 CE D5 17:33:37.307 -> PingAddr = 86 Mess: MACRO NU17:33:37.307 -> 87 88 89 8A 17:33:37.307 -> 80 82 83 84 85 86 '7D' '7F' C3 CD C2 C5 D2 FA E0 E0 E0 17:33:37.354 -> PingAddr = 86 Mess: MBER:   17:33:37.354 -> 87 88 89 8A 17:33:37.354 -> 80 82 83 84 85 86 '7D' '7F' C8 CD 17:33:37.354 -> PingAddr = 86 Mess: Move cursor CD17:33:37.400 -> 17:33:37.400 -> 87 88 89 8A 17:33:37.400 -> 80 82 83 84 85 86 '7D' '7F' CF 17:33:37.400 -> PingAddr = 86 Mess: Enable cursor 17:33:37.400 -> 17:33:37.400 -> 87 88 89 8A 17:33:37.447 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A
...12 identical lines
17:33:37.963 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:33:38.010 -> 80 82 83 84 85 86 Send 5117:33:38.057 -> 87 88 89 8A 17:33:38.057 -> 80 82 83 84 85 86 '7D' '7F' C3 CD C2 C5 D2 FA E0 E0 E0 17:33:38.104 -> PingAddr = 86 Mess: MBER:   17:33:38.104 -> 87 88 89 8A 17:33:38.104 -> 80 82 83 84 85 86 '7D' '7F' C8 CD 17:33:38.104 -> PingAddr = 86 Mess: Move cursor CD17:33:38.151 -> 17:33:38.151 -> 87 88 89 8A 17:33:38.151 -> 80 82 83 84 85 86 '7D' '7F' CA F1 17:33:38.151 -> PingAddr = 86 Mess: Print Character F117:33:38.151 -> 17:33:38.151 -> 87 88 89 8A 17:33:38.197 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A
.......14 Identical lines
17:33:38.776 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:33:38.822 -> 80 C1 E0 F1 F2 FA F5 F5 C1 CD 17:33:38.822 -> PingAddr = 80 Mess: 12:55AM17:33:38.822 -> 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:33:38.869 -> 80 82 83 84 85 86 Send 5717:33:38.869 -> CA F7 17:33:38.869 -> PingAddr = 86 Mess: Print Character F717:33:38.869 -> 17:33:38.869 -> 87 88 89 8A 17:33:38.869 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A
....18 identical lines
7:33:39.619 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:33:39.666 -> 80 82 83 84 85 86 Send 5417:33:39.666 -> CA F4 17:33:39.666 -> PingAddr = 86 Mess: Print Character F417:33:39.713 -> 17:33:39.713 -> 87 88 89 8A 17:33:39.713 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A
....18 identical lines
17:33:40.416 -> 80 82 83 84 85 86 '7D' '7F' 87 88 89 8A 17:33:40.463 -> 80 82 83 84 85 86 Send 4017:33:40.510 -> CE 17:33:40.510 -> PingAddr = 86 Mess: Disable cursor17:33:40.510 -> 87 88 89 8A

At time 37: 166 there is a macro request (5C) .There are other actions but at time 37: 307 there is a response from the Controller MACRO NUThe message is completed at time 37: 354. MBER:   At time 38.010 the value 51 is sent. At 38.104 the host resends the message MBER:   There are a number of cursor operations and then at time 38.151 Character F1. In NCE code 51 is the number "1" while F1 is the character "1" So the F1 echos the 51. The display would now read MBER:1__ where "__" are the numbers to come.At time 38.869 the second number 57 is sent. The host responds almost immediately with F7At time:39.666 the operation is repeated for the number 4.At time 40.463 the terminator 40 is sent. and the request is complete,
Note there is significant wait time between each bust of activity related to the macro activity. This wait time, specificity number of cycles SEND_DELAY could be significantly reduced if desired. The trace suggests for the critical situation is between the macro request 0x5C and the first data byte 0x51 SEND_DELAY (see header file) could be reduced by 12.

The photo shows the macro being developed on an NCE CAB. At this point a macro has been requested (0x5C), the NCE Controller has responded with the message MACRO NUMBER: and the cursor commands to place the cursor ready for the first key entry.

Conclusion

That completes the development of the class NCE_Bus_Interface.

The project is now used as part of a model railway system to control several sets of points.