NCE Bus Probe 1: Capturing Activity

This page presents a project that will capture and display on the monitor the activity on the NCE bus.

This project is known as NCE_Bus_Probe_1. Later projects NCE_Bus_Probe_2 etc will enhance the C-code developed in this project.

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

Background.

This project captures the activity on the NCE bus. For initial testing a NCE DCC Twin controller will be used. This is a simple controller that will control two locos at address 3 and 4 on a DCC track. NCE know this as a throttle.

The NCE DCC Twin also has an RS485 interface (the NCE Bus) where additional controllers may be added to enhance its capability. Twin. This project simply captures the activity on the NCE bus.

NCE DCC Twin. Two knobs plus switches to control locos at address 3 and 4.

Rear of NDE DCC Twin showing on the left the RS495 connector for the NCE DCC Bus

The project is illustrated in the following figure.

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

The NCE Bus Activity

A flow chart of the activity on the NCE bus is shown below. Looking ahead it is assumed this project will have the address 85.

The NCE DCC Twin will ping the addresses 80 through 8A in turn checking for a response from the addressed device. If it receives no response it moves to the next address.

At address 80, the broadcast address should be listened to by all devices. The NCE Twin will broadcast messages every 100 or so cycles.

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

The Circuit

The project uses a TTL to RS485 breakout board to perform the interface between the Arduino and the NCE Bus. On one side of the board are the two RS485 signals "A" and "B" or "+" and "-" (**) plus a ground. On the other side there are 4 pins that include the power (Vcc) and Ground plus the Receive and Transmit TTL pins that are wired directly to the Arduino I/O pins.

** Examples on the internet indicate that the manufacturers definitions are not consistent, and it may be necessary to swap the wiring to A/B.

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

The NCE Bus Signal

Once a TTL to RS485 interface board is powered the received signal at RO may be observed with a mixed signal oscilloscope (MSO). The first trace below shows a typical result (**). By using the timing features of the MSO the signal can be determined to be 9600 baud and the time between each byte approximately 3.88 mS (See cursors). Further the data may be deduced/read as 0x80, 0x82, 0x83 through 0x8A. That is the NCE Bus first pings address 80, the broadcast address, it misses device 1, but then pings/addresses devices "2" through "10" before repeating.

Every so often the broadcast address (0x80) is followed by a string of data. With much patience this can be captured. (!!)

** To synchronise the trace the trigger has been set for a negative pulse of greater than 800uS which synchronises on the 0x80 or broadcast ping address.

!! In this example the resultant trace was captured after 84 attempts.

The above trace has captured the signal on the NCE bus. Note it goes through the sequence 0x80, 0x82, 0x83 through 0x8A and then repeats. Each byte is 9600 baud and the time between each byte is 3.88mS,

Occasionally following the 0x80 Broadcast ping/command a burst of activity is inserted before the 0x82 ping. It will be the job of the project firmware to capture this string and take the appropriate action,
In this example the scan was repeated 84 times before this stretched sequence was captured.

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

Getting Started with the Firmware: Probing the activity on the NCE data bus.

The first step is to generate 3 files DCC_NCE_Probe with extensions ino, cpp and h
1. Create a new project with the label DCC_NCE_Probe. This will present a new file NCE_Bus_Probe with the extension .ino.
2. Using the inverted triangle in the Arduino IDE to create two new tabs. Give these the labels NCE_Bus_Probe.cpp and NCE_Bus_Probe.h

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

Populating the files.

It is possible to start generating the files at either end.

For example, in the *ino file there needs to be a function/method to read the bytes on the NCE bus. That is a method of the form handleByte(). (In this example it is wait_for_myaddress( ) which handles all the bytes).

Alternatively, starting with the *.h file there needs to be a class NCE_Bus_Probe that ultimately performs all the underlining detailed work and provides functions available to the client (*.ino) code.

Client or *ino code

Possible client or *ino code must:

(1) Create an object bus of type NCE_Bus_Probe. For flexiility this can include as a parameter the address of the object. In example address 5 is used

NCE_Bus_Probe bus(5);

(2) Initialise the serial port and write a message to the monitor. The serial port will be used for debugging.

