MCU
Loading...
Searching...
No Matches
Functions
pedals_system_test.h File Reference
#include <gtest/gtest.h>
#include <string>
#include "PedalsSystem.h"
#include <array>
#include "MCU_rev15_defs.h"
Include dependency graph for pedals_system_test.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

float get_pedal_conversion_val (float min, float max, float data)
 
PedalsParams gen_positive_and_negative_slope_params ()
 
PedalsParams get_real_accel_pedal_params ()
 
PedalsParams get_real_brake_pedal_params ()
 
PedalsParams gen_positive_slope_only_params ()
 
bool get_result_of_double_brake_test (PedalsSystem &pedals, const AnalogConversion_s &a1, const AnalogConversion_s &a2, const AnalogConversion_s &b1, const AnalogConversion_s &b2)
 
bool get_result_of_single_brake_test (PedalsSystem &pedals, const AnalogConversion_s &a1, const AnalogConversion_s &a2, const AnalogConversion_s &b1)
 
bool reset_pedals_system_implaus_time (PedalsSystem &pedals)
 
 TEST (PedalsSystemTesting, test_accel_and_brake_limits_plausibility)
 
 TEST (PedalsSystemTesting, test_accel_and_brake_percentages_implausibility)
 
 TEST (PedalsSystemTesting, test_accel_and_brake_pressed_at_same_time_and_activation)
 
 TEST (PedalsSystemTesting, test_implausibility_duration)
 
 TEST (PedalsSystemTesting, implausibility_latching_until_accel_released_double_brake)
 
 TEST (PedalsSystemTesting, implausibility_latching_until_accel_released_single_brake)
 
 TEST (PedalsSystemTesting, deadzone_removal_calc_double_brake_ped)
 
 TEST (PedalsSystemTesting, deadzone_removal_calc_single_brake_ped)
 
 TEST (PedalsSystemTesting, brake_value_testing_double)
 
 TEST (PedalsSystemTesting, brake_value_testing_single)
 
 TEST (PedalsSystemTesting, check_accel_never_negative_single)
 
 TEST (PedalsSystemTesting, check_accel_never_negative_double)
 
 TEST (PedalsSystemTesting, check_accel_pressed)
 
 TEST (PedalsSystemTesting, check_accel_oor)
 
 TEST (PedalsSystemTesting, check_accel1_implaus_fix)
 

Function Documentation

◆ gen_positive_and_negative_slope_params()

PedalsParams gen_positive_and_negative_slope_params ( )

Definition at line 21 of file pedals_system_test.h.

22{
23 PedalsParams params;
24 params.min_pedal_1 = 2000;
25 params.max_pedal_1 = 1000;
26 params.min_pedal_2 = 1000;
27 params.max_pedal_2 = 2000;
28 params.min_sensor_pedal_1 = 90;
29 params.min_sensor_pedal_2 = 90;
30 params.max_sensor_pedal_1 = 4000;
31 params.max_sensor_pedal_2 = 4000;
32 params.activation_percentage = 0.25;
33 params.mechanical_activation_percentage = 0.4;
34 params.deadzone_margin = .03; // .05
35 params.implausibility_margin = DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN; // 0.1
36 return params;
37}
DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN
const float DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN
Definition: MCU_rev15_defs.h:80
params
ParameterInterface params
Definition: main_ethernet_test.cpp:9
PedalsParams
system interface struct that contains the data from the pedal system
Definition: PedalsSystem.h:26

◆ gen_positive_slope_only_params()

PedalsParams gen_positive_slope_only_params ( )

Definition at line 75 of file pedals_system_test.h.

76{
77 PedalsParams params;
78 params.min_pedal_1 = 1000;
79 params.max_pedal_1 = 2000;
80 params.min_pedal_2 = 1000;
81 params.max_pedal_2 = 2000;
82 params.min_sensor_pedal_1 = BRAKE1_PEDAL_OOR_MIN;
83 params.max_sensor_pedal_1 = BRAKE1_PEDAL_OOR_MAX;
84 params.min_sensor_pedal_2 = BRAKE2_PEDAL_OOR_MIN;
85 params.max_sensor_pedal_2 = BRAKE1_PEDAL_OOR_MAX;
86 params.activation_percentage = 0.1;
87 params.mechanical_activation_percentage = 0.4;
88 params.deadzone_margin = DEFAULT_PEDAL_DEADZONE; // .05
89 params.implausibility_margin = DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN; // 0.1
90 return params;
91}
BRAKE2_PEDAL_OOR_MIN
const int BRAKE2_PEDAL_OOR_MIN
Definition: MCU_rev15_defs.h:74
BRAKE1_PEDAL_OOR_MIN
const int BRAKE1_PEDAL_OOR_MIN
Definition: MCU_rev15_defs.h:73
DEFAULT_PEDAL_DEADZONE
const float DEFAULT_PEDAL_DEADZONE
Definition: MCU_rev15_defs.h:79
BRAKE1_PEDAL_OOR_MAX
const int BRAKE1_PEDAL_OOR_MAX
Definition: MCU_rev15_defs.h:76

◆ get_pedal_conversion_val()

float get_pedal_conversion_val ( float  min,
float  max,
float  data 
)

