apollo::guardian::GuardianComponent类 参考

#include <guardian_component.h>

类 apollo::guardian::GuardianComponent 继承关系图:

apollo::guardian::GuardianComponent 的协作图:

Public 成员函数
bool	Init () override
bool	Proc () override
	The Proc logic of the component, which called by the CyberRT frame.
Public 成员函数 继承自 apollo::cyber::TimerComponent
	TimerComponent ()
	~TimerComponent () override
bool	Initialize (const TimerComponentConfig &config) override
	init the component by protobuf object.
void	Clear () override
bool	Process ()
uint32_t	GetInterval () const
Public 成员函数 继承自 apollo::cyber::ComponentBase
virtual	~ComponentBase ()
virtual bool	Initialize (const ComponentConfig &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
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_

详细描述

在文件 guardian_component.h 第 42 行定义.

成员函数说明

Init()

bool apollo::guardian::GuardianComponent::Init ( )

overridevirtual

实现了 apollo::cyber::ComponentBase.

在文件 guardian_component.cc 第 31 行定义.

                             {
  if (!GetProtoConfig(&guardian_conf_)) {
    AERROR << "Unable to load canbus conf file: " << ConfigFilePath();
    return false;
  }
 
  chassis_reader_ = node_->CreateReader<Chassis>(
      FLAGS_chassis_topic, [this](const std::shared_ptr<Chassis>& chassis) {
        ADEBUG << "Received chassis data: run chassis callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        chassis_.CopyFrom(*chassis);
      });
 
  control_cmd_reader_ = node_->CreateReader<ControlCommand>(
      FLAGS_control_command_topic,
      [this](const std::shared_ptr<ControlCommand>& cmd) {
        ADEBUG << "Received control data: run control callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        control_cmd_.CopyFrom(*cmd);
      });
 
  system_status_reader_ = node_->CreateReader<SystemStatus>(
      FLAGS_system_status_topic,
      [this](const std::shared_ptr<SystemStatus>& status) {
        ADEBUG << "Received system status data: run system status callback.";
        std::lock_guard<std::mutex> lock(mutex_);
        last_status_received_s_ = Time::Now().ToSecond();
        system_status_.CopyFrom(*status);
      });
 
  guardian_writer_ = node_->CreateWriter<GuardianCommand>(FLAGS_guardian_topic);
 
  return true;
}

Proc()

bool apollo::guardian::GuardianComponent::Proc ( )

overridevirtual

The Proc logic of the component, which called by the CyberRT frame.

返回

returns true if successful, otherwise returns false

实现了 apollo::cyber::TimerComponent.

在文件 guardian_component.cc 第 66 行定义.

                             {
  constexpr double kSecondsTillTimeout(2.5);
 
  bool safety_mode_triggered = false;
  if (guardian_conf_.guardian_enable()) {
    std::lock_guard<std::mutex> lock(mutex_);
    if (Time::Now().ToSecond() - last_status_received_s_ >
        kSecondsTillTimeout) {
      safety_mode_triggered = true;
    }
    safety_mode_triggered =
        safety_mode_triggered || system_status_.has_safety_mode_trigger_time();
  }
 
  if (safety_mode_triggered) {
    ADEBUG << "Safety mode triggered, enable safety mode";
    TriggerSafetyMode();
  } else {
    ADEBUG << "Safety mode not triggered, bypass control command";
    PassThroughControlCommand();
  }
 
  common::util::FillHeader(node_->Name(), &guardian_cmd_);
  guardian_writer_->Write(guardian_cmd_);
  return true;
}

---

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

• modules/guardian/guardian_component.h
• modules/guardian/guardian_component.cc