Wye Control LEDs

Introduction

This project controls the points/turnouts of a model train layout. There are 6 control panels where the user can request one of the various track options.
A block diagram is shown below. The six control panels are given names corresponding to where they are located on the model train layout
On each panel there will be 4 buttons to request possible routes. Note due to the physical payout of the track, specifically the "wye" connection there are only 4 possible options on each panel and the 4 options on each board will be different.
Also on the control panel are a set of 4 LEDs that indicate the active routes. For the 6 boards there will only be 2 LEDs active. One on panel MAIN for example representing that route to HARD is active. Then panel HARD will have the LED representing that the route to A is active. On the remaining 4 panels there will be no active LEDs.
This page develops a class/library Wye_Control_LEDs that takes an input byte and turns on the appropriate LEDs

The Circuit

The basic circuit of the controller and one control panel is shown. The 165 device is the request component of the control panel and is the subject of the page Wye Control Buttons.
The 164 device drives the 4 LEDs to indicate the chosen point selection. Only one is shown, the remainder are wired to 164 pins 4, 5 and 6.
The 164 clock is wired to pin D2 of the micro controller, while the serial data for the device shown comes from pin D3 of the microcontroller.
There are 5 other control panels all being clocked via pin D2 with the data pins being D4, D5, D6, D9 and D10

The Software Structure

The software structure is illustrated.There are 6 memory locations known as Main_data through Pommy_data where the LED patterns will be stored. These labels correspond to locations on the original train layout.The firmware:

Initialises the memory to the required LED patterns
Places bit 0 of all the memory on the 6 microcontroller output pins Main_pin through Pommy_pin
Clocks all the shift registers to ripple the data on the output pins into the shift registers on the 6 boards Main_board through Pommy_Board.
Shift the memory data one bit right and repeat the above process.

The Basic Software

The software consists of three files

The header file "Wye_LEDs.h" that creates the class and defines all definitions
The implementation file "Wye_LEDs.cpp" and
The test or client code "Wye_LEDs.ino" that will not be part of the final library but will be used for testing and illustrating how the library might be used.

The Header File

