devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

利用SUMO进行交叉口速度引导_sumo控制车速

作者：Gausst松鼠会 | 2024-05-30 06:12:13

赞

踩

sumo控制车速

系列文章目录

SUMO使用E2检测器获取信号交叉口车道信息和信号控制方案

SUMO轨迹图的绘制和traci接口的简单使用

SUMO利用转弯率构建车流rou文件

sumo仿真netgenerate使用

前言

最近，本人由于项目上和一些实际上的学习需求，本文利用SUMO仿真平台对交叉口速度引导进行了一定的实践。

一、交叉口速度引导公式推算

根据车辆的速度、信号相位等信息，基本可以将车辆经过交叉口的速度引导情景概括为以下几类：

①绿灯匀速通过

phase = green

t_g >d/v _0

②绿灯加速通过

phase = green

\frac{d_u-(v_{max}^{2}-v_{0}^{2})/2a}{v_{max}^{2}}+\frac{v_{max}-v_0}{a}<t_g<d/v_0

③绿灯减速通过

phase = green

 t_g<\frac{d_u-(v_{max}^{2}-v_{0}^{2})/2a}{v_{max}^{2}}+\frac{v_{max}-v_0}{a}

t_g+t_r<\frac{d_u-(v_{min}^{2}-v_{0}^{2})/2a_d}{v_{min}^{2}}+\frac{v_{min}-v_0}{a_d}

④绿灯停车

phase = green

  t_g<\frac{d_u-(v_{max}^{2}-v_{0}^{2})/2a}{v_{max}^{2}}+\frac{v_{max}-v_0}{a}

t_g+t_r > \frac{d-(v_{min}^{2}-v_0^{2})}{v_{min}}+\frac{v_{min}-v_0}{a_d}

⑤红灯匀速通过

phase = red

t_r<d/v_0<t_g+t_r

⑥红灯加速通过

phase = red

\frac{d_u-(v_{max}^{2}-v_{0}^{2})/2a}{v_{max}^{2}}+\frac{v_{max}-v_0}{a}<t_g+t_r<d/v_0

⑦红灯减速通过

phase = red

d/v_0<t_r <\frac{d_u-(v_{min}^{2}-v_0^2)/2a_d}{v_{min}}+\frac{v_{min}-v_0}{a_d}

⑧红灯停车

phase = red

t_r > \frac{d-(v_{max}^2-v_0^2)/2a_d}{v_{min}}+\frac{v_{min}-v_0}{a_d}

下面对于上述八种情况对于引导速度的计算过程

①绿灯匀速通过：

车辆能够匀速通过，如果车辆行驶速度较低，不仅不利于交叉口的通行效率提升，也提升了整体燃油消耗。

因此如果车辆速度<经济速度：

v_{guide}=v_{eco}

如果车辆速度大于经济速度：

v_{guide}=v_0

②红灯匀速通过：

v_{guide}=v_0

③加速通过：

v_{guide}=v_0+aT_a-\sqrt{a^2T_a^2+2v_0T-2aL}

④减速通过：

v_{guide}=v_0+a_dT_d-\sqrt{a_d^2T_d^2+2v_0T-2a_dL}

⑤停车通过：

v_{guide} = v_{min}

二、仿真场景搭建

1.SUMO仿真场景搭建

由于本文所进行构建的场景为工程场景，需要使用项目地址的路网，所以本文利用OSM真实路网构建仿真场景。为了能够更加便利地构建真实道路网络，这里使用SUMO自带的OSM web wizard工具，自动生成真实路网。

点击generate即可自动生成路网，以及车流文件，但是本文中所使用的算法仅为一阶段算法，不考虑车辆排队和车辆之间的相互作用，因此实际运用过程中，还需要对车流做进一步 调整。构建完成的路网如下：

仿真车流为项目道路，双向车流，车流量为60辆/小时 

2.车速引导算法实现

1.功能函数实现：

