Wye Control Buttons

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 are 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.

On each panel there are four buttons to select the required routes

This project develops a class/library that reads the 4 buttons on each panel and returns the requested route.

The Circuit

The basic circuit of the controller and one control panel is shown. The 164 device drives the 4 LEDs to indicate the chosen point selection and is the subject of the page Wye Contrel Leds

The 165 device is wired to pin D4 (load), D8 (clock) and A0 (data in) The remaining boards use the same load and clock signals but the data is wired to pins A1 through A5.

The Software Header File

Full Header Code. Click

#ifndef WYE_BUTTON_H#define WYE_BUTTON_H#include "Arduino.h"
#define MAIN_PAN 0x10#define SILO_PAN 0x20#define HARD_PAN 0x30#define SID_PAN 0x40#define ASH_PAN 0x50#define POMMY_PAN 0x60
#define TOP 16 #define SECOND 32#define THIRD 2#define BOT 1#define TOP_REQ 0x1 #define SEC_REQ 2 #define THIRD_REQ 4 #define BOT_REQ 8 #define MAIN_HARD_REQ MAIN_PAN+TOP_REQ#define MAIN_SID_REQ MAIN_PAN+SEC_REQ#define MAIN_ASH_REQ MAIN_PAN+THIRD_REQ#define MAIN_POMMY_REQ MAIN_PAN+BOT_REQ#define SILO_HARD_REQ SILO_PAN+TOP_REQ#define SILO_SID_REQ SILO_PAN+SEC_REQ#define SILO_ASH_REQ SILO_PAN+THIRD_REQ#define SILO_POMMY_REQ SILO_PAN+BOT_REQ
#define HARD_MAIN_REQ HARD_PAN+TOP_REQ#define HARD_SILO_REQ HARD_PAN+SEC_REQ#define HARD_ASH_REQ HARD_PAN+THIRD_REQ#define HARD_POMMY_REQ HARD_PAN+BOT_REQ
#define SID_MAIN_REQ SID_PAN+TOP_REQ#define SID_SILO_REQ SID_PAN+SEC_REQ#define SID_ASH_REQ SID_PAN+THIRD_REQ#define SID_POMMY_REQ SID_PAN+BOT_REQ
#define ASH_MAIN_REQ ASH_PAN+TOP_REQ#define ASH_SILO_REQ ASH_PAN+SEC_REQ#define ASH_HARD_REQ ASH_PAN+THIRD_REQ#define ASH_SID_REQ ASH_PAN+BOT_REQ
#define POMMY_MAIN_REQ POMMY_PAN+TOP_REQ#define POMMY_SILO_REQ POMMY_PAN+SEC_REQ#define POMMY_HARD_REQ POMMY_PAN+THIRD_REQ#define POMMY_SID_REQ POMMY_PAN+BOT_REQ
class Wye_Buttons { public: Wye_Buttons (int,int,int,int,int,int,int,int); void begin( ); unsigned int read_buttons( ); void but_test(int); private: int load_pin; int clk_pin; int main_pin; int silo_pin; int hard_pin; int sid_pin; int ash_pin; int pommy_pin; int main_mem; int silo_mem; int hard_mem; int sid_mem; int ash_mem; int pommy_mem; unsigned int _convert(unsigned int ); };#endif

The main features of the header file will be:

Create a number of public methods:

   class Wye_Buttons {      public:        Wye_Buttons (int,int,int,int,int,int,int,int);        void begin( );         unsigned int read_buttons( );   These will include the class definition that has 8 parameters corresponding to the pin wirings: load and clock to all boards and input pins from the 6 control panels.
There will be the begin( ) method that will be used for any initialisation and the read_buttons( ) that will return the state of the buttons.
2, Create a range of private variables
private: int load_pin;              int clk_pin;             int main_pin;            ...........................             int main_mem;            ...............................    };
      Examples here are the declaration of the pins corresponding to the circuit wirings (8) and the 6 memory locations to store the results from the 6 control panels.
3. Definition of constants

