Formula Student Electronics & Software
The code for the embedded software
Loading...
Searching...
No Matches
test_checkupManager.cpp
Go to the documentation of this file.
1#include "comm/communicatorSettings.hpp"
2#include "logic/checkupManager.hpp"
3#include "model/systemData.hpp"
4#include "unity.h"
5
6void test_shouldStayManualDriving_true() {
7 SystemData systemData;
8 systemData.mission_ = Mission::MANUAL;
9 systemData.hardware_data_.pneumatic_line_pressure_ = false;
10 systemData.hardware_data_.asms_on_ = false;
11
12 CheckupManager checkupManager(&systemData);
13
14 TEST_ASSERT_TRUE(checkupManager.should_stay_manual_driving());
15}
16
17void test_shouldStayManualDriving_false() {
18 SystemData systemData;
19 CheckupManager checkupManager(&systemData);
20
21 systemData.mission_ = Mission::INSPECTION;
22 TEST_ASSERT_FALSE(checkupManager.should_stay_manual_driving());
23
24 systemData.mission_ = Mission::MANUAL;
25 systemData.hardware_data_.pneumatic_line_pressure_ = true;
26 TEST_ASSERT_FALSE(checkupManager.should_stay_manual_driving());
27
28 systemData.hardware_data_.pneumatic_line_pressure_ = false;
29 systemData.hardware_data_.asms_on_ = true;
30 TEST_ASSERT_FALSE(checkupManager.should_stay_manual_driving());
31
32 systemData.hardware_data_.asms_on_ = false;
33 TEST_ASSERT_TRUE(checkupManager.should_stay_manual_driving());
34}
35
36// can only test false since we can't mock the initial sequence :(
37void test_shouldStayOff_whenInitialCheckupFails_false() {
38 SystemData systemData;
39 DigitalSender digitalSender;
40 // default values shouldnt allow to pass test
41 CheckupManager checkupManager(&systemData);
42
43 TEST_ASSERT_TRUE(checkupManager.should_stay_off(&digitalSender));
44}
45
46void test_initialCheckupSequence_states() {
47 SystemData sd;
48 DigitalSender digitalSender;
49 CheckupManager cm(&sd);
50
51 cm.initial_checkup_sequence(&digitalSender);
52 TEST_ASSERT_EQUAL(CheckupManager::CheckupState::WAIT_FOR_ASMS, cm.checkupState);
53
54 sd.hardware_data_.asms_on_ = true;
55 cm.initial_checkup_sequence(&digitalSender);
56 // TEST_ASSERT_EQUAL(CheckupManager::CheckupState::START_TOGGLING_WATCHDOG, cm.checkupState);
57
58 // cm.initialCheckupSequence(&digitalSender);
59 // TEST_ASSERT_EQUAL(CheckupManager::CheckupState::WAIT_FOR_WATCHDOG, cm.checkupState);
60
61 // cm.getInitialCheckupTimestamp().reset();
62 // sd.hardware_data_.watchdog_state = true;
63 // cm.initialCheckupSequence(&digitalSender);
64 // TEST_ASSERT_EQUAL(CheckupManager::CheckupState::STOP_TOGGLING_WATCHDOG, cm.checkupState);
65
66 // cm.initialCheckupSequence(&digitalSender);
67 // TEST_ASSERT_EQUAL(CheckupManager::CheckupState::CHECK_WATCHDOG, cm.checkupState);
68
69 // Metro waitForWatchdogExpiration{1000};
70 // while (!waitForWatchdogExpiration.check()) {
71 // }
72 // sd.hardware_data_.watchdog_state = false;
73 // cm.initialCheckupSequence(&digitalSender);
74 TEST_ASSERT_EQUAL(CheckupManager::CheckupState::CLOSE_SDC, cm.checkupState);
75
76 cm.initial_checkup_sequence(&digitalSender);
77 TEST_ASSERT_EQUAL(CheckupManager::CheckupState::WAIT_FOR_ASATS, cm.checkupState);
78
79 sd.hardware_data_.bspd_sdc_open_ = false;
80 cm.initial_checkup_sequence(&digitalSender);
81 TEST_ASSERT_EQUAL(CheckupManager::CheckupState::WAIT_FOR_TS, cm.checkupState);
82
83 sd.failure_detection_.ts_on_ = true;
84 cm.initial_checkup_sequence(&digitalSender);
85 TEST_ASSERT_EQUAL(CheckupManager::CheckupState::TOGGLE_VALVE, cm.checkupState);
86
87 sd.hardware_data_.pneumatic_line_pressure_ = true;
88 sd.hardware_data_._hydraulic_line_pressure = HYDRAULIC_BRAKE_THRESHOLD;
89 cm.initial_checkup_sequence(&digitalSender);
90 TEST_ASSERT_EQUAL(CheckupManager::CheckupState::CHECK_PRESSURE, cm.checkupState);
91
92 sd.failure_detection_.emergency_signal_ = false;
93 sd.failure_detection_.inversor_alive_timestamp_.reset();
94 sd.failure_detection_.pc_alive_timestamp_.reset();
95 sd.failure_detection_.steer_alive_timestamp_.reset();
96 // todo MISSING INVERSOR ALIVE TIMESTAMP
97
98 TEST_ASSERT_EQUAL(CheckupManager::CheckupError::SUCCESS,
99 cm.initial_checkup_sequence(&digitalSender));
100}
101
102void test_shouldStayReady() {
103 SystemData systemData;
104 systemData.r2d_logics_.r2d = false;
105
106 CheckupManager checkupManager(&systemData);
107
108 TEST_ASSERT_TRUE(checkupManager.shouldStayReady());
109
110 systemData.r2d_logics_.r2d = true;
111 TEST_ASSERT_FALSE(checkupManager.shouldStayReady());
112}
113
114void test_shouldEnterEmergency() {
115 SystemData sd;
116 sd.hardware_data_.bspd_sdc_open_ = false;
117 sd.hardware_data_.pneumatic_line_pressure_ = true;
118 sd.hardware_data_.asms_on_ = true;
119 sd.hardware_data_._hydraulic_line_pressure = HYDRAULIC_BRAKE_THRESHOLD + 1;
120 sd.failure_detection_.inversor_alive_timestamp_.reset();
121 sd.failure_detection_.pc_alive_timestamp_.reset();
122 sd.failure_detection_.steer_alive_timestamp_.reset();
123 sd.failure_detection_.res_signal_loss_timestamp_.reset();
124 sd.failure_detection_.emergency_signal_ = false;
125 sd.failure_detection_.ts_on_ = true;
126
127 CheckupManager checkupManager(&sd);
128
129 TEST_ASSERT_FALSE(checkupManager.shouldEnterEmergency(State::AS_READY));
130 sd.hardware_data_.bspd_sdc_open_ = true;
131 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
132 sd.hardware_data_.bspd_sdc_open_ = false;
133 sd.hardware_data_.pneumatic_line_pressure_ = false;
134 while (!sd.r2d_logics_.releaseEbsTimestamp.checkWithoutReset());
135 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
136 sd.hardware_data_.pneumatic_line_pressure_ = true;
137 sd.hardware_data_.asms_on_ = false;
138 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
139 sd.hardware_data_.asms_on_ = true;
140 sd.failure_detection_.ts_on_ = false;
141 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
142 sd.failure_detection_.ts_on_ = true;
143 sd.failure_detection_.emergency_signal_ = true;
144 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
145 sd.failure_detection_.emergency_signal_ = false;
146 sd.hardware_data_._hydraulic_line_pressure = 1;
147 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
148
149 sd.failure_detection_.inversor_alive_timestamp_.reset();
150 sd.failure_detection_.pc_alive_timestamp_.reset();
151 sd.failure_detection_.steer_alive_timestamp_.reset();
152 sd.failure_detection_.res_signal_loss_timestamp_.reset();
153 TEST_ASSERT_FALSE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
154 sd.hardware_data_.bspd_sdc_open_ = true;
155 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
156 sd.hardware_data_.bspd_sdc_open_ = false;
157 sd.hardware_data_.pneumatic_line_pressure_ = false;
158 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
159 sd.hardware_data_.pneumatic_line_pressure_ = true;
160 sd.hardware_data_.asms_on_ = false;
161 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
162 sd.hardware_data_.asms_on_ = true;
163 sd.failure_detection_.ts_on_ = false;
164 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
165 sd.failure_detection_.ts_on_ = true;
166 sd.failure_detection_.emergency_signal_ = true;
167 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
168 sd.failure_detection_.emergency_signal_ = false;
169 sd.hardware_data_._hydraulic_line_pressure = HYDRAULIC_BRAKE_THRESHOLD + 1;
170
171 // // Metro wait{WATCHDOG_TIMEOUT};
172 // while (!wait.check()) {
173 // }
174 // TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_READY));
175 sd.hardware_data_._hydraulic_line_pressure = HYDRAULIC_BRAKE_THRESHOLD + 1;
176 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
177}
178
179void test_shouldEnterEmergencyAsDrivingEBSValves() {
180 SystemData sd;
181 sd.hardware_data_.bspd_sdc_open_ = false;
182 sd.hardware_data_.pneumatic_line_pressure_ = true;
183 sd.hardware_data_.asms_on_ = true;
184 sd.hardware_data_._hydraulic_line_pressure = 1;
185 sd.failure_detection_.inversor_alive_timestamp_.reset();
186 sd.failure_detection_.pc_alive_timestamp_.reset();
187 sd.failure_detection_.steer_alive_timestamp_.reset();
188 sd.failure_detection_.res_signal_loss_timestamp_.checkWithoutReset();
189 sd.r2d_logics_.releaseEbsTimestamp.reset();
190 sd.failure_detection_.emergency_signal_ = false;
191 sd.failure_detection_.ts_on_ = true;
192
193 CheckupManager checkupManager(&sd);
194
195 TEST_ASSERT_FALSE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
196 sd.hardware_data_._hydraulic_line_pressure = HYDRAULIC_BRAKE_THRESHOLD + 1;
197 TEST_ASSERT_FALSE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
198
199 Metro time3{RELEASE_EBS_TIMEOUT_MS + 10};
200 while (!time3.check()) {
201 sd.failure_detection_.inversor_alive_timestamp_.reset();
202 sd.failure_detection_.pc_alive_timestamp_.reset();
203 sd.failure_detection_.steer_alive_timestamp_.reset();
204 sd.failure_detection_.res_signal_loss_timestamp_.reset();
205 }
206
207 TEST_ASSERT_TRUE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
208 sd.hardware_data_._hydraulic_line_pressure = 1;
209 TEST_ASSERT_FALSE(checkupManager.shouldEnterEmergency(State::AS_DRIVING));
210}
211
212void test_shouldStayDriving() {
213 SystemData systemData;
214 systemData.hardware_data_._left_wheel_rpm = 0;
215 systemData.mission_finished_ = true;
216
217 CheckupManager checkupManager(&systemData);
218
219 TEST_ASSERT_FALSE(checkupManager.shouldStayDriving());
220
221 systemData.hardware_data_._left_wheel_rpm = 1;
222 TEST_ASSERT_TRUE(checkupManager.shouldStayDriving());
223
224 systemData.hardware_data_._left_wheel_rpm = 0;
225 systemData.mission_finished_ = false;
226 TEST_ASSERT_TRUE(checkupManager.shouldStayDriving());
227}
228
229void test_shouldStayMissionFinished() {
230 SystemData systemData;
231 systemData.hardware_data_.asms_on_ = false;
232
233 CheckupManager checkupManager(&systemData);
234
235 TEST_ASSERT_FALSE(checkupManager.shouldStayMissionFinished());
236
237 systemData.hardware_data_.asms_on_ = true;
238 TEST_ASSERT_TRUE(checkupManager.shouldStayMissionFinished());
239}
240
241void test_emergencySequenceComplete() {
242 SystemData systemData;
243 systemData.hardware_data_.asms_on_ = true;
244
245 CheckupManager checkupManager(&systemData);
246
247 TEST_ASSERT_FALSE(checkupManager.emergencySequenceComplete());
248
249 systemData.hardware_data_.asms_on_ = false;
250 Metro waitForEbsSound{8500};
251 while (!waitForEbsSound.check()) {
252 }
253 TEST_ASSERT_TRUE(checkupManager.emergencySequenceComplete());
254}
255
256void test_resTriggered() {
257 SystemData systemData;
258 systemData.failure_detection_.emergency_signal_ = true;
259
260 CheckupManager checkupManager(&systemData);
261
262 TEST_ASSERT_TRUE(checkupManager.resTriggered());
263
264 systemData.failure_detection_.emergency_signal_ = false;
265 TEST_ASSERT_FALSE(checkupManager.resTriggered());
266}
267
268void setUp(void) {}
269
270void tearDown(void) {}
271
272int main() {
273 UNITY_BEGIN();
274 RUN_TEST(test_shouldEnterEmergencyAsDrivingEBSValves);
275 RUN_TEST(test_initialCheckupSequence_states);
276 RUN_TEST(test_shouldStayManualDriving_true);
277 RUN_TEST(test_shouldStayManualDriving_false);
278 RUN_TEST(test_shouldStayOff_whenInitialCheckupFails_false);
279 RUN_TEST(test_shouldStayReady);
280 RUN_TEST(test_shouldEnterEmergency);
281 RUN_TEST(test_shouldStayDriving);
282 RUN_TEST(test_shouldStayMissionFinished);
283 RUN_TEST(test_emergencySequenceComplete);
284 RUN_TEST(test_resTriggered);
285 return UNITY_END();
286}
CheckupManager
The CheckupManager class handles various checkup operations.
Definition checkupManager.hpp:14
CheckupManager::should_stay_manual_driving
bool should_stay_manual_driving() const
Performs a manual driving checkup.
Definition checkupManager.hpp:186
CheckupManager::should_stay_off
bool should_stay_off()
Performs an off checkup.
Definition checkupManager.hpp:196
CheckupManager::initial_checkup_sequence
CheckupError initial_checkup_sequence()
Performs an initial checkup.
Definition checkupManager.hpp:205
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
RELEASE_EBS_TIMEOUT_MS
constexpr unsigned long RELEASE_EBS_TIMEOUT_MS
Definition hardwareSettings.hpp:12
HardwareData::_hydraulic_line_pressure
int _hydraulic_line_pressure
Definition hardwareData.hpp:19
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_READY
@ AS_READY
sd
SystemData sd
Definition test_callbacks.cpp:16
test_shouldStayReady
void test_shouldStayReady()
Definition test_checkupManager.cpp:102
test_shouldStayOff_whenInitialCheckupFails_false
void test_shouldStayOff_whenInitialCheckupFails_false()
Definition test_checkupManager.cpp:37
test_resTriggered
void test_resTriggered()
Definition test_checkupManager.cpp:256
test_shouldEnterEmergencyAsDrivingEBSValves
void test_shouldEnterEmergencyAsDrivingEBSValves()
Definition test_checkupManager.cpp:179
test_shouldEnterEmergency
void test_shouldEnterEmergency()
Definition test_checkupManager.cpp:114
test_shouldStayManualDriving_true
void test_shouldStayManualDriving_true()
Definition test_checkupManager.cpp:6
test_shouldStayMissionFinished
void test_shouldStayMissionFinished()
Definition test_checkupManager.cpp:229
setUp
void setUp(void)
Definition test_checkupManager.cpp:268
test_shouldStayDriving
void test_shouldStayDriving()
Definition test_checkupManager.cpp:212
tearDown
void tearDown(void)
Definition test_checkupManager.cpp:270
test_initialCheckupSequence_states
void test_initialCheckupSequence_states()
Definition test_checkupManager.cpp:46
test_shouldStayManualDriving_false
void test_shouldStayManualDriving_false()
Definition test_checkupManager.cpp:17
test_emergencySequenceComplete
void test_emergencySequenceComplete()
Definition test_checkupManager.cpp:241
main
int main()
Definition test_checkupManager.cpp:272
digitalSender
DigitalSender digitalSender
Definition test_integration.cpp:14