①信号周期计算：

  1. def cycle_time(tls_id):
  2.     tls_logic = traci.trafficlight.getAllProgramLogics(tls_id)#获取下一信号交叉口的控制方案
  3.     current_phase = tls_logic[0].currentPhaseIndex#获取信号相位traci.simulation.getCurrentTime()/1000#获取当前仿真时间
  4.     cycle_time = 0#周期时长初始化
  5.     for i in  range(len(tls_logic[0].phases)):
  6.         cycle_time += tls_logic[0].phases[i].duration#将控制方案中各相位的控制方案累加获得周期长
  7.     return cycle_time

②获取交叉口各相位进口道信息：

  1. def incoming_lane(tls_id):
  2.     logic = traci.trafficlight.getAllProgramLogics(tls_id)#获取控制方案
  3.     in_lane = traci.trafficlight.getControlledLanes(tls_id)
  4.     program = logic[0]
  5.     phase = {}#定义空相位
  6.     for i in range(len(program.phases)):#遍历信号相位
  7.         if i%2 ==0:#因为相位中间存在黄灯信号，所以绿灯信号全为双数
  8.             phase[i] = program.phases[i].state#信号为logic格式，.state是其中的具体信号控制方案
  9.     incoming_lanes_all = {}#定义进口车道集
  10.     for i in phase:#遍历相位
  11.         incoming_lanes = []#定义进口空车道
  12.         k = 0#控制相位数
  13.         #print(phase[i])
  14.         for j in phase[i]:
  15.             #print(k)
  16.             if j =='G':#将’G‘对应的车道记录下来
  17.                 #print(k)
  18.                 incoming_lanes.append(in_lane[k])
  19.                 #print(incoming_lanes)
  20.             k = k+1
  21.         incoming_lanes_all[i] = incoming_lanes#将每一相位的车道保存
  22.     return incoming_lanes_all

③获取下一绿灯相位开始时间和结束时间

  1. def next_green(vehicle_id):
  2.     data = traci.vehicle.getNextTLS(vehicle_id)#获取下一信号交叉口信息
  3.     tls_id_1 = data[0][0]#获取交叉口id
  4.     in_lane = incoming_lane(tls_id_1)#获取各相位进口道
  5.     cycle = cycle_time(tls_id_1)#获取周期时长
  6.     current_lane = traci.vehicle.getLaneID(vehicle_id)#获取车辆所在车道
  7.   
  8.     signal_state_1 = data[0][3]#获取当前车道信号状态
  9.     phases = traci.trafficlight.getAllProgramLogics(tls_id_1)[0].phases#获取信号相位
  10.     phases_num  = len(phases)#获取相位数
  11.     remaining_time = traci.trafficlight.getNextSwitch(tls_id_1) - traci.simulation.getCurrentTime()/1000 #获取当前信号相位剩余时间
  12.     
  13.     if current_lane in in_lane[0]:#如果当前车道为相位0通行相位，则绿灯相位为0
  14.         green_phase = 0
  15.         #print(green_phase)
  16.         
  17.         
  18.     elif current_lane in in_lane[2]:#如果当前车道为相位2通行相位，则绿灯相位为2
  19.         green_phase = 2
  20.         #print(green_phase)
  21.         
  22.     elif current_lane[0:8] == 'cluster':
  23.         print(current_lane)
  24.         green_phase = 0
  25.         
  26.         
  27.     else :
  28.         print("绿灯相位读取错误")
  29.         green_phase = 0
  30.     current_phase = traci.trafficlight.getPhase(tls_id_1)
  31.     
  32.     
  33.     if signal_state_1 == 'g' or signal_state_1 == 'G':#如果当前相位为绿灯
  34.         next_g_start = cycle - traci.trafficlight.getPhaseDuration(tls_id_1) + remaining_time#下一绿灯开始时间为周期长-当前相位周期时长+相位剩余时间
  35.         next_g_end = cycle + remaining_time#下一绿灯结束时间为周期长加相位剩余时间
  36.         
  37.         
  38.     elif signal_state_1 == 'r' or signal_state_1 == 'y':
  39.         
  40.         if green_phase == 0 :
  41.             if current_phase == 1:#如果为黄灯相位
  42.                 next_g_start = remaining_time+phases[2].duration+phases[3].duration#下一绿灯开始为剩余时间+下一相位+下一相位
  43.                 next_g_end = next_g_start + phases[0].duration
  44.             elif current_phase == 2:
  45.                 next_g_start = remaining_time + phases[3].duration
  46.                 next_g_end = next_g_start + phases[0].duration
  47.             elif current_phase == 3:
  48.                 next_g_start = remaining_time
  49.                 next_g_end = next_g_start + phases[0].duration
  50.                 
  51.                 
  52.             elif current_phase == 0:
  53.                 next_g_start = remaining_time + phases[1].duration
  54.                 next_g_end = remaining_time + phases[1].duration + phases[2].duration
  55.                 
  56.                 
  57.         if green_phase == 2:#如果绿灯相位为相位2
  58.             if current_phase == 3:
  59.                 next_g_start = remaining_time+phases[0].duration+phases[1].duration
  60.                 next_g_end = next_g_start + phases[2].duration
  61.             elif current_phase == 0:
  62.                 next_g_start = remaining_time+phases[1].duration
  63.                 next_g_end = next_g_start + phases[2].duration
  64.             elif current_phase == 1:
  65.                 next_g_start = remaining_time
  66.                 next_g_end = next_g_start + phases[2].duration
  67.                 
  68.                 
  69.                 
  70.     return next_g_start,next_g_end

