OS block control using an Arduino microcontroller

The following project is an update of Gary D. Patterson’s “Simplified CTC signals” in the July 1988 issue of MR. Bringing the project up to date was a large endeavour. The block control project now incorporates “all” solid-state components controlled by an Arduino microcontroller. I refer to this updated article as “CTC Signals 2.0.”

The scope of the project included many disciplines, such as electronic components selections, circuitry, building light-emitting diode (LED) signals, building the printed-circuit board (PCB), and programming the controller. I’ve broken it down into four major parts, as follows. In each section, numerous diagrams and pictures are included to help with the explanation.

 

Part 1 — Basic concepts, terminology, and overall block logic

 

The 1988 story referenced above presented a design that allowed the dispatcher to change the signal lights depending on which routes the trains take through a passing siding. The signal lights were controlled by the turnouts, which were manually controlled by the dispatcher.

The reason for this update is to increase the level of automation, but not to the point of eliminating the role of dispatcher. The controller is set to automatically position the departure turnout based on the trains position and considers whether there is any opposing traffic. The Arduino microcontroller also controls the signals to match the turnouts. The system is set as a self-contained block with two entry points which I call “EB Approach” and “WB Approach.” Both points correspond to sensors in the track and either will initiate the logic block. The only thing that the dispatcher must do is assign the first train to a route and then set the entry turnout accordingly. The controller will do the rest until the block is clear, with the exception being a train “on hold” in the siding. A train can be held for scheduling purposes or if the dispatcher is aware of any higher priority train approaching in either direction.

 

Terminology

 

Before we dive into the logic of how the controller processes trains through the block, we need to define the types and locations of the sensors and other critical components.

The following illustrations explain the logic for a typical meet at this passing siding.

To explain the logic, let’s assume that the eastbound train is the first to the control block and it will proceed onto the main because it has a higher priority than the approaching westbound.

Table 2: Track indications

The “hold” button is used to keep a train on the siding for train-schedule purposes. If it’s truly a passing meet, the train on the siding is automatically cleared.

This controller is a stand-alone product that doesn’t require any interconnection with other control blocks. It’s recommended to locate the approach sensors as far as possible from the control block to provide sufficient time for setting the turnout position.

 

Part 2 — Components and prototype

 

In this section, we’ll look at the technology options for each of the components and consider the benefits of each. Keep in mind that the goal is to be 100% solid-state with proven, simple, and reliable products.

 

Sensors

 

I wanted to find an option that would be foolproof in its ability to pinpoint the location of trains within the control block. The reed switches used in the original article are effective, but I wanted to eliminate the need for making conversions on the locomotives to accommodate the magnets, while at the same time, eliminating the inefficiencies of mechanical devices.

Photocells are often referred to as photoresistors. Common types contain cadmium sulphide, a light-sensitive compound. In the dark, they exhibit an exceedingly high resistance, up to several megohms. Their resistance drops when light shines on the surface. Because the resistance varies with the amount of light, they’re considered analog components.

Photocells are passive devices that are most frequently used in a voltage divider configuration, as shown here. The voltage that’s read at the signal point is a function of the amount of light which controls the resistance of the photocell.  As such, they don’t have a sharp on/off signal, typical of photodiodes or phototransistors, which are true semiconductor devices.

I’ve seen numerous references to IR sensors, usually with an IR beam directed across the track. The receiver is positioned to detect a reflected beam when a train passes. These may have been a good option, but were discounted for several reasons:

1. IR sensors must be mounted above grade and have two components that would need to be scenicked.
2. The two components increase the wiring needed. One set of wires is required to turn on the LED, and a second set of wires is needed to connect the receiver.
3. These sensors need to be carefully aligned for accurate detection.

Since none of the above met the needs, the choice became phototransistors.

Phototransistors belong to the family of transistors. Transistors function as switches, they’re either on or off, making them true digital components.

These diagrams compare the activation of transistors and phototransistors. A transistor requires a voltage to be applied on the base to turn on the transistor. When it’s on, current can flow from the power source to ground. Phototransistors don’t have a base connection. They’re activated when light shines on them, which turns them on or off.

Phototransistors would be the sensor of choice, but where is the optimum place to locate them on the layout?

For the overall layout, the dispatcher needs to think in terms of block limits. The approach sensors need to be located as far from the turnouts as possible thus defining the block limits.  Additionally, this would give the dispatcher the maximum time to set the turnout correctly to initiate the program. However, there can’t be any other access points onto the main between the Approach sensor and the Signal sensor (points 1 & 3 in the terminology).

The Signal sensor should be placed at the frog to indicate entry into the block. Because this sensor can be used to indicate that the train has entered the appropriate track, there shouldn’t be a long time-delay for the train to clear the frog.

The Mast sensor is placed at the end of the mainline section before reaching the block departure turnout. It needs to be in front of the signal so that the red signal can be activated and seen by the engineer.

The Dwarf sensor is placed at the end of the siding section before reaching the departure turnout, for the same reason as discussed above.

