In this project, an Arduino based Traffic Light Controller system is designed. It is a simple implementation of traffic lights system but can be extended to a real time system with programmable timings, pedestrian lighting etc.
Components
- Arduino UNO
- 1KΩ Resistor X 12
- Red LEDs X 4
- Yellow LEDs X 4
- Green LEDs X 4
- Connecting wires
- Prototyping board
- Power adapter
Component Description
Arduino UNO: The main part of the Traffic Light Controller is the controller itself. Arduino UNO will serve the purpose in this project to handle all the switching of the LEDs and controlling their timings.
LEDs: The LEDs used in the project are basic 5mm LEDs of Red, Yellow and Green colors. The maximum current that can be allowed through these LEDs (Red, Yellow and Green in particular) is 20mA. (Foe Blue LED, the maximum current can be up to 30mA).
Circuit Design
Since the project is a traffic light controller, the circuit consists of many LEDs (12 as a matter of fact) as we are implementing traffic lights at a 4 way intersection. The project is a simple representation of traffic light controller and hence no other extra components are used.
We need three LEDs of Red, Yellow and Green colors at each intersection. The intersection is divided in to four lanes: Lane1, Lane 2 Lane 3 and Lane 4.
All the LEDs are connected to the Arduino UNO’s digital I/O pins through respective current limiting resistors of 1KΩ.
All the connections are made as per the circuit diagram. The complete wiring diagram of the circuit is shown below
Working of the Traffic Light Controller Project
The real time traffic light controller is a complex piece of equipment which consists of power cabinet, main controller or processor, relays, control panel with switches or keys, communication ports etc.
In this project, a simple traffic light system for a 4 way intersection is implemented using Arduino UNO. Although it is not the ideal implementation for real life scenarios, it gives an idea of the process behind the traffic light control system
The aim of the project is to implement a simple traffic light controller using Arduino UNO, where the traffic is controlled in a pre-defined timing system. The working of the project is very simple and is explained below.
Consider the following gif image showing a loop of traffic light operations. The project is also implemented in the same manner.
In that, first the Lane 1 gets its Green light turned. Hence, in all the other Lanes, their corresponding Red lights are turned on. After a time delay of predefined time say 5 seconds, the Green light in the Lane 3 must be turned on and the Green light in the Lane 1 must be turned off.
As a warning indicator, the Yellow light in Lane 1 is tuned on indicating that the red light is about to light up. Similarly, the yellow light in the Lane 3 is also turned as an indication that the green light about to be turned on.
The yellow lights in Lanes 1 and 3 are turned for a small duration say 2 seconds after with the red light in the Lane 1 is turned on and green light in Lane 3 is also turned on.
The green light in Lane 3 is also turned on for a predefined time and the process moves forward to Lane 4 and finally Lane 2.
The system then loops back to Lane 1 where the process mentioned above will be repeated all over again.
Note: The project implemented here doesn’t include the pedestrian crossing and pedestrian signaling in to consideration.
Limitations
- The project is not suitable for actual implementation but just a demonstration of the process behind the system.
- Real time traffic light controller systems are generally run time programmable i.e. the operator (usually a policeman) can change the timings of each lane as per the intensity of the traffic in each lane.
- There will also be a provision for either manual operation or pre-programmed operation.
Applications
- A simple traffic light controller is implemented in this project with a real chance of expansion.
- An external memory can be interface with the main controller so that the timings are not fixed during its programming but rather can be programmed during operation.
- An efficient traffic light controller system will include a pedestrian signaling system.
Project Code
| int Lane1[] = {13,12,11}; // Lane 1 Red, Yellow and Green | |
| int Lane2[] = {10,9,8};// Lane 2 Red, Yellow and Green | |
| int Lane3[] = {7,6,5};// Lane 3 Red, Yellow and Green | |
| int Lane4[] = {4,3,2};// Lane 4 Red, Yellow and Green | |
| void setup() | |
| { | |
| for (int i = 0; i < 3; i++) | |
| { | |
| pinMode(Lane1[i], OUTPUT); | |
| pinMode(Lane2[i], OUTPUT); | |
| pinMode(Lane3[i], OUTPUT); | |
| pinMode(Lane4[i], OUTPUT); | |
| } | |
| for (int i = 0; i < 3; i++) | |
| { | |
| digitalWrite(Lane1[i], LOW); | |
| digitalWrite(Lane2[i], LOW); | |
| digitalWrite(Lane3[i], LOW); | |
| digitalWrite(Lane4[i], LOW); | |
| } | |
| } | |
| void loop() | |
| { | |
| digitalWrite(Lane1[2], HIGH); | |
| digitalWrite(Lane3[0], HIGH); | |
| digitalWrite(Lane4[0], HIGH); | |
| digitalWrite(Lane2[0], HIGH); | |
| delay(7000); | |
| digitalWrite(Lane1[2], LOW); | |
| digitalWrite(Lane3[0], LOW); | |
| digitalWrite(Lane1[1], HIGH); | |
| digitalWrite(Lane3[1], HIGH); | |
| delay(3000); | |
| digitalWrite(Lane1[1], LOW); | |
| digitalWrite(Lane3[1], LOW); | |
| digitalWrite(Lane1[0], HIGH); | |
| digitalWrite(Lane3[2], HIGH); | |
| delay(7000); | |
| digitalWrite(Lane3[2], LOW); | |
| digitalWrite(Lane4[0], LOW); | |
| digitalWrite(Lane3[1], HIGH); | |
| digitalWrite(Lane4[1], HIGH); | |
| delay(3000); | |
| digitalWrite(Lane3[1], LOW); | |
| digitalWrite(Lane4[1], LOW); | |
| digitalWrite(Lane3[0], HIGH); | |
| digitalWrite(Lane4[2], HIGH); | |
| delay(7000); | |
| digitalWrite(Lane4[2], LOW); | |
| digitalWrite(Lane2[0], LOW); | |
| digitalWrite(Lane4[1], HIGH); | |
| digitalWrite(Lane2[1], HIGH); | |
| delay(3000); | |
| digitalWrite(Lane4[1], LOW); | |
| digitalWrite(Lane2[1], LOW); | |
| digitalWrite(Lane4[0], HIGH); | |
| digitalWrite(Lane2[2], HIGH); | |
| delay(7000); | |
| digitalWrite(Lane1[0], LOW); | |
| digitalWrite(Lane2[2], LOW); | |
| digitalWrite(Lane1[1], HIGH); | |
| digitalWrite(Lane2[1], HIGH); | |
| delay(3000); | |
| digitalWrite(Lane2[1], LOW); | |
| digitalWrite(Lane1[1], LOW); | |
| } |
or
int r1 = 1;
int y1 = 2;
int g1 = 3;
int r2 = 4;
int y2 = 5;
int g2 = 6;
int r3 = 7;
int y3 = 8;
int g3 = 9;
int r4 = 10;
int y4 = 11;
int g4 = 12;
//Eng; ALI MEKAAL
void setup() {
pinMode (r1, OUTPUT);
pinMode (y1, OUTPUT);
pinMode (g1, OUTPUT);
pinMode (r2, OUTPUT);
pinMode (y2, OUTPUT);
pinMode (g2, OUTPUT);
pinMode (r3, OUTPUT);
pinMode (y3, OUTPUT);
pinMode (g3, OUTPUT);
pinMode (r4, OUTPUT);
pinMode (y4, OUTPUT);
pinMode (g4, OUTPUT);
//ALI KARKUKI
}
void loop() {
digitalWrite(g1, HIGH);
digitalWrite(r2, HIGH);
digitalWrite(r3, HIGH);
digitalWrite(r4, HIGH);
delay(9000);
digitalWrite(g1, LOW);
digitalWrite(r2, LOW);
digitalWrite(y1, HIGH);
digitalWrite(y2, HIGH);
delay(3000);
digitalWrite(y1, LOW);
digitalWrite(y2, LOW);
digitalWrite(r1, HIGH);
digitalWrite(g2, HIGH);
delay(9000);
digitalWrite(g2, LOW);
digitalWrite(r3, LOW);
digitalWrite(y2, HIGH);
digitalWrite(y3, HIGH);
delay(3000);
digitalWrite(y2, LOW);
digitalWrite(y3, LOW);
digitalWrite(r2, HIGH);
digitalWrite(g3, HIGH);
digitalWrite(r4, HIGH);
delay(9000);
digitalWrite(g3, LOW);
digitalWrite(r4, LOW);
//??? ???????
digitalWrite(y3, HIGH);
digitalWrite(y4, HIGH);
delay(3000);
digitalWrite(y3, LOW);
digitalWrite(y4, LOW);
digitalWrite(r3, HIGH);
digitalWrite(g4, HIGH);
delay(9000);
digitalWrite(r3, LOW);
digitalWrite(g4, LOW);
digitalWrite(r1, LOW);
digitalWrite(y1, HIGH);
digitalWrite(y4, HIGH);
delay(3000);
digitalWrite(y1, LOW);
digitalWrite(y4, LOW);
}
abiola.johnson@outlook.com
theyoungengineerzz@gmail.com
WhatsApp +234-8079593532