④建议速度计算：

  1. def advise_speed(vehicle_id,next_g_start,next_g_end):
  2.     min_speed = 2.0#最小速度
  3.     max_speed = traci.vehicle.getAllowedSpeed(vehicle_id)#道路通行最大速度
  4.     acc = traci.vehicle.getAccel(vehicle_id)#加速度
  5.     dec = -traci.vehicle.getDecel(vehicle_id)#减速度
  6.     distance = traci.vehicle.getNextTLS(vehicle_id)[0][2]#车辆距离交叉口距离
  7.     speed_now = traci.vehicle.getSpeed(vehicle_id)#当前车辆速度
  8.     phase_now = traci.vehicle.getNextTLS(vehicle_id)[0][3]#下一交叉口相位
  9.     if phase_now == 'G' or phase_now == 'g':#如果相位为绿灯
  10.         remaining_time = traci.trafficlight.getNextSwitch(traci.vehicle.getNextTLS(vehicle_id)[0][0]) - traci.simulation.getCurrentTime()/1000
  11.         if remaining_time > distance/(speed_now+0.01):#绿灯匀速通过
  12.             speed_advise = speed_now
  13.             traci.vehicle.setColor(vehicle_id,(0,255,0))#设置颜色为绿色
  14.             print('speed_now:',speed_now)
  15.             print(speed_advise,'绿灯匀速通过')
  16.             
  17.             
  18.         elif remaining_time > ((distance-(max_speed**2-speed_now**2)/(2*acc))/max_speed + (max_speed-speed_now)/acc) and remaining_time<distance/(speed_now+0.0000000001):
  19.             discriminant = acc**2*remaining_time**2+2*acc*speed_now*remaining_time-2*acc*distance #计算方程判别式
  20.             accTime = (acc*remaining_time-math.sqrt(discriminant))/acc
  21.             speed_advise = speed_now+accTime*acc #绿灯加速通过
  22.             traci.vehicle.setColor(vehicle_id,(255,0,255))#设置颜色为粉色
  23.             print('speed_now:',speed_now)
  24.             print(speed_advise,'绿灯加速通过')
  25.             
  26.         elif remaining_time <= ((distance-(max_speed**2-speed_now**2)/(2*acc))/max_speed + (max_speed-speed_now)/acc) and next_g_start < ((distance-(min_speed**2-speed_now**2)/(2*dec))/min_speed + (min_speed-speed_now)/dec) :
  27.             discriminant_1 = dec**2*next_g_start**2+2*dec*speed_now*next_g_start-2*dec*distance
  28.             decTime_1 = (dec*next_g_start+math.sqrt(discriminant_1))/dec
  29.             speed_advise_1 = speed_now + decTime_1*dec#绿灯减速通行   最大速度
  30.             
  31.             discriminant_2 = dec**2*next_g_end**2+2*dec*speed_now*next_g_end-2*dec*distance
  32.             decTime_2 = (dec*next_g_end+math.sqrt(discriminant_2))/dec
  33.             speed_advise_2 = speed_now + decTime_2*dec#绿灯减速通行  最小速度
  34.             
  35.             speed_advise = (speed_advise_1+speed_advise_2)/2# 确保车辆能够通过
  36.             
  37.             traci.vehicle.setColor(vehicle_id,(0,255,255))#设置颜色为蓝色
  38.             
  39.             print(traci.simulation.getCurrentTime()/1000)
  40.             print('speed_now:',speed_now)
  41.             print(speed_advise_1,speed_advise_2,'绿灯减速通行')
  42.         
  43.         
  44.         elif remaining_time <= ((distance-(max_speed**2-speed_now**2)/(2*acc))/max_speed + (max_speed-speed_now)/acc) and next_g_start >= ((distance-(min_speed**2-speed_now**2)/(2*dec))/min_speed + (min_speed-speed_now)/dec) :
  45.             discriminant = dec**2*next_g_start**2+2*dec*speed_now*next_g_start-2*dec*distance
  46.             decTime = (dec*next_g_start+math.sqrt(discriminant))/dec
  47.             speed_advise = speed_now + decTime*dec#绿灯减速停车
  48.             if speed_advise<min_speed:
  49.                 speed_advise = min_speed
  50.             
  51.             traci.vehicle.setColor(vehicle_id,(255,0,0))#设置为红色
  52.             print('speed_now:',speed_now)
  53.             print(speed_advise,'绿灯减速停车')
  54.             
  55.     if phase_now == 'r' or phase_now == 'y':
  56.         if next_g_start< distance/(speed_now+0.01) and next_g_end> distance/(speed_now+0.01):
  57.             if distance/(speed_now+0.01)-next_g_start < 2:
  58.                 speed_advise = distance/(next_g_start+3)
  59.                 print('略微减速')
  60.             else:
  61.                 speed_advise = speed_now #红灯匀速通行
  62.             traci.vehicle.setColor(vehicle_id,(255,255,255))#设置颜色为白色
  63.             print('speed_now:',speed_now)
  64.             print(speed_advise,'红灯匀速通过')
  65.             
  66.             
  67.         elif next_g_start < distance / (speed_now+0.0000001) and next_g_start > ((distance-(max_speed**2-speed_now**2)/(2*acc))/max_speed + (max_speed-speed_now)/acc):
  68.             discriminant = dec**2*next_g_start**2+2*dec*speed_now*next_g_start-2*dec*distance #计算方程判别式
  69.             decTime = (dec*next_g_start+math.sqrt(discriminant))/dec
  70.             speed_advise = speed_now + decTime*dec#红灯减速通行
  71.             traci.vehicle.setColor(vehicle_id,(0,0,255))#设置颜色为蓝色
  72.             print('speed_now:',speed_now)
  73.             print(speed_advise,'红灯减速通过')
  74.             
  75.             
  76.         elif next_g_end>((distance-(max_speed**2-speed_now**2)/(2*acc))/max_speed + (max_speed-speed_now)/acc) and next_g_end<distance/(speed_now+0.00000001):
  77.             discriminant = acc**2*next_g_end**2+2*acc*speed_now*next_g_end-2*acc*distance #计算方程判别式
  78.             accTime = (acc*next_g_end-math.sqrt(discriminant))/acc
  79.             speed_advise = speed_now+accTime*acc #红灯加速通过
  80.             traci.vehicle.setColor(vehicle_id,(255,0,255))#设置颜色为粉色
  81.             print('speed_now:',speed_now)
  82.             print(speed_advise,'红灯加速通过')
  83.             print(traci.simulation.getCurrentTime()/1000)
  84.             
  85.             
  86.         else :
  87.             print('红灯减速停车')
  88.             speed_advise = min_speed
  89.             traci.vehicle.setColor(vehicle_id,(255,0,0))#设置为红色
  90.         
  91.     
  92.     return speed_advise

