#include <gem_controller.h>

类 apollo::canbus::gem::GemController 继承关系图:

apollo::canbus::gem::GemController 的协作图:

Public 成员函数
	GemController ()

virtual	~GemController ()

::apollo::common::ErrorCode	Init (const VehicleParameter &params, CanSender<::apollo::canbus::Gem > const can_sender, MessageManager<::apollo::canbus::Gem > const message_manager) override

bool	Start () override
	start the vehicle controller.

void	Stop () override
	stop the vehicle controller.

Chassis	chassis () override
	calculate and return the chassis.

	FRIEND_TEST (GemControllerTest, SetDrivingMode)

	FRIEND_TEST (GemControllerTest, Status)

	FRIEND_TEST (GemControllerTest, UpdateDrivingMode)

Public 成员函数继承自 apollo::canbus::VehicleController<::apollo::canbus::Gem >
virtual	~VehicleController ()=default

virtual common::ErrorCode	Init (const VehicleParameter &params, CanSender< ::apollo::canbus::Gem > const can_sender, MessageManager< ::apollo::canbus::Gem > const message_manager)=0
	initialize the vehicle controller.

virtual common::ErrorCode	Update (const control::ControlCommand &command)
	update the vehicle controller.

virtual common::ErrorCode	Update (const external_command::ChassisCommand &command)

virtual common::ErrorCode	SetDrivingMode (const Chassis::DrivingMode &driving_mode)
	set vehicle to appointed driving mode.

virtual bool	CheckChassisCommunicationError ()

virtual void	AddSendMessage ()

virtual ::apollo::canbus::Gem	GetNewRecvChassisDetail ()

virtual ::apollo::canbus::Gem	GetNewSenderChassisDetail ()

virtual Chassis::DrivingMode	driving_mode ()

额外继承的成员函数
Protected 成员函数继承自 apollo::canbus::VehicleController<::apollo::canbus::Gem >
virtual void	set_driving_mode (const Chassis::DrivingMode &driving_mode)

Protected 属性继承自 apollo::canbus::VehicleController<::apollo::canbus::Gem >
common::VehicleSignal	last_chassis_command_

common::VehicleSignal	last_control_command_

canbus::VehicleParameter	params_

common::VehicleParam	vehicle_params_

CanSender< ::apollo::canbus::Gem > *	can_sender_

CanReceiver< ::apollo::canbus::Gem > *	can_receiver_

MessageManager< ::apollo::canbus::Gem > *	message_manager_

bool	is_initialized_

Chassis::DrivingMode	driving_mode_

bool	is_reset_

std::mutex	mode_mutex_

uint32_t	lost_chassis_reveive_detail_count_

bool	is_need_count_

size_t	sender_data_size_previous_

int64_t	start_time_

bool	is_chassis_communication_error_

详细描述

在文件 gem_controller.h 第 41 行定义.

构造及析构函数说明

◆ GemController()

apollo::canbus::gem::GemController::GemController ( )

inline

在文件 gem_controller.h 第 43 行定义.

43{}

◆ ~GemController()

apollo::canbus::gem::GemController::~GemController ( )

virtual

在文件 gem_controller.cc 第 131 行定义.

131{}

成员函数说明

◆ chassis()

Chassis apollo::canbus::gem::GemController::chassis ( )

overridevirtual

calculate and return the chassis.

返回: a copy of chassis. Use copy here to avoid multi-thread issues.

实现了 apollo::canbus::VehicleController<::apollo::canbus::Gem >.

