There's nothing particularly unique or special about this circuit, although I haven't come across any toy traffic light design that uses signal towers. What I do like about this circuit is the fact that a single user interface--a momentary contact pushbutton--controls all the functions, and that I didn't have to include any indicator LED or buzzer and instead could use the lamps of the traffic light itself to provide feedback to the user.
Operation
There are three modes:
1. Flashing amber (0.8sec on, 0.8sec off)
2. Flashing red (0.8sec on, 0.8sec off)
3. Normal traffic light operation: green --> amber --> red (variable red/green on-time, amber on-time = 2sec)
Upon power up the traffic light starts in mode 1. Modes are selected by pressing the button momentarily.
The stop (red) and go (green) time is user selectable. This is accomplished by pressing and holding the button down (regardless of what mode the traffic light is in). 1.5 seconds after pressing the button all lights will be turned off indicating the green light is about to begin showing the amount of go/stop time. Three seconds after pressing the button the green light will go through sets of blinking. The number of flashes per set indicates the go/stop time:
| Number of flashes per set | Go/Stop time in seconds |
|---|---|
| 1 | 5 |
| 2 | 10 |
| 3 | 15 |
| 4 | 20 |
As with the modes keeping the button depressed will eternally cycle through the four sets. To choose a go/stop time the user releases the button after the particular set of flashes has occured. So letting go of the button after the set of three flashes of the green light will set the go time and stop time to 15 seconds. The selected go/stop time is stored in EEPROM so the circuit doesn't forget even when powered down. Once the button is released the traffic light goes into mode 3 and begins with the yield (amber) light on.
Hardware
I originally planned to use the PIC12615 which is more than adequate. Unfortunately I need EEPROM which the 615 lacks. The only 8-pin PIC with EEPROM that I have right now is the 12F1822 and so that's what I ended up using for the MCU.
The circuit has a polarity reversal protection in the form of a 1N5822 Scottky diode (D1 in the schematic) which has a rated capacity of 3A. Although the wall wart has a no-load measured output of 16VDC, this drops to around 12V when any of the lamps is on. Each of the power transistors also has a voltage drop across their collector-emitter. So to minimize further dip in voltage across the the incandescents I opted to use a Schottky instead of an ordinary rectifier. I've used the TIP102 NPN Darlington since as I reported in the Darlington transistor test, the 102 has the least collector-emitter voltage in the three types I was able to get hold of and play around with. As stated in that test using this very same signal tower, the power dissipation in the Darlingtons is such that heatsinks can be dispensed with.
One of my concerns is that the children will knock this thing over and break it. So I cut out a sponge in the shape of circle with a diameter one and a half times larger than the signal tower. I can just glue it on top of the tower. It'll definitely break any falls and save the polystyrene or acrylic lenses from cracking and breaking. But the sponge solution is ugly to state it mildly. So I might instead superglue something akin to an O-ring around the sides of top cap of the tower. Not as elastic and shock absorbing as the sponge but it's still better than nothing at all. Another is option would be a quarter inch PVC or rubber tubing.
Firmware
I simply adapted the firmware I used for the 4-way traffic light I built the kids last year. This signal tower version is actually a lot simplier--no charlieplexing necessary. I opted to just clock the MCU using its default power-on frequency of 500kHz. Only one timer is used. I can no longer remember why I chose timer2 instead of timer0. For expediency's sake I didn't bother changing what ain't broken. A state machine is used with a timer tick of 4ms. In the configuration word, watchdog timer, power up timer, brownout reset, stack over/underflow reset are all enabled. All other options are disabled. Internal oscillator is used with I/O function on all pins.
/*
Kids' Traffic Light Using a Signal Tower
Created: January 10 2012
Processor: PIC 12F1822
Compiler mikroC Pro 5.0.0
* Uses a 12VDC wall wart as power supply
* Tower light 12VDC red, amber, green incandescent lamps are switched by NPN Darlington transistors
* pushbutton:
* when momentarily pressed: cycles through different possible modes:
1. normal traffic light: green -> amber -> red
2. flashing amber
3. flashing red
* when pressed and kept depressed for over a couple of seconds: cycles through different green/red light on time:
1. 5sec
2. 10sec
3. 15sec
4. 20sec.
* green/red light on time is stored in EEPROM
--------------------------+--------------------------------------
No. of green flashes/set | Green/red light on time in seconds
--------------------------+--------------------------------------
1 | 5
2 | 10
3 | 15
4 | 20
--------------------------+--------------------------------------
*/
// ************************************************************************************************
// input / output
// ************************************************************************************************
#define lred LATA.f0 // NPN darlington switches 12VDC incandescent lamp
#define lamber LATA.f1 // NPN darlington switches 12VDC incandescent lamp
#define lgreen LATA.f2 // NPN darlington switches 12VDC incandescent lamp
#define tris_red TRISA.f0
#define tris_amber TRISA.f1
#define tris_green TRISA.f2
#define pb PORTA.f3 // momentary contact push button
#define tris_pb TRISA.f3
#define wpullup 0b111000 // for WPUA -- enable pull ups on pb and unused pins
// ************************************************************************************************
// for traffic light
// ************************************************************************************************
#define ambertime 500 // in normal mode -- amount of time for amber light to be on after green and before red -- time in terms of timer2 ticks
#define flashambertime 200 // in flashing amber mode -- amount of time for amber light to be on and amount of time to be off -- time in terms of timer2 ticks
#define flashredtime 200 // in flashing red mode -- amount of time for red light to be on and amount of time to be off -- time in terms of timer2 ticks
#define flashgreentime 50 // during selection of green/red light on time -- amount of time for green light to be on and amount of time to be off when it is flashing -- time in terms of timer2 ticks
#define changergtime 750 // minimum amount of time for button to be kept pressed before cycling through the green light on time -- time in terms of timer2 ticks
// given 4ms timer2 tick, changergtime of 250 = 1sec real time
#define prechangergtime changergtime - 375 // amount of time after button is held down when all lights are turned off in preparation for possible change of green/red light on time
#define rgtime_increm 1250 // amount of time for green/red light to be on, and multiples thereof upon continual button press -- value in terms of timer2 ticks.
#define maxgtime 4 // maximum allowed multiple of rgtime_increm
int16 REDGREENTIME; // amount of time for green/red light to be on -- time in terms of timer2 ticks
int8 RGTIME; // multiples of rgtime_increm such that RGTIME*rgtime_increm = REDGREENTIME
// ************************************************************************************************
// eeprom
// ************************************************************************************************
#define addr_rgtime 0x10 // eeprom address for user selected green/red light on time
// ************************************************************************************************
// for pushbutton
// ************************************************************************************************
#define rising 1 // rising edge detected. used by PBedge
#define released 1 // rising edge detected. used by PBedge
#define falling 2 // falling edge detected. used by PBedge
#define pressed 2 // falling edge detected. used by PBedge
#define none 0 // no edge. used by PBedge
int8 PBval; // last eight values of the switch upon reading it
int8 PBedge; // edge detected?, 0 = no edge detect, 1 = rising edge, 2 = falling edge; other values = Not Used / Undefined for now
bit PBlevel; // voltage level of switch when not bouncing (hi = 1, lo = 0)
// ************************************************************************************************
// general defines and variables
// ************************************************************************************************
#define int1 bit
#define int8 unsigned char
#define int16 unsigned int
#define int32 unsigned long
#define on 1
#define off 0
#define _on 0
#define _off 1
#define yes 1
#define no 0
#define input 1 // for TRISx
#define output 0 // for TRISx
#define analog 1 // for ANSELx
#define digital 0 // for ANSELx
#define hi 1 // switch level high
#define lo 0 // switch level low
int16 TIME = 0; // records how long a light has been on -- in terms of timer2 ticks
// ************************************************************************************************
// for state machines
// ************************************************************************************************
enum {_normal, _flashingamber, _flashingred, _flashgreen, _standby} STATEMODE = _flashingamber;
enum {_go, _yield, _stop} STATENORMAL = _stop;
enum {_init, _flash} STATEFLASHGREEN = _init;
// ===========================================================================================
// functions
// ===========================================================================================
void ComputeRedGreenTime()
{
REDGREENTIME = RGTIME*rgtime_increm;
}
void IniReg()
{
TRISA = input;
ANSELA = digital;
tris_red = output;
tris_amber = output;
tris_green = output;
// enable weak pull up for pushbutton and unused pins
OPTION_REG.NOT_WPUEN = 0;
WPUA = wpullup;
// default clock frequency is 500kHz upon power up.
// Timer2 is used for state machine and switch debouncing timing tick
// with clock = 500kHz, PR2 = 125, prescale = 1:4, postscale = 1:1
// TMR2 will count from zero to PR2 and timer2 interrupt occurs every 125*4 / (500kHz / 4) = 4ms = timer2 tick
T2CON = 0b101; // postscaler = 1:1, prescaler = 1:4, timer2 on
TMR2 = 0;
PR2 = 125;
WDTCON = 0b1000; // prescale = 1:512 (16ms typical)
// WDTE in configuration word is configured so that WDT enabled when MCU awake and disabled when MCU asleep
// retrieve stored green/red light on time value.
// If eeprom-stored value is out of valid range then set it to minimum and store this value in eeprom
// stored values are in terms of multiples of rgtime_increm such that stored value multiplied by rgtime_increm = time in terms of TMR2 ticks
RGTIME = EEPROM_Read(addr_rgtime);
if (RGTIME == 0 || RGTIME > maxgtime)
{
RGTIME = 1;
EEPROM_Write(addr_rgtime, RGTIME);
}
ComputeRedGreenTime(); //REDGREENTIME = RGTIME*rgtime_increm;
// initialize push button
PBval = 0xFF;
PBlevel = hi;
} // void InitRegisters()
// normal traffic light operation: green --> amber --> red
// red/green light on time is user selectable
void Normal()
{
switch (STATENORMAL)
{
case _go:
if (++TIME < REDGREENTIME)
lgreen = on;
else
{
STATENORMAL = _yield;
TIME = 0;
lgreen = off;
}
break;
case _yield:
if (++TIME < ambertime)
lamber = on;
else
{
STATENORMAL = _stop;
TIME = 0;
lamber = off;
}
break;
case _stop:
if (++TIME < REDGREENTIME)
lred = on;
else
{
STATENORMAL = _go;
TIME = 0;
lred = off;
}
break;
default:
TIME = 0;
STATENORMAL = _yield;
} // switch (STATENORMAL)
} // void StateMachNormal()
// amber flashes on and off
void FlashingAmber()
{
static bit flag;
if (++TIME < flashambertime)
{
if (flag)
lamber = on;
else
lamber = off;
}
else
{
if (flag)
flag = 0;
else
flag = 1;
TIME = 0;
}
} // void FlashingAmber()
// red flashes on and off
void FlashingRed()
{
static bit flag;
if (++TIME < flashredtime)
{
if (flag)
lred = on;
else
lred = off;
}
else
{
if (flag)
flag = 0;
else
flag = 1;
TIME = 0;
}
} // void FlashingRed()
// when user selects red/green light on time the green light is flashed 1,2,3,or 4 times
// to indicate 5, 10, 15, 20sec of on time
void FlashGreen()
{
static int8 i, CYCLES;
static bit flag;
switch (STATEFLASHGREEN)
{
case _init:
i = 0;
flag = 1;
TIME = 0;
CYCLES = RGTIME*2-1;
STATEFLASHGREEN = _flash;
break;
case _flash:
if (++TIME < flashgreentime)
{
if (flag)
lgreen = on;
else
lgreen = off;
}
else
{
if (flag)
flag = 0;
else
flag = 1;
TIME = 0;
if (++i >= CYCLES)
{
lgreen = off;
STATEMODE = _standby;
}
}
break;
} // switch (STATEFLASHGREEN)
} // void FlashGreen()
void StateMachMain()
{
switch (STATEMODE)
{
case _normal:
Normal();
break;
case _flashingamber:
FlashingAmber();
break;
case _flashingred:
FlashingRed();
break;
case _flashgreen: // green light is flashed to indicate to user the length of time green/red light are on during normal mode
FlashGreen();
break;
case _standby: // do nothing mode where all lights are off. used when changing green on time
break;
default:
STATEMODE = _normal;
}
} // void StateMachMain()
void AllLightsOff()
{
lred = off;
lamber = off;
lgreen = off;
}
void DebounceSwitch()
{
// shift all bits to the left
// if switch reading is hi then let pb_val bit 0 = 1
PBval <<= 1;
if (pb)
++PBval;
PBedge = none;
// if level is lo and all bits of pb_val are now hi then
// a rising edge has been detected
// switch is considered just released when rising edge is detected
// switch level is now hi
if ((!PBlevel) && (PBval == 0xFF))
{
PBlevel = hi;
PBedge = rising;
}
// if level is hi and all bits of pb_val are now low then
// a falling edge has been detected
// switch is considered just pressed when falling edge is detected
// switch level is now lo
if ((PBlevel) && (!PBval))
{
PBlevel = lo;
PBedge = falling;
}
} // void DebounceSwitch()
void ProcessKey()
{
int8 MODE; // temporary storage of current STATEMODE
static int16 PBPRESSTIMETOTAL = 0; // Keeps track of how long PB is depreesed in terms of timer2 ticks
// Keeps track of total time from falling edge (switched pressed) to rising edge (switch released).
// if less than changergtime then we know the keypress is momentary and is meant to cycle through the various traffic light modes
static int16 PBPRESSTIME = 0; // Keeps track of how long PB is depreesed in terms of timer2 ticks
// this variable is reset every time it exceeds changergtime
// every time it exceeds changergtime green on time is incremented
DebounceSwitch();
MODE = STATEMODE;
if (PBlevel == lo)
{
if (++PBPRESSTIMETOTAL == prechangergtime)
{
AllLightsOff();
STATEMODE = _standby;
}
if (++PBPRESSTIME >= changergtime)
{
PBPRESSTIME = 0;
if (++RGTIME > maxgtime)
RGTIME = 1;
EEPROM_Write(addr_rgtime, RGTIME);
ComputeRedGreenTime(); //REDGREENTIME = RGTIME*rgtime_increm;
STATEMODE = _flashgreen;
STATEFLASHGREEN = _init;
} // if (++PBPRESSTIME >= changergtime)
} // if (PBlevel == lo)
if (PBedge == released)
{
if (PBPRESSTIMETOTAL < changergtime)
{
switch (MODE)
{
case _flashingred:
STATEMODE = _normal;
STATENORMAL = _yield;
break;
case _normal:
STATEMODE = _flashingamber;
break;
case _flashingamber:
STATEMODE = _flashingred;
break;
default:
STATEMODE = _normal;
} // switch (MODE)
} // if (PBPRESSTIMETOTAL < changergtime)
else // green/red light on time has been changed so go to normal traffic light mode and begin with amber light
{
STATEMODE = _normal;
STATENORMAL = _yield;
}
AllLightsOff();
TIME = 0; // reset timer so that whatever mode has been selected, light will go through full time allotted
PBPRESSTIMETOTAL = 0;
PBPRESSTIME = 0;
} // if (PBedge == released)
} // void ProcessKey()
void main()
{
IniReg();
while(1)
{
if (PIR1.TMR2IF)
{
PIR1.TMR2IF = 0;
asm{clrwdt}
ProcessKey();
StateMachMain();
} // if (PIR1.TMR2IF)
} // while(1)
} // void main()
----
10am Addendum:
I knocked the tower over a couple of times. From the sound of the thud it still doesn't match the exceptional shock absorbing properties of the sponge but this will have to do. It certainly beats having no bumpers at all.