Definition at line 16 of file pedals_system_test.h.

17{
18 float scale = 1.0f / (max - min);
19 return ((data - min) * scale);
20}

◆ get_real_accel_pedal_params()

PedalsParams get_real_accel_pedal_params ( )

Definition at line 40 of file pedals_system_test.h.

41{
42 PedalsParams params;
43 params.min_pedal_1 = ACCEL1_PEDAL_MIN;
44 params.max_pedal_1 = ACCEL1_PEDAL_MAX;
45 params.min_pedal_2 = ACCEL2_PEDAL_MIN;
46 params.max_pedal_2 = ACCEL2_PEDAL_MAX;
47 params.min_sensor_pedal_1 = ACCEL1_PEDAL_OOR_MIN;
48 params.max_sensor_pedal_1 = ACCEL1_PEDAL_OOR_MAX;
49 params.min_sensor_pedal_2 = ACCEL2_PEDAL_OOR_MIN;
50 params.max_sensor_pedal_2 = ACCEL1_PEDAL_OOR_MAX;
51 params.activation_percentage = APPS_ACTIVATION_PERCENTAGE;
52 params.mechanical_activation_percentage = APPS_ACTIVATION_PERCENTAGE;
53 params.deadzone_margin = DEFAULT_PEDAL_DEADZONE; // .05
54 params.implausibility_margin = DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN; // 0.1
55 return params;
56}
ACCEL1_PEDAL_MIN
const int ACCEL1_PEDAL_MIN
Definition: MCU_rev15_defs.h:58
ACCEL1_PEDAL_MAX
const int ACCEL1_PEDAL_MAX
Definition: MCU_rev15_defs.h:55
ACCEL2_PEDAL_OOR_MIN
const int ACCEL2_PEDAL_OOR_MIN
Definition: MCU_rev15_defs.h:68
ACCEL2_PEDAL_MIN
const int ACCEL2_PEDAL_MIN
Definition: MCU_rev15_defs.h:59
ACCEL2_PEDAL_MAX
const int ACCEL2_PEDAL_MAX
Definition: MCU_rev15_defs.h:56
ACCEL1_PEDAL_OOR_MAX
const int ACCEL1_PEDAL_OOR_MAX
Definition: MCU_rev15_defs.h:70
APPS_ACTIVATION_PERCENTAGE
const float APPS_ACTIVATION_PERCENTAGE
Definition: MCU_rev15_defs.h:82
ACCEL1_PEDAL_OOR_MIN
const int ACCEL1_PEDAL_OOR_MIN
Definition: MCU_rev15_defs.h:67

◆ get_real_brake_pedal_params()

PedalsParams get_real_brake_pedal_params ( )

Definition at line 57 of file pedals_system_test.h.

58{
59 PedalsParams params;
60 params.min_pedal_1 = BRAKE1_PEDAL_MIN;
61 params.max_pedal_1 = BRAKE1_PEDAL_MAX;
62 params.min_pedal_2 = BRAKE2_PEDAL_MIN;
63 params.max_pedal_2 = BRAKE2_PEDAL_MAX;
64 params.min_sensor_pedal_1 = BRAKE1_PEDAL_OOR_MIN;
65 params.max_sensor_pedal_1 = BRAKE1_PEDAL_OOR_MAX;
66 params.min_sensor_pedal_2 = BRAKE2_PEDAL_OOR_MIN;
67 params.max_sensor_pedal_2 = BRAKE1_PEDAL_OOR_MAX;
68 params.activation_percentage = APPS_ACTIVATION_PERCENTAGE;
69 params.mechanical_activation_percentage = BRAKE_MECH_THRESH;
70 params.deadzone_margin = DEFAULT_PEDAL_DEADZONE; // .05
71 params.implausibility_margin = DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN; // 0.1
72 return params;
73}
BRAKE1_PEDAL_MAX
const int BRAKE1_PEDAL_MAX
Definition: MCU_rev15_defs.h:61
BRAKE2_PEDAL_MIN
const int BRAKE2_PEDAL_MIN
Definition: MCU_rev15_defs.h:65
BRAKE1_PEDAL_MIN
const int BRAKE1_PEDAL_MIN
Definition: MCU_rev15_defs.h:64
BRAKE_MECH_THRESH
const float BRAKE_MECH_THRESH
Definition: MCU_rev15_defs.h:84
BRAKE2_PEDAL_MAX
const int BRAKE2_PEDAL_MAX
Definition: MCU_rev15_defs.h:62

◆ get_result_of_double_brake_test()

bool get_result_of_double_brake_test ( PedalsSystem &  pedals,
const AnalogConversion_s &  a1,
const AnalogConversion_s &  a2,
const AnalogConversion_s &  b1,
const AnalogConversion_s &  b2 
)

Definition at line 93 of file pedals_system_test.h.

