Apollo planning lane_change_decider解析

已于 2022-10-21 12:55:22 修改
阅读量1.4k 收藏 11
点赞数 2
文章标签： c++
于 2022-07-28 00:34:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34310307/article/details/126025431
版权

PathReuseDecider 是lanefollow 场景下，所调用的第 1 个 task，它的作用主要是对车辆换道状态进行管理，即对车辆换道状态（IN_CHANGE_LANE 换道中、CHANGE_LANE_FINISHED 换道结束、CHANGE_LANE_FAILED 换道失败）之间的转换进行管理

入口参数：frame、current_reference_line_info

该decider的主要操作是对记录车此时的换道状态，并不决定车是否换道。车的换道状态信息存于 injector_->planning_context()->mutable_planning_status()->mutable_change_lane()中，此dicider中出现最多的就是以下代码

void LaneChangeDecider::UpdateStatus(double timestamp,
                                     ChangeLaneStatus::Status status_code,
                                     const std::string& path_id) {
  auto* lane_change_status = injector_->planning_context()
                                 ->mutable_planning_status()
                                 ->mutable_change_lane();
  lane_change_status->set_timestamp(timestamp);
  lane_change_status->set_path_id(path_id);
  lane_change_status->set_status(status_code);
}

可以看到，UpdateStatus()的操作就是通过lane_change_status指针来对车辆换道状态进行实时更新。更新逻辑如下：