在文件 gem_controller.cc 第 157 行定义.

                               {
  chassis_.Clear();
 
  Gem chassis_detail;
  message_manager_->GetSensorData(&chassis_detail);
 
  // 21, 22, previously 1, 2
  if (driving_mode() == Chassis::EMERGENCY_MODE) {
    set_chassis_error_code(Chassis::NO_ERROR);
  }
 
  chassis_.set_driving_mode(driving_mode());
  chassis_.set_error_code(chassis_error_code());
 
  // 3
  chassis_.set_engine_started(true);
 
  // 5
  if (chassis_detail.has_vehicle_speed_rpt_6f() &&
      chassis_detail.vehicle_speed_rpt_6f().has_vehicle_speed()) {
    chassis_.set_speed_mps(static_cast<float>(
        chassis_detail.vehicle_speed_rpt_6f().vehicle_speed()));
  } else {
    chassis_.set_speed_mps(0);
  }
 
  // 7
  chassis_.set_fuel_range_m(0);
  // 8
  if (chassis_detail.has_accel_rpt_68() &&
      chassis_detail.accel_rpt_68().has_output_value()) {
    chassis_.set_throttle_percentage(
        static_cast<float>(chassis_detail.accel_rpt_68().output_value()));
  } else {
    chassis_.set_throttle_percentage(0);
  }
  // 9
  if (chassis_detail.has_brake_rpt_6c() &&
      chassis_detail.brake_rpt_6c().has_output_value()) {
    chassis_.set_brake_percentage(
        static_cast<float>(chassis_detail.brake_rpt_6c().output_value()));
  } else {
    chassis_.set_brake_percentage(0);
  }
 
  // 23, previously 10
  if (chassis_detail.has_shift_rpt_66() &&
      chassis_detail.shift_rpt_66().has_output_value()) {
    Chassis::GearPosition gear_pos = Chassis::GEAR_INVALID;
 
    if (chassis_detail.shift_rpt_66().output_value() ==
        Shift_rpt_66::OUTPUT_VALUE_NEUTRAL) {
      gear_pos = Chassis::GEAR_NEUTRAL;
    }
    if (chassis_detail.shift_rpt_66().output_value() ==
        Shift_rpt_66::OUTPUT_VALUE_REVERSE) {
      gear_pos = Chassis::GEAR_REVERSE;
    }
    if (chassis_detail.shift_rpt_66().output_value() ==
        Shift_rpt_66::OUTPUT_VALUE_FORWARD) {
      gear_pos = Chassis::GEAR_DRIVE;
    }
 
    chassis_.set_gear_location(gear_pos);
  } else {
    chassis_.set_gear_location(Chassis::GEAR_NONE);
  }
 
  // 11
  // TODO(QiL) : verify the unit here.
  if (chassis_detail.has_steering_rpt_1_6e() &&
      chassis_detail.steering_rpt_1_6e().has_output_value()) {
    chassis_.set_steering_percentage(
        static_cast<float>(chassis_detail.steering_rpt_1_6e().output_value() *
                           100.0 / vehicle_params_.max_steer_angle()));
  } else {
    chassis_.set_steering_percentage(0);
  }
 
  if (chassis_detail.has_global_rpt_6a() &&
      chassis_detail.global_rpt_6a().has_pacmod_status()) {
    if (chassis_detail.global_rpt_6a().pacmod_status() ==
        Global_rpt_6a::PACMOD_STATUS_CONTROL_ENABLED) {
      chassis_.set_driving_mode(Chassis::COMPLETE_AUTO_DRIVE);
      global_cmd_69_->set_clear_override(
          Global_cmd_69::CLEAR_OVERRIDE_DON_T_CLEAR_ACTIVE_OVERRIDES);
    } else {
      chassis_.set_driving_mode(Chassis::COMPLETE_MANUAL);
    }
  } else {
    chassis_.set_driving_mode(Chassis::COMPLETE_MANUAL);
  }
 
  // TODO(QiL) : implement the turn light signal here
 
  // 16, 17
  if (chassis_detail.has_light() &&
      chassis_detail.light().has_turn_light_type() &&
      chassis_detail.light().turn_light_type() != Light::TURN_LIGHT_OFF) {
    if (chassis_detail.light().turn_light_type() == Light::TURN_LEFT_ON) {
      chassis_.mutable_signal()->set_turn_signal(
          common::VehicleSignal::TURN_LEFT);
    } else if (chassis_detail.light().turn_light_type() ==
               Light::TURN_RIGHT_ON) {
      chassis_.mutable_signal()->set_turn_signal(
          common::VehicleSignal::TURN_RIGHT);
    } else {
      chassis_.mutable_signal()->set_turn_signal(
          common::VehicleSignal::TURN_NONE);
    }
  } else {
    chassis_.mutable_signal()->set_turn_signal(
        common::VehicleSignal::TURN_NONE);
  }
 
  // TODO(all): implement the rest here/
  // 26
  if (chassis_error_mask_) {
    chassis_.set_chassis_error_mask(chassis_error_mask_);
  }
 
  // Give engage_advice based on error_code and canbus feedback
  if (!chassis_error_mask_ && !chassis_.parking_brake() &&
      chassis_.throttle_percentage() == 0.0 &&
      chassis_.brake_percentage() != 0.0) {
    chassis_.mutable_engage_advice()->set_advice(
        apollo::common::EngageAdvice::READY_TO_ENGAGE);
  } else {
    chassis_.mutable_engage_advice()->set_advice(
        apollo::common::EngageAdvice::DISALLOW_ENGAGE);
    chassis_.mutable_engage_advice()->set_reason(
        "CANBUS not ready, firmware error or emergency button pressed!");
  }
 
  return chassis_;
}

◆ FRIEND_TEST() [1/3]

apollo::canbus::gem::GemController::FRIEND_TEST	(	GemControllerTest	,
		SetDrivingMode
	)

◆ FRIEND_TEST() [2/3]

apollo::canbus::gem::GemController::FRIEND_TEST	(	GemControllerTest	,
		Status
	)

◆ FRIEND_TEST() [3/3]

apollo::canbus::gem::GemController::FRIEND_TEST	(	GemControllerTest	,
		UpdateDrivingMode
	)

◆ Init()

ErrorCode apollo::canbus::gem::GemController::Init	(	const VehicleParameter &	params,
		CanSender<::apollo::canbus::Gem > *const	can_sender,
		MessageManager<::apollo::canbus::Gem > *const	message_manager
	)

