Apollo 10.0
自动驾驶开放平台
steering_64.cc
浏览该文件的文档.
1/******************************************************************************
2 * Copyright 2017 The Apollo Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *****************************************************************************/
16
18
20
21namespace apollo {
22namespace canbus {
23namespace lincoln {
24
25using ::apollo::drivers::canbus::Byte;
26
27const int32_t Steering64::ID = 0x64;
28
29uint32_t Steering64::GetPeriod() const {
30 // receive rate??
31 // receive timeout would trigger fault, letting en=0 and etc.
32 static const uint32_t PERIOD = 10 * 1000;
33 return PERIOD;
34}
35
36void Steering64::UpdateData(uint8_t *data) {
37 set_steering_angle_p(data, steering_angle_);
38 set_enable_p(data, steering_enable_);
39 set_clear_driver_override_flag_p(data, clear_driver_override_flag_);
40 set_ignore_driver_override_p(data, ignore_driver_override_);
41 set_steering_angle_speed_p(data, steering_angle_speed_);
42 set_watchdog_counter_p(data, watchdog_counter_);
43 set_disable_audible_warning_p(data, disable_audible_warning_);
44}
45
47 steering_angle_ = 0.0;
48 steering_enable_ = false;
49 clear_driver_override_flag_ = false;
50 ignore_driver_override_ = false;
51 steering_angle_speed_ = 0.0;
52 watchdog_counter_ = 0;
53 disable_audible_warning_ = false;
54}
55
57 steering_angle_ = angle;
58 return this;
59}
60
62 steering_enable_ = true;
63 return this;
64}
65
67 steering_enable_ = false;
68 return this;
69}
70
72 steering_angle_speed_ = angle_speed;
73 return this;
74}
75
76// private
77
78// positive for left, negative for right
79void Steering64::set_steering_angle_p(uint8_t *data, double angle) {
80 angle = ProtocolData::BoundedValue(-470.0, 470.0, angle);
81 int32_t x = static_cast<int32_t>(angle / 0.100000);
82
83 // add offset
84 if (x < 0) {
85 x += 0x10000;
86 }
87
88 std::uint8_t t = 0;
89 t = static_cast<uint8_t>(x & 0xFF); // low
90 Byte frame_low(data + 0);
91 frame_low.set_value(t, 0, 8);
92
93 x >>= 8; // high
94 t = static_cast<uint8_t>(x & 0xFF);
95 Byte frame_high(data + 1);
96 frame_high.set_value(t, 0, 8);
97}
98
99void Steering64::set_enable_p(uint8_t *bytes, bool enable) {
100 Byte frame(bytes + 2);
101 if (enable) {
102 frame.set_bit_1(0);
103 } else {
104 frame.set_bit_0(0);
105 }
106}
107
108void Steering64::set_clear_driver_override_flag_p(uint8_t *bytes, bool clear) {
109 Byte frame(bytes + 2);
110 if (clear) {
111 frame.set_bit_1(1);
112 } else {
113 frame.set_bit_0(1);
114 }
115}
116
117void Steering64::set_ignore_driver_override_p(uint8_t *bytes, bool ignore) {
118 Byte frame(bytes + 2);
119 if (ignore) {
120 frame.set_bit_1(2);
121 } else {
122 frame.set_bit_0(2);
123 }
124}
125
126void Steering64::set_steering_angle_speed_p(uint8_t *data, double angle_speed) {
127 angle_speed = ProtocolData::BoundedValue(0.0, 500.0, angle_speed);
128 int32_t x = static_cast<int32_t>(angle_speed / 2.000000);
129
130 Byte frame(data + 3);
131 frame.set_value(static_cast<uint8_t>(x), 0, 8);
132}
133
134void Steering64::set_watchdog_counter_p(uint8_t *data, int32_t count) {
135 count = ProtocolData::BoundedValue(0, 255, count);
136 Byte frame(data + 7);
137 frame.set_value(static_cast<uint8_t>(count), 0, 8);
138}
139
140void Steering64::set_disable_audible_warning_p(uint8_t *data, bool disable) {
141 Byte frame(data + 2);
142 if (disable) {
143 frame.set_bit_1(4);
144 } else {
145 frame.set_bit_0(4);
146 }
147}
148
149} // namespace lincoln
150} // namespace canbus
151} // namespace apollo
Defines the Byte class.
one of the protocol data of lincoln vehicle
Definition steering_64.h:41
virtual void UpdateData(uint8_t *data)
update the data
Steering64 * set_enable()
set steering request enable to true
virtual void Reset()
reset the private variables
virtual uint32_t GetPeriod() const
get the data period
Steering64 * set_steering_angle_speed(double angle_speed)
set steering angle speed
Steering64 * set_steering_angle(double angle)
set steering angle
Steering64 * set_disable()
set steering request disable to true
class register implement
Definition arena_queue.h:37
the class of Steering64 (for lincoln vehicle)