94{
95 auto data = pedals.evaluate_pedals(a1, a2, b1, b2, 1000);
96 data = pedals.evaluate_pedals(a1, a2, b1, b2, 1110);
97 return data.implausibilityExceededMaxDuration;
98}
PedalsSystem::evaluate_pedals
PedalsSystemData_s evaluate_pedals(const AnalogConversion_s &accel1, const AnalogConversion_s &accel2, const AnalogConversion_s &brake1, const AnalogConversion_s &brake2, unsigned long curr_time)
Definition: PedalsSystem.cpp:64
a2
MCP_ADC< 4 > a2
Definition: main.cpp:177
a1
MCP_ADC< 8 > a1
Definition: main.cpp:176
PedalsSystemData_s::implausibilityExceededMaxDuration
bool implausibilityExceededMaxDuration
Definition: SharedDataTypes.h:44

◆ get_result_of_single_brake_test()

bool get_result_of_single_brake_test ( PedalsSystem &  pedals,
const AnalogConversion_s &  a1,
const AnalogConversion_s &  a2,
const AnalogConversion_s &  b1 
)

Definition at line 100 of file pedals_system_test.h.

101{
102 auto data = pedals.evaluate_pedals(a1, a2, b1, 1000);
103 data = pedals.evaluate_pedals(a1, a2, b1, 1110);
104 return data.implausibilityExceededMaxDuration;
105}

◆ reset_pedals_system_implaus_time()

bool reset_pedals_system_implaus_time ( PedalsSystem &  pedals)

Definition at line 108 of file pedals_system_test.h.