override

在文件 gem_controller.cc 第 48 行定义.

                                                            {
  if (is_initialized_) {
    AINFO << "GemController has already been initialized.";
    return ErrorCode::CANBUS_ERROR;
  }
  vehicle_params_.CopyFrom(
      common::VehicleConfigHelper::Instance()->GetConfig().vehicle_param());
  params_.CopyFrom(params);
  if (!params_.has_driving_mode()) {
    AERROR << "Vehicle conf pb not set driving_mode.";
    return ErrorCode::CANBUS_ERROR;
  }
 
  if (can_sender == nullptr) {
    AERROR << "Canbus sender is null.";
    return ErrorCode::CANBUS_ERROR;
  }
  can_sender_ = can_sender;
 
  if (message_manager == nullptr) {
    AERROR << "Protocol manager is null.";
    return ErrorCode::CANBUS_ERROR;
  }
  message_manager_ = message_manager;
 
  // Sender part
  brake_cmd_6b_ = dynamic_cast<Brakecmd6b*>(
      message_manager_->GetMutableProtocolDataById(Brakecmd6b::ID));
  if (brake_cmd_6b_ == nullptr) {
    AERROR << "Brakecmd6b does not exist in the GemMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  accel_cmd_67_ = dynamic_cast<Accelcmd67*>(
      message_manager_->GetMutableProtocolDataById(Accelcmd67::ID));
  if (accel_cmd_67_ == nullptr) {
    AERROR << "Accelcmd67 does not exist in the GemMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  steering_cmd_6d_ = dynamic_cast<Steeringcmd6d*>(
      message_manager_->GetMutableProtocolDataById(Steeringcmd6d::ID));
  if (steering_cmd_6d_ == nullptr) {
    AERROR << "Steeringcmd6d does not exist in the GemMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  shift_cmd_65_ = dynamic_cast<Shiftcmd65*>(
      message_manager_->GetMutableProtocolDataById(Shiftcmd65::ID));
  if (shift_cmd_65_ == nullptr) {
    AERROR << "Shiftcmd65 does not exist in the GemMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
  turn_cmd_63_ = dynamic_cast<Turncmd63*>(
      message_manager_->GetMutableProtocolDataById(Turncmd63::ID));
  if (turn_cmd_63_ == nullptr) {
    AERROR << "Turncmd63 does not exist in the GemMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
  global_cmd_69_ = dynamic_cast<Globalcmd69*>(
      message_manager_->GetMutableProtocolDataById(Globalcmd69::ID));
  if (global_cmd_69_ == nullptr) {
    AERROR << "Turncmd63 does not exist in the GemMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  can_sender_->AddMessage(Brakecmd6b::ID, brake_cmd_6b_, false);
  can_sender_->AddMessage(Accelcmd67::ID, accel_cmd_67_, false);
  can_sender_->AddMessage(Steeringcmd6d::ID, steering_cmd_6d_, false);
  can_sender_->AddMessage(Shiftcmd65::ID, shift_cmd_65_, false);
  can_sender_->AddMessage(Turncmd63::ID, turn_cmd_63_, false);
  can_sender_->AddMessage(Globalcmd69::ID, global_cmd_69_, false);
 
  // Need to sleep to ensure all messages received.
  AINFO << "GemController is initialized.";
 
  is_initialized_ = true;
  return ErrorCode::OK;
}

◆ Start()

bool apollo::canbus::gem::GemController::Start ( )

overridevirtual

start the vehicle controller.

返回: true if successfully started.

实现了 apollo::canbus::VehicleController<::apollo::canbus::Gem >.

在文件 gem_controller.cc 第 133 行定义.

                          {
  if (!is_initialized_) {
    AERROR << "GemController has NOT been initiated.";
    return false;
  }
  const auto& update_func = [this] { SecurityDogThreadFunc(); };
  thread_.reset(new std::thread(update_func));
 
  return true;
}

◆ Stop()

void apollo::canbus::gem::GemController::Stop ( )

overridevirtual

stop the vehicle controller.

实现了 apollo::canbus::VehicleController<::apollo::canbus::Gem >.

在文件 gem_controller.cc 第 144 行定义.

                         {
  if (!is_initialized_) {
    AERROR << "GemController stops or starts improperly!";
    return;
  }
 
  if (thread_ != nullptr && thread_->joinable()) {
    thread_->join();
    thread_.reset();
    AINFO << "GemController stopped.";
  }
}

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

modules/canbus_vehicle/gem/gem_controller.h
modules/canbus_vehicle/gem/gem_controller.cc

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ GemController()

◆ ~GemController()

成员函数说明

◆ chassis()

◆ FRIEND_TEST() [1/3]

◆ FRIEND_TEST() [2/3]

◆ FRIEND_TEST() [3/3]

◆ Init()

◆ Start()

◆ Stop()