Apollo 10.0
自动驾驶开放平台
dash_controls_right_rpt_210.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 lexus {
24
25using ::apollo::drivers::canbus::Byte;
26
27const int32_t Dashcontrolsrightrpt210::ID = 0x210;
28
29// public
31
33 // TODO(QiL) modify every protocol's period manually
34 static const uint32_t PERIOD = 20 * 1000;
35 return PERIOD;
36}
37
39 set_p_output_value(data, output_value_);
40 set_p_commanded_value(data, commanded_value_);
41 set_p_vehicle_fault(data, vehicle_fault_);
42 set_p_pacmod_fault(data, pacmod_fault_);
43 set_p_override_active(data, override_active_);
44 set_p_output_reported_fault(data, output_reported_fault_);
45 set_p_input_output_fault(data, input_output_fault_);
46 set_p_enabled(data, enabled_);
47 set_p_command_output_fault(data, command_output_fault_);
48 set_p_manual_input(data, manual_input_);
49}
50
52 // TODO(QiL) you should check this manually
54 commanded_value_ =
56 vehicle_fault_ = false;
57 pacmod_fault_ = false;
58 override_active_ = false;
59 output_reported_fault_ = false;
60 input_output_fault_ = false;
61 enabled_ = false;
62 command_output_fault_ = false;
64}
65
68 output_value_ = output_value;
69 return this;
70}
71
72// config detail: {'name': 'OUTPUT_VALUE', 'enum': {0:
73// 'OUTPUT_VALUE_DASH_CONTROL_NONE', 1: 'OUTPUT_VALUE_DASH_CONTROL_OK', 2:
74// 'OUTPUT_VALUE_DASH_CONTROL_LEFT', 3: 'OUTPUT_VALUE_DASH_CONTROL_RIGHT', 4:
75// 'OUTPUT_VALUE_DASH_CONTROL_UP', 5: 'OUTPUT_VALUE_DASH_CONTROL_DOWN'},
76// 'precision': 1.0, 'len': 8, 'is_signed_var': False, 'offset': 0.0,
77// 'physical_range': '[0|255]', 'bit': 31, 'type': 'enum', 'order': 'motorola',
78// 'physical_unit': ''}
79void Dashcontrolsrightrpt210::set_p_output_value(
80 uint8_t* data, Dash_controls_right_rpt_210::Output_valueType output_value) {
81 int x = output_value;
82
83 Byte to_set(data + 3);
84 to_set.set_value(static_cast<uint8_t>(x), 0, 8);
85}
86
89 commanded_value_ = commanded_value;
90 return this;
91}
92
93// config detail: {'name': 'COMMANDED_VALUE', 'enum': {0:
94// 'COMMANDED_VALUE_DASH_CONTROL_NONE', 1: 'COMMANDED_VALUE_DASH_CONTROL_OK', 2:
95// 'COMMANDED_VALUE_DASH_CONTROL_LEFT', 3: 'COMMANDED_VALUE_DASH_CONTROL_RIGHT',
96// 4: 'COMMANDED_VALUE_DASH_CONTROL_UP', 5:
97// 'COMMANDED_VALUE_DASH_CONTROL_DOWN'}, 'precision': 1.0, 'len': 8,
98// 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|255]', 'bit':
99// 23, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
100void Dashcontrolsrightrpt210::set_p_commanded_value(
101 uint8_t* data,
103 int x = commanded_value;
104
105 Byte to_set(data + 2);
106 to_set.set_value(static_cast<uint8_t>(x), 0, 8);
107}
108
110 bool vehicle_fault) {
111 vehicle_fault_ = vehicle_fault;
112 return this;
113}
114
115// config detail: {'name': 'VEHICLE_FAULT', 'offset': 0.0, 'precision': 1.0,
116// 'len': 1, 'is_signed_var': False, 'physical_range': '[0|1]', 'bit': 6,
117// 'type': 'bool', 'order': 'motorola', 'physical_unit': ''}
118void Dashcontrolsrightrpt210::set_p_vehicle_fault(uint8_t* data,
119 bool vehicle_fault) {
120 int x = vehicle_fault;
121
122 Byte to_set(data + 0);
123 to_set.set_value(static_cast<uint8_t>(x), 6, 1);
124}
125
127 bool pacmod_fault) {
128 pacmod_fault_ = pacmod_fault;
129 return this;
130}
131
132// config detail: {'name': 'PACMOD_FAULT', 'offset': 0.0, 'precision': 1.0,
133// 'len': 1, 'is_signed_var': False, 'physical_range': '[0|1]', 'bit': 5,
134// 'type': 'bool', 'order': 'motorola', 'physical_unit': ''}
135void Dashcontrolsrightrpt210::set_p_pacmod_fault(uint8_t* data,
136 bool pacmod_fault) {
137 int x = pacmod_fault;
138
139 Byte to_set(data + 0);
140 to_set.set_value(static_cast<uint8_t>(x), 5, 1);
141}
142
144 bool override_active) {
145 override_active_ = override_active;
146 return this;
147}
148
149// config detail: {'name': 'OVERRIDE_ACTIVE', 'offset': 0.0, 'precision': 1.0,
150// 'len': 1, 'is_signed_var': False, 'physical_range': '[0|1]', 'bit': 1,
151// 'type': 'bool', 'order': 'motorola', 'physical_unit': ''}
152void Dashcontrolsrightrpt210::set_p_override_active(uint8_t* data,
153 bool override_active) {
154 int x = override_active;
155
156 Byte to_set(data + 0);
157 to_set.set_value(static_cast<uint8_t>(x), 1, 1);
158}
159
161 bool output_reported_fault) {
162 output_reported_fault_ = output_reported_fault;
163 return this;
164}
165
166// config detail: {'name': 'OUTPUT_REPORTED_FAULT', 'offset': 0.0,
167// 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'physical_range':
168// '[0|1]', 'bit': 4, 'type': 'bool', 'order': 'motorola', 'physical_unit': ''}
169void Dashcontrolsrightrpt210::set_p_output_reported_fault(
170 uint8_t* data, bool output_reported_fault) {
171 int x = output_reported_fault;
172
173 Byte to_set(data + 0);
174 to_set.set_value(static_cast<uint8_t>(x), 4, 1);
175}
176
178 bool input_output_fault) {
179 input_output_fault_ = input_output_fault;
180 return this;
181}
182
183// config detail: {'name': 'INPUT_OUTPUT_FAULT', 'offset': 0.0,
184// 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'physical_range':
185// '[0|1]', 'bit': 3, 'type': 'bool', 'order': 'motorola', 'physical_unit': ''}
186void Dashcontrolsrightrpt210::set_p_input_output_fault(
187 uint8_t* data, bool input_output_fault) {
188 int x = input_output_fault;
189
190 Byte to_set(data + 0);
191 to_set.set_value(static_cast<uint8_t>(x), 3, 1);
192}
193
195 enabled_ = enabled;
196 return this;
197}
198
199// config detail: {'name': 'ENABLED', 'offset': 0.0, 'precision': 1.0, 'len': 1,
200// 'is_signed_var': False, 'physical_range': '[0|1]', 'bit': 0, 'type': 'bool',
201// 'order': 'motorola', 'physical_unit': ''}
202void Dashcontrolsrightrpt210::set_p_enabled(uint8_t* data, bool enabled) {
203 int x = enabled;
204
205 Byte to_set(data + 0);
206 to_set.set_value(static_cast<uint8_t>(x), 0, 1);
207}
208
210 bool command_output_fault) {
211 command_output_fault_ = command_output_fault;
212 return this;
213}
214
215// config detail: {'name': 'COMMAND_OUTPUT_FAULT', 'offset': 0.0,
216// 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'physical_range':
217// '[0|1]', 'bit': 2, 'type': 'bool', 'order': 'motorola', 'physical_unit': ''}
218void Dashcontrolsrightrpt210::set_p_command_output_fault(
219 uint8_t* data, bool command_output_fault) {
220 int x = command_output_fault;
221
222 Byte to_set(data + 0);
223 to_set.set_value(static_cast<uint8_t>(x), 2, 1);
224}
225
228 manual_input_ = manual_input;
229 return this;
230}
231
232// config detail: {'name': 'MANUAL_INPUT', 'enum': {0:
233// 'MANUAL_INPUT_DASH_CONTROL_NONE', 1: 'MANUAL_INPUT_DASH_CONTROL_OK', 2:
234// 'MANUAL_INPUT_DASH_CONTROL_LEFT', 3: 'MANUAL_INPUT_DASH_CONTROL_RIGHT', 4:
235// 'MANUAL_INPUT_DASH_CONTROL_UP', 5: 'MANUAL_INPUT_DASH_CONTROL_DOWN'},
236// 'precision': 1.0, 'len': 8, 'is_signed_var': False, 'offset': 0.0,
237// 'physical_range': '[0|255]', 'bit': 15, 'type': 'enum', 'order': 'motorola',
238// 'physical_unit': ''}
239void Dashcontrolsrightrpt210::set_p_manual_input(
240 uint8_t* data, Dash_controls_right_rpt_210::Manual_inputType manual_input) {
241 int x = manual_input;
242
243 Byte to_set(data + 1);
244 to_set.set_value(static_cast<uint8_t>(x), 0, 8);
245}
246
247} // namespace lexus
248} // namespace canbus
249} // namespace apollo
Defines the Byte class.
Dashcontrolsrightrpt210 * set_vehicle_fault(bool vehicle_fault)
Dashcontrolsrightrpt210 * set_override_active(bool override_active)
Dashcontrolsrightrpt210 * set_pacmod_fault(bool pacmod_fault)
Dashcontrolsrightrpt210 * set_enabled(bool enabled)
Dashcontrolsrightrpt210 * set_commanded_value(Dash_controls_right_rpt_210::Commanded_valueType commanded_value)
Dashcontrolsrightrpt210 * set_command_output_fault(bool command_output_fault)
Dashcontrolsrightrpt210 * set_input_output_fault(bool input_output_fault)
Dashcontrolsrightrpt210 * set_output_value(Dash_controls_right_rpt_210::Output_valueType output_value)
Dashcontrolsrightrpt210 * set_manual_input(Dash_controls_right_rpt_210::Manual_inputType manual_input)
Dashcontrolsrightrpt210 * set_output_reported_fault(bool output_reported_fault)
class register implement
Definition arena_queue.h:37