From 0bc864b3d5928ea0bbb5c69e3940b7c0f0bc17d4 Mon Sep 17 00:00:00 2001 From: Adeeb <8762862+quillford@users.noreply.github.com> Date: Tue, 28 Apr 2020 10:33:20 -0700 Subject: [PATCH] Make torque-based steering state global (#518) * use generic steering state vars for toyota * chrysler * gm * comment * more unnecessary lines * hyundai * subaru * vw * fix mazda --- board/safety/safety_chrysler.h | 26 ++--- board/safety/safety_gm.h | 25 ++-- board/safety/safety_hyundai.h | 25 ++-- board/safety/safety_mazda.h | 3 +- board/safety/safety_subaru.h | 25 ++-- board/safety/safety_toyota.h | 33 +++--- board/safety/safety_volkswagen.h | 26 ++--- board/safety_declarations.h | 7 ++ tests/safety/libpandasafety_py.py | 42 ++----- tests/safety/test.c | 169 +++++----------------------- tests/safety/test_chrysler.py | 36 +++--- tests/safety/test_gm.py | 28 ++--- tests/safety/test_hyundai.py | 28 ++--- tests/safety/test_subaru.py | 10 +- tests/safety/test_toyota.py | 44 ++++---- tests/safety/test_volkswagen_mqb.py | 40 +++---- tests/safety/test_volkswagen_pq.py | 40 +++---- 17 files changed, 224 insertions(+), 383 deletions(-) diff --git a/board/safety/safety_chrysler.h b/board/safety/safety_chrysler.h index 3ace1a3..82fcfb1 100644 --- a/board/safety/safety_chrysler.h +++ b/board/safety/safety_chrysler.h @@ -18,11 +18,7 @@ AddrCheckStruct chrysler_rx_checks[] = { }; const int CHRYSLER_RX_CHECK_LEN = sizeof(chrysler_rx_checks) / sizeof(chrysler_rx_checks[0]); -int chrysler_rt_torque_last = 0; -int chrysler_desired_torque_last = 0; int chrysler_speed = 0; -uint32_t chrysler_ts_last = 0; -struct sample_t chrysler_torque_meas; // last few torques measured static uint8_t chrysler_get_checksum(CAN_FIFOMailBox_TypeDef *to_push) { int checksum_byte = GET_LEN(to_push) - 1; @@ -83,7 +79,7 @@ static int chrysler_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { int torque_meas_new = ((GET_BYTE(to_push, 4) & 0x7U) << 8) + GET_BYTE(to_push, 5) - 1024U; // update array of samples - update_sample(&chrysler_torque_meas, torque_meas_new); + update_sample(&torque_meas, torque_meas_new); } // enter controls on rising edge of ACC, exit controls on ACC off @@ -158,20 +154,20 @@ static int chrysler_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { violation |= max_limit_check(desired_torque, CHRYSLER_MAX_STEER, -CHRYSLER_MAX_STEER); // *** torque rate limit check *** - violation |= dist_to_meas_check(desired_torque, chrysler_desired_torque_last, - &chrysler_torque_meas, CHRYSLER_MAX_RATE_UP, CHRYSLER_MAX_RATE_DOWN, CHRYSLER_MAX_TORQUE_ERROR); + violation |= dist_to_meas_check(desired_torque, desired_torque_last, + &torque_meas, CHRYSLER_MAX_RATE_UP, CHRYSLER_MAX_RATE_DOWN, CHRYSLER_MAX_TORQUE_ERROR); // used next time - chrysler_desired_torque_last = desired_torque; + desired_torque_last = desired_torque; // *** torque real time rate limit check *** - violation |= rt_rate_limit_check(desired_torque, chrysler_rt_torque_last, CHRYSLER_MAX_RT_DELTA); + violation |= rt_rate_limit_check(desired_torque, rt_torque_last, CHRYSLER_MAX_RT_DELTA); // every RT_INTERVAL set the new limits - uint32_t ts_elapsed = get_ts_elapsed(ts, chrysler_ts_last); + uint32_t ts_elapsed = get_ts_elapsed(ts, ts_last); if (ts_elapsed > CHRYSLER_RT_INTERVAL) { - chrysler_rt_torque_last = desired_torque; - chrysler_ts_last = ts; + rt_torque_last = desired_torque; + ts_last = ts; } } @@ -182,9 +178,9 @@ static int chrysler_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { // reset to 0 if either controls is not allowed or there's a violation if (violation || !controls_allowed) { - chrysler_desired_torque_last = 0; - chrysler_rt_torque_last = 0; - chrysler_ts_last = ts; + desired_torque_last = 0; + rt_torque_last = 0; + ts_last = ts; } if (violation) { diff --git a/board/safety/safety_gm.h b/board/safety/safety_gm.h index 0176e58..264df31 100644 --- a/board/safety/safety_gm.h +++ b/board/safety/safety_gm.h @@ -33,11 +33,6 @@ AddrCheckStruct gm_rx_checks[] = { }; const int GM_RX_CHECK_LEN = sizeof(gm_rx_checks) / sizeof(gm_rx_checks[0]); -int gm_rt_torque_last = 0; -int gm_desired_torque_last = 0; -uint32_t gm_ts_last = 0; -struct sample_t gm_torque_driver; // last few driver torques measured - static int gm_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { bool valid = addr_safety_check(to_push, gm_rx_checks, GM_RX_CHECK_LEN, @@ -52,7 +47,7 @@ static int gm_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { int torque_driver_new = ((GET_BYTE(to_push, 6) & 0x7) << 8) | GET_BYTE(to_push, 7); torque_driver_new = to_signed(torque_driver_new, 11); // update array of samples - update_sample(&gm_torque_driver, torque_driver_new); + update_sample(&torque_driver, torque_driver_new); } // sample speed, really only care if car is moving or not @@ -173,21 +168,21 @@ static int gm_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { violation |= max_limit_check(desired_torque, GM_MAX_STEER, -GM_MAX_STEER); // *** torque rate limit check *** - violation |= driver_limit_check(desired_torque, gm_desired_torque_last, &gm_torque_driver, + violation |= driver_limit_check(desired_torque, desired_torque_last, &torque_driver, GM_MAX_STEER, GM_MAX_RATE_UP, GM_MAX_RATE_DOWN, GM_DRIVER_TORQUE_ALLOWANCE, GM_DRIVER_TORQUE_FACTOR); // used next time - gm_desired_torque_last = desired_torque; + desired_torque_last = desired_torque; // *** torque real time rate limit check *** - violation |= rt_rate_limit_check(desired_torque, gm_rt_torque_last, GM_MAX_RT_DELTA); + violation |= rt_rate_limit_check(desired_torque, rt_torque_last, GM_MAX_RT_DELTA); // every RT_INTERVAL set the new limits - uint32_t ts_elapsed = get_ts_elapsed(ts, gm_ts_last); + uint32_t ts_elapsed = get_ts_elapsed(ts, ts_last); if (ts_elapsed > GM_RT_INTERVAL) { - gm_rt_torque_last = desired_torque; - gm_ts_last = ts; + rt_torque_last = desired_torque; + ts_last = ts; } } @@ -198,9 +193,9 @@ static int gm_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { // reset to 0 if either controls is not allowed or there's a violation if (violation || !current_controls_allowed) { - gm_desired_torque_last = 0; - gm_rt_torque_last = 0; - gm_ts_last = ts; + desired_torque_last = 0; + rt_torque_last = 0; + ts_last = ts; } if (violation) { diff --git a/board/safety/safety_hyundai.h b/board/safety/safety_hyundai.h index 651db4a..f27f2f0 100644 --- a/board/safety/safety_hyundai.h +++ b/board/safety/safety_hyundai.h @@ -18,11 +18,6 @@ AddrCheckStruct hyundai_rx_checks[] = { }; const int HYUNDAI_RX_CHECK_LEN = sizeof(hyundai_rx_checks) / sizeof(hyundai_rx_checks[0]); -int hyundai_rt_torque_last = 0; -int hyundai_desired_torque_last = 0; -uint32_t hyundai_ts_last = 0; -struct sample_t hyundai_torque_driver; // last few driver torques measured - static int hyundai_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { bool valid = addr_safety_check(to_push, hyundai_rx_checks, HYUNDAI_RX_CHECK_LEN, @@ -37,7 +32,7 @@ static int hyundai_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { if (addr == 593) { int torque_driver_new = ((GET_BYTES_04(to_push) & 0x7ff) * 0.79) - 808; // scale down new driver torque signal to match previous one // update array of samples - update_sample(&hyundai_torque_driver, torque_driver_new); + update_sample(&torque_driver, torque_driver_new); } // enter controls on rising edge of ACC, exit controls on ACC off @@ -113,21 +108,21 @@ static int hyundai_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { violation |= max_limit_check(desired_torque, HYUNDAI_MAX_STEER, -HYUNDAI_MAX_STEER); // *** torque rate limit check *** - violation |= driver_limit_check(desired_torque, hyundai_desired_torque_last, &hyundai_torque_driver, + violation |= driver_limit_check(desired_torque, desired_torque_last, &torque_driver, HYUNDAI_MAX_STEER, HYUNDAI_MAX_RATE_UP, HYUNDAI_MAX_RATE_DOWN, HYUNDAI_DRIVER_TORQUE_ALLOWANCE, HYUNDAI_DRIVER_TORQUE_FACTOR); // used next time - hyundai_desired_torque_last = desired_torque; + desired_torque_last = desired_torque; // *** torque real time rate limit check *** - violation |= rt_rate_limit_check(desired_torque, hyundai_rt_torque_last, HYUNDAI_MAX_RT_DELTA); + violation |= rt_rate_limit_check(desired_torque, rt_torque_last, HYUNDAI_MAX_RT_DELTA); // every RT_INTERVAL set the new limits - uint32_t ts_elapsed = get_ts_elapsed(ts, hyundai_ts_last); + uint32_t ts_elapsed = get_ts_elapsed(ts, ts_last); if (ts_elapsed > HYUNDAI_RT_INTERVAL) { - hyundai_rt_torque_last = desired_torque; - hyundai_ts_last = ts; + rt_torque_last = desired_torque; + ts_last = ts; } } @@ -138,9 +133,9 @@ static int hyundai_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { // reset to 0 if either controls is not allowed or there's a violation if (violation || !controls_allowed) { - hyundai_desired_torque_last = 0; - hyundai_rt_torque_last = 0; - hyundai_ts_last = ts; + desired_torque_last = 0; + rt_torque_last = 0; + ts_last = ts; } if (violation) { diff --git a/board/safety/safety_mazda.h b/board/safety/safety_mazda.h index 007a2b8..8ee6384 100644 --- a/board/safety/safety_mazda.h +++ b/board/safety/safety_mazda.h @@ -83,8 +83,7 @@ static int mazda_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { violation |= max_limit_check(desired_torque, MAZDA_MAX_STEER, -MAZDA_MAX_STEER); // *** torque rate limit check *** - int desired_torque_last = mazda_desired_torque_last; - violation |= driver_limit_check(desired_torque, desired_torque_last, &mazda_torque_driver, + violation |= driver_limit_check(desired_torque, mazda_desired_torque_last, &mazda_torque_driver, MAZDA_MAX_STEER, MAZDA_MAX_RATE_UP, MAZDA_MAX_RATE_DOWN, MAZDA_DRIVER_TORQUE_ALLOWANCE, MAZDA_DRIVER_TORQUE_FACTOR); // used next time diff --git a/board/safety/safety_subaru.h b/board/safety/safety_subaru.h index 11d8564..b65b8d0 100644 --- a/board/safety/safety_subaru.h +++ b/board/safety/safety_subaru.h @@ -30,11 +30,7 @@ AddrCheckStruct subaru_l_rx_checks[] = { const int SUBARU_RX_CHECK_LEN = sizeof(subaru_rx_checks) / sizeof(subaru_rx_checks[0]); const int SUBARU_L_RX_CHECK_LEN = sizeof(subaru_l_rx_checks) / sizeof(subaru_l_rx_checks[0]); -int subaru_rt_torque_last = 0; -int subaru_desired_torque_last = 0; -uint32_t subaru_ts_last = 0; bool subaru_global = false; -struct sample_t subaru_torque_driver; // last few driver torques measured static uint8_t subaru_get_checksum(CAN_FIFOMailBox_TypeDef *to_push) { return (uint8_t)GET_BYTE(to_push, 0); @@ -78,7 +74,7 @@ static int subaru_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { torque_driver_new = (GET_BYTE(to_push, 3) >> 5) + (GET_BYTE(to_push, 4) << 3); } torque_driver_new = to_signed(torque_driver_new, 11); - update_sample(&subaru_torque_driver, torque_driver_new); + update_sample(&torque_driver, torque_driver_new); } // enter controls on rising edge of ACC, exit controls on ACC off @@ -160,22 +156,21 @@ static int subaru_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { violation |= max_limit_check(desired_torque, SUBARU_MAX_STEER, -SUBARU_MAX_STEER); // *** torque rate limit check *** - int desired_torque_last = subaru_desired_torque_last; - violation |= driver_limit_check(desired_torque, desired_torque_last, &subaru_torque_driver, + violation |= driver_limit_check(desired_torque, desired_torque_last, &torque_driver, SUBARU_MAX_STEER, SUBARU_MAX_RATE_UP, SUBARU_MAX_RATE_DOWN, SUBARU_DRIVER_TORQUE_ALLOWANCE, SUBARU_DRIVER_TORQUE_FACTOR); // used next time - subaru_desired_torque_last = desired_torque; + desired_torque_last = desired_torque; // *** torque real time rate limit check *** - violation |= rt_rate_limit_check(desired_torque, subaru_rt_torque_last, SUBARU_MAX_RT_DELTA); + violation |= rt_rate_limit_check(desired_torque, rt_torque_last, SUBARU_MAX_RT_DELTA); // every RT_INTERVAL set the new limits - uint32_t ts_elapsed = get_ts_elapsed(ts, subaru_ts_last); + uint32_t ts_elapsed = get_ts_elapsed(ts, ts_last); if (ts_elapsed > SUBARU_RT_INTERVAL) { - subaru_rt_torque_last = desired_torque; - subaru_ts_last = ts; + rt_torque_last = desired_torque; + ts_last = ts; } } @@ -186,9 +181,9 @@ static int subaru_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { // reset to 0 if either controls is not allowed or there's a violation if (violation || !controls_allowed) { - subaru_desired_torque_last = 0; - subaru_rt_torque_last = 0; - subaru_ts_last = ts; + desired_torque_last = 0; + rt_torque_last = 0; + ts_last = ts; } if (violation) { diff --git a/board/safety/safety_toyota.h b/board/safety/safety_toyota.h index f0ed6c4..f69e4d3 100644 --- a/board/safety/safety_toyota.h +++ b/board/safety/safety_toyota.h @@ -45,13 +45,6 @@ const int TOYOTA_RX_CHECKS_LEN = sizeof(toyota_rx_checks) / sizeof(toyota_rx_che // global actuation limit states int toyota_dbc_eps_torque_factor = 100; // conversion factor for STEER_TORQUE_EPS in %: see dbc file -// states -int toyota_desired_torque_last = 0; // last desired steer torque -int toyota_rt_torque_last = 0; // last desired torque for real time check -uint32_t toyota_ts_last = 0; -struct sample_t toyota_torque_meas; // last 3 motor torques produced by the eps - - static uint8_t toyota_compute_checksum(CAN_FIFOMailBox_TypeDef *to_push) { int addr = GET_ADDR(to_push); int len = GET_LEN(to_push); @@ -85,11 +78,11 @@ static int toyota_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { torque_meas_new = (torque_meas_new * toyota_dbc_eps_torque_factor) / 100; // update array of sample - update_sample(&toyota_torque_meas, torque_meas_new); + update_sample(&torque_meas, torque_meas_new); // increase torque_meas by 1 to be conservative on rounding - toyota_torque_meas.min--; - toyota_torque_meas.max++; + torque_meas.min--; + torque_meas.max++; } // enter controls on rising edge of ACC, exit controls on ACC off @@ -212,20 +205,20 @@ static int toyota_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { violation |= max_limit_check(desired_torque, TOYOTA_MAX_TORQUE, -TOYOTA_MAX_TORQUE); // *** torque rate limit check *** - violation |= dist_to_meas_check(desired_torque, toyota_desired_torque_last, - &toyota_torque_meas, TOYOTA_MAX_RATE_UP, TOYOTA_MAX_RATE_DOWN, TOYOTA_MAX_TORQUE_ERROR); + violation |= dist_to_meas_check(desired_torque, desired_torque_last, + &torque_meas, TOYOTA_MAX_RATE_UP, TOYOTA_MAX_RATE_DOWN, TOYOTA_MAX_TORQUE_ERROR); // used next time - toyota_desired_torque_last = desired_torque; + desired_torque_last = desired_torque; // *** torque real time rate limit check *** - violation |= rt_rate_limit_check(desired_torque, toyota_rt_torque_last, TOYOTA_MAX_RT_DELTA); + violation |= rt_rate_limit_check(desired_torque, rt_torque_last, TOYOTA_MAX_RT_DELTA); // every RT_INTERVAL set the new limits - uint32_t ts_elapsed = get_ts_elapsed(ts, toyota_ts_last); + uint32_t ts_elapsed = get_ts_elapsed(ts, ts_last); if (ts_elapsed > TOYOTA_RT_INTERVAL) { - toyota_rt_torque_last = desired_torque; - toyota_ts_last = ts; + rt_torque_last = desired_torque; + ts_last = ts; } } @@ -236,9 +229,9 @@ static int toyota_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { // reset to 0 if either controls is not allowed or there's a violation if (violation || !controls_allowed) { - toyota_desired_torque_last = 0; - toyota_rt_torque_last = 0; - toyota_ts_last = ts; + desired_torque_last = 0; + rt_torque_last = 0; + ts_last = ts; } if (violation) { diff --git a/board/safety/safety_volkswagen.h b/board/safety/safety_volkswagen.h index 41dfd18..4063fa7 100644 --- a/board/safety/safety_volkswagen.h +++ b/board/safety/safety_volkswagen.h @@ -51,10 +51,6 @@ AddrCheckStruct volkswagen_pq_rx_checks[] = { }; const int VOLKSWAGEN_PQ_RX_CHECKS_LEN = sizeof(volkswagen_pq_rx_checks) / sizeof(volkswagen_pq_rx_checks[0]); -struct sample_t volkswagen_torque_driver; // Last few driver torques measured -int volkswagen_rt_torque_last = 0; -int volkswagen_desired_torque_last = 0; -uint32_t volkswagen_ts_last = 0; int volkswagen_torque_msg = 0; int volkswagen_lane_msg = 0; uint8_t volkswagen_crc8_lut_8h2f[256]; // Static lookup table for CRC8 poly 0x2F, aka 8H2F/AUTOSAR @@ -168,7 +164,7 @@ static int volkswagen_mqb_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { if (sign == 1) { torque_driver_new *= -1; } - update_sample(&volkswagen_torque_driver, torque_driver_new); + update_sample(&torque_driver, torque_driver_new); } // Update ACC status from drivetrain coordinator for controls-allowed state @@ -235,7 +231,7 @@ static int volkswagen_pq_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { if (sign == 1) { torque_driver_new *= -1; } - update_sample(&volkswagen_torque_driver, torque_driver_new); + update_sample(&torque_driver, torque_driver_new); } // Update ACC status from ECU for controls-allowed state @@ -282,19 +278,19 @@ static bool volkswagen_steering_check(int desired_torque) { violation |= max_limit_check(desired_torque, VOLKSWAGEN_MAX_STEER, -VOLKSWAGEN_MAX_STEER); // *** torque rate limit check *** - violation |= driver_limit_check(desired_torque, volkswagen_desired_torque_last, &volkswagen_torque_driver, + violation |= driver_limit_check(desired_torque, desired_torque_last, &torque_driver, VOLKSWAGEN_MAX_STEER, VOLKSWAGEN_MAX_RATE_UP, VOLKSWAGEN_MAX_RATE_DOWN, VOLKSWAGEN_DRIVER_TORQUE_ALLOWANCE, VOLKSWAGEN_DRIVER_TORQUE_FACTOR); - volkswagen_desired_torque_last = desired_torque; + desired_torque_last = desired_torque; // *** torque real time rate limit check *** - violation |= rt_rate_limit_check(desired_torque, volkswagen_rt_torque_last, VOLKSWAGEN_MAX_RT_DELTA); + violation |= rt_rate_limit_check(desired_torque, rt_torque_last, VOLKSWAGEN_MAX_RT_DELTA); // every RT_INTERVAL set the new limits - uint32_t ts_elapsed = get_ts_elapsed(ts, volkswagen_ts_last); + uint32_t ts_elapsed = get_ts_elapsed(ts, ts_last); if (ts_elapsed > VOLKSWAGEN_RT_INTERVAL) { - volkswagen_rt_torque_last = desired_torque; - volkswagen_ts_last = ts; + rt_torque_last = desired_torque; + ts_last = ts; } } @@ -305,9 +301,9 @@ static bool volkswagen_steering_check(int desired_torque) { // reset to 0 if either controls is not allowed or there's a violation if (violation || !controls_allowed) { - volkswagen_desired_torque_last = 0; - volkswagen_rt_torque_last = 0; - volkswagen_ts_last = ts; + desired_torque_last = 0; + rt_torque_last = 0; + ts_last = ts; } return violation; diff --git a/board/safety_declarations.h b/board/safety_declarations.h index 68d20fc..be8be93 100644 --- a/board/safety_declarations.h +++ b/board/safety_declarations.h @@ -92,6 +92,13 @@ bool brake_pressed_prev = false; bool cruise_engaged_prev = false; bool vehicle_moving = false; +// for torque-based safety modes +int desired_torque_last = 0; // last desired steer torque +int rt_torque_last = 0; // last desired torque for real time check +struct sample_t torque_meas; // last 3 motor torques produced by the eps +struct sample_t torque_driver; // last 3 driver torques measured +uint32_t ts_last = 0; + // This can be set with a USB command // It enables features we consider to be unsafe, but understand others may have different opinions // It is always 0 on mainline comma.ai openpilot diff --git a/tests/safety/libpandasafety_py.py b/tests/safety/libpandasafety_py.py index dc2cc2b..9898e6d 100644 --- a/tests/safety/libpandasafety_py.py +++ b/tests/safety/libpandasafety_py.py @@ -41,6 +41,16 @@ bool get_gas_interceptor_detetcted(void); int get_gas_interceptor_prev(void); bool get_gas_pressed_prev(void); bool get_brake_pressed_prev(void); + +void set_torque_meas(int min, int max); +int get_torque_meas_min(void); +int get_torque_meas_max(void); +void set_torque_driver(int min, int max); +int get_torque_driver_min(void); +int get_torque_driver_max(void); +void set_desired_torque_last(int t); +void set_rt_torque_last(int t); + bool get_cruise_engaged_prev(void); bool get_vehicle_moving(void); int get_hw_type(void); @@ -51,47 +61,17 @@ int safety_tx_hook(CAN_FIFOMailBox_TypeDef *to_push); int safety_fwd_hook(int bus_num, CAN_FIFOMailBox_TypeDef *to_fwd); int set_safety_hooks(uint16_t mode, int16_t param); -void init_tests_toyota(void); -int get_toyota_torque_meas_min(void); -int get_toyota_torque_meas_max(void); -void set_toyota_torque_meas(int min, int max); -void set_toyota_desired_torque_last(int t); -void set_toyota_rt_torque_last(int t); +void init_tests(void); void init_tests_honda(void); void set_honda_fwd_brake(bool); void set_honda_alt_brake_msg(bool); int get_honda_hw(void); -void init_tests_gm(void); -void set_gm_desired_torque_last(int t); -void set_gm_rt_torque_last(int t); -void set_gm_torque_driver(int min, int max); - -void init_tests_hyundai(void); -void set_hyundai_desired_torque_last(int t); -void set_hyundai_rt_torque_last(int t); -void set_hyundai_torque_driver(int min, int max); - void init_tests_chrysler(void); -void set_chrysler_desired_torque_last(int t); -void set_chrysler_rt_torque_last(int t); -int get_chrysler_torque_meas_min(void); -int get_chrysler_torque_meas_max(void); -void set_chrysler_torque_meas(int min, int max); -void init_tests_subaru(void); -void set_subaru_desired_torque_last(int t); -void set_subaru_rt_torque_last(int t); bool get_subaru_global(void); -void init_tests_volkswagen(void); -int get_volkswagen_torque_driver_min(void); -int get_volkswagen_torque_driver_max(void); -void set_volkswagen_desired_torque_last(int t); -void set_volkswagen_rt_torque_last(int t); -void set_volkswagen_torque_driver(int min, int max); - void init_tests_nissan(void); void set_nissan_desired_angle_last(int t); diff --git a/tests/safety/test.c b/tests/safety/test.c index b5c4f9b..52d2ea7 100644 --- a/tests/safety/test.c +++ b/tests/safety/test.c @@ -23,12 +23,8 @@ typedef struct uint32_t CNT; } TIM_TypeDef; -struct sample_t toyota_torque_meas; -struct sample_t gm_torque_driver; -struct sample_t hyundai_torque_driver; -struct sample_t chrysler_torque_meas; -struct sample_t subaru_torque_driver; -struct sample_t volkswagen_torque_driver; +struct sample_t torque_meas; +struct sample_t torque_driver; TIM_TypeDef timer; TIM_TypeDef *TIM2 = &timer; @@ -149,101 +145,38 @@ void set_timer(uint32_t t){ timer.CNT = t; } -void set_toyota_torque_meas(int min, int max){ - toyota_torque_meas.min = min; - toyota_torque_meas.max = max; +void set_torque_meas(int min, int max){ + torque_meas.min = min; + torque_meas.max = max; } -void set_gm_torque_driver(int min, int max){ - gm_torque_driver.min = min; - gm_torque_driver.max = max; +int get_torque_meas_min(void){ + return torque_meas.min; } -void set_hyundai_torque_driver(int min, int max){ - hyundai_torque_driver.min = min; - hyundai_torque_driver.max = max; +int get_torque_meas_max(void){ + return torque_meas.max; } -void set_chrysler_torque_meas(int min, int max){ - chrysler_torque_meas.min = min; - chrysler_torque_meas.max = max; +void set_torque_driver(int min, int max){ + torque_driver.min = min; + torque_driver.max = max; } -void set_volkswagen_torque_driver(int min, int max){ - volkswagen_torque_driver.min = min; - volkswagen_torque_driver.max = max; +int get_torque_driver_min(void){ + return torque_driver.min; } -int get_volkswagen_torque_driver_min(void){ - return volkswagen_torque_driver.min; +int get_torque_driver_max(void){ + return torque_driver.max; } -int get_volkswagen_torque_driver_max(void){ - return volkswagen_torque_driver.max; +void set_rt_torque_last(int t){ + rt_torque_last = t; } -int get_chrysler_torque_meas_min(void){ - return chrysler_torque_meas.min; -} - -int get_chrysler_torque_meas_max(void){ - return chrysler_torque_meas.max; -} - -int get_toyota_torque_meas_min(void){ - return toyota_torque_meas.min; -} - -int get_toyota_torque_meas_max(void){ - return toyota_torque_meas.max; -} - -void set_toyota_rt_torque_last(int t){ - toyota_rt_torque_last = t; -} - -void set_gm_rt_torque_last(int t){ - gm_rt_torque_last = t; -} - -void set_hyundai_rt_torque_last(int t){ - hyundai_rt_torque_last = t; -} - -void set_chrysler_rt_torque_last(int t){ - chrysler_rt_torque_last = t; -} - -void set_subaru_rt_torque_last(int t){ - subaru_rt_torque_last = t; -} - -void set_volkswagen_rt_torque_last(int t){ - volkswagen_rt_torque_last = t; -} - -void set_toyota_desired_torque_last(int t){ - toyota_desired_torque_last = t; -} - -void set_gm_desired_torque_last(int t){ - gm_desired_torque_last = t; -} - -void set_hyundai_desired_torque_last(int t){ - hyundai_desired_torque_last = t; -} - -void set_chrysler_desired_torque_last(int t){ - chrysler_desired_torque_last = t; -} - -void set_subaru_desired_torque_last(int t){ - subaru_desired_torque_last = t; -} - -void set_volkswagen_desired_torque_last(int t){ - volkswagen_desired_torque_last = t; +void set_desired_torque_last(int t){ + desired_torque_last = t; } void set_honda_alt_brake_msg(bool c){ @@ -268,69 +201,21 @@ void init_tests(void){ safety_mode_cnt = 2U; // avoid ignoring relay_malfunction logic gas_pressed_prev = false; brake_pressed_prev = false; + desired_torque_last = 0; + rt_torque_last = 0; + ts_last = 0; + torque_driver.min = 0; + torque_driver.max = 0; + torque_meas.min = 0; + torque_meas.max = 0; vehicle_moving = false; unsafe_mode = 0; -} - -void init_tests_toyota(void){ - init_tests(); - toyota_torque_meas.min = 0; - toyota_torque_meas.max = 0; - toyota_desired_torque_last = 0; - toyota_rt_torque_last = 0; - toyota_ts_last = 0; - set_timer(0); -} - -void init_tests_gm(void){ - init_tests(); - gm_torque_driver.min = 0; - gm_torque_driver.max = 0; - gm_desired_torque_last = 0; - gm_rt_torque_last = 0; - gm_ts_last = 0; - set_timer(0); -} - -void init_tests_hyundai(void){ - init_tests(); - hyundai_torque_driver.min = 0; - hyundai_torque_driver.max = 0; - hyundai_desired_torque_last = 0; - hyundai_rt_torque_last = 0; - hyundai_ts_last = 0; set_timer(0); } void init_tests_chrysler(void){ init_tests(); chrysler_speed = 0; - chrysler_torque_meas.min = 0; - chrysler_torque_meas.max = 0; - chrysler_desired_torque_last = 0; - chrysler_rt_torque_last = 0; - chrysler_ts_last = 0; - set_timer(0); -} - -void init_tests_subaru(void){ - init_tests(); - subaru_torque_driver.min = 0; - subaru_torque_driver.max = 0; - subaru_desired_torque_last = 0; - subaru_rt_torque_last = 0; - subaru_ts_last = 0; - set_timer(0); -} - -void init_tests_volkswagen(void){ - init_tests(); - volkswagen_torque_driver.min = 0; - volkswagen_torque_driver.max = 0; - volkswagen_desired_torque_last = 0; - volkswagen_rt_torque_last = 0; - volkswagen_ts_last = 0; - set_timer(0); } void init_tests_honda(void){ diff --git a/tests/safety/test_chrysler.py b/tests/safety/test_chrysler.py index a6d89d8..6a259ef 100755 --- a/tests/safety/test_chrysler.py +++ b/tests/safety/test_chrysler.py @@ -95,9 +95,9 @@ class TestChryslerSafety(common.PandaSafetyTest): return to_send def _set_prev_torque(self, t): - self.safety.set_chrysler_desired_torque_last(t) - self.safety.set_chrysler_rt_torque_last(t) - self.safety.set_chrysler_torque_meas(t, t) + self.safety.set_desired_torque_last(t) + self.safety.set_rt_torque_last(t) + self.safety.set_torque_meas(t, t) def _torque_meas_msg(self, torque): to_send = make_msg(0, 544) @@ -121,7 +121,7 @@ class TestChryslerSafety(common.PandaSafetyTest): self.assertFalse(self._tx(self._torque_msg(t))) else: self.assertTrue(self._tx(self._torque_msg(t))) - + # TODO: why does chrysler check if moving? def test_disengage_on_gas(self): self.safety.set_controls_allowed(1) @@ -145,15 +145,15 @@ class TestChryslerSafety(common.PandaSafetyTest): def test_non_realtime_limit_down(self): self.safety.set_controls_allowed(True) - self.safety.set_chrysler_rt_torque_last(MAX_STEER) + self.safety.set_rt_torque_last(MAX_STEER) torque_meas = MAX_STEER - MAX_TORQUE_ERROR - 20 - self.safety.set_chrysler_torque_meas(torque_meas, torque_meas) - self.safety.set_chrysler_desired_torque_last(MAX_STEER) + self.safety.set_torque_meas(torque_meas, torque_meas) + self.safety.set_desired_torque_last(MAX_STEER) self.assertTrue(self._tx(self._torque_msg(MAX_STEER - MAX_RATE_DOWN))) - self.safety.set_chrysler_rt_torque_last(MAX_STEER) - self.safety.set_chrysler_torque_meas(torque_meas, torque_meas) - self.safety.set_chrysler_desired_torque_last(MAX_STEER) + self.safety.set_rt_torque_last(MAX_STEER) + self.safety.set_torque_meas(torque_meas, torque_meas) + self.safety.set_desired_torque_last(MAX_STEER) self.assertFalse(self._tx(self._torque_msg(MAX_STEER - MAX_RATE_DOWN + 1))) def test_exceed_torque_sensor(self): @@ -175,14 +175,14 @@ class TestChryslerSafety(common.PandaSafetyTest): self._set_prev_torque(0) for t in np.arange(0, MAX_RT_DELTA+1, 1): t *= sign - self.safety.set_chrysler_torque_meas(t, t) + self.safety.set_torque_meas(t, t) self.assertTrue(self._tx(self._torque_msg(t))) self.assertFalse(self._tx(self._torque_msg(sign * (MAX_RT_DELTA + 1)))) self._set_prev_torque(0) for t in np.arange(0, MAX_RT_DELTA+1, 1): t *= sign - self.safety.set_chrysler_torque_meas(t, t) + self.safety.set_torque_meas(t, t) self.assertTrue(self._tx(self._torque_msg(t))) # Increase timer to update rt_torque_last @@ -198,16 +198,16 @@ class TestChryslerSafety(common.PandaSafetyTest): self._rx(self._torque_meas_msg(0)) self._rx(self._torque_meas_msg(0)) - self.assertEqual(-50, self.safety.get_chrysler_torque_meas_min()) - self.assertEqual(50, self.safety.get_chrysler_torque_meas_max()) + self.assertEqual(-50, self.safety.get_torque_meas_min()) + self.assertEqual(50, self.safety.get_torque_meas_max()) self._rx(self._torque_meas_msg(0)) - self.assertEqual(0, self.safety.get_chrysler_torque_meas_max()) - self.assertEqual(-50, self.safety.get_chrysler_torque_meas_min()) + self.assertEqual(0, self.safety.get_torque_meas_max()) + self.assertEqual(-50, self.safety.get_torque_meas_min()) self._rx(self._torque_meas_msg(0)) - self.assertEqual(0, self.safety.get_chrysler_torque_meas_max()) - self.assertEqual(0, self.safety.get_chrysler_torque_meas_min()) + self.assertEqual(0, self.safety.get_torque_meas_max()) + self.assertEqual(0, self.safety.get_torque_meas_min()) def test_cancel_button(self): CANCEL = 1 diff --git a/tests/safety/test_gm.py b/tests/safety/test_gm.py index 25b7238..5343355 100644 --- a/tests/safety/test_gm.py +++ b/tests/safety/test_gm.py @@ -35,7 +35,7 @@ class TestGmSafety(common.PandaSafetyTest): self.packer_chassis = CANPackerPanda("gm_global_a_chassis") self.safety = libpandasafety_py.libpandasafety self.safety.set_safety_hooks(Panda.SAFETY_GM, 0) - self.safety.init_tests_gm() + self.safety.init_tests() # override these tests from PandaSafetyTest, GM uses button enable def test_disable_control_allowed_from_cruise(self): pass @@ -68,8 +68,8 @@ class TestGmSafety(common.PandaSafetyTest): return self.packer.make_can_msg_panda("ASCMGasRegenCmd", 0, values) def _set_prev_torque(self, t): - self.safety.set_gm_desired_torque_last(t) - self.safety.set_gm_rt_torque_last(t) + self.safety.set_desired_torque_last(t) + self.safety.set_rt_torque_last(t) def _torque_driver_msg(self, torque): values = {"LKADriverAppldTrq": torque} @@ -126,7 +126,7 @@ class TestGmSafety(common.PandaSafetyTest): self.assertTrue(self._tx(self._torque_msg(t))) def test_non_realtime_limit_up(self): - self.safety.set_gm_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) self._set_prev_torque(0) @@ -141,7 +141,7 @@ class TestGmSafety(common.PandaSafetyTest): self.assertFalse(self._tx(self._torque_msg(-MAX_RATE_UP - 1))) def test_non_realtime_limit_down(self): - self.safety.set_gm_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) def test_against_torque_driver(self): @@ -150,11 +150,11 @@ class TestGmSafety(common.PandaSafetyTest): for sign in [-1, 1]: for t in np.arange(0, DRIVER_TORQUE_ALLOWANCE + 1, 1): t *= -sign - self.safety.set_gm_torque_driver(t, t) + self.safety.set_torque_driver(t, t) self._set_prev_torque(MAX_STEER * sign) self.assertTrue(self._tx(self._torque_msg(MAX_STEER * sign))) - self.safety.set_gm_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) + self.safety.set_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) self.assertFalse(self._tx(self._torque_msg(-MAX_STEER))) # spot check some individual cases @@ -163,20 +163,20 @@ class TestGmSafety(common.PandaSafetyTest): torque_desired = (MAX_STEER - 10 * DRIVER_TORQUE_FACTOR) * sign delta = 1 * sign self._set_prev_torque(torque_desired) - self.safety.set_gm_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertTrue(self._tx(self._torque_msg(torque_desired))) self._set_prev_torque(torque_desired + delta) - self.safety.set_gm_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertFalse(self._tx(self._torque_msg(torque_desired + delta))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_gm_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._torque_msg((MAX_STEER - MAX_RATE_DOWN) * sign))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_gm_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._torque_msg(0))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_gm_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertFalse(self._tx(self._torque_msg((MAX_STEER - MAX_RATE_DOWN + 1) * sign))) @@ -184,9 +184,9 @@ class TestGmSafety(common.PandaSafetyTest): self.safety.set_controls_allowed(True) for sign in [-1, 1]: - self.safety.init_tests_gm() + self.safety.init_tests() self._set_prev_torque(0) - self.safety.set_gm_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) for t in np.arange(0, MAX_RT_DELTA, 1): t *= sign self.assertTrue(self._tx(self._torque_msg(t))) diff --git a/tests/safety/test_hyundai.py b/tests/safety/test_hyundai.py index 0e63aa3..b0ba85e 100644 --- a/tests/safety/test_hyundai.py +++ b/tests/safety/test_hyundai.py @@ -29,7 +29,7 @@ class TestHyundaiSafety(common.PandaSafetyTest): self.packer = CANPackerPanda("hyundai_kia_generic") self.safety = libpandasafety_py.libpandasafety self.safety.set_safety_hooks(Panda.SAFETY_HYUNDAI, 0) - self.safety.init_tests_hyundai() + self.safety.init_tests() def _button_msg(self, buttons): values = {"CF_Clu_CruiseSwState": buttons} @@ -53,8 +53,8 @@ class TestHyundaiSafety(common.PandaSafetyTest): return self.packer.make_can_msg_panda("SCC12", 0, values) def _set_prev_torque(self, t): - self.safety.set_hyundai_desired_torque_last(t) - self.safety.set_hyundai_rt_torque_last(t) + self.safety.set_desired_torque_last(t) + self.safety.set_rt_torque_last(t) # TODO: this is unused def _torque_driver_msg(self, torque): @@ -76,7 +76,7 @@ class TestHyundaiSafety(common.PandaSafetyTest): self.assertTrue(self._tx(self._torque_msg(t))) def test_non_realtime_limit_up(self): - self.safety.set_hyundai_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) self._set_prev_torque(0) @@ -91,7 +91,7 @@ class TestHyundaiSafety(common.PandaSafetyTest): self.assertFalse(self._tx(self._torque_msg(-MAX_RATE_UP - 1))) def test_non_realtime_limit_down(self): - self.safety.set_hyundai_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) def test_against_torque_driver(self): @@ -100,11 +100,11 @@ class TestHyundaiSafety(common.PandaSafetyTest): for sign in [-1, 1]: for t in np.arange(0, DRIVER_TORQUE_ALLOWANCE + 1, 1): t *= -sign - self.safety.set_hyundai_torque_driver(t, t) + self.safety.set_torque_driver(t, t) self._set_prev_torque(MAX_STEER * sign) self.assertTrue(self._tx(self._torque_msg(MAX_STEER * sign))) - self.safety.set_hyundai_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) + self.safety.set_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) self.assertFalse(self._tx(self._torque_msg(-MAX_STEER))) # spot check some individual cases @@ -113,20 +113,20 @@ class TestHyundaiSafety(common.PandaSafetyTest): torque_desired = (MAX_STEER - 10 * DRIVER_TORQUE_FACTOR) * sign delta = 1 * sign self._set_prev_torque(torque_desired) - self.safety.set_hyundai_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertTrue(self._tx(self._torque_msg(torque_desired))) self._set_prev_torque(torque_desired + delta) - self.safety.set_hyundai_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertFalse(self._tx(self._torque_msg(torque_desired + delta))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_hyundai_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._torque_msg((MAX_STEER - MAX_RATE_DOWN) * sign))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_hyundai_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._torque_msg(0))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_hyundai_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertFalse(self._tx(self._torque_msg((MAX_STEER - MAX_RATE_DOWN + 1) * sign))) @@ -134,9 +134,9 @@ class TestHyundaiSafety(common.PandaSafetyTest): self.safety.set_controls_allowed(True) for sign in [-1, 1]: - self.safety.init_tests_hyundai() + self.safety.init_tests() self._set_prev_torque(0) - self.safety.set_hyundai_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) for t in np.arange(0, MAX_RT_DELTA, 1): t *= sign self.assertTrue(self._tx(self._torque_msg(t))) diff --git a/tests/safety/test_subaru.py b/tests/safety/test_subaru.py index 358823e..078e4b3 100644 --- a/tests/safety/test_subaru.py +++ b/tests/safety/test_subaru.py @@ -35,11 +35,11 @@ class TestSubaruSafety(common.PandaSafetyTest): self.packer = CANPackerPanda("subaru_global_2017") self.safety = libpandasafety_py.libpandasafety self.safety.set_safety_hooks(Panda.SAFETY_SUBARU, 0) - self.safety.init_tests_subaru() + self.safety.init_tests() def _set_prev_torque(self, t): - self.safety.set_subaru_desired_torque_last(t) - self.safety.set_subaru_rt_torque_last(t) + self.safety.set_desired_torque_last(t) + self.safety.set_rt_torque_last(t) def _torque_driver_msg(self, torque): values = {"Steer_Torque_Sensor": -torque, "counter": self.cnt_torque_driver % 4} @@ -147,7 +147,7 @@ class TestSubaruSafety(common.PandaSafetyTest): self.safety.set_controls_allowed(True) for sign in [-1, 1]: - self.safety.init_tests_subaru() + self.safety.init_tests() self._set_prev_torque(0) self._set_torque_driver(0, 0) for t in np.arange(0, MAX_RT_DELTA, 1): @@ -178,7 +178,7 @@ class TestSubaruLegacySafety(TestSubaruSafety): self.packer = CANPackerPanda("subaru_outback_2015_eyesight") self.safety = libpandasafety_py.libpandasafety self.safety.set_safety_hooks(Panda.SAFETY_SUBARU_LEGACY, 0) - self.safety.init_tests_subaru() + self.safety.init_tests() # subaru legacy safety doesn't have brake checks def test_prev_brake(self): pass diff --git a/tests/safety/test_toyota.py b/tests/safety/test_toyota.py index 027565e..dee80d7 100755 --- a/tests/safety/test_toyota.py +++ b/tests/safety/test_toyota.py @@ -39,12 +39,12 @@ class TestToyotaSafety(common.PandaSafetyTest, common.InterceptorSafetyTest): self.packer = CANPackerPanda("toyota_prius_2017_pt_generated") self.safety = libpandasafety_py.libpandasafety self.safety.set_safety_hooks(Panda.SAFETY_TOYOTA, 66) - self.safety.init_tests_toyota() + self.safety.init_tests() def _set_prev_torque(self, t): - self.safety.set_toyota_desired_torque_last(t) - self.safety.set_toyota_rt_torque_last(t) - self.safety.set_toyota_torque_meas(t, t) + self.safety.set_desired_torque_last(t) + self.safety.set_rt_torque_last(t) + self.safety.set_torque_meas(t, t) def _torque_meas_msg(self, torque): values = {"STEER_TORQUE_EPS": torque} @@ -102,9 +102,9 @@ class TestToyotaSafety(common.PandaSafetyTest, common.InterceptorSafetyTest): for controls_allowed in [True, False]: for torque in np.arange(-MAX_TORQUE - 1000, MAX_TORQUE + 1000, MAX_RATE_UP): self.safety.set_controls_allowed(controls_allowed) - self.safety.set_toyota_rt_torque_last(torque) - self.safety.set_toyota_torque_meas(torque, torque) - self.safety.set_toyota_desired_torque_last(torque - MAX_RATE_UP) + self.safety.set_rt_torque_last(torque) + self.safety.set_torque_meas(torque, torque) + self.safety.set_desired_torque_last(torque - MAX_RATE_UP) if controls_allowed: send = (-MAX_TORQUE <= torque <= MAX_TORQUE) @@ -125,14 +125,14 @@ class TestToyotaSafety(common.PandaSafetyTest, common.InterceptorSafetyTest): def test_non_realtime_limit_down(self): self.safety.set_controls_allowed(True) - self.safety.set_toyota_rt_torque_last(1000) - self.safety.set_toyota_torque_meas(500, 500) - self.safety.set_toyota_desired_torque_last(1000) + self.safety.set_rt_torque_last(1000) + self.safety.set_torque_meas(500, 500) + self.safety.set_desired_torque_last(1000) self.assertTrue(self._tx(self._torque_msg(1000 - MAX_RATE_DOWN))) - self.safety.set_toyota_rt_torque_last(1000) - self.safety.set_toyota_torque_meas(500, 500) - self.safety.set_toyota_desired_torque_last(1000) + self.safety.set_rt_torque_last(1000) + self.safety.set_torque_meas(500, 500) + self.safety.set_desired_torque_last(1000) self.assertFalse(self._tx(self._torque_msg(1000 - MAX_RATE_DOWN + 1))) def test_exceed_torque_sensor(self): @@ -150,18 +150,18 @@ class TestToyotaSafety(common.PandaSafetyTest, common.InterceptorSafetyTest): self.safety.set_controls_allowed(True) for sign in [-1, 1]: - self.safety.init_tests_toyota() + self.safety.init_tests() self._set_prev_torque(0) for t in np.arange(0, 380, 10): t *= sign - self.safety.set_toyota_torque_meas(t, t) + self.safety.set_torque_meas(t, t) self.assertTrue(self._tx(self._torque_msg(t))) self.assertFalse(self._tx(self._torque_msg(sign * 380))) self._set_prev_torque(0) for t in np.arange(0, 370, 10): t *= sign - self.safety.set_toyota_torque_meas(t, t) + self.safety.set_torque_meas(t, t) self.assertTrue(self._tx(self._torque_msg(t))) # Increase timer to update rt_torque_last @@ -174,16 +174,16 @@ class TestToyotaSafety(common.PandaSafetyTest, common.InterceptorSafetyTest): self._rx(self._torque_meas_msg(trq)) # toyota safety adds one to be conservative on rounding - self.assertEqual(-51, self.safety.get_toyota_torque_meas_min()) - self.assertEqual(51, self.safety.get_toyota_torque_meas_max()) + self.assertEqual(-51, self.safety.get_torque_meas_min()) + self.assertEqual(51, self.safety.get_torque_meas_max()) self._rx(self._torque_meas_msg(0)) - self.assertEqual(1, self.safety.get_toyota_torque_meas_max()) - self.assertEqual(-51, self.safety.get_toyota_torque_meas_min()) + self.assertEqual(1, self.safety.get_torque_meas_max()) + self.assertEqual(-51, self.safety.get_torque_meas_min()) self._rx(self._torque_meas_msg(0)) - self.assertEqual(1, self.safety.get_toyota_torque_meas_max()) - self.assertEqual(-1, self.safety.get_toyota_torque_meas_min()) + self.assertEqual(1, self.safety.get_torque_meas_max()) + self.assertEqual(-1, self.safety.get_torque_meas_min()) def test_rx_hook(self): # checksum checks diff --git a/tests/safety/test_volkswagen_mqb.py b/tests/safety/test_volkswagen_mqb.py index 7491034..ea93dc6 100644 --- a/tests/safety/test_volkswagen_mqb.py +++ b/tests/safety/test_volkswagen_mqb.py @@ -46,14 +46,14 @@ class TestVolkswagenMqbSafety(common.PandaSafetyTest): self.packer = CANPackerPanda("vw_mqb_2010") self.safety = libpandasafety_py.libpandasafety self.safety.set_safety_hooks(Panda.SAFETY_VOLKSWAGEN_MQB, 0) - self.safety.init_tests_volkswagen() + self.safety.init_tests() # override these inherited tests from PandaSafetyTest def test_cruise_engaged_prev(self): pass def _set_prev_torque(self, t): - self.safety.set_volkswagen_desired_torque_last(t) - self.safety.set_volkswagen_rt_torque_last(t) + self.safety.set_desired_torque_last(t) + self.safety.set_rt_torque_last(t) # Wheel speeds _esp_19_msg def _speed_msg(self, speed): @@ -129,7 +129,7 @@ class TestVolkswagenMqbSafety(common.PandaSafetyTest): self.assertTrue(self._tx(self._gra_acc_01_msg(resume=1))) def test_non_realtime_limit_up(self): - self.safety.set_volkswagen_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) self._set_prev_torque(0) @@ -144,7 +144,7 @@ class TestVolkswagenMqbSafety(common.PandaSafetyTest): self.assertFalse(self._tx(self._hca_01_msg(-MAX_RATE_UP - 1))) def test_non_realtime_limit_down(self): - self.safety.set_volkswagen_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) def test_against_torque_driver(self): @@ -153,11 +153,11 @@ class TestVolkswagenMqbSafety(common.PandaSafetyTest): for sign in [-1, 1]: for t in np.arange(0, DRIVER_TORQUE_ALLOWANCE + 1, 1): t *= -sign - self.safety.set_volkswagen_torque_driver(t, t) + self.safety.set_torque_driver(t, t) self._set_prev_torque(MAX_STEER * sign) self.assertTrue(self._tx(self._hca_01_msg(MAX_STEER * sign))) - self.safety.set_volkswagen_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) + self.safety.set_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) self.assertFalse(self._tx(self._hca_01_msg(-MAX_STEER))) # spot check some individual cases @@ -166,29 +166,29 @@ class TestVolkswagenMqbSafety(common.PandaSafetyTest): torque_desired = (MAX_STEER - 10 * DRIVER_TORQUE_FACTOR) * sign delta = 1 * sign self._set_prev_torque(torque_desired) - self.safety.set_volkswagen_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertTrue(self._tx(self._hca_01_msg(torque_desired))) self._set_prev_torque(torque_desired + delta) - self.safety.set_volkswagen_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertFalse(self._tx(self._hca_01_msg(torque_desired + delta))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_volkswagen_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._hca_01_msg((MAX_STEER - MAX_RATE_DOWN) * sign))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_volkswagen_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._hca_01_msg(0))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_volkswagen_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertFalse(self._tx(self._hca_01_msg((MAX_STEER - MAX_RATE_DOWN + 1) * sign))) def test_realtime_limits(self): self.safety.set_controls_allowed(True) for sign in [-1, 1]: - self.safety.init_tests_volkswagen() + self.safety.init_tests() self._set_prev_torque(0) - self.safety.set_volkswagen_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) for t in np.arange(0, MAX_RT_DELTA, 1): t *= sign self.assertTrue(self._tx(self._hca_01_msg(t))) @@ -212,16 +212,16 @@ class TestVolkswagenMqbSafety(common.PandaSafetyTest): self._rx(self._eps_01_msg(0)) self._rx(self._eps_01_msg(0)) - self.assertEqual(-50, self.safety.get_volkswagen_torque_driver_min()) - self.assertEqual(50, self.safety.get_volkswagen_torque_driver_max()) + self.assertEqual(-50, self.safety.get_torque_driver_min()) + self.assertEqual(50, self.safety.get_torque_driver_max()) self._rx(self._eps_01_msg(0)) - self.assertEqual(0, self.safety.get_volkswagen_torque_driver_max()) - self.assertEqual(-50, self.safety.get_volkswagen_torque_driver_min()) + self.assertEqual(0, self.safety.get_torque_driver_max()) + self.assertEqual(-50, self.safety.get_torque_driver_min()) self._rx(self._eps_01_msg(0)) - self.assertEqual(0, self.safety.get_volkswagen_torque_driver_max()) - self.assertEqual(0, self.safety.get_volkswagen_torque_driver_min()) + self.assertEqual(0, self.safety.get_torque_driver_max()) + self.assertEqual(0, self.safety.get_torque_driver_min()) def test_rx_hook(self): # checksum checks diff --git a/tests/safety/test_volkswagen_pq.py b/tests/safety/test_volkswagen_pq.py index 8e2b75c..f30d19f 100644 --- a/tests/safety/test_volkswagen_pq.py +++ b/tests/safety/test_volkswagen_pq.py @@ -50,14 +50,14 @@ class TestVolkswagenPqSafety(common.PandaSafetyTest): def setUp(self): self.safety = libpandasafety_py.libpandasafety self.safety.set_safety_hooks(Panda.SAFETY_VOLKSWAGEN_PQ, 0) - self.safety.init_tests_volkswagen() + self.safety.init_tests() # override these inherited tests from PandaSafetyTest def test_cruise_engaged_prev(self): pass def _set_prev_torque(self, t): - self.safety.set_volkswagen_desired_torque_last(t) - self.safety.set_volkswagen_rt_torque_last(t) + self.safety.set_desired_torque_last(t) + self.safety.set_rt_torque_last(t) # Wheel speeds (Bremse_3) def _speed_msg(self, speed): @@ -148,7 +148,7 @@ class TestVolkswagenPqSafety(common.PandaSafetyTest): self.assertTrue(self._tx(self._gra_neu_msg(BIT_RESUME))) def test_non_realtime_limit_up(self): - self.safety.set_volkswagen_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) self._set_prev_torque(0) @@ -163,7 +163,7 @@ class TestVolkswagenPqSafety(common.PandaSafetyTest): self.assertFalse(self._tx(self._hca_1_msg(-MAX_RATE_UP - 1))) def test_non_realtime_limit_down(self): - self.safety.set_volkswagen_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) self.safety.set_controls_allowed(True) def test_against_torque_driver(self): @@ -172,11 +172,11 @@ class TestVolkswagenPqSafety(common.PandaSafetyTest): for sign in [-1, 1]: for t in np.arange(0, DRIVER_TORQUE_ALLOWANCE + 1, 1): t *= -sign - self.safety.set_volkswagen_torque_driver(t, t) + self.safety.set_torque_driver(t, t) self._set_prev_torque(MAX_STEER * sign) self.assertTrue(self._tx(self._hca_1_msg(MAX_STEER * sign))) - self.safety.set_volkswagen_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) + self.safety.set_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1) self.assertFalse(self._tx(self._hca_1_msg(-MAX_STEER))) # spot check some individual cases @@ -185,29 +185,29 @@ class TestVolkswagenPqSafety(common.PandaSafetyTest): torque_desired = (MAX_STEER - 10 * DRIVER_TORQUE_FACTOR) * sign delta = 1 * sign self._set_prev_torque(torque_desired) - self.safety.set_volkswagen_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertTrue(self._tx(self._hca_1_msg(torque_desired))) self._set_prev_torque(torque_desired + delta) - self.safety.set_volkswagen_torque_driver(-driver_torque, -driver_torque) + self.safety.set_torque_driver(-driver_torque, -driver_torque) self.assertFalse(self._tx(self._hca_1_msg(torque_desired + delta))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_volkswagen_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._hca_1_msg((MAX_STEER - MAX_RATE_DOWN) * sign))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_volkswagen_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertTrue(self._tx(self._hca_1_msg(0))) self._set_prev_torque(MAX_STEER * sign) - self.safety.set_volkswagen_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) + self.safety.set_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign) self.assertFalse(self._tx(self._hca_1_msg((MAX_STEER - MAX_RATE_DOWN + 1) * sign))) def test_realtime_limits(self): self.safety.set_controls_allowed(True) for sign in [-1, 1]: - self.safety.init_tests_volkswagen() + self.safety.init_tests() self._set_prev_torque(0) - self.safety.set_volkswagen_torque_driver(0, 0) + self.safety.set_torque_driver(0, 0) for t in np.arange(0, MAX_RT_DELTA, 1): t *= sign self.assertTrue(self._tx(self._hca_1_msg(t))) @@ -231,16 +231,16 @@ class TestVolkswagenPqSafety(common.PandaSafetyTest): self._rx(self._lenkhilfe_3_msg(0)) self._rx(self._lenkhilfe_3_msg(0)) - self.assertEqual(-50, self.safety.get_volkswagen_torque_driver_min()) - self.assertEqual(50, self.safety.get_volkswagen_torque_driver_max()) + self.assertEqual(-50, self.safety.get_torque_driver_min()) + self.assertEqual(50, self.safety.get_torque_driver_max()) self._rx(self._lenkhilfe_3_msg(0)) - self.assertEqual(0, self.safety.get_volkswagen_torque_driver_max()) - self.assertEqual(-50, self.safety.get_volkswagen_torque_driver_min()) + self.assertEqual(0, self.safety.get_torque_driver_max()) + self.assertEqual(-50, self.safety.get_torque_driver_min()) self._rx(self._lenkhilfe_3_msg(0)) - self.assertEqual(0, self.safety.get_volkswagen_torque_driver_max()) - self.assertEqual(0, self.safety.get_volkswagen_torque_driver_min()) + self.assertEqual(0, self.safety.get_torque_driver_max()) + self.assertEqual(0, self.safety.get_torque_driver_min()) def test_rx_hook(self): # checksum checks