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

this class implements the vehicle controller for lincoln vehicle. 更多...

#include <lincoln_controller.h>

类 apollo::canbus::lincoln::LincolnController 继承关系图:
apollo::canbus::lincoln::LincolnController 的协作图:

Public 成员函数

common::ErrorCode Init (const VehicleParameter &params, CanSender<::apollo::canbus::Lincoln > *const can_sender, MessageManager<::apollo::canbus::Lincoln > *const message_manager) override
 initialize the lincoln vehicle controller.
 
bool Start () override
 start the vehicle controller.
 
void Stop () override
 stop the vehicle controller.
 
Chassis chassis () override
 calculate and return the chassis.
 
 FRIEND_TEST (LincolnControllerTest, SetDrivingMode)
 
 FRIEND_TEST (LincolnControllerTest, Status)
 
 FRIEND_TEST (LincolnControllerTest, UpdateDrivingMode)
 
- Public 成员函数 继承自 apollo::canbus::VehicleController<::apollo::canbus::Lincoln >
virtual ~VehicleController ()=default
 
virtual common::ErrorCode Init (const VehicleParameter &params, CanSender< ::apollo::canbus::Lincoln > *const can_sender, MessageManager< ::apollo::canbus::Lincoln > *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::Lincoln GetNewRecvChassisDetail ()
 
virtual ::apollo::canbus::Lincoln GetNewSenderChassisDetail ()
 
virtual Chassis::DrivingMode driving_mode ()
 

额外继承的成员函数

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

详细描述

this class implements the vehicle controller for lincoln vehicle.

在文件 lincoln_controller.h57 行定义.

成员函数说明

◆ chassis()

Chassis apollo::canbus::lincoln::LincolnController::chassis ( )
overridevirtual

calculate and return the chassis.

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

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

在文件 lincoln_controller.cc151 行定义.

151 {
152 chassis_.Clear();
153
154 Lincoln chassis_detail;
155 message_manager_->GetSensorData(&chassis_detail);
156
157 // 21, 22, previously 1, 2
159 set_chassis_error_code(Chassis::NO_ERROR);
160 }
161
162 chassis_.set_driving_mode(driving_mode());
163 chassis_.set_error_code(chassis_error_code());
164
165 // 3
166 chassis_.set_engine_started(true);
167 // 4
168 if (chassis_detail.has_ems() && chassis_detail.ems().has_engine_rpm()) {
169 chassis_.set_engine_rpm(
170 static_cast<float>(chassis_detail.ems().engine_rpm()));
171 } else {
172 chassis_.set_engine_rpm(0);
173 }
174 // 5
175 if (chassis_detail.has_vehicle_spd() &&
176 chassis_detail.vehicle_spd().has_vehicle_spd()) {
177 chassis_.set_speed_mps(
178 static_cast<float>(chassis_detail.vehicle_spd().vehicle_spd()));
179 chassis_.mutable_wheel_speed()->set_is_wheel_spd_rr_valid(
180 chassis_detail.vehicle_spd().is_wheel_spd_rr_valid());
181 chassis_.mutable_wheel_speed()->set_wheel_direction_rr(
182 chassis_detail.vehicle_spd().wheel_direction_rr());
183 chassis_.mutable_wheel_speed()->set_wheel_spd_rr(
184 chassis_detail.vehicle_spd().wheel_spd_rr());
185
186 chassis_.mutable_wheel_speed()->set_is_wheel_spd_rl_valid(
187 chassis_detail.vehicle_spd().is_wheel_spd_rl_valid());
188 chassis_.mutable_wheel_speed()->set_wheel_direction_rl(
189 chassis_detail.vehicle_spd().wheel_direction_rl());
190 chassis_.mutable_wheel_speed()->set_wheel_spd_rl(
191 chassis_detail.vehicle_spd().wheel_spd_rl());
192
193 chassis_.mutable_wheel_speed()->set_is_wheel_spd_fr_valid(
194 chassis_detail.vehicle_spd().is_wheel_spd_fr_valid());
195 chassis_.mutable_wheel_speed()->set_wheel_direction_fr(
196 chassis_detail.vehicle_spd().wheel_direction_fr());
197 chassis_.mutable_wheel_speed()->set_wheel_spd_fr(
198 chassis_detail.vehicle_spd().wheel_spd_fr());
199
200 chassis_.mutable_wheel_speed()->set_is_wheel_spd_fl_valid(
201 chassis_detail.vehicle_spd().is_wheel_spd_fl_valid());
202 chassis_.mutable_wheel_speed()->set_wheel_direction_fl(
203 chassis_detail.vehicle_spd().wheel_direction_fl());
204 chassis_.mutable_wheel_speed()->set_wheel_spd_fl(
205 chassis_detail.vehicle_spd().wheel_spd_fl());
206
207 } else {
208 chassis_.set_speed_mps(0);
209 }
210 // 6
211 if (chassis_detail.has_basic() && chassis_detail.basic().has_odo_meter()) {
212 // odo_meter is in km
213 chassis_.set_odometer_m(
214 static_cast<float>(chassis_detail.basic().odo_meter() * 1000.0));
215 } else {
216 chassis_.set_odometer_m(0);
217 }
218
219 // 7
220 // lincoln only has fuel percentage
221 // to avoid confusing, just don't set
222 chassis_.set_fuel_range_m(0);
223 // 8
224 if (chassis_detail.has_gas() && chassis_detail.gas().has_throttle_output()) {
225 chassis_.set_throttle_percentage(
226 static_cast<float>(chassis_detail.gas().throttle_output()));
227 } else {
228 chassis_.set_throttle_percentage(0);
229 }
230 // 9
231 if (chassis_detail.has_brake() && chassis_detail.brake().has_brake_output()) {
232 chassis_.set_brake_percentage(
233 static_cast<float>(chassis_detail.brake().brake_output()));
234 } else {
235 chassis_.set_brake_percentage(0);
236 }
237 // 23, previously 10
238 if (chassis_detail.has_gear() && chassis_detail.gear().has_gear_state()) {
239 chassis_.set_gear_location(chassis_detail.gear().gear_state());
240 } else {
241 chassis_.set_gear_location(Chassis::GEAR_NONE);
242 }
243 // 11
244 if (chassis_detail.has_eps() && chassis_detail.eps().has_steering_angle()) {
245 chassis_.set_steering_percentage(
246 static_cast<float>(chassis_detail.eps().steering_angle() * 100.0 /
247 vehicle_params_.max_steer_angle() * M_PI / 180.0));
248 } else {
249 chassis_.set_steering_percentage(0);
250 }
251 // 12
252 if (chassis_detail.has_eps() && chassis_detail.eps().has_epas_torque()) {
253 chassis_.set_steering_torque_nm(
254 static_cast<float>(chassis_detail.eps().epas_torque()));
255 } else {
256 chassis_.set_steering_torque_nm(0);
257 }
258 // 13
259 if (chassis_detail.has_eps() &&
260 chassis_detail.epb().has_parking_brake_status()) {
261 chassis_.set_parking_brake(chassis_detail.epb().parking_brake_status() ==
263 } else {
264 chassis_.set_parking_brake(false);
265 }
266
267 // 14, 15
268 if (chassis_detail.has_light() &&
269 chassis_detail.light().has_lincoln_lamp_type()) {
270 chassis_.mutable_signal()->set_high_beam(
271 chassis_detail.light().lincoln_lamp_type() == Light::BEAM_HIGH);
272 } else {
273 chassis_.mutable_signal()->set_high_beam(false);
274 }
275
276 // 16, 17
277 if (chassis_detail.has_light() &&
278 chassis_detail.light().has_turn_light_type() &&
279 chassis_detail.light().turn_light_type() != Light::TURN_LIGHT_OFF) {
280 if (chassis_detail.light().turn_light_type() == Light::TURN_LEFT_ON) {
281 chassis_.mutable_signal()->set_turn_signal(
283 } else if (chassis_detail.light().turn_light_type() ==
285 chassis_.mutable_signal()->set_turn_signal(
287 } else {
288 chassis_.mutable_signal()->set_turn_signal(
290 }
291 } else {
292 chassis_.mutable_signal()->set_turn_signal(
294 }
295 // 18
296 if (chassis_detail.has_light() && chassis_detail.light().has_is_horn_on() &&
297 chassis_detail.light().is_horn_on()) {
298 chassis_.mutable_signal()->set_horn(true);
299 } else {
300 chassis_.mutable_signal()->set_horn(false);
301 }
302
303 // 19, lincoln wiper is too complicated
304 // 24
305 if (chassis_detail.has_eps() && chassis_detail.eps().has_timestamp_65()) {
306 chassis_.set_steering_timestamp(chassis_detail.eps().timestamp_65());
307 }
308 // 26
309 if (chassis_error_mask_) {
310 chassis_.set_chassis_error_mask(chassis_error_mask_);
311 }
312
313 // 6d, 6e, 6f, if gps valid is available, assume all gps related field
314 // available
315 if (chassis_detail.basic().has_gps_valid()) {
316 chassis_.mutable_chassis_gps()->set_latitude(
317 chassis_detail.basic().latitude());
318 chassis_.mutable_chassis_gps()->set_longitude(
319 chassis_detail.basic().longitude());
320 chassis_.mutable_chassis_gps()->set_gps_valid(
321 chassis_detail.basic().gps_valid());
322 chassis_.mutable_chassis_gps()->set_year(chassis_detail.basic().year());
323 chassis_.mutable_chassis_gps()->set_month(chassis_detail.basic().month());
324 chassis_.mutable_chassis_gps()->set_day(chassis_detail.basic().day());
325 chassis_.mutable_chassis_gps()->set_hours(chassis_detail.basic().hours());
326 chassis_.mutable_chassis_gps()->set_minutes(
327 chassis_detail.basic().minutes());
328 chassis_.mutable_chassis_gps()->set_seconds(
329 chassis_detail.basic().seconds());
330 chassis_.mutable_chassis_gps()->set_compass_direction(
331 chassis_detail.basic().compass_direction());
332 chassis_.mutable_chassis_gps()->set_pdop(chassis_detail.basic().pdop());
333 chassis_.mutable_chassis_gps()->set_is_gps_fault(
334 chassis_detail.basic().is_gps_fault());
335 chassis_.mutable_chassis_gps()->set_is_inferred(
336 chassis_detail.basic().is_inferred());
337 chassis_.mutable_chassis_gps()->set_altitude(
338 chassis_detail.basic().altitude());
339 chassis_.mutable_chassis_gps()->set_heading(
340 chassis_detail.basic().heading());
341 chassis_.mutable_chassis_gps()->set_hdop(chassis_detail.basic().hdop());
342 chassis_.mutable_chassis_gps()->set_vdop(chassis_detail.basic().vdop());
343 chassis_.mutable_chassis_gps()->set_quality(
344 chassis_detail.basic().quality());
345 chassis_.mutable_chassis_gps()->set_num_satellites(
346 chassis_detail.basic().num_satellites());
347 chassis_.mutable_chassis_gps()->set_gps_speed(
348 chassis_detail.basic().gps_speed());
349 } else {
350 chassis_.mutable_chassis_gps()->set_gps_valid(false);
351 }
352
353 // VIN number will be written into KVDB once.
354 if (chassis_detail.vehicle_id().has_vin()) {
355 chassis_.mutable_vehicle_id()->set_vin(chassis_detail.vehicle_id().vin());
356 if (!received_vin_) {
357 apollo::common::KVDB::Put("apollo:canbus:vin",
358 chassis_detail.vehicle_id().vin());
359 received_vin_ = true;
360 }
361 }
362
363 if (chassis_detail.has_surround()) {
364 chassis_.mutable_surround()->CopyFrom(chassis_detail.surround());
365 }
366 // Give engage_advice based on error_code and canbus feedback
367 if (chassis_error_mask_ || chassis_.throttle_percentage() == 0.0 ||
368 chassis_.brake_percentage() == 0.0) {
369 chassis_.mutable_engage_advice()->set_advice(
371 chassis_.mutable_engage_advice()->set_reason("Chassis error!");
372 } else if (chassis_.parking_brake() || CheckSafetyError(chassis_detail)) {
373 chassis_.mutable_engage_advice()->set_advice(
375 chassis_.mutable_engage_advice()->set_reason(
376 "Vehicle is not in a safe state to engage!");
377 } else {
378 chassis_.mutable_engage_advice()->set_advice(
380 }
381 return chassis_;
382}
MessageManager< ::apollo::canbus::Lincoln > * message_manager_
static bool Put(std::string_view key, std::string_view value)
Store {key, value} to DB.
Definition kv_db.cc:94
optional float brake_percentage
Definition chassis.proto:82
optional bool parking_brake
Definition chassis.proto:94
optional float throttle_percentage
Definition chassis.proto:79

◆ FRIEND_TEST() [1/3]

apollo::canbus::lincoln::LincolnController::FRIEND_TEST ( LincolnControllerTest  ,
SetDrivingMode   
)

◆ FRIEND_TEST() [2/3]

apollo::canbus::lincoln::LincolnController::FRIEND_TEST ( LincolnControllerTest  ,
Status   
)

◆ FRIEND_TEST() [3/3]

apollo::canbus::lincoln::LincolnController::FRIEND_TEST ( LincolnControllerTest  ,
UpdateDrivingMode   
)

◆ Init()

ErrorCode apollo::canbus::lincoln::LincolnController::Init ( const VehicleParameter params,
CanSender<::apollo::canbus::Lincoln > *const  can_sender,
MessageManager<::apollo::canbus::Lincoln > *const  message_manager 
)
override

initialize the lincoln vehicle controller.

返回
init error_code

在文件 lincoln_controller.cc50 行定义.

53 {
54 if (is_initialized_) {
55 AINFO << "LincolnController has already been initiated.";
56 return ErrorCode::CANBUS_ERROR;
57 }
58 vehicle_params_.CopyFrom(
59 common::VehicleConfigHelper::Instance()->GetConfig().vehicle_param());
60 params_.CopyFrom(params);
61 if (!params_.has_driving_mode()) {
62 AERROR << "Vehicle conf pb not set driving_mode.";
63 return ErrorCode::CANBUS_ERROR;
64 }
65
66 if (can_sender == nullptr) {
67 AERROR << "Canbus sender is null.";
68 return ErrorCode::CANBUS_ERROR;
69 }
70 can_sender_ = can_sender;
71
72 if (message_manager == nullptr) {
73 AERROR << "Protocol manager is null.";
74 return ErrorCode::CANBUS_ERROR;
75 }
76 message_manager_ = message_manager;
77
78 // Sender part
79 brake_60_ = dynamic_cast<Brake60 *>(
80 message_manager_->GetMutableProtocolDataById(Brake60::ID));
81 if (brake_60_ == nullptr) {
82 AERROR << "Brake60 does not exist in the LincolnMessageManager!";
83 return ErrorCode::CANBUS_ERROR;
84 }
85
86 throttle_62_ = dynamic_cast<Throttle62 *>(
87 message_manager_->GetMutableProtocolDataById(Throttle62::ID));
88 if (throttle_62_ == nullptr) {
89 AERROR << "Throttle62 does not exist in the LincolnMessageManager!";
90 return ErrorCode::CANBUS_ERROR;
91 }
92
93 steering_64_ = dynamic_cast<Steering64 *>(
94 message_manager_->GetMutableProtocolDataById(Steering64::ID));
95 if (steering_64_ == nullptr) {
96 AERROR << "Steering64 does not exist in the LincolnMessageManager!";
97 return ErrorCode::CANBUS_ERROR;
98 }
99
100 gear_66_ = dynamic_cast<Gear66 *>(
101 message_manager_->GetMutableProtocolDataById(Gear66::ID));
102 if (gear_66_ == nullptr) {
103 AERROR << "Gear66 does not exist in the LincolnMessageManager!";
104 return ErrorCode::CANBUS_ERROR;
105 }
106 turnsignal_68_ = dynamic_cast<Turnsignal68 *>(
107 message_manager_->GetMutableProtocolDataById(Turnsignal68::ID));
108 if (turnsignal_68_ == nullptr) {
109 AERROR << "Turnsignal68 does not exist in the LincolnMessageManager!";
110 return ErrorCode::CANBUS_ERROR;
111 }
112
113 can_sender_->AddMessage(Brake60::ID, brake_60_, false);
114 can_sender_->AddMessage(Throttle62::ID, throttle_62_, false);
115 can_sender_->AddMessage(Steering64::ID, steering_64_, false);
116 can_sender_->AddMessage(Gear66::ID, gear_66_, false);
117 can_sender_->AddMessage(Turnsignal68::ID, turnsignal_68_, false);
118
119 // Need to sleep to ensure all messages received
120 AINFO << "LincolnController is initialized.";
121
122 gear_tmp_ = Chassis::GEAR_INVALID;
123 is_initialized_ = true;
124 return ErrorCode::OK;
125}
static const int32_t ID
Definition brake_60.h:43
static const int32_t ID
Definition gear_66.h:43
#define AERROR
Definition log.h:44
#define AINFO
Definition log.h:42

◆ Start()

bool apollo::canbus::lincoln::LincolnController::Start ( )
overridevirtual

start the vehicle controller.

返回
true if successfully started.

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

在文件 lincoln_controller.cc127 行定义.

127 {
128 if (!is_initialized_) {
129 AERROR << "LincolnController has NOT been initiated.";
130 return false;
131 }
132 const auto &update_func = [this] { SecurityDogThreadFunc(); };
133 thread_.reset(new std::thread(update_func));
134
135 return true;
136}

◆ Stop()

void apollo::canbus::lincoln::LincolnController::Stop ( )
overridevirtual

stop the vehicle controller.

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

在文件 lincoln_controller.cc138 行定义.

138 {
139 if (!is_initialized_) {
140 AERROR << "LincolnController stops or starts improperly!";
141 return;
142 }
143
144 if (thread_ != nullptr && thread_->joinable()) {
145 thread_->join();
146 thread_.reset();
147 AINFO << "LincolnController stopped.";
148 }
149}

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