From ba8762d5a3e30c3c3ceceaf9b378418c9fadf9a0 Mon Sep 17 00:00:00 2001 From: Riccardo Date: Tue, 17 Jul 2018 19:43:06 -0700 Subject: [PATCH] Toyota safety: vars and consts need 'toyota_' prefix --- board/safety/safety_toyota.h | 75 ++++++++++++++++--------------- board/safety/safety_toyota_ipas.h | 8 ++-- tests/safety/libpandasafety_py.py | 10 ++--- tests/safety/test.c | 34 +++++++------- tests/safety/test_toyota.py | 40 ++++++++--------- 5 files changed, 84 insertions(+), 83 deletions(-) diff --git a/board/safety/safety_toyota.h b/board/safety/safety_toyota.h index 7cbeafcb96f65d..57f86b8ab0bfd7 100644 --- a/board/safety/safety_toyota.h +++ b/board/safety/safety_toyota.h @@ -1,32 +1,32 @@ -struct sample_t torque_meas; // last 3 motor torques produced by the eps +struct sample_t toyota_torque_meas; // last 3 motor torques produced by the eps // global torque limit -const int MAX_TORQUE = 1500; // max torque cmd allowed ever +const int TOYOTA_MAX_TORQUE = 1500; // max torque cmd allowed ever // rate based torque limit + stay within actually applied // packet is sent at 100hz, so this limit is 1000/sec -const int MAX_RATE_UP = 10; // ramp up slow -const int MAX_RATE_DOWN = 25; // ramp down fast -const int MAX_TORQUE_ERROR = 350; // max torque cmd in excess of torque motor +const int TOYOTA_MAX_RATE_UP = 10; // ramp up slow +const int TOYOTA_MAX_RATE_DOWN = 25; // ramp down fast +const int TOYOTA_MAX_TORQUE_ERROR = 350; // max torque cmd in excess of torque motor // real time torque limit to prevent controls spamming // the real time limit is 1500/sec -const int MAX_RT_DELTA = 375; // max delta torque allowed for real time checks -const int RT_INTERVAL = 250000; // 250ms between real time checks +const int TOYOTA_MAX_RT_DELTA = 375; // max delta torque allowed for real time checks +const int TOYOTA_RT_INTERVAL = 250000; // 250ms between real time checks // longitudinal limits -const int MAX_ACCEL = 1500; // 1.5 m/s2 -const int MIN_ACCEL = -3000; // 3.0 m/s2 +const int TOYOTA_MAX_ACCEL = 1500; // 1.5 m/s2 +const int TOYOTA_MIN_ACCEL = -3000; // 3.0 m/s2 // global actuation limit state -int actuation_limits = 1; // by default steer limits are imposed -int dbc_eps_torque_factor = 100; // conversion factor for STEER_TORQUE_EPS in %: see dbc file +int toyota_actuation_limits = 1; // by default steer limits are imposed +int toyota_dbc_eps_torque_factor = 100; // conversion factor for STEER_TORQUE_EPS in %: see dbc file // state of torque limits -int desired_torque_last = 0; // last desired steer torque -int rt_torque_last = 0; // last desired torque for real time check -uint32_t ts_last = 0; -int cruise_engaged_last = 0; // cruise state +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; +int toyota_cruise_engaged_last = 0; // cruise state static void toyota_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { @@ -36,25 +36,25 @@ static void toyota_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { torque_meas_new = to_signed(torque_meas_new, 16); // scale by dbc_factor - torque_meas_new = (torque_meas_new * dbc_eps_torque_factor) / 100; + torque_meas_new = (torque_meas_new * toyota_dbc_eps_torque_factor) / 100; // increase torque_meas by 1 to be conservative on rounding torque_meas_new += (torque_meas_new > 0 ? 1 : -1); // update array of sample - update_sample(&torque_meas, torque_meas_new); + update_sample(&toyota_torque_meas, torque_meas_new); } // enter controls on rising edge of ACC, exit controls on ACC off if ((to_push->RIR>>21) == 0x1D2) { // 4 bits: 55-52 int cruise_engaged = to_push->RDHR & 0xF00000; - if (cruise_engaged && !cruise_engaged_last) { + if (cruise_engaged && !toyota_cruise_engaged_last) { controls_allowed = 1; } else if (!cruise_engaged) { controls_allowed = 0; } - cruise_engaged_last = cruise_engaged; + toyota_cruise_engaged_last = cruise_engaged; } } @@ -70,8 +70,8 @@ static int toyota_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { if ((to_send->RIR>>21) == 0x343) { int desired_accel = ((to_send->RDLR & 0xFF) << 8) | ((to_send->RDLR >> 8) & 0xFF); desired_accel = to_signed(desired_accel, 16); - if (controls_allowed && actuation_limits) { - int violation = max_limit_check(desired_accel, MAX_ACCEL, MIN_ACCEL); + if (controls_allowed && toyota_actuation_limits) { + int violation = max_limit_check(desired_accel, TOYOTA_MAX_ACCEL, TOYOTA_MIN_ACCEL); if (violation) return 0; } else if (!controls_allowed && (desired_accel != 0)) { return 0; @@ -87,25 +87,26 @@ static int toyota_tx_hook(CAN_FIFOMailBox_TypeDef *to_send) { uint32_t ts = TIM2->CNT; // only check if controls are allowed and actuation_limits are imposed - if (controls_allowed && actuation_limits) { + if (controls_allowed && toyota_actuation_limits) { // *** global torque limit check *** - violation |= max_limit_check(desired_torque, MAX_TORQUE, -MAX_TORQUE); + violation |= max_limit_check(desired_torque, TOYOTA_MAX_TORQUE, -TOYOTA_MAX_TORQUE); // *** torque rate limit check *** - violation |= dist_to_meas_check(desired_torque, desired_torque_last, &torque_meas, MAX_RATE_UP, MAX_RATE_DOWN, MAX_TORQUE_ERROR); + 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); // used next time - desired_torque_last = desired_torque; + toyota_desired_torque_last = desired_torque; // *** torque real time rate limit check *** - violation |= rt_rate_limit_check(desired_torque, rt_torque_last, MAX_RT_DELTA); + violation |= rt_rate_limit_check(desired_torque, toyota_rt_torque_last, TOYOTA_MAX_RT_DELTA); // every RT_INTERVAL set the new limits - uint32_t ts_elapsed = get_ts_elapsed(ts, ts_last); - if (ts_elapsed > RT_INTERVAL) { - rt_torque_last = desired_torque; - ts_last = ts; + uint32_t ts_elapsed = get_ts_elapsed(ts, toyota_ts_last); + if (ts_elapsed > TOYOTA_RT_INTERVAL) { + toyota_rt_torque_last = desired_torque; + toyota_ts_last = ts; } } @@ -116,9 +117,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) { - desired_torque_last = 0; - rt_torque_last = 0; - ts_last = ts; + toyota_desired_torque_last = 0; + toyota_rt_torque_last = 0; + toyota_ts_last = ts; } if (violation) { @@ -138,8 +139,8 @@ static int toyota_tx_lin_hook(int lin_num, uint8_t *data, int len) { static void toyota_init(int16_t param) { controls_allowed = 0; - actuation_limits = 1; - dbc_eps_torque_factor = param; + toyota_actuation_limits = 1; + toyota_dbc_eps_torque_factor = param; } static int toyota_fwd_hook(int bus_num, CAN_FIFOMailBox_TypeDef *to_fwd) { @@ -157,8 +158,8 @@ const safety_hooks toyota_hooks = { static void toyota_nolimits_init(int16_t param) { controls_allowed = 0; - actuation_limits = 0; - dbc_eps_torque_factor = param; + toyota_actuation_limits = 0; + toyota_dbc_eps_torque_factor = param; } const safety_hooks toyota_nolimits_hooks = { diff --git a/board/safety/safety_toyota_ipas.h b/board/safety/safety_toyota_ipas.h index 35b7e2b5974a64..dc265fa03e55c7 100644 --- a/board/safety/safety_toyota_ipas.h +++ b/board/safety/safety_toyota_ipas.h @@ -2,7 +2,7 @@ // TODO: refactor to repeat less code // IPAS override -const int32_t IPAS_OVERRIDE_THRESHOLD = 200; // disallow controls when user torque exceeds this value +const int32_t TOYOTA_IPAS_OVERRIDE_THRESHOLD = 200; // disallow controls when user torque exceeds this value struct lookup_t { float x[3]; @@ -92,7 +92,7 @@ static void toyota_ipas_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { // every RT_INTERVAL or when controls are turned on, set the new limits uint32_t ts_elapsed = get_ts_elapsed(ts, ts_angle_last); - if ((ts_elapsed > RT_INTERVAL) || (controls_allowed && !controls_allowed_last)) { + if ((ts_elapsed > TOYOTA_RT_INTERVAL) || (controls_allowed && !controls_allowed_last)) { rt_angle_last = angle_meas_new; ts_angle_last = ts; } @@ -118,8 +118,8 @@ static void toyota_ipas_rx_hook(CAN_FIFOMailBox_TypeDef *to_push) { } // exit controls on high steering override - if (angle_control && ((torque_driver.min > IPAS_OVERRIDE_THRESHOLD) || - (torque_driver.max < -IPAS_OVERRIDE_THRESHOLD) || + if (angle_control && ((torque_driver.min > TOYOTA_IPAS_OVERRIDE_THRESHOLD) || + (torque_driver.max < -TOYOTA_IPAS_OVERRIDE_THRESHOLD) || (ipas_state==5))) { controls_allowed = 0; } diff --git a/tests/safety/libpandasafety_py.py b/tests/safety/libpandasafety_py.py index 8840c66f315dd1..0af95ae47a4e3d 100644 --- a/tests/safety/libpandasafety_py.py +++ b/tests/safety/libpandasafety_py.py @@ -38,13 +38,13 @@ int get_controls_allowed(void); void init_tests_toyota(void); void set_timer(int t); -void set_torque_meas(int min, int max); +void set_toyota_torque_meas(int min, int max); void set_cadillac_torque_driver(int min, int max); void set_gm_torque_driver(int min, int max); -void set_rt_torque_last(int t); -void set_desired_torque_last(int t); -int get_torque_meas_min(void); -int get_torque_meas_max(void); +void set_toyota_rt_torque_last(int t); +void set_toyota_desired_torque_last(int t); +int get_toyota_torque_meas_min(void); +int get_toyota_torque_meas_max(void); void init_tests_honda(void); int get_ego_speed(void); diff --git a/tests/safety/test.c b/tests/safety/test.c index f0f2af506da58b..3d4288116e4a47 100644 --- a/tests/safety/test.c +++ b/tests/safety/test.c @@ -22,7 +22,7 @@ typedef struct uint32_t CNT; } TIM_TypeDef; -struct sample_t torque_meas; +struct sample_t toyota_torque_meas; struct sample_t cadillac_torque_driver; struct sample_t gm_torque_driver; @@ -60,9 +60,9 @@ void set_timer(int t){ timer.CNT = t; } -void set_torque_meas(int min, int max){ - torque_meas.min = min; - torque_meas.max = max; +void set_toyota_torque_meas(int min, int max){ + toyota_torque_meas.min = min; + toyota_torque_meas.max = max; } void set_cadillac_torque_driver(int min, int max){ @@ -75,16 +75,16 @@ void set_gm_torque_driver(int min, int max){ gm_torque_driver.max = max; } -int get_torque_meas_min(void){ - return torque_meas.min; +int get_toyota_torque_meas_min(void){ + return toyota_torque_meas.min; } -int get_torque_meas_max(void){ - return torque_meas.max; +int get_toyota_torque_meas_max(void){ + return toyota_torque_meas.max; } -void set_rt_torque_last(int t){ - rt_torque_last = t; +void set_toyota_rt_torque_last(int t){ + toyota_rt_torque_last = t; } void set_cadillac_rt_torque_last(int t){ @@ -95,8 +95,8 @@ void set_gm_rt_torque_last(int t){ gm_rt_torque_last = t; } -void set_desired_torque_last(int t){ - desired_torque_last = t; +void set_toyota_desired_torque_last(int t){ + toyota_desired_torque_last = t; } void set_cadillac_desired_torque_last(int t){ @@ -129,11 +129,11 @@ void set_bosch_hardware(bool c){ } void init_tests_toyota(void){ - torque_meas.min = 0; - torque_meas.max = 0; - desired_torque_last = 0; - rt_torque_last = 0; - ts_last = 0; + 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); } diff --git a/tests/safety/test_toyota.py b/tests/safety/test_toyota.py index ad86be63beb64b..b4d23af65df321 100644 --- a/tests/safety/test_toyota.py +++ b/tests/safety/test_toyota.py @@ -41,9 +41,9 @@ def setUp(cls): cls.safety.init_tests_toyota() def _set_prev_torque(self, t): - self.safety.set_desired_torque_last(t) - self.safety.set_rt_torque_last(t) - self.safety.set_torque_meas(t, 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) def _torque_meas_msg(self, torque): to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *') @@ -158,9 +158,9 @@ def test_torque_absolute_limits(self): 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_rt_torque_last(torque) - self.safety.set_torque_meas(torque, torque) - self.safety.set_desired_torque_last(torque - MAX_RATE_UP) + 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) if controls_allowed: send = (-MAX_TORQUE <= torque <= MAX_TORQUE) @@ -181,14 +181,14 @@ def test_non_realtime_limit_up(self): def test_non_realtime_limit_down(self): self.safety.set_controls_allowed(True) - self.safety.set_rt_torque_last(1000) - self.safety.set_torque_meas(500, 500) - self.safety.set_desired_torque_last(1000) + 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.assertTrue(self.safety.toyota_tx_hook(self._torque_msg(1000 - MAX_RATE_DOWN))) - self.safety.set_rt_torque_last(1000) - self.safety.set_torque_meas(500, 500) - self.safety.set_desired_torque_last(1000) + 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.assertFalse(self.safety.toyota_tx_hook(self._torque_msg(1000 - MAX_RATE_DOWN + 1))) def test_exceed_torque_sensor(self): @@ -210,14 +210,14 @@ def test_realtime_limit_up(self): self._set_prev_torque(0) for t in np.arange(0, 380, 10): t *= sign - self.safety.set_torque_meas(t, t) + self.safety.set_toyota_torque_meas(t, t) self.assertTrue(self.safety.toyota_tx_hook(self._torque_msg(t))) self.assertFalse(self.safety.toyota_tx_hook(self._torque_msg(sign * 380))) self._set_prev_torque(0) for t in np.arange(0, 370, 10): t *= sign - self.safety.set_torque_meas(t, t) + self.safety.set_toyota_torque_meas(t, t) self.assertTrue(self.safety.toyota_tx_hook(self._torque_msg(t))) # Increase timer to update rt_torque_last @@ -233,16 +233,16 @@ def test_torque_measurements(self): self.safety.toyota_rx_hook(self._torque_meas_msg(0)) self.safety.toyota_rx_hook(self._torque_meas_msg(0)) - self.assertEqual(-51, self.safety.get_torque_meas_min()) - self.assertEqual(51, self.safety.get_torque_meas_max()) + self.assertEqual(-51, self.safety.get_toyota_torque_meas_min()) + self.assertEqual(51, self.safety.get_toyota_torque_meas_max()) self.safety.toyota_rx_hook(self._torque_meas_msg(0)) - self.assertEqual(-1, self.safety.get_torque_meas_max()) - self.assertEqual(-51, self.safety.get_torque_meas_min()) + self.assertEqual(-1, self.safety.get_toyota_torque_meas_max()) + self.assertEqual(-51, self.safety.get_toyota_torque_meas_min()) self.safety.toyota_rx_hook(self._torque_meas_msg(0)) - self.assertEqual(-1, self.safety.get_torque_meas_max()) - self.assertEqual(-1, self.safety.get_torque_meas_min()) + self.assertEqual(-1, self.safety.get_toyota_torque_meas_max()) + self.assertEqual(-1, self.safety.get_toyota_torque_meas_min()) def test_ipas_override(self):