以下是使用Python实现红绿灯控制的示例代码，结合了线程和事件控制，模拟了基础的红绿灯交替逻辑：

一、基础红绿灯控制（单信号灯）

import threading
import time

# 定义红绿灯状态常量
RED = 0
GREEN = 1
YELLOW = 2

# 灯光持续时间（秒）
RED_TIME = 5
GREEN_TIME = 10
YELLOW_TIME = 2

# 事件控制
event = threading.Event()

def traffic_light_control():
    state = GREEN  # 初始状态为绿灯
    while True:
        if state == RED:
            print("\033[41m红灯亮起，禁止通行！\033[0m")
            time.sleep(RED_TIME)
            state = GREEN
        elif state == GREEN:
            print("\033[42m绿灯亮起，可以通行！\033[0m")
            time.sleep(GREEN_TIME)
            state = YELLOW
        elif state == YELLOW:
            print("\033[43m黄灯亮起，准备停止！\033[0m")
            time.sleep(YELLOW_TIME)
            state = RED
        event.set()  # 重置事件

def main():
    light_thread = threading.Thread(target=traffic_light_control)
    light_thread.start()
    light_thread.join()  # 阻塞主线程

if __name__ == "__main__":
    main()

二、多信号灯控制（独立方向）

import threading
import time

# 定义信号灯状态常量
RED = 0
GREEN = 1
YELLOW = 2

# 灯光持续时间（秒）
RED_TIME = 5
GREEN_TIME = 10
YELLOW_TIME = 2

# 信号灯字典
signals = {
    '北': GREEN,
    '南': RED,
    '东': GREEN,
    '西': RED
}

# 锁机制
lock = threading.Lock()

def traffic_light_control(direction):
    while True:
        with lock:
            state = signals[direction]
            print(f"\033[41m{direction}方向：{get_light_color(state)}\033[0m")
            time.sleep(RED_TIME if state == RED else GREEN_TIME)
            signals[direction] = YELLOW if state == GREEN else (RED if state == YELLOW else GREEN)
        lock.release()

def get_light_color(state):
    if state == RED:
        return "红色"
    elif state == GREEN:
        return "绿色"
    elif state == YELLOW:
        return "黄色"

def main():
    directions = ['北', '南', '东', '西']
    threads = []
    for direction in directions:
        thread = threading.Thread(target=traffic_light_control, args=(direction,))
        thread.start()
        threads.append(thread)
    for thread in threads:
        thread.join()

if __name__ == "__main__":
    main()

三、智能交通灯控制（车流量调节）

import threading
import time

# 定义信号灯状态常量
RED = 0
GREEN = 1
YELLOW = 2

# 灯光持续时间（秒）
GREEN_TIME = 30
RED_TIME = 30
YELLOW_TIME = 5

# 模拟车流量
car_flow = 100  # 单位：辆/秒

def traffic_light_control(traffic_flow):
    while True:
        if traffic_flow > 100:
            GREEN_TIME = 60
            RED_TIME = 30
        else:
            GREEN_TIME = 30
            RED_TIME = 60
        print(f"车流量：{traffic_flow}辆/秒，绿灯{GREEN_TIME}秒，红灯{RED_TIME}秒")
        time.sleep(GREEN_TIME + RED_TIME + YELLOW_TIME)

def main():
    light_thread = threading.Thread(target=traffic_light_control, args=(150,))
    light_thread.start()
    light_thread.join()

if __name__ == "__main__":
    main()

说明

1. 单信号灯 ：通过一个线程控制红绿灯状态，使用time.sleep实现时间控制。

2. 多信号灯 ：为每个方向创建独立线程，使用threading.Lock确保状态切换的互斥性。

3. 智能控制 ：根据模拟车流量动态调整绿灯时间，适用于复杂交通场景。

扩展建议

• 硬件接口 ：结合GPIO库实现与交通信号灯硬件的交互。

• 视频识别 ：使用OpenCV进行车辆检测，实现