Entry into the block is indicated by a “true” signal at the Mast sensor (or Dwarf) or by a “false” response at the Signal sensor.

 

LEDs

 

The Mast and Dwarf lights mimic the main signal, so wiring them in parallel (diagram below) reduces the number of output pins from the microcontroller.

Only the LEDs of the main double-head Signal LED are controlled by the program. The Mast and Dwarf sensors are mimicked by wiring in parallel.

For this project, I made custom LEDs as described in my article in an upcoming issue of MR.

 

Push buttons

 

The push buttons selected for turnout position control and for hold/release are the momentary press type. These are an update compared to the older double-pole double throw (DPDT) switches. The program contains code that interprets the pressing action and latches the position setting until it is pressed again.

 

Optocouplers

 

As I wrote in my previous story about touch screen control (which can be found in the October 2022 issue of MR), I use optoisolators (or optocoupler) to control the operation of the Tortoise by Circuitron machines. An optoisolator is like a relay in that a signal causes a switch to open.

An optoisolator has two components in the IC body: pins 1 and 2 represent the control side, which is an embedded IR LED. The output side is a phototransistor which is activated by the light from the LED. When a 5V supply is connected to pin 1, the photodiode starts to emit light which is aimed at the phototransistor. This causes current to flow from pin 4 to pin 3. The key feature is that there’s no electrical connection. In my project, all power is at a 5VDC level except the Tortoise by Circuitron machines which are at 12V. A voltage level of 12V would destroy the board, so electrical isolation is important.

 

Microcontroller

 

Today’s microcontrollers are power-packed when you consider the current prices. For under $10 (for a clone, genuine products are about $30), a user gets an 8-bit, 16MHz, 32kB RAM mini-computer. While not super-fast, the requirements for a model railroad do not fall into the category of microsecond time sensitive.

The workhorse in the hobby industry is the Arduino microcontroller. There a three main types: Uno, Nano and Mega. They all work with the same processor, but the memory and number of input/output (IO) changes. The footprint also changes. The differences are:

These boards are referred to as development boards. For convenience, all the pins are traced out to the headers for easier development of prototypes. In addition, the development boards also contain power distribution, programmer chips, oscillator, communication interfaces, and LED indicators. More advanced users can use the bare microchip to save space on their printed circuit boards.

Genuine Arduino boards can get pricey, but they are open-sourced and have been cloned by many suppliers. The clones work equally well and save a lot of money.

A prime consideration in the selection of a microcontroller is the number of input/output (I/O) pins that are required for a project. As a project develops, it isn’t uncommon to run out of pins.

The best way to maximize the functionality of an Arduino is to use peripheral devices such as pin extenders, shift registers, and multiplexers to increase the number of available pins, and to optimize the programming.

The program, which we’ll go into detail later, is less than 10kB, which means that a single Nano could control up to 3 blocks. The Mega could process 24 blocks.

 

Part 3 — PCB build

 

The goal I had in mind was to create a system suitable to build a dispatcher’s board from.

As the schematic is developed, it’s advisable to create the circuit on a breadboard where it can be tested for function. A breadboard enables connecting various components to see if they do what’s intended. The figure below shows the prototype for this controller. Every component on the breadboard is transferred onto the PCB.

Part 4 — Arduino program

 

Arduino provides on its website a free download of their Integrated Development Environment (IDE) which is essentially an app that facilitates the programming.

This IDE uses the C++ program language. When the program is complete, the IDE compiles it to check for errors. If there are none, it’s ready to upload to the Arduino.

There are three major components of an Arduino sketch: the initialization of variables, the setup loop, and the main loop program. When executed, the sketch will run continually until it is powered down.