The header file will create the class. That is
class Wye_LED { public: Wye_LED(int a,int b,int c,int d,int e,int f,int g);
For this project the final wiring is not known so the class includes 7 parameters to allow the wiring to be specified when an object of the class Wye_LED is created. (one int for the clock and the reining for the data pin to each control panel
All classes have a begin() function and in this case a public function dump_LED(byte) is required to set up the memory and clock the data to the external boards (shift registers)           void begin( );        void dump_LED(byte);
The parameter defines the active patterns.
The class definition also declares the pin and memory variables. That is
  private: int clk_pin; int main_pin; int silo_pin; ........ pommy_pin;                 byte main_data; byte silo_data; .........................pommy_data;

The header file will need to be expanded as the project progresses.

Open collapsible box for more complete file to this point. Note the final code contains a range of definitions. For example #define MAIN_HARD_LED 0x18 which is the pattern to turn on the LED that indicates the MAIN to HARD route.

Final *.H Code (click to open)

#ifndef WYE_LED_H#define WYE_LED_H
#include "Arduino.h"
#define MAIN_HARD_LED 0x18#define MAIN_SID_LED 0x14#define MAIN_ASH_LED 0x12#define MAIN_POMMY_LED 0x11#define SILO_HARD_LED 0x28#define SILO_SID_LED 0x24#define SILO_ASH_LED 0x22#define SILO_POMMY_LED 0x21
#define HARD_MAIN_LED 0x38#define HARD_SILO_LED 0x34#define HARD_ASH_LED 0x32#define HARD_POMMY_LED 0x31#define SID_MAIN_LED 0x48#define SID_SILO_LED 0x44#define SID_ASH_LED 0x42#define SID_POMMY_LED 0x41
#define ASH_MAIN_LED 0x58#define ASH_SILO_LED 0x54#define ASH_HARD_LED 0x52#define ASH_SID_LED 0x51
#define POMMY_MAIN_LED 0x68#define POMMY_SILO_LED 0x64#define POMMY_HARD_LED 0x62#define POMMY_SID_LED 0x61

#define MAIN_PAN 0x10#define SILO_PAN 0x20#define HARD_PAN 0x30#define SID_PAN 0x40#define ASH_PAN 0x50#define POMMY_PAN 0x60
class Wye_LED { public: Wye_LED(int a,int b,int c,int d,int e,int f,int g); void begin( ); void dump_LED(byte); private: int clk_pin; int main_pin; int silo_pin; int hard_pin; int sid_pin; int ash_pin; byte pommy_pin; byte main_data; byte silo_data; byte hard_data; byte sid_data; byte ash_data; byte pommy_data; void set_memory(byte); };

The Implementation Code

The implementation code consists of the class constructor where the pin variables are set to the parameters:
          Wye_LED::Wye_LED(int a, int b, int c, int d, int e, int f, int g)            {                      clk_pin =a; main_pin=b; silo_pin=c;                       hard_pin=d; sid_pin=e; ash_pin = f; pommy_pin =g;           }
Generally classes consist of a begin( ) function where variables may be initialised. In this project the output pins are programmed as outputs.
void Wye_LED::begin( ) {      pinMode(clk_pin, OUTPUT); pinMode(main_pin, OUTPUT); ... pinMode(pommy_pin, OUTPUT);   At this point no attempt is made to populate the dump_LED( ) function
              void Wye_LED::dump_LED(byte pat) { }

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

The Client or Test Code

The client code creates an instance of object of the class Wye_LED. This requires 7 parameters: the clock pin and the six outputs to the control panels.
           Wye_LED led(2,3,5,6,7,9,10);
An object led is defined. This is used in the setup function to specify the source of the begin() operation.
void setup() {   led.begin();}
For testing the LEDs should be flashed on and off.
            void loop() {                             led.dump_LED(0xFF);                             delay(500);                             led.dump_LED(0xF0);                             delay(500);                           }  While the dump_LED( ) function is yet to be written it assumed that the most significant nibble will specify all LEDs and the least significant the pattern.
Note: The code should compile and run at this point.

Enhancing the dump_LED( ) function

Central to the operation is generating the pulse to clock the shift registers. That is switching the clock pin high and low.        digitalWrite(clk_pin,HIGH); //4.4uS clock       digitalWrite(clk_pin,LOW);      A logic probe may be used to verify the operation. I measured a 4.4uS pulse. (The required minimum pulse width for the 74HC164 shift register is 20nS.)
For this project with 4 Leds on each control panel, a burst of 4 clock pulses will be required

     for (int i=0; i<4; i++) //39uS for each bit ~179uS complete message         {                the clock       }
As given the code outputs whatever is on the output pins. Before each clock pulse the contents of the memory are placed on the output pins. That is 6 lines of code are required before the clock
       digitalWrite(main_pin,main_data&1); .......etc...... digitalWrite(pommy_pin,pommy_data&1);
The last step in the process is after the clock to ripple the data in memory ready for the next bit,
         main_data = main_data >>1; .....etc... pommy_data = pommy_data >>1;
The code as given will output whatever is in memory. The memory should be set to the desired values. This will be performed by a separate function that will be called as the first line using the parameter.
     void Wye_LED::dump_LED(byte pat) {           set_memory(pat);           other actions      }

dump_LED(pat) Full code.

void Wye_LED::dump_LED(byte pat) { set_memory(pat); for (int i=0; i<4; i++) //39uS for each bit ~179uS complete message { digitalWrite(main_pin,main_data&1); //load the data digitalWrite(silo_pin,silo_data&1); digitalWrite(hard_pin,hard_data&1); digitalWrite(sid_pin,sid_data&1); digitalWrite(ash_pin,ash_data&1); digitalWrite(pommy_pin,pommy_data&1); digitalWrite(clk_pin,HIGH); //4.4uS clock digitalWrite(clk_pin,LOW); main_data = main_data >>1; //get next bit silo_data = silo_data >>1; hard_data = hard_data >>1; sid_data = sid_data >>1; ash_data = ash_data >> 1; pommy_data = pommy_data >>1; } }

set_memory(byte pat) code

A new function is written. That is void Wye_LED::set_memory(byte pat){ }
This function is added to the class definition.
For starters this function can load the parameter into all memory.
main_data= pat; silo_data= pat; ....... pommy_data=pat;
With the client code this implementation flashes all leds on and off

Test Waveforms

The client code is changed between 0xFA and 0xF5. This causes the LEDs to alternatingly turn on and off.The resultant waveform for the test program is captured below.

The lower trace captures the 4 clock pulses at the Microprocessor output pin D2.
The other wave forms are at pins 3 through 10. These waveforms indicate the pins 3 through 10 being set high in turn. Pins 4 and 7 are not part of the LED circuitry so they show no activity.
The trace has captured outputting 0xA to all the channels. With 0xA bit 0 is initially zero so the output pins are all low. The first clock pulse will transfer a zero to all channels.
For 0xA the firmware ripples the second bit (a high) to the output pins which the next clock pulse will load into the shift registers that drive the LEDS.
The sequences repeats for the 4 clock pulses.

With each clock the data is rippled across at an invisible rate . Ater 4 clock pulses the outputs will be stable and the LEDs steady.

Final set_memory(byte) Code

The existing code for testing places a bit pattern into all memory locations. In the final product the memory is an image of the LED displays.
The header file is enhanced to include the different bit patterns. For example, sending the code 0x18 will indicate that there has been a request from the MAIN panel to set the points for the HARD station. The 0x10 portion is user defined while the 0x80 takes into account how the control panel is wired.
The header file will contain the following definitions:
#define MAIN_HARD_LED 0x18 .... #define MAIN_SID_LED 0x14.....#define MAIN_ASH_LED 0x12 ... etc#define HARD_MAIN_LED 0x38 ,,,,#define HARD_SILO_LED 0x38.......#define POMMY_HARD_LED 0x62 #define POMMY_SID _LED 0x61 24 entries in total
The basic code will be of the form
if (pat == MAIN_HARD_LED) main_data = MAIN_HARD_LED;
There will be 24 such statements
As given, there will be only ONE LED active across the 6 panels.
In practice if a train is programmed to go from the MAIN to the HARD a train can also travel from the HARD to MAIN. The new code becomes:

if (pat == MAIN_HARD_LED) {main_data = MAIN_HARD_LED; hard_data = HARD_MAIN_LED; } //24 such statements

Full Implementation Code

#include "Wye_LEDs.h"
Wye_LED::Wye_LED(int a, int b, int c, int d, int e, int f, int g){  clk_pin =a; main_pin=b; silo_pin=c;  hard_pin=d; sid_pin=e; ash_pin = f; pommy_pin =g;}void Wye_LED::begin( ) {      pinMode(clk_pin, OUTPUT);      pinMode(main_pin, OUTPUT);      pinMode(silo_pin, OUTPUT);      pinMode(hard_pin, OUTPUT);      pinMode(sid_pin, OUTPUT);      pinMode(ash_pin, OUTPUT);      pinMode(pommy_pin, OUTPUT); } void Wye_LED::set_memory(byte pat){     byte high = pat&0xF0;           main_data = 0; //preclear           silo_data = 0;           hard_data = 0;           sid_data = 0;           ash_data = 0;           pommy_data = 0;
           //pat &= 0xFF;     if (high == MAIN_PAN){           main_data = pat;           if (pat == MAIN_HARD_LED) hard_data = HARD_MAIN_LED;           else if (pat == MAIN_SID_LED) sid_data = SID_MAIN_LED;           else if (pat == MAIN_ASH_LED) ash_data = ASH_MAIN_LED;           else if (pat == MAIN_POMMY_LED) pommy_data = POMMY_MAIN_LED;     }     else if (high == SILO_PAN){               silo_data = pat;           if (pat == SILO_SID_LED) sid_data = SID_SILO_LED;           else if (pat == SILO_SID_LED) sid_data = SID_SILO_LED;           else if (pat == SILO_ASH_LED) ash_data = ASH_SILO_LED;           else if (pat == SILO_POMMY_LED) pommy_data = POMMY_SILO_LED;         }      else if (high == HARD_PAN){           hard_data = pat;       if (pat == HARD_MAIN_LED) main_data = MAIN_HARD_LED;           else if (pat == HARD_SILO_LED) silo_data = SILO_HARD_LED;           else if (pat == HARD_ASH_LED) ash_data = ASH_HARD_LED;           else if (pat == HARD_POMMY_LED) pommy_data = POMMY_HARD_LED;         }     else if (high == SID_PAN){           sid_data = pat;        if (pat == SID_MAIN_LED) main_data = MAIN_SID_LED;           else if (pat == SID_SILO_LED) silo_data = SILO_SID_LED;           else if (pat == SID_ASH_LED) ash_data = ASH_SID_LED;           else if (pat == SID_POMMY_LED) pommy_data = POMMY_SID_LED;    }     else if (high == ASH_PAN){           ash_data = pat;           if (pat == ASH_MAIN_LED) main_data = MAIN_ASH_LED;           else if (pat == ASH_SILO_LED) silo_data = SILO_ASH_LED;           else if (pat == ASH_HARD_LED) ash_data = HARD_ASH_LED;           else if (pat == ASH_SID_LED) pommy_data = SID_ASH_LED;     }     else if (high == POMMY_PAN){           pommy_data = pat;           if (pat == POMMY_MAIN_LED) main_data = MAIN_POMMY_LED;           else if (pat == POMMY_SILO_LED) silo_data = SILO_POMMY_LED;           else if (pat == POMMY_HARD_LED) ash_data = HARD_POMMY_LED;           else if (pat == POMMY_SID_LED) pommy_data = SID_POMMY_LED;     }     else //if (high == 0xF0)           { //for testing - all patterns the same           main_data = pat;           silo_data = pat;           hard_data = pat;           sid_data = pat;           ash_data = pat;           pommy_data = pat;    }}
void Wye_LED::dump_LED(byte pat) {     if (pat == 0) return;     set_memory(pat);     for (int i=0; i<4; i++) //39uS for each bit ~179uS complete message     {          digitalWrite(main_pin,main_data&1); //transfer the data        digitalWrite(silo_pin,silo_data&1);       digitalWrite(hard_pin,hard_data&1);         digitalWrite(sid_pin,sid_data&1);       digitalWrite(ash_pin,ash_data&1);           digitalWrite(pommy_pin,pommy_data&1);            digitalWrite(clk_pin,HIGH); //4.4uS clock       digitalWrite(clk_pin,LOW);                  main_data = main_data >>1; //ripple data out       silo_data = silo_data >>1;       hard_data = hard_data >>1;       sid_data = sid_data >>1;       ash_data = ash_data >> 1;        pommy_data = pommy_data >>1;    }  }

Testing

At this point the operation was verified by using different combinations in the client code. A complete testing will be performed when it is integrated with other modules.
By toggling a pin at the start and end of the dump_LED() method using a logic analyzer the time required was approximately 150uS.

#include "Wye_LEDs.h"
Wye_LED led(2,10,9,3,7,6,5);
void setup() { led.begin(); pinMode(12,OUTPUT); //used for timing}
void loop() { digitalWrite(12,HIGH); led.dump_LED(ASH_MAIN_LED); digitalWrite(12,LOW); delay(500); }

Looking Ahead

In a model railway system this module will be part of three that control points and hence the train routes.

(i) Wye_Control_Buttons where a button of microswitch is used to select a chosen route
(ii) Wye_Points_Control that uses the button request to generate a macro for the NCE Controller
(iii) Wye_Control_Leds (this project) that displays the chosen route

To create the library, see the section in the page Arduino IDE