#define MAIN_PAN 0x10#define SILO_PAN 0x20..........#define TOP 16 #define SECOND 32#define THIRD 2#define BOT 1............#define TOP_REQ 0x1 #define SEC_REQ 2 #define THIRD_REQ 4                               #define BOT_REQ 8 ..............#define MAIN_HARD_REQ MAIN_PAN+TOP_REQ#define MAIN_SID_REQ MAIN_PAN+SEC_REQ.....................
The first group of definitions assigns a number/code to the six panels.
The second group defines the weight of each button when it is rippled into memory. This will be determined by the PCB wirings. (On the PCB the buttons are wired to the most convenient input pin so the numerical order is random and not all values in the sequence are used
The third group assigns a code to the 4 buttons on the panel.
The final group gives the resultant code for the requests - there will be 24 in total. This if there is a request for the MAIN track to HARD track then the code will be the value of the MAIN panel plus a definition of what request REQ is required.
In summary. Assuming on the MAIN panel the top button corresponds to a request to HARD. On pressing the top button after rippling the results into memory the private variable main_mem will contain the value 16. The implementation code will decode this as a MAIN_HARD_REQuest and return the value MAIN_PANEL + ROP_REQuest or 0x11 in this example.

The Software Implementation File

Complete Software Implementation File (Click)

#include "Wye_Buttons.h"Wye_Buttons::Wye_Buttons (int a, int b, int c, int d, int e, int f, int g, int h) {  load_pin = a; clk_pin = b;  main_pin = c; silo_pin = d; hard_pin = e;  sid_pin = f; ash_pin = g; pommy_pin = h;}void Wye_Buttons::begin() {  Serial.begin(115200);  pinMode(load_pin, OUTPUT);  pinMode(clk_pin, OUTPUT);  //pinMode(6,OUTPUT);  pinMode(main_pin, INPUT_PULLUP);  pinMode(silo_pin, INPUT_PULLUP);  pinMode(hard_pin, INPUT_PULLUP);  pinMode(sid_pin, INPUT_PULLUP);  pinMode(ash_pin, INPUT_PULLUP);  pinMode(pommy_pin, INPUT_PULLUP);}
unsigned int Wye_Buttons::read_buttons(){  main_mem = 0; silo_mem = 0; hard_mem = 0;  sid_mem = 0; ash_mem = 0; pommy_mem = 0;  digitalWrite(load_pin, LOW);  delay(10);  digitalWrite(load_pin, HIGH); //pulse to read buttons into Par 2 Ser cct

  for (int pp = 0; pp < 8 ; pp++) //read 8 bits  {    main_mem *= 2; //left shift    main_mem += !digitalRead(main_pin); //add bit    silo_mem *= 2; //left shift    silo_mem += !digitalRead(silo_pin); //add bit    hard_mem *= 2; //left shift    hard_mem += !digitalRead(hard_pin); //add bit    sid_mem *= 2; //left shift    sid_mem += !digitalRead(sid_pin); //add bit    ash_mem *= 2; //left shift    ash_mem += !digitalRead(ash_pin); //add bit    pommy_mem *= 2; //left shift    pommy_mem += !digitalRead(pommy_pin); //add bit
    digitalWrite(clk_pin, HIGH); //clock Par to ser    delay(10);    digitalWrite(clk_pin, LOW);  }  if (main_mem & TOP) return (MAIN_HARD_REQ);  else if (main_mem & SECOND) return (MAIN_SID_REQ);  else if (main_mem & THIRD) return(MAIN_ASH_REQ);  else if (main_mem & BOT) return(MAIN_POMMY_REQ);
  else if (silo_mem & TOP) return (SILO_HARD_REQ);  else if (silo_mem & SECOND) return (SILO_SID_REQ);  else if (silo_mem & THIRD) return(SILO_ASH_REQ);  else if (silo_mem & BOT) return(SILO_POMMY_REQ);
  else if (hard_mem & TOP) return (HARD_MAIN_REQ);  else if (hard_mem & SECOND) return (HARD_SILO_REQ);  else if (hard_mem & THIRD) return(HARD_ASH_REQ);  else if (hard_mem & BOT) return(HARD_POMMY_REQ);
  else if (sid_mem & TOP) return (SID_MAIN_REQ);  else if (sid_mem & SECOND) return(SID_SILO_REQ);  else if (sid_mem & THIRD) return(SID_ASH_REQ);  else if (sid_mem & BOT) return(SID_POMMY_REQ);
  else if (ash_mem & TOP) return (ASH_MAIN_REQ);  else if (ash_mem & SECOND) return(ASH_SILO_REQ);  else if (ash_mem & THIRD) return(ASH_HARD_REQ);  else if (ash_mem & BOT) return(ASH_SID_REQ);
  else if (pommy_mem & TOP) return (POMMY_MAIN_REQ);  else if (pommy_mem & SECOND) return(POMMY_SILO_REQ);  else if (pommy_mem & THIRD) return(POMMY_HARD_REQ);  else if (pommy_mem & BOT) return(ASH_SID_REQ);    else return (0);}

Features of the implementation code include.

Code to create a Wye_Buttons Object

Wye_Buttons::Wye_Buttons (int a, int b, int c, int d, int e, int f, int g, int h) {    load_pin = a; clk_pin = b; main_pin = c; silo_pin = d; hard_pin = e;   sid_pin = f; ash_pin = g; pommy_pin = h;}
The method assigns all the parameters (8) to actual hardware pins.
2, The begin( ) method
void Wye_Buttons::begin() {  Serial.begin(115200);  pinMode(load_pin, OUTPUT);  pinMode(clk_pin, OUTPUT);
  pinMode(main_pin, INPUT_PULLUP);}
This method assigns the clock and load pins as outputs and the other 6 pins as inputs
3. read_buttons
unsigned int Wye_Buttons::read_buttons(){  main_mem = 0; silo_mem = 0; hard_mem = 0;  sid_mem = 0; ash_mem = 0; pommy_mem = 0;  digitalWrite(load_pin, LOW);  delay(10);  digitalWrite(load_pin, HIGH); //pulse to read buttons into Par 2 Ser cct

  for (int pp = 0; pp < 8 ; pp++) //read 8 bits  {    main_mem *= 2; //left shift    main_mem += !digitalRead(main_pin); //add bit   ..............
    digitalWrite(clk_pin, HIGH); //clock Par to ser    delay(10);    digitalWrite(clk_pin, LOW);  }
This operation clears the 6 memory locations used to store the readings.
The load pulse is generated.
The parallel to serial output is clocked into the memory locations. Note sequence - shift memory bits, read pin and then clock serial data in parallel to serial.
4. Decode Messages This consists of six blocks of four messages of the form:
  if (main_mem & TOP) return (MAIN_HARD_REQ);  else if (main_mem & SECOND) return (MAIN_SID_REQ);  else if (main_mem & THIRD) return(MAIN_ASH_REQ);  else if (main_mem & BOT) return(MAIN_POMMY_REQ);
........................  else return (0);}
This code has taken the values read by the hardware and translated it into values for further use.

The Client or Test Code (*.ino)

#include "Wye_Buttons.h"

Wye_Buttons but(4,8,A0,A1,A2,A3,A4,A5);

void setup() {

but.begin( );

pinMode(12,OUTPUT);

}

void loop() {

int static save_req;

digitalWrite(12,HIGH);

int request = but.read_buttons();

if ((request)&&(request != save_req)) {

Serial.println(request,HEX);

save_req = request;

}

digitalWrite(12,LOW);

delay(100);

}

The client code will

1.Create an object of the type Wye_Buttons.

This object specifies how the object is wired. That is the load, clock and the serial out of the 6 panels.

2, Calls the begin method to initialise the object

For observation with a mixed signal oscilloscope pin 12 is set as an output.

3. Requests the button reading and displays the result.

To observe the timings pin 12 is set high before and low after the read_buttons operations. This is known as the Activity signal in the following trace.

System Waveforms

The above trace shows the signals to/from the buttons. The first channel gives the load signal that transfers the button state into the parallel to serial shift converter or shift register.

This is followed by 8 clock pulses to ripple the data from the shift register into the microcontroller (Serial In)

For the final trace a microcontroller pin was set high before reading the buttons and low when the operation was complete. By setting the cursors this may be read as 367 uSec.

Note the waveforms have captured a number of glitches. These appear to be related to the Serial In line going high and could possibly be eliminated by adding a small capacitance to the line.

Adding Wye_Buttons Library

The Wye_Butons can be added to the Arduino as a library.

Currently the *.h and *.cpp files (and *.ino) will be under the user work directory in a sub folder Wye_Buttons. (This happens by default when a new *.ino file is created.

To generate a library:

1. In the sub folder Wye_Buttons use a program such as Windows Explorer to create a *.zip file of the *.h and *.cpp files.

2. In the Arduino IDE under sketch --> Include Library --> Add .zip Library

3. Browse your files and select Wye_Buttons.zip

The operation will, if necessary create another sub folder "libraries". Under the libraries folder will be a folder Wye_Buttons where there will be the Wye_Buttons.cpp and Wye_Buttons.h files. Further libraries will be created under the same libraries folder.**

Notes (i) .if the two files are copied across the Arduino would need to be restarted for the updates to take affect.

ii. The original client code (*.ino file) included the library using #include "Wye_Buttons.h" with quotes. To use the files in the libraries folder the #include uses < ..>.

4. For other project to use the library (i) in the Arduino IDE under sketch-->Include Library and (ii) in the list of contributed libraries select Wye_Buttons.

For other users if the *.zip file is available start at step 2.

** This is a different location to libraries included as part of the Arduino IDE. In my case they were at C:\\Program Files(x86)\Arduino\Arduino\libraries. With the "< >" directive the compiler will search in both locations for the given file.

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

Page updated

Google Sites

Report abuse