2.速度引导控制主程序实现：

  1. while traci.simulation.getMinExpectedNumber() > 0:
  2.     traci.simulationStep()
  3.     for vehicle_id in traci.vehicle.getIDList():
  4.         traci.vehicle.setMaxSpeed(vehicle_id,16.67)
  5.         allowed_speed = traci.vehicle.getAllowedSpeed(vehicle_id)#获取路网允许速度
  6.  
  7.             
  8.         if traci.vehicle.getNextTLS(vehicle_id) != ():#确保车辆下一交叉口信息不为空
  9.             if traci.vehicle.getNextTLS(vehicle_id)[0][2] < 210: #车辆进入交叉口停止线210m范围内
  10.                 next_g_start , next_g_end =  next_green(vehicle_id)#获取下一绿灯开始时间、结束时间
  11.                 distance = traci.vehicle.getNextTLS(vehicle_id)[0][2]#获取距离交叉口停止线的距离
  12.                 speed_adv = advise_speed(vehicle_id,next_g_start,next_g_end)#获取引导速度
  13.                 traci.vehicle.setSpeed(vehicle_id,speed_adv)#对车辆速度进行控制
  14.                 
  15.                 
  16.             elif traci.vehicle.getNextTLS(vehicle_id)[0][2] > 220:#车辆距离交叉口大于220m时，控制车辆按照正常速度行驶
  17.                 traci.vehicle.setColor(vehicle_id,(255,255,0))
  18.                 traci.vehicle.setSpeed(vehicle_id,allowed_speed)
  19.                 
  20.         elif traci.vehicle.getNextTLS(vehicle_id) == ():#如果车辆即将离开路网，控制车辆按允许速度行驶
  21.             print(vehicle_id,'结束')
  22.             traci.vehicle.setColor(vehicle_id,(255,255,0))
  23.             traci.vehicle.setSpeed(vehicle_id,allowed_speed)#对车辆速度进行控制

