#include <lexus_controller.h>

类 apollo::canbus::lexus::LexusController 继承关系图:

apollo::canbus::lexus::LexusController 的协作图:

Public 成员函数
virtual	~LexusController ()

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

	FRIEND_TEST (LexusControllerTest, Status)

	FRIEND_TEST (LexusControllerTest, UpdateDrivingMode)

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

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

virtual ::apollo::canbus::Lexus	GetNewSenderChassisDetail ()

virtual Chassis::DrivingMode	driving_mode ()

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

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

common::VehicleSignal	last_control_command_

canbus::VehicleParameter	params_

common::VehicleParam	vehicle_params_

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

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

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

详细描述

在文件 lexus_controller.h 第 47 行定义.

构造及析构函数说明

◆ ~LexusController()

apollo::canbus::lexus::LexusController::~LexusController ( )

virtual

在文件 lexus_controller.cc 第 121 行定义.

121{}

成员函数说明

◆ chassis()

Chassis apollo::canbus::lexus::LexusController::chassis ( )

overridevirtual

calculate and return the chassis.

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

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

在文件 lexus_controller.cc 第 147 行定义.

                                 {
  chassis_.Clear();
 
  Lexus 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_400() &&
      chassis_detail.vehicle_speed_rpt_400().has_vehicle_speed()) {
    chassis_.set_speed_mps(static_cast<float>(
        chassis_detail.vehicle_speed_rpt_400().vehicle_speed()));
  } else {
    chassis_.set_speed_mps(0);
  }
 
  if (chassis_detail.has_wheel_speed_rpt_407()) {
    // TODO(QiL) : No wheel speed valid bit in lexus, so default valid
    chassis_.mutable_wheel_speed()->set_is_wheel_spd_rr_valid(true);
    // chassis_.mutable_wheel_speed()->set_wheel_direction_rr(true);
    chassis_.mutable_wheel_speed()->set_wheel_spd_rr(
        chassis_detail.wheel_speed_rpt_407().wheel_spd_rear_right());
 
    chassis_.mutable_wheel_speed()->set_is_wheel_spd_rl_valid(true);
    /*
    chassis_.mutable_wheel_speed()->set_wheel_direction_rl(
        chassis_detail.vehicle_spd().wheel_direction_rl());
        */
    chassis_.mutable_wheel_speed()->set_wheel_spd_rl(
        chassis_detail.wheel_speed_rpt_407().wheel_spd_rear_left());
 
    chassis_.mutable_wheel_speed()->set_is_wheel_spd_fr_valid(true);
    /*
    chassis_.mutable_wheel_speed()->set_wheel_direction_fr(
        chassis_detail.vehicle_spd().wheel_direction_fr());
        */
    chassis_.mutable_wheel_speed()->set_wheel_spd_fr(
        chassis_detail.wheel_speed_rpt_407().wheel_spd_front_right());
 
    chassis_.mutable_wheel_speed()->set_is_wheel_spd_fl_valid(true);
    /*
    chassis_.mutable_wheel_speed()->set_wheel_direction_fl(
        chassis_detail.vehicle_spd().wheel_direction_fl());
        */
    chassis_.mutable_wheel_speed()->set_wheel_spd_fl(
        chassis_detail.wheel_speed_rpt_407().wheel_spd_front_left());
  }
 
  // 7
  chassis_.set_fuel_range_m(0);
  // 8
  if (chassis_detail.has_accel_rpt_200() &&
      chassis_detail.accel_rpt_200().has_output_value()) {
    // TODO(snehagn): Temp fix until AS to fix the scaling
    chassis_.set_throttle_percentage(static_cast<float>(
        chassis_detail.accel_rpt_200().output_value() * 100));
  } else {
    chassis_.set_throttle_percentage(0);
  }
  // 9
  if (chassis_detail.has_brake_rpt_204() &&
      chassis_detail.brake_rpt_204().has_output_value()) {
    // TODO(snehagn): Temp fix until AS to fix the scaling
    chassis_.set_brake_percentage(static_cast<float>(
        chassis_detail.brake_rpt_204().output_value() * 100));
  } else {
    chassis_.set_brake_percentage(0);
  }
 
  // 23, previously 10
  if (chassis_detail.has_shift_rpt_228() &&
      chassis_detail.shift_rpt_228().has_output_value()) {
    AINFO << "Start reading shift values";
    Chassis::GearPosition gear_pos = Chassis::GEAR_INVALID;
 
    if (chassis_detail.shift_rpt_228().output_value() ==
        Shift_rpt_228::OUTPUT_VALUE_PARK) {
      gear_pos = Chassis::GEAR_PARKING;
    }
 
    if (chassis_detail.shift_rpt_228().output_value() ==
        Shift_rpt_228::OUTPUT_VALUE_NEUTRAL) {
      gear_pos = Chassis::GEAR_NEUTRAL;
    }
    if (chassis_detail.shift_rpt_228().output_value() ==
        Shift_rpt_228::OUTPUT_VALUE_REVERSE) {
      gear_pos = Chassis::GEAR_REVERSE;
    }
    if (chassis_detail.shift_rpt_228().output_value() ==
        Shift_rpt_228::OUTPUT_VALUE_FORWARD_HIGH) {
      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_22c() &&
      chassis_detail.steering_rpt_22c().has_output_value()) {
    chassis_.set_steering_percentage(
        static_cast<float>(chassis_detail.steering_rpt_22c().output_value() *
                           100.0 / vehicle_params_.max_steer_angle()));
  } else {
    chassis_.set_steering_percentage(0);
  }
 
  // 16, 17
  if (chassis_detail.has_turn_rpt_230() &&
      chassis_detail.turn_rpt_230().has_output_value() &&
      chassis_detail.turn_rpt_230().output_value() !=
          Turn_rpt_230::OUTPUT_VALUE_NONE) {
    if (chassis_detail.turn_rpt_230().output_value() ==
        Turn_rpt_230::OUTPUT_VALUE_LEFT) {
      chassis_.mutable_signal()->set_turn_signal(
          common::VehicleSignal::TURN_LEFT);
    } else if (chassis_detail.turn_rpt_230().output_value() ==
               Turn_rpt_230::OUTPUT_VALUE_RIGHT) {
      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_.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::lexus::LexusController::FRIEND_TEST	(	LexusControllerTest	,
		SetDrivingMode
	)

◆ FRIEND_TEST() [2/3]

apollo::canbus::lexus::LexusController::FRIEND_TEST	(	LexusControllerTest	,
		Status
	)

◆ FRIEND_TEST() [3/3]

apollo::canbus::lexus::LexusController::FRIEND_TEST	(	LexusControllerTest	,
		UpdateDrivingMode
	)

◆ Init()

ErrorCode apollo::canbus::lexus::LexusController::Init	(	const VehicleParameter &	params,
		CanSender<::apollo::canbus::Lexus > *const	can_sender,
		MessageManager<::apollo::canbus::Lexus > *const	message_manager
	)

override

在文件 lexus_controller.cc 第 44 行定义.

                                                              {
  if (is_initialized_) {
    AINFO << "LexusController 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
  accel_cmd_100_ = dynamic_cast<Accelcmd100*>(
      message_manager_->GetMutableProtocolDataById(Accelcmd100::ID));
  if (accel_cmd_100_ == nullptr) {
    AERROR << "Accelcmd100 does not exist in the LexusMessalexusanager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  brake_cmd_104_ = dynamic_cast<Brakecmd104*>(
      message_manager_->GetMutableProtocolDataById(Brakecmd104::ID));
  if (brake_cmd_104_ == nullptr) {
    AERROR << "Brakecmd104 does not exist in the LexusMessalexusanager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  shift_cmd_128_ = dynamic_cast<Shiftcmd128*>(
      message_manager_->GetMutableProtocolDataById(Shiftcmd128::ID));
  if (shift_cmd_128_ == nullptr) {
    AERROR << "Shiftcmd128 does not exist in the LexusMessalexusanager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  turn_cmd_130_ = dynamic_cast<Turncmd130*>(
      message_manager_->GetMutableProtocolDataById(Turncmd130::ID));
  if (turn_cmd_130_ == nullptr) {
    AERROR << "Turncmd130 does not exist in the LexusMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  steering_cmd_12c_ = dynamic_cast<Steeringcmd12c*>(
      message_manager_->GetMutableProtocolDataById(Steeringcmd12c::ID));
  if (steering_cmd_12c_ == nullptr) {
    AERROR << "Steeringcmd12c does not exist in the LexusMessageManager!";
    return ErrorCode::CANBUS_ERROR;
  }
 
  can_sender_->AddMessage(Accelcmd100::ID, accel_cmd_100_, false);
  can_sender_->AddMessage(Brakecmd104::ID, brake_cmd_104_, false);
  can_sender_->AddMessage(Shiftcmd128::ID, shift_cmd_128_, false);
  can_sender_->AddMessage(Steeringcmd12c::ID, steering_cmd_12c_, false);
  can_sender_->AddMessage(Turncmd130::ID, turn_cmd_130_, false);
 
  // Need to sleep to ensure all messages were received
  AINFO << "LexusController is initialized.";
 
  is_initialized_ = true;
  return ErrorCode::OK;
}

◆ Start()

bool apollo::canbus::lexus::LexusController::Start ( )

overridevirtual

start the vehicle controller.

返回: true if successfully started.

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

在文件 lexus_controller.cc 第 123 行定义.

                            {
  if (!is_initialized_) {
    AERROR << "LexusController 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::lexus::LexusController::Stop ( )

overridevirtual

stop the vehicle controller.

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

在文件 lexus_controller.cc 第 134 行定义.

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

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

modules/canbus_vehicle/lexus/lexus_controller.h
modules/canbus_vehicle/lexus/lexus_controller.cc

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ ~LexusController()

成员函数说明

◆ chassis()

◆ FRIEND_TEST() [1/3]

◆ FRIEND_TEST() [2/3]

◆ FRIEND_TEST() [3/3]

◆ Init()

◆ Start()

◆ Stop()