Squashed 'panda/' changes from 39c1e39e..06958e42

06958e42 Fix pedal bootstub build
f5817e6b Fix Pedal bootstub version
c00fe867 CircleCI needs to check bootstub doesn't break too
9b5b696e Subaru: remove GM leftover
20c76ad5 Power Saving (#169)
c6eeaad6 Subaru: added last engage/disengage regression test
37d46e0c Subaru: added subaru safety tests
5686dae2 Subaru updated driver factor
a6193a82 Dcp remove (#168)
e437b9b4 Subaru: fixed bug and added safety tests
176f1325 Subaru: added proper safety model
0b10bb70 Subaru safety: move camera to bus 2
bce279a6 Pedal: only one firmware (#164)
4f73cb48 Toyota pedal: checking for no pedal being commanded when openpilot is off
0b2327e5 Merge pull request #160 from commaai/capture_make_failure
7b504d2f panda safety test that replays drives of saved CAN messages (#151)
d7d08892 Capture make failure so it can be logged to sentry

git-subtree-dir: panda
git-subtree-split: 06958e424cad7efa3fb35d262480c29817733059

tests/safety/libpandasafety_py.py

@@ -30,25 +30,20 @@ typedef struct
   uint32_t CNT;
 } TIM_TypeDef;
 
+void set_controls_allowed(int c);
+int get_controls_allowed(void);
+void set_timer(int t);
+void reset_angle_control(void);
+
+void init_tests_toyota(void);
 void toyota_rx_hook(CAN_FIFOMailBox_TypeDef *to_push);
 int toyota_tx_hook(CAN_FIFOMailBox_TypeDef *to_send);
 void toyota_init(int16_t param);
-void set_controls_allowed(int c);
-void reset_angle_control(void);
-int get_controls_allowed(void);
-void init_tests_toyota(void);
-void set_timer(int t);
-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_hyundai_torque_driver(int min, int max);
-void set_chrysler_torque_meas(int min, int max);
-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);
-int get_chrysler_torque_meas_min(void);
-int get_chrysler_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_honda(void);
 int get_ego_speed(void);
@@ -66,6 +61,7 @@ void cadillac_rx_hook(CAN_FIFOMailBox_TypeDef *to_push);
 int cadillac_tx_hook(CAN_FIFOMailBox_TypeDef *to_send);
 void set_cadillac_desired_torque_last(int t);
 void set_cadillac_rt_torque_last(int t);
+void set_cadillac_torque_driver(int min, int max);
 
 void init_tests_gm(void);
 void gm_init(int16_t param);
@@ -73,6 +69,7 @@ void gm_rx_hook(CAN_FIFOMailBox_TypeDef *to_push);
 int gm_tx_hook(CAN_FIFOMailBox_TypeDef *to_send);
 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 nooutput_init(int16_t param);
@@ -80,6 +77,7 @@ void hyundai_rx_hook(CAN_FIFOMailBox_TypeDef *to_push);
 int hyundai_tx_hook(CAN_FIFOMailBox_TypeDef *to_send);
 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 toyota_ipas_rx_hook(CAN_FIFOMailBox_TypeDef *to_push);
 int toyota_ipas_tx_hook(CAN_FIFOMailBox_TypeDef *to_send);
@@ -89,6 +87,16 @@ void chrysler_rx_hook(CAN_FIFOMailBox_TypeDef *to_push);
 int chrysler_tx_hook(CAN_FIFOMailBox_TypeDef *to_send);
 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 subaru_rx_hook(CAN_FIFOMailBox_TypeDef *to_push);
+int subaru_tx_hook(CAN_FIFOMailBox_TypeDef *to_send);
+void set_subaru_desired_torque_last(int t);
+void set_subaru_rt_torque_last(int t);
+void set_subaru_torque_driver(int min, int max);
 
 
 """)

tests/safety/test.c

@@ -26,7 +26,8 @@ struct sample_t toyota_torque_meas;
 struct sample_t cadillac_torque_driver;
 struct sample_t gm_torque_driver;
 struct sample_t hyundai_torque_driver;
-struct sample_t chrysler_torque_driver;
+struct sample_t chrysler_torque_meas;
+struct sample_t subaru_torque_driver;
 
 TIM_TypeDef timer;
 TIM_TypeDef *TIM2 = &timer;
@@ -87,6 +88,11 @@ void set_chrysler_torque_meas(int min, int max){
   chrysler_torque_meas.max = max;
 }
 
+void set_subaru_torque_driver(int min, int max){
+  subaru_torque_driver.min = min;
+  subaru_torque_driver.max = max;
+}
+
 int get_chrysler_torque_meas_min(void){
   return chrysler_torque_meas.min;
 }
@@ -123,6 +129,10 @@ 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_toyota_desired_torque_last(int t){
   toyota_desired_torque_last = t;
 }
@@ -143,6 +153,10 @@ 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;
+}
+
 int get_ego_speed(void){
   return ego_speed;
 }
@@ -200,14 +214,23 @@ void init_tests_hyundai(void){
 }
 
 void init_tests_chrysler(void){
-  chrysler_torque_driver.min = 0;
-  chrysler_torque_driver.max = 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){
+  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_honda(void){
   ego_speed = 0;
   gas_interceptor_detected = 0;

tests/safety/test_chrysler.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python2
+import csv
+import glob
 import unittest
 import numpy as np
 import libpandasafety_py
@@ -24,6 +26,11 @@ def sign(a):
   else:
     return -1
 
+def swap_bytes(data_str):
+  """Accepts string with hex, returns integer with order swapped for CAN."""
+  a = int(data_str, 16)
+  return ((a & 0xff) << 24) + ((a & 0xff00) << 8) + ((a & 0x00ff0000) >> 8) + ((a & 0xff000000) >> 24)
+
 class TestChryslerSafety(unittest.TestCase):
   @classmethod
   def setUp(cls):
@@ -166,6 +173,33 @@ class TestChryslerSafety(unittest.TestCase):
     self.assertEqual(0, self.safety.get_chrysler_torque_meas_max())
     self.assertEqual(0, self.safety.get_chrysler_torque_meas_min())
 
+  def _replay_drive(self, csv_reader):
+    for row in csv_reader:
+      if len(row) != 4:  # sometimes truncated at end of the file
+        continue
+      if row[0] == 'time':  # skip CSV header
+        continue
+      addr = int(row[1])
+      bus = int(row[2])
+      data_str = row[3]  # Example '081407ff0806e06f'
+      to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+      to_send[0].RIR = addr << 21
+      to_send[0].RDHR = swap_bytes(data_str[8:])
+      to_send[0].RDLR = swap_bytes(data_str[:8])
+      if (bus == 128):
+        self.assertTrue(self.safety.chrysler_tx_hook(to_send), msg=row)
+      else:
+        self.safety.chrysler_rx_hook(to_send)
+
+  def test_replay_drive(self):
+    # In Cabana, click "Save Log" and then put the downloaded CSV in this directory.
+    test_files = glob.glob('chrysler_*.csv')
+    for filename in test_files:
+      print 'testing %s' % filename
+      with open(filename) as csvfile:
+        reader = csv.reader(csvfile)
+        self._replay_drive(reader)
+
 
 if __name__ == "__main__":
   unittest.main()

tests/safety/test_subaru.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_RATE_UP = 50
+MAX_RATE_DOWN = 70
+MAX_STEER = 2047
+
+MAX_RT_DELTA = 940
+RT_INTERVAL = 250000
+
+DRIVER_TORQUE_ALLOWANCE = 60;
+DRIVER_TORQUE_FACTOR = 10;
+
+def twos_comp(val, bits):
+  if val >= 0:
+    return val
+  else:
+    return (2**bits) + val
+
+def sign(a):
+  if a > 0:
+    return 1
+  else:
+    return -1
+
+class TestSubaruSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.nooutput_init(0)
+    cls.safety.init_tests_subaru()
+
+  def _set_prev_torque(self, t):
+    self.safety.set_subaru_desired_torque_last(t)
+    self.safety.set_subaru_rt_torque_last(t)
+
+  def _torque_driver_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x119 << 21
+
+    t = twos_comp(torque, 11)
+    to_send[0].RDLR = ((t & 0x7FF) << 16)
+    return to_send
+
+  def _torque_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x122 << 21
+
+    t = twos_comp(torque, 13)
+    to_send[0].RDLR = (t << 16)
+    return to_send
+
+  def test_default_controls_not_allowed(self):
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_enable_control_allowed_from_cruise(self):
+    to_push = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_push[0].RIR = 0x240 << 21
+    to_push[0].RDHR = 1 << 9
+
+    self.safety.subaru_rx_hook(to_push)
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_disable_control_allowed_from_cruise(self):
+    to_push = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_push[0].RIR = 0x240 << 21
+    to_push[0].RDHR = 0
+
+    self.safety.set_controls_allowed(1)
+    self.safety.subaru_rx_hook(to_push)
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_steer_safety_check(self):
+    for enabled in [0, 1]:
+      for t in range(-3000, 3000):
+        self.safety.set_controls_allowed(enabled)
+        self._set_prev_torque(t)
+        if abs(t) > MAX_STEER or (not enabled and abs(t) > 0):
+          self.assertFalse(self.safety.subaru_tx_hook(self._torque_msg(t)))
+        else:
+          self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(t)))
+
+  def test_manually_enable_controls_allowed(self):
+    self.safety.set_controls_allowed(1)
+    self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.set_controls_allowed(0)
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_non_realtime_limit_up(self):
+    self.safety.set_subaru_torque_driver(0, 0)
+    self.safety.set_controls_allowed(True)
+
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(MAX_RATE_UP)))
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(-MAX_RATE_UP)))
+
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.subaru_tx_hook(self._torque_msg(MAX_RATE_UP + 1)))
+    self.safety.set_controls_allowed(True)
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.subaru_tx_hook(self._torque_msg(-MAX_RATE_UP - 1)))
+
+  def test_non_realtime_limit_down(self):
+    self.safety.set_subaru_torque_driver(0, 0)
+    self.safety.set_controls_allowed(True)
+
+  def test_against_torque_driver(self):
+    self.safety.set_controls_allowed(True)
+
+    for sign in [-1, 1]:
+      for t in np.arange(0, DRIVER_TORQUE_ALLOWANCE + 1, 1):
+        t *= -sign
+        self.safety.set_subaru_torque_driver(t, t)
+        self._set_prev_torque(MAX_STEER * sign)
+        self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(MAX_STEER * sign)))
+
+      self.safety.set_subaru_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1)
+      self.assertFalse(self.safety.subaru_tx_hook(self._torque_msg(-MAX_STEER)))
+
+    # spot check some individual cases
+    for sign in [-1, 1]:
+      driver_torque = (DRIVER_TORQUE_ALLOWANCE + 10) * sign
+      torque_desired = (MAX_STEER - 10 * DRIVER_TORQUE_FACTOR) * sign
+      delta = 1 * sign
+      self._set_prev_torque(torque_desired)
+      self.safety.set_subaru_torque_driver(-driver_torque, -driver_torque)
+      self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(torque_desired)))
+      self._set_prev_torque(torque_desired + delta)
+      self.safety.set_subaru_torque_driver(-driver_torque, -driver_torque)
+      self.assertFalse(self.safety.subaru_tx_hook(self._torque_msg(torque_desired + delta)))
+
+      self._set_prev_torque(MAX_STEER * sign)
+      self.safety.set_subaru_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign)
+      self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg((MAX_STEER - MAX_RATE_DOWN) * sign)))
+      self._set_prev_torque(MAX_STEER * sign)
+      self.safety.set_subaru_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign)
+      self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(0)))
+      self._set_prev_torque(MAX_STEER * sign)
+      self.safety.set_subaru_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign)
+      self.assertFalse(self.safety.subaru_tx_hook(self._torque_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_subaru()
+      self._set_prev_torque(0)
+      self.safety.set_subaru_torque_driver(0, 0)
+      for t in np.arange(0, MAX_RT_DELTA, 1):
+        t *= sign
+        self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(t)))
+      self.assertFalse(self.safety.subaru_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA + 1))))
+
+      self._set_prev_torque(0)
+      for t in np.arange(0, MAX_RT_DELTA, 1):
+        t *= sign
+        self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(t)))
+
+      # Increase timer to update rt_torque_last
+      self.safety.set_timer(RT_INTERVAL + 1)
+      self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA - 1))))
+      self.assertTrue(self.safety.subaru_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA + 1))))
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_toyota.py

@@ -119,6 +119,13 @@ class TestToyotaSafety(unittest.TestCase):
     to_send[0].RDLR = (a & 0xFF) << 8 | (a >> 8)
     return to_send
 
+  def _gas_msg(self, gas):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x200 << 21
+    to_send[0].RDLR = gas
+
+    return to_send
+
   def test_default_controls_not_allowed(self):
     self.assertFalse(self.safety.get_controls_allowed())
 
@@ -409,6 +416,13 @@ class TestToyotaSafety(unittest.TestCase):
     # reset no angle control at the end of the test
     self.safety.reset_angle_control()
 
+  def test_gas_safety_check(self):
+    self.safety.set_controls_allowed(0)
+    self.assertTrue(self.safety.honda_tx_hook(self._gas_msg(0x0000)))
+    self.assertFalse(self.safety.honda_tx_hook(self._gas_msg(0x1000)))
+    self.safety.set_controls_allowed(1)
+    self.assertTrue(self.safety.honda_tx_hook(self._gas_msg(0x1000)))
+
 
 if __name__ == "__main__":
   unittest.main()

tests/safety/trim_csv.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python2
+
+# This trims CAN message CSV files to just the messages relevant for Panda testing.
+# Usage:
+# cat input.csv | ./trim_csv.py > output.csv
+import fileinput
+
+addr_to_keep = [544, 0x1f4, 0x292]  # For Chrysler, update to the addresses that matter for you.
+
+for line in fileinput.input():
+  line = line.strip()
+  cols = line.split(',')
+  if len(cols) != 4:
+    continue  # malformed, such as at the end or every 60s.
+  (_, addr, bus, _) = cols
+  if (addr == 'addr'):
+    continue
+  if (int(bus) == 128):  # Keep all messages sent by OpenPilot.
+    print line
+  elif (int(addr) in addr_to_keep):
+    print line