#include <task_manager_component.h>

类 apollo::task_manager::TaskManagerComponent 继承关系图:

apollo::task_manager::TaskManagerComponent 的协作图:

Public 成员函数
	TaskManagerComponent ()=default

	~TaskManagerComponent ()=default

bool	Init () override

bool	Proc (const std::shared_ptr< task_manager::Task > &task) override

Public 成员函数继承自 apollo::cyber::Component< task_manager::Task >
	Component ()

	~Component () override

bool	Initialize (const ComponentConfig &config) override
	init the component by protobuf object.

bool	Process (const std::shared_ptr< task_manager::Task > &msg0, const std::shared_ptr< NullType > &msg1, const std::shared_ptr< NullType > &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_

详细描述

在文件 task_manager_component.h 第 37 行定义.

构造及析构函数说明

◆ TaskManagerComponent()

apollo::task_manager::TaskManagerComponent::TaskManagerComponent ( )

default

◆ ~TaskManagerComponent()

apollo::task_manager::TaskManagerComponent::~TaskManagerComponent ( )

default

成员函数说明

◆ Init()

bool apollo::task_manager::TaskManagerComponent::Init ( )

overridevirtual

实现了 apollo::cyber::ComponentBase.

在文件 task_manager_component.cc 第 34 行定义.

                                {
  TaskManagerConfig task_manager_conf;
  ACHECK(cyber::ComponentBase::GetProtoConfig(&task_manager_conf))
      << "Unable to load task_manager conf file: "
      << cyber::ComponentBase::ConfigFilePath();
 
  AINFO << "Config file: " << cyber::ComponentBase::ConfigFilePath()
        << " is loaded.";
 
  localization_reader_ = node_->CreateReader<LocalizationEstimate>(
      task_manager_conf.topic_config().localization_pose_topic(),
      [this](const std::shared_ptr<LocalizationEstimate>& localization) {
        ADEBUG << "Received localization data: run localization callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        localization_.CopyFrom(*localization);
      });
 
  planning_command_reader_ = node_->CreateReader<PlanningCommand>(
      task_manager_conf.topic_config().planning_command_topic(),
      [this](const std::shared_ptr<PlanningCommand>& planning_command) {
        ADEBUG << "Received planning_command: run response callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        planning_command_.CopyFrom(*planning_command);
      });
 
  lane_follow_command_client_ =
      node_->CreateClient<LaneFollowCommand, CommandStatus>(
          task_manager_conf.topic_config().lane_follow_command_topic());
  return true;
}

◆ Proc()

bool apollo::task_manager::TaskManagerComponent::Proc ( const std::shared_ptr< task_manager::Task > & task )

override

在文件 task_manager_component.cc 第 65 行定义.

                                                               {
  if (task->task_type() != CYCLE_ROUTING) {
    AERROR << "Task type is not cycle_routing.";
    return false;
  }
 
  if (task->task_type() == CYCLE_ROUTING) {
    cycle_routing_manager_ = std::make_shared<CycleRoutingManager>();
    cycle_routing_manager_->Init(task->cycle_routing_task());
    lane_follow_command_ = task->cycle_routing_task().lane_follow_command();
    Rate rate(1.0);
 
    while (cycle_routing_manager_->GetCycle() > 0) {
      if (cycle_routing_manager_->GetNewRouting(localization_.pose(),
                                                &lane_follow_command_)) {
        auto last_planning_command_ = planning_command_;
        common::util::FillHeader(node_->Name(), &lane_follow_command_);
        auto lane_follow_command = std::make_shared<LaneFollowCommand>();
        lane_follow_command->CopyFrom(lane_follow_command_);
        lane_follow_command_client_->SendRequest(lane_follow_command);
        AINFO << "[TaskManagerComponent]Reach begin/end point: "
              << "routing manager send a routing request. ";
        rate.Sleep();
 
        if (!planning_command_.has_header()) {
          AINFO << "[TaskManagerComponent]routing failed";
          return false;
        }
        if (last_planning_command_.has_header()) {
          if (last_planning_command_.header().sequence_num() ==
              planning_command_.header().sequence_num()) {
            AINFO << "[TaskManagerComponent]No routing response: "
                  << "new routing failed";
            return false;
          }
        }
      }
      rate.Sleep();
    }
  }
  return true;
}

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

modules/task_manager/task_manager_component.h
modules/task_manager/task_manager_component.cc

Public 成员函数