ExternalCommandDemo类 参考

#include <external_command_demo.h>

类 ExternalCommandDemo 继承关系图:

ExternalCommandDemo 的协作图:

Public 成员函数
	ExternalCommandDemo ()
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_

详细描述

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

构造及析构函数说明

ExternalCommandDemo()

ExternalCommandDemo::ExternalCommandDemo

(

)

在文件 external_command_demo.cc 第 30 行定义.

    : command_id_(0), module_name_("demo") {}

成员函数说明

Init()

bool ExternalCommandDemo::Init ( )

overridevirtual

实现了 apollo::cyber::ComponentBase.

在文件 external_command_demo.cc 第 33 行定义.

                               {
  action_command_client_ =
      node_->CreateClient<apollo::external_command::ActionCommand,
                          CommandStatus>("/apollo/external_command/action");
  chassis_command_client_ =
      node_->CreateClient<apollo::external_command::ChassisCommand,
                          CommandStatus>("/apollo/external_command/chassis");
  free_space_command_client_ =
      node_->CreateClient<apollo::external_command::FreeSpaceCommand,
                          CommandStatus>("/apollo/external_command/free_space");
  lane_follow_command_client_ =
      node_->CreateClient<apollo::external_command::LaneFollowCommand,
                          CommandStatus>(
          "/apollo/external_command/lane_follow");
  path_follow_command_client_ =
      node_->CreateClient<apollo::external_command::PathFollowCommand,
                          CommandStatus>(
          "/apollo/external_command/path_follow");
  speed_command_client_ =
      node_
          ->CreateClient<apollo::external_command::SpeedCommand, CommandStatus>(
              "/apollo/external_command/speed");
  valet_parking_command_client_ =
      node_->CreateClient<apollo::external_command::ValetParkingCommand,
                          CommandStatus>(
          "/apollo/external_command/valet_parking");
  status_client_ =
      node_->CreateClient<apollo::external_command::CommandStatusRequest,
                          CommandStatus>(
          "/apollo/external_command/command_status");
  apollo::cyber::common::GetProtoFromFile(
      "modules/external_command/external_command_demo/conf/"
      "demo_config.pb.txt",
      &demo_config_);
  return true;
}

Proc()

bool ExternalCommandDemo::Proc ( )

overridevirtual

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

返回

returns true if successful, otherwise returns false

实现了 apollo::cyber::TimerComponent.

