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

#include <wey_controller.h>

类 apollo::canbus::wey::WeyController 继承关系图:
apollo::canbus::wey::WeyController 的协作图:

Public 成员函数

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

额外继承的成员函数

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

详细描述

在文件 wey_controller.h39 行定义.

构造及析构函数说明

◆ WeyController()

apollo::canbus::wey::WeyController::WeyController ( )
inline

在文件 wey_controller.h41 行定义.

41{}

◆ ~WeyController()

apollo::canbus::wey::WeyController::~WeyController ( )
virtual

在文件 wey_controller.cc120 行定义.

120{}

成员函数说明

◆ chassis()

Chassis apollo::canbus::wey::WeyController::chassis ( )
overridevirtual

calculate and return the chassis.

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

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

在文件 wey_controller.cc146 行定义.

146 {
147 chassis_.Clear();
148
149 Wey chassis_detail;
150 message_manager_->GetSensorData(&chassis_detail);
151
152 // 21, 22, previously 1, 2
153 // if (driving_mode() == Chassis::EMERGENCY_MODE) {
154 // set_chassis_error_code(Chassis::NO_ERROR);
155 // }
156
157 chassis_.set_driving_mode(driving_mode());
158 chassis_.set_error_code(chassis_error_code());
159
160 // 3
161 chassis_.set_engine_started(true);
162
163 // 4 engine_rpm
164 if (chassis_detail.has_fbs3_237() && chassis_detail.fbs3_237().has_engspd()) {
165 chassis_.set_engine_rpm(
166 static_cast<float>(chassis_detail.fbs3_237().engspd()));
167 } else {
168 chassis_.set_engine_rpm(0);
169 }
170
171 // 5 6
172 if (chassis_detail.has_fbs2_240() &&
173 chassis_detail.fbs2_240().has_vehiclespd() &&
174 chassis_detail.has_fbs1_243() && chassis_detail.has_status_310()) {
175 Fbs2_240 fbs2_240 = chassis_detail.fbs2_240();
176 Fbs1_243 fbs1_243 = chassis_detail.fbs1_243();
177 Status_310 status_310 = chassis_detail.status_310();
178 // speed_mps
179 chassis_.set_speed_mps(static_cast<float>(fbs2_240.vehiclespd()));
180 // rr
181 chassis_.mutable_wheel_speed()->set_is_wheel_spd_rr_valid(
182 static_cast<bool>(status_310.rrwheelspdvalid()));
183 if (fbs2_240.rrwheeldirection() == Fbs2_240::RRWHEELDIRECTION_FORWARD) {
184 chassis_.mutable_wheel_speed()->set_wheel_direction_rr(
186 } else if (fbs2_240.rrwheeldirection() ==
188 chassis_.mutable_wheel_speed()->set_wheel_direction_rr(
190 } else if (fbs2_240.rrwheeldirection() == Fbs2_240::RRWHEELDIRECTION_STOP) {
191 chassis_.mutable_wheel_speed()->set_wheel_direction_rr(
193 } else {
194 chassis_.mutable_wheel_speed()->set_wheel_direction_rr(
196 }
197 chassis_.mutable_wheel_speed()->set_wheel_spd_rr(fbs2_240.rrwheelspd());
198 // rl
199 chassis_.mutable_wheel_speed()->set_is_wheel_spd_rl_valid(
200 static_cast<bool>(status_310.rlwheelspdvalid()));
201 if (fbs2_240.rlwheeldrivedirection() ==
203 chassis_.mutable_wheel_speed()->set_wheel_direction_rl(
205 } else if (fbs2_240.rlwheeldrivedirection() ==
207 chassis_.mutable_wheel_speed()->set_wheel_direction_rl(
209 } else if (fbs2_240.rlwheeldrivedirection() ==
211 chassis_.mutable_wheel_speed()->set_wheel_direction_rl(
213 } else {
214 chassis_.mutable_wheel_speed()->set_wheel_direction_rl(
216 }
217 chassis_.mutable_wheel_speed()->set_wheel_spd_rl(fbs2_240.rlwheelspd());
218 // fr
219 chassis_.mutable_wheel_speed()->set_is_wheel_spd_fr_valid(
220 static_cast<bool>(status_310.frwheelspdvalid()));
221 if (fbs1_243.frwheeldirection() == Fbs1_243::FRWHEELDIRECTION_FORWARD) {
222 chassis_.mutable_wheel_speed()->set_wheel_direction_fr(
224 } else if (fbs1_243.frwheeldirection() ==
226 chassis_.mutable_wheel_speed()->set_wheel_direction_fr(
228 } else if (fbs1_243.frwheeldirection() == Fbs1_243::FRWHEELDIRECTION_STOP) {
229 chassis_.mutable_wheel_speed()->set_wheel_direction_fr(
231 } else {
232 chassis_.mutable_wheel_speed()->set_wheel_direction_fr(
234 }
235 chassis_.mutable_wheel_speed()->set_wheel_spd_fr(fbs2_240.frwheelspd());
236 // fl
237 chassis_.mutable_wheel_speed()->set_is_wheel_spd_fl_valid(
238 static_cast<bool>(status_310.flwheelspdvalid()));
239 if (fbs2_240.flwheeldirection() == Fbs2_240::FLWHEELDIRECTION_FORWARD) {
240 chassis_.mutable_wheel_speed()->set_wheel_direction_fl(
242 } else if (fbs2_240.flwheeldirection() ==
244 chassis_.mutable_wheel_speed()->set_wheel_direction_fl(
246 } else if (fbs2_240.flwheeldirection() == Fbs2_240::FLWHEELDIRECTION_STOP) {
247 chassis_.mutable_wheel_speed()->set_wheel_direction_fl(
249 } else {
250 chassis_.mutable_wheel_speed()->set_wheel_direction_fl(
252 }
253 chassis_.mutable_wheel_speed()->set_wheel_spd_fl(fbs1_243.flwheelspd());
254 } else {
255 chassis_.set_speed_mps(0);
256 }
257 // 7
258 chassis_.set_fuel_range_m(0);
259 // 8
260 if (chassis_detail.has_fbs3_237() &&
261 chassis_detail.fbs3_237().has_accpedalpos()) {
262 chassis_.set_throttle_percentage(
263 static_cast<float>(chassis_detail.fbs3_237().accpedalpos()));
264 } else {
265 chassis_.set_throttle_percentage(0);
266 }
267 // 23, previously 10 gear position
268 if (chassis_detail.has_fbs3_237() &&
269 chassis_detail.fbs3_237().has_currentgear()) {
270 switch (chassis_detail.fbs3_237().currentgear()) {
272 chassis_.set_gear_location(Chassis::GEAR_DRIVE);
273 } break;
275 chassis_.set_gear_location(Chassis::GEAR_NEUTRAL);
276 } break;
278 chassis_.set_gear_location(Chassis::GEAR_REVERSE);
279 } break;
281 chassis_.set_gear_location(Chassis::GEAR_PARKING);
282 } break;
283 default:
284 chassis_.set_gear_location(Chassis::GEAR_INVALID);
285 break;
286 }
287 } else {
288 chassis_.set_gear_location(Chassis::GEAR_NONE);
289 }
290 // 11
291 if (chassis_detail.has_fbs4_235() &&
292 chassis_detail.fbs4_235().has_steerwheelangle() &&
293 chassis_detail.has_status_310() &&
294 chassis_detail.status_310().has_steerwheelanglesign()) {
295 if (chassis_detail.status_310().steerwheelanglesign() ==
297 chassis_.set_steering_percentage(static_cast<float>(
298 chassis_detail.fbs4_235().steerwheelangle() * 100.0 /
299 vehicle_params_.max_steer_angle() * M_PI / 180));
300 angle_init = chassis_detail.fbs4_235().steerwheelangle();
301 } else if (chassis_detail.status_310().steerwheelanglesign() ==
303 chassis_.set_steering_percentage(static_cast<float>(
304 chassis_detail.fbs4_235().steerwheelangle() * (-1) * 100.0 /
305 vehicle_params_.max_steer_angle() * M_PI / 180));
306 angle_init = chassis_detail.fbs4_235().steerwheelangle() * (-1);
307 } else {
308 chassis_.set_steering_percentage(0);
309 }
310 } else {
311 chassis_.set_steering_percentage(0);
312 }
313
314 // 12
315 if (chassis_detail.has_fbs3_237() &&
316 chassis_detail.fbs3_237().has_epsdrvinputtrqvalue()) {
317 chassis_.set_steering_torque_nm(
318 static_cast<float>(chassis_detail.fbs3_237().epsdrvinputtrqvalue()));
319 } else {
320 chassis_.set_steering_torque_nm(0);
321 }
322 // 13
323 if (chassis_detail.has_status_310() &&
324 chassis_detail.status_310().has_epbsts()) {
325 chassis_.set_parking_brake(chassis_detail.status_310().epbsts() ==
327 } else {
328 chassis_.set_parking_brake(false);
329 }
330 // 14, 15
331 if (chassis_detail.has_status_310() &&
332 chassis_detail.status_310().has_lowbeamsts() &&
333 chassis_detail.status_310().lowbeamsts() == Status_310::LOWBEAMSTS_ON) {
334 chassis_.mutable_signal()->set_low_beam(true);
335 } else {
336 chassis_.mutable_signal()->set_low_beam(false);
337 }
338 // 16, 17
339 if (chassis_detail.has_status_310()) {
340 if (chassis_detail.status_310().has_leftturnlampsts() &&
341 chassis_detail.status_310().leftturnlampsts() ==
343 chassis_.mutable_signal()->set_turn_signal(
345 } else if (chassis_detail.status_310().has_rightturnlampsts() &&
346 chassis_detail.status_310().rightturnlampsts() ==
348 chassis_.mutable_signal()->set_turn_signal(
350 } else {
351 chassis_.mutable_signal()->set_turn_signal(
353 }
354 } else {
355 chassis_.mutable_signal()->set_turn_signal(
357 }
358 // 18
359 if (chassis_detail.has_vin_resp1_391() &&
360 chassis_detail.has_vin_resp2_392() &&
361 chassis_detail.has_vin_resp3_393()) {
362 Vin_resp1_391 vin_resp1_391 = chassis_detail.vin_resp1_391();
363 Vin_resp2_392 vin_resp2_392 = chassis_detail.vin_resp2_392();
364 Vin_resp3_393 vin_resp3_393 = chassis_detail.vin_resp3_393();
365 if (vin_resp1_391.has_vin00() && vin_resp1_391.has_vin01() &&
366 vin_resp1_391.has_vin02() && vin_resp1_391.has_vin03() &&
367 vin_resp1_391.has_vin04() && vin_resp1_391.has_vin05() &&
368 vin_resp1_391.has_vin06() && vin_resp1_391.has_vin07() &&
369 vin_resp2_392.has_vin08() && vin_resp2_392.has_vin09() &&
370 vin_resp2_392.has_vin10() && vin_resp2_392.has_vin11() &&
371 vin_resp2_392.has_vin12() && vin_resp2_392.has_vin13() &&
372 vin_resp2_392.has_vin14() && vin_resp2_392.has_vin15() &&
373 vin_resp3_393.has_vin16()) {
374 int n[17];
375 n[0] = vin_resp1_391.vin07();
376 n[1] = vin_resp1_391.vin06();
377 n[2] = vin_resp1_391.vin05();
378 n[3] = vin_resp1_391.vin04();
379 n[4] = vin_resp1_391.vin03();
380 n[5] = vin_resp1_391.vin02();
381 n[6] = vin_resp1_391.vin01();
382 n[7] = vin_resp1_391.vin00();
383 n[8] = vin_resp2_392.vin15();
384 n[9] = vin_resp2_392.vin14();
385 n[10] = vin_resp2_392.vin13();
386 n[11] = vin_resp2_392.vin12();
387 n[12] = vin_resp2_392.vin11();
388 n[13] = vin_resp2_392.vin10();
389 n[14] = vin_resp2_392.vin09();
390 n[15] = vin_resp2_392.vin08();
391 n[16] = vin_resp3_393.vin16();
392 char ch[17];
393 memset(&ch, '\0', sizeof(ch));
394 for (int i = 0; i < 17; i++) {
395 ch[i] = static_cast<char>(n[i]);
396 }
397 chassis_.mutable_vehicle_id()->set_vin(ch);
398 }
399 }
400
401 if (chassis_error_mask_) {
402 chassis_.set_chassis_error_mask(chassis_error_mask_);
403 }
404 // Give engage_advice based on error_code and canbus feedback
405 if (!chassis_error_mask_ && !chassis_.parking_brake()) {
406 chassis_.mutable_engage_advice()->set_advice(
408 } else {
409 chassis_.mutable_engage_advice()->set_advice(
411 }
412
413 // 19 add checkresponse signal
414 if (chassis_detail.has_fbs3_237() &&
415 chassis_detail.fbs3_237().has_eps_streeingmode()) {
416 chassis_.mutable_check_response()->set_is_eps_online(
417 chassis_detail.fbs3_237().eps_streeingmode() == 1);
418 }
419 if (chassis_detail.has_status_310() &&
420 chassis_detail.status_310().has_longitudedrivingmode()) {
421 chassis_.mutable_check_response()->set_is_esp_online(
422 chassis_detail.status_310().longitudedrivingmode() == 1);
423 chassis_.mutable_check_response()->set_is_vcu_online(
424 chassis_detail.status_310().longitudedrivingmode() == 1);
425 }
426
427 return chassis_;
428}
MessageManager< ::apollo::canbus::Wey > * message_manager_
optional bool parking_brake
Definition chassis.proto:94

◆ FRIEND_TEST() [1/3]

apollo::canbus::wey::WeyController::FRIEND_TEST ( WeyControllerTest  ,
SetDrivingMode   
)

◆ FRIEND_TEST() [2/3]

apollo::canbus::wey::WeyController::FRIEND_TEST ( WeyControllerTest  ,
Status   
)

◆ FRIEND_TEST() [3/3]

apollo::canbus::wey::WeyController::FRIEND_TEST ( WeyControllerTest  ,
UpdateDrivingMode   
)

◆ Init()

ErrorCode apollo::canbus::wey::WeyController::Init ( const VehicleParameter params,
CanSender<::apollo::canbus::Wey > *const  can_sender,
MessageManager<::apollo::canbus::Wey > *const  message_manager 
)
override

在文件 wey_controller.cc43 行定义.

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

◆ Start()

bool apollo::canbus::wey::WeyController::Start ( )
overridevirtual

start the vehicle controller.

返回
true if successfully started.

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

在文件 wey_controller.cc122 行定义.

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

◆ Stop()

void apollo::canbus::wey::WeyController::Stop ( )
overridevirtual

stop the vehicle controller.

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

在文件 wey_controller.cc133 行定义.

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

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