NCE Bus Probe 4 Generating Bus Requests

Introduction/Background

This project is part of an overall system for an NCE Controlled model train layout. Previous projects NCE_Bus_Probe_1, NCE_Bus_Probe_2 and NCE_Bus_Probe_3 have captured and displayed the activity on the NCE Bus. That is activity in the right hand box.

This project will inplement the left hand box. That is send commands/requests to the NCE Controller shown as a NCE Twin) over the NCE Bus (RS485)

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

Setting up the Send Buffer

The Header File

This section will set up a buffer ready to send to the NCE Bus. The header file is upgraded to include a private array _sen_buffer[8]. Associated with the buffer will be variables indicating the buffer size and a pointer to incdicate progress when sending the buffer. In addition there will be a flag to indicate when the buffer is full (ie new data).

Fo client access there are two public methods macro() and free2send(). free2send() will return the buffer status while macro() will receive the required macro number and put it into the desired NCE format and load the result into _send_buffer[]. (Handling a macro ws chosen as the easiest of the BCE requests to implement. If required later projects could look at accessories or loco operations)

class NCE_Bus_Probe { public: NCE_Bus_Probe (uint8_t my_address ); ........ void macro(int); bool free2send(); private: ......... uint8_t _send_buffer[8]; int _buffer_ptr; int _buffer_size; bool _buffer_full;

-----------------------------------------------The Client File

At this point the client code is simply code to test the class underdevelopment. As given the status of the buffer is tested every cycle and if the buffer is empty a random macro request is issued.

void loop() { bus.wait_for_myaddress(); if (bus.free2send()){ bus.macro(173); Serial.println("Macro 173 loaded."); } }

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

The Implementation Code: The macro.

The macro() method will put the requested macro in the desired format into the buffer. In the case of macro 173 this will be the sequence 0x5C, 0x51, 0x57, 0x53, 0x40 where 0x5C is the NCE pattern for a macro request, 0x51...0x53 are NCE code for the number 173 and 0x40 the terninator or carriage return.

Associated with loading the buffer some variables are initialised.

void NCE_Bus_Probe::macro(int mac){ if (_buffer_full) return; Serial.println("Loading Buffer"); _send_buffer[0] = 0x5C; _send_buffer[1] = 0x50+ mac/100; mac %= 100; _send_buffer[2] = 0x50+ mac/10; mac %= 10; _send_buffer[3] = 0x50+ mac; _send_buffer[4] = 0x40; _buffer_ptr = 0; _buffer_size = 5; _buffer_full = 1; } bool NCE_Bus_Probe::free2send(){ return (!_buffer_full); }

Also given is the implementation of the free2send() method that maybe used by the client to test if the buffer is free. The macro() method also includes a test should the client not test for the buffer empty. ------------------------- The Implementaion Code: Testing the buffer.
After the NCE host sends myaddress it expects a response. To date the response in the _its_me() method has been to send I_AM_HERE (ie 0x7D, 0x7F).
The its_me() method needs to test if there is something in the buffer to send. For the moment it will also send the I_AM_HERE message. The next stage in the program development will be to adjust this message to inlude the buffer contents.

void NCE_Bus_Probe ::_its_me(){ if (_buffer_full) { Serial.println("Data to send "); I_AM_HERE; //adjust message } else if (_trace) Serial.println("I'm here send 0x7D 0x7F"); I_AM_HERE; //nothing to send }

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

Enhancing the _its_me() method.

In the actual NCE system the operation of sending any commands will involve some handshaking and will occur at human speeds not computer speeds.

The operator first enters the Macro request and the NCE controller would respond sometime later with the display message MACRO NUMBER:-

The operator would then press the "1" key and the NCE Controller would respond by updating its display etc followed by the enter key. These operations all occur at human speeds.

At this point in the code development the firmware sends the two bytes 0x7D, 0x7F.

The 0x7D will need to be replaced with the macro request sequence 0x5C, 0x7F then 0x51, 0x7F then 0x57, 0x7F, and 0x51, 0x7F and finally 0x40,0x7F.

Header Code Upgrade

//NCE_Bus_Probe.h Header File/* * uint8_t _send_buffer[6];    int _buffer_ptr;          void load_buffer(unsigned int);              bool buffer_full();    */#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);         void macro(int);          bool free2send();   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();    long start_timer;    void Send2Bytes485(uint8_t m1,uint8_t m2);    void SendByteRS485(uint8_t mess);           uint8_t _send_buffer[8];          int _buffer_ptr;          int _buffer_size;          bool _buffer_full;          int _mess_count;             };

Full Header Code

//NCE_Bus_Probe.h Header File/* * uint8_t _send_buffer[6];    int _buffer_ptr;          void load_buffer(unsigned int);              bool buffer_full();    */#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);         void macro(int);          bool free2send();   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();    long start_timer;    void Send2Bytes485(uint8_t m1,uint8_t m2);    void SendByteRS485(uint8_t mess);           uint8_t _send_buffer[8];          int _buffer_ptr;          int _buffer_size;          bool _buffer_full;          int _mess_count;             };

Implementation Code Upgrade

//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);    _send_buffer[0]= 0;   _buffer_ptr = 0;   _buffer_full = 0;
}//----------------------------
//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);                // Serial.print(rxByte,HEX); Serial.print(',');              } else                    _BusBuffer[_BusPtr++] = get_NCE_Byte(); //load buffer           }       // Serial.println();       _output_message();            return get_NCE_Byte( );  }    //----------------------------
  void NCE_Bus_Probe ::_its_me(){   start_timer = millis( );     if (_buffer_full) { //there's a request to send        if (_buffer_ptr ==0){ //first byte of request            Send2Bytes485(_send_buffer[0],0x7F);            Serial.print("Request "); Serial.println(_send_buffer[0],HEX);            _buffer_ptr++;          } else //following bytes of request             if (_mess_count < 20){ //hold off outputting next byte                   _mess_count++;                   I_AM_HERE;                  } else                    { //count ==20 send out the next byte                  Serial.print(" Send "); Serial.println(_send_buffer[_buffer_ptr],HEX);                  Send2Bytes485(_send_buffer[_buffer_ptr++],0x7F);                  _mess_count = 0; //start the delay                  if (_buffer_ptr == _buffer_size) _buffer_full = 0; //all done                }             }                else //buffer empty - nothing to send        if (_trace) Serial.println("I'm here send 0x7D 0x7F");       I_AM_HERE; //no requests  }  //-------------------------------------------------    void NCE_Bus_Probe ::wait_for_myaddress(){     uint8_t rxByte;     /*      * Could get here in unsyncronised entry but should      * Will also enter here after doing whatever for myaddress      */     rxByte = get_NCE_Byte(); //will be next ping but could be a message to my address      while (rxByte != _my_address) //will not do loop if myaddress          {            if BUS_PING rxByte = get_NCE_Byte(); //next ping                else { //its a message                         Serial.print(" mess "); Serial.print(rxByte,HEX);Serial.print(" ");                          rxByte = _handle_mess(rxByte);                       }            }          _its_me(); //do whatever for myaddress          //will exit before reading any messages          //should read message on next loop       }  //--------------------------------------------------------  uint8_t NCE_Bus_Probe::get_NCE_Byte( )       {       uint8_t rxByte;       while (!RS485.available( ));       rxByte = RS485.read();       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);  while (millis() < start_timer + 200);  RS485.write(mess);}void NCE_Bus_Probe::Send2Bytes485(uint8_t m1,uint8_t m2) {// delayMicroseconds(200);          while (millis() < start_timer + 200);    RS485.write(m1);   RS485.write(m2);   }  //---------------------------------------------------------   void NCE_Bus_Probe::macro(int mac){      if (_buffer_full) return;        Serial.println("Loading Buffer");        _send_buffer[0] = 0x5C;        _send_buffer[1] = 0x50+ mac/100; mac %= 100;        _send_buffer[2] = 0x50+ mac/10; mac %= 10;        _send_buffer[3] = 0x50+ mac;           _send_buffer[4] = 0x40;        _buffer_ptr = 0;        _buffer_size = 5;        _buffer_full = 1;     }  bool NCE_Bus_Probe::free2send(){     return (!_buffer_full);  }

Full Implementation 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);    _send_buffer[0]= 0;   _buffer_ptr = 0;   _buffer_full = 0;
}//----------------------------
//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);                // Serial.print(rxByte,HEX); Serial.print(',');              } else                    _BusBuffer[_BusPtr++] = get_NCE_Byte(); //load buffer           }       // Serial.println();       _output_message();            return get_NCE_Byte( );  }    //----------------------------
  void NCE_Bus_Probe ::_its_me(){   start_timer = millis( );     if (_buffer_full) { //there's a request to send        if (_buffer_ptr ==0){ //first byte of request            Send2Bytes485(_send_buffer[0],0x7F);            Serial.print("Request "); Serial.println(_send_buffer[0],HEX);            _buffer_ptr++;          } else //following bytes of request             if (_mess_count < 20){ //hold off outputting next byte                   _mess_count++;                   I_AM_HERE;                  } else                    { //count ==20 send out the next byte                  Serial.print(" Send "); Serial.println(_send_buffer[_buffer_ptr],HEX);                  Send2Bytes485(_send_buffer[_buffer_ptr++],0x7F);                  _mess_count = 0; //start the delay                  if (_buffer_ptr == _buffer_size) _buffer_full = 0; //all done                }             }                else //buffer empty - nothing to send        if (_trace) Serial.println("I'm here send 0x7D 0x7F");       I_AM_HERE; //no requests  }  //-------------------------------------------------    void NCE_Bus_Probe ::wait_for_myaddress(){     uint8_t rxByte;     /*      * Could get here in unsyncronised entry but should      * Will also enter here after doing whatever for myaddress      */     rxByte = get_NCE_Byte(); //will be next ping but could be a message to my address      while (rxByte != _my_address) //will not do loop if myaddress          {            if BUS_PING rxByte = get_NCE_Byte(); //next ping                else { //its a message                         Serial.print(" mess "); Serial.print(rxByte,HEX);Serial.print(" ");                          rxByte = _handle_mess(rxByte);                       }            }          _its_me(); //do whatever for myaddress          //will exit before reading any messages          //should read message on next loop       }  //--------------------------------------------------------  uint8_t NCE_Bus_Probe::get_NCE_Byte( )       {       uint8_t rxByte;       while (!RS485.available( ));       rxByte = RS485.read();       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);  while (millis() < start_timer + 200);  RS485.write(mess);}void NCE_Bus_Probe::Send2Bytes485(uint8_t m1,uint8_t m2) {// delayMicroseconds(200);          while (millis() < start_timer + 200);    RS485.write(m1);   RS485.write(m2);   }  //---------------------------------------------------------   void NCE_Bus_Probe::macro(int mac){      if (_buffer_full) return;        Serial.println("Loading Buffer");        _send_buffer[0] = 0x5C;        _send_buffer[1] = 0x50+ mac/100; mac %= 100;        _send_buffer[2] = 0x50+ mac/10; mac %= 10;        _send_buffer[3] = 0x50+ mac;           _send_buffer[4] = 0x40;        _buffer_ptr = 0;        _buffer_size = 5;        _buffer_full = 1;     }  bool NCE_Bus_Probe::free2send(){     return (!_buffer_full);  }

Client Code Upgrade

#include "NCE_Bus_Probe.h"
NCE_Bus_Probe bus(6);
//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(" 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();       if (bus.free2send()){          bus.macro(173);         Serial.println("Macro 173 loaded.");      } }

Full Client Code

#include "NCE_Bus_Probe.h"
NCE_Bus_Probe bus(6);
//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(" 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();       if (bus.free2send()){          bus.macro(173);         Serial.println("Macro 173 loaded.");      } }