Formula Student Electronics & Software
The code for the embedded software
Loading...
Searching...
No Matches
test_integration.cpp
Go to the documentation of this file.
1#include "comm/communicator.hpp"
2#include "embedded/digitalSender.hpp"
3#include "logic/stateLogic.hpp"
4#include "model/systemData.hpp"
5#include "unity.h"
6
7#define HYDRAULIC_PRESSURE_HIGH 0xf8
8#define HYDRAULIC_PRESSURE_LOW 0x01
9#define BAMOCAR_VDC_HIGH 0x11
10#define RES_GO 0x02
11
12SystemData sd;
13Communicator communicator = Communicator(&sd); // CAN
14DigitalSender digitalSender = DigitalSender(); // Digital outputs
15ASState as_state = ASState(&sd, &communicator, &digitalSender);
16
24
28void to_ready() {
29 sd.hardware_data_.asms_on_ = true;
30 // sd.digitalData.watchdog_state = true;
31 sd.hardware_data_.bspd_sdc_open_ = false;
32
33 uint8_t bamo_msg[] = {VDC_BUS, 0x00, BAMOCAR_VDC_HIGH}; // VDC_BUS fill
34 communicator.bamocar_callback(bamo_msg);
35
36 sd.hardware_data_.pneumatic_line_pressure_ = true;
37 uint8_t hydraulic_msg[] = {HYDRAULIC_LINE, HYDRAULIC_PRESSURE_HIGH, 0x00};
38 communicator.c1_callback(hydraulic_msg);
39
40 // Iterate a few times to go to check wd
41 Metro time{1};
42 while (!time.checkWithoutReset()) {
43 as_state.calculate_state();
44 }
45
46 // sd.digitalData.watchdog_state = false;
47 // Wait for wd timeout
48 Metro time2{INITIAL_CHECKUP_STEP_TIMEOUT};
49 while (!time2.checkWithoutReset()) {
50 as_state.calculate_state();
51 sd.failure_detection_.inversor_alive_timestamp_.reset();
52 sd.failure_detection_.pc_alive_timestamp_.reset();
53 sd.failure_detection_.steer_alive_timestamp_.reset();
54 sd.failure_detection_.res_signal_loss_timestamp_.reset();
55 }
56}
57
62void test_off_to_ready_success(void) {
63 reset();
64 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
65
66 to_ready();
67
68 TEST_ASSERT_EQUAL(false, sd.failure_detection_.emergency_signal_);
69
70 TEST_ASSERT_EQUAL(CheckupManager::CheckupState::CHECK_TIMESTAMPS,
71 as_state._checkup_manager_.checkupState);
72
73 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
74}
75
80void test_off_to_ready_recheck() {
81 reset();
82
83 bool went_ready = false;
84 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
85
86 sd.hardware_data_.asms_on_ = true;
87 // sd.digitalData.watchdog_state = true;
88 sd.hardware_data_.bspd_sdc_open_ = false;
89
90 uint8_t bamo_msg[] = {VDC_BUS, 0x00, BAMOCAR_VDC_HIGH}; // VDC_BUS fill
91 communicator.bamocar_callback(bamo_msg);
92
93 sd.hardware_data_.pneumatic_line_pressure_ = true;
94 uint8_t hydraulic_msg[] = {HYDRAULIC_LINE, HYDRAULIC_PRESSURE_HIGH, 0x00};
95 communicator.c1_callback(hydraulic_msg);
96
97 // // Iterate a few times to go to check wd
98 // Metro time{1};
99 // while (!time.checkWithoutReset()) {
100 // as_state.calculate_state();
101 // }
102
103 // sd.digitalData.watchdog_state = false;
104 sd.hardware_data_.asms_on_ = false; // switch previously checked condition
105 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
106 // Wait for wd timeout
107
108 Metro time2{INITIAL_CHECKUP_STEP_TIMEOUT};
109 while (!time2.checkWithoutReset()) {
110 if (as_state.state_ == State::AS_READY) went_ready = true;
111
112 as_state.calculate_state();
113 sd.failure_detection_.inversor_alive_timestamp_.reset();
114 sd.failure_detection_.pc_alive_timestamp_.reset();
115 sd.failure_detection_.steer_alive_timestamp_.reset();
116 }
117
118 TEST_ASSERT_EQUAL(false, went_ready);
119 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
120}
121
125void test_off_to_ready_wayback_impossible() {
126 bool reverted_to_off = false;
127 reset();
128 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
129 to_ready();
130 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
131
132 // Procedure to go back to AS_OFF state
133 uint8_t bamo_msg2[] = {VDC_BUS, 0x00, 0x00}; // cd voltage set to below threshold
134 communicator.bamocar_callback(bamo_msg2);
135
136 Metro time3{1};
137 while (!time3.checkWithoutReset()) {
138 as_state.calculate_state();
139 if (as_state.state_ == State::AS_OFF) reverted_to_off = true;
140 }
141
142 TEST_ASSERT_EQUAL(false, reverted_to_off);
143 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
144}
145
150void test_ready_to_emg_to_off() {
151 reset();
152 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
153 to_ready();
154 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
155
156 Metro time{COMPONENT_TIMESTAMP_TIMEOUT + 10};
157 while (!time.checkWithoutReset()) {
158 as_state.calculate_state();
159 }
160
161 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
162
163 Metro time2{EBS_BUZZER_TIMEOUT / 2};
164 while (!time2.checkWithoutReset()) {
165 as_state.calculate_state();
166 }
167 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
168
169 Metro time3{EBS_BUZZER_TIMEOUT / 2};
170 while (!time3.checkWithoutReset()) {
171 as_state.calculate_state();
172 }
173 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
174 sd.hardware_data_.asms_on_ = false;
175 as_state.calculate_state();
176 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
177}
178
183void test_ready_to_driving_to_emg() {
184 reset();
185 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
186 to_ready();
187 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
188
189 Metro time{READY_TIMEOUT_MS / 2};
190 while (!time.checkWithoutReset()) {
191 as_state.calculate_state();
192 sd.failure_detection_.inversor_alive_timestamp_.reset();
193 sd.failure_detection_.pc_alive_timestamp_.reset();
194 sd.failure_detection_.steer_alive_timestamp_.reset();
195 sd.failure_detection_.res_signal_loss_timestamp_.reset();
196 }
197
198 uint8_t msg[8] = {RES_GO, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
199 communicator.res_state_callback(msg);
200
201 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
202
203 Metro time2{READY_TIMEOUT_MS / 2};
204 while (!time2.checkWithoutReset()) {
205 as_state.calculate_state();
206 sd.failure_detection_.inversor_alive_timestamp_.reset();
207 sd.failure_detection_.pc_alive_timestamp_.reset();
208 sd.failure_detection_.steer_alive_timestamp_.reset();
209 sd.failure_detection_.res_signal_loss_timestamp_.reset();
210 }
211
212 communicator.res_state_callback(msg);
213 as_state.calculate_state();
214 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
215
216 // brake pressure has a threshold to be updated, otherwise emergency
217 Metro time3{RELEASE_EBS_TIMEOUT_MS / 2};
218 while (!time3.checkWithoutReset()) {
219 sd.failure_detection_.inversor_alive_timestamp_.reset();
220 sd.failure_detection_.pc_alive_timestamp_.reset();
221 sd.failure_detection_.steer_alive_timestamp_.reset();
222 sd.failure_detection_.res_signal_loss_timestamp_.reset();
223 as_state.calculate_state();
224 }
225
226 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_); // still within threshold, okay
227
228 Metro time4{RELEASE_EBS_TIMEOUT_MS + 10};
229 while (!sd.r2d_logics_.releaseEbsTimestamp.checkWithoutReset()) {
230 sd.failure_detection_.inversor_alive_timestamp_.reset();
231 sd.failure_detection_.pc_alive_timestamp_.reset();
232 sd.failure_detection_.steer_alive_timestamp_.reset();
233 sd.failure_detection_.res_signal_loss_timestamp_.reset();
234 as_state.calculate_state();
235 }
236 // threshold over, still with brake pressure, emergency
237 TEST_ASSERT_TRUE(sd.r2d_logics_.releaseEbsTimestamp.checkWithoutReset());
238 as_state.calculate_state();
239 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
240}
241
246void test_ready_to_driving_to_emg2() {
247 reset();
248 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
249 to_ready();
250 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
251
252 Metro time{READY_TIMEOUT_MS};
253 while (!time.checkWithoutReset()) {
254 as_state.calculate_state();
255 sd.failure_detection_.inversor_alive_timestamp_.reset();
256 sd.failure_detection_.pc_alive_timestamp_.reset();
257 sd.failure_detection_.steer_alive_timestamp_.reset();
258 sd.failure_detection_.res_signal_loss_timestamp_.reset();
259 }
260
261 uint8_t msg[8] = {RES_GO, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
262 communicator.res_state_callback(msg);
263 as_state.calculate_state();
264
265 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
266
267 uint8_t hydraulic_msg[] = {HYDRAULIC_LINE, HYDRAULIC_PRESSURE_LOW,
268 0x00}; // loose brake activation
269 communicator.c1_callback(hydraulic_msg);
270 as_state.calculate_state();
271 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
272
273 sd.hardware_data_.bspd_sdc_open_ = true;
274 as_state.calculate_state();
275 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
276}
277
282void test_driving_to_finished_to_off() {
283 reset();
284 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
285 to_ready();
286 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
287 sd.r2d_logics_.r2d = true;
288 as_state.calculate_state();
289 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
290
291 uint8_t pc_msg[] = {MISSION_FINISHED};
292 communicator.pc_callback(pc_msg);
293
294 uint8_t c1_msg[] = {RIGHT_WHEEL_CODE, 0x00, 0x01, 0x00, 0x00}; // value not 0
295 communicator.c1_callback(c1_msg); // right wheel = msg
296 sd.hardware_data_._left_wheel_rpm = 0;
297
298 as_state.calculate_state();
299 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
300
301 uint8_t c1_msg2[] = {RIGHT_WHEEL_CODE, 0x00, 0x00, 0x00, 0x00};
302 communicator.c1_callback(c1_msg2); // right wheel = msg
303
304 as_state.calculate_state();
305 TEST_ASSERT_EQUAL(State::AS_FINISHED, as_state.state_);
306
307 sd.hardware_data_.asms_on_ = false;
308 as_state.calculate_state();
309 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
310}
311
316void test_finished_to_emg() {
317 reset();
318 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
319 to_ready();
320 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
321 sd.r2d_logics_.r2d = true;
322 as_state.calculate_state();
323 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
324 sd.hardware_data_._left_wheel_rpm = 0;
325 sd.hardware_data_._right_wheel_rpm = 0;
326 sd.mission_finished_ = true;
327 as_state.calculate_state();
328 TEST_ASSERT_EQUAL(State::AS_FINISHED, as_state.state_);
329 sd.failure_detection_.emergency_signal_ = true;
330 as_state.calculate_state();
331 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
332}
333
338void test_off_to_manual_wayback() {
339 reset();
340 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
341 sd.hardware_data_.asms_on_ = false;
342 as_state.calculate_state();
343 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
344
345 sd.mission_ = Mission::MANUAL;
346 as_state.calculate_state();
347 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
348
349 sd.hardware_data_.pneumatic_line_pressure_ = false;
350 as_state.calculate_state();
351 TEST_ASSERT_EQUAL(State::AS_MANUAL, as_state.state_);
352
353 sd.hardware_data_.pneumatic_line_pressure_ = true;
354 as_state.calculate_state();
355 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
356}
357
361void test_flow_driving() {
362 reset();
363 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
364 uint8_t hydraulic_msg[] = {HYDRAULIC_LINE, HYDRAULIC_PRESSURE_HIGH, 0x00};
365 communicator.c1_callback(hydraulic_msg);
366 as_state.calculate_state();
367
368 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
369 sd.r2d_logics_.r2d = true;
370
371 as_state.calculate_state();
372 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
373 to_ready(); // will validate asms is on and ts is active
374 as_state.calculate_state();
375 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
376
377 as_state.calculate_state();
378 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_); // r2d reset after transition to ready
379
380 sd.r2d_logics_.r2d = true;
381 as_state.calculate_state();
382 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
383}
384
388void test_flow_ready() {
389 reset();
390 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
391
392 sd.hardware_data_.asms_on_ = true;
393 // sd.digitalData.watchdog_state = true;
394 sd.hardware_data_.bspd_sdc_open_ = false;
395
396 uint8_t bamo_msg[] = {VDC_BUS, 0x00, BAMOCAR_VDC_HIGH};
397 communicator.bamocar_callback(bamo_msg);
398
399 sd.hardware_data_.pneumatic_line_pressure_ = true;
400 uint8_t hydraulic_msg[] = {HYDRAULIC_LINE, HYDRAULIC_PRESSURE_HIGH, 0x00};
401 // uint8_t hydraulic_msg2[] = {HYDRAULIC_LINE, HYDRAULIC_PRESSURE_LOW, 0x00}; // loose brake
402 // activation
403 communicator.c1_callback(hydraulic_msg);
404
405
406
407 Metro time3{INITIAL_CHECKUP_STEP_TIMEOUT};
408 while (!time3.checkWithoutReset()) {
409 communicator.c1_callback(hydraulic_msg);
410 as_state.calculate_state();
411 sd.failure_detection_.inversor_alive_timestamp_.reset();
412 sd.failure_detection_.pc_alive_timestamp_.reset();
413 sd.failure_detection_.steer_alive_timestamp_.reset();
414 sd.failure_detection_.res_signal_loss_timestamp_.reset();
415 }
416
417 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
418}
419
423void test_flow_emergency() {
424 reset();
425 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
426 to_ready();
427 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
428 sd.r2d_logics_.r2d = true;
429 as_state.calculate_state();
430 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
431
432 sd.hardware_data_.bspd_sdc_open_ = true; // ebs before finished checks
433
434 as_state.calculate_state();
435 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
436
437 uint8_t pc_msg[] = {MISSION_FINISHED};
438 communicator.pc_callback(pc_msg);
439 sd.hardware_data_._left_wheel_rpm = 0;
440 uint8_t c1_msg[] = {RIGHT_WHEEL_CODE, 0x00, 0x00, 0x00, 0x00};
441 communicator.c1_callback(c1_msg); // right wheel = msg
442 as_state.calculate_state();
443 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
444}
445
449void test_flow_finished() {
450 reset();
451 TEST_ASSERT_EQUAL(State::AS_OFF, as_state.state_);
452 to_ready();
453 TEST_ASSERT_EQUAL(State::AS_READY, as_state.state_);
454 sd.r2d_logics_.r2d = true;
455 as_state.calculate_state();
456 TEST_ASSERT_EQUAL(State::AS_DRIVING, as_state.state_);
457
458 uint8_t pc_msg[] = {MISSION_FINISHED};
459 communicator.pc_callback(pc_msg);
460 sd.hardware_data_._left_wheel_rpm = 0;
461 uint8_t c1_msg[] = {RIGHT_WHEEL_CODE, 0x00, 0x00, 0x00, 0x00};
462 communicator.c1_callback(c1_msg); // right wheel = msg
463 as_state.calculate_state();
464 TEST_ASSERT_EQUAL(State::AS_FINISHED, as_state.state_);
465
466 sd.hardware_data_.bspd_sdc_open_ = true;
467 as_state.calculate_state();
468 TEST_ASSERT_EQUAL(State::AS_FINISHED, as_state.state_);
469
470 sd.failure_detection_.emergency_signal_ = true;
471 as_state.calculate_state();
472 TEST_ASSERT_EQUAL(State::AS_EMERGENCY, as_state.state_);
473}
474
475void setUp() {}
476
477int main() {
478 UNITY_BEGIN();
479 RUN_TEST(test_off_to_ready_success);
480 RUN_TEST(test_off_to_ready_recheck);
481 RUN_TEST(test_off_to_ready_wayback_impossible);
482 RUN_TEST(test_ready_to_driving_to_emg);
483 RUN_TEST(test_ready_to_driving_to_emg2);
484 RUN_TEST(test_ready_to_emg_to_off);
485 RUN_TEST(test_driving_to_finished_to_off);
486 RUN_TEST(test_finished_to_emg);
487 RUN_TEST(test_off_to_manual_wayback);
488 RUN_TEST(test_flow_driving);
489 RUN_TEST(test_flow_ready);
490 RUN_TEST(test_flow_emergency);
491 RUN_TEST(test_flow_finished);
492 return UNITY_END();
493}
ASState
The ASState class manages and transitions between different states of the vehicle system.
Definition stateLogic.hpp:18
ASState::calculate_state
void calculate_state()
Calculates the state of the vehicle.
Definition stateLogic.hpp:56
ASState::_checkup_manager_
CheckupManager _checkup_manager_
CheckupManager object for handling various checkup operations.
Definition stateLogic.hpp:31
ASState::state_
State state_
Current state of the vehicle system, initialized to OFF.
Definition stateLogic.hpp:32
Communicator
Class that contains definitions of typical messages to send via CAN It serves only as an example of t...
Definition communicator.hpp:41
Communicator::res_state_callback
static void res_state_callback(const uint8_t *buf)
Callback RES default callback.
Definition communicator.hpp:151
Communicator::pc_callback
static void pc_callback(const uint8_t *buf)
Callback for message from AS CU.
Definition communicator.hpp:212
Communicator::bamocar_callback
static void bamocar_callback(const uint8_t *buf)
Callback from inversor, for alive signal and data.
Definition communicator.hpp:182
DigitalSender
Class responsible for controlling digital outputs in the Master Teensy.
Definition digitalSender.hpp:15
Metro
Our own implementation of Metro class.
Definition metro.h:13
Metro::reset
void reset()
Resets the timer to the current time.
Definition metro.h:124
Metro::checkWithoutReset
bool checkWithoutReset() const
Checks if the interval has passed without resetting the timer.
Definition metro.h:115
READY_TIMEOUT_MS
constexpr unsigned long READY_TIMEOUT_MS
Definition hardwareSettings.hpp:11
RELEASE_EBS_TIMEOUT_MS
constexpr unsigned long RELEASE_EBS_TIMEOUT_MS
Definition hardwareSettings.hpp:12
COMPONENT_TIMESTAMP_TIMEOUT
constexpr int COMPONENT_TIMESTAMP_TIMEOUT
Definition hardwareSettings.hpp:3
INITIAL_CHECKUP_STEP_TIMEOUT
constexpr int INITIAL_CHECKUP_STEP_TIMEOUT
Definition hardwareSettings.hpp:10
EBS_BUZZER_TIMEOUT
constexpr int EBS_BUZZER_TIMEOUT
Definition hardwareSettings.hpp:7
HardwareData::_right_wheel_rpm
double _right_wheel_rpm
Definition hardwareData.hpp:17
HardwareData::pneumatic_line_pressure_
bool pneumatic_line_pressure_
Definition hardwareData.hpp:7
HardwareData::_left_wheel_rpm
double _left_wheel_rpm
Definition hardwareData.hpp:18
R2DLogics::releaseEbsTimestamp
Metro releaseEbsTimestamp
Definition systemDiagnostics.hpp:15
SystemData
The whole model of the system: holds all the data necessary.
Definition systemData.hpp:11
SystemData::mission_
Mission mission_
Definition systemData.hpp:16
SystemData::r2d_logics_
R2DLogics r2d_logics_
Definition systemData.hpp:12
SystemData::failure_detection_
FailureDetection failure_detection_
Definition systemData.hpp:13
SystemData::hardware_data_
HardwareData hardware_data_
Definition systemData.hpp:15
SystemData::mission_finished_
bool mission_finished_
Definition systemData.hpp:19
State::AS_DRIVING
@ AS_DRIVING
State::AS_MANUAL
@ AS_MANUAL
State::AS_READY
@ AS_READY
State::AS_FINISHED
@ AS_FINISHED
State::AS_EMERGENCY
@ AS_EMERGENCY
msg
CAN_message_t msg
Definition test_callbacks.cpp:18
test_off_to_ready_wayback_impossible
void test_off_to_ready_wayback_impossible()
Test function to validate AS_READY doesn't revert to AS_Ready.
Definition test_integration.cpp:125
test_driving_to_finished_to_off
void test_driving_to_finished_to_off()
Test function to validate AS_DRIVING to AS_FINISHED transition and AS_FINISHED to AS_OFF after.
Definition test_integration.cpp:282
test_flow_finished
void test_flow_finished()
Test function to validate flow diagram conditions to go AS_FINISHED.
Definition test_integration.cpp:449
communicator
Communicator communicator
Definition test_integration.cpp:13
test_ready_to_emg_to_off
void test_ready_to_emg_to_off()
Test function to validate AS_READY to AS_Emergency and the AS_EMERGENCY to AS_OFF transition.
Definition test_integration.cpp:150
RES_GO
#define RES_GO
Definition test_integration.cpp:10
as_state
ASState as_state
Definition test_integration.cpp:15
test_off_to_ready_success
void test_off_to_ready_success(void)
Test function to validate AS_OFF to AS_Ready transition normal and successful transition.
Definition test_integration.cpp:62
test_finished_to_emg
void test_finished_to_emg()
Test function to validate AS_FINISHED to AS_EMERGENCY transition if RES is activated after mission fi...
Definition test_integration.cpp:316
test_flow_emergency
void test_flow_emergency()
Test function to validate flow diagram conditions to go AS_EMERGENCY.
Definition test_integration.cpp:423
setUp
void setUp()
Definition test_integration.cpp:475
test_ready_to_driving_to_emg2
void test_ready_to_driving_to_emg2()
Test function to validate AS_READY to AS_Driving transition and AS_DRIVING to AS_EMERGENCY if failure...
Definition test_integration.cpp:246
digitalSender
DigitalSender digitalSender
Definition test_integration.cpp:14
HYDRAULIC_PRESSURE_HIGH
#define HYDRAULIC_PRESSURE_HIGH
Definition test_integration.cpp:7
BAMOCAR_VDC_HIGH
#define BAMOCAR_VDC_HIGH
Definition test_integration.cpp:9
to_ready
void to_ready()
Auxiliary function to set state as ready.
Definition test_integration.cpp:28
test_flow_ready
void test_flow_ready()
Test function to validate flow diagram conditions to go AS_READY.
Definition test_integration.cpp:388
HYDRAULIC_PRESSURE_LOW
#define HYDRAULIC_PRESSURE_LOW
Definition test_integration.cpp:8
reset
void reset()
Auxiliary function to reset data values.
Definition test_integration.cpp:20
sd
SystemData sd
Definition test_integration.cpp:12
test_off_to_manual_wayback
void test_off_to_manual_wayback()
Test function to validate AS_OFF to AS_Manual transition and the other way around.
Definition test_integration.cpp:338
test_off_to_ready_recheck
void test_off_to_ready_recheck()
Test function to validate AS_OFF to AS_Ready transition with checks reverting to invalid mid transiti...
Definition test_integration.cpp:80
main
int main()
Definition test_integration.cpp:477
test_flow_driving
void test_flow_driving()
Test function to validate flow diagram conditions to go AS_DRIVING.
Definition test_integration.cpp:361
test_ready_to_driving_to_emg
void test_ready_to_driving_to_emg()
Test function to validate AS_READY to AS_Driving transition and AS_DRIVING to AS_EMERGENCY if brakes ...
Definition test_integration.cpp:183