//通过frame拿到车辆此时所在的区域参考线个数
std::list<ReferenceLineInfo>* reference_line_info =frame->mutable_reference_line_info();
//没有参考线就return，因为apollo的后续所有tasks全部都依赖参考线来做轨迹规划
if (reference_line_info->empty())
  {
    const std::string msg = "Reference lines empty.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
...（省略的地方最后讲）
//判断参考线数量
bool has_change_lane = reference_line_info->size() > 1;
//如果只有一条参考线（比如往某个方向只有一条车道），那就通过updatestatus将车辆状态设置为CHANGE_LANE_FINISHED，这也符合我们认知，单向只有一条车道，还换什么道，所以车辆就该一直处于换到结束的状态
if (!has_change_lane) {
    const auto& path_id = reference_line_info->front().Lanes().Id();
    if (prev_status->status() == ChangeLaneStatus::CHANGE_LANE_FINISHED) {
    } else if (prev_status->status() == ChangeLaneStatus::IN_CHANGE_LANE) {
      UpdateStatus(now, ChangeLaneStatus::CHANGE_LANE_FINISHED, path_id);
    } else if (prev_status->status() == ChangeLaneStatus::CHANGE_LANE_FAILED) {
    } else {
      const std::string msg =
          absl::StrCat("Unknown state: ", prev_status->ShortDebugString());
      AERROR << msg;
      return Status(ErrorCode::PLANNING_ERROR, msg);
    }
    return Status::OK();
  }
//下面的else处理不止一条参考线的情况，正常道路都不止一条参考线，就连我们家小县城的马路都是单向3车道。主要逻辑为状态切换，实际操作还是通过updatestatus来实时更新车辆的换道状态。
else {  
    auto current_path_id = GetCurrentPathId(*reference_line_info);
    if (current_path_id.empty()) {
      const std::string msg = "The vehicle is not on any reference line";
      AERROR << msg;
      return Status(ErrorCode::PLANNING_ERROR, msg);
    }
    if (prev_status->status() == ChangeLaneStatus::IN_CHANGE_LANE) {
      if (prev_status->path_id() == current_path_id) {
        PrioritizeChangeLane(true, reference_line_info);
      } else {
        // RemoveChangeLane(reference_line_info);
        PrioritizeChangeLane(false, reference_line_info);
        ADEBUG << "removed change lane.";
        UpdateStatus(now, ChangeLaneStatus::CHANGE_LANE_FINISHED,
                     current_path_id);
      }
      return Status::OK();
    } else if (prev_status->status() == ChangeLaneStatus::CHANGE_LANE_FAILED) {
      // TODO(SHU): add an optimization_failure counter to enter
      // change_lane_failed status
      if (now - prev_status->timestamp() <
          lane_change_decider_config.change_lane_fail_freeze_time()) {
        // RemoveChangeLane(reference_line_info);
        PrioritizeChangeLane(false, reference_line_info);
        ADEBUG << "freezed after failed";
      } else {
        UpdateStatus(now, ChangeLaneStatus::IN_CHANGE_LANE, current_path_id);
        ADEBUG << "change lane again after failed";
      }
      return Status::OK();
    } else if (prev_status->status() ==
               ChangeLaneStatus::CHANGE_LANE_FINISHED) {
      if (now - prev_status->timestamp() <
          lane_change_decider_config.change_lane_success_freeze_time()) {
        // RemoveChangeLane(reference_line_info);
        PrioritizeChangeLane(false, reference_line_info);
        ADEBUG << "freezed after completed lane change";
      } else {
        PrioritizeChangeLane(true, reference_line_info);
        UpdateStatus(now, ChangeLaneStatus::IN_CHANGE_LANE, current_path_id);
        ADEBUG << "change lane again after success";
      }
    } else {
      const std::string msg =
          absl::StrCat("Unknown state: ", prev_status->ShortDebugString());
      AERROR << msg;
      return Status(ErrorCode::PLANNING_ERROR, msg);
    }
  }

 用图表示切换逻辑（在这里引用知乎的一张图）

 

PrioritizeChangeLane(const bool is_prioritize_change_lane,std::list<ReferenceLineInfo>* reference_line_info) 解析：

//当is_prioritize_change_lane为true,则遍历存储referenceLineInfo的链表，把
//当前车辆不位于的的那条（俗称换到参考线）放到链表的第一个位置
//当is_prioritize_change_lane为false,则遍历存储referenceLineInfo的链表，把
//当前车辆所位于的的那条放到链表的第一个位置
//我很纳闷，这里的形参reference_line_info是从frame类里面拿来的，你在这里任意调换
//referenceLineInfo的位置，就不怕public_road_planner那边对参考线进行遍历的功能吗？
//还有，将referenceLineInfo在链表中的位置来回换的目的我还不清楚，个人粗浅的认为
//此PrioritizeChangeLane（）功能意义不大
void LaneChangeDecider::PrioritizeChangeLane(
    const bool is_prioritize_change_lane,
    std::list<ReferenceLineInfo>* reference_line_info) const {
  if (reference_line_info->empty()) {
    AERROR << "Reference line info empty";
    return;
  }

  const auto& lane_change_decider_config = config_.lane_change_decider_config();

  // TODO(SHU): disable the reference line order change for now
  if (!lane_change_decider_config.enable_prioritize_change_lane()) {
    return;
  }
  auto iter = reference_line_info->begin();
  while (iter != reference_line_info->end()) {
    ADEBUG << "iter->IsChangeLanePath(): " << iter->IsChangeLanePath();
    /* is_prioritize_change_lane == true: prioritize change_lane_reference_line
       is_prioritize_change_lane == false: prioritize
       non_change_lane_reference_line */
    if ((is_prioritize_change_lane && iter->IsChangeLanePath()) ||
        (!is_prioritize_change_lane && !iter->IsChangeLanePath())) {
      ADEBUG << "is_prioritize_change_lane: " << is_prioritize_change_lane;
      ADEBUG << "iter->IsChangeLanePath(): " << iter->IsChangeLanePath();
      break;
    }
    ++iter;
  }
  reference_line_info->splice(reference_line_info->begin(),
                              *reference_line_info, iter);
  ADEBUG << "reference_line_info->IsChangeLanePath(): "
         << reference_line_info->begin()->IsChangeLanePath();
}

上文...省略的地方解析：

//当配置文件强制要求换道，即lane_change_decider_config.reckless_change_lane()为true，
//则调用PrioritizeChangeLane(true, reference_line_info)，将换道参考线放到链表第一位，
//直接return true。好奇连车的换道状态都不设置了吗？直接return了
if (lane_change_decider_config.reckless_change_lane()) {
    //若第一个参数为true,则将reference_line_info中的第一个变道车道参考线调到第一位
    //若第一个参数为false,则将reference_line_info中的第一个非变道车道参考线调到第一位
    PrioritizeChangeLane(true, reference_line_info);
    return Status::OK();
   }
//此处判断传进来的referenceLineinfo是否是变道参考线，如果是则通过
//IsClearToChangeLane()检查该参考线是否满足变道条件，
//IsClearToChangeLane只考虑传入的参考线上的动态障碍物，不考虑虚的和静态的障碍物。疑点：为什么只/考虑动态障碍物？
if (current_reference_line_info->IsChangeLanePath()) {
    //获取reference_line_info中存储的所有动态obstacle，一一的遍历这些obstacle
    //如果该障碍物不再reference_line_info所在的车道中，则不考虑
    //对于在此车道范围内的obstacle，通过分析该障碍物的位置与运动方向，结合车辆的位置来判断是否iscleartochangelane
    prev_status->set_is_clear_to_change_lane(
        IsClearToChangeLane(current_reference_line_info));
  }
//头次进入task，车道换道状态应该为空，默认设置为换道结束状态
  if (!prev_status->has_status()) {
    UpdateStatus(now, ChangeLaneStatus::CHANGE_LANE_FINISHED,
                 GetCurrentPathId(*reference_line_info));//获取非变道lane的id
    prev_status->set_last_succeed_timestamp(now);
    return Status::OK();
  }

IsClearToChangeLane（）解析：

//调选出位于该referenceline上的动态障碍物，结合障碍物的运动方向和车的运动方向，
//检查每个障碍物与车的前后距离，看是否都满足安全阈值。只要有一个动态障碍物不满足条件
//该referenceline就不满足换道条件。prev_status->set_is_clear_to_change_lane(false)
bool LaneChangeDecider::IsClearToChangeLane(
    ReferenceLineInfo* reference_line_info) {
  //车辆轮廓起点
  double ego_start_s = reference_line_info->AdcSlBoundary().start_s();
  //车辆轮廓终点
  double ego_end_s = reference_line_info->AdcSlBoundary().end_s();
  double ego_v =
      std::abs(reference_line_info->vehicle_state().linear_velocity());

  for (const auto* obstacle : reference_line_info->path_decision()->obstacles().Items()) {
    if (obstacle->IsVirtual() || obstacle->IsStatic()) {
      ADEBUG << "skip one virtual or static obstacle";
      continue;
    }

    double start_s = std::numeric_limits<double>::max();
    double end_s = -std::numeric_limits<double>::max();
    double start_l = std::numeric_limits<double>::max();
    double end_l = -std::numeric_limits<double>::max();

    for (const auto& p : obstacle->PerceptionPolygon().points()) {
      SLPoint sl_point;
      reference_line_info->reference_line().XYToSL(p, &sl_point);
      start_s = std::fmin(start_s, sl_point.s());
      end_s = std::fmax(end_s, sl_point.s());

      start_l = std::fmin(start_l, sl_point.l());
      end_l = std::fmax(end_l, sl_point.l());
    }

    if (reference_line_info->IsChangeLanePath()) {
      double left_width(0), right_width(0);
      reference_line_info->mutable_reference_line()->GetLaneWidth(
          (start_s + end_s) * 0.5, &left_width, &right_width);
      //只考虑在reference_line_info所在的车道的障碍物
      if (end_l < -right_width || start_l > left_width) {
        continue;
      }
    }

    // Raw estimation on whether same direction with ADC or not based on
    // prediction trajectory
    bool same_direction = true;
    if (obstacle->HasTrajectory()) {
      double obstacle_moving_direction =
          obstacle->Trajectory().trajectory_point(0).path_point().theta();
      const auto& vehicle_state = reference_line_info->vehicle_state();
      double vehicle_moving_direction = vehicle_state.heading();
      if (vehicle_state.gear() == canbus::Chassis::GEAR_REVERSE) {
        vehicle_moving_direction =
            common::math::NormalizeAngle(vehicle_moving_direction + M_PI);
      }
      double heading_difference = std::abs(common::math::NormalizeAngle(
          obstacle_moving_direction - vehicle_moving_direction));
      same_direction = heading_difference < (M_PI / 2.0);
    }

    // TODO(All) move to confs
    static constexpr double kSafeTimeOnSameDirection = 3.0;
    static constexpr double kSafeTimeOnOppositeDirection = 5.0;
    static constexpr double kForwardMinSafeDistanceOnSameDirection = 10.0;
    static constexpr double kBackwardMinSafeDistanceOnSameDirection = 10.0;
    static constexpr double kForwardMinSafeDistanceOnOppositeDirection = 50.0;
    static constexpr double kBackwardMinSafeDistanceOnOppositeDirection = 1.0;
    static constexpr double kDistanceBuffer = 0.5;

    double kForwardSafeDistance = 0.0;
    double kBackwardSafeDistance = 0.0;
    if (same_direction) {
      kForwardSafeDistance =
          std::fmax(kForwardMinSafeDistanceOnSameDirection,
                    (ego_v - obstacle->speed()) * kSafeTimeOnSameDirection);
      kBackwardSafeDistance =
          std::fmax(kBackwardMinSafeDistanceOnSameDirection,
                    (obstacle->speed() - ego_v) * kSafeTimeOnSameDirection);
    } else {
      kForwardSafeDistance =
          std::fmax(kForwardMinSafeDistanceOnOppositeDirection,
                    (ego_v + obstacle->speed()) * kSafeTimeOnOppositeDirection);
      kBackwardSafeDistance = kBackwardMinSafeDistanceOnOppositeDirection;
    }

    if (HysteresisFilter(ego_start_s - end_s, kBackwardSafeDistance,
                         kDistanceBuffer, obstacle->IsLaneChangeBlocking()) &&
        HysteresisFilter(start_s - ego_end_s, kForwardSafeDistance,
                         kDistanceBuffer, obstacle->IsLaneChangeBlocking())) {
      reference_line_info->path_decision()
          ->Find(obstacle->Id())
          ->SetLaneChangeBlocking(true);
      ADEBUG << "Lane Change is blocked by obstacle" << obstacle->Id();
      return false;
    } else {
      reference_line_info->path_decision()
          ->Find(obstacle->Id())
          ->SetLaneChangeBlocking(false);
    }
  }
  return true;
}

 总结与疑问：
lane_change_decider，我觉得应该叫车辆换道状态检测器，因为该decider通篇都在通过UpdateStatus来对injector_->planning_context()->mutable_planning_status()

->mutable_change_lane()信息进行实时更新。当然，顺便对proc传进来的current_reference_line_info通过IsClearToChangeLane()做了是否具备换道条件检测，是的话就额外的将injector_->planning_context()->mutable_planning_status()

->mutable_change_lane()->set_is_clear_to_change_lane设置为true,表面车辆此时周围有可以换道的参考线。这一信息很重要，后面的path_bound_decider会依据此标志位来确定regular_path_bound。

该决策器还有一个重点就是多参考线的换道逻辑状态图，这里有疑点:

else if (prev_status->status() ==
               ChangeLaneStatus::CHANGE_LANE_FINISHED) {
      if (now - prev_status->timestamp() <
          lane_change_decider_config.change_lane_success_freeze_time()) {
        // RemoveChangeLane(reference_line_info);
        PrioritizeChangeLane(false, reference_line_info);
        ADEBUG << "freezed after completed lane change";
      } else {
//为什么CHANGE_LANE_FINISHED结束后，过个一定时间，又要切换到IN_CHANGE_LANE,
//就不能消停点吗？
        PrioritizeChangeLane(true, reference_line_info);
        UpdateStatus(now, ChangeLaneStatus::IN_CHANGE_LANE, current_path_id);
        ADEBUG << "change lane again after success";
      }

 图片链接：Apollo规划模块详解（五）：算法实现-lane change decider - 知乎 

bupt_yan
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
Apollo Planning决策规划算法代码详细解析 (6):LaneChangeDecider
自动驾驶Player的博客
04-02 4713
Apollo Planning决策规划系列文章： Apollo Planning决策规划代码详细解析 (1)：Scenario选择 Apollo Planning决策规划代码详细解析 (2)：Scenario执行 Apollo Planning决策规划代码详细解析 (3)：stage执行 Apollo Planning决策规划代码详细解析 (4)：Stage逻辑详解 Apollo Planning决策规划代码详细解析 (5)：规划算法流程介绍 正文如下： 一、概述 LaneChangeDec
apollo学习之---（27）reference line切换过程分析之二
qq_41593516的博客
04-07 858
bool LaneChangeDecider::IsClearToChangeLane( ReferenceLineInfo* reference_line_info) { } ```
百度apollo lane_change_decider 详细注释代码
04-02
百度apollo lane_change_decider 详细注释代码
Apollo Planning——换道：LANE_CHANGE_DECIDER
xiaohu的博客
12-19 1528
4、判断是否为可变车道时调用了 IsChangeLanePath()，它的逻辑也很简单， 如果自车在当前ReferenceLine 的车道segment上，则为FALSE；2、在stage阶段会依次调用每个 task 的 Execute() 函数，LaneChangeDecider继承自 Decider 类，Decider继承自基类 task 类，并且override了Execute() 方法；场景下，所调用的第一个task，它的作用主要有两点：判断当前是否进行变道，以及变道的状态，并将结果存在变量。
【Apollo学习笔记】——规划模块TASK之PATH_DECIDER
sinat_52032317的博客
08-29 944
在Apollo星火计划学习笔记——Apollo路径规划算法原理与实践与【Apollo学习笔记】——Planning模块讲到……Stage::Process的函数会依次调用task_list中的TASK，本文将会继续以LaneFollow为例依次介绍其中的TASK部分究竟做了哪些工作。由于个人能力所限，文章可能有纰漏的地方，还请批评斧正。在配置文件中，我们可以看到LaneFollow所需要执行的所有task。本文将继续介绍LaneFollow的第7个TASK——根据选出的路径给出对障碍物的决策。
Autoware1.15 + OpenPlanner2.5 下的laneChange解析（1）
weixin_41697321的博客
06-06 2810
本文研究global planner里的laneChange功能，包括：1. 对vector map的要求； 2. Vector map的loader如何提供laneChange的功能； 3. Global planner中laneChange的代码实现
Apollo6.0 PathReuseDecider流程与代码解析
xl_courage的博客
11-30 1600
Apollo6.0 PathReuseDecider流程与代码解析 0、引言 对于轨迹规划而言，主要包含横向路径以及纵向位置、速度、加速度规划。当前主流算法，主要都是轨迹规划问题拆解为横向和纵向两个部分进行独立规划，以达到复杂问题的降维解耦，减小对运行平台资源的算力需求。 每一次横向路径规划，都会涉及约束边界、坐标转化等计算工作，这些都会带来时间复杂度上的开销;但在某些场景下，对于横向轨迹的生成，有时并不需要高频的定周期或触发式的重新计算生成。因此有必要设计判断是否可以对前周期的轨迹重复利用。比如在换道.
【Apollo学习笔记】——规划模块TASK之LANE_CHANGE_DECIDER
sinat_52032317的博客
08-20 1881
在Apollo星火计划学习笔记——Apollo路径规划算法原理与实践与【Apollo学习笔记】——Planning模块讲到……Stage::Process的函数会依次调用task_list中的TASK，本文将会继续以LaneFollow为例依次介绍其中的TASK部分究竟做了哪些工作。由于个人能力所限，文章可能有纰漏的地方，还请批评斧正。在配置文件中，我们可以看到LaneFollow所需要执行的所有task。本文将从第一个task——开始介绍。主要功能产生是否换道的决策，更新换道状态。
Apollo Planning学习（3）-------LANE_CHANGE_DECIDER
m0_71477431的博客
01-31 2378
学习记录
Apollo Planning——TASK之PathBoundsDecider
xiaohu的博客
12-19 233
利用前几个决策器，根据相应条件，产生相应的SL边界。这里说明以下Nudge障碍物的概念——主车旁边的障碍物未完全阻挡主车，主车可以通过绕行避过障碍物（注意图中的边界）。
apollo_demo_2.0.bag数据包
01-13
apollo官方的2.0数据包。根据对应的apllo版本，在跑仿真时，可以播放此数据包。此数据包中包含topic，可以在ros环境（docker）中使用rosbag info xxx.bag 命令来查询。
apollo__demo_1.5.bag数据包
01-13
apollo官方的1.5数据包。根据对应的apllo版本，在跑仿真时，可以播放此数据包。此数据包中包含topic，可以在ros环境（docker）中使用rosbag info xxx.bag 命令来查询。
control_apollo_control_自动驾驶_
09-28
百度Apollo自动驾驶系统开源代码Control
apollo_upload_server-ruby
02-04
gem 'apollo_upload_server' , '2.0.3' 然后执行： $ bundle 或自己安装为： $ gem install apollo_upload_server 中间件将自动使用。 宝石将自定义Upload类型添加到您的GraphQL类型。 将文件的
apollo学习之---（24）reference line切换过程分析之一
qq_41593516的博客
03-31 1395
文章目录背景描述调试信息 背景描述 地图： 调试信息 变道前： ref_info size = 2 best_ref_info: 3143_1_-2 best_ref_info: 96_1_-2 best_ref_info: 42_1_-3 best_ref_info: 2414_1_-3 best_ref_info: 128_1_-2 best_ref_info: 97_1_-2 best_ref_info: 1775_1_-2 target_ref_info: 3143_1_-1 target_re
carla官方文档笔记1
学习笔记
08-01 5562
介绍 介绍 CARLA是一个开源的自动驾驶模拟器。它是从零开始构建的，作为一个模块化和灵活的API来解决一系列涉及到自动驾驶问题的任务。carla的主要目标之一是帮助实现自主驾驶研发的灵活化，作为一种用户可以方便地访问和定制的工具。为此，模拟器必须满足一般驾驶问题中不同用例的要求（例如学习驾驶策略、训练感知算法等）。CARLA以Unreal Engine为基础来运行模拟，并使用OpenDRIVE标准（1.4与今天一样）来定义道路和城市设置。模拟的控制权是通过Python和C语言处理的API授予的，该AP
Apollo开发者说｜Apollo换道与相关数据结构详解
csdndevpress0029的博客
08-11 441
RoutingRequest输入给Routing模块，通过A*算法搜索，得到从起点到终点的最优路径，最优路径的信息包含在RoutingResponse中，它是车道级别的路径。图1是Apollo收到一个导航请求时的处理流程，用户在Dreamview上通过鼠标点选和车辆当前的位置，得到起点和终点的位姿，经过在地图上映射，得到RoutingRequest信息，其中包含了起点和终点在最近车道上的对应点。当车辆短期范围包含了直行车道的终点时，因为换道车道对应的参考线较长，所以会选择换道车道，这就完成了换道的决策。
实战 | 详解Apollo 换道
CV_Autobot的博客
11-07 456
作者|徐明 编辑|汽车人原文链接：https://zhuanlan.zhihu.com/p/665125585点击下方卡片，关注“自动驾驶之心”公众号ADAS巨卷干货，即可获取点击进入→自动驾驶之心【全栈算法】技术交流群本文只做学术分享，如有侵权，联系删文1. 介绍1.1. 换道的功能简单地说, 换道的作用就是从待选地参考线中选择其中一个参考线, 供 Planning 后续模块进行使用....
【Apollo学习笔记】——规划模块TASK之PATH_REUSE_DECIDER
sinat_52032317的博客
08-22 1124
在Apollo星火计划学习笔记——Apollo路径规划算法原理与实践与【Apollo学习笔记】——Planning模块讲到……Stage::Process的函数会依次调用task_list中的TASK，本文将会继续以LaneFollow为例依次介绍其中的TASK部分究竟做了哪些工作。由于个人能力所限，文章可能有纰漏的地方，还请批评斧正。在配置文件中，我们可以看到LaneFollow所需要执行的所有task。本文将继续介绍LaneFollow的第二个TASK——主要功能：检查路径是否可重用,提高帧间平顺性。
apollo speed_bounds_decider
最新发布
02-02
apollo speed_bounds_decider是指在Apollo自动驾驶平台中的一个模块，其作用是决定车辆的速度限制。在自动驾驶系统中，车辆需要根据不同的路况和交通规则来决定适当的行驶速度，以确保行车安全和高效性。因此，speed_bounds_decider模块就是负责根据车辆所处的环境和道路情况来计算车辆的最高速度，并将这些信息传递给车辆的控制系统。 在执行这一任务时，speed_bounds_decider模块需要综合考虑一系列的因素，比如车辆所处的道路类型（高速公路、城市道路、乡村道路等）、交通标志、限速标识、其他车辆的行驶状况等。通过这些信息的综合分析，speed_bounds_decider模块可以给出一个合理的速度限制值，以确保车辆在各种情况下都能保持安全的速度。 此外，speed_bounds_decider模块还会与其他的Apollo模块进行通信和协作，比如感知模块、规划模块和控制模块等，以确保速度限制的信息能够被有效地传递给车辆的控制系统，并且车辆能够根据这些信息来调整自身的行驶速度。 总之，speed_bounds_decider模块在Apollo自动驾驶平台中扮演着非常重要的角色，它不仅可以帮助车辆合理地决定行驶速度，还能够提高自动驾驶系统的整体性能和安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值