Apollo 10.0
自动驾驶开放平台
adc_motioncontrol1_10.cc
浏览该文件的文档.
1/******************************************************************************
2 * Copyright 2018 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 transit {
24
25using ::apollo::drivers::canbus::Byte;
26
27const int32_t Adcmotioncontrol110::ID = 0x10;
28
29// public
31
33 // TODO(All) : modify every protocol's period manually
34 static const uint32_t PERIOD = 10 * 1000;
35 return PERIOD;
36}
37
39 set_p_adc_cmd_steerwheelangle(data, adc_cmd_steerwheelangle_);
40 set_p_adc_cmd_steeringcontrolmode(data, adc_cmd_steeringcontrolmode_);
41 set_p_adc_cmd_parkingbrake(data, adc_cmd_parkingbrake_);
42 set_p_adc_cmd_gear(data, adc_cmd_gear_);
43 set_p_adc_motioncontrol1_checksum(data, adc_motioncontrol1_checksum_);
44 set_p_adc_cmd_brakepercentage(data, adc_cmd_brakepercentage_);
45 set_p_adc_cmd_throttleposition(data, adc_cmd_throttleposition_);
46 set_p_adc_motioncontrol1_counter(data, adc_motioncontrol1_counter_);
47 set_p_adc_cmd_autonomyrequest(data, adc_cmd_autonomyrequest_);
48 set_p_adc_cmd_longitudinalcontrolmode(data, adc_cmd_longitudinalcontrolmode_);
49}
50
52 // TODO(All) : you should check this manually
53 adc_cmd_steerwheelangle_ = 0.0;
54 adc_cmd_steeringcontrolmode_ =
56 adc_cmd_parkingbrake_ = false;
58 adc_motioncontrol1_checksum_ = 0;
59 adc_cmd_brakepercentage_ = 0.0;
60 adc_cmd_throttleposition_ = 0.0;
61 adc_motioncontrol1_counter_ = 0;
62 adc_cmd_autonomyrequest_ =
64 adc_cmd_longitudinalcontrolmode_ =
66}
67
69 double adc_cmd_steerwheelangle) {
70 adc_cmd_steerwheelangle_ = adc_cmd_steerwheelangle;
71 return this;
72}
73
74// config detail: {'description': 'Setpoint for steering wheel angle. Positive
75// for CW', 'offset': 0.0, 'precision': -0.05, 'len': 16, 'name':
76// 'ADC_CMD_SteerWheelAngle', 'is_signed_var': True, 'physical_range':
77// '[-1638.4|1638.35]', 'bit': 27, 'type': 'double', 'order': 'intel',
78// 'physical_unit': 'deg'}
79void Adcmotioncontrol110::set_p_adc_cmd_steerwheelangle(
80 uint8_t* data, double adc_cmd_steerwheelangle) {
81 adc_cmd_steerwheelangle =
82 ProtocolData::BoundedValue(-1638.4, 1638.35, adc_cmd_steerwheelangle);
83 int x = static_cast<int>(adc_cmd_steerwheelangle / -0.050000);
84 uint8_t t = 0;
85
86 t = static_cast<uint8_t>(x & 0x1F);
87 Byte to_set0(data + 3);
88 to_set0.set_value(t, 3, 5);
89 x >>= 5;
90
91 t = static_cast<uint8_t>(x & 0xFF);
92 Byte to_set1(data + 4);
93 to_set1.set_value(t, 0, 8);
94 x >>= 8;
95
96 t = static_cast<uint8_t>(x & 0x7);
97 Byte to_set2(data + 5);
98 to_set2.set_value(t, 0, 3);
99}
100
103 adc_cmd_steeringcontrolmode) {
104 adc_cmd_steeringcontrolmode_ = adc_cmd_steeringcontrolmode;
105 return this;
106}
107
108// config detail: {'description': 'Select steering control mode', 'enum': {0:
109// 'ADC_CMD_STEERINGCONTROLMODE_NONE', 1: 'ADC_CMD_STEERINGCONTROLMODE_ANGLE',
110// 2: 'ADC_CMD_STEERINGCONTROLMODE_RESERVED_CURVATURE', 3:
111// 'ADC_CMD_STEERINGCONTROLMODE_RESERVED'}, 'precision': 1.0, 'len': 2, 'name':
112// 'ADC_CMD_SteeringControlMode', 'is_signed_var': False, 'offset': 0.0,
113// 'physical_range': '[0|3]', 'bit': 4, 'type': 'enum', 'order': 'intel',
114// 'physical_unit': ''}
115void Adcmotioncontrol110::set_p_adc_cmd_steeringcontrolmode(
117 adc_cmd_steeringcontrolmode) {
118 int x = adc_cmd_steeringcontrolmode;
119
120 Byte to_set(data + 0);
121 to_set.set_value(static_cast<uint8_t>(x), 4, 2);
122}
123
125 bool adc_cmd_parkingbrake) {
126 adc_cmd_parkingbrake_ = adc_cmd_parkingbrake;
127 return this;
128}
129
130// config detail: {'description': '(Reserved) Control parking brake', 'offset':
131// 0.0, 'precision': 1.0, 'len': 1, 'name': 'ADC_CMD_ParkingBrake',
132// 'is_signed_var': False, 'physical_range': '[0|1]', 'bit': 53, 'type': 'bool',
133// 'order': 'intel', 'physical_unit': 'T/F'}
134void Adcmotioncontrol110::set_p_adc_cmd_parkingbrake(
135 uint8_t* data, bool adc_cmd_parkingbrake) {
136 int x = adc_cmd_parkingbrake;
137
138 Byte to_set(data + 6);
139 to_set.set_value(static_cast<uint8_t>(x), 5, 1);
140}
141
144 adc_cmd_gear_ = adc_cmd_gear;
145 return this;
146}
147
148// config detail: {'description': 'Transmission control - only used in direct
149// longitudinal control', 'enum': {0: 'ADC_CMD_GEAR_P_PARK', 1:
150// 'ADC_CMD_GEAR_D_DRIVE', 2: 'ADC_CMD_GEAR_N_NEUTRAL', 3:
151// 'ADC_CMD_GEAR_R_REVERSE'}, 'precision': 1.0, 'len': 3, 'name':
152// 'ADC_CMD_Gear', 'is_signed_var': False, 'offset': 0.0, 'physical_range':
153// '[0|7]', 'bit': 50, 'type': 'enum', 'order': 'intel', 'physical_unit': ''}
154void Adcmotioncontrol110::set_p_adc_cmd_gear(
155 uint8_t* data, Adc_motioncontrol1_10::Adc_cmd_gearType adc_cmd_gear) {
156 int x = adc_cmd_gear;
157
158 Byte to_set(data + 6);
159 to_set.set_value(static_cast<uint8_t>(x), 2, 3);
160}
161
163 int adc_motioncontrol1_checksum) {
164 adc_motioncontrol1_checksum_ = adc_motioncontrol1_checksum;
165 return this;
166}
167
168// config detail: {'description': 'Motion Control 1 checksum', 'offset': 0.0,
169// 'precision': 1.0, 'len': 8, 'name': 'ADC_MotionControl1_Checksum',
170// 'is_signed_var': False, 'physical_range': '[0|255]', 'bit': 56, 'type':
171// 'int', 'order': 'intel', 'physical_unit': ''}
172void Adcmotioncontrol110::set_p_adc_motioncontrol1_checksum(
173 uint8_t* data, int adc_motioncontrol1_checksum) {
174 adc_motioncontrol1_checksum =
175 ProtocolData::BoundedValue(0, 255, adc_motioncontrol1_checksum);
176 int x = adc_motioncontrol1_checksum;
177
178 Byte to_set(data + 7);
179 to_set.set_value(static_cast<uint8_t>(x), 0, 8);
180}
181
183 double adc_cmd_brakepercentage) {
184 adc_cmd_brakepercentage_ = adc_cmd_brakepercentage;
185 return this;
186}
187
188// config detail: {'description': 'Brake pressure for direct longitudinal
189// control', 'offset': 0.0, 'precision': 0.0556, 'len': 11, 'name':
190// 'ADC_CMD_BrakePercentage', 'is_signed_var': False, 'physical_range':
191// '[0|113.8132]', 'bit': 6, 'type': 'double', 'order': 'intel',
192// 'physical_unit': '%'}
193void Adcmotioncontrol110::set_p_adc_cmd_brakepercentage(
194 uint8_t* data, double adc_cmd_brakepercentage) {
195 adc_cmd_brakepercentage =
196 ProtocolData::BoundedValue(0.0, 113.8132, adc_cmd_brakepercentage);
197 int x = static_cast<int>(adc_cmd_brakepercentage / 0.055600);
198 uint8_t t = 0;
199
200 t = static_cast<uint8_t>(x & 0x3);
201 Byte to_set0(data + 0);
202 to_set0.set_value(t, 6, 2);
203 x >>= 2;
204
205 t = static_cast<uint8_t>(x & 0xFF);
206 Byte to_set1(data + 1);
207 to_set1.set_value(t, 0, 8);
208 x >>= 8;
209
210 t = static_cast<uint8_t>(x & 0x1);
211 Byte to_set2(data + 2);
212 to_set2.set_value(t, 0, 1);
213}
214
216 double adc_cmd_throttleposition) {
217 adc_cmd_throttleposition_ = adc_cmd_throttleposition;
218 return this;
219}
220
221// config detail: {'description': 'Throttle pedal position percentage for direct
222// longitudinal control', 'offset': 0.0, 'precision': 0.1, 'len': 10, 'name':
223// 'ADC_CMD_ThrottlePosition', 'is_signed_var': False, 'physical_range':
224// '[0|100]', 'bit': 17, 'type': 'double', 'order': 'intel', 'physical_unit':
225// '%'}
226void Adcmotioncontrol110::set_p_adc_cmd_throttleposition(
227 uint8_t* data, double adc_cmd_throttleposition) {
228 adc_cmd_throttleposition =
229 ProtocolData::BoundedValue(0.0, 100.0, adc_cmd_throttleposition);
230 int x = static_cast<int>(adc_cmd_throttleposition / 0.100000);
231 uint8_t t = 0;
232
233 t = static_cast<uint8_t>(x & 0x7F);
234 Byte to_set0(data + 2);
235 to_set0.set_value(t, 1, 7);
236 x >>= 7;
237
238 t = static_cast<uint8_t>(x & 0x7);
239 Byte to_set1(data + 3);
240 to_set1.set_value(t, 0, 3);
241}
242
244 int adc_motioncontrol1_counter) {
245 adc_motioncontrol1_counter_ = adc_motioncontrol1_counter;
246 return this;
247}
248
249// config detail: {'description': 'Motion control 1 Heartbeat counter',
250// 'offset': 0.0, 'precision': 1.0, 'len': 2, 'name':
251// 'ADC_MotionControl1_Counter', 'is_signed_var': False, 'physical_range':
252// '[0|3]', 'bit': 54, 'type': 'int', 'order': 'intel', 'physical_unit': ''}
253void Adcmotioncontrol110::set_p_adc_motioncontrol1_counter(
254 uint8_t* data, int adc_motioncontrol1_counter) {
255 adc_motioncontrol1_counter =
256 ProtocolData::BoundedValue(0, 3, adc_motioncontrol1_counter);
257 int x = adc_motioncontrol1_counter;
258
259 Byte to_set(data + 6);
260 to_set.set_value(static_cast<uint8_t>(x), 6, 2);
261}
262
265 adc_cmd_autonomyrequest) {
266 adc_cmd_autonomyrequest_ = adc_cmd_autonomyrequest;
267 return this;
268}
269
270// config detail: {'description': 'Request from ADC to LLC for autonomy',
271// 'enum': {0: 'ADC_CMD_AUTONOMYREQUEST_AUTONOMY_NOT_REQUESTED', 1:
272// 'ADC_CMD_AUTONOMYREQUEST_AUTONOMY_REQUESTED', 2:
273// 'ADC_CMD_AUTONOMYREQUEST_RESERVED0', 3: 'ADC_CMD_AUTONOMYREQUEST_RESERVED1'},
274// 'precision': 1.0, 'len': 2, 'name': 'ADC_CMD_AutonomyRequest',
275// 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|3]', 'bit': 0,
276// 'type': 'enum', 'order': 'intel', 'physical_unit': ''}
277void Adcmotioncontrol110::set_p_adc_cmd_autonomyrequest(
279 adc_cmd_autonomyrequest) {
280 int x = adc_cmd_autonomyrequest;
281
282 Byte to_set(data + 0);
283 to_set.set_value(static_cast<uint8_t>(x), 0, 2);
284}
285
288 adc_cmd_longitudinalcontrolmode) {
289 adc_cmd_longitudinalcontrolmode_ = adc_cmd_longitudinalcontrolmode;
290 return this;
291}
292
293// config detail: {'description': 'Select longitudinal control mode', 'enum':
294// {0: 'ADC_CMD_LONGITUDINALCONTROLMODE_NONE', 1:
295// 'ADC_CMD_LONGITUDINALCONTROLMODE_RESERVED_VELOCITY_AND_ACCELERATION', 2:
296// 'ADC_CMD_LONGITUDINALCONTROLMODE_RESERVED_FORCE', 3:
297// 'ADC_CMD_LONGITUDINALCONTROLMODE_DIRECT_THROTTLE_BRAKE'}, 'precision': 1.0,
298// 'len': 2, 'name': 'ADC_CMD_LongitudinalControlMode', 'is_signed_var': False,
299// 'offset': 0.0, 'physical_range': '[0|3]', 'bit': 2, 'type': 'enum', 'order':
300// 'intel', 'physical_unit': ''}
301void Adcmotioncontrol110::set_p_adc_cmd_longitudinalcontrolmode(
303 adc_cmd_longitudinalcontrolmode) {
304 int x = adc_cmd_longitudinalcontrolmode;
305
306 Byte to_set(data + 0);
307 to_set.set_value(static_cast<uint8_t>(x), 2, 2);
308}
309
310} // namespace transit
311} // namespace canbus
312} // namespace apollo
Defines the Byte class.
Adcmotioncontrol110 * set_adc_cmd_gear(Adc_motioncontrol1_10::Adc_cmd_gearType adc_cmd_gear)
Adcmotioncontrol110 * set_adc_cmd_brakepercentage(double adc_cmd_brakepercentage)
Adcmotioncontrol110 * set_adc_cmd_throttleposition(double adc_cmd_throttleposition)
Adcmotioncontrol110 * set_adc_cmd_parkingbrake(bool adc_cmd_parkingbrake)
Adcmotioncontrol110 * set_adc_cmd_longitudinalcontrolmode(Adc_motioncontrol1_10::Adc_cmd_longitudinalcontrolmodeType adc_cmd_longitudinalcontrolmode)
Adcmotioncontrol110 * set_adc_cmd_autonomyrequest(Adc_motioncontrol1_10::Adc_cmd_autonomyrequestType adc_cmd_autonomyrequest)
Adcmotioncontrol110 * set_adc_motioncontrol1_checksum(int adc_motioncontrol1_checksum)
Adcmotioncontrol110 * set_adc_cmd_steerwheelangle(double adc_cmd_steerwheelangle)
Adcmotioncontrol110 * set_adc_cmd_steeringcontrolmode(Adc_motioncontrol1_10::Adc_cmd_steeringcontrolmodeType adc_cmd_steeringcontrolmode)
Adcmotioncontrol110 * set_adc_motioncontrol1_counter(int adc_motioncontrol1_counter)
class register implement
Definition arena_queue.h:37