109{
110 AnalogConversion_s test_accel_good_val = {1010, 0.01, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
111 AnalogConversion_s test_brake_good_val = {1010, 0.01, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
112 auto data = pedals.evaluate_pedals(test_accel_good_val, test_accel_good_val, test_brake_good_val, 1000);
113 data = pedals.evaluate_pedals(test_accel_good_val, test_accel_good_val, test_brake_good_val, 1110);
114 return (!data.implausibilityExceededMaxDuration);
115}

◆ TEST() [1/15]

TEST ( PedalsSystemTesting  ,
brake_value_testing_double   
)

Definition at line 426 of file pedals_system_test.h.

427{
428 AnalogConversion_s test_pedal_good_val_accel = {1050, 0.05, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
429 AnalogConversion_s test_pedal_good_val_brake = {1200, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
430 auto params = gen_positive_slope_only_params();
431 // taking out deadzone margin to ensure that brake vals are good
432 params.deadzone_margin = 0;
433 PedalsSystem pedals(params, params);
434 auto data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
435 EXPECT_NEAR(data.brakePercent, 0.2, .02);
436 EXPECT_NEAR(data.regenPercent, 0.5, .02);
437
438 EXPECT_TRUE(data.brakePressed);
439 EXPECT_FALSE(data.mechBrakeActive);
440
441 test_pedal_good_val_brake.raw = 1400;
442 test_pedal_good_val_brake.conversion = .4;
443 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1500);
444 EXPECT_NEAR(data.brakePercent, 0.4, .03);
445 EXPECT_TRUE(data.brakePressed);
446 EXPECT_TRUE(data.mechBrakeActive);
447 EXPECT_NEAR(data.regenPercent, 1, .03);
448
449
450}
gen_positive_slope_only_params
PedalsParams gen_positive_slope_only_params()
Definition: pedals_system_test.h:75

◆ TEST() [2/15]

TEST ( PedalsSystemTesting  ,
brake_value_testing_single   
)

Definition at line 452 of file pedals_system_test.h.

453{
454 AnalogConversion_s test_pedal_good_val_accel = {1050, 0.05, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
455 AnalogConversion_s test_pedal_good_val_brake = {1200, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
456 auto params = gen_positive_slope_only_params();
457 // taking out deadzone margin to ensure that brake vals are good
458 params.deadzone_margin = 0;
459 PedalsSystem pedals(params, params);
460 auto data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, 1300);
461 EXPECT_NEAR(data.brakePercent, 0.2, .02);
462 EXPECT_NEAR(data.regenPercent, 0.5, .02);
463
464 EXPECT_TRUE(data.brakePressed);
465 EXPECT_FALSE(data.mechBrakeActive);
466
467 test_pedal_good_val_brake.raw = 1400;
468 test_pedal_good_val_brake.conversion = .4;
469 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, 1500);
470 EXPECT_NEAR(data.brakePercent, 0.4, .03);
471 EXPECT_TRUE(data.brakePressed);
472 EXPECT_TRUE(data.mechBrakeActive);
473 EXPECT_NEAR(data.regenPercent, 1, .03);
474}

◆ TEST() [3/15]

TEST ( PedalsSystemTesting  ,
check_accel1_implaus_fix   
)

Definition at line 538 of file pedals_system_test.h.

539{
540
541 AnalogConversion_s test_pedal_good_val_accel = {2152, 0.05, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
542 AnalogConversion_s test_pedal_implaus_1 = {1250, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
543 AnalogConversion_s test_pedal_implaus_2 = {600, 0.5, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
544 AnalogConversion_s test_pedal_good_val_brake = {900, 0.02, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
545
546 auto params = gen_positive_slope_only_params();
547 PedalsSystem pedals(params, params);
548 PedalsSystem pedals_single(params, params);
549 auto data_double_implause_1 = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_implaus_1, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
550 EXPECT_NEAR(data_double_implause_1.accelPercent, 0, .001);
551 auto data_single_implause_1 = pedals_single.evaluate_pedals(test_pedal_good_val_accel, test_pedal_implaus_1, test_pedal_good_val_brake, 1300);
552 EXPECT_NEAR(data_single_implause_1.accelPercent, 0, .001);
553 auto data_double_implause_2 = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_implaus_2, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
554 EXPECT_NEAR(data_double_implause_2.accelPercent, 0, .001);
555 auto data_single_implause_2 = pedals_single.evaluate_pedals(test_pedal_good_val_accel, test_pedal_implaus_2, test_pedal_good_val_brake, 1300);
556 EXPECT_NEAR(data_single_implause_2.accelPercent, 0, .001);
557
558}

◆ TEST() [4/15]

TEST ( PedalsSystemTesting  ,
check_accel_never_negative_double   
)

Definition at line 490 of file pedals_system_test.h.

491{
492 AnalogConversion_s test_pedal_good_val_accel = {930, -0.05, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
493 AnalogConversion_s test_pedal_good_val_brake = {1200, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
494 auto params = gen_positive_slope_only_params();
495 // taking out deadzone margin to ensure that brake vals are good
496 params.deadzone_margin = 0;
497 PedalsSystem pedals(params, params);
498 auto data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
499 EXPECT_FALSE(data.accelImplausible);
500 EXPECT_EQ(data.accelPercent, 0);
501
502}

◆ TEST() [5/15]

TEST ( PedalsSystemTesting  ,
check_accel_never_negative_single   
)

Definition at line 476 of file pedals_system_test.h.

477{
478 AnalogConversion_s test_pedal_good_val_accel = {930, -0.05, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
479 AnalogConversion_s test_pedal_good_val_brake = {1200, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
480 auto params = gen_positive_slope_only_params();
481 // taking out deadzone margin to ensure that brake vals are good
482 params.deadzone_margin = 0;
483 PedalsSystem pedals(params, params);
484 auto data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, 1300);
485 EXPECT_FALSE(data.accelImplausible);
486 EXPECT_EQ(data.accelPercent, 0);
487
488}

◆ TEST() [6/15]

TEST ( PedalsSystemTesting  ,
check_accel_oor   
)

Definition at line 518 of file pedals_system_test.h.

519{
520 AnalogConversion_s test_pedal_oor_hi_val_accel = {40, 0.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
521 AnalogConversion_s test_pedal_oor_lo_val_accel = {4095, 1.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
522 AnalogConversion_s test_pedal_good_val_accel = {1200, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
523 AnalogConversion_s test_pedal_good_val_brake = {1001, 0.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
524
525 auto params = gen_positive_slope_only_params();
526 PedalsSystem pedals(params, params);
527 PedalsSystem pedals_single(params, params);
528 auto data_double_oor_hi = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_oor_hi_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
529 EXPECT_NEAR(data_double_oor_hi.accelPercent, 0, .001);
530 auto data_single_oor_hi = pedals_single.evaluate_pedals(test_pedal_good_val_accel, test_pedal_oor_hi_val_accel, test_pedal_good_val_brake, 1300);
531 EXPECT_NEAR(data_single_oor_hi.accelPercent, 0, .001);
532 auto data_double_oor_lo = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_oor_lo_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
533 EXPECT_NEAR(data_double_oor_lo.accelPercent, 0, .001);
534 auto data_single_oor_lo = pedals_single.evaluate_pedals(test_pedal_good_val_accel, test_pedal_oor_lo_val_accel, test_pedal_good_val_brake, 1300);
535 EXPECT_NEAR(data_single_oor_lo.accelPercent, 0, .001);
536
537}

◆ TEST() [7/15]

TEST ( PedalsSystemTesting  ,
check_accel_pressed   
)

Definition at line 504 of file pedals_system_test.h.

505{
506 AnalogConversion_s test_pedal_good_val_accel = {1200, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
507 AnalogConversion_s test_pedal_good_val_brake = {1001, 0.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
508
509 auto params = gen_positive_slope_only_params();
510 PedalsSystem pedals(params, params);
511 PedalsSystem pedals_single(params, params);
512 auto data_double = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
513 EXPECT_TRUE(data_double.accelPressed);
514 auto data_single = pedals_single.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, 1300);
515 EXPECT_TRUE(data_single.accelPressed);
516}

◆ TEST() [8/15]

TEST ( PedalsSystemTesting  ,
deadzone_removal_calc_double_brake_ped   
)

Definition at line 363 of file pedals_system_test.h.

364{
365 // accel value testing (0, 100 percent, 50 percent)
366 AnalogConversion_s test_pedal_good_val = {1010, 0.03, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
367 PedalsSystem pedals(gen_positive_slope_only_params(), gen_positive_slope_only_params());
368 auto data = pedals.evaluate_pedals(test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, 1000);
369 EXPECT_NEAR(data.accelPercent, 0, .001);
370 test_pedal_good_val.raw = 200;
371 test_pedal_good_val.conversion = 1.03;
372 data = pedals.evaluate_pedals(test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, 1100);
373 EXPECT_NEAR(data.accelPercent, 1, .001);
374 test_pedal_good_val.raw = 1500;
375 test_pedal_good_val.conversion = 0.5;
376 data = pedals.evaluate_pedals(test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, 1200);
377 EXPECT_NEAR(data.accelPercent, 0.5, .001);
378
379 // brake value testing (0, 100 percent, 50 percent)
380 AnalogConversion_s test_pedal_good_val_accel = {1050, 0.03, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
381 AnalogConversion_s test_pedal_good_val_brake = {1050, 0.03, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
382 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1300);
383 EXPECT_NEAR(data.brakePercent, 0, .001);
384 test_pedal_good_val_brake.raw = 2059;
385 test_pedal_good_val_brake.conversion = 1.05;
386 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1400);
387 EXPECT_NEAR(data.brakePercent, 1, .001);
388 test_pedal_good_val_brake.raw = 1500;
389 test_pedal_good_val_brake.conversion = 0.5;
390 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, test_pedal_good_val_brake, 1500);
391 EXPECT_NEAR(data.brakePercent, 0.5, .001);
392}

◆ TEST() [9/15]

TEST ( PedalsSystemTesting  ,
deadzone_removal_calc_single_brake_ped   
)

Definition at line 394 of file pedals_system_test.h.

395{
396 // accel value testing (0, 100 percent, 50 percent)
397 AnalogConversion_s test_pedal_good_val = {1010, 0.03, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
398 PedalsSystem pedals(gen_positive_slope_only_params(), gen_positive_slope_only_params());
399 auto data = pedals.evaluate_pedals(test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, 1000);
400 EXPECT_NEAR(data.accelPercent, 0, .001);
401 test_pedal_good_val.raw = 2009;
402 test_pedal_good_val.conversion = 1.03;
403 data = pedals.evaluate_pedals(test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, 1100);
404 EXPECT_NEAR(data.accelPercent, 1, .001);
405 test_pedal_good_val.raw = 1500;
406 test_pedal_good_val.conversion = 0.5;
407 data = pedals.evaluate_pedals(test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, 1200);
408 EXPECT_NEAR(data.accelPercent, 0.5, .001);
409
410 // brake value testing (0, 100 percent, 50 percent)
411 AnalogConversion_s test_pedal_good_val_accel = {1010, 0.03, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
412 AnalogConversion_s test_pedal_good_val_brake = {1010, 0.03, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
413 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, 1300);
414 EXPECT_NEAR(data.brakePercent, 0, .01);
415 test_pedal_good_val_brake.raw = 2059;
416 test_pedal_good_val_brake.conversion = 1.05;
417 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, 1400);
418 EXPECT_NEAR(data.brakePercent, 1, .001);
419 test_pedal_good_val_brake.raw = 1500;
420 test_pedal_good_val_brake.conversion = 0.5;
421 data = pedals.evaluate_pedals(test_pedal_good_val_accel, test_pedal_good_val_accel, test_pedal_good_val_brake, 1500);
422 EXPECT_NEAR(data.brakePercent, 0.5, .001);
423}

◆ TEST() [10/15]

TEST ( PedalsSystemTesting  ,
implausibility_latching_until_accel_released_double_brake   
)

Definition at line 303 of file pedals_system_test.h.

304{
305 AnalogConversion_s test_accel1_val = {2583, 0.37, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
306 AnalogConversion_s test_accel2_val = {1068, 0.37, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
307 AnalogConversion_s test_brake1_val = {((BRAKE1_PEDAL_MAX - BRAKE1_PEDAL_MIN) /2), get_pedal_conversion_val(BRAKE1_PEDAL_MIN, BRAKE1_PEDAL_MAX, ((BRAKE1_PEDAL_MAX- BRAKE1_PEDAL_MIN) /2)), AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
308 AnalogConversion_s test_brake2_val = {((BRAKE1_PEDAL_MAX - BRAKE1_PEDAL_MIN) /2), get_pedal_conversion_val(BRAKE2_PEDAL_MIN, BRAKE2_PEDAL_MAX, ((BRAKE2_PEDAL_MAX- BRAKE2_PEDAL_MIN) /2)), AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
309
310 PedalsSystem pedals(get_real_accel_pedal_params(), get_real_brake_pedal_params());
311
312 // should stay im
313 EXPECT_TRUE(get_result_of_double_brake_test(pedals, test_accel1_val, test_accel2_val, test_brake1_val, test_brake2_val));
314
315 test_brake1_val.raw = BRAKE1_PEDAL_MIN;
316 test_brake1_val.conversion = 0.0;
317 test_brake2_val.raw = BRAKE2_PEDAL_MIN;
318 test_brake2_val.conversion = 0.0;
319 auto data = pedals.evaluate_pedals(test_accel1_val, test_accel2_val, test_brake1_val, test_brake2_val, 1600);
320 // this should still be implause since accel is still pressed
321 EXPECT_TRUE(data.implausibilityExceededMaxDuration);
322
323 // reset accel to zero and try again this time it should pass
324 test_accel1_val.raw = ACCEL1_PEDAL_MIN;
325 test_accel2_val.raw = ACCEL2_PEDAL_MIN;
326 test_accel1_val.conversion = 0.0;
327 test_accel2_val.conversion = 0.0;
328 data = pedals.evaluate_pedals(test_accel1_val, test_accel2_val, test_brake1_val, test_brake2_val, 1650);
329
330 std::cout << data.accelImplausible << " " << data.brakeImplausible << " "<<std::endl;
331 EXPECT_FALSE(data.implausibilityExceededMaxDuration);
332}
get_real_accel_pedal_params
PedalsParams get_real_accel_pedal_params()
Definition: pedals_system_test.h:40
get_real_brake_pedal_params
PedalsParams get_real_brake_pedal_params()
Definition: pedals_system_test.h:57
get_result_of_double_brake_test
bool get_result_of_double_brake_test(PedalsSystem &pedals, const AnalogConversion_s &a1, const AnalogConversion_s &a2, const AnalogConversion_s &b1, const AnalogConversion_s &b2)
Definition: pedals_system_test.h:93
get_pedal_conversion_val
float get_pedal_conversion_val(float min, float max, float data)
Definition: pedals_system_test.h:16

◆ TEST() [11/15]

TEST ( PedalsSystemTesting  ,
implausibility_latching_until_accel_released_single_brake   
)

Definition at line 334 of file pedals_system_test.h.

335{
337 // repeat above with single pedal brake test:
339 AnalogConversion_s test_accel1_val = {2583, 0.37, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
340 AnalogConversion_s test_accel2_val = {1068, 0.37, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
341 AnalogConversion_s test_brake_val = {((BRAKE1_PEDAL_MAX - BRAKE1_PEDAL_MIN) /2), get_pedal_conversion_val(BRAKE1_PEDAL_MIN, BRAKE1_PEDAL_MAX, ((BRAKE1_PEDAL_MAX - BRAKE1_PEDAL_MIN) /2)), AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
342
343 PedalsSystem pedals2(get_real_accel_pedal_params(), get_real_brake_pedal_params());
344
345 // first we fail
346 EXPECT_TRUE(get_result_of_single_brake_test(pedals2, test_accel1_val, test_accel2_val, test_brake_val));
347
348 test_brake_val.raw = BRAKE1_PEDAL_MIN;
349 test_brake_val.conversion = 0.0;
350 auto data2 = pedals2.evaluate_pedals(test_accel1_val, test_accel2_val, test_brake_val, 1600);
351 // this should still be implause since accel is still pressed
352 EXPECT_TRUE(data2.implausibilityExceededMaxDuration);
353
354 // now we reset throttle back to 0
355 test_accel1_val.raw = ACCEL1_PEDAL_MIN + 10;
356 test_accel2_val.raw = ACCEL2_PEDAL_MIN + 30;
357 test_accel1_val.conversion = 0.01;
358 test_accel2_val.conversion = 0.05;
359 data2 = pedals2.evaluate_pedals(test_accel1_val, test_accel2_val, test_brake_val, 1710);
360 EXPECT_FALSE(data2.implausibilityExceededMaxDuration);
361}
get_result_of_single_brake_test
bool get_result_of_single_brake_test(PedalsSystem &pedals, const AnalogConversion_s &a1, const AnalogConversion_s &a2, const AnalogConversion_s &b1)
Definition: pedals_system_test.h:100

◆ TEST() [12/15]

TEST ( PedalsSystemTesting  ,
test_accel_and_brake_limits_plausibility   
)

Definition at line 118 of file pedals_system_test.h.

119{
120 auto params = gen_positive_and_negative_slope_params();
121 PedalsSystem pedals(params, params);
122
123 AnalogConversion_s test_pedal_bad_val_min = {0, 0.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
124 AnalogConversion_s test_pedal_bad_val_max = {4000, 2.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
125 AnalogConversion_s test_pedal_good_val = {1200, 0.2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
126
127 std::vector<std::tuple<AnalogConversion_s, AnalogConversion_s>> pedal_pairs;
128
129 // check the possibilities of all min/max pairs for accel and good brake
130 pedal_pairs.push_back({test_pedal_bad_val_min, test_pedal_bad_val_min});
131 pedal_pairs.push_back({test_pedal_bad_val_min, test_pedal_bad_val_max});
132 pedal_pairs.push_back({test_pedal_bad_val_max, test_pedal_bad_val_min});
133 pedal_pairs.push_back({test_pedal_bad_val_max, test_pedal_bad_val_max});
134
135 // T.4.2.7 , T.4.2.9 and T.4.2.10 (accel out of ranges min/max) testing
136 for (auto pair : pedal_pairs)
137 {
138 auto p1 = std::get<0>(pair);
139 auto p2 = std::get<1>(pair);
140 bool t_4_2_7 = get_result_of_double_brake_test(pedals, p1, p2, test_pedal_good_val, test_pedal_good_val);
141 EXPECT_TRUE(t_4_2_7);
142 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
143
144 t_4_2_7 = get_result_of_single_brake_test(pedals, p1, p2, test_pedal_good_val);
145 EXPECT_TRUE(t_4_2_7);
146 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
147 }
148
149 // ensure that all good is still good for d.p. brake
150 bool t_4_2_7 = get_result_of_double_brake_test(pedals, test_pedal_good_val, test_pedal_good_val, test_pedal_good_val, test_pedal_good_val);
151 EXPECT_FALSE(t_4_2_7);
152 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
153 // ensure that all good is still good for s.p. brake
154 t_4_2_7 = get_result_of_single_brake_test(pedals, test_pedal_good_val, test_pedal_good_val, test_pedal_good_val);
155 EXPECT_FALSE(t_4_2_7);
156 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
157
158 // T.4.3.4 brake testing
159 for (auto pair : pedal_pairs)
160 {
161 auto p1 = std::get<0>(pair);
162 auto p2 = std::get<1>(pair);
163 bool t_4_3_4 = get_result_of_double_brake_test(pedals, test_pedal_good_val, test_pedal_good_val, p1, p2);
164 EXPECT_TRUE(t_4_3_4);
165 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
166
167 t_4_3_4 = get_result_of_single_brake_test(pedals, test_pedal_good_val, test_pedal_good_val, p1);
168 EXPECT_TRUE(t_4_3_4);
169 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
170 }
171}
reset_pedals_system_implaus_time
bool reset_pedals_system_implaus_time(PedalsSystem &pedals)
Definition: pedals_system_test.h:108
gen_positive_and_negative_slope_params
PedalsParams gen_positive_and_negative_slope_params()
Definition: pedals_system_test.h:21

◆ TEST() [13/15]

TEST ( PedalsSystemTesting  ,
test_accel_and_brake_percentages_implausibility   
)

Definition at line 174 of file pedals_system_test.h.

175{
176 // accel percentage outside of range
177 AnalogConversion_s test_pedal_pos_slope_val_not_pressed = {1000, 0.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
178 AnalogConversion_s test_pedal_neg_slope_val_not_pressed = {2000, 0.0, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
179 AnalogConversion_s test_pedal_val_half_pressed = {1500, 0.4, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
180
181 // the pos / neg slop gens pedal sens 1 with neg, and sensor 2 with pos. slope
182 auto accel_params = gen_positive_and_negative_slope_params();
183 auto brake_params = gen_positive_slope_only_params();
184 PedalsSystem pedals(accel_params, brake_params);
185 // bool is true if it is supposed to error, false otherwise
186 std::vector<std::tuple<AnalogConversion_s, AnalogConversion_s, bool>> pedal_pairs_w_expected_val;
187
188 // check the possibilities of all half pressed and not pressed with aligned slopes for sensor values
189 pedal_pairs_w_expected_val.push_back({test_pedal_neg_slope_val_not_pressed, test_pedal_val_half_pressed, true});
190 pedal_pairs_w_expected_val.push_back({test_pedal_val_half_pressed, test_pedal_pos_slope_val_not_pressed, true});
191 pedal_pairs_w_expected_val.push_back({test_pedal_neg_slope_val_not_pressed, test_pedal_pos_slope_val_not_pressed, false});
192 pedal_pairs_w_expected_val.push_back({test_pedal_val_half_pressed, test_pedal_val_half_pressed, false});
193
194 for (auto set : pedal_pairs_w_expected_val)
195 {
196 auto p1 = std::get<0>(set);
197 auto p2 = std::get<1>(set);
198 // test accel
199 bool res = get_result_of_double_brake_test(pedals, p1, p2, test_pedal_pos_slope_val_not_pressed, test_pedal_pos_slope_val_not_pressed);
200 EXPECT_EQ(res, std::get<2>(set));
201 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
202 // TODO test double brake res (brakes not within req percentage) (not required by rules, still good to have)
203
204 // testing single brake accel mode
205 res = get_result_of_single_brake_test(pedals, p1, p2, test_pedal_pos_slope_val_not_pressed);
206 EXPECT_EQ(res, std::get<2>(set));
207 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
208 }
209}
accel_params
const PedalsParams accel_params
Definition: main.cpp:101
brake_params
const PedalsParams brake_params
Definition: main.cpp:145

◆ TEST() [14/15]

TEST ( PedalsSystemTesting  ,
test_accel_and_brake_pressed_at_same_time_and_activation   
)

Definition at line 212 of file pedals_system_test.h.

213{
214 // test with example data
215 AnalogConversion_s test_pedal_val_half_pressed = {1500, 0.5, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
216
217 // the pos / neg slop gens pedal sens 1 with neg, and sensor 2 with pos. slope
218 auto accel_params = gen_positive_and_negative_slope_params();
219 auto brake_params = gen_positive_slope_only_params();
220 PedalsSystem pedals(accel_params, brake_params);
221 //
222 EXPECT_TRUE(get_result_of_double_brake_test(pedals, test_pedal_val_half_pressed, test_pedal_val_half_pressed, test_pedal_val_half_pressed, test_pedal_val_half_pressed));
223 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
224 EXPECT_TRUE(get_result_of_single_brake_test(pedals, test_pedal_val_half_pressed, test_pedal_val_half_pressed, test_pedal_val_half_pressed));
225 EXPECT_TRUE(reset_pedals_system_implaus_time(pedals));
226
227 // test with real data (accel = ~37%) accel pressed
228 int accel1 = 2583;
229 int accel2 = 1068;
230 int brake = 1510;
231 pedals.setParams(
232 {
233 .min_pedal_1 = ACCEL1_PEDAL_MIN,
234 .min_pedal_2 = ACCEL2_PEDAL_MIN,
235 .max_pedal_1 = ACCEL1_PEDAL_MAX,
236 .max_pedal_2 = ACCEL2_PEDAL_MAX,
237 .min_sensor_pedal_1 = ACCEL1_PEDAL_OOR_MIN,
238 .min_sensor_pedal_2 = ACCEL2_PEDAL_OOR_MIN,
239 .max_sensor_pedal_1 = ACCEL1_PEDAL_OOR_MAX,
240 .max_sensor_pedal_2 = ACCEL2_PEDAL_OOR_MAX,
241 .activation_percentage = APPS_ACTIVATION_PERCENTAGE,
242 .deadzone_margin = DEFAULT_PEDAL_DEADZONE,
243 .implausibility_margin = DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN,
244 .mechanical_activation_percentage = APPS_ACTIVATION_PERCENTAGE,
245 },
246 {
247 .min_pedal_1 = BRAKE1_PEDAL_MIN,
248 .min_pedal_2 = BRAKE2_PEDAL_MIN,
249 .max_pedal_1 = BRAKE1_PEDAL_MAX,
250 .max_pedal_2 = BRAKE2_PEDAL_MAX,
251 .min_sensor_pedal_1 = BRAKE1_PEDAL_OOR_MIN,
252 .min_sensor_pedal_2 = BRAKE2_PEDAL_OOR_MIN,
253 .max_sensor_pedal_1 = BRAKE1_PEDAL_OOR_MAX,
254 .max_sensor_pedal_2 = BRAKE2_PEDAL_OOR_MAX,
255 .activation_percentage = BRAKE_ACTIVATION_PERCENTAGE,
256 .deadzone_margin = DEFAULT_PEDAL_DEADZONE,
257 .implausibility_margin = DEFAULT_PEDAL_IMPLAUSIBILITY_MARGIN,
258 .mechanical_activation_percentage = BRAKE_MECH_THRESH,
259 }
260 );
261 float conv1 = get_pedal_conversion_val(ACCEL1_PEDAL_MIN, ACCEL1_PEDAL_MAX, accel1);
262 float conv2 = get_pedal_conversion_val(ACCEL2_PEDAL_MIN, ACCEL2_PEDAL_MAX, accel2);
263 float convb = get_pedal_conversion_val(BRAKE1_PEDAL_MIN, BRAKE1_PEDAL_MAX, brake);
264
265 std::cout << conv1 << " " << conv2 << " " << convb << std::endl;
266 AnalogConversion_s accel1_data = {accel1, conv1, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
267 AnalogConversion_s accel2_data = {accel1, conv2, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
268 AnalogConversion_s brake_data = {brake, convb, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
269 EXPECT_TRUE(get_result_of_single_brake_test(pedals, test_pedal_val_half_pressed, test_pedal_val_half_pressed, test_pedal_val_half_pressed));
270}
BRAKE_ACTIVATION_PERCENTAGE
const float BRAKE_ACTIVATION_PERCENTAGE
Definition: MCU_rev15_defs.h:83
ACCEL2_PEDAL_OOR_MAX
const int ACCEL2_PEDAL_OOR_MAX
Definition: MCU_rev15_defs.h:71
BRAKE2_PEDAL_OOR_MAX
const int BRAKE2_PEDAL_OOR_MAX
Definition: MCU_rev15_defs.h:77

◆ TEST() [15/15]

TEST ( PedalsSystemTesting  ,
test_implausibility_duration   
)

Definition at line 273 of file pedals_system_test.h.

274{
275 AnalogConversion_s test_accel1_val = {2583, 0.37, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
276 AnalogConversion_s test_accel2_val = {1068, 1.00, AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
277 AnalogConversion_s test_brake_val = {1510, get_pedal_conversion_val(BRAKE1_PEDAL_MIN, BRAKE1_PEDAL_MAX, BRAKE1_PEDAL_MAX), AnalogSensorStatus_e::ANALOG_SENSOR_GOOD};
278
279 PedalsSystem pedals(get_real_accel_pedal_params(), get_real_brake_pedal_params());
280
281 auto data = pedals.evaluate_pedals(test_accel1_val, test_accel1_val, test_brake_val, test_brake_val, 1000);
282
283 std::cout << data.accelPressed <<std::endl;
284 std::cout << data.brakePressed <<std::endl;
285 EXPECT_TRUE(data.brakeAndAccelPressedImplausibility);
286 EXPECT_TRUE(data.brakePressed);
287 EXPECT_FALSE(data.implausibilityExceededMaxDuration);
288
289 data = pedals.evaluate_pedals(test_accel1_val, test_accel1_val, test_brake_val, test_brake_val, 1110);
290 EXPECT_TRUE(data.implausibilityExceededMaxDuration);
291
292 // testing the single brake pedal vals
293 auto data2 = pedals.evaluate_pedals(test_accel1_val, test_accel1_val, test_brake_val, 1000);
294 EXPECT_TRUE(data2.brakeAndAccelPressedImplausibility);
295 EXPECT_TRUE(data2.brakePressed);
296 EXPECT_FALSE(data2.implausibilityExceededMaxDuration);
297
298 data2 = pedals.evaluate_pedals(test_accel1_val, test_accel1_val, test_brake_val, 1110);
299 EXPECT_TRUE(data2.implausibilityExceededMaxDuration);
300}
Generated by doxygen 1.9.5