在文件 external_command_demo.cc 第 70 行定义.

                               {
  int8_t revent = 0;  // short
  struct pollfd fd = {STDIN_FILENO, POLLIN, revent};
  switch (poll(&fd, 1, 100)) {
    case -1:
      std::cout << "Failed to read keyboard" << std::endl;
      return false;
    case 0:
      return true;
    default:
      char data[50];
      std::cin.getline(data, 50);
      std::string input_command_string = data;
      if (input_command_string == "pull_over") {
        // Pull over.
        SendActionCommand(
            apollo::external_command::ActionCommandType::PULL_OVER);
      } else if (input_command_string == "stop") {
        // Stop planning.
        SendActionCommand(apollo::external_command::ActionCommandType::STOP);
      } else if (input_command_string == "start") {
        // Start planning.
        SendActionCommand(apollo::external_command::ActionCommandType::START);
      } else if (input_command_string == "clear") {
        // Start planning.
        SendActionCommand(
            apollo::external_command::ActionCommandType::CLEAR_PLANNING);
      } else if (input_command_string == "manual") {
        // Switch manual mode.
        SendActionCommand(
            apollo::external_command::ActionCommandType::SWITCH_TO_MANUAL);
      } else if (input_command_string == "auto") {
        // Switch auto mode.
        SendActionCommand(
            apollo::external_command::ActionCommandType::SWITCH_TO_AUTO);
      } else if (input_command_string == "vin") {
        // Send vin validation.
        SendActionCommand(apollo::external_command::ActionCommandType::VIN_REQ);
      } else if (input_command_string == "enter_mission") {
        // Enter mission model.
        SendActionCommand(
            apollo::external_command::ActionCommandType::ENTER_MISSION);
      } else if (input_command_string == "exit_mission") {
        // Exit mission model.
        SendActionCommand(
            apollo::external_command::ActionCommandType::EXIT_MISSION);
      } else if (input_command_string == "chassis") {
        SendVehicleSignalCommand();
      } else if (input_command_string == "custom_chassis") {
        SendCustomChassisCommand();
      } else if (input_command_string.find("set_speed") != std::string::npos) {
        auto index = input_command_string.find("set_speed");
        std::string speed_value_string = input_command_string.substr(
            index + std::string("set_speed").length(),
            input_command_string.length());
        if (!speed_value_string.empty()) {
          double speed_value = std::atof(speed_value_string.c_str());
          SendSpeedCommand(speed_value);
        } else {
          AWARN << "Input format is invalid, please input format like: "
                   "set_speed 1.5";
        }
      } else if (input_command_string == "increase_speed") {
        double speed_factor = 1.2;
        SendSpeedFactorCommand(speed_factor);
      } else if (input_command_string == "decrease_speed") {
        double speed_factor = 0.8;
        SendSpeedFactorCommand(speed_factor);
      } else if (input_command_string == "restore_speed") {
        RestoreSpeed();
      } else if (input_command_string == "lane") {
        // Modify way point as needed.
        apollo::external_command::Pose way_point;
        way_point.set_x(0.0);
        way_point.set_y(0.0);
        way_point.set_heading(0.0);
        std::vector<apollo::external_command::Pose> way_points;
        way_points.emplace_back(way_point);
        apollo::external_command::Pose end_pose;
        end_pose.set_x(10.0);
        end_pose.set_y(0.0);
        end_pose.set_heading(0.0);
        SendLaneFollowCommand(way_points, end_pose,
                              demo_config_.target_speed());
      } else if (input_command_string == "path_loc") {
        SendPathFollowCommandWithLocationRecord(
            demo_config_.file_of_path_follow_with_localization_record());
      } else if (input_command_string == "path_path") {
        SendPathFollowCommandWithPathRecord(
            demo_config_.file_of_path_follow_with_planning_record());
      } else if (input_command_string == "valet_parking") {
        std::string parking_spot_id = "451089045";
        SendValetParkingCommand(parking_spot_id, demo_config_.target_speed());
      } else if (input_command_string.find("command_status") !=
                 std::string::npos) {
        // Input command with format: command_status=XX, where XX is the
        // command_id
        const size_t start_pos = std::string("command_status=").length();
        const size_t end_pos = input_command_string.length();
        if (end_pos <= start_pos) {
          std::cout
              << "Please check command status with format: command_status=XX!"
              << std::endl;
          break;
        }
        std::string command_id_string =
            input_command_string.substr(start_pos, end_pos);
        command_id_string.erase(
            std::remove_if(command_id_string.begin(), command_id_string.end(),
                           ::isspace),
            command_id_string.end());
        uint64_t id = std::atoi(command_id_string.c_str());
        CheckCommandStatus(id);
      } else if (input_command_string == "free1") {
        apollo::external_command::Pose end_pose;
        end_pose.set_x(437556.02);
        end_pose.set_y(4432540.34);
        end_pose.set_heading(1.8);
        std::vector<apollo::external_command::Point> way_points;
        apollo::external_command::Point point1;
        apollo::external_command::Point point2;
        apollo::external_command::Point point3;
        apollo::external_command::Point point4;
        point1.set_x(437536.29);
        point1.set_y(4432560.69);
        point2.set_x(437536.29);
        point2.set_y(4432510.69);
        point3.set_x(437576.29);
        point3.set_y(4432510.69);
        point4.set_x(437576.29);
        point4.set_y(4432560.69);
        way_points.emplace_back(point1);
        way_points.emplace_back(point2);
        way_points.emplace_back(point3);
        way_points.emplace_back(point4);
 
        SendFreespaceCommand(way_points, end_pose);
      } else {
        std::cout << "Invalid input!" << input_command_string << std::endl;
      }
  }
  return true;
}

---

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

• modules/external_command/external_command_demo/external_command_demo.h
• modules/external_command/external_command_demo/external_command_demo.cc