NCE Bus Probe 3:

Hand Shaking

This page presents a project that handshakes with the NCE Controller. It simply advises the NCE that there is a device (also known as CAB or Throttle) present on the NCE bus. It will not request any action.

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

Background.

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

The RS485 interface will capture 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 will jump to the method _output_message().

NCE_Bus_Probe2 populates the method _output_message() to send the messages to client software. The trace below illustrates the results of NCE_Bus_Probe2 .

At this point the slave controller has done absolutely nothing except monitor the bus activity. In practice for starters the slave needs to let the host know it is present. It will do this by loading information on to the bus following the receipt of its ping address (0x85 used).

The slave responses are the subject of this page.

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

The activities for myaddress.

To date the design is just looping waiting for myaddress. In this example 0x85. Upon receipt of 0x85 it needs to respond to the NCE host.

Initially there will be some initialisation required.
Following this the target (this project) must respond to the NCE with either a "I'm still here" or a command/request that will be the subject of a separate project.

The NCE may or may not send a message to device 0x85. If so the code from the previous projects should handle these messages.

The question will be where the dividing line between the class and the client responsibility is. To assist the client all the initialisation will be performed by the class along with the "I am here" response.

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

Writing to the NCE Bus.

To write to the NCE Bus (RS485) the following two methods will be required

void NCE_Bus_Probe::SendByteRS485(uint8_t mess){ delayMicroseconds(200); RS485.write(mess);}void NCE_Bus_Probe::Send2Bytes485(uint8_t m1,uint8_t m2) { delayMicroseconds(200); RS485.write(m1); RS485.write(m2); }
The 200uS delay was determined by experimentation (100uS did not work)

The myaddress initialisation.

The following code should be added to the begin() method to handle the initialisation operations.
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 wait_for_myaddress( );
Serial.print("\nMy Address on reset "); Send2Bytes485(0x7E,0x7F); Serial.print("Send 7E-7F: "); uint8_t rxByte = get_NCE_Byte( ); if (rxByte == 0xD2) {SendByteRS485('a'); //dumb terminal Serial.println("\nResponse 'a' == Dumb terminal. ");} else _handle_mess(rxByte);}//
The start activity is illustrated below.

Start Up Trace

Once the project is attached to the RS485bus the code generates the RS485 Available message.

Upon receipt of myaddress the code sends the message 0x7E 0x7F advising the Host (The NCE Controller) that there is a new device on the bus.

The host then sends the 0xD2 message requesting the type of terminal.

The device sends 'a" to indicate a dumb terminal.

The host then continues pinging all addresses.

The waveforms for the reset actions are shown below.

In detail the top channel shows a 85 ping is received from the NCE Twin, the project responds/transmits with the two bytes and then the NCE Twin sends the message/command/request which by observation may be seen to be 0xD2.

** The NCE TWIN expects two byte commands. In this example 7E requests that the data be displayed and 7F that the loco speed is zero.

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

The Handshaking.

  Once myaddress is received the device at that address should respond.
This will require including a new method _its_me( ) in the wait_for_myaddress() method.
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);          }          _its_me();                }
At this stage all the _its_me( ) method will do is send the message I_AM_HERE ie 0x7D 0x7F
void NCE_Bus_Probe ::_its_me(){         if (_trace) Serial.println("I'm here send 0x7D 0x7F");       I_AM_HERE;    } The follow project will enhance the _its_me( ) response to include requests
A trace illustrating I am here is given below,

I am here

The trace shows at the address 0x85 the message I'm here is displayed. The message 0x7D 0x7F is send to the NCE Host.

The next project will include the ability to send alternative messages/requests.

Note that the displayed trace has also captured a broadcast message up datting the Fast Clocl.

Full Implementation 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  wait_for_myaddress( );
  Serial.print("\nMy Address on reset ");  Send2Bytes485(0x7E,0x7F);   Serial.print("Send 7E-7F: ");  uint8_t rxByte = get_NCE_Byte( );  if (rxByte == 0xD2) {SendByteRS485('a'); //dumb terminal               Serial.println("\nResponse 'a' == Dumb terminal. ");}       else _handle_mess(rxByte);}//----------------------------//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 ::_its_me(){         if (_trace) Serial.println("I'm here send 0x7D 0x7F");       I_AM_HERE; //nothing to send  } //-------------------------------------------------    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);          }          _its_me();                   }  //--------------------------------------------------------  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;            }
//digital writes required if using RS485 device with separate Tx enable.//It appears a delay of 200 microseconds is required. 100 will not work
void NCE_Bus_Probe::SendByteRS485(uint8_t mess){  delayMicroseconds(200);  RS485.write(mess);}void NCE_Bus_Probe::Send2Bytes485(uint8_t m1,uint8_t m2) {   delayMicroseconds(200);         RS485.write(m1);   RS485.write(m2);   }

The Header *.h File

The header file should add the following operations to the private definitions of the class.
void _its_me(); void Send2Bytes485(uint8_t m1,uint8_t m2); void SendByteRS485(uint8_t mess); The header file has also added a new definition
#define I_AM_HERE Send2Bytes485(0x7D,0x7F)

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))#define I_AM_HERE Send2Bytes485(0x7D,0x7F) #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;     void _its_me();    void Send2Bytes485(uint8_t m1,uint8_t m2);    void SendByteRS485(uint8_t mess);    };#endif

The Client Test *,ino code.

No changes to the *.ino were required to test this project. The client code for project 1 is given for convenience.

#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 Next Steps

The project as given will only respond with the message "I'm Here" on every 0x85 ping address.

Following projects will enhance the software to requests actions from the NCE Host

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