三、程序结果分析

仿真结果：

优化前后行程时间，技术参数表

　

arrivalSpeed

行程时间

等待时间

启停次数

timeLoss

优化后

13.92

469.93

0.00

0.00

129.93

优化前

13.64

425.48

49.59

3.31

85.58

优化前后步均燃油消耗量及污染物

　

CO2

CO

HC

Nox

PMx

fuel

优化后

13963.28786

21.5826697

0

124.2140218

2.719787913

5.919309

优化前

14829.80422

22.3261729

0

129.304049

2.773325695

6.28883

仿真图像：

车辆运动轨迹图：

正向车流

优化前：

优化后：

逆向车流：

优化前：

优化后：

速度-距离图：

优化前：

优化后：

结论分析

        本文所提出的车辆速度引导算法可以在不考虑排队车辆和车辆间相互影响的情况下，显著减少车辆的启停次数和排队等待时间，但是由于SUMO仿真默认按照较高的速度行驶，速度引导算法为了使车辆能够顺利通过，部分场景使用了较低的引导速度，所以行程时间和timeloss并没有显著下降。

       下一阶段算法的设计将考虑排队长度、车辆间的相互影响，队列的信号优化等方面，可以使得算法的使用场景更加广阔，实用性更强。如果有朋友对这一方面感兴趣，欢迎交流讨论。

2023年12月更新：

项目已开源，地址：TeleYuhao/speed_guide_in_sumo: a speed guide demo using sumo (github.com)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/645607
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号