Apollo 10.0
自动驾驶开放平台
apollo::canbus::zhongyun::ZhongyunController类 参考final

#include <zhongyun_controller.h>

类 apollo::canbus::zhongyun::ZhongyunController 继承关系图:
apollo::canbus::zhongyun::ZhongyunController 的协作图:

Public 成员函数

 ZhongyunController ()
 
virtual ~ZhongyunController ()
 
::apollo::common::ErrorCode Init (const VehicleParameter &params, CanSender<::apollo::canbus::Zhongyun > *const can_sender, MessageManager<::apollo::canbus::Zhongyun > *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 (ZhongyunControllerTest, SetDrivingMode)
 
 FRIEND_TEST (ZhongyunControllerTest, Status)
 
 FRIEND_TEST (ZhongyunControllerTest, UpdateDrivingMode)
 
- Public 成员函数 继承自 apollo::canbus::VehicleController<::apollo::canbus::Zhongyun >
virtual ~VehicleController ()=default
 
virtual common::ErrorCode Init (const VehicleParameter &params, CanSender< ::apollo::canbus::Zhongyun > *const can_sender, MessageManager< ::apollo::canbus::Zhongyun > *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::Zhongyun GetNewRecvChassisDetail ()
 
virtual ::apollo::canbus::Zhongyun GetNewSenderChassisDetail ()
 
virtual Chassis::DrivingMode driving_mode ()
 

额外继承的成员函数

- Protected 成员函数 继承自 apollo::canbus::VehicleController<::apollo::canbus::Zhongyun >
virtual void set_driving_mode (const Chassis::DrivingMode &driving_mode)
 
- Protected 属性 继承自 apollo::canbus::VehicleController<::apollo::canbus::Zhongyun >
common::VehicleSignal last_chassis_command_
 
common::VehicleSignal last_control_command_
 
canbus::VehicleParameter params_
 
common::VehicleParam vehicle_params_
 
CanSender< ::apollo::canbus::Zhongyun > * can_sender_
 
CanReceiver< ::apollo::canbus::Zhongyun > * can_receiver_
 
MessageManager< ::apollo::canbus::Zhongyun > * 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_
 

详细描述

在文件 zhongyun_controller.h39 行定义.

构造及析构函数说明

◆ ZhongyunController()

apollo::canbus::zhongyun::ZhongyunController::ZhongyunController ( )
inline

在文件 zhongyun_controller.h42 行定义.

42{}

◆ ~ZhongyunController()

apollo::canbus::zhongyun::ZhongyunController::~ZhongyunController ( )
virtual

在文件 zhongyun_controller.cc119 行定义.

119{}

成员函数说明

◆ chassis()

Chassis apollo::canbus::zhongyun::ZhongyunController::chassis ( )
overridevirtual

calculate and return the chassis.

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

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

在文件 zhongyun_controller.cc145 行定义.

145 {
146 chassis_.Clear();
147
148 Zhongyun chassis_detail;
149 message_manager_->GetSensorData(&chassis_detail);
150
151 // 1, 2
152 // if (driving_mode() == Chassis::EMERGENCY_MODE) {
153 // set_chassis_error_code(Chassis::NO_ERROR);
154 // }
155
156 chassis_.set_driving_mode(driving_mode());
157 chassis_.set_error_code(chassis_error_code());
158
159 // 3
160 chassis_.set_engine_started(true);
161
162 // 4 engine_rpm
163 if (chassis_detail.has_vehicle_state_feedback_2_c4() &&
164 chassis_detail.vehicle_state_feedback_2_c4().has_motor_speed()) {
165 chassis_.set_engine_rpm(static_cast<float>(
166 chassis_detail.vehicle_state_feedback_2_c4().motor_speed()));
167 } else {
168 chassis_.set_engine_rpm(0);
169 }
170 // 5 speed_mps
171 if (chassis_detail.has_vehicle_state_feedback_c1() &&
172 chassis_detail.vehicle_state_feedback_c1().has_speed()) {
173 chassis_.set_speed_mps(
174 static_cast<float>(chassis_detail.vehicle_state_feedback_c1().speed()));
175 } else {
176 chassis_.set_speed_mps(0);
177 }
178 // 6
179 chassis_.set_fuel_range_m(0);
180
181 // 7 acc_pedal
182 if (chassis_detail.has_vehicle_state_feedback_2_c4() &&
183 chassis_detail.vehicle_state_feedback_2_c4()
184 .has_driven_torque_feedback()) {
185 chassis_.set_throttle_percentage(static_cast<float>(
186 chassis_detail.vehicle_state_feedback_2_c4().driven_torque_feedback()));
187 } else {
188 chassis_.set_throttle_percentage(0);
189 }
190 // 8 brake_pedal
191 if (chassis_detail.has_vehicle_state_feedback_c1() &&
192 chassis_detail.vehicle_state_feedback_c1().has_brake_torque_feedback()) {
193 chassis_.set_brake_percentage(static_cast<float>(
194 chassis_detail.vehicle_state_feedback_c1().brake_torque_feedback()));
195 } else {
196 chassis_.set_brake_percentage(0);
197 }
198 // 9 gear position
199 if (chassis_detail.has_vehicle_state_feedback_c1() &&
200 chassis_detail.vehicle_state_feedback_c1().has_gear_state_actual()) {
201 switch (chassis_detail.vehicle_state_feedback_c1().gear_state_actual()) {
203 chassis_.set_gear_location(Chassis::GEAR_DRIVE);
204 } break;
206 chassis_.set_gear_location(Chassis::GEAR_NEUTRAL);
207 } break;
209 chassis_.set_gear_location(Chassis::GEAR_REVERSE);
210 } break;
212 chassis_.set_gear_location(Chassis::GEAR_PARKING);
213 } break;
214 default:
215 chassis_.set_gear_location(Chassis::GEAR_INVALID);
216 break;
217 }
218 } else {
219 chassis_.set_gear_location(Chassis::GEAR_NONE);
220 }
221 // 11 steering_percentage
222 if (chassis_detail.has_vehicle_state_feedback_c1() &&
223 chassis_detail.vehicle_state_feedback_c1().has_steering_actual()) {
224 chassis_.set_steering_percentage(static_cast<float>(
225 chassis_detail.vehicle_state_feedback_c1().steering_actual() * 100.0 /
226 vehicle_params_.max_steer_angle() * M_PI / 180));
227 } else {
228 chassis_.set_steering_percentage(0);
229 }
230 // 12 epb
231 if (chassis_detail.has_vehicle_state_feedback_c1() &&
232 chassis_detail.vehicle_state_feedback_c1().has_parking_actual()) {
233 chassis_.set_parking_brake(
234 chassis_detail.vehicle_state_feedback_c1().parking_actual() ==
236 } else {
237 chassis_.set_parking_brake(false);
238 }
239 // 13 error mask
240 if (chassis_error_mask_) {
241 chassis_.set_chassis_error_mask(chassis_error_mask_);
242 }
243 // Give engage_advice based on error_code and canbus feedback
244 if (!chassis_error_mask_ && !chassis_.parking_brake()) {
245 chassis_.mutable_engage_advice()->set_advice(
247 } else {
248 chassis_.mutable_engage_advice()->set_advice(
250 chassis_.mutable_engage_advice()->set_reason(
251 "CANBUS not ready, epb is not released or firmware error!");
252 }
253
254 // 14 add checkresponse signal
255 if (chassis_detail.has_enable_state_feedback_c3()) {
256 if (chassis_detail.enable_state_feedback_c3().has_brake_enable_state()) {
257 chassis_.mutable_check_response()->set_is_esp_online(
258 chassis_detail.enable_state_feedback_c3().brake_enable_state() == 1);
259 }
260 if (chassis_detail.enable_state_feedback_c3().has_driven_enable_state() &&
261 chassis_detail.enable_state_feedback_c3().has_gear_enable_actual()) {
262 chassis_.mutable_check_response()->set_is_vcu_online(
263 ((chassis_detail.enable_state_feedback_c3().driven_enable_state() ==
264 1) &&
265 (chassis_detail.enable_state_feedback_c3().gear_enable_actual() ==
266 1)) == 1);
267 }
268 if (chassis_detail.enable_state_feedback_c3().has_steering_enable_state()) {
269 chassis_.mutable_check_response()->set_is_eps_online(
270 chassis_detail.enable_state_feedback_c3().steering_enable_state() ==
271 1);
272 }
273 }
274
275 return chassis_;
276}
MessageManager< ::apollo::canbus::Zhongyun > * message_manager_
optional bool parking_brake
Definition chassis.proto:94

◆ FRIEND_TEST() [1/3]

apollo::canbus::zhongyun::ZhongyunController::FRIEND_TEST ( ZhongyunControllerTest  ,
SetDrivingMode   
)

◆ FRIEND_TEST() [2/3]

apollo::canbus::zhongyun::ZhongyunController::FRIEND_TEST ( ZhongyunControllerTest  ,
Status   
)

◆ FRIEND_TEST() [3/3]

apollo::canbus::zhongyun::ZhongyunController::FRIEND_TEST ( ZhongyunControllerTest  ,
UpdateDrivingMode   
)

◆ Init()

ErrorCode apollo::canbus::zhongyun::ZhongyunController::Init ( const VehicleParameter params,
CanSender<::apollo::canbus::Zhongyun > *const  can_sender,
MessageManager<::apollo::canbus::Zhongyun > *const  message_manager 
)
override

在文件 zhongyun_controller.cc42 行定义.

45 {
46 if (is_initialized_) {
47 AINFO << "ZhongyunController has already been initialized.";
48 return ErrorCode::CANBUS_ERROR;
49 }
50 vehicle_params_.CopyFrom(
51 common::VehicleConfigHelper::Instance()->GetConfig().vehicle_param());
52 params_.CopyFrom(params);
53 if (!params_.has_driving_mode()) {
54 AERROR << "Vehicle conf pb not set driving_mode.";
55 return ErrorCode::CANBUS_ERROR;
56 }
57
58 if (can_sender == nullptr) {
59 AERROR << "Canbus sender is null.";
60 return ErrorCode::CANBUS_ERROR;
61 }
62 can_sender_ = can_sender;
63
64 if (message_manager == nullptr) {
65 AERROR << "Protocol manager is null.";
66 return ErrorCode::CANBUS_ERROR;
67 }
68 message_manager_ = message_manager;
69
70 // Sender part
71 brake_control_a4_ = dynamic_cast<Brakecontrola4*>(
72 message_manager_->GetMutableProtocolDataById(Brakecontrola4::ID));
73 if (brake_control_a4_ == nullptr) {
74 AERROR << "Brakecontrola4 does not exist in the ZhongyunMessageManager!";
75 return ErrorCode::CANBUS_ERROR;
76 }
77
78 gear_control_a1_ = dynamic_cast<Gearcontrola1*>(
79 message_manager_->GetMutableProtocolDataById(Gearcontrola1::ID));
80 if (gear_control_a1_ == nullptr) {
81 AERROR << "Gearcontrola1 does not exist in the ZhongyunMessageManager!";
82 return ErrorCode::CANBUS_ERROR;
83 }
84
85 parking_control_a5_ = dynamic_cast<Parkingcontrola5*>(
86 message_manager_->GetMutableProtocolDataById(Parkingcontrola5::ID));
87 if (parking_control_a5_ == nullptr) {
88 AERROR << "Parkingcontrola5 does not exist in the ZhongyunMessageManager!";
89 return ErrorCode::CANBUS_ERROR;
90 }
91
92 steering_control_a2_ = dynamic_cast<Steeringcontrola2*>(
93 message_manager_->GetMutableProtocolDataById(Steeringcontrola2::ID));
94 if (steering_control_a2_ == nullptr) {
95 AERROR << "Steeringcontrola2 does not exist in the ZhongyunMessageManager!";
96 return ErrorCode::CANBUS_ERROR;
97 }
98
99 torque_control_a3_ = dynamic_cast<Torquecontrola3*>(
100 message_manager_->GetMutableProtocolDataById(Torquecontrola3::ID));
101 if (torque_control_a3_ == nullptr) {
102 AERROR << "Torquecontrola3 does not exist in the ZhongyunMessageManager!";
103 return ErrorCode::CANBUS_ERROR;
104 }
105
106 can_sender_->AddMessage(Brakecontrola4::ID, brake_control_a4_, false);
107 can_sender_->AddMessage(Gearcontrola1::ID, gear_control_a1_, false);
108 can_sender_->AddMessage(Parkingcontrola5::ID, parking_control_a5_, false);
109 can_sender_->AddMessage(Steeringcontrola2::ID, steering_control_a2_, false);
110 can_sender_->AddMessage(Torquecontrola3::ID, torque_control_a3_, false);
111
112 // Need to sleep to ensure all messages received
113 AINFO << "ZhongyunController is initialized.";
114
115 is_initialized_ = true;
116 return ErrorCode::OK;
117}
#define AERROR
Definition log.h:44
#define AINFO
Definition log.h:42

◆ Start()

bool apollo::canbus::zhongyun::ZhongyunController::Start ( )
overridevirtual

start the vehicle controller.

返回
true if successfully started.

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

在文件 zhongyun_controller.cc121 行定义.

121 {
122 if (!is_initialized_) {
123 AERROR << "ZhongyunController has not been initialized.";
124 return false;
125 }
126 const auto& update_func = [this] { SecurityDogThreadFunc(); };
127 thread_.reset(new std::thread(update_func));
128
129 return true;
130}

◆ Stop()

void apollo::canbus::zhongyun::ZhongyunController::Stop ( )
overridevirtual

stop the vehicle controller.

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

在文件 zhongyun_controller.cc132 行定义.

132 {
133 if (!is_initialized_) {
134 AERROR << "ZhongyunController stops or starts improperly!";
135 return;
136 }
137
138 if (thread_ != nullptr && thread_->joinable()) {
139 thread_->join();
140 thread_.reset();
141 AINFO << "ZhongyunController stopped.";
142 }
143}

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