Arduino Traffic Light System

Want to build a real-world traffic light with your Arduino? Then this project is for you. In fact, you’ll create a full traffic sequence—red, yellow, and green—with a live countdown timer on a 7-segment display. Moreover, you’ll learn core electronics skills like digital output control, BCD decoding, and precise timing. Best of all, it uses only basic, affordable parts.

This guide walks you through every step: from parts list to wiring, code upload, and testing. Therefore, whether you’re a student, hobbyist, or teacher, you’ll finish with a working system that looks and acts like a real intersection light. So, let’s get started—safely and step by step.

Why Build an Arduino Traffic Light System with Countdown Timer?

This project is more than just blinking LEDs. First, it mimics actual traffic behavior—red means stop, green means go, and yellow warns of change. Second, it adds a 7-segment countdown, just like real crosswalk or signal timers. As a result, you get visual feedback that’s both educational and satisfying.

Additionally, you’ll learn how to use a 4511 BCD-to-7-segment decoder IC. This chip simplifies display control by converting binary numbers into readable digits. Consequently, you avoid complex wiring or extra code for segment control. Furthermore, the project teaches timing logic—critical for robotics, automation, and IoT.

Finally, it’s highly scalable. Once you master this, you can add pedestrian buttons, sensors, or even sync two intersections. So, this beginner project opens doors to advanced embedded systems.

Essential Components for Arduino Traffic Light Project

Gather these parts before you begin. First, you need an Arduino Uno or any compatible board. Second, get three LEDs: one red, one yellow, and one green. Third, prepare three current-limiting resistors—220Ω to 330Ω works well for standard 5V LEDs.

Next, you’ll need a common cathode 7-segment display. Make sure it’s common cathode—not common anode—because the 4511 IC only drives common cathode types. Then, add a 4511 BCD-to-7-segment decoder IC. This chip does the heavy lifting for the display.

Also, use a breadboard and jumper wires for clean, reusable connections. Finally, connect your Arduino to a computer with a standard USB cable for power and programming. Optionally, include a USB-to-Serial module if you’re using a custom board without built-in USB.

How to Wire the Arduino Traffic Light Circuit

Wiring is simple if you follow the pin plan. Start with the LEDs. Connect the red LED anode to Arduino pin 11 through a 220Ω resistor. Similarly, link the yellow LED to pin 12 and the green LED to pin 13—each with its own resistor. Then, join all LED cathodes to Arduino GND.

Now, wire the 4511 IC. Connect its BCD input pins—A, B, C, D—to Arduino digital pins 4, 5, 6, and 7 respectively. After that, link the 4511’s output pins (a through g) to the matching segments on your 7-segment display. Be sure to check the 4511 datasheet for exact pin mapping—ICs can vary by manufacturer.

Crucially, connect the common cathode pin of the 7-segment display directly to GND. Also, power the 4511 IC by linking its VCC to 5V and GND to ground. Double-check all connections before powering up. Otherwise, a wrong wire could damage the display or IC.

💡 Tip: Label your jumper wires with tape or use color coding. This prevents mix-ups between BCD lines and LED signals. In addition, test each LED individually before adding the display.

Arduino Code for Traffic Light with 7-Segment Countdown

The code controls both the light sequence and the countdown timer. It uses the 4511 IC to show numbers 0–9 on the display. Because the 4511 understands Binary Coded Decimal (BCD), the Arduino only sends 4 bits per number—making the code clean and efficient.

 #define RED 11 // Arduino pin for Red LED
#define YELLOW 12 // Arduino pin for Yellow LED
#define GREEN 13 // Arduino pin for Green LED

// Arduino pins for 4511 BCD inputs (A, B, C, D)
#define A 4
#define B 5
#define C 6
#define D 7

// Function to update the 7-segment display via 4511 IC
void updateCounter(int value) {
// Use bitwise operations to send BCD representation of 'value' to 4511 inputs
digitalWrite(A, value & 0x01); // LSB for A
digitalWrite(B, (value >> 1) & 0x01); // Bit 1 for B
digitalWrite(C, (value >> 2) & 0x01); // Bit 2 for C
digitalWrite(D, (value >> 3) & 0x01); // MSB for D
}

// Function to perform a countdown on the 7-segment display
void countdown(int startValue) {
for (int i = startValue; i >= 0; i--) {
updateCounter(i); // Display the current countdown value
delay(1000); // Wait for 1 second
}
}

void setup() {
// Set LED pins as OUTPUTs
pinMode(RED, OUTPUT);
pinMode(YELLOW, OUTPUT);
pinMode(GREEN, OUTPUT);

// Set 4511 IC input pins as OUTPUTs
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);

// Initial state: Red light is ON, start countdown
digitalWrite(RED, HIGH);
countdown(9); // Countdown from 9 seconds
}

