#include <ge3_controller.h>

类 apollo::canbus::ge3::Ge3Controller 继承关系图:

apollo::canbus::ge3::Ge3Controller 的协作图:

Public 成员函数
	Ge3Controller ()

virtual	~Ge3Controller ()

::apollo::common::ErrorCode	Init (const VehicleParameter &params, CanSender<::apollo::canbus::Ge3 > const can_sender, MessageManager<::apollo::canbus::Ge3 > 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 (Ge3ControllerTest, SetDrivingMode)

	FRIEND_TEST (Ge3ControllerTest, Status)

	FRIEND_TEST (Ge3ControllerTest, UpdateDrivingMode)

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

virtual common::ErrorCode	Init (const VehicleParameter &params, CanSender< ::apollo::canbus::Ge3 > const can_sender, MessageManager< ::apollo::canbus::Ge3 > 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::Ge3	GetNewRecvChassisDetail ()

virtual ::apollo::canbus::Ge3	GetNewSenderChassisDetail ()

virtual Chassis::DrivingMode	driving_mode ()

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

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

common::VehicleSignal	last_control_command_

canbus::VehicleParameter	params_

common::VehicleParam	vehicle_params_

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

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

MessageManager< ::apollo::canbus::Ge3 > *	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_

详细描述

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

构造及析构函数说明

◆ Ge3Controller()

apollo::canbus::ge3::Ge3Controller::Ge3Controller ( )

inline

在文件 ge3_controller.h 第 39 行定义.

39{}

◆ ~Ge3Controller()

apollo::canbus::ge3::Ge3Controller::~Ge3Controller ( )

virtual

在文件 ge3_controller.cc 第 120 行定义.

120{}

成员函数说明

◆ chassis()

Chassis apollo::canbus::ge3::Ge3Controller::chassis ( )

overridevirtual

calculate and return the chassis.

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

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

在文件 ge3_controller.cc 第 146 行定义.

                               {
  chassis_.Clear();
 
  Ge3 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_scu_bcs_3_308()) {
    Scu_bcs_3_308 scu_bcs_3_308 = chassis_detail.scu_bcs_3_308();
    if (scu_bcs_3_308.has_bcs_rrwheelspd()) {
      if (chassis_.has_wheel_speed()) {
        chassis_.mutable_wheel_speed()->set_is_wheel_spd_rr_valid(
            scu_bcs_3_308.bcs_rrwheelspdvd());
        chassis_.mutable_wheel_speed()->set_wheel_direction_rr(
            (WheelSpeed::WheelSpeedType)scu_bcs_3_308.bcs_rrwheeldirection());
        chassis_.mutable_wheel_speed()->set_wheel_spd_rr(
            scu_bcs_3_308.bcs_rrwheelspd());
      }
    }
 
    if (scu_bcs_3_308.has_bcs_rlwheelspd()) {
      if (chassis_.has_wheel_speed()) {
        chassis_.mutable_wheel_speed()->set_is_wheel_spd_rl_valid(
            scu_bcs_3_308.bcs_rlwheelspdvd());
        chassis_.mutable_wheel_speed()->set_wheel_direction_rl(
            (WheelSpeed::WheelSpeedType)scu_bcs_3_308.bcs_rlwheeldirection());
        chassis_.mutable_wheel_speed()->set_wheel_spd_rl(
            scu_bcs_3_308.bcs_rlwheelspd());
      }
    }
 
    if (scu_bcs_3_308.has_bcs_frwheelspd()) {
      if (chassis_.has_wheel_speed()) {
        chassis_.mutable_wheel_speed()->set_is_wheel_spd_fr_valid(
            scu_bcs_3_308.bcs_frwheelspdvd());
        chassis_.mutable_wheel_speed()->set_wheel_direction_fr(
            (WheelSpeed::WheelSpeedType)scu_bcs_3_308.bcs_frwheeldirection());
        chassis_.mutable_wheel_speed()->set_wheel_spd_fr(
            scu_bcs_3_308.bcs_frwheelspd());
      }
    }
 
    if (scu_bcs_3_308.has_bcs_flwheelspd()) {
      if (chassis_.has_wheel_speed()) {
        chassis_.mutable_wheel_speed()->set_is_wheel_spd_fl_valid(
            scu_bcs_3_308.bcs_flwheelspdvd());
        chassis_.mutable_wheel_speed()->set_wheel_direction_fl(
            (WheelSpeed::WheelSpeedType)scu_bcs_3_308.bcs_flwheeldirection());
        chassis_.mutable_wheel_speed()->set_wheel_spd_fl(
            scu_bcs_3_308.bcs_flwheelspd());
      }
    }
  }
 
  if (chassis_detail.has_scu_bcs_2_307() &&
      chassis_detail.scu_bcs_2_307().has_bcs_vehspd()) {
    chassis_.set_speed_mps(
        static_cast<float>(chassis_detail.scu_bcs_2_307().bcs_vehspd()));
  } else {
    chassis_.set_speed_mps(0);
  }
 
  // 7
  // ge3 only has fuel percentage
  // to avoid confusing, just don't set
  chassis_.set_fuel_range_m(0);
 
  if (chassis_detail.has_scu_vcu_1_312() &&
      chassis_detail.scu_vcu_1_312().has_vcu_accpedact()) {
    chassis_.set_throttle_percentage(
        static_cast<float>(chassis_detail.scu_vcu_1_312().vcu_accpedact()));
  } else {
    chassis_.set_throttle_percentage(0);
  }
  // 9
  if (chassis_detail.has_scu_bcs_1_306() &&
      chassis_detail.scu_bcs_1_306().has_bcs_brkpedact()) {
    chassis_.set_brake_percentage(
        static_cast<float>(chassis_detail.scu_bcs_1_306().bcs_brkpedact()));
  } else {
    chassis_.set_brake_percentage(0);
  }
  // 23, previously 10
  if (chassis_detail.has_scu_vcu_1_312() &&
      chassis_detail.scu_vcu_1_312().has_vcu_gearact()) {
    switch (chassis_detail.scu_vcu_1_312().vcu_gearact()) {
      case Scu_vcu_1_312::VCU_GEARACT_INVALID: {
        chassis_.set_gear_location(Chassis::GEAR_INVALID);
      } break;
      case Scu_vcu_1_312::VCU_GEARACT_DRIVE: {
        chassis_.set_gear_location(Chassis::GEAR_DRIVE);
      } break;
      case Scu_vcu_1_312::VCU_GEARACT_NEUTRAL: {
        chassis_.set_gear_location(Chassis::GEAR_NEUTRAL);
      } break;
      case Scu_vcu_1_312::VCU_GEARACT_REVERSE: {
        chassis_.set_gear_location(Chassis::GEAR_REVERSE);
      } break;
      case Scu_vcu_1_312::VCU_GEARACT_PARK: {
        chassis_.set_gear_location(Chassis::GEAR_PARKING);
      } break;
      default:
        chassis_.set_gear_location(Chassis::GEAR_INVALID);
        break;
    }
  } else {
    chassis_.set_gear_location(Chassis::GEAR_INVALID);
  }
 
  // 11
  if (chassis_detail.has_scu_eps_311() &&
      chassis_detail.scu_eps_311().has_eps_steerangle()) {
    chassis_.set_steering_percentage(
        static_cast<float>(chassis_detail.scu_eps_311().eps_steerangle() /
                           vehicle_params_.max_steer_angle() * M_PI / 1.80));
  } else {
    chassis_.set_steering_percentage(0);
  }
 
  // 13
  if (chassis_detail.has_scu_epb_310() &&
      chassis_detail.scu_epb_310().has_epb_sysst()) {
    chassis_.set_parking_brake(chassis_detail.scu_epb_310().epb_sysst() ==
                               Scu_epb_310::EPB_SYSST_APPLIED);
  } else {
    chassis_.set_parking_brake(false);
  }
 
  // 14, 15: ge3 light control
  if (chassis_detail.has_scu_bcm_304() &&
      chassis_detail.scu_bcm_304().has_bcm_highbeamst() &&
      Scu_bcm_304::BCM_HIGHBEAMST_ACTIVE ==
          chassis_detail.scu_bcm_304().bcm_highbeamst()) {
    if (chassis_.has_signal()) {
      chassis_.mutable_signal()->set_high_beam(true);
    }
  } else {
    if (chassis_.has_signal()) {
      chassis_.mutable_signal()->set_high_beam(false);
    }
  }
 
  // 16, 17
  if (chassis_detail.has_scu_bcm_304()) {
    Scu_bcm_304 scu_bcm_304 = chassis_detail.scu_bcm_304();
    if (scu_bcm_304.has_bcm_leftturnlampst() &&
        Scu_bcm_304::BCM_LEFTTURNLAMPST_ACTIVE ==
            scu_bcm_304.bcm_leftturnlampst()) {
      chassis_.mutable_signal()->set_turn_signal(
          common::VehicleSignal::TURN_LEFT);
    } else if (scu_bcm_304.has_bcm_rightturnlampst() &&
               Scu_bcm_304::BCM_RIGHTTURNLAMPST_ACTIVE ==
                   scu_bcm_304.bcm_rightturnlampst()) {
      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);
  }
  // 18
  if (chassis_detail.has_scu_bcm_304() &&
      chassis_detail.scu_bcm_304().has_bcm_hornst() &&
      Scu_bcm_304::BCM_HORNST_ACTIVE ==
          chassis_detail.scu_bcm_304().bcm_hornst()) {
    chassis_.mutable_signal()->set_horn(true);
  } else {
    chassis_.mutable_signal()->set_horn(false);
  }
 
  // vin number will be written into KVDB once.
  chassis_.mutable_vehicle_id()->set_vin("");
  if (chassis_detail.has_scu_1_301() && chassis_detail.has_scu_2_302() &&
      chassis_detail.has_scu_3_303()) {
    Scu_1_301 scu_1_301 = chassis_detail.scu_1_301();
    Scu_2_302 scu_2_302 = chassis_detail.scu_2_302();
    Scu_3_303 scu_3_303 = chassis_detail.scu_3_303();
    if (scu_2_302.has_vin00() && scu_2_302.has_vin01() &&
        scu_2_302.has_vin02() && scu_2_302.has_vin03() &&
        scu_2_302.has_vin04() && scu_2_302.has_vin05() &&
        scu_2_302.has_vin06() && scu_2_302.has_vin07() &&
        scu_3_303.has_vin08() && scu_3_303.has_vin09() &&
        scu_3_303.has_vin10() && scu_3_303.has_vin11() &&
        scu_3_303.has_vin12() && scu_3_303.has_vin13() &&
        scu_3_303.has_vin14() && scu_3_303.has_vin15() &&
        scu_1_301.has_vin16()) {
      int n[17];
      n[0] = scu_2_302.vin00();
      n[1] = scu_2_302.vin01();
      n[2] = scu_2_302.vin02();
      n[3] = scu_2_302.vin03();
      n[4] = scu_2_302.vin04();
      n[5] = scu_2_302.vin05();
      n[6] = scu_2_302.vin06();
      n[7] = scu_2_302.vin07();
      n[8] = scu_3_303.vin08();
      n[9] = scu_3_303.vin09();
      n[10] = scu_3_303.vin10();
      n[11] = scu_3_303.vin11();
      n[12] = scu_3_303.vin12();
      n[13] = scu_3_303.vin13();
      n[14] = scu_3_303.vin14();
      n[15] = scu_3_303.vin15();
      n[16] = scu_1_301.vin16();
 
      char ch[17];
      memset(&ch, '\0', sizeof(ch));
      for (int i = 0; i < 17; i++) {
        ch[i] = static_cast<char>(n[i]);
      }
      if (chassis_.has_vehicle_id()) {
        chassis_.mutable_vehicle_id()->set_vin(ch);
      }
    }
  }
 
  // give engage_advice based on error_code and canbus feedback
  if (chassis_error_mask_) {
    if (chassis_.has_engage_advice()) {
      chassis_.mutable_engage_advice()->set_advice(
          apollo::common::EngageAdvice::DISALLOW_ENGAGE);
      chassis_.mutable_engage_advice()->set_reason("Chassis error!");
    }
  } else if (chassis_.parking_brake() || CheckSafetyError(chassis_detail)) {
    if (chassis_.has_engage_advice()) {
      chassis_.mutable_engage_advice()->set_advice(
          apollo::common::EngageAdvice::DISALLOW_ENGAGE);
      chassis_.mutable_engage_advice()->set_reason(
          "Vehicle is not in a safe state to engage!");
    }
  } else {
    if (chassis_.has_engage_advice()) {
      chassis_.mutable_engage_advice()->set_advice(
          apollo::common::EngageAdvice::READY_TO_ENGAGE);
    }
  }
 
  // 19 add checkresponse signal
  if (chassis_detail.has_scu_bcs_1_306() &&
      chassis_detail.scu_bcs_1_306().has_bcs_drvmode()) {
    chassis_.mutable_check_response()->set_is_esp_online(
        chassis_detail.scu_bcs_1_306().bcs_drvmode() == 1);
  }
  if (chassis_detail.has_scu_eps_311() &&
      chassis_detail.scu_eps_311().has_eps_drvmode()) {
    chassis_.mutable_check_response()->set_is_eps_online(
        chassis_detail.scu_eps_311().eps_drvmode() == 1);
  }
  if (chassis_detail.has_scu_vcu_1_312() &&
      chassis_detail.scu_vcu_1_312().has_vcu_drvmode()) {
    chassis_.mutable_check_response()->set_is_vcu_online(
        chassis_detail.scu_vcu_1_312().vcu_drvmode() == 1);
  }
 
  return chassis_;
}

◆ FRIEND_TEST() [1/3]

apollo::canbus::ge3::Ge3Controller::FRIEND_TEST	(	Ge3ControllerTest	,
		SetDrivingMode
	)

◆ FRIEND_TEST() [2/3]

apollo::canbus::ge3::Ge3Controller::FRIEND_TEST	(	Ge3ControllerTest	,
		Status
	)

◆ FRIEND_TEST() [3/3]

apollo::canbus::ge3::Ge3Controller::FRIEND_TEST	(	Ge3ControllerTest	,
		UpdateDrivingMode
	)

◆ Init()

ErrorCode apollo::canbus::ge3::Ge3Controller::Init	(	const VehicleParameter &	params,
		CanSender<::apollo::canbus::Ge3 > *const	can_sender,
		MessageManager<::apollo::canbus::Ge3 > *const	message_manager
	)

override

在文件 ge3_controller.cc 第 43 行定义.

                                                            {
  if (is_initialized_) {
    AINFO << "Ge3Controller has already been initiated.";
    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
  pc_bcm_201_ = dynamic_cast<Pcbcm201*>(
      message_manager_->GetMutableProtocolDataById(Pcbcm201::ID));
  if (pc_bcm_201_ == nullptr) {
    AERROR << "Pcbcm201 does not exist in the Ge3MessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  pc_bcs_202_ = dynamic_cast<Pcbcs202*>(
      message_manager_->GetMutableProtocolDataById(Pcbcs202::ID));
  if (pc_bcs_202_ == nullptr) {
    AERROR << "Pcbcs202 does not exist in the Ge3MessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  pc_epb_203_ = dynamic_cast<Pcepb203*>(
      message_manager_->GetMutableProtocolDataById(Pcepb203::ID));
  if (pc_epb_203_ == nullptr) {
    AERROR << "Pcepb203 does not exist in the Ge3MessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  pc_eps_204_ = dynamic_cast<Pceps204*>(
      message_manager_->GetMutableProtocolDataById(Pceps204::ID));
  if (pc_eps_204_ == nullptr) {
    AERROR << "Pceps204 does not exist in the Ge3MessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  pc_vcu_205_ = dynamic_cast<Pcvcu205*>(
      message_manager_->GetMutableProtocolDataById(Pcvcu205::ID));
  if (pc_vcu_205_ == nullptr) {
    AERROR << "Pcvcu205 does not exist in the Ge3MessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  can_sender_->AddMessage(Pcbcm201::ID, pc_bcm_201_, false);
  can_sender_->AddMessage(Pcbcs202::ID, pc_bcs_202_, false);
  can_sender_->AddMessage(Pcepb203::ID, pc_epb_203_, false);
  can_sender_->AddMessage(Pceps204::ID, pc_eps_204_, false);
  can_sender_->AddMessage(Pcvcu205::ID, pc_vcu_205_, false);
 
  // Need to sleep to ensure all messages received
  AINFO << "Ge3Controller is initialized.";
 
  is_initialized_ = true;
  return ErrorCode::OK;
}

◆ Start()

bool apollo::canbus::ge3::Ge3Controller::Start ( )

overridevirtual

start the vehicle controller.

返回: true if successfully started.

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

在文件 ge3_controller.cc 第 122 行定义.

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

◆ Stop()

void apollo::canbus::ge3::Ge3Controller::Stop ( )

overridevirtual

stop the vehicle controller.

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

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

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

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

modules/canbus_vehicle/ge3/ge3_controller.h
modules/canbus_vehicle/ge3/ge3_controller.cc

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ Ge3Controller()

◆ ~Ge3Controller()

成员函数说明

◆ chassis()

◆ FRIEND_TEST() [1/3]

◆ FRIEND_TEST() [2/3]

◆ FRIEND_TEST() [3/3]

◆ Init()

◆ Start()

◆ Stop()