NCE Bus Probe 2: Displaying Messages

This page presents a project that will build on the project NCE Bus Probe 1 that reads all the activity on an NCE Bus and automatically transfers the messages to a client.

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

Background.

The project NCE Bus Probe 1 has captured the messages on the NCE Bus as illustrated in the following diagram

The RS485 interface captures all the activity on the NCE Bus. At this point the software NCE_Bus_Probe will place the address of the message in the variable _ping and the actual message in the variable buffer[9].

The code jumps to the method _output_message(). Currently this method just displays the messages for debugging purposes. The object of this project/page is to develop the code to output the messages to clients.

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)

The Message Structure or Type: Header Definitions

Since the messages are 9 bytes long which becomes 10 bytes if the address the included the header file must define a type with 10 parameters. That is

typedef void (*MessHandler) (uint8_t pp, 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);
There will need to be a private method that will perform the actual transfer of data from the library/class to the client. This will be the type MessHandler, that is

MessHandler MessHandlerFn;

Finally in the header code there will need to be a public method that is used by the client to advise the target destination.

void setMessHandler(MessHandler funcPtr);

Note the parameter here is the type MessHandler so funcPtr should be a type with 10 parameters

Full Header Code

//NCE_Bus_Probe.h Header File
#ifndef NCE_BUS_PROBE_H#define NCE_BUS_PROBE_H#include "Arduino.h"
#define TRACE 1
#define BUS_PING ((rxByte >= 0x80)&&(rxByte <0xC0))
#include <SoftwareSerial.h> //Included SoftwareSerial Library
//in order to create a link between the library and the client code need to define a type
typedef void (*MessHandler) (uint8_t pp,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);
class NCE_Bus_Probe { public: NCE_Bus_Probe (uint8_t my_address ); void begin(uint8_t tt); void wait_for_myaddress(); //To transfer the clock result from the library to the client need a public routine that client can call to setup link void setMessHandler(MessHandler funcPtr); private: uint8_t _trace; uint8_t _ping; uint8_t _my_address; uint8_t _BusBuffer[10]; uint8_t _BusPtr; uint8_t _BusSize; uint8_t _bufflen; uint8_t get_NCE_Byte( ); uint8_t _handle_mess(uint8_t rxByte); void _output_message( ); uint8_t _NCE_ASCII(uint8_t rr); //Need the private links that will do the actual transfers MessHandler MessHandlerFn; };#endif

The Implementation Code *.cpp

The implementation code must provide the nuts and bolts for the methods declared in the header file.

void NCE_Bus_Probe::setMessHandler(MessHandler clientPtr) { MessHandlerFn = clientPtr; } The setMessHandler will be called from the client code where the parameter clientPtr points to a method provided by the client that will handle 10 parameters. That is it will be of type MessHandler.
The original code included a method void NCE_Bus_Probe::_output_message( ) that is reached if there were any messages. This method needs to be populated. That is
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]);

As noted if the client has not set up this link the code is skipped. That is if the client does not need the messages there will be no issue leaving the feature in the library.

Full Implmentation *.cpp Code.

