apollo::planning::PlanningComponent类 参考

#include <planning_component.h>

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

apollo::planning::PlanningComponent 的协作图:

Public 成员函数
	PlanningComponent ()=default
	~PlanningComponent ()=default
bool	Init () override
bool	Proc (const std::shared_ptr< prediction::PredictionObstacles > &prediction_obstacles, const std::shared_ptr< canbus::Chassis > &chassis, const std::shared_ptr< localization::LocalizationEstimate > &localization_estimate) override
Public 成员函数 继承自 apollo::cyber::Component< prediction::PredictionObstacles, canbus::Chassis, localization::LocalizationEstimate >
	Component ()
	~Component () override
bool	Initialize (const ComponentConfig &config) override
	init the component by protobuf object.
bool	Process (const std::shared_ptr< prediction::PredictionObstacles > &msg0, const std::shared_ptr< canbus::Chassis > &msg1, const std::shared_ptr< localization::LocalizationEstimate > &msg2, const std::shared_ptr< NullType > &msg3)
Public 成员函数 继承自 apollo::cyber::ComponentBase
virtual	~ComponentBase ()
virtual bool	Initialize (const TimerComponentConfig &config)
virtual void	Shutdown ()
template<typename T >
bool	GetProtoConfig (T *config) const

额外继承的成员函数
Public 类型 继承自 apollo::cyber::ComponentBase
template<typename M >
using	Reader = cyber::Reader< M >
Protected 成员函数 继承自 apollo::cyber::ComponentBase
virtual void	Clear ()
const std::string &	ConfigFilePath () const
void	LoadConfigFiles (const ComponentConfig &config)
void	LoadConfigFiles (const TimerComponentConfig &config)
Protected 属性 继承自 apollo::cyber::ComponentBase
std::atomic< bool >	is_shutdown_ = {false}
std::shared_ptr< Node >	node_ = nullptr
std::string	config_file_path_ = ""
std::vector< std::shared_ptr< ReaderBase > >	readers_

详细描述

在文件 planning_component.h 第 45 行定义.

构造及析构函数说明

PlanningComponent()

apollo::planning::PlanningComponent::PlanningComponent ( )

default

~PlanningComponent()

apollo::planning::PlanningComponent::~PlanningComponent ( )

default

成员函数说明

Init()

bool apollo::planning::PlanningComponent::Init ( )

overridevirtual

实现了 apollo::cyber::ComponentBase.

在文件 planning_component.cc 第 44 行定义.

                             {
  injector_ = std::make_shared<DependencyInjector>();
 
  if (FLAGS_use_navigation_mode) {
    planning_base_ = std::make_unique<NaviPlanning>(injector_);
  } else {
    planning_base_ = std::make_unique<OnLanePlanning>(injector_);
  }
 
  ACHECK(ComponentBase::GetProtoConfig(&config_))
      << "failed to load planning config file "
      << ComponentBase::ConfigFilePath();
 
  if (FLAGS_planning_offline_learning ||
      config_.learning_mode() != PlanningConfig::NO_LEARNING) {
    if (!message_process_.Init(config_, injector_)) {
      AERROR << "failed to init MessageProcess";
      return false;
    }
  }
 
  planning_base_->Init(config_);
 
  planning_command_reader_ = node_->CreateReader<PlanningCommand>(
      config_.topic_config().planning_command_topic(),
      [this](const std::shared_ptr<PlanningCommand>& planning_command) {
        AINFO << "Received planning data: run planning callback."
              << planning_command->header().DebugString();
        std::lock_guard<std::mutex> lock(mutex_);
        planning_command_.CopyFrom(*planning_command);
      });
 
  traffic_light_reader_ = node_->CreateReader<TrafficLightDetection>(
      config_.topic_config().traffic_light_detection_topic(),
      [this](const std::shared_ptr<TrafficLightDetection>& traffic_light) {
        ADEBUG << "Received traffic light data: run traffic light callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        traffic_light_.CopyFrom(*traffic_light);
      });
 
  pad_msg_reader_ = node_->CreateReader<PadMessage>(
      config_.topic_config().planning_pad_topic(),
      [this](const std::shared_ptr<PadMessage>& pad_msg) {
        ADEBUG << "Received pad data: run pad callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        pad_msg_.CopyFrom(*pad_msg);
      });
 
  story_telling_reader_ = node_->CreateReader<Stories>(
      config_.topic_config().story_telling_topic(),
      [this](const std::shared_ptr<Stories>& stories) {
        ADEBUG << "Received story_telling data: run story_telling callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        stories_.CopyFrom(*stories);
      });
 
  control_interactive_reader_ = node_->CreateReader<ControlInteractiveMsg>(
      config_.topic_config().control_interative_topic(),
      [this](const std::shared_ptr<ControlInteractiveMsg>&
                 control_interactive_msg) {
        ADEBUG << "Received story_telling data: run story_telling callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        control_interactive_msg_.CopyFrom(*control_interactive_msg);
      });
 
  if (FLAGS_use_navigation_mode) {
    relative_map_reader_ = node_->CreateReader<MapMsg>(
        config_.topic_config().relative_map_topic(),
        [this](const std::shared_ptr<MapMsg>& map_message) {
          ADEBUG << "Received relative map data: run relative map callback.";
          std::lock_guard<std::mutex> lock(mutex_);
          relative_map_.CopyFrom(*map_message);
        });
  }
  planning_writer_ = node_->CreateWriter<ADCTrajectory>(
      config_.topic_config().planning_trajectory_topic());
 
  rerouting_client_ =
      node_->CreateClient<apollo::external_command::LaneFollowCommand,
                          external_command::CommandStatus>(
          config_.topic_config().routing_request_topic());
  planning_learning_data_writer_ = node_->CreateWriter<PlanningLearningData>(
      config_.topic_config().planning_learning_data_topic());
  command_status_writer_ = node_->CreateWriter<external_command::CommandStatus>(
      FLAGS_planning_command_status);
  return true;
}

