Wye Control LEDs

Introduction

This project control the points/turnouts of a model train layout. There are 6 control panels where the user can request one of the various track options. On each panel there will be 4 options for the possible routes. Note due to the physical payout of the track, specifically the "wye" connection 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 A for example representing that route to B is active. Then panel B 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 turn on the appropriate LEDs

The Circuit

The basic circuit of the controller and one control panel is shown. The 165 device is the point selection component of the control panel and is the subject of another page.

The 164 device drives the LEDs to indicate the chosen point selection. There are 4 LEDs. Only one is shown, the remainer 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 microcontroller output pins Main_pin .. Pommy_pin
Clocks all the shift registers to ripple the data on the output pins into the shift registers on the boards Main_board .. 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.

Starting H Code (click to open)

#ifndef WYE_LED_H#define WYE_LED_H
#include "Arduino.h"
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 progammed 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 is less than 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 of 0xFA and 0FxF5. 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 0x18 .... #define MAIN_SID 0x14.....#define MAIN_ASH 0x12 ... etc#define HARD_MAIN 0x38 ,,,,#define HARD_SILO 0x38.......#define POMMY_HARD 0x62 #define POMMY_SID 0x61 24 entries in total
The basic code will be of the form
if (pat == MAIN_HARD) main_data = MAIN_HARD;
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) {main_data = MAIN_HARD; hard_data = HARD_MAIN; } //24 such statements

If there is an invalid parameter the final statement will set all memory to the value of the parameter pat;

Conclusion

At this point the operation has been verified by using different combinations in the client code. A complete testing will be performed when it is integrated with other modules.

Using a logic analyzer the time required for the dump_LED() routine was approximately 120uS.