C++ Projects: Basic Traffic Management System

A traffic management system simulates traffic flow, manages signals, and ensures smooth operations.

Components:

• Signals: Control vehicle flow at intersections.
• Vehicles: Simulate traffic movement.
• Logic of Intersection: Manages signal timing and crossing safety.
• Simulation: Displays real-time traffic flow.

Tools Used:

• Classes: For modeling signals and vehicles.
• Functions: For controlling traffic flow.

System Design

TrafficLight Class

Manages signals with three states: RED, YELLOW, and GREEN.

Code:

#include <iostream>
#include <string>

enum LightState { RED, YELLOW, GREEN };

class TrafficLight {
    LightState state;
    int timer;
public:
    TrafficLight() : state(RED), timer(10) {}
    
    void changeState() {
        if (state == RED) {
            state = GREEN;
            timer = 15;
        } else if (state == GREEN) {
            state = YELLOW;
            timer = 5;
        } else {
            state = RED;
            timer = 10;
        }
    }
    
    void tick() { timer--; }
    bool isTimeUp() const { return timer <= 0; }
    std::string getState() const {
        switch (state) {
            case RED: return "RED";
            case YELLOW: return "YELLOW";
            case GREEN: return "GREEN";
        }
        return "";
    }
};

Intersection Class

Manages multiple traffic lights and coordinates them.

Code:

class Intersection {
    TrafficLight northSouth;
    TrafficLight eastWest;
public:
    Intersection() {}
    
    void update() {
        if (northSouth.isTimeUp()) {
            northSouth.changeState();
        } else {
            northSouth.tick();
        }
        
        if (eastWest.isTimeUp()) {
            eastWest.changeState();
        } else {
            eastWest.tick();
        }
    }
    
    void display() const {
        std::cout << "North-South Light: " << northSouth.getState() << std::endl;
        std::cout << "East-West Light: " << eastWest.getState() << std::endl;
    }
};

Vehicle Class

Represents vehicles approaching an intersection.

Code:

class Vehicle {
    std::string direction;
public:
    Vehicle(const std::string &dir) : direction(dir) {}
    void move(const std::string &lightState) {
        if (lightState == "GREEN") {
            std::cout << "Vehicle moving " << direction << " through intersection." << std::endl;
        } else {
            std::cout << "Vehicle waiting at " << direction << " signal." << std::endl;
        }
    }
};

Simulation Logic

The main() function runs the simulation, updates the system, and displays state changes.

Code:

#include <vector>
#include <thread>
#include <chrono>

int main() {
    Intersection intersection;
    std::vector<Vehicle> vehicles = { Vehicle("North"), Vehicle("South"), Vehicle("East"), Vehicle("West") };

    for (int t = 0; t < 30; t++) {
        std::cout << "Time: " << t << " seconds" << std::endl;
        intersection.update();
        intersection.display();
        
        for (auto &vehicle : vehicles) {
            if (vehicle.direction == "North" || vehicle.direction == "South") {
                vehicle.move(intersection.getEastWestState());
            } else {
                vehicle.move(intersection.getNorthSouthState());
            }
        }
        
        std::cout << "--------------------------------" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    return 0;
}

Real-World Applications

SCOOT (Split Cycle Offset Optimization Technique)

• Used in cities like Los Angeles and London.
• Adjusts signal timing based on real-time vehicle queue detection.
• Code Connection: TrafficLight::changeState() can be modified to adjust timing dynamically based on sensor input.

Singapore’s GLIDE System

• Central coordination of traffic lights using pre-programmed schedules.
• Code Connection: Extend Intersection to include different time profiles (e.g., morning peak, off-peak).

Autonomous Vehicle Coordination (Google, Tesla)

• Self-driving cars adjust speed based on upcoming signals.
• Code Connection: Implement Vehicle::adjustSpeed() to optimize movement based on TrafficLight::getTimer().

Case Studies

1. Pittsburgh's Surtrac AI Traffic System

• Challenge: Static timers caused congestion.
• Solution: AI optimizes signal cycles based on real-time data.
• Code Connection: Modify Intersection::update() to accept live traffic data.

2. Jakarta's Traffic Gridlock

• Challenge: Poor synchronization led to cascading traffic jams.
• Solution: Implement "Green Wave" coordination.
• Code Connection: Add Intersection::syncWithNeighbor() for neighboring intersections.

3. Munich's Emergency Vehicle Priority System

• Challenge: Emergency vehicles delayed at red lights.
• Solution: RFID triggers automatic green signals.
• Code Connection: Implement TrafficLight::overrideState() based on emergency vehicle input.

Problem-Solving Approaches

Intersection Deadlock

• Challenge: Conflicting green signals cause collisions.
• Solution: Implement a 1.5-2 second all-red buffer.
• Code:

void TrafficLight::changeState() {
    state = YELLOW;
    timer = 2;  // All-red buffer before state transition
}

Handling Emergency Vehicles

• Challenge: Emergency vehicles stuck at red lights.
• Solution: Introduce priority flags for forced green signals.
• Code:

void Intersection::forceGreenForDirection(const std::string& dir) {
    if (dir == "North-South") northSouth.setState(GREEN);
    else eastWest.setState(GREEN);
}

Dynamic Traffic Flow Control

• Challenge: Fixed timers fail during traffic spikes.
• Solution: Use machine learning to predict congestion.
• Code:

void TrafficLight::adjustTimer(int congestionLevel) {
    timer = (congestionLevel > 5) ? 20 : 10;
}

Conclusion

Traffic management is crucial in modern cities, and C++ provides a robust way to simulate and improve traffic flow using dynamic logic, AI, and real-world integration.