apollo::planning::EmergencyPullOverStageApproach类 参考

#include <stage_approach.h>

类 apollo::planning::EmergencyPullOverStageApproach 继承关系图:

apollo::planning::EmergencyPullOverStageApproach 的协作图:

Public 成员函数
StageResult	Process (const common::TrajectoryPoint &planning_init_point, Frame *frame) override
	Each stage does its business logic inside Process function.
Public 成员函数 继承自 apollo::planning::Stage
	Stage ()
virtual bool	Init (const StagePipeline &config, const std::shared_ptr< DependencyInjector > &injector, const std::string &config_dir, void *context)
virtual	~Stage ()=default
const std::string &	Name () const
template<typename T >
T *	GetContextAs () const
const std::string &	NextStage () const

额外继承的成员函数
Protected 成员函数 继承自 apollo::planning::Stage
StageResult	ExecuteTaskOnReferenceLine (const common::TrajectoryPoint &planning_start_point, Frame *frame)
StageResult	ExecuteTaskOnReferenceLineForOnlineLearning (const common::TrajectoryPoint &planning_start_point, Frame *frame)
StageResult	ExecuteTaskOnOpenSpace (Frame *frame)
virtual StageResult	FinishScenario ()
void	RecordDebugInfo (ReferenceLineInfo *reference_line_info, const std::string &name, const double time_diff_ms)
Protected 属性 继承自 apollo::planning::Stage
std::vector< std::shared_ptr< Task > >	task_list_
std::shared_ptr< Task >	fallback_task_
std::string	next_stage_
void *	context_
std::shared_ptr< DependencyInjector >	injector_
StagePipeline	pipeline_config_

详细描述

在文件 stage_approach.h 第 35 行定义.

成员函数说明

Process()

StageResult apollo::planning::EmergencyPullOverStageApproach::Process ( const common::TrajectoryPoint &  planning_init_point, Frame *  frame  )

overridevirtual

Each stage does its business logic inside Process function.

If the stage want to transit to a different stage after finish, it should set the type of 'next_stage_'.

实现了 apollo::planning::Stage.

在文件 stage_approach.cc 第 40 行定义.

                                                              {
  ADEBUG << "stage: Approach";
  CHECK_NOTNULL(frame);
  auto scenario_context = GetContextAs<EmergencyPullOverContext>();
  const auto& scenario_config = scenario_context->scenario_config;
 
  auto& reference_line_info = frame->mutable_reference_line_info()->front();
  reference_line_info.LimitCruiseSpeed(
      scenario_context->target_slow_down_speed);
  // set vehicle signal
  reference_line_info.SetTurnSignal(VehicleSignal::TURN_RIGHT);
 
  double stop_line_s = 0.0;
 
  // add a stop fence
  const auto& pull_over_status =
      injector_->planning_context()->planning_status().pull_over();
  if (pull_over_status.has_position() && pull_over_status.position().has_x() &&
      pull_over_status.position().has_y()) {
    const auto& reference_line = reference_line_info.reference_line();
    common::SLPoint pull_over_sl;
    reference_line.XYToSL(pull_over_status.position(), &pull_over_sl);
    const double stop_distance = scenario_config.stop_distance();
    stop_line_s =
        pull_over_sl.s() + stop_distance +
        VehicleConfigHelper::GetConfig().vehicle_param().front_edge_to_center();
    const std::string virtual_obstacle_id = "EMERGENCY_PULL_OVER";
    const std::vector<std::string> wait_for_obstacle_ids;
    planning::util::BuildStopDecision(
        virtual_obstacle_id, stop_line_s, stop_distance,
        StopReasonCode::STOP_REASON_PULL_OVER, wait_for_obstacle_ids,
        "EMERGENCY_PULL_OVER-scenario", frame,
        &(frame->mutable_reference_line_info()->front()));
 
    ADEBUG << "Build a stop fence for emergency_pull_over: id["
           << virtual_obstacle_id << "] s[" << stop_line_s << "]";
  }
 
  StageResult result = ExecuteTaskOnReferenceLine(planning_init_point, frame);
  if (result.HasError()) {
    AERROR << "EmergencyPullOverStageApproach planning error";
  }
 
  if (stop_line_s > 0.0) {
    const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
    double distance = stop_line_s - adc_front_edge_s;
    const double adc_speed = injector_->vehicle_state()->linear_velocity();
    const double max_adc_stop_speed = common::VehicleConfigHelper::Instance()
                                          ->GetConfig()
                                          .vehicle_param()
                                          .max_abs_speed_when_stopped();
    ADEBUG << "adc_speed[" << adc_speed << "] distance[" << distance << "]";
    static constexpr double kStopSpeedTolerance = 0.4;
    static constexpr double kStopDistanceTolerance = 3.0;
    if (adc_speed <= max_adc_stop_speed + kStopSpeedTolerance &&
        std::fabs(distance) <= kStopDistanceTolerance) {
      return FinishStage();
    }
  }
 
  return result.SetStageStatus(StageStatusType::RUNNING);
}

---

该类的文档由以下文件生成:

• modules/planning/scenarios/emergency_pull_over/stage_approach.h
• modules/planning/scenarios/emergency_pull_over/stage_approach.cc