//NCE_Bus_Probe.cpp Implementation File#include "NCE_Bus_Probe.h"
SoftwareSerial RS485(12,11); //Rx Tx
NCE_Bus_Probe :: NCE_Bus_Probe ( uint8_t my_address)      {_my_address = 0x80+my_address; };
void NCE_Bus_Probe::begin (uint8_t tt ){  _trace = tt;           RS485.begin(9600);  int count = 0;  while (!RS485.available( ))           {if (count<50) //do not saturate screen with dots.            {Serial.print("."); count++;}}              Serial.println("\nRS485 Available");  while (get_NCE_Byte( ) != 0x80){ }; //synchronise with broadcast address}//----------------------------
//Need to implement the method that will point the library routine to the required client operation//Client will call this as part of initialisation
void NCE_Bus_Probe::setMessHandler(MessHandler clientPtr)               {                  MessHandlerFn = clientPtr;              }             //-----------------------------------------------------------  void NCE_Bus_Probe::_output_message( ) { //(uint8_t len) {
//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 (_bufflen == 9) {       if (_trace) {           Serial.print("Message");           for (int i=1; i<= _bufflen; i++){              Serial.print(" ");              Serial.print(char(_BusBuffer[i]));           }           Serial.println();           }     }   } //--------------------------------------------------------------------------------
//NCE does not use straight ASCII code - this routine adjusts
uint8_t NCE_Bus_Probe::_NCE_ASCII(uint8_t rr){
  if (rr & 0x20) return (rr & 0x3F);    else return (rr & 0x7F);}//-------------------------------------------------------uint8_t NCE_Bus_Probe:: _handle_mess(uint8_t rxByte){        if ((rxByte >= 0xC0)&& (rxByte <= 0xC7)) _bufflen=9;     else if ((rxByte ==0xCE)||(rxByte==0xCF)) _bufflen= 1;       else _bufflen = 2;        if (_trace){      Serial.print("Message rxByte = "); Serial.print(rxByte,HEX);       Serial.print(" length = "); Serial.println(_bufflen,HEX);      Serial.print("Raw message ");       }       _BusBuffer[0] = rxByte;       _BusPtr = 1;        while(_BusPtr < _bufflen){              if (_bufflen == 9 ){                   rxByte = get_NCE_Byte();                  _BusBuffer[_BusPtr++] = _NCE_ASCII(rxByte);              } else                    _BusBuffer[_BusPtr++] = get_NCE_Byte(); //load buffer           }          Serial.println();       _output_message();            return get_NCE_Byte( );  }  //-------------------------------------------------    void NCE_Bus_Probe ::wait_for_myaddress(){     uint8_t rxByte;     rxByte = get_NCE_Byte();     while (rxByte != _my_address)          {            if BUS_PING rxByte = get_NCE_Byte();                else rxByte = _handle_mess(rxByte);          }    }  //--------------------------------------------------------  uint8_t NCE_Bus_Probe::get_NCE_Byte( )       {       uint8_t rxByte;       while (!RS485.available( ));       rxByte = RS485.read();      // if ((rxByte & 0xF0)== 0x80) _ping = rxByte; //save ping of interest       if BUS_PING _ping = rxByte; //save ping of interest              if (_trace){          if (rxByte == 0x80) Serial.println(); //sync to broadcast            if (rxByte < 16) Serial.print('0');          Serial.print(rxByte,HEX);          Serial.print(' ');       }         return rxByte;            }

The Client *.ino Code

The client or *ino code will need to include a method that will receive the messages and take the required actions. Since at this point the client code is just testing or demonstrating the class/library all it will do is print out the results. The method will be the type NCE_Message( ) with 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) { Serial.print("NCE Device = "); Serial.print(ping,HEX); Serial.print(" Client Message: "); 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"); }

The final step is to include in the set up code the method that will point to the above message handler,

bus.setMessHandler(&NCE_Message);

Full Client *.ino code

#include "NCE_Bus_Probe.h"
NCE_Bus_Probe bus(5);

//need the client code to handle the clock -
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) {    Serial.print("NCE Device = ");     Serial.print(ping,HEX); Serial.print(" Client Message: ");        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"); }
void setup(){  Serial.begin(115200);   Serial.println("\n-NCE Twin Probe-");  bus.begin(0); //1: output all bytes on NCE Bus     //need to set up the link between library and code for client to handle clock    bus.setMessHandler(&NCE_Message);
}
void loop()  {        bus.wait_for_myaddress(); }

Testing

The following test results were obtained using a NCE Twin Probe.

The first three lines are part of the library while the remainder is the output from the method NCE_Message( ).

The above trace is part of the displayed data includes all data captures, messages in the implementation file and client messages.

It is captured with begin(1) in the client code.

After start up the above trace is the client messages only.

It is captured with begin(0) in the client code.

The above messages captured by the client illustrate what is happening on the NCE DCC Twin bus with no additional CABs/Throttles