Serial.begin(115200); Serial.println("\n-NCE Twin Probe-");

(3)The setup( ) method/function will also initialise the new class NCE_Bus_Probe.

bus.begin(1);

The begin method will include a parameter that determines the amount of information displayed. This is illustrated below

With parameter = 0 all pieces of captured information will be displays plus any messages generated by the code

With parameter = 1 no reads of the data bytes are sent to the serial monitor

(4) Since the basic operation of the project will be to wait until a ping of my address is received and then do something similer to a method bus.wait_for_myaddress() is required,

void loop() { bus.wait_for_myaddress(); }

Full Client or *.ino code

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

void setup(){ Serial.begin(115200); Serial.println("\n-NCE Twin Probe-"); bus.begin(1); //1: output all bytes on NCE Bus
}
void loop() { bus.wait_for_myaddress(); }

The Header Code

The header file must:
(1) Include the SoftwareSerial Library to interface with the RS485 bus
#include <SoftwareSerial.h>
(2) Create a class that has as a parameter the address of the project (0x85 has been used in this project.
class NCE_Bus_Probe { public:                                             NCE_Bus_Probe (uint8_t my_address );

(3) Include in the public definition of the class the desired public methods
                                                                                                 void begin(uint8_t tt);                (4) In the private area of the class include all the variables and methods for the program implementation. For starters the method
        uint8_t get_NCE_Byte( );
that will read every byte in turn

The full header or *.h code

//NCE_Bus_Probe.h Header File//NCE_Bus_Probe.h Header File
#ifndef NCE_BUS_PROBE_H#define NCE_BUS_PROBE_H#include "Arduino.h"
#define TRACE 1#define PROGRAM 1 #define BUS_PING ((rxByte >= 0x80)&&(rxByte <0xC0))
#include <SoftwareSerial.h> //Included SoftwareSerial Library
class NCE_Bus_Probe { public: NCE_Bus_Probe (uint8_t my_address ); void begin(uint8_t tt); void wait_for_myaddress(); 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);};#endif

The Implementation of *.cpp code

The implementation code will need to

Specify the pins to which the RS485 bus is attached:

SoftwareSerial RS485(12,11); //Rx Tx

Create NCE_BusProbe object at the address specified by the parameter

NCE_Bus_Probe :: NCE_Bus_Probe ( uint8_t my_address)

{_my_address = 0x80+my_address; };

Implement the begin method

void NCE_Bus_Probe::begin (uint8_t tt )

The begin will in turn initialise the RS485 device{

RS485.begin(9600);

Wait for the RS485 to become available

while (!RS485.available( ))

Implement the method that contiually reads the RS485 bus until my_address occurs

void NCE_Bus_Probe ::wait_for_myaddress()
while (rxByte != _my_address)
rxByte = get_NCE_Byte( );

Implement the method that reads each byte on the bus

uint8_t NCE_Bus_Probe::get_NCE_Byte( )
while (!RS485.available( ));
rxByte = RS485.read();

The full implementation or *.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}        //-----------------------------------------------------------  void NCE_Bus_Probe::_output_message( ) { //(uint8_t len) {
  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 (_trace){          if (rxByte == 0x80) Serial.println(); //sync to broadcast            if (rxByte < 16) Serial.print('0');          Serial.print(rxByte,HEX);          Serial.print(' ');       }         return rxByte;            }          if (rxByte < 16) Serial.print('0');          Serial.print(rxByte,HEX);          Serial.print(' ');       }         return rxByte;            }

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

Handling the NCE Data Bytes

To handle the NCE data a method wait_for_myaddress() is included in the NCE_Bus_Probe class. This calls the get_NCE_Byte( ) which performs the nuts and bolts operation of reading the data on the RS485 or NCE bus. This returns the data byte to the wait_for_myaddress() that loops until my_address (0x85) is received.

To display the bus activity Serial.print( ) statements are included. Note this display is conditional depending on the variable _trace which is determined by the parameter in the set up begin( ) method.

Also for clarity of the display a new line is created at the broadcast address (0x80) and spaces are added between each byte.

Two traces of the bus activity to illustrate the parameter in the begin method are shown below.

With begin(1) the monitor will display all bus activity. The monitor display following reset. After the messages the code has captured the data 0x80, 0x82, 0x83 .... 0x8A. For clarity the program adds a new line prior to printing each 0x80, the broadcast ping.

With begin(0) the byte activity is not displayed. Only information of the users choosing.

With the NCE bus the controller will occasionally output messages at the broadcast address 0x80. This trace is part of a later project that displys the messages. With begin(0) these messages are not swamped by all the byte reads.

Notes:

The first trace shows the start up code with a number of dots while the RS485 bus synchronizes.

In general the captured data will be the pings to addresses 0x80 through 0x8A (less address 0x81.) as per the above.

Occasionally in the Broadcast state there will be a message. This message could be 2 bytes starting with D4 (telling all controllers to turn on a green light) or 9 bytes starting with 0xC1 - C1 tells LCD to display message on top row to right. The following 8 bytes are the message. In the example " 03:56AMPM"

Looking ahead a following step in the project will be to extract the data from these longer lines. Later projects will do something with the data

Handling Messages.

The lowest level code in the implementation file is get_NCE_Byte( ). This returns the next byte.

        while (!RS485.available( ));       rxByte = RS485.read();
    If the byte is a ping address this will be saved for future use
       if (BUS_PING)== 0x80) _ping = rxByte; //save ping of interest
        where BUS_PING has been defined in the header file. ie #define BUS_PING ((rxByte >= 0x80)&&(rxByte <0xC0))     and depending on the parameter _trace print the received byte to the monitor. Some formatting is included.           ...     Serial.print(rxByte,HEX);
'''''   The method returns the next byte.                      return rxByte;

The main method in the implementation code is wait_for_myaddress(). This will

       call get_NCE_Byte( ) that returns the next byte on the RS485 Bus
        exit if myaddress (0x85);        continue looping if a ping address        branch to the method _handle_mess() if it's not a ping
       exit when the received byte is my address      3 At this point the data is a message not a ping. _handle_mess(rxByte)
   Uses the parameter to determine the size of the message
    if ((rxByte >= 0xC0)&& (rxByte <= 0xC7)) _bufflen=9;     else if ((rxByte ==0xCE)||(rxByte==0xCF)) _bufflen= 1;       else _bufflen = 2;

   Places the received byte in a buffer                   while(_BusPtr < _bufflen){              if (_bufflen == 9 ){                   rxByte = get_NCE_Byte();                  _BusBuffer[_BusPtr++] = _NCE_ASCII(rxByte);              } else                    _BusBuffer[_BusPtr++] = get_NCE_Byte();
  The only complication is that NCE does not use conventional ASCII code for text messages. Messages of lenght 9 are text so the NCE code is converted to standard ASCII.                  _BusBuffer[_BusPtr++] = _NCE_ASCII(rxByte);
4. _NCE_ASCII(rxByte); converts NCE code to standard ASCII
5. handle_mess calls _output_message( )
that at this point displays messages to the monitor for debugging purposes but will be a holding method for messages for further projects    -------------------------------

Sample traces

Start Up

Line 1 is a message displayed at the start of the program

Line 2 are dots displayed while waiting for the Bus to become avilable

Line 3 is the monitor message when the project is linked to the NCE Twin

The remaining lines ate the captured data formatted for clarity with spaces and a new line for each broadcast address.

With the NCE Twin the addresses are 80 through 8A with 81 missing. Larger controllers can have addresses in the range 0x80 through 0xBF

Capture of small message

Occasionally there will be broadcast messages that may be captured with a monitor program that has a large buffer.

By scrolling through the captured the message 0xD4 0x0A was captured.

To assist explain what is happening the monitor messages as shown are included.

Capture of long message

By scrolling through the data a long message has been captured.

Following the broadcast address (0x80) the data 0xC1 is captured. THis is a 9 byte message. The program displays this line plus the start of the next line.

The method get_NCE_Byte( ) continues to read data and display on the monitorThe next line shows what happens after the NCE ASCII has been translated to normal ASCII.
After handing the broadcast message the next ping address (0x82) is read etc