🚦 Multi-Way Traffic Light Control Tutorial

Introduction

This tutorial extends the basic single traffic light example to handle two-way and three-way intersections. We'll explore the logic, safety considerations, and implementation strategies for realistic traffic control systems using Raspberry Pi and Python.

Safety First: The Golden Rule

UK Traffic Light Sequence

Two-Way Traffic Lights

Scenario: Simple Crossroads

Imagine a simple crossroads where:

• Direction A: North-South traffic
• Direction B: East-West traffic

The Logic

At any given time:

• If A is green, B must be red
• If B is green, A must be red
• There's a transition period where both are red (for safety)

State Diagram

Key Concepts

Code Example: Simple Approach

from gpiozero import TrafficLights
from time import sleep

lights_a = TrafficLights(2, 3, 4)    # North-South
lights_b = TrafficLights(17, 27, 22) # East-West

while True:
    # Direction A gets priority
    lights_a.red.on()
    lights_a.amber.on()
    lights_b.red.on()
    sleep(2)
    
    lights_a.green.on()
    lights_a.red.off()
    lights_a.amber.off()
    sleep(10)
    
    lights_a.amber.on()
    lights_a.green.off()
    sleep(3)
    
    lights_a.red.on()
    lights_a.amber.off()
    sleep(2)  # Safety buffer
    
    # Direction B gets priority
    lights_b.red.on()
    lights_b.amber.on()
    sleep(2)
    
    lights_b.green.on()
    lights_b.red.off()
    lights_b.amber.off()
    sleep(10)
    
    lights_b.amber.on()
    lights_b.green.off()
    sleep(3)
    
    lights_b.red.on()
    lights_b.amber.off()
    sleep(2)  # Safety buffer

Three-Way Traffic Lights

Scenario: T-Junction

Consider a T-junction with:

• Direction A: Main road (straight through)
• Direction B: Main road (opposite direction)
• Direction C: Side road (joining the main road)

Strategy 1: Paired Operation

A and B operate together (they're on the same road) vs C operating independently. This creates a two-way system: (A+B) vs C

Strategy 2: Sequential Operation

Each direction gets its own green phase. Order: A → B → C → repeat. More complex but potentially more efficient for specific junction layouts.

Circuit Setup

GPIO Pin Allocation

Component Requirements

Current Draw Calculation

Each LED draws approximately 20mA through a 330Ω resistor:

• Two-way system: 6 LEDs max = 120mA (safe)
• Three-way system: 9 LEDs max = 180mA (safe)

The Raspberry Pi can safely source up to 50mA per GPIO pin and approximately 500mA total, so these configurations are well within limits.

Programming Approaches

1. Sequential State Machine

Define each state explicitly and transition between them.

2. Generator Functions

Use Python generators to yield light states, leveraging gpiozero's source parameter.

def direction_a_sequence():
    while True:
        yield (1, 1, 0)  # red+amber
        sleep(2)
        yield (0, 0, 1)  # green
        sleep(10)
        yield (0, 1, 0)  # amber
        sleep(3)
        yield (1, 0, 0)  # red
        sleep(15)

lights_a.source = direction_a_sequence()

3. Object-Oriented Design

Create a traffic light controller class with methods for each phase.

Project Files

Suggested Learning Path

1. Read the README.md and this HTML tutorial
2. Run traffic_simulator.py to see the logic in action (no hardware needed!)
3. Build your circuit following the GPIO pin allocation
4. Start with two_way_traffic_simple.py
5. Try the generator approach with two_way_traffic_generator.py
6. Extend to three-way with three_way_traffic_paired.py
7. Explore sequential logic with three_way_traffic_sequential.py
8. Study the professional approach in traffic_oo_controller.py

Challenges & Extensions

Once you've mastered the basics, try these extensions:

Testing & Debugging

Safety Checklist

Common Issues

LEDs Not Lighting

• Check LED polarity (flat side = cathode/negative)
• Verify GPIO pin numbers (BCM mode)
• Test individual LEDs with simple on/off code
• Check resistor connections

Incorrect Sequence

• Add print statements to track state changes
• Run the simulator first to verify logic
• Check timing constants
• Verify all sleep() calls are in correct order

Lights Flickering

• Ensure proper power supply to Raspberry Pi
• Check for loose connections
• Verify GPIO pins aren't being shared