void loop() {
// Red to Yellow Transition
digitalWrite(RED, LOW); // Turn Red OFF
digitalWrite(YELLOW, HIGH); // Turn Yellow ON
delay(2000); // Yellow light stays on for 2 seconds

// Yellow to Green Transition
digitalWrite(YELLOW, LOW); // Turn Yellow OFF
digitalWrite(GREEN, HIGH); // Turn Green ON
countdown(9); // Green light with 9-second countdown

// Green to Red Transition
digitalWrite(GREEN, LOW); // Turn Green OFF
digitalWrite(RED, HIGH); // Turn Red ON
countdown(9); // Red light with 9-second countdown
}

How the Arduino Traffic Light Code Works

Let’s break down the key parts. First, the #define statements assign clear names to pins. This makes the code easy to read and modify. For example, changing the red LED pin only requires updating one line.

Next, the updateCounter() function converts a number (0–9) into BCD. It uses bitwise operations: value & 0x01 gets the least significant bit for pin A, (value >> 1) & 0x01 gets the next bit for pin B, and so on. As a result, the 4511 IC receives the correct pattern to light the right segments.

Then, the countdown() function loops from a start value (like 9) down to 0. Each second, it calls updateCounter() and pauses with delay(1000). Therefore, the display updates once per second—just like a real traffic timer.

In setup(), all pins become outputs, and the red light turns on immediately with a 9-second countdown. In loop(), the sequence runs forever: red → yellow (2 sec) → green (with countdown) → red (with countdown). This creates a smooth, repeating cycle.

Step-by-Step Testing Guide for Your Traffic Light

After wiring and coding, test your system carefully. First, upload the code using the Arduino IDE. Make sure you select the correct board and port. Then, watch the LEDs and display closely.

The red LED should light up right away. At the same time, the 7-segment display must show “9” and count down to “0”. After that, the yellow LED turns on for exactly 2 seconds. Next, the green LED activates with another 9-second countdown. Finally, it returns to red—and repeats.

If something fails, troubleshoot step by step. For instance, if no LEDs light, check resistor placement and GND connections. If the display shows wrong digits, verify the 4511 pinout and segment wiring. Also, ensure the display is common cathode—common anode types won’t work with the 4511.

💡 Tip: Use the Serial Monitor to debug timing issues. Add Serial.begin(9600) in setup() and print messages like “Green phase started” in loop(). This helps confirm the code runs as expected.

Common Problems and Quick Fixes

Even simple projects face hiccups. For example, dim LEDs often mean resistor values are too high. Try 220Ω instead of 330Ω. Conversely, flickering may signal loose jumper wires—press them firmly into the breadboard.

Another issue: the 7-segment shows “8” all the time. This usually means the 4511 isn’t receiving BCD signals. Check that pins A–D are connected to Arduino outputs—not inputs. Also, confirm the IC has 5V power and GND.

What if the countdown skips numbers? Then the delay(1000) might be interrupted by other code. But in this project, the loop is simple—so this rarely happens. Still, avoid adding extra delays or sensor reads unless you use non-blocking timing later.

Finally, if the yellow light stays on too long or too short, adjust the delay(2000) value. Change it to delay(1500) for 1.5 seconds, or delay(3000) for 3 seconds—whatever matches your design goal.

How to Upgrade Your Arduino Traffic Light System

Once your base system works, expand it. First, add a button for pedestrian crossing. When pressed, it could extend the red light and trigger a “WALK” signal (using another LED or display).

Second, replace fixed delays with millis() for non-blocking code. This lets you add sensors or Bluetooth control without freezing the timer. For example, a light sensor could shorten green time at night.

Third, build a dual-direction system. Use two sets of lights and displays, and sync them so one direction is green while the other is red. This mimics real city intersections and teaches state machine logic.

Moreover, log data to an SD card or send it to a phone via Bluetooth. You could track how often the light cycles or detect faults. In this way, a simple project becomes a smart city prototype.

Why This Project Is Perfect for Beginners

This traffic light system uses only digital outputs—no analog reads, no libraries, no complex math. Therefore, it’s ideal for first-time Arduino users. You see immediate results, which builds confidence fast.

Additionally, every component has a clear role. LEDs show states, the display shows time, and the 4511 simplifies wiring. As a result, you learn without feeling overwhelmed. Teachers love it for classroom demos, and students enjoy the “real-world” feel.

Finally, it’s safe. Everything runs on 5V USB power—no high voltage or dangerous parts. So, kids, teens, and adults can all build it with minimal supervision.

Final Thoughts: Build, Learn, and Expand

This Arduino traffic light with countdown timer proves that powerful learning comes from simple circuits. You’ve controlled LEDs, decoded BCD, managed timing, and built a system that mirrors real infrastructure.

Now that it works, don’t stop. Modify the countdown length, add sound effects, or enclose it in a 3D-printed housing. Before long, you’ll design your own traffic controllers, smart signs, or interactive art.

So, gather your parts, follow the steps, and watch your Arduino bring order to the road—one light at a time.