The Loop for this project has three main elements to control the block: Turnout position, LED signals, and push-button controls. The following table shows the handler routine for a train approaching at the EB sensor and contains all the logic given in Table 2. The information after the double slashes (//) are comments for clarity.

The code is activated, in this case, by the EB Approach sensor. A decision is made by the dispatcher whether this train will stay on the main or divert to the siding. Then, the EB ENTRY HANDLER ROUTINE is executed. Once the EB is in the block, a check is run to see if a WB has arrived. If so, it will be assigned to the other route by running the WB ENTRY HANDLER ROUTINE. Since priority is given to the main, the CLEAR MAIN routine is run next. Finally, the CLEAR SIDING routine clears the siding.

Table 5: Program snippet for the EB HANDLER ROUTE

There’s a similar block of code for the WB Approach.

As covered earlier, effective allocation of pins is a major consideration. There are too many LEDs to assign a pin to each signal. This is overcome using shift registers. These devices are serial to parallel converters in which data is supplied serially to the chip which converts it into parallel data. In this way, one data line controls eight LEDs.

Table 6: Signal LED output program snippet

Below is the code to release a train that was previously held on the siding.

Table 7: Program snippet to release hold train

If there are no trains near the block, the program constantly repeats the LOOP function. It’s waiting for a trigger to begin full execution. For us, the trigger is the detection of a train at either the EB or WB Approach sensor.

Imagine when there’s no road traffic: The program just blindly loops. However, it needs to know when something has happened, such as a train tripping one of the approach sensors. Execution of the code needs to begin instantly, but what happens if the code is in another part of the loop running other commands where it’s not watching the sensors.

This is what interrupt routines do. They wait for an extraordinary event which will disrupt the normal program flow so that the interrupt routine can be processed. In this case, the program would jump to the interrupt routine and process the approach, and from there jump back into the main program to execute the approach handler.

Table 8: Approach sensor detection function

These interrupts need to confirm whether an input at an approach sensor is truly a train coming into the block or if it a train leaving. There is an internal flag to indicate a train that is leaving the block.

A complete listing of the Arduino sketch is given in the Appendix.

 

Hot off the press

 

This article was written with the intent of the PCB acting as the control panel. It’s possible to add Wi-Fi functionality to an Arduino and use the Arduino to generate a webpage that can be viewed on a monitor. The push-button controls can be activated by mouse-clicking or pressing on a touchscreen.

The following is a sample page representing the Norsuth Junction via a webpage on a local internet connection.

This is further evidence of where technology can advance the enjoyment of the hobby.

My hope is that this story has invoked a sense of curiosity among the readers to the point they can see the potential applications for microcontrollers in model railroading. Personally, I have about 20 more projects using Arduino on my to-do list. More to come later.

The following is a complete listing of the code I have used.

 

Appendix: Arduino sketch

 

001 #include <Arduino.h>

002 #include <avr/sleep.h>

003

004 /*LED OUTPUT VARIABLES

005 ledSignals1 bits || 7=ebGreen,    6=ebRedMain,  5=ebYellow,     4=ebRedSiding,    3=wbGreen,  2=wbRedMain, 1=wbYellow, 0=wbRedSiding

006 ledSignals2 bits || 7=ebApproach, 6=wbAllroach, 5=mainOccupied, 4=sidingOccupied, 3=ebFouled, 2=wbFouled,  1=hold,     0=release

007 */

008 volatile byte ledSignals1 = 0b00000000;

009 volatile byte ledSignals2 = 0b00000000;

010

011 byte oldSignals2;

012

013 int delayTime = 3000;

014

015 int isHoldingPin = 2;

016 int switchWBposition = 3;

017 int switchWBpositionPin = 4;

018 int switchEBposition = 5;

019 int switchEBpositionPin = 6;

020 int dataPin = 7;

021 int ebSwitchApproachPin = 8;

022 int wbSwitchApproachPin = 9;

023 int latchPin = 10;

024 int clockPin = 11;

025 int killPin = 12;

026 int wbSwitchSignalPin = 14;

027 int wbSwitchMastPin = 15;

028 int wbSwitchDwarfPin = 16;

029 int ebSwitchSignalPin = 17;

030 int ebSwitchMastPin = 18;

031 int ebSwitchDwarfPin = 19;

032 int timerPin = A6;                                        //analog A6

033

034 volatile int ebSwitchPosition;

035 volatile int wbSwitchPosition;

036 volatile int holdState = 1;

037 int trackOption;

038 volatile int hasStarted = 0;

039 int holdDirection = 0;                                    //1 = EB | 2 = WB

040 volatile int ebSwitchApproach = 0;

041 volatile int wbSwitchApproach = 0;

042 volatile int ebSwitchSignal;

043 volatile int ebSwitchMast;

044 volatile int ebSwitchDwarf;

045 volatile int wbSwitchSignal;

046 volatile int wbSwitchMast;

047 volatile int wbSwitchDwarf;

048

049 int ebPosition;

050 int wbPosition;

051 unsigned long counter;

052 volatile int ebDeparted = 0;

053 volatile int wbDeparted = 0;

054 volatile int ebApproachSwitched = 0;

055 volatile int wbApproachSwitched = 0;

056 volatile int holdSwitched = 0;

057 volatile unsigned long i;

058

059 unsigned long startSleepTime;

060 volatile int isAsleep = 0;

061 int timerScale;

062

063 void setup() {

064     Serial.begin(115200);

065

066     pinMode (isHoldingPin, INPUT);

067     pinMode (switchEBposition, OUTPUT);

068     pinMode (switchEBpositionPin, INPUT);

069     pinMode (dataPin, OUTPUT);

070     pinMode (latchPin, OUTPUT);

071     pinMode (ebSwitchApproachPin, INPUT);

072     pinMode (wbSwitchApproachPin, INPUT);

073     pinMode (switchWBpositionPin, INPUT);

074     pinMode (switchWBposition, OUTPUT);

075     pinMode (clockPin, OUTPUT);

076     pinMode (ebSwitchSignalPin, INPUT);

077     pinMode (ebSwitchMastPin, INPUT);

078     pinMode (ebSwitchDwarfPin, INPUT);

079     pinMode (wbSwitchSignalPin, INPUT);

080     pinMode (wbSwitchMastPin, INPUT);

081     pinMode (wbSwitchDwarfPin, INPUT);

082     pinMode (killPin, OUTPUT);

083     pinMode (timerPin, INPUT);

084     /*

085     killPin feeds base of transistor to provide ground for PCB mounted LED; if LOW, all LED are OFF

086     */

087     digitalWrite (killPin, HIGH);

088

089     /*INTERRUPTS

090     INT0 detects pressing the hold pin, D2; also reconfigured as wakeup if system goes to sleep

091     INT1 not used

092     PCMSK0 calls ISR(PCINT0_vect) for approach triggers

093 094     PCMSK1 calls ISR(PCINT1_vect) for change in signal, mast or dwarf sensors

095     PCMSK2 calls ISR(PCINT2_vect) for change in turnout position

096     */

097     attachInterrupt (digitalPinToInterrupt(isHoldingPin), holdPressed, RISING);

098     PCICR  |= 0b00000111;

099     PCMSK0 |= 0b00000011;

100     PCMSK1 |= 0b00111111;

101     PCMSK2 |= 0b01010000;

102 }

103 void loop() {

104     /*

105     Adjustable timer to change the wait time between approach trigger and setting of turnout position

106     This is dispatcher’s reaction time to route the train

107     */

108     timerScale = map(analogRead(timerPin), 0, 1023, 2, 120);

109

110     interrupts();

111     hasStarted = 0;

112

113     //INITIALIZE ALL TRACKSIDE SIGNALS RED

114     ledSignals1 = 0b10101010;

115     outShift();

116

117     /*

118     SYSTEM WILL SLEEP IF THERE HAS BEEN NO MOVEMENT WITHIN DEFINED PERIOD

119     */

120     startSleepTime = millis();

121

122     /*

123     PROGRAM BEGINS EXECUTION WHEN AN APPROACH SENSOR HAS ACTIVATED OR IF THE RELEASE BUTTON IS PRESSED

124     PROGRAM STAYS IN WHILE LOOP UNTIL ACIVATED OR SLEEP TIMER ACTIVATED

125     */

126     while (ebSwitchApproach == 0 && wbSwitchApproach == 0 && hasStarted == 0 && holdState != 3) {

127         if (millis() – startSleepTime >= 30000) {

128             noInterrupts();

129             isAsleep = 1;

130             set_sleep_mode(SLEEP_MODE_PWR_DOWN);

131             PCICR = 0b00000000;

132             digitalWrite(killPin, LOW);

133             ledSignals1 = 0b00000000;

134             oldSignals2 = ledSignals2;

135             ledSignals2 = 0b00000000;

136             outShift();

137             delay(50);

138             sleep_enable();

139             attachInterrupt(digitalPinToInterrupt(isHoldingPin), wakeUp, FALLING);

140             interrupts();

141             delay(1000);

142             sleep_cpu();

143             /*

144             RETURN POINT AFTER WAKEUP

145             */

146             attachInterrupt(digitalPinToInterrupt(isHoldingPin), holdPressed, RISING);

147             digitalWrite(killPin, HIGH);

148             PCICR |= 0b00000111;

149             ledSignals1 = 0b10101010;

150             ledSignals2 = oldSignals2;

151             outShift();

152             startSleepTime = millis();

153             delay(50);

154         }

155         outShift();

156     }

157     //APPROACH LED BLINKS FOR TIME INTERVAL SET BY POTENTIOMETER (APPROX 1-60 SECOND)

158     for (counter = 1; counter <= timerScale; counter++) {

159       if (ebSwitchApproach == 1) {

160         ledSignals2 = ledSignals2 ^ 0b10000000;

161       }

162       else if (wbSwitchApproach == 1) {

163         ledSignals2 = ledSignals2 ^ 0b01000000;

164       }

165       outShift();

166       delay(500);

167     }

168     /*

169     hasStarted = 1 STARTS PROGRAM EXECUTION

170     trackOption = 1 IS EB TRIGGER

171     trackOption = 2 IS WB TRIGGER

172     trackOption = 3 IS EB RELEASE

173     */

174     hasStarted = 1;

175     if (hasStarted == 1) {

176       if (ebSwitchApproach == 1 && holdState != 3) {

177         trackOption = 1;

178       }

179       if (wbSwitchApproach == 1 && holdState != 3) {

180         trackOption = 2;

181       }

182       if (holdState == 3) {

183         trackOption = 3;

184       }

185

186       /*LOGIC BLOCKS TRACK WHERE TRAINS ARE

187       0 = no TRAIN | 1 = TRAIN ON MAIN | 2 = TRAIN ON SIDING

188       */

189       ebPosition = 0;

190       wbPosition = 0;

191

192       switch (trackOption) {

193

194         case 1:

195           /*

196           EB APPROACH TRIGGERED

197           EB ENTRY HANDLER ROUTINE

198           */

199           if (holdState == 2 && ebSwitchPosition == 1){

200             while (ebSwitchPosition == 1){

201               EBfouled();

202             }

203           }

204           if (ebSwitchPosition == 0) { //EB SWITCH SET TO MAIN

205               ebPosition = 1; // EB IS ON MAIN

206               greenRedEBsignal(); //GIVE GREEN TO ENTER MAIN, RESET TO RED WHEN REACH EBMAST

207           }

208           else if (ebSwitchPosition == 1 && holdState == 1) { //CHECKS IF SIDING IS ON HOLD

209               ebPosition = 2; //EB IS ON SIDING

210               holdDirection = 1; //FLAGS THE DIRECTION THE TRAIN WAS GOING WHEN PUT ON HOLD 1=EB 2=WB

211               redYellowEBsignal(); //EB ENTERS THE SIDING, SIGNALS RESET TO RED/RED WHEN REACHES EB DWARF

212           }

213           /*

214           WB ENTRY HANDLER ROUTINE (IF NECESSARY)

215           */

216           if (wbSwitchApproach == 1) { //CHECK FOR WB

217               while (wbSwitchPosition == ebSwitchPosition) { //IF SWITCHES ARE THE SAME, SWITCH IS FOULED

218                     WBfouled(); //FUNCTION TO BLINK LED, WAIT FOR SWITCH TO BE CHANGED

219               }

220               if (wbSwitchPosition == 0) { //WB SWITCH SET TO MAIN

221                   wbPosition = 1; //WB IS ON MAIN

222                   greenRedWBsignal(); //WAITS FOR WBMAST TO INDICATE TRAIN IS IN, THEN SETS RED/RED

223               }

224               else if (wbSwitchPosition == 1 && holdState == 1) { //WB SWITCH SET TO SIDING

225                   wbPosition = 2; //WB IS ON SIDING

226                   holdDirection = 2; //FLAGS THE DIRECTION THE TRAIN WAS GOING WHEN PUT ON HOLD 1=EB 2=WB

227                   redYellowWBsignal(); //WB ENTERS SIDING, SIGNALS SET TO RED/RED WHEN REACHES WBDWARF

228               }

229           }

230           /*

231           CLEAR MAIN HANDLER ROUTINE

232           */

233           if (ebPosition == 1) { //CLEAR EB ON MAIN

234               while (wbSwitchPosition == 1) { //CHANGE WB SWITCH POSITION TO MAIN

235                   WBfouled();

236               }

237               ebDeparted = 1;

238               greenRedEBmast(); //EB CLEARS MAIN, SIGNALS RESET TO RED/RED

239           }

240           if (wbPosition == 1) { //CLEAR WB ON MAIN

241               while (ebSwitchPosition == 1) { //CHANGE EB SWITCH POSITION TO MAIN

242                   EBfouled();

243               }

244               wbDeparted = 1;

245               greenRedWBmast(); //WB CLEARS MAIN, SIGNALS RESET TO RED/RED

246           }

247           /*

248           CLEAR SIDING AS LONG AS NO HOLD HANDLER ROUTINE (IF NECESSARY)

249           */

250           if (holdState == 1) { //CLEARS SIDING IF NOT ON HOLD

251               if (ebPosition == 2) { //CLEAR EB ON SIDING

252                   while (wbSwitchPosition == 0) { //CHANGE WB SWITCH POSITION TO SIDING

253                       WBfouled();

254                   }

255                   ebDeparted = 1;

256                   redYellowEBdwarf(); //EB CLEARS SIDING

257               }

258               else if (wbPosition == 2) { //CLEAR WB ON SIDING

259                   while (ebSwitchPosition == 0) { //CHANGE EB SWITCH POSITION TO SIDING

260                       EBfouled();

261                   }

262                   wbDeparted = 1;

263                   redYellowWBdwarf(); //WB CLEARS SIDING

264               }

265           }

266           ebSwitchApproach = 0;

267           wbSwitchApproach = 0;

268           ebApproachSwitched = 0;

269           wbApproachSwitched = 0;

270         break;

271

272         case 2:

273           /*

274           WB APPROACH TRIGGERED

275           WB ENTRY HANDLER ROUTINE

276           */

277             if (holdState == 2 && wbSwitchPosition == 1){

278               while (wbSwitchPosition == 1){

279                 WBfouled();

280               }

281             }

282             if (wbSwitchPosition == 0) { //WB SWITCH SET TO MAIN

283                 wbPosition = 1; //WB IS ON MAIN

284                 greenRedWBsignal(); //GIVE GREEN TO ENTER MAIN, RESET TO RED WHEN REACH WBMAST

285             }

286             else if (wbSwitchPosition == 1 && holdState == 1) { //CHECKS IF SIDING IS ON HOLD

287                 wbPosition = 2; //WB IS ON SIDING

288                 holdDirection = 2; //FLAGS THE DIRECTION THE TRAIN WAS GOING WHEN PUT ON HOLD 1=EB 2=WB

289                 redYellowWBsignal(); //WB ENTERS THE SIDING, SIGNALS RESET TO RED/RED WHEN REACHES WBDWARF

290             }

291           /*

292           //EB ENTRY HANDLER ROUTINE (IF NECESSARY)

293           */

294             if (ebSwitchApproach == 1) { //CHECK FOR EB

295                 while (ebSwitchPosition == wbSwitchPosition) { //IF SWITCHES ARE THE SAME, SWITCH IS FOULED

296                     EBfouled(); //FUNCTION TO BLINK LED, WAIT FOR SWITCH TO BE CHANGED

297                 }

298                 if (ebSwitchPosition == 0) { //EB SWITCH SET TO MAIN

299                     ebPosition = 1; //EB IS ON MAIN

300                     greenRedEBsignal(); //WAITS FOR EBMAST TO INDICATE TRAIN IS IN, THEN SETS RED/RED

301                 }

302                 else if (ebSwitchPosition == 1) { //EB SWITCH SET TO SIDING

303                     ebPosition = 2; //EB IS ON SIDING

304                     holdDirection = 1; //FLAGS THE DIRECTION THE TRAIN WAS GOING WHEN PUT ON HOLD 1=EB 2=WB

305                     redYellowEBsignal(); //EB ENTERS THE SIDING, SIGNALS RESET TO RED/RED WHEN REACHES EBDWARF

306                 }

307               }

308               /*

309               //CLEAR MAIN HANDLER ROUTINE

310               */

311               if (wbPosition == 1) { //CLEAR WB ON MAIN

312                   while (ebSwitchPosition == 1) { //CHANGE EB SWITCH POSITION TO MAIN

313                       EBfouled();

314                   }

315                   wbDeparted = 1;

316                   greenRedWBmast(); //WB CLEARS MAIN, SIGNALS RESET TO RED/RED

317               }

318               else if (ebPosition == 1) { //CLEAR EB ON MAIN

319                   while (wbSwitchPosition == 1) { //CHANGE WB POSITION TO MAIN

320                       WBfouled();

321                   }

322                   ebDeparted = 1;

323                   greenRedEBmast(); //EB CLEARS MAIN, SIGNALS RESET TO RED/RED

324               }

325               /*

326               //CLEAR SIDING AS LONG AS NO HOLD

327               */

328               if (holdState == 1) { //CLEARS SIDING IF NOT ON HOLD

329                 if (wbPosition == 2) { //CLEAR WB ON SIDING

330                     while (ebSwitchPosition == 0) { //CHANGE EB SWITCH POSITION TO SIDING

331                         EBfouled();

332                     }

333                   wbDeparted = 1;

334                   redYellowWBdwarf(); //WB CLEARS SIDING

335                 }

336                 else if (ebPosition == 2) { //CLEAR EB ON SIDING

337                     while (wbSwitchPosition == 0) { //CHANGE WB SWITCH POSITION TO SIDING

338                         WBfouled();

339                     }

340                   ebDeparted = 1;

341                   redYellowEBdwarf(); //EB CLEARS SIDING

342                 } //SIDING IS CLEARED

343               }

344               ebSwitchApproach = 0;

345               wbSwitchApproach = 0;

350               ebApproachSwitched = 0;

351               wbApproachSwitched = 0;

352         break;

353

354         case 3:  //RELEASE HOLD TRAIN

355           bitWrite(ledSignals2, 0, HIGH); //RELEASE LED

356           outShift();

357           if (bitRead(ledSignals2, 4 == 1)) { //SIDING IS OCCUPIED

358             if (holdDirection == 1) { //EB ON HOLD

359               if (wbSwitchApproach == 0) { //NO WB TRAIN APPROACHING

360                 while (wbSwitchPosition == 0) {

361                   WBfouled(); //SETS FOULED INDICATOR ON WB SWITCH

362                 }

363                 redYellowEB(); //EB PROCEEDS THROUGH WB SWITCH

364                 delay(delayTime / 4);

365                 while (wbSwitchSignal == 0) {

366                   delayMicroseconds(1); //EB CLEARS SIDING

367                 }

368                 ebDeparted = 1;

369                 ledSignals1 = 0b10101010; //EB SIGNALS SET TO RED/RED

370               }

371             }

372             if (holdDirection == 2) { //WB ON HOLD

373               if (ebSwitchApproach == 0) { //NO EB TRAIN APPROACHING

374                 while (ebSwitchPosition == 0) {

375                   EBfouled(); //SETS FOULED INDICATOR ON EB SWITCH

376                 }

377                 redYellowWB(); //WB PROCEEDS THROUGH EB SWITCH

378                 delay(delayTime / 4);

379                 while (ebSwitchSignal == 0) {

380                   delayMicroseconds(1); //WB CLEARS SIDING

381                 }

382                 wbDeparted = 1;

383                 ledSignals1 = 0b10101010; //WB SIGNALS SET TO RED/RED

384               }

385             }

386             bitWrite(ledSignals2, 4, !bitRead(ledSignals2, 4)); //RESET SIDING OCCUPIED LED

387             bitWrite(ledSignals2, 0, HIGH);

388             outShift();

389           }

390           holdState = 1; //RESET HOLDSTATE TO NORMAL

391           bitWrite(ledSignals2, 0, LOW);

392           outShift();

393           holdDirection = 0; //CLEAR HOLD FLAGS

394         break;

395       } //end switch case

396     } //END OF STARTED LOOP

397     bitWrite(ledSignals2, 7, LOW); //TURN OFF EBSWITCH APPROACH LED

398     bitWrite(ledSignals2, 6, LOW); //TURN OFF WBSWITCH APPROACH LED

399     outShift();

400 } //END OF MAIN LOOP

401

402 void outShift() {

403    digitalWrite(latchPin, LOW);

404    shiftOut(dataPin, clockPin, MSBFIRST, ledSignals2);

405    shiftOut(dataPin, clockPin, LSBFIRST, ledSignals1);

406    digitalWrite(latchPin, HIGH);

407 }

408 void mainOccupied() {

409   ledSignals2 = ledSignals2 ^ 0b00100000;

410   outShift();

411 }

412 void sidingOccupied() {

413   ledSignals2 = ledSignals2 ^ 0b00010000;

414   outShift();

415 }

416 ISR(PCINT2_vect) { //PCINT FOR TURNOUT SWITCH CONTROLS

417   if (digitalRead(switchEBpositionPin) == 1) { //HAS EB SWITCH BUTTON BEEN PRESSED

418     ebSwitchPosition = !ebSwitchPosition; //FLIP THE POSITION WITH !

419     digitalWrite(switchEBposition, ebSwitchPosition); //SENDS NEW VALUE TO THE MOTOR CONTROLS

420   }

421   if (digitalRead(switchWBpositionPin) == 1) { //HAS WB SWITCH BUTTON BEEN PRESSED

422     wbSwitchPosition = !wbSwitchPosition; //FLIP THE POSITION WITH !

423     digitalWrite(switchWBposition, wbSwitchPosition); //SENDS NEW VALUE TO THE MOTOR CONTROLS

424   }

425   digitalWrite (switchEBpositionPin, LOW); //RESET IF SET BY EBFOULED OR WBFOULED

426   digitalWrite (switchWBpositionPin, LOW);

427   outShift();

428 }

429 /*

430 PCINT TO READ INPUT SENSORS EXCEPT APPROACHES

431 VALUES ARE ASSIGNED TO VARIABLES FOR USE IN THE PROGRAM. VARIABLES ARE EFFECTIVELY RESET BY SUCCESSIVE

432 READS.

433 */

434 ISR(PCINT1_vect) { //

435   ebSwitchSignal = !digitalRead(ebSwitchSignalPin);

436   ebSwitchMast = !digitalRead(ebSwitchMastPin);

437   ebSwitchDwarf = !digitalRead(ebSwitchDwarfPin);

438   wbSwitchSignal = !digitalRead(wbSwitchSignalPin);

439   wbSwitchMast = !digitalRead(wbSwitchMastPin);

440   wbSwitchDwarf = !digitalRead(wbSwitchDwarfPin);

441   outShift();

442 }

443 /*

444 PCINT TO READ APPROACH VECTORS

445 APPROACH VECTORS ACTIVATE THE MAIN PROGRAM.

446 */

447 ISR(PCINT0_vect) {

448   if (!digitalRead(ebSwitchApproachPin)) { //EB BUTTON PRESSED

449    if (ebApproachSwitched == 0 && wbDeparted == 0) { //CHECKS IF SENSOR IS FOR A TRAIN ENTERING OR LEAVING 0 = ENTERING

450       ebSwitchApproach = 1; //VALUE ASSIGNED TO VARIABLE FOR USE IN PROGRAM

451       ebApproachSwitched = 1; //SETS TO 1 TO SKIP SECOND PASS

452       bitWrite(ledSignals2, 7, HIGH); //ACTIVATE BLOCK ON TURN ON APPROACH LED

453     }

454     if (wbDeparted == 1) { //WBDEPARTED SET TO 1 WHEN AN EB CLEARS THE BLOCK

455       ebSwitchApproach = 0; //CLEAR

456       wbDeparted = 0; //RESET BUT DO NOT INITIALIZE PROGRAM

457       bitWrite(ledSignals2, 7, LOW);  //LED OFF

458     }

459   }

460   if (!digitalRead(wbSwitchApproachPin)) { //WB BUTTON PRESSED

461     if (wbApproachSwitched == 0 && ebDeparted == 0) { //CHECKS IF SENSOR IS FOR A TRAIN ENTERING OR LEAVING 0 = ENTERING

462       wbSwitchApproach = 1; //VALUE ASSIGNED TO VARIABLE FOR USE IN PROGRAM

463       wbApproachSwitched = 1; //SETS TO 1 TO SKIP SECOND PASS

464       bitWrite(ledSignals2, 6, HIGH); //ACTIVATE BLOCK ON TURN ON APPROACH LED

465     }

466     if (ebDeparted == 1) { //WBDEPARTED SET TO 1 WHEN AN EB CLEARS THE BLOCK

467       wbSwitchApproach = 0; //CLEAR

468       ebDeparted = 0; //RESET BUT DO NOT INITIALIZE PROGRAM

469       bitWrite(ledSignals2, 6, LOW);  //LED OFF

470     }

471   }

472   outShift();

473 }

474 /*

475 INTERRUPT 2 REDEFINED IN LOOP TO CATCH WAKEUP

476 */

477 void wakeUp() {

478   if (isAsleep == 1) {

479     sleep_disable();

480     isAsleep = 0;

481   }

482 }

483 /*

484 INTERRUPT 2 HOLD BUTTON PRESSED WHILE AWAKE

485 holdState = 0 – NO TRAIN HELD ON SIDING

486 holdState = 1 – IF PRESSED BEFORE SIGNAL OR DWARF SENSOR, TRAIN WILL BE HELD

487 holdState = 2 – RELEASE TRAIN FROM SIDING WHEN CLEAR, RESET TO 0

488

489 holdState INCREMENTS EACH TIME PRESSED

490 */

491 void holdPressed() {

492   holdSwitched = 0;

493   if (holdSwitched == 0) {

494     holdState = holdState + 1;

495     if (holdState == 1) {

496       bitWrite(ledSignals2, 1, LOW);

497       bitWrite(ledSignals2, 0, LOW);

498     }

499     if (holdState == 2) {

500       bitWrite(ledSignals2, 1, HIGH);

501       bitWrite(ledSignals2, 0, LOW);

502     }

503     if (holdState == 3) {

504       bitWrite(ledSignals2, 1, LOW);

505       bitWrite(ledSignals2, 0, HIGH);

506     }

507     holdSwitched = 1;

508   }

509   outShift();

510 }

511 void greenRedEB() {

512   ledSignals1 = ledSignals1 ^ 0b00000011; //TOGGLES EB RED/GREEN

513   outShift();

514   delay(delayTime);

515 }

516 void greenRedWB() {

517   ledSignals1 = ledSignals1 ^ 0b00110000; //TOGGLES WB RED/GREEN

518   outShift();

519   delay(delayTime);

520 }

521 void redYellowEB() {

522   ledSignals1 = ledSignals1 ^ 0b00001100; //TOGGLES EB RED/YELLOW

523   outShift();

524   delay(delayTime);

525 }

526 void redYellowWB() {

527   ledSignals1 = ledSignals1 ^ 0b11000000; //TOGGLES EB RED/YELLOW

528   outShift();

529   delay(delayTime);

530 }

531 void EBfouled() {

532   ledSignals2 = ledSignals2 ^ 0b00001000; //TOGGLES (ledSignals2, 3);

533   outShift();

534   delay(delayTime / 16);

535   ledSignals2 = ledSignals2 ^ 0b00001000; // FORCES LED TO BE OFF EACH TIME FUNCTION CALLED

536   outShift();

537   delay(delayTime / 16);

538 }

539 void WBfouled() {

540   ledSignals2 = ledSignals2 ^ 0b00000100; //TOGGLES (ledSignals2, 3);

541   outShift();

542   delay(delayTime / 16);

543   ledSignals2 = ledSignals2 ^ 0b00000100; // FORCES LED TO BE OFF EACH TIME FUNCTION CALLED

544   outShift();

545   delay(delayTime / 16);

546 }

547 /*

548 TRACKSIDE LED CONTROLS

549 */

550 void greenRedEBsignal() {

551   greenRedEB();

552   while (ebSwitchSignal == 0  && ebSwitchMast == 0){

553     delayMicroseconds(1);

554   }

555   mainOccupied();

556   greenRedEB();

557 }

558 void greenRedEBmast() {

559   greenRedEB();

560   while (wbSwitchSignal == 0) {

561     delayMicroseconds(1);

562   }

563   mainOccupied();

564   greenRedEB();

565 }

566 void greenRedWBsignal() {

567   greenRedWB();

568   while (wbSwitchSignal == 0 && wbSwitchMast == 0) {

569     delayMicroseconds(1);

570   }

571   mainOccupied();

572   greenRedWB();

573 }

574 void greenRedWBmast() {

575   greenRedWB();

576   while (ebSwitchSignal == 0) {

577     delayMicroseconds(1);

578   }

579   mainOccupied();

580   greenRedWB();

581 }

582 void redYellowEBsignal() {

583   redYellowEB();

584   while (ebSwitchSignal == 0 && ebSwitchDwarf == 0) {

585     delayMicroseconds(1);

586   }

587   sidingOccupied();

588   redYellowEB();

589 }

590 void redYellowEBdwarf() {

591   redYellowEB();

592   while (wbSwitchSignal == 0) {

593     delayMicroseconds(1);

594   }

595   sidingOccupied();

596   redYellowEB();

597 }

598 void redYellowWBsignal() {

599   redYellowWB();

600   while (wbSwitchSignal == 0 && wbSwitchDwarf == 0) {

601     delayMicroseconds(1);

602   }

603   sidingOccupied();

604   redYellowWB();

605 }

606 void redYellowWBdwarf() {

607   redYellowWB();

608   while (ebSwitchSignal == 0) {

609     delayMicroseconds(1);

610   }

611   sidingOccupied();

612   redYellowWB();

613 }