Proc()

bool apollo::planning::PlanningComponent::Proc ( const std::shared_ptr< prediction::PredictionObstacles > &  prediction_obstacles, const std::shared_ptr< canbus::Chassis > &  chassis, const std::shared_ptr< localization::LocalizationEstimate > &  localization_estimate  )

override

在文件 planning_component.cc 第 132 行定义.

                               {
  ACHECK(prediction_obstacles != nullptr);
 
  // check and process possible rerouting request
  CheckRerouting();
 
  // process fused input data
  local_view_.prediction_obstacles = prediction_obstacles;
  local_view_.chassis = chassis;
  local_view_.localization_estimate = localization_estimate;
  {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!local_view_.planning_command ||
        !common::util::IsProtoEqual(local_view_.planning_command->header(),
                                    planning_command_.header())) {
      local_view_.planning_command =
          std::make_shared<PlanningCommand>(planning_command_);
    }
  }
  {
    std::lock_guard<std::mutex> lock(mutex_);
    local_view_.traffic_light =
        std::make_shared<TrafficLightDetection>(traffic_light_);
    local_view_.relative_map = std::make_shared<MapMsg>(relative_map_);
  }
  {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!local_view_.pad_msg ||
        !common::util::IsProtoEqual(local_view_.pad_msg->header(),
                                    pad_msg_.header())) {
      // Check if "CLEAR_PLANNING" PadMessage is received and process.
      if (pad_msg_.action() == PadMessage::CLEAR_PLANNING) {
        local_view_.planning_command = nullptr;
        planning_command_.Clear();
      }
      local_view_.pad_msg = std::make_shared<PadMessage>(pad_msg_);
    }
  }
  {
    std::lock_guard<std::mutex> lock(mutex_);
    local_view_.stories = std::make_shared<Stories>(stories_);
  }
  {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!local_view_.control_interactive_msg ||
        !common::util::IsProtoEqual(
            local_view_.control_interactive_msg->header(),
            control_interactive_msg_.header())) {
      local_view_.control_interactive_msg =
          std::make_shared<ControlInteractiveMsg>(control_interactive_msg_);
    }
  }
 
  if (!CheckInput()) {
    AINFO << "Input check failed";
    return false;
  }
 
  if (config_.learning_mode() != PlanningConfig::NO_LEARNING) {
    // data process for online training
    message_process_.OnChassis(*local_view_.chassis);
    message_process_.OnPrediction(*local_view_.prediction_obstacles);
    if (local_view_.planning_command->has_lane_follow_command()) {
      message_process_.OnRoutingResponse(
          local_view_.planning_command->lane_follow_command());
    }
    message_process_.OnStoryTelling(*local_view_.stories);
    message_process_.OnTrafficLightDetection(*local_view_.traffic_light);
    message_process_.OnLocalization(*local_view_.localization_estimate);
  }
 
  // publish learning data frame for RL test
  if (config_.learning_mode() == PlanningConfig::RL_TEST) {
    PlanningLearningData planning_learning_data;
    LearningDataFrame* learning_data_frame =
        injector_->learning_based_data()->GetLatestLearningDataFrame();
    if (learning_data_frame) {
      planning_learning_data.mutable_learning_data_frame()->CopyFrom(
          *learning_data_frame);
      common::util::FillHeader(node_->Name(), &planning_learning_data);
      planning_learning_data_writer_->Write(planning_learning_data);
    } else {
      AERROR << "fail to generate learning data frame";
      return false;
    }
    return true;
  }
 
  ADCTrajectory adc_trajectory_pb;
  planning_base_->RunOnce(local_view_, &adc_trajectory_pb);
  auto start_time = adc_trajectory_pb.header().timestamp_sec();
  common::util::FillHeader(node_->Name(), &adc_trajectory_pb);
 
  SetLocation(&adc_trajectory_pb);
  // modify trajectory relative time due to the timestamp change in header
  const double dt = start_time - adc_trajectory_pb.header().timestamp_sec();
  for (auto& p : *adc_trajectory_pb.mutable_trajectory_point()) {
    p.set_relative_time(p.relative_time() + dt);
  }
  planning_writer_->Write(adc_trajectory_pb);
 
  // Send command execution feedback.
  // Error occured while executing the command.
  external_command::CommandStatus command_status;
  common::util::FillHeader(node_->Name(), &command_status);
  if (nullptr != local_view_.planning_command) {
    command_status.set_command_id(local_view_.planning_command->command_id());
  }
 
  ADCTrajectory::TrajectoryType current_trajectory_type =
      adc_trajectory_pb.trajectory_type();
  if (adc_trajectory_pb.header().status().error_code() !=
      common::ErrorCode::OK) {
    command_status.set_status(external_command::CommandStatusType::ERROR);
    command_status.set_message(adc_trajectory_pb.header().status().msg());
  } else if (planning_base_->IsPlanningFinished(current_trajectory_type)) {
    AINFO << "Set the external_command: FINISHED";
    command_status.set_status(external_command::CommandStatusType::FINISHED);
  } else {
    AINFO << "Set the external_command: RUNNING";
    command_status.set_status(external_command::CommandStatusType::RUNNING);
  }
  command_status_writer_->Write(command_status);
 
  // record in history
  auto* history = injector_->history();
  history->Add(adc_trajectory_pb);
 
  return true;
}

---

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

• modules/planning/planning_component/planning_component.h
• modules/planning/planning_component/planning_component.cc