Squashed 'panda/' content from commit ae816c104

git-subtree-dir: panda
git-subtree-split: ae816c104a99a8cd4d508ccd6abdc7b93053529c

tests/all_wifi_test.py

@@ -0,0 +1,29 @@
+#!/usr/bin/python
+import requests
+import json
+from automated.helpers import _connect_wifi
+from panda import Panda
+from nose.tools import assert_equal
+
+if __name__ == "__main__":
+  print("Fetching latest firmware from github.com/commaai/panda-artifacts")
+  r = requests.get("https://raw.githubusercontent.com/commaai/panda-artifacts/master/latest.json")
+  latest_version = json.loads(r.text)['version']
+
+  for p in Panda.list():
+    dongle_id, pw = Panda(p).get_serial()
+    print dongle_id, pw
+    assert(dongle_id.isalnum())
+    _connect_wifi(dongle_id, pw)
+
+    r = requests.get("http://192.168.0.10/")
+    print r.text
+    wifi_dongle_id = r.text.split("ssid: panda-")[1].split("<br/>")[0]
+    st_version = r.text.split("st version:")[1].strip().split("<br/>")[0]
+    esp_version = r.text.split("esp version:")[1].strip().split("<br/>")[0]
+
+    assert_equal(str(dongle_id), wifi_dongle_id)
+    assert_equal(latest_version, st_version)
+    assert_equal(latest_version, esp_version)
+
+

tests/automated/0_builds.py

@@ -0,0 +1,9 @@
+import os
+from panda import build_st
+
+def test_build_panda():
+  build_st("obj/panda.bin")
+
+def test_build_bootstub_panda():
+  build_st("obj/bootstub.panda.bin")
+

tests/automated/1_program.py

@@ -0,0 +1,15 @@
+import os
+from panda import Panda
+from helpers import panda_color_to_serial, test_white_and_grey
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_recover(serial=None):
+  p = Panda(serial=serial)
+  assert p.recover(timeout=30)
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_flash(serial=None):
+  p = Panda(serial=serial)
+  p.flash()

tests/automated/2_usb_to_can.py

@@ -0,0 +1,199 @@
+from __future__ import print_function
+import os
+import sys
+import time
+from panda import Panda
+from nose.tools import assert_equal, assert_less, assert_greater
+from helpers import time_many_sends, connect_wo_esp, test_white_and_grey, panda_color_to_serial
+
+SPEED_NORMAL = 500
+SPEED_GMLAN = 33.3
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_can_loopback(serial=None):
+  p = connect_wo_esp(serial)
+
+  # enable output mode
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+  # enable CAN loopback mode
+  p.set_can_loopback(True)
+
+  if p.legacy:
+    busses = [0,1]
+  else:
+    busses = [0,1,2]
+
+  for bus in busses:
+    # set bus 0 speed to 250
+    p.set_can_speed_kbps(bus, 250)
+
+    # send a message on bus 0
+    p.can_send(0x1aa, "message", bus)
+
+    # confirm receive both on loopback and send receipt
+    time.sleep(0.05)
+    r = p.can_recv()
+    sr = filter(lambda x: x[3] == 0x80 | bus, r)
+    lb = filter(lambda x: x[3] == bus, r)
+    assert len(sr) == 1
+    assert len(lb) == 1
+
+    # confirm data is correct
+    assert 0x1aa == sr[0][0] == lb[0][0]
+    assert "message" == sr[0][2] == lb[0][2]
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_safety_nooutput(serial=None):
+  p = connect_wo_esp(serial)
+
+  # enable output mode
+  p.set_safety_mode(Panda.SAFETY_NOOUTPUT)
+
+  # enable CAN loopback mode
+  p.set_can_loopback(True)
+
+  # send a message on bus 0
+  p.can_send(0x1aa, "message", 0)
+
+  # confirm receive nothing
+  time.sleep(0.05)
+  r = p.can_recv()
+  assert len(r) == 0
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_reliability(serial=None):
+  p = connect_wo_esp(serial)
+
+  LOOP_COUNT = 100
+  MSG_COUNT = 100
+
+  # enable output mode
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+  p.set_can_loopback(True)
+  p.set_can_speed_kbps(0, 1000)
+
+  addrs = range(100, 100+MSG_COUNT)
+  ts = [(j, 0, "\xaa"*8, 0) for j in addrs]
+
+  # 100 loops
+  for i in range(LOOP_COUNT):
+    st = time.time()
+
+    p.can_send_many(ts)
+
+    r = []
+    while len(r) < 200 and (time.time() - st) < 0.5:
+      r.extend(p.can_recv())
+
+    sent_echo = filter(lambda x: x[3] == 0x80, r)
+    loopback_resp = filter(lambda x: x[3] == 0, r)
+
+    assert_equal(sorted(map(lambda x: x[0], loopback_resp)), addrs)
+    assert_equal(sorted(map(lambda x: x[0], sent_echo)), addrs)
+    assert_equal(len(r), 200)
+
+    # take sub 20ms
+    et = (time.time()-st)*1000.0
+    assert_less(et, 20)
+
+    sys.stdout.write("P")
+    sys.stdout.flush()
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_throughput(serial=None):
+  p = connect_wo_esp(serial)
+
+  # enable output mode
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+  # enable CAN loopback mode
+  p.set_can_loopback(True)
+
+  for speed in [100,250,500,750,1000]:
+    # set bus 0 speed to speed
+    p.set_can_speed_kbps(0, speed)
+    time.sleep(0.05)
+
+    comp_kbps = time_many_sends(p, 0)
+
+    # bit count from https://en.wikipedia.org/wiki/CAN_bus
+    saturation_pct = (comp_kbps/speed) * 100.0
+    assert_greater(saturation_pct, 80)
+    assert_less(saturation_pct, 100)
+
+    print("loopback 100 messages at speed %d, comp speed is %.2f, percent %.2f" % (speed, comp_kbps, saturation_pct))
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_gmlan(serial=None):
+  p = connect_wo_esp(serial)
+
+  if p.legacy:
+    return
+
+  # enable output mode
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+  # enable CAN loopback mode
+  p.set_can_loopback(True)
+
+  p.set_can_speed_kbps(1, SPEED_NORMAL)
+  p.set_can_speed_kbps(2, SPEED_NORMAL)
+  p.set_can_speed_kbps(3, SPEED_GMLAN)
+
+  # set gmlan on CAN2
+  for bus in [Panda.GMLAN_CAN2, Panda.GMLAN_CAN3, Panda.GMLAN_CAN2, Panda.GMLAN_CAN3]:
+    p.set_gmlan(bus)
+    comp_kbps_gmlan = time_many_sends(p, 3)
+    assert_greater(comp_kbps_gmlan, 0.8 * SPEED_GMLAN)
+    assert_less(comp_kbps_gmlan, 1.0 * SPEED_GMLAN)
+
+    p.set_gmlan(None)
+    comp_kbps_normal = time_many_sends(p, bus)
+    assert_greater(comp_kbps_normal, 0.8 * SPEED_NORMAL)
+    assert_less(comp_kbps_normal, 1.0 * SPEED_NORMAL)
+
+    print("%d: %.2f kbps vs %.2f kbps" % (bus, comp_kbps_gmlan, comp_kbps_normal))
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_gmlan_bad_toggle(serial=None):
+  p = connect_wo_esp(serial)
+
+  if p.legacy:
+    return
+
+  # enable output mode
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+  # enable CAN loopback mode
+  p.set_can_loopback(True)
+
+  # GMLAN_CAN2
+  for bus in [Panda.GMLAN_CAN2, Panda.GMLAN_CAN3]:
+    p.set_gmlan(bus)
+    comp_kbps_gmlan = time_many_sends(p, 3)
+    assert_greater(comp_kbps_gmlan, 0.6 * SPEED_GMLAN)
+    assert_less(comp_kbps_gmlan, 1.0 * SPEED_GMLAN)
+
+  # normal
+  for bus in [Panda.GMLAN_CAN2, Panda.GMLAN_CAN3]:
+    p.set_gmlan(None)
+    comp_kbps_normal = time_many_sends(p, bus)
+    assert_greater(comp_kbps_normal, 0.6 * SPEED_NORMAL)
+    assert_less(comp_kbps_normal, 1.0 * SPEED_NORMAL)
+
+
+# this will fail if you have hardware serial connected
+@test_white_and_grey
+@panda_color_to_serial
+def test_serial_debug(serial=None):
+  p = connect_wo_esp(serial)
+  junk = p.serial_read(Panda.SERIAL_DEBUG)
+  p.call_control_api(0xc0)
+  assert(p.serial_read(Panda.SERIAL_DEBUG).startswith("can "))

tests/automated/3_wifi.py

@@ -0,0 +1,60 @@
+from __future__ import print_function
+import os
+import time
+from panda import Panda
+from helpers import connect_wifi, test_white, test_white_and_grey, panda_color_to_serial
+import requests
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_get_serial(serial=None):
+  p = Panda(serial)
+  print(p.get_serial())
+
+@test_white_and_grey
+@panda_color_to_serial
+def test_get_serial_in_flash_mode(serial=None):
+  p = Panda(serial)
+  p.reset(enter_bootstub=True)
+  assert(p.bootstub)
+  print(p.get_serial())
+  p.reset()
+
+@test_white
+@panda_color_to_serial
+def test_connect_wifi(serial=None):
+  connect_wifi(serial)
+
+@test_white
+@panda_color_to_serial
+def test_flash_wifi(serial=None):
+  connect_wifi(serial)
+  assert Panda.flash_ota_wifi(release=False), "OTA Wifi Flash Failed"
+  connect_wifi(serial)
+
+@test_white
+@panda_color_to_serial
+def test_wifi_flash_st(serial=None):
+  connect_wifi(serial)
+  assert Panda.flash_ota_st(), "OTA ST Flash Failed"
+  connected = False
+  st = time.time()
+  while not connected and (time.time() - st) < 20:
+    try:
+      p = Panda(serial=serial)
+      p.get_serial()
+      connected = True
+    except:
+      time.sleep(1)
+
+  if not connected:
+    assert False, "Panda failed to connect on USB after flashing"
+
+@test_white
+@panda_color_to_serial
+def test_webpage_fetch(serial=None):
+  connect_wifi(serial)
+  r = requests.get("http://192.168.0.10/")
+  print(r.text)
+
+  assert "This is your comma.ai panda" in r.text

tests/automated/4_wifi_functionality.py

@@ -0,0 +1,59 @@
+from __future__ import print_function
+import time
+from panda import Panda
+from helpers import time_many_sends, connect_wifi, test_white, panda_color_to_serial
+from nose.tools import timed, assert_equal, assert_less, assert_greater
+
+@test_white
+@panda_color_to_serial
+def test_get_serial_wifi(serial=None):
+  connect_wifi(serial)
+
+  p = Panda("WIFI")
+  print(p.get_serial())
+
+@test_white
+@panda_color_to_serial
+def test_throughput(serial=None):
+  connect_wifi(serial)
+  p = Panda(serial)
+
+  # enable output mode
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+  # enable CAN loopback mode
+  p.set_can_loopback(True)
+
+  p = Panda("WIFI")
+
+  for speed in [100,250,500,750,1000]:
+    # set bus 0 speed to speed
+    p.set_can_speed_kbps(0, speed)
+    time.sleep(0.1)
+
+    comp_kbps = time_many_sends(p, 0)
+
+    # bit count from https://en.wikipedia.org/wiki/CAN_bus
+    saturation_pct = (comp_kbps/speed) * 100.0
+    #assert_greater(saturation_pct, 80)
+    #assert_less(saturation_pct, 100)
+
+    print("WIFI loopback 100 messages at speed %d, comp speed is %.2f, percent %.2f" % (speed, comp_kbps, saturation_pct))
+
+@test_white
+@panda_color_to_serial
+def test_recv_only(serial=None):
+  connect_wifi(serial)
+  p = Panda(serial)
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+  p.set_can_loopback(True)
+  pwifi = Panda("WIFI")
+
+  # TODO: msg_count=1000 drops packets, is this fixable?
+  for msg_count in [10,100,200]:
+    speed = 500
+    p.set_can_speed_kbps(0, speed)
+    comp_kbps = time_many_sends(p, 0, pwifi, msg_count)
+    saturation_pct = (comp_kbps/speed) * 100.0
+
+    print("HT WIFI loopback %d messages at speed %d, comp speed is %.2f, percent %.2f" % (msg_count, speed, comp_kbps, saturation_pct))

tests/automated/5_wifi_udp.py

@@ -0,0 +1,66 @@
+from __future__ import print_function
+import sys
+import time
+from helpers import time_many_sends, connect_wifi, test_white, panda_color_to_serial
+from panda import Panda, PandaWifiStreaming
+from nose.tools import timed, assert_equal, assert_less, assert_greater
+
+@test_white
+@panda_color_to_serial
+def test_udp_doesnt_drop(serial=None):
+  connect_wifi(serial)
+
+  p = Panda(serial)
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+  p.set_can_loopback(True)
+
+  pwifi = PandaWifiStreaming()
+  while 1:
+    if len(pwifi.can_recv()) == 0:
+      break
+
+  for msg_count in [1, 100]:
+    saturation_pcts = []
+    for i in range({1: 0x80, 100: 0x20}[msg_count]):
+      pwifi.kick()
+
+      speed = 500
+      p.set_can_speed_kbps(0, speed)
+      comp_kbps = time_many_sends(p, 0, pwifi, msg_count=msg_count, msg_id=0x100+i)
+      saturation_pct = (comp_kbps/speed) * 100.0
+
+      if msg_count == 1:
+        sys.stdout.write(".")
+        sys.stdout.flush()
+      else:
+        print("UDP WIFI loopback %d messages at speed %d, comp speed is %.2f, percent %.2f" % (msg_count, speed, comp_kbps, saturation_pct))
+        assert_greater(saturation_pct, 15) #sometimes the wifi can be slow...
+        assert_less(saturation_pct, 100)
+        saturation_pcts.append(saturation_pct)
+    if len(saturation_pcts) > 0:
+      assert_greater(sum(saturation_pcts)/len(saturation_pcts), 60)
+
+  time.sleep(5)
+  usb_ok_cnt = 0
+  REQ_USB_OK_CNT = 500
+  st = time.time()
+  msg_id = 0x1bb
+  bus = 0
+  last_missing_msg = 0
+  while usb_ok_cnt < REQ_USB_OK_CNT and (time.time() - st) < 40:
+    p.can_send(msg_id, "message", bus)
+    time.sleep(0.01)
+    r = [1]
+    missing = True
+    while len(r) > 0:
+      r = p.can_recv()
+      r = filter(lambda x: x[3] == bus and x[0] == msg_id, r)
+      if len(r) > 0:
+        missing = False
+        usb_ok_cnt += len(r)
+      if missing:
+        last_missing_msg = time.time()
+  et = time.time() - st
+  last_missing_msg = last_missing_msg - st
+  print("waited {} for panda to recv can on usb, {} msgs, last missing at {}".format(et, usb_ok_cnt, last_missing_msg))
+  assert usb_ok_cnt >= REQ_USB_OK_CNT, "Unable to recv can on USB after UDP"

tests/automated/6_two_panda.py

@@ -0,0 +1,121 @@
+from __future__ import print_function
+import time
+from panda import Panda
+from nose.tools import assert_equal, assert_less, assert_greater
+from helpers import time_many_sends, test_two_panda, panda_color_to_serial
+
+@test_two_panda
+@panda_color_to_serial
+def test_send_recv(serial_sender=None, serial_reciever=None):
+  p_send = Panda(serial_sender)
+  p_recv = Panda(serial_reciever)
+
+  p_send.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+  p_send.set_can_loopback(False)
+
+  p_recv.set_can_loopback(False)
+
+  assert not p_send.legacy
+  assert not p_recv.legacy
+
+  p_send.can_send_many([(0x1ba, 0, "message", 0)]*2)
+  time.sleep(0.05)
+  p_recv.can_recv()
+  p_send.can_recv()
+
+  busses = [0,1,2]
+
+  for bus in busses:
+    for speed in [100, 250, 500, 750, 1000]:
+      p_send.set_can_speed_kbps(bus, speed)
+      p_recv.set_can_speed_kbps(bus, speed)
+      time.sleep(0.05)
+
+      comp_kbps = time_many_sends(p_send, bus, p_recv, two_pandas=True)
+
+      saturation_pct = (comp_kbps/speed) * 100.0
+      assert_greater(saturation_pct, 80)
+      assert_less(saturation_pct, 100)
+
+      print("two pandas bus {}, 100 messages at speed {:4d}, comp speed is {:7.2f}, percent {:6.2f}".format(bus, speed, comp_kbps, saturation_pct))
+
+@test_two_panda
+@panda_color_to_serial
+def test_latency(serial_sender=None, serial_reciever=None):
+  p_send = Panda(serial_sender)
+  p_recv = Panda(serial_reciever)
+
+  p_send.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+  p_send.set_can_loopback(False)
+
+  p_recv.set_can_loopback(False)
+
+  assert not p_send.legacy
+  assert not p_recv.legacy
+
+  p_send.set_can_speed_kbps(0, 100)
+  p_recv.set_can_speed_kbps(0, 100)
+  time.sleep(0.05)
+
+  p_send.can_send_many([(0x1ba, 0, "testmsg", 0)]*10)
+  time.sleep(0.05)
+  p_recv.can_recv()
+  p_send.can_recv()
+
+  busses = [0,1,2]
+
+  for bus in busses:
+    for speed in [100, 250, 500, 750, 1000]:
+      p_send.set_can_speed_kbps(bus, speed)
+      p_recv.set_can_speed_kbps(bus, speed)
+      time.sleep(0.1)
+      #clear can buffers
+      r = [1]
+      while len(r) > 0:
+        r = p_send.can_recv()
+      r = [1]
+      while len(r) > 0:
+        r = p_recv.can_recv()
+      time.sleep(0.05)
+
+      latencies = []
+      comp_kbps_list = []
+      saturation_pcts = []
+
+      num_messages = 100
+
+      for i in range(num_messages):
+        st = time.time()
+        p_send.can_send(0x1ab, "message", bus)
+        r = []
+        while len(r) < 1 and (time.time() - st) < 5:
+          r = p_recv.can_recv()
+        et = time.time()
+        r_echo = []
+        while len(r_echo) < 1 and (time.time() - st) < 10:
+          r_echo = p_send.can_recv()
+
+        if len(r) == 0 or len(r_echo) == 0:
+          print("r: {}, r_echo: {}".format(r, r_echo))
+
+        assert_equal(len(r),1)
+        assert_equal(len(r_echo),1)
+
+        et = (et - st)*1000.0
+        comp_kbps = (1+11+1+1+1+4+8*8+15+1+1+1+7) / et
+        latency = et - ((1+11+1+1+1+4+8*8+15+1+1+1+7) / speed)
+
+        assert_less(latency, 5.0)
+
+        saturation_pct = (comp_kbps/speed) * 100.0
+        latencies.append(latency)
+        comp_kbps_list.append(comp_kbps)
+        saturation_pcts.append(saturation_pct)
+
+      average_latency = sum(latencies)/num_messages
+      assert_less(average_latency, 1.0)
+      average_comp_kbps = sum(comp_kbps_list)/num_messages
+      average_saturation_pct = sum(saturation_pcts)/num_messages
+
+      print("two pandas bus {}, {} message average at speed {:4d}, latency is {:5.3f}ms, comp speed is {:7.2f}, percent {:6.2f}"\
+            .format(bus, num_messages, speed, average_latency, average_comp_kbps, average_saturation_pct))

tests/automated/helpers.py

@@ -0,0 +1,192 @@
+import os
+import sys
+import time
+import random
+import subprocess
+import requests
+from functools import wraps
+from panda import Panda
+from nose.tools import timed, assert_equal, assert_less, assert_greater
+from parameterized import parameterized, param
+
+test_white_and_grey = parameterized([param(panda_color="White"),
+                                     param(panda_color="Grey")])
+test_white = parameterized([param(panda_color="White")])
+test_grey = parameterized([param(panda_color="Grey")])
+test_two_panda = parameterized([param(panda_color=["Grey", "White"]),
+                                param(panda_color=["White", "Grey"])])
+
+_serials = {}
+def get_panda_serial(is_grey=None):
+  global _serials
+  if is_grey not in _serials:
+    for serial in Panda.list():
+      p = Panda(serial=serial)
+      if is_grey is None or p.is_grey() == is_grey:
+        _serials[is_grey] = serial
+        return serial
+    raise IOError("Panda not found. is_grey: {}".format(is_grey))
+  else:
+    return _serials[is_grey]
+
+def connect_wo_esp(serial=None):
+  # connect to the panda
+  p = Panda(serial=serial)
+
+  # power down the ESP
+  p.set_esp_power(False)
+
+  # clear old junk
+  while len(p.can_recv()) > 0:
+    pass
+
+  return p
+
+def connect_wifi(serial=None):
+  p = Panda(serial=serial)
+  p.set_esp_power(True)
+  dongle_id, pw = p.get_serial()
+  assert(dongle_id.isalnum())
+  _connect_wifi(dongle_id, pw)
+
+FNULL = open(os.devnull, 'w')
+def _connect_wifi(dongle_id, pw, insecure_okay=False):
+  ssid = str("panda-" + dongle_id)
+
+  r = subprocess.call(["ping", "-W", "4", "-c", "1", "192.168.0.10"], stdout=FNULL, stderr=subprocess.STDOUT)
+  if not r:
+    #Can already ping, try connecting on wifi
+    try:
+      p = Panda("WIFI")
+      p.get_serial()
+      print("Already connected")
+      return
+    except:
+      pass
+
+  print("WIFI: connecting to %s" % ssid)
+
+  while 1:
+    if sys.platform == "darwin":
+      os.system("networksetup -setairportnetwork en0 %s %s" % (ssid, pw))
+    else:
+      wlan_interface = subprocess.check_output(["sh", "-c", "iw dev | awk '/Interface/ {print $2}'"]).strip()
+      cnt = 0
+      MAX_TRIES = 10
+      while cnt < MAX_TRIES:
+        print("WIFI: scanning %d" % cnt)
+        os.system("iwlist %s scanning > /dev/null" % wlan_interface)
+        os.system("nmcli device wifi rescan")
+        wifi_scan = filter(lambda x: ssid in x, subprocess.check_output(["nmcli","dev", "wifi", "list"]).split("\n"))
+        if len(wifi_scan) != 0:
+          break
+        time.sleep(0.1)
+        # MAX_TRIES tries, ~10 seconds max
+        cnt += 1
+      assert cnt < MAX_TRIES
+      if "-pair" in wifi_scan[0]:
+        os.system("nmcli d wifi connect %s-pair" % (ssid))
+        connect_cnt = 0
+        MAX_TRIES = 20
+        while connect_cnt < MAX_TRIES:
+          connect_cnt += 1
+          r = subprocess.call(["ping", "-W", "4", "-c", "1", "192.168.0.10"], stdout=FNULL, stderr=subprocess.STDOUT)
+          if r:
+            print("Waiting for panda to ping...")
+            time.sleep(0.1)
+          else:
+            break
+        if insecure_okay:
+          break
+        # fetch webpage
+        print("connecting to insecure network to secure")
+        try:
+          r = requests.get("http://192.168.0.10/")
+        except requests.ConnectionError:
+          r = requests.get("http://192.168.0.10/")
+        assert r.status_code==200
+
+        print("securing")
+        try:
+          r = requests.get("http://192.168.0.10/secure", timeout=0.01)
+        except requests.exceptions.Timeout:
+          print("timeout http request to secure")
+          pass
+      else:
+        ret = os.system("nmcli d wifi connect %s password %s" % (ssid, pw))
+        if os.WEXITSTATUS(ret) == 0:
+          #check ping too
+          ping_ok = False
+          connect_cnt = 0
+          MAX_TRIES = 10
+          while connect_cnt < MAX_TRIES:
+            connect_cnt += 1
+            r = subprocess.call(["ping", "-W", "4", "-c", "1", "192.168.0.10"], stdout=FNULL, stderr=subprocess.STDOUT)
+            if r:
+              print("Waiting for panda to ping...")
+              time.sleep(0.1)
+            else:
+              ping_ok = True
+              break
+          if ping_ok:
+            break
+
+  # TODO: confirm that it's connected to the right panda
+
+def time_many_sends(p, bus, precv=None, msg_count=100, msg_id=None, two_pandas=False):
+  if precv == None:
+    precv = p
+  if msg_id == None:
+    msg_id = random.randint(0x100, 0x200)
+  if p == precv and two_pandas:
+    raise ValueError("Cannot have two pandas that are the same panda")
+
+  st = time.time()
+  p.can_send_many([(msg_id, 0, "\xaa"*8, bus)]*msg_count)
+  r = []
+  r_echo = []
+  r_len_expected = msg_count if two_pandas else msg_count*2
+  r_echo_len_exected = msg_count if two_pandas else 0
+
+  while len(r) < r_len_expected and (time.time() - st) < 5:
+    r.extend(precv.can_recv())
+  et = time.time()
+  if two_pandas:
+    while len(r_echo) < r_echo_len_exected and (time.time() - st) < 10:
+      r_echo.extend(p.can_recv())
+
+  sent_echo = filter(lambda x: x[3] == 0x80 | bus and x[0] == msg_id, r)
+  sent_echo.extend(filter(lambda x: x[3] == 0x80 | bus and x[0] == msg_id, r_echo))
+  resp = filter(lambda x: x[3] == bus and x[0] == msg_id, r)
+
+  leftovers = filter(lambda x: (x[3] != 0x80 | bus and x[3] != bus) or x[0] != msg_id, r)
+  assert_equal(len(leftovers), 0)
+
+  assert_equal(len(resp), msg_count)
+  assert_equal(len(sent_echo), msg_count)
+
+  et = (et-st)*1000.0
+  comp_kbps = (1+11+1+1+1+4+8*8+15+1+1+1+7)*msg_count / et
+
+  return comp_kbps
+
+
+def panda_color_to_serial(fn):
+  @wraps(fn)
+  def wrapper(panda_color=None, **kwargs):
+    pandas_is_grey = []
+    if panda_color is not None:
+      if not isinstance(panda_color, list):
+        panda_color = [panda_color]
+      panda_color = [s.lower() for s in panda_color]
+    for p in panda_color:
+      if p is None:
+        pandas_is_grey.append(None)
+      elif p in ["grey", "gray"]:
+        pandas_is_grey.append(True)
+      elif p in ["white"]:
+        pandas_is_grey.append(False)
+      else:
+        raise ValueError("Invalid Panda Color {}".format(p))
+    return fn(*[get_panda_serial(is_grey) for is_grey in pandas_is_grey], **kwargs)
+  return wrapper

tests/build/Dockerfile

@@ -0,0 +1,17 @@
+FROM ubuntu:16.04
+
+RUN apt-get update && apt-get install -y gcc-arm-none-eabi libnewlib-arm-none-eabi python python-pip gcc g++ git autoconf gperf bison flex automake texinfo wget help2man gawk libtool libtool-bin ncurses-dev unzip unrar-free libexpat-dev sed bzip2
+
+RUN pip install pycrypto==2.6.1
+
+# Build esp toolchain
+RUN mkdir -p /panda/boardesp
+WORKDIR /panda/boardesp
+RUN git clone --recursive https://github.com/pfalcon/esp-open-sdk.git
+WORKDIR /panda/boardesp/esp-open-sdk
+RUN git checkout 03f5e898a059451ec5f3de30e7feff30455f7ce
+RUN CT_ALLOW_BUILD_AS_ROOT_SURE=1 make STANDALONE=y
+
+COPY . /panda
+
+WORKDIR /panda

tests/build_strict/Dockerfile

@@ -0,0 +1,9 @@
+FROM ubuntu:16.04
+
+RUN apt-get update && apt-get install -y gcc-arm-none-eabi libnewlib-arm-none-eabi python python-pip gcc g++
+
+RUN pip install pycrypto==2.6.1
+
+COPY . /panda
+
+WORKDIR /panda

tests/build_strict/test_build_strict.sh

@@ -0,0 +1,15 @@
+#!/bin/bash -e
+
+cd ../../board/
+
+make -f Makefile.strict clean
+make -f Makefile.strict bin 2> compiler_output.txt
+
+
+if [[ -s "compiler_output.txt" ]]
+then
+  echo "Found alerts from the compiler:"
+  cat compiler_output.txt
+  exit 1
+fi
+      

tests/can_printer.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os
+import sys
+import time
+from collections import defaultdict
+import binascii
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda
+
+# fake
+def sec_since_boot():
+  return time.time()
+
+def can_printer():
+  p = Panda()
+  p.set_safety_mode(0x1337)
+
+  start = sec_since_boot()
+  lp = sec_since_boot()
+  msgs = defaultdict(list)
+  canbus = int(os.getenv("CAN", 0))
+  while True:
+    can_recv = p.can_recv()
+    for address, _, dat, src  in can_recv:
+      if src == canbus:
+        msgs[address].append(dat)
+
+    if sec_since_boot() - lp > 0.1:
+      dd = chr(27) + "[2J"
+      dd += "%5.2f\n" % (sec_since_boot() - start)
+      for k,v in sorted(zip(msgs.keys(), map(lambda x: binascii.hexlify(x[-1]), msgs.values()))):
+        dd += "%s(%6d) %s\n" % ("%04X(%4d)" % (k,k),len(msgs[k]), v)
+      print(dd)
+      lp = sec_since_boot()
+
+if __name__ == "__main__":
+  can_printer()

tests/debug_console.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os
+import sys
+import time
+import select
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda
+
+setcolor = ["\033[1;32;40m", "\033[1;31;40m"]
+unsetcolor = "\033[00m"
+
+if __name__ == "__main__":
+  port_number = int(os.getenv("PORT", 0))
+  claim = os.getenv("CLAIM") is not None
+
+  serials = Panda.list()
+  if os.getenv("SERIAL"):
+    serials = filter(lambda x: x==os.getenv("SERIAL"), serials)
+
+  pandas = list(map(lambda x: Panda(x, claim=claim), serials))
+
+  if not len(pandas):
+    sys.exit("no pandas found")
+
+  if os.getenv("BAUD") is not None:
+    for panda in pandas:
+      panda.set_uart_baud(port_number, int(os.getenv("BAUD")))
+
+  while True:
+    for i, panda in enumerate(pandas):
+      while True:
+        ret = panda.serial_read(port_number)
+        if len(ret) > 0:
+          sys.stdout.write(setcolor[i] + str(ret) + unsetcolor)
+          sys.stdout.flush()
+        else:
+          break
+      if select.select([sys.stdin], [], [], 0) == ([sys.stdin], [], []):
+        ln = sys.stdin.readline()
+        if claim:
+          panda.serial_write(port_number, ln)
+      time.sleep(0.01)

tests/disable_esp.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+from panda import Panda
+Panda().set_esp_power(False)
+

tests/elm_car_simulator.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python
+"""Used to Reverse/Test ELM protocol auto detect and OBD message response without a car."""
+from __future__ import print_function
+import sys
+import os
+import struct
+import binascii
+import time
+import threading
+from collections import deque
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda
+
+def lin_checksum(dat):
+    return sum(dat) % 0x100
+
+class ELMCarSimulator():
+    def __init__(self, sn, silent=False, can_kbaud=500,
+                 can=True, can11b=True, can29b=True,
+                 lin=True):
+        self.__p = Panda(sn if sn else Panda.list()[0])
+        self.__on = True
+        self.__stop = False
+        self.__silent = silent
+
+        self.__lin_timer = None
+        self.__lin_active = False
+        self.__lin_enable = lin
+        self.__lin_monitor_thread = threading.Thread(target=self.__lin_monitor)
+
+        self.__can_multipart_data = None
+        self.__can_kbaud = can_kbaud
+        self.__can_extra_noise_msgs = deque()
+        self.__can_enable = can
+        self.__can11b = can11b
+        self.__can29b = can29b
+        self.__can_monitor_thread = threading.Thread(target=self.__can_monitor)
+
+    @property
+    def panda(self):
+        return self.__p
+
+    def stop(self):
+        if self.__lin_timer:
+            self.__lin_timer.cancel()
+            self.__lin_timeout_handler()
+
+        self.__stop = True
+
+    def join(self):
+        if self.__lin_monitor_thread.is_alive():
+            self.__lin_monitor_thread.join()
+        if self.__can_monitor_thread.is_alive():
+            self.__can_monitor_thread.join()
+        if self.__p:
+            print("closing handle")
+            self.__p.close()
+
+    def set_enable(self, on):
+        self.__on = on
+
+    def start(self):
+        self.panda.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+        if self.__lin_enable:
+            self.__lin_monitor_thread.start()
+        if self.__can_enable:
+            self.__can_monitor_thread.start()
+
+    #########################
+    # LIN related functions #
+    #########################
+
+    def __lin_monitor(self):
+        print("STARTING LIN THREAD")
+        self.panda.set_uart_baud(2, 10400)
+        self.panda.kline_drain() # Toss whatever was already there
+
+        lin_buff = bytearray()
+
+        while not self.__stop:
+            lin_msg = self.panda.serial_read(2)
+            if not lin_msg:
+                continue
+
+            lin_buff += lin_msg
+            #print("    ** Buff", lin_buff)
+            if lin_buff.endswith(b'\x00\xc1\x33\xf1\x81\x66'): # Leading 0 is wakeup
+                lin_buff = bytearray()
+                self.__lin_active = True
+                print("GOT LIN (KWP FAST) WAKEUP SIGNAL")
+                self._lin_send(0x10, b'\xC1\x8F\xE9')
+                self.__reset_lin_timeout()
+                continue
+            if self.__lin_active:
+                msglen = lin_buff[0] & 0x7
+                if lin_buff[0] & 0xF8 not in (0x80, 0xC0):
+                    print("Invalid bytes at start of message")
+                    print("    BUFF", lin_buff)
+                    continue
+                if len(lin_buff) < msglen + 4: continue
+                if lin_checksum(lin_buff[:-1]) != lin_buff[-1]: continue
+                self.__lin_process_msg(lin_buff[0] & 0xF8, #Priority
+                                       lin_buff[1], lin_buff[2], lin_buff[3:-1])
+                lin_buff = bytearray()
+
+    def _lin_send(self, to_addr, msg):
+        if not self.__silent:
+            print("    LIN Reply (%x)" % to_addr, binascii.hexlify(msg))
+
+        PHYS_ADDR = 0x80
+        FUNC_ADDR = 0xC0
+        RECV = 0xF1
+        SEND = 0x33 # Car OBD Functional Address
+        headers = struct.pack("BBB", PHYS_ADDR | len(msg), RECV, to_addr)
+        if not self.__silent:
+            print("    Sending LIN", binascii.hexlify(headers+msg),
+                  hex(sum(bytearray(headers+msg))%0x100))
+        self.panda.kline_send(headers + msg)
+
+    def __reset_lin_timeout(self):
+        if self.__lin_timer:
+            self.__lin_timer.cancel()
+        self.__lin_timer = threading.Timer(5, self.__lin_timeout_handler)
+        self.__lin_timer.start()
+
+    def __lin_timeout_handler(self):
+        print("LIN TIMEOUT")
+        self.__lin_timer = None
+        self.__lin_active = False
+
+    @property
+    def lin_active(self):
+        return self.__lin_active
+
+    def __lin_process_msg(self, priority, toaddr, fromaddr, data):
+        self.__reset_lin_timeout()
+
+        if not self.__silent and data != b'\x3E':
+            print("LIN MSG", "Addr:", hex(toaddr), "obdLen:", len(data),
+                  binascii.hexlify(data))
+
+        outmsg = None
+        #if data == b'\x3E':
+        #    print("KEEP ALIVE")
+        #el
+        if len(data) > 1:
+            outmsg = self._process_obd(data[0], data[1])
+
+        if outmsg:
+            obd_header = struct.pack("BB", 0x40 | data[0], data[1])
+            if len(outmsg) <= 5:
+                self._lin_send(0x10, obd_header + outmsg)
+            else:
+                first_msg_len = MIN(4, len(outmsg)%4) or 4
+                self._lin_send(0x10, obd_header + b'\x01' +
+                               b'\x00'*(4-first_msg_len) +
+                               outmsg[:first_msg_len])
+
+                for num, i in enumerate(range(first_msg_len, len(outmsg), 4)):
+                    self._lin_send(0x10, obd_header +
+                                   struct.pack('B', (num+2)%0x100) + outmsg[i:i+4])
+
+    #########################
+    # CAN related functions #
+    #########################
+
+    def __can_monitor(self):
+        print("STARTING CAN THREAD")
+        self.panda.set_can_speed_kbps(0, self.__can_kbaud)
+        self.panda.can_recv() # Toss whatever was already there
+
+        while not self.__stop:
+            for address, ts, data, src in self.panda.can_recv():
+                if self.__on and src is 0 and len(data) == 8 and data[0] >= 2:
+                    if not self.__silent:
+                        print("Processing CAN message", src, hex(address), binascii.hexlify(data))
+                    self.__can_process_msg(data[1], data[2], address, ts, data, src)
+                elif not self.__silent:
+                    print("Rejecting CAN message", src, hex(address), binascii.hexlify(data))
+
+    def can_mode_11b(self):
+        self.__can11b = True
+        self.__can29b = False
+
+    def can_mode_29b(self):
+        self.__can11b = False
+        self.__can29b = True
+
+    def can_mode_11b_29b(self):
+        self.__can11b = True
+        self.__can29b = True
+
+    def change_can_baud(self, kbaud):
+        self.__can_kbaud = kbaud
+        self.panda.set_can_speed_kbps(0, self.__can_kbaud)
+
+    def can_add_extra_noise(self, noise_msg, addr=None):
+        self.__can_extra_noise_msgs.append((addr, noise_msg))
+
+    def _can_send(self, addr, msg):
+        if not self.__silent:
+            print("    CAN Reply (%x)" % addr, binascii.hexlify(msg))
+        self.panda.can_send(addr, msg + b'\x00'*(8-len(msg)), 0)
+        if self.__can_extra_noise_msgs:
+            noise = self.__can_extra_noise_msgs.popleft()
+            self.panda.can_send(noise[0] if noise[0] is not None else addr,
+                             noise[1] + b'\x00'*(8-len(noise[1])), 0)
+
+    def _can_addr_matches(self, addr):
+        if self.__can11b and (addr == 0x7DF or (addr & 0x7F8) == 0x7E0):
+            return True
+        if self.__can29b and (addr == 0x18db33f1 or (addr & 0x1FFF00FF) == 0x18da00f1):
+            return True
+        return False
+
+    def __can_process_msg(self, mode, pid, address, ts, data, src):
+        if not self.__silent:
+            print("CAN MSG", binascii.hexlify(data[1:1+data[0]]),
+                  "Addr:", hex(address), "Mode:", hex(mode)[2:].zfill(2),
+                  "PID:", hex(pid)[2:].zfill(2), "canLen:", len(data),
+                  binascii.hexlify(data))
+
+        if self._can_addr_matches(address) and len(data) == 8:
+            outmsg = None
+            if data[:3] == b'\x30\x00\x00' and len(self.__can_multipart_data):
+                if not self.__silent:
+                    print("Request for more data");
+                outaddr = 0x7E8 if address == 0x7DF or address == 0x7E0 else 0x18DAF110
+                msgnum = 1
+                while(self.__can_multipart_data):
+                    datalen = MIN(7, len(self.__can_multipart_data))
+                    msgpiece = struct.pack("B", 0x20 | msgnum) + self.__can_multipart_data[:datalen]
+                    self._can_send(outaddr, msgpiece)
+                    self.__can_multipart_data = self.__can_multipart_data[7:]
+                    msgnum = (msgnum+1)%0x10
+                    time.sleep(0.01)
+
+            else:
+                outmsg = self._process_obd(mode, pid)
+
+            if outmsg:
+                outaddr = 0x7E8 if address == 0x7DF or address == 0x7E0 else 0x18DAF110
+
+                if len(outmsg) <= 5:
+                    self._can_send(outaddr,
+                                   struct.pack("BBB", len(outmsg)+2, 0x40|data[1], pid) + outmsg)
+                else:
+                    first_msg_len = MIN(3, len(outmsg)%7)
+                    payload_len = len(outmsg)+3
+                    msgpiece = struct.pack("BBBBB", 0x10 | ((payload_len>>8)&0xF),
+                                           payload_len&0xFF,
+                                           0x40|data[1], pid, 1) + outmsg[:first_msg_len]
+                    self._can_send(outaddr, msgpiece)
+                    self.__can_multipart_data = outmsg[first_msg_len:]
+
+    #########################
+    # General OBD functions #
+    #########################
+
+    def _process_obd(self, mode, pid):
+        if mode == 0x01: # Mode: Show current data
+            if pid == 0x00:   #List supported things
+                return b"\xff\xff\xff\xfe"#b"\xBE\x1F\xB8\x10" #Bitfield, random features
+            elif pid == 0x01: # Monitor Status since DTC cleared
+                return b"\x00\x00\x00\x00" #Bitfield, random features
+            elif pid == 0x04: # Calculated engine load
+                return b"\x2f"
+            elif pid == 0x05: # Engine coolant temperature
+                return b"\x3c"
+            elif pid == 0x0B: # Intake manifold absolute pressure
+                return b"\x90"
+            elif pid == 0x0C: # Engine RPM
+                return b"\x1A\xF8"
+            elif pid == 0x0D: # Vehicle Speed
+                return b"\x53"
+            elif pid == 0x10: # MAF air flow rate
+                return b"\x01\xA0"
+            elif pid == 0x11: # Throttle Position
+                return b"\x90"
+            elif pid == 0x33: # Absolute Barometric Pressure
+                return b"\x90"
+        elif mode == 0x09: # Mode: Request vehicle information
+            if pid == 0x02:   # Show VIN
+                return b"1D4GP00R55B123456"
+            if pid == 0xFC:   # test long multi message. Ligned up for LIN responses
+                return b''.join((struct.pack(">BBH", 0xAA, 0xAA, num+1) for num in range(80)))
+            if pid == 0xFD:   # test long multi message
+                parts = (b'\xAA\xAA\xAA' + struct.pack(">I", num) for num in range(80))
+                return b'\xAA\xAA\xAA' + b''.join(parts)
+            if pid == 0xFE:   # test very long multi message
+                parts = (b'\xAA\xAA\xAA' + struct.pack(">I", num) for num in range(584))
+                return b'\xAA\xAA\xAA' + b''.join(parts) + b'\xAA'
+            if pid == 0xFF:
+                return b'\xAA\x00\x00' +\
+                        b"".join(((b'\xAA'*5)+struct.pack(">H", num+1) for num in range(584)))
+                #return b"\xAA"*100#(0xFFF-3)
+
+
+if __name__ == "__main__":
+    serial = os.getenv("SERIAL") if os.getenv("SERIAL") else None
+    kbaud = int(os.getenv("CANKBAUD")) if os.getenv("CANKBAUD") else 500
+    bitwidth = int(os.getenv("CANBITWIDTH")) if os.getenv("CANBITWIDTH") else 0
+    canenable = bool(int(os.getenv("CANENABLE"))) if os.getenv("CANENABLE") else True
+    linenable = bool(int(os.getenv("LINENABLE"))) if os.getenv("LINENABLE") else True
+    sim = ELMCarSimulator(serial, can_kbaud=kbaud, can=canenable, lin=linenable)
+    if(bitwidth == 0):
+        sim.can_mode_11b_29b()
+    if(bitwidth == 11):
+        sim.can_mode_11b()
+    if(bitwidth == 29):
+        sim.can_mode_29b()
+
+    import signal
+    def signal_handler(signal, frame):
+        print('\nShutting down simulator')
+        sim.stop()
+        sim.join()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+
+    sim.start()
+
+    signal.pause()

tests/elm_throughput.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import socket
+import threading
+import select
+
+class Reader(threading.Thread):
+    def __init__(self, s, *args, **kwargs):
+        super(Reader, self).__init__(*args, **kwargs)
+        self._s = s
+        self.__stop = False
+
+    def stop(self):
+        self.__stop = True
+
+    def run(self):
+        while not self.__stop:
+            s.recv(1000)
+
+def read_or_fail(s):
+    ready = select.select([s], [], [], 4)
+    assert ready[0], "Socket did not receive data within the timeout duration."
+    return s.recv(1000)
+
+def send_msg(s, msg):
+    s.send(msg)
+    res = b''
+    while not res.endswith(">"):
+        res += read_or_fail(s)
+    return res
+
+if __name__ == "__main__":
+    s = socket.create_connection(("192.168.0.10", 35000))
+    #t1 = Reader(s)
+    #t1.start()
+    send_msg(s, b"ATZ\r")
+    send_msg(s, b"ATL1\r")
+    print(send_msg(s, b"ATE0\r"))
+    print(send_msg(s, b"ATS0\r"))
+    print(send_msg(s, b"ATSP6\r"))
+
+    print("\nLOOP\n")
+
+    while True:
+        print(send_msg(s, b"0100\r"))
+        print(send_msg(s, b"010d\r"))

tests/elm_wifi.py

@@ -0,0 +1,669 @@
+from __future__ import print_function
+import os
+import sys
+import time
+import socket
+import select
+import pytest
+import struct
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+import elm_car_simulator
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", ".."))
+from panda import Panda
+
+def elm_connect():
+    s = socket.create_connection(("192.168.0.10", 35000))
+    s.setblocking(0)
+    return s
+
+def read_or_fail(s):
+    ready = select.select([s], [], [], 4)
+    assert ready[0], "Socket did not receive data within the timeout duration."
+    return s.recv(1000)
+
+def sendrecv(s, dat):
+    s.send(dat)
+    return read_or_fail(s)
+
+def send_compare(s, dat, ret, timeout=4):
+    s.send(dat)
+    res = b''
+    while ret.startswith(res) and ret != res:
+        print("Waiting")
+        ready = select.select([s], [], [], timeout)
+        if not ready[0]:
+            print("current recv data:", repr(res))
+            break;
+        res += s.recv(1000)
+    #print("final recv data: '%s'" % repr(res))
+    assert ret == res#, "Data does not agree (%s) (%s)"%(repr(ret), repr(res))
+
+def sync_reset(s):
+    s.send("ATZ\r")
+    res = b''
+    while not res.endswith("ELM327 v1.5\r\r>"):
+        res += read_or_fail(s)
+        print("Reset response is '%s'" % repr(res))
+
+def test_reset():
+    s = socket.create_connection(("192.168.0.10", 35000))
+    s.setblocking(0)
+
+    try:
+        sync_reset(s)
+    finally:
+        s.close()
+
+def test_elm_cli():
+    s = elm_connect()
+
+    try:
+        sync_reset(s)
+
+        send_compare(s, b'ATI\r', b'ATI\rELM327 v1.5\r\r>')
+
+        #Test Echo Off
+        #Expected to be misimplimentation, but this is how the reference device behaved.
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') #Here is the odd part
+        send_compare(s, b'ATE0\r', b'OK\r\r>')       #Should prob show this immediately
+        send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>')
+
+        #Test Newline On
+        send_compare(s, b'ATL1\r', b'OK\r\n\r\n>')
+        send_compare(s, b'ATI\r', b'ELM327 v1.5\r\n\r\n>')
+        send_compare(s, b'ATL0\r', b'OK\r\r>')
+        send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>')
+
+        send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>') #Test repeat command no echo
+        send_compare(s, b'\r', b'ELM327 v1.5\r\r>')
+
+        send_compare(s, b'aTi\r', b'ELM327 v1.5\r\r>') #Test different case
+
+        send_compare(s, b'  a     T i\r', b'ELM327 v1.5\r\r>') #Test with white space
+
+        send_compare(s, b'ATCATHAT\r', b'?\r\r>') #Test Invalid AT command
+
+        send_compare(s, b'01 00 00 00 00 00 00 00\r', b'?\r\r>') #Test Invalid (too long) OBD command
+        send_compare(s, b'01 GZ\r', b'?\r\r>') #Test Invalid (Non hex chars) OBD command
+    finally:
+        s.close()
+
+def test_elm_setget_protocol():
+    s = elm_connect()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+
+        send_compare(s, b'ATSP0\r', b"OK\r\r>") # Set auto
+        send_compare(s, b'ATDP\r', b"AUTO\r\r>")
+        send_compare(s, b'ATDPN\r', b"A0\r\r>")
+
+        send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set protocol
+        send_compare(s, b'ATDP\r', b"ISO 15765-4 (CAN 11/500)\r\r>")
+        send_compare(s, b'ATDPN\r', b"6\r\r>")
+
+        send_compare(s, b'ATSPA6\r', b"OK\r\r>") # Set auto with protocol default
+        send_compare(s, b'ATDP\r', b"AUTO, ISO 15765-4 (CAN 11/500)\r\r>")
+        send_compare(s, b'ATDPN\r', b"A6\r\r>")
+
+        send_compare(s, b'ATSP7\r', b"OK\r\r>")
+        send_compare(s, b'ATDP\r', b"ISO 15765-4 (CAN 29/500)\r\r>")
+        send_compare(s, b'ATDPN\r', b"7\r\r>") #Test Does not accept invalid protocols
+        send_compare(s, b'ATSPD\r', b"?\r\r>")
+        send_compare(s, b'ATDP\r', b"ISO 15765-4 (CAN 29/500)\r\r>")
+        send_compare(s, b'ATDPN\r', b"7\r\r>")
+    finally:
+        s.close()
+
+def test_elm_protocol_failure():
+    s = elm_connect()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+
+        send_compare(s, b'ATSP0\r', b"OK\r\r>")
+        send_compare(s, b'0100\r', b"SEARCHING...\rUNABLE TO CONNECT\r\r>", timeout=10)
+
+        send_compare(s, b'ATSP1\r', b"OK\r\r>")
+        send_compare(s, b'0100\r', b"NO DATA\r\r>")
+
+        send_compare(s, b'ATSP2\r', b"OK\r\r>")
+        send_compare(s, b'0100\r', b"NO DATA\r\r>")
+
+        send_compare(s, b'ATSP3\r', b"OK\r\r>")
+        send_compare(s, b'0100\r', b"BUS INIT: ...ERROR\r\r>")
+
+        send_compare(s, b'ATSP4\r', b"OK\r\r>")
+        send_compare(s, b'0100\r', b"BUS INIT: ...ERROR\r\r>")
+
+        send_compare(s, b'ATSP5\r', b"OK\r\r>")
+        send_compare(s, b'0100\r', b"BUS INIT: ERROR\r\r>")
+
+        #send_compare(s, b'ATSP6\r', b"OK\r\r>")
+        #send_compare(s, b'0100\r', b"NO DATA\r\r>")
+        #
+        #send_compare(s, b'ATSP7\r', b"OK\r\r>")
+        #send_compare(s, b'0100\r', b"NO DATA\r\r>")
+        #
+        #send_compare(s, b'ATSP8\r', b"OK\r\r>")
+        #send_compare(s, b'0100\r', b"NO DATA\r\r>")
+        #
+        #send_compare(s, b'ATSP9\r', b"OK\r\r>")
+        #send_compare(s, b'0100\r', b"NO DATA\r\r>")
+        #
+        #send_compare(s, b'ATSPA\r', b"OK\r\r>")
+        #send_compare(s, b'0100\r', b"NO DATA\r\r>")
+        #
+        #send_compare(s, b'ATSPB\r', b"OK\r\r>")
+        #send_compare(s, b'0100\r', b"NO DATA\r\r>")
+        #
+        #send_compare(s, b'ATSPC\r', b"OK\r\r>")
+        #send_compare(s, b'0100\r', b"NO DATA\r\r>")
+    finally:
+        s.close()
+
+def test_elm_protocol_autodetect_ISO14230_KWP_FAST():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, can=False)#, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers ON
+        send_compare(s, b'ATS0\r', b"OK\r\r>")
+
+        send_compare(s, b'ATSP0\r', b"OK\r\r>")
+        send_compare(s, b'010D\r', b"SEARCHING...\r410D53\r\r>", timeout=10)
+        send_compare(s, b'ATDPN\r', b"A5\r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_basic_send_lin():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, can=False)#, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto
+
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'0100\r', b"BUS INIT: OK\r41 00 FF FF FF FE \r\r>")
+        send_compare(s, b'010D\r', b"41 0D 53 \r\r>")
+
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces Off
+        send_compare(s, b'0100\r', b"4100FFFFFFFE\r\r>")
+        send_compare(s, b'010D\r', b"410D53\r\r>")
+
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Spaces Off Headers On
+        send_compare(s, b'0100\r', b"86F1104100FFFFFFFEC3\r\r>")
+        send_compare(s, b'010D\r', b"83F110410D5325\r\r>")
+
+        send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces On Headers On
+        send_compare(s, b'0100\r', b"86 F1 10 41 00 FF FF FF FE C3 \r\r>")
+        send_compare(s, b'010D\r', b"83 F1 10 41 0D 53 25 \r\r>")
+
+        send_compare(s, b'1F00\r', b"NO DATA\r\r>") # Unhandled msg, no response.
+
+        # Repeat last check to see if it still works after NO DATA was received
+        send_compare(s, b'0100\r', b"86 F1 10 41 00 FF FF FF FE C3 \r\r>")
+        send_compare(s, b'010D\r', b"83 F1 10 41 0D 53 25 \r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_send_lin_multiline_msg():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, can=False)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATSP5\r', b"OK\r\r>") # Set Proto
+
+        send_compare(s, b'0902\r', # headers OFF, Spaces ON
+                     b"BUS INIT: OK\r"
+                     "49 02 01 00 00 00 31 \r"
+                     "49 02 02 44 34 47 50 \r"
+                     "49 02 03 30 30 52 35 \r"
+                     "49 02 04 35 42 31 32 \r"
+                     "49 02 05 33 34 35 36 \r\r>")
+
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'0902\r', # Headers OFF, Spaces OFF
+                     b"49020100000031\r"
+                     "49020244344750\r"
+                     "49020330305235\r"
+                     "49020435423132\r"
+                     "49020533343536\r\r>")
+
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON
+        send_compare(s, b'0902\r', # Headers ON, Spaces OFF
+                     b"87F1104902010000003105\r"
+                     "87F11049020244344750E4\r"
+                     "87F11049020330305235BD\r"
+                     "87F11049020435423132B1\r"
+                     "87F11049020533343536AA\r\r>")
+
+        send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON
+        send_compare(s, b'0902\r', # Headers ON, Spaces ON
+                     b"87 F1 10 49 02 01 00 00 00 31 05 \r"
+                     "87 F1 10 49 02 02 44 34 47 50 E4 \r"
+                     "87 F1 10 49 02 03 30 30 52 35 BD \r"
+                     "87 F1 10 49 02 04 35 42 31 32 B1 \r"
+                     "87 F1 10 49 02 05 33 34 35 36 AA \r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_send_lin_multiline_msg_throughput():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, can=False, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF
+
+        send_compare(s, b'09fc\r', # headers OFF, Spaces OFF
+                     b"BUS INIT: OK\r" +
+                     b''.join((b'49FC' + hex(num+1)[2:].upper().zfill(2) +
+                               b'AAAA' + hex(num+1)[2:].upper().zfill(4) + b'\r'
+                               for num in range(80))) +
+                     b"\r>",
+                     timeout=10
+        )
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_panda_safety_mode_KWPFast():
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    p_car = Panda(serial) # Configure this so the messages will send
+    p_car.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+    p_car.kline_drain()
+
+    p_elm = Panda("WIFI")
+    p_elm.set_safety_mode(0xE327);
+
+    def get_checksum(dat):
+        result = 0
+        result += sum(map(ord, dat)) if isinstance(b'dat', str) else sum(dat)
+        return struct.pack("B", result % 0x100)
+
+    def timed_recv_check(p, bus, goodmsg):
+        t = time.time()
+        msg = bytearray()
+
+        while time.time()-t < 0.5 and len(msg) != len(goodmsg):
+            msg += p._handle.controlRead(Panda.REQUEST_OUT, 0xe0, bus, 0, len(goodmsg)-len(msg))
+            #print("Received", repr(msg))
+            if msg == goodmsg:
+                return True
+            time.sleep(0.01)
+        return False
+
+    def kline_send(p, x, bus=2):
+        p.kline_drain(bus=bus)
+        p._handle.bulkWrite(2, chr(bus).encode()+x)
+        return timed_recv_check(p, bus, x)
+
+    def did_send(priority, toaddr, fromaddr, dat, bus=2, checkbyte=None):
+        msgout = struct.pack("BBB", priority | len(dat), toaddr, fromaddr) + dat
+        msgout += get_checksum(msgout) if checkbyte is None else checkbyte
+        print("Sending", hex(priority), hex(toaddr), hex(fromaddr), repr(msgout))
+
+        if not kline_send(p_elm, msgout, bus=bus):
+            return False
+        return timed_recv_check(p_car, bus, msgout)
+
+    assert not did_send(0xC0, 0x33, 0xF1, b'\x01\x0F', bus=3) #wrong bus
+    assert not did_send(0xC0, 0x33, 0xF1, b'') #wrong length
+    assert not did_send(0xB0, 0x33, 0xF1, b'\x01\x0E') #bad priority
+    assert not did_send(0xC0, 0x00, 0xF1, b'\x01\x0D') #bad addr
+    assert not did_send(0xC0, 0x33, 0x00, b'\x01\x0C') #bad addr
+
+    assert did_send(0xC0, 0x33, 0xF1, b'\x01\x0B') #good! (obd func req)
+
+def test_elm_lin_keepalive():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, can=False, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF
+
+        send_compare(s, b'0100\r', b"BUS INIT: OK\r4100FFFFFFFE\r\r>")
+        assert sim.lin_active
+        time.sleep(6)
+        assert sim.lin_active
+
+        send_compare(s, b'ATPC\r', b"OK\r\r>") #STOP KEEPALIVE
+        assert sim.lin_active
+        time.sleep(6)
+        assert not sim.lin_active
+
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+#////////////
+def test_elm_protocol_autodetect_ISO15765():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON
+        send_compare(s, b'ATS0\r', b"OK\r\r>")
+
+        sim.can_mode_11b()
+        send_compare(s, b'ATSP0\r', b"OK\r\r>")
+        send_compare(s, b'010D\r', b"SEARCHING...\r7E803410D53\r\r>", timeout=10)
+        send_compare(s, b'ATDPN\r', b"A6\r\r>")
+
+        sim.can_mode_29b()
+        send_compare(s, b'ATSP0\r', b"OK\r\r>")
+        send_compare(s, b'010D\r', b"SEARCHING...\r18DAF11003410D53\r\r>", timeout=10)
+        send_compare(s, b'ATDPN\r', b"A7\r\r>")
+
+        sim.change_can_baud(250)
+
+        sim.can_mode_11b()
+        send_compare(s, b'ATSP0\r', b"OK\r\r>")
+        send_compare(s, b'010D\r', b"SEARCHING...\r7E803410D53\r\r>", timeout=10)
+        send_compare(s, b'ATDPN\r', b"A8\r\r>")
+
+        sim.can_mode_29b()
+        send_compare(s, b'ATSP0\r', b"OK\r\r>")
+        send_compare(s, b'010D\r', b"SEARCHING...\r18DAF11003410D53\r\r>", timeout=10)
+        send_compare(s, b'ATDPN\r', b"A9\r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_basic_send_can():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto
+
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'0100\r', b"41 00 FF FF FF FE \r\r>")
+        send_compare(s, b'010D\r', b"41 0D 53 \r\r>")
+
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces Off
+        send_compare(s, b'0100\r', b"4100FFFFFFFE\r\r>")
+        send_compare(s, b'010D\r', b"410D53\r\r>")
+
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Spaces Off Headers On
+        send_compare(s, b'0100\r', b"7E8064100FFFFFFFE\r\r>")
+        send_compare(s, b'010D\r', b"7E803410D53\r\r>")
+
+        send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces On Headers On
+        send_compare(s, b'0100\r', b"7E8 06 41 00 FF FF FF FE \r\r>")
+        send_compare(s, b'010D\r', b"7E8 03 41 0D 53 \r\r>")
+
+        send_compare(s, b'1F00\r', b"NO DATA\r\r>") # Unhandled msg, no response.
+
+        # Repeat last check to see if it still works after NO DATA was received
+        send_compare(s, b'0100\r', b"7E8 06 41 00 FF FF FF FE \r\r>")
+        send_compare(s, b'010D\r', b"7E8 03 41 0D 53 \r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_send_can_multimsg():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON
+
+        send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500)
+        sim.can_add_extra_noise(b'\x03\x41\x0D\xFA', addr=0x7E9)# Inject message into the stream
+        send_compare(s, b'010D\r',
+                     b"7E8 03 41 0D 53 \r"
+                     "7E9 03 41 0D FA \r\r>") # Check it was ignored.
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+"""The ability to correctly filter out messages with the wrong PID is not
+implemented correctly in the reference device."""
+def test_elm_can_check_mode_pid():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF
+
+        send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500)
+        sim.can_add_extra_noise(b'\x03\x41\x0E\xFA')# Inject message into the stream
+        send_compare(s, b'010D\r', b"410D53\r\r>") # Check it was ignored.
+        send_compare(s, b'0100\r', b"4100FFFFFFFE\r\r>") # Check it was ignored again.
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_send_can_multiline_msg():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+
+        send_compare(s, b'0902\r', # headers OFF, Spaces ON
+                     b"014 \r"
+                     "0: 49 02 01 31 44 34 \r"
+                     "1: 47 50 30 30 52 35 35 \r"
+                     "2: 42 31 32 33 34 35 36 \r\r>")
+
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'0902\r', # Headers OFF, Spaces OFF
+                     b"014\r"
+                     "0:490201314434\r"
+                     "1:47503030523535\r"
+                     "2:42313233343536\r\r>")
+
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON
+        send_compare(s, b'0902\r', # Headers ON, Spaces OFF
+                     b"7E81014490201314434\r"
+                     "7E82147503030523535\r"
+                     "7E82242313233343536\r\r>")
+
+        send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON
+        send_compare(s, b'0902\r', # Headers ON, Spaces ON
+                     b"7E8 10 14 49 02 01 31 44 34 \r"
+                     "7E8 21 47 50 30 30 52 35 35 \r"
+                     "7E8 22 42 31 32 33 34 35 36 \r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_send_can_multiline_msg_throughput():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON
+
+        rows = 584
+        send_compare(s, b'09ff\r', # headers ON, Spaces OFF
+                     ("7E8" + "1" + hex((rows*7)+6)[2:].upper().zfill(3) + "49FF01"+"AA0000\r" +
+                      "".join(
+                          ("7E82"+hex((num+1)%0x10)[2:].upper()+("AA"*5) +
+                           hex(num+1)[2:].upper().zfill(4) + "\r" for num in range(rows))
+                      ) + "\r>").encode(),
+                     timeout=10
+        )
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_interrupted_obd_cmd_resets_state():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False, silent=True)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        s.send(b"09fd\r")
+        ready = select.select([s], [], [], 4)
+        assert ready[0], "Socket did not receive data within the timeout duration."
+        s.send(b"ATI\r")
+
+        assert b"236\r0:49FD01AAAAAA\r" in s.recv(10000)
+
+        #Will likely have to be improved to scan for STOPPED if the FW gets more responsive.
+        ready = select.select([s], [], [], 4)
+        assert ready[0], "Socket did not receive data within the timeout duration."
+
+        assert b"STOPPED" in s.recv(10000)
+
+        sim.set_enable(False)
+        send_compare(s, b'09fd\r', b"NO DATA\r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_can_baud():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    sim = elm_car_simulator.ELMCarSimulator(serial, lin=False)
+    sim.start()
+
+    try:
+        sync_reset(s)
+        send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF
+        send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
+        send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON
+
+        send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500)
+        send_compare(s, b'0100\r', b"7E8064100FFFFFFFE\r\r>")
+
+        send_compare(s, b'ATSP8\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/250)
+        send_compare(s, b'0100\r', b"CAN ERROR\r\r>")
+
+        sim.change_can_baud(250)
+
+        send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500)
+        send_compare(s, b'0100\r', b"CAN ERROR\r\r>")
+
+        send_compare(s, b'ATSP8\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/250)
+        send_compare(s, b'0100\r', b"7E8064100FFFFFFFE\r\r>")
+    finally:
+        sim.stop()
+        sim.join()
+        s.close()
+
+def test_elm_panda_safety_mode_ISO15765():
+    s = elm_connect()
+    serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None
+    p_car = Panda(serial) # Configure this so the messages will send
+    p_car.set_can_speed_kbps(0, 500)
+    p_car.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+    p_elm = Panda("WIFI")
+    p_elm.set_safety_mode(0xE327);
+
+    #sim = elm_car_simulator.ELMCarSimulator(serial, lin=False)
+    #sim.start()
+
+    def did_send(p, addr, dat, bus):
+        p.can_send(addr, dat, bus)
+        t = time.time()
+        while time.time()-t < 0.5:
+            msg = p.can_recv()
+            for addrin, _, datin, busin in msg:
+                if (0x80 | bus) == busin and addr == addrin and datin == dat:
+                    return True
+            time.sleep(0.01)
+        return False
+
+    try:
+        sync_reset(s) # Reset elm (which requests the ELM327 safety mode)
+
+        #29 bit
+        assert not did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 1) #wrong canid
+        assert not did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00', 0) #wrong length
+        assert not did_send(p_elm, 0x10000000, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr
+        assert not did_send(p_elm, 0x18DAF133, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr (phy addr)
+        assert not did_send(p_elm, 0x18DAF000, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr
+        assert not did_send(p_elm, 0x18DAF1F3, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr! (phys rsp to elm)
+
+        assert did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (obd func req)
+        assert did_send(p_elm, 0x18DA10F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (phys response)
+
+        #11 bit
+        assert not did_send(p_elm, 0X7DF, b'\x02\x01\x00\x00\x00\x00\x00\x00', 1) #wrong canid
+        assert not did_send(p_elm, 0X7DF, b'\x02\x01\x00', 0) #wrong length
+        assert not did_send(p_elm, 0xAA, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr
+        assert not did_send(p_elm, 0x7DA, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr (phy addr)
+        assert not did_send(p_elm, 0x7E8, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr (sending 'response')
+
+        assert did_send(p_elm, 0x7DF, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (obd func req)
+        assert did_send(p_elm, 0x7E1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (phys response)
+
+    finally:
+        s.close()

tests/flashing_loop.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+cd ../board
+make clean
+
+while true; do
+  make ota
+  sleep 10
+done
+

tests/get_version.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+from panda import Panda
+
+if __name__ == "__main__":
+  for p in Panda.list():
+    pp = Panda(p)
+    print("%s: %s" % (pp.get_serial()[0], pp.get_version()))
+
+

tests/gmbitbang/recv.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+import time
+from panda import Panda
+
+p = Panda()
+p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+p.set_gmlan(bus=2)
+#p.can_send(0xaaa, "\x00\x00", bus=3)
+last_add = None
+while 1:
+  ret = p.can_recv()
+  if len(ret) > 0:
+    add = ret[0][0]
+    if last_add is not None and add != last_add+1:
+      print "MISS %d %d" % (last_add, add)
+    last_add = add
+    print ret

tests/gmbitbang/rigol.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+import numpy as np
+import visa
+import matplotlib.pyplot as plt
+
+resources = visa.ResourceManager()
+print resources.list_resources()
+
+scope = resources.open_resource('USB0::0x1AB1::0x04CE::DS1ZA184652242::INSTR', timeout=2000, chunk_size=1024000)
+print(scope.query('*IDN?').strip())
+
+#voltscale = scope.ask_for_values(':CHAN1:SCAL?')[0]
+#voltoffset = scope.ask_for_values(":CHAN1:OFFS?")[0]
+
+#scope.write(":STOP")
+scope.write(":WAV:POIN:MODE RAW")
+scope.write(":WAV:DATA? CHAN1")[10:]
+rawdata = scope.read_raw()
+data = np.frombuffer(rawdata, 'B')
+print data.shape
+
+s1 = data[0:650]
+s2 = data[650:]
+s1i = np.argmax(s1 > 100)
+s2i = np.argmax(s2 > 100)
+s1 = s1[s1i:]
+s2 = s2[s2i:]
+
+plt.plot(s1)
+plt.plot(s2)
+plt.show()
+#data = (data - 130.0 - voltoffset/voltscale*25) / 25 * voltscale
+
+print data
+

tests/gmbitbang/test.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+import time
+from panda import Panda
+
+p1 = Panda('380016000551363338383037')
+p2 = Panda('430026000951363338383037')
+
+# this is a test, no safety
+p1.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+p2.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+# get versions
+print(p1.get_version())
+print(p2.get_version())
+
+# this sets bus 2 to actually be GMLAN
+p2.set_gmlan(bus=2)
+
+# send w bitbang then without
+#iden = 123
+iden = 18000
+#dat = "\x01\x02"
+dat = "\x01\x02\x03\x04\x05\x06\x07\x08"
+while 1:
+  iden += 1
+  p1.set_gmlan(bus=None)
+  p1.can_send(iden, dat, bus=3)
+  #p1.set_gmlan(bus=2)
+  #p1.can_send(iden, dat, bus=3)
+  time.sleep(0.01)
+  print p2.can_recv()
+  #exit(0)
+

tests/gmbitbang/test_one.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+import time
+from panda import Panda
+
+p = Panda()
+p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+# ack any crap on bus
+p.set_gmlan(bus=2)
+time.sleep(0.1)
+while len(p.can_recv()) > 0:
+  print "clearing"
+  time.sleep(0.1)
+print "cleared"
+p.set_gmlan(bus=None)
+
+iden = 18000
+dat = "\x01\x02\x03\x04\x05\x06\x07\x08"
+while 1:
+  iden += 1
+  p.can_send(iden, dat, bus=3)
+  time.sleep(0.01)
+

tests/gmbitbang/test_packer.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef struct {
+  uint32_t RIR;  /*!< CAN receive FIFO mailbox identifier register */
+  uint32_t RDTR; /*!< CAN receive FIFO mailbox data length control and time stamp register */
+  uint32_t RDLR; /*!< CAN receive FIFO mailbox data low register */
+  uint32_t RDHR; /*!< CAN receive FIFO mailbox data high register */
+} CAN_FIFOMailBox_TypeDef;
+
+#include "../../board/drivers/canbitbang.h"
+
+int main() {
+  char out[300];
+  CAN_FIFOMailBox_TypeDef to_bang = {0};
+  to_bang.RIR = 20 << 21;
+  to_bang.RDTR = 1;
+  to_bang.RDLR = 1;
+
+  int len = get_bit_message(out, &to_bang);
+  printf("T:");
+  for (int i = 0; i < len; i++) {
+    printf("%d", out[i]);
+  }
+  printf("\n");
+  printf("R:0000010010100000100010000010011110111010100111111111111111");
+  printf("\n");
+  return 0;
+}
+
+
+

tests/location_listener.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+import os
+import time
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda, PandaSerial
+
+def add_nmea_checksum(msg):
+  d = msg[1:]
+  cs = 0
+  for i in d:
+    cs ^= ord(i)
+  return msg + "*%02X" % cs
+
+if __name__ == "__main__":
+  panda = Panda()
+  ser = PandaSerial(panda, 1, 9600)
+
+  # power cycle by toggling reset
+  print "resetting"
+  panda.set_esp_power(0)
+  time.sleep(0.5)
+  panda.set_esp_power(1)
+  time.sleep(0.5)
+  print "done"
+  print ser.read(1024)
+
+  # upping baud rate
+  baudrate = 460800
+
+  print "upping baud rate"
+  msg = add_nmea_checksum("$PUBX,41,1,0007,0003,%d,0" % baudrate)+"\r\n"
+  print msg
+  ser.write(msg)
+  time.sleep(0.1)   # needs a wait for it to actually send
+
+  # new panda serial
+  ser = PandaSerial(panda, 1, baudrate)
+
+  while True:
+    ret = ser.read(1024)
+    if len(ret) > 0:
+      sys.stdout.write(ret)
+      sys.stdout.flush()
+      #print str(ret).encode("hex")
+

tests/loopback_test.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os
+import sys
+import time
+import random
+import argparse
+
+from hexdump import hexdump
+from itertools import permutations
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda
+
+def get_test_string():
+  return b"test"+os.urandom(10)
+
+def run_test(sleep_duration):
+  pandas = Panda.list()
+  print(pandas)
+
+  if len(pandas) == 0:
+    print("NO PANDAS")
+    assert False
+
+  if len(pandas) == 1:
+    # if we only have one on USB, assume the other is on wifi
+    pandas.append("WIFI")
+  run_test_w_pandas(pandas, sleep_duration)
+
+def run_test_w_pandas(pandas, sleep_duration):
+  h = list(map(lambda x: Panda(x), pandas))
+  print("H", h)
+
+  for hh in h:
+    hh.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+  # test both directions
+  for ho in permutations(range(len(h)), r=2):
+    print("***************** TESTING", ho)
+
+    panda0, panda1 = h[ho[0]], h[ho[1]]
+
+    if(panda0._serial == "WIFI"):
+      print("  *** Can not send can data over wifi panda. Skipping! ***")
+      continue
+
+    # **** test health packet ****
+    print("health", ho[0], h[ho[0]].health())
+
+    # **** test K/L line loopback ****
+    for bus in [2,3]:
+      # flush the output
+      h[ho[1]].kline_drain(bus=bus)
+
+      # send the characters
+      st = get_test_string()
+      st = b"\xaa"+chr(len(st)+3).encode()+st
+      h[ho[0]].kline_send(st, bus=bus, checksum=False)
+
+      # check for receive
+      ret = h[ho[1]].kline_drain(bus=bus)
+
+      print("ST Data:")
+      hexdump(st)
+      print("RET Data:")
+      hexdump(ret)
+      assert st == ret
+      print("K/L pass", bus, ho, "\n")
+      time.sleep(sleep_duration)
+
+    # **** test can line loopback ****
+    for bus, gmlan in [(0, False), (1, False), (2, False), (1, True), (2, True)]:
+      print("\ntest can", bus)
+      # flush
+      cans_echo = panda0.can_recv()
+      cans_loop = panda1.can_recv()
+
+      panda0.set_gmlan(None)
+      panda1.set_gmlan(None)
+
+      if gmlan is True:
+        panda0.set_gmlan(bus)
+        panda1.set_gmlan(bus)
+        bus = 3
+
+      # send the characters
+      at = random.randint(1, 2000)
+      st = get_test_string()[0:8]
+      panda0.can_send(at, st, bus)
+      time.sleep(0.1)
+
+      # check for receive
+      cans_echo = panda0.can_recv()
+      cans_loop = panda1.can_recv()
+
+      print("Bus", bus, "echo", cans_echo, "loop", cans_loop)
+
+      assert len(cans_echo) == 1
+      assert len(cans_loop) == 1
+
+      assert cans_echo[0][0] == at
+      assert cans_loop[0][0] == at
+
+      assert cans_echo[0][2] == st
+      assert cans_loop[0][2] == st
+
+      assert cans_echo[0][3] == 0x80 | bus
+      if cans_loop[0][3] != bus:
+        print("EXPECTED %d GOT %d" % (bus, cans_loop[0][3]))
+      assert cans_loop[0][3] == bus
+
+      print("CAN pass", bus, ho)
+      time.sleep(sleep_duration)
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser()
+  parser.add_argument("-n", type=int, help="Number of test iterations to run")
+  parser.add_argument("-sleep", type=int, help="Sleep time between tests", default=0)
+  args = parser.parse_args()
+
+  if args.n is None:
+    while True:
+      run_test(sleep_duration=args.sleep)
+  else:
+    for i in range(args.n):
+      run_test(sleep_duration=args.sleep)

tests/misra/Dockerfile

@@ -0,0 +1,6 @@
+FROM ubuntu:16.04
+
+RUN apt-get update && apt-get install -y make python python-pip git
+COPY tests/safety/requirements.txt /panda/tests/safety/requirements.txt
+RUN pip install -r /panda/tests/safety/requirements.txt
+COPY . /panda

tests/misra/test_misra.sh

@@ -0,0 +1,24 @@
+#!/bin/bash -e
+
+git clone https://github.com/danmar/cppcheck.git || true
+cd cppcheck
+git fetch
+git checkout 44d6066c6fad32e2b0332b3f2b24bd340febaef8
+make -j4
+cd ../../../
+
+# whole panda code
+tests/misra/cppcheck/cppcheck --dump --enable=all --inline-suppr board/main.c 2>/tmp/misra/cppcheck_output.txt || true
+python tests/misra/cppcheck/addons/misra.py board/main.c.dump 2>/tmp/misra/misra_output.txt || true
+
+# violations in safety files
+(cat /tmp/misra/misra_output.txt | grep safety) > /tmp/misra/misra_safety_output.txt || true
+(cat /tmp/misra/cppcheck_output.txt | grep safety) > /tmp/misra/cppcheck_safety_output.txt || true
+
+if [[ -s "/tmp/misra/misra_safety_output.txt" ]] || [[ -s "/tmp/misra/cppcheck_safety_output.txt" ]]
+then
+  echo "Found Misra violations in the safety code:"
+  cat /tmp/misra/misra_safety_output.txt
+  cat /tmp/misra/cppcheck_safety_output.txt
+  exit 1
+fi

tests/pedal/enter_canloader.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+import sys
+import time
+import struct
+import argparse
+import signal
+from panda import Panda
+
+class CanHandle(object):
+  def __init__(self, p):
+    self.p = p
+
+  def transact(self, dat):
+    #print "W:",dat.encode("hex")
+    self.p.isotp_send(1, dat, 0, recvaddr=2)
+
+    def _handle_timeout(signum, frame):
+      # will happen on reset
+      raise Exception("timeout")
+
+    signal.signal(signal.SIGALRM, _handle_timeout)
+    signal.alarm(1)
+    try:
+      ret = self.p.isotp_recv(2, 0, sendaddr=1)
+    finally:
+      signal.alarm(0)
+
+    #print "R:",ret.encode("hex")
+    return ret
+
+  def controlWrite(self, request_type, request, value, index, data, timeout=0):
+    # ignore data in reply, panda doesn't use it
+    return self.controlRead(request_type, request, value, index, 0, timeout)
+
+  def controlRead(self, request_type, request, value, index, length, timeout=0):
+    dat = struct.pack("HHBBHHH", 0, 0, request_type, request, value, index, length)
+    return self.transact(dat)
+
+  def bulkWrite(self, endpoint, data, timeout=0):
+    if len(data) > 0x10:
+      raise ValueError("Data must not be longer than 0x10")
+    dat = struct.pack("HH", endpoint, len(data))+data
+    return self.transact(dat)
+
+  def bulkRead(self, endpoint, length, timeout=0):
+    dat = struct.pack("HH", endpoint, 0)
+    return self.transact(dat)
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser(description='Flash pedal over can')
+  parser.add_argument('--recover', action='store_true')
+  parser.add_argument("fn", type=str, nargs='?', help="flash file")
+  args = parser.parse_args()
+
+  p = Panda()
+  p.set_safety_mode(0x1337)
+
+  while 1:
+    if len(p.can_recv()) == 0:
+      break
+
+  if args.recover:
+    p.can_send(0x200, "\xce\xfa\xad\xde\x1e\x0b\xb0\x02", 0)
+    exit(0)
+  else:
+    p.can_send(0x200, "\xce\xfa\xad\xde\x1e\x0b\xb0\x0a", 0)
+
+  if args.fn:
+    time.sleep(0.1)
+    print "flashing", args.fn
+    code = open(args.fn).read()
+    Panda.flash_static(CanHandle(p), code)
+
+  print "can flash done"
+
+

tests/read_st_flash.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+rm -f /tmp/dump_bootstub
+rm -f /tmp/dump_main
+dfu-util -a 0 -s 0x08000000 -U /tmp/dump_bootstub
+dfu-util -a 0 -s 0x08004000 -U /tmp/dump_main
+

tests/read_winusb_descriptors.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+from panda import Panda
+from hexdump import hexdump
+
+DEBUG = False
+
+if __name__ == "__main__":
+  p = Panda()
+
+  len = p._handle.controlRead(Panda.REQUEST_IN, 0x06, 3 << 8 | 238, 0, 1)
+  print 'Microsoft OS String Descriptor'
+  dat = p._handle.controlRead(Panda.REQUEST_IN, 0x06, 3 << 8 | 238, 0, len[0])
+  if DEBUG: print 'LEN: {}'.format(hex(len[0]))
+  hexdump("".join(map(chr, dat)))
+
+  ms_vendor_code = dat[16]
+  if DEBUG: print 'MS_VENDOR_CODE: {}'.format(hex(len[0]))
+
+  print '\nMicrosoft Compatible ID Feature Descriptor'
+  len = p._handle.controlRead(Panda.REQUEST_IN, ms_vendor_code, 0, 4, 1)
+  if DEBUG: print 'LEN: {}'.format(hex(len[0]))
+  dat = p._handle.controlRead(Panda.REQUEST_IN, ms_vendor_code, 0, 4, len[0])
+  hexdump("".join(map(chr, dat)))
+
+  print '\nMicrosoft Extended Properties Feature Descriptor'
+  len = p._handle.controlRead(Panda.REQUEST_IN, ms_vendor_code, 0, 5, 1)
+  if DEBUG: print 'LEN: {}'.format(hex(len[0]))
+  dat = p._handle.controlRead(Panda.REQUEST_IN, ms_vendor_code, 0, 5, len[0])
+  hexdump("".join(map(chr, dat)))

tests/safety/Dockerfile

@@ -0,0 +1,6 @@
+FROM ubuntu:16.04
+
+RUN apt-get update && apt-get install -y clang make python python-pip
+COPY tests/safety/requirements.txt /panda/tests/safety/requirements.txt
+RUN pip install -r /panda/tests/safety/requirements.txt
+COPY . /panda

tests/safety/Makefile

@@ -0,0 +1,18 @@
+CC = clang
+CCFLAGS = -O3 -fPIC -DPANDA -I.
+
+.PHONY: all
+all: libpandasafety.so
+
+libpandasafety.so: test.o
+	$(CC) -shared -o '$@' $^ -lm
+
+test.o: test.c
+	@echo "[ CC ] $@"
+	$(CC) $(CCFLAGS) -MMD -c -I../../board -o '$@' '$<'
+
+.PHONY: clean
+clean:
+	rm -f libpandasafety.so test.o test.d
+
+-include test.d

tests/safety/libpandasafety_py.py

@@ -0,0 +1,97 @@
+import os
+import subprocess
+
+from cffi import FFI
+
+can_dir = os.path.dirname(os.path.abspath(__file__))
+libpandasafety_fn = os.path.join(can_dir, "libpandasafety.so")
+subprocess.check_call(["make"], cwd=can_dir)
+
+ffi = FFI()
+ffi.cdef("""
+typedef struct
+{
+  uint32_t TIR;  /*!< CAN TX mailbox identifier register */
+  uint32_t TDTR; /*!< CAN mailbox data length control and time stamp register */
+  uint32_t TDLR; /*!< CAN mailbox data low register */
+  uint32_t TDHR; /*!< CAN mailbox data high register */
+} CAN_TxMailBox_TypeDef;
+
+typedef struct
+{
+  uint32_t RIR;  /*!< CAN receive FIFO mailbox identifier register */
+  uint32_t RDTR; /*!< CAN receive FIFO mailbox data length control and time stamp register */
+  uint32_t RDLR; /*!< CAN receive FIFO mailbox data low register */
+  uint32_t RDHR; /*!< CAN receive FIFO mailbox data high register */
+} CAN_FIFOMailBox_TypeDef;
+
+typedef struct
+{
+  uint32_t CNT;
+} TIM_TypeDef;
+
+void set_controls_allowed(bool c);
+bool get_controls_allowed(void);
+void set_long_controls_allowed(bool c);
+bool get_long_controls_allowed(void);
+void set_gas_interceptor_detected(bool c);
+bool get_gas_interceptor_detetcted(void);
+int get_gas_interceptor_prev(void);
+void set_timer(uint32_t t);
+void reset_angle_control(void);
+
+void safety_rx_hook(CAN_FIFOMailBox_TypeDef *to_send);
+int safety_tx_hook(CAN_FIFOMailBox_TypeDef *to_push);
+int safety_fwd_hook(int bus_num, CAN_FIFOMailBox_TypeDef *to_fwd);
+int safety_set_mode(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);
+int get_toyota_gas_prev(void);
+void set_toyota_torque_meas(int min, int max);
+void set_toyota_desired_torque_last(int t);
+void set_toyota_camera_forwarded(int t);
+void set_toyota_rt_torque_last(int t);
+
+void init_tests_honda(void);
+int get_honda_ego_speed(void);
+int get_honda_brake_prev(void);
+int get_honda_gas_prev(void);
+void set_honda_alt_brake_msg(bool);
+void set_honda_bosch_hardware(bool);
+
+void init_tests_cadillac(void);
+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 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 set_hyundai_giraffe_switch_2(int t);
+void set_hyundai_camera_bus(int t);
+
+void init_tests_chrysler(void);
+void set_chrysler_desired_torque_last(int t);
+void set_chrysler_rt_torque_last(int t);
+void set_chrysler_camera_detected(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);
+void set_subaru_torque_driver(int min, int max);
+
+
+""")
+
+libpandasafety = ffi.dlopen(libpandasafety_fn)

tests/safety/requirements.txt

@@ -0,0 +1,2 @@
+cffi==1.11.4
+numpy==1.14.1

tests/safety/test.c

@@ -0,0 +1,290 @@
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct
+{
+  uint32_t TIR;  /*!< CAN TX mailbox identifier register */
+  uint32_t TDTR; /*!< CAN mailbox data length control and time stamp register */
+  uint32_t TDLR; /*!< CAN mailbox data low register */
+  uint32_t TDHR; /*!< CAN mailbox data high register */
+} CAN_TxMailBox_TypeDef;
+
+typedef struct
+{
+  uint32_t RIR;  /*!< CAN receive FIFO mailbox identifier register */
+  uint32_t RDTR; /*!< CAN receive FIFO mailbox data length control and time stamp register */
+  uint32_t RDLR; /*!< CAN receive FIFO mailbox data low register */
+  uint32_t RDHR; /*!< CAN receive FIFO mailbox data high register */
+} CAN_FIFOMailBox_TypeDef;
+
+typedef struct
+{
+  uint32_t CNT;
+} TIM_TypeDef;
+
+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_meas;
+struct sample_t subaru_torque_driver;
+
+TIM_TypeDef timer;
+TIM_TypeDef *TIM2 = &timer;
+
+#define MIN(a,b)                                \
+  ({ __typeof__ (a) _a = (a);                   \
+    __typeof__ (b) _b = (b);                    \
+    _a < _b ? _a : _b; })
+
+#define MAX(a,b)                                \
+  ({ __typeof__ (a) _a = (a);                   \
+    __typeof__ (b) _b = (b);                    \
+    _a > _b ? _a : _b; })
+
+#define UNUSED(x) (void)(x)
+
+#define PANDA
+#define NULL ((void*)0)
+#define static
+#include "safety.h"
+
+void set_controls_allowed(bool c){
+  controls_allowed = c;
+}
+
+void set_long_controls_allowed(bool c){
+  long_controls_allowed = c;
+}
+
+void set_gas_interceptor_detected(bool c){
+  gas_interceptor_detected = c;
+}
+
+void reset_angle_control(void){
+  angle_control = 0;
+}
+
+bool get_controls_allowed(void){
+  return controls_allowed;
+}
+
+bool get_long_controls_allowed(void){
+  return long_controls_allowed;
+}
+
+bool get_gas_interceptor_detected(void){
+  return gas_interceptor_detected;
+}
+
+int get_gas_interceptor_prev(void){
+  return gas_interceptor_prev;
+}
+
+void set_timer(uint32_t t){
+  timer.CNT = t;
+}
+
+void set_toyota_camera_forwarded(int t){
+  toyota_camera_forwarded = t;
+}
+
+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){
+  cadillac_torque_driver.min = min;
+  cadillac_torque_driver.max = max;
+}
+
+void set_gm_torque_driver(int min, int max){
+  gm_torque_driver.min = min;
+  gm_torque_driver.max = max;
+}
+
+void set_hyundai_torque_driver(int min, int max){
+  hyundai_torque_driver.min = min;
+  hyundai_torque_driver.max = max;
+}
+
+void set_hyundai_camera_bus(int t){
+  hyundai_camera_bus = t;
+}
+
+void set_hyundai_giraffe_switch_2(int t){
+  hyundai_giraffe_switch_2 = t;
+}
+
+void set_chrysler_camera_detected(int t){
+  chrysler_camera_detected = t;
+}
+
+void set_chrysler_torque_meas(int min, int max){
+  chrysler_torque_meas.min = min;
+  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;
+}
+
+int get_chrysler_torque_meas_max(void){
+  return chrysler_torque_meas.max;
+}
+
+int get_toyota_gas_prev(void){
+  return toyota_gas_prev;
+}
+
+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_cadillac_rt_torque_last(int t){
+  cadillac_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_toyota_desired_torque_last(int t){
+  toyota_desired_torque_last = t;
+}
+
+void set_cadillac_desired_torque_last(int t){
+  for (int i = 0; i < 4; i++) cadillac_desired_torque_last[i] = 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;
+}
+
+int get_honda_ego_speed(void){
+  return honda_ego_speed;
+}
+
+int get_honda_brake_prev(void){
+  return honda_brake_prev;
+}
+
+int get_honda_gas_prev(void){
+  return honda_gas_prev;
+}
+
+void set_honda_alt_brake_msg(bool c){
+  honda_alt_brake_msg = c;
+}
+
+void set_honda_bosch_hardware(bool c){
+  honda_bosch_hardware = c;
+}
+
+void init_tests_toyota(void){
+  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_cadillac(void){
+  cadillac_torque_driver.min = 0;
+  cadillac_torque_driver.max = 0;
+  for (int i = 0; i < 4; i++) cadillac_desired_torque_last[i] = 0;
+  cadillac_rt_torque_last = 0;
+  cadillac_ts_last = 0;
+  set_timer(0);
+}
+
+void init_tests_gm(void){
+  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){
+  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){
+  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){
+  honda_ego_speed = 0;
+  honda_brake_prev = 0;
+  honda_gas_prev = 0;
+}
+
+void set_gmlan_digital_output(int to_set){
+}
+
+void reset_gmlan_switch_timeout(void){
+}
+
+void gmlan_switch_init(int timeout_enable){
+}
+

tests/safety/test.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+python -m unittest discover .

tests/safety/test_cadillac.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_RATE_UP = 2
+MAX_RATE_DOWN = 5
+MAX_TORQUE = 150
+
+MAX_RT_DELTA = 75
+RT_INTERVAL = 250000
+
+DRIVER_TORQUE_ALLOWANCE = 50;
+DRIVER_TORQUE_FACTOR = 4;
+
+IPAS_OVERRIDE_THRESHOLD = 200
+
+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 TestCadillacSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(6, 0)
+    cls.safety.init_tests_cadillac()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+    return to_send
+
+  def _set_prev_torque(self, t):
+    self.safety.set_cadillac_desired_torque_last(t)
+    self.safety.set_cadillac_rt_torque_last(t)
+
+  def _torque_driver_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x164 << 21
+
+    t = twos_comp(torque, 11)
+    to_send[0].RDLR = ((t >> 8) & 0x7) | ((t & 0xFF) << 8)
+    return to_send
+
+  def _torque_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x151 << 21
+
+    t = twos_comp(torque, 14)
+    to_send[0].RDLR = ((t >> 8) & 0x3F) | ((t & 0xFF) << 8)
+    return to_send
+
+  def test_default_controls_not_allowed(self):
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  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)
+
+  def test_enable_control_allowed_from_cruise(self):
+    to_push = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_push[0].RIR = 0x370 << 21
+    to_push[0].RDLR = 0x800000
+    to_push[0].RDTR = 0
+
+    self.safety.safety_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 = 0x370 << 21
+    to_push[0].RDLR = 0
+    to_push[0].RDTR = 0
+
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(to_push)
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  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_cadillac_rt_torque_last(torque)
+        self.safety.set_cadillac_torque_driver(0, 0)
+        self.safety.set_cadillac_desired_torque_last(torque - MAX_RATE_UP)
+
+        if controls_allowed:
+          send = (-MAX_TORQUE <= torque <= MAX_TORQUE)
+        else:
+          send = torque == 0
+
+        self.assertEqual(send, self.safety.safety_tx_hook(self._torque_msg(torque)))
+
+  def test_non_realtime_limit_up(self):
+    self.safety.set_cadillac_torque_driver(0, 0)
+    self.safety.set_controls_allowed(True)
+
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP)))
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(-MAX_RATE_UP)))
+
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP + 1)))
+    self.safety.set_controls_allowed(True)
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(-MAX_RATE_UP - 1)))
+
+  def test_non_realtime_limit_down(self):
+    self.safety.set_cadillac_torque_driver(0, 0)
+    self.safety.set_controls_allowed(True)
+
+  def test_exceed_torque_sensor(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_cadillac_torque_driver(t, t)
+        self._set_prev_torque(MAX_TORQUE * sign)
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_TORQUE * sign)))
+
+      self.safety.set_cadillac_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1)
+      self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(-MAX_TORQUE)))
+
+    # spot check some individual cases
+    for sign in [-1, 1]:
+      driver_torque = (DRIVER_TORQUE_ALLOWANCE + 10) * sign
+      torque_desired = (MAX_TORQUE - 10 * DRIVER_TORQUE_FACTOR) * sign
+      delta = 1 * sign
+      self._set_prev_torque(torque_desired)
+      self.safety.set_cadillac_torque_driver(-driver_torque, -driver_torque)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(torque_desired)))
+      self._set_prev_torque(torque_desired + delta)
+      self.safety.set_cadillac_torque_driver(-driver_torque, -driver_torque)
+      self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(torque_desired + delta)))
+
+      self._set_prev_torque(MAX_TORQUE * sign)
+      self.safety.set_cadillac_torque_driver(-MAX_TORQUE * sign, -MAX_TORQUE * sign)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg((MAX_TORQUE - MAX_RATE_DOWN) * sign)))
+      self._set_prev_torque(MAX_TORQUE * sign)
+      self.safety.set_cadillac_torque_driver(-MAX_TORQUE * sign, -MAX_TORQUE * sign)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(0)))
+      self._set_prev_torque(MAX_TORQUE * sign)
+      self.safety.set_cadillac_torque_driver(-MAX_TORQUE * sign, -MAX_TORQUE * sign)
+      self.assertFalse(self.safety.safety_tx_hook(self._torque_msg((MAX_TORQUE - 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_cadillac()
+      self._set_prev_torque(0)
+      self.safety.set_cadillac_torque_driver(0, 0)
+      for t in np.arange(0, MAX_RT_DELTA, 1):
+        t *= sign
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+      self.assertFalse(self.safety.safety_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.safety_tx_hook(self._torque_msg(t)))
+
+      # Increase timer to update rt_torque_last
+      self.safety.set_timer(RT_INTERVAL + 1)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA - 1))))
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA + 1))))
+
+
+  def test_fwd_hook(self):
+    # nothing allowed
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+
+    for b in buss:
+      for m in msgs:
+        # assume len 8
+        self.assertEqual(-1, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_chrysler.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python2
+import csv
+import glob
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_RATE_UP = 3
+MAX_RATE_DOWN = 3
+MAX_STEER = 261
+
+MAX_RT_DELTA = 112
+RT_INTERVAL = 250000
+
+MAX_TORQUE_ERROR = 80
+
+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
+
+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):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(9, 0)
+    cls.safety.init_tests_chrysler()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+    return to_send
+
+  def _button_msg(self, buttons):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 1265 << 21
+    to_send[0].RDLR = buttons
+    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)
+
+  def _torque_meas_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 544 << 21
+    to_send[0].RDHR = ((torque + 1024) >> 8) + (((torque + 1024) & 0xff) << 8)
+    return to_send
+
+  def _torque_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x292 << 21
+    to_send[0].RDLR = ((torque + 1024) >> 8) + (((torque + 1024) & 0xff) << 8)
+    return to_send
+
+  def test_default_controls_not_allowed(self):
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_steer_safety_check(self):
+    for enabled in [0, 1]:
+      for t in range(-MAX_STEER*2, MAX_STEER*2):
+        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.safety_tx_hook(self._torque_msg(t)))
+        else:
+          self.assertTrue(self.safety.safety_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_enable_control_allowed_from_cruise(self):
+    to_push = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_push[0].RIR = 0x1f4 << 21
+    to_push[0].RDLR = 0x380000
+
+    self.safety.safety_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 = 0x1f4 << 21
+    to_push[0].RDLR = 0
+
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(to_push)
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_non_realtime_limit_up(self):
+    self.safety.set_controls_allowed(True)
+
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP)))
+
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP + 1)))
+
+  def test_non_realtime_limit_down(self):
+    self.safety.set_controls_allowed(True)
+
+    self.safety.set_chrysler_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.assertTrue(self.safety.safety_tx_hook(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.assertFalse(self.safety.safety_tx_hook(self._torque_msg(MAX_STEER - MAX_RATE_DOWN + 1)))
+
+  def test_exceed_torque_sensor(self):
+    self.safety.set_controls_allowed(True)
+
+    for sign in [-1, 1]:
+      self._set_prev_torque(0)
+      for t in np.arange(0, MAX_TORQUE_ERROR + 2, 2):  # step needs to be smaller than MAX_TORQUE_ERROR
+        t *= sign
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+
+      self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_TORQUE_ERROR + 2))))
+
+  def test_realtime_limit_up(self):
+    self.safety.set_controls_allowed(True)
+
+    for sign in [-1, 1]:
+      self.safety.init_tests_chrysler()
+      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.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+      self.assertFalse(self.safety.safety_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, 1):
+        t *= sign
+        self.safety.set_chrysler_torque_meas(t, t)
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+
+      # Increase timer to update rt_torque_last
+      self.safety.set_timer(RT_INTERVAL + 1)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * MAX_RT_DELTA)))
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA + 1))))
+
+  def test_torque_measurements(self):
+    self.safety.safety_rx_hook(self._torque_meas_msg(50))
+    self.safety.safety_rx_hook(self._torque_meas_msg(-50))
+    self.safety.safety_rx_hook(self._torque_meas_msg(0))
+    self.safety.safety_rx_hook(self._torque_meas_msg(0))
+    self.safety.safety_rx_hook(self._torque_meas_msg(0))
+    self.safety.safety_rx_hook(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.safety.safety_rx_hook(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.safety.safety_rx_hook(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())
+
+  def test_fwd_hook(self):
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+    chrysler_camera_detected = [0, 1]
+
+    for ccd in chrysler_camera_detected:
+      self.safety.set_chrysler_camera_detected(ccd)
+      blocked_msgs = [658, 678]
+      for b in buss:
+        for m in msgs:
+          if not ccd:
+            if b == 0:
+              fwd_bus = 2
+            elif b == 1:
+              fwd_bus = -1
+            elif b == 2:
+              fwd_bus = -1 if m in blocked_msgs else 0
+          else:
+            fwd_bus = -1
+
+          # assume len 8
+          self.assertEqual(fwd_bus, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_gm.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_RATE_UP = 7
+MAX_RATE_DOWN = 17
+MAX_STEER = 300
+MAX_BRAKE = 350
+MAX_GAS = 3072
+MAX_REGEN = 1404
+
+MAX_RT_DELTA = 128
+RT_INTERVAL = 250000
+
+DRIVER_TORQUE_ALLOWANCE = 50;
+DRIVER_TORQUE_FACTOR = 4;
+
+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 TestGmSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(3, 0)
+    cls.safety.init_tests_gm()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+    return to_send
+
+  def _speed_msg(self, speed):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 842 << 21
+    to_send[0].RDLR = speed
+    return to_send
+
+  def _button_msg(self, buttons):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 481 << 21
+    to_send[0].RDHR = buttons << 12
+    return to_send
+
+  def _brake_msg(self, brake):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 241 << 21
+    to_send[0].RDLR = 0xa00 if brake else 0x900
+    return to_send
+
+  def _gas_msg(self, gas):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 417 << 21
+    to_send[0].RDHR = (1 << 16) if gas else 0
+    return to_send
+
+  def _send_brake_msg(self, brake):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 789 << 21
+    brake = (-brake) & 0xfff
+    to_send[0].RDLR = (brake >> 8) | ((brake &0xff) << 8)
+    return to_send
+
+  def _send_gas_msg(self, gas):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 715 << 21
+    to_send[0].RDLR = ((gas & 0x1f) << 27) | ((gas & 0xfe0) << 11)
+    return to_send
+
+  def _set_prev_torque(self, t):
+    self.safety.set_gm_desired_torque_last(t)
+    self.safety.set_gm_rt_torque_last(t)
+
+  def _torque_driver_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 388 << 21
+
+    t = twos_comp(torque, 11)
+    to_send[0].RDHR = (((t >> 8) & 0x7) << 16) | ((t & 0xFF) << 24)
+    return to_send
+
+  def _torque_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 384 << 21
+
+    t = twos_comp(torque, 11)
+    to_send[0].RDLR = ((t >> 8) & 0x7) | ((t & 0xFF) << 8)
+    return to_send
+
+  def test_default_controls_not_allowed(self):
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_resume_button(self):
+    RESUME_BTN = 2
+    self.safety.set_controls_allowed(0)
+    self.safety.safety_rx_hook(self._button_msg(RESUME_BTN))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_set_button(self):
+    SET_BTN = 3
+    self.safety.set_controls_allowed(0)
+    self.safety.safety_rx_hook(self._button_msg(SET_BTN))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_cancel_button(self):
+    CANCEL_BTN = 6
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._button_msg(CANCEL_BTN))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_disengage_on_brake(self):
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_allow_brake_at_zero_speed(self):
+    # Brake was already pressed
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.safety.set_controls_allowed(1)
+
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._brake_msg(False))
+
+  def test_not_allow_brake_when_moving(self):
+    # Brake was already pressed
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.safety.safety_rx_hook(self._speed_msg(100))
+    self.safety.set_controls_allowed(1)
+
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.assertFalse(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._brake_msg(False))
+
+  def test_disengage_on_gas(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      self.safety.set_controls_allowed(1)
+      self.safety.safety_rx_hook(self._gas_msg(True))
+      if long_controls_allowed:
+        self.assertFalse(self.safety.get_controls_allowed())
+      else:
+        self.assertTrue(self.safety.get_controls_allowed())
+      self.safety.safety_rx_hook(self._gas_msg(False))
+
+  def test_allow_engage_with_gas_pressed(self):
+    self.safety.safety_rx_hook(self._gas_msg(True))
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._gas_msg(True))
+    self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._gas_msg(False))
+
+  def test_brake_safety_check(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      for enabled in [0, 1]:
+        for b in range(0, 500):
+          self.safety.set_controls_allowed(enabled)
+          if abs(b) > MAX_BRAKE or ((not enabled or not long_controls_allowed) and b != 0):
+            self.assertFalse(self.safety.safety_tx_hook(self._send_brake_msg(b)))
+          else:
+            self.assertTrue(self.safety.safety_tx_hook(self._send_brake_msg(b)))
+    self.safety.set_long_controls_allowed(True)
+
+  def test_gas_safety_check(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      for enabled in [0, 1]:
+        for g in range(0, 2**12-1):
+          self.safety.set_controls_allowed(enabled)
+          if abs(g) > MAX_GAS or ((not enabled or not long_controls_allowed) and g != MAX_REGEN):
+            self.assertFalse(self.safety.safety_tx_hook(self._send_gas_msg(g)))
+          else:
+            self.assertTrue(self.safety.safety_tx_hook(self._send_gas_msg(g)))
+    self.safety.set_long_controls_allowed(True)
+
+  def test_steer_safety_check(self):
+    for enabled in [0, 1]:
+      for t in range(-0x200, 0x200):
+        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.safety_tx_hook(self._torque_msg(t)))
+        else:
+          self.assertTrue(self.safety.safety_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_gm_torque_driver(0, 0)
+    self.safety.set_controls_allowed(True)
+
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP)))
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(-MAX_RATE_UP)))
+
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP + 1)))
+    self.safety.set_controls_allowed(True)
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(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_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_gm_torque_driver(t, t)
+        self._set_prev_torque(MAX_STEER * sign)
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_STEER * sign)))
+
+      self.safety.set_gm_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1)
+      self.assertFalse(self.safety.safety_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_gm_torque_driver(-driver_torque, -driver_torque)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(torque_desired)))
+      self._set_prev_torque(torque_desired + delta)
+      self.safety.set_gm_torque_driver(-driver_torque, -driver_torque)
+      self.assertFalse(self.safety.safety_tx_hook(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.assertTrue(self.safety.safety_tx_hook(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.assertTrue(self.safety.safety_tx_hook(self._torque_msg(0)))
+      self._set_prev_torque(MAX_STEER * sign)
+      self.safety.set_gm_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign)
+      self.assertFalse(self.safety.safety_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_gm()
+      self._set_prev_torque(0)
+      self.safety.set_gm_torque_driver(0, 0)
+      for t in np.arange(0, MAX_RT_DELTA, 1):
+        t *= sign
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+      self.assertFalse(self.safety.safety_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.safety_tx_hook(self._torque_msg(t)))
+
+      # Increase timer to update rt_torque_last
+      self.safety.set_timer(RT_INTERVAL + 1)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA - 1))))
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA + 1))))
+
+
+  def test_fwd_hook(self):
+    # nothing allowed
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+
+    for b in buss:
+      for m in msgs:
+        # assume len 8
+        self.assertEqual(-1, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_honda.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_BRAKE = 255
+
+class TestHondaSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(1, 0)
+    cls.safety.init_tests_honda()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+
+    return to_send
+
+  def _speed_msg(self, speed):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x158 << 21
+    to_send[0].RDLR = speed
+
+    return to_send
+
+  def _button_msg(self, buttons, msg):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = msg << 21
+    to_send[0].RDLR = buttons << 5
+
+    return to_send
+
+  def _brake_msg(self, brake):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x17C << 21
+    to_send[0].RDHR = 0x200000 if brake else 0
+
+    return to_send
+
+  def _alt_brake_msg(self, brake):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x1BE << 21
+    to_send[0].RDLR = 0x10 if brake else 0
+
+    return to_send
+
+  def _gas_msg(self, gas):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x17C << 21
+    to_send[0].RDLR = 1 if gas else 0
+
+    return to_send
+
+  def _send_brake_msg(self, brake):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x1FA << 21
+    to_send[0].RDLR = ((brake & 0x3) << 8) | ((brake & 0x3FF) >> 2)
+
+    return to_send
+
+  def _send_interceptor_msg(self, gas, addr):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = 6
+    to_send[0].RDLR = ((gas & 0xff) << 8) | ((gas & 0xff00) >> 8)
+
+    return to_send
+
+  def _send_steer_msg(self, steer):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0xE4 << 21
+    to_send[0].RDLR = steer
+
+    return to_send
+
+  def test_default_controls_not_allowed(self):
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_resume_button(self):
+    RESUME_BTN = 4
+    self.safety.set_controls_allowed(0)
+    self.safety.safety_rx_hook(self._button_msg(RESUME_BTN, 0x1A6))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_set_button(self):
+    SET_BTN = 3
+    self.safety.set_controls_allowed(0)
+    self.safety.safety_rx_hook(self._button_msg(SET_BTN, 0x1A6))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_cancel_button(self):
+    CANCEL_BTN = 2
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._button_msg(CANCEL_BTN, 0x1A6))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_sample_speed(self):
+    self.assertEqual(0, self.safety.get_honda_ego_speed())
+    self.safety.safety_rx_hook(self._speed_msg(100))
+    self.assertEqual(100, self.safety.get_honda_ego_speed())
+
+  def test_prev_brake(self):
+    self.assertFalse(self.safety.get_honda_brake_prev())
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.assertTrue(self.safety.get_honda_brake_prev())
+
+  def test_disengage_on_brake(self):
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._brake_msg(1))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_alt_disengage_on_brake(self):
+    self.safety.set_honda_alt_brake_msg(1)
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._alt_brake_msg(1))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+    self.safety.set_honda_alt_brake_msg(0)
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._alt_brake_msg(1))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_allow_brake_at_zero_speed(self):
+    # Brake was already pressed
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.safety.set_controls_allowed(1)
+
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._brake_msg(False))  # reset no brakes
+
+  def test_not_allow_brake_when_moving(self):
+    # Brake was already pressed
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.safety.safety_rx_hook(self._speed_msg(100))
+    self.safety.set_controls_allowed(1)
+
+    self.safety.safety_rx_hook(self._brake_msg(True))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_prev_gas(self):
+    self.safety.safety_rx_hook(self._gas_msg(False))
+    self.assertFalse(self.safety.get_honda_gas_prev())
+    self.safety.safety_rx_hook(self._gas_msg(True))
+    self.assertTrue(self.safety.get_honda_gas_prev())
+
+  def test_prev_gas_interceptor(self):
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x0, 0x201))
+    self.assertFalse(self.safety.get_gas_interceptor_prev())
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+    self.assertTrue(self.safety.get_gas_interceptor_prev())
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x0, 0x201))
+    self.safety.set_gas_interceptor_detected(False)
+
+  def test_disengage_on_gas(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      self.safety.safety_rx_hook(self._gas_msg(0))
+      self.safety.set_controls_allowed(1)
+      self.safety.safety_rx_hook(self._gas_msg(1))
+      if long_controls_allowed:
+        self.assertFalse(self.safety.get_controls_allowed())
+      else:
+        self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.set_long_controls_allowed(True)
+
+  def test_allow_engage_with_gas_pressed(self):
+    self.safety.safety_rx_hook(self._gas_msg(1))
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._gas_msg(1))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_disengage_on_gas_interceptor(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      self.safety.safety_rx_hook(self._send_interceptor_msg(0, 0x201))
+      self.safety.set_controls_allowed(1)
+      self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+      if long_controls_allowed:
+        self.assertFalse(self.safety.get_controls_allowed())
+      else:
+        self.assertTrue(self.safety.get_controls_allowed())
+      self.safety.safety_rx_hook(self._send_interceptor_msg(0, 0x201))
+      self.safety.set_gas_interceptor_detected(False)
+    self.safety.set_long_controls_allowed(True)
+
+  def test_allow_engage_with_gas_interceptor_pressed(self):
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+    self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0, 0x201))
+    self.safety.set_gas_interceptor_detected(False)
+
+  def test_brake_safety_check(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      for brake in np.arange(0, MAX_BRAKE + 10, 1):
+        for controls_allowed in [True, False]:
+          self.safety.set_controls_allowed(controls_allowed)
+          if controls_allowed and long_controls_allowed:
+            send = MAX_BRAKE >= brake >= 0
+          else:
+            send = brake == 0
+          self.assertEqual(send, self.safety.safety_tx_hook(self._send_brake_msg(brake)))
+    self.safety.set_long_controls_allowed(True)
+
+  def test_gas_interceptor_safety_check(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      for gas in np.arange(0, 4000, 100):
+        for controls_allowed in [True, False]:
+          self.safety.set_controls_allowed(controls_allowed)
+          if controls_allowed and long_controls_allowed:
+            send = True
+          else:
+            send = gas == 0
+          self.assertEqual(send, self.safety.safety_tx_hook(self._send_interceptor_msg(gas, 0x200)))
+    self.safety.set_long_controls_allowed(True)
+
+  def test_steer_safety_check(self):
+    self.safety.set_controls_allowed(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._send_steer_msg(0x0000)))
+    self.assertFalse(self.safety.safety_tx_hook(self._send_steer_msg(0x1000)))
+
+  def test_spam_cancel_safety_check(self):
+    RESUME_BTN = 4
+    SET_BTN = 3
+    CANCEL_BTN = 2
+    BUTTON_MSG = 0x296
+    self.safety.set_honda_bosch_hardware(1)
+    self.safety.set_controls_allowed(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._button_msg(CANCEL_BTN, BUTTON_MSG)))
+    self.assertFalse(self.safety.safety_tx_hook(self._button_msg(RESUME_BTN, BUTTON_MSG)))
+    self.assertFalse(self.safety.safety_tx_hook(self._button_msg(SET_BTN, BUTTON_MSG)))
+    # do not block resume if we are engaged already
+    self.safety.set_controls_allowed(1)
+    self.assertTrue(self.safety.safety_tx_hook(self._button_msg(RESUME_BTN, BUTTON_MSG)))
+
+  def test_fwd_hook(self):
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+    long_controls_allowed = [0, 1]
+
+    self.safety.set_honda_bosch_hardware(0)
+
+    for l in long_controls_allowed:
+      self.safety.set_long_controls_allowed(l)
+      blocked_msgs = [0xE4, 0x194, 0x33D]
+      if l:
+        blocked_msgs += [0x1FA ,0x30C, 0x39F]
+      for b in buss:
+        for m in msgs:
+          if b == 0:
+            fwd_bus = 2
+          elif b == 1:
+            fwd_bus = -1
+          elif b == 2:
+            fwd_bus = -1 if m in blocked_msgs else 0
+
+          # assume len 8
+          self.assertEqual(fwd_bus, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+    self.safety.set_long_controls_allowed(True)
+
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_honda_bosch.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_BRAKE = 255
+
+class TestHondaSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(4, 0)
+    cls.safety.init_tests_honda()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+
+    return to_send
+
+  def test_fwd_hook(self):
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+
+    blocked_msgs = [0xE4, 0x33D]
+    for b in buss:
+      for m in msgs:
+        if b == 0:
+          fwd_bus = -1
+        elif b == 1:
+          fwd_bus = -1 if m in blocked_msgs else 2
+        elif b == 2:
+          fwd_bus = 1
+
+        # assume len 8
+        self.assertEqual(fwd_bus, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_hyundai.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_RATE_UP = 3
+MAX_RATE_DOWN = 7
+MAX_STEER = 255
+
+MAX_RT_DELTA = 112
+RT_INTERVAL = 250000
+
+DRIVER_TORQUE_ALLOWANCE = 50;
+DRIVER_TORQUE_FACTOR = 2;
+
+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 TestHyundaiSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(7, 0)
+    cls.safety.init_tests_hyundai()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+    return to_send
+
+  def _button_msg(self, buttons):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 1265 << 21
+    to_send[0].RDLR = buttons
+    return to_send
+
+  def _set_prev_torque(self, t):
+    self.safety.set_hyundai_desired_torque_last(t)
+    self.safety.set_hyundai_rt_torque_last(t)
+
+  def _torque_driver_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 897 << 21
+    to_send[0].RDLR = (torque + 2048) << 11
+    return to_send
+
+  def _torque_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 832 << 21
+    to_send[0].RDLR = (torque + 1024) << 16
+    return to_send
+
+  def test_default_controls_not_allowed(self):
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_steer_safety_check(self):
+    for enabled in [0, 1]:
+      for t in range(-0x200, 0x200):
+        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.safety_tx_hook(self._torque_msg(t)))
+        else:
+          self.assertTrue(self.safety.safety_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_enable_control_allowed_from_cruise(self):
+    to_push = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_push[0].RIR = 1057 << 21
+    to_push[0].RDLR = 1 << 13
+
+    self.safety.safety_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 = 1057 << 21
+    to_push[0].RDLR = 0
+
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(to_push)
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_non_realtime_limit_up(self):
+    self.safety.set_hyundai_torque_driver(0, 0)
+    self.safety.set_controls_allowed(True)
+
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP)))
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(-MAX_RATE_UP)))
+
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP + 1)))
+    self.safety.set_controls_allowed(True)
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(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_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_hyundai_torque_driver(t, t)
+        self._set_prev_torque(MAX_STEER * sign)
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_STEER * sign)))
+
+      self.safety.set_hyundai_torque_driver(DRIVER_TORQUE_ALLOWANCE + 1, DRIVER_TORQUE_ALLOWANCE + 1)
+      self.assertFalse(self.safety.safety_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_hyundai_torque_driver(-driver_torque, -driver_torque)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(torque_desired)))
+      self._set_prev_torque(torque_desired + delta)
+      self.safety.set_hyundai_torque_driver(-driver_torque, -driver_torque)
+      self.assertFalse(self.safety.safety_tx_hook(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.assertTrue(self.safety.safety_tx_hook(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.assertTrue(self.safety.safety_tx_hook(self._torque_msg(0)))
+      self._set_prev_torque(MAX_STEER * sign)
+      self.safety.set_hyundai_torque_driver(-MAX_STEER * sign, -MAX_STEER * sign)
+      self.assertFalse(self.safety.safety_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_hyundai()
+      self._set_prev_torque(0)
+      self.safety.set_hyundai_torque_driver(0, 0)
+      for t in np.arange(0, MAX_RT_DELTA, 1):
+        t *= sign
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+      self.assertFalse(self.safety.safety_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.safety_tx_hook(self._torque_msg(t)))
+
+      # Increase timer to update rt_torque_last
+      self.safety.set_timer(RT_INTERVAL + 1)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA - 1))))
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA + 1))))
+
+
+  #def test_spam_cancel_safety_check(self):
+  #  RESUME_BTN = 1
+  #  SET_BTN = 2
+  #  CANCEL_BTN = 4
+  #  BUTTON_MSG = 1265
+  #  self.safety.set_controls_allowed(0)
+  #  self.assertTrue(self.safety.safety_tx_hook(self._button_msg(CANCEL_BTN)))
+  #  self.assertFalse(self.safety.safety_tx_hook(self._button_msg(RESUME_BTN)))
+  #  self.assertFalse(self.safety.safety_tx_hook(self._button_msg(SET_BTN)))
+  #  # do not block resume if we are engaged already
+  #  self.safety.set_controls_allowed(1)
+  #  self.assertTrue(self.safety.safety_tx_hook(self._button_msg(RESUME_BTN)))
+
+  def test_fwd_hook(self):
+
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+    hyundai_giraffe_switch_2 = [0, 1]
+
+    self.safety.set_hyundai_camera_bus(2)
+    for hgs in hyundai_giraffe_switch_2:
+      self.safety.set_hyundai_giraffe_switch_2(hgs)
+      blocked_msgs = [832]
+      for b in buss:
+        for m in msgs:
+          if hgs:
+            if b == 0:
+              fwd_bus = 2
+            elif b == 1:
+              fwd_bus = -1
+            elif b == 2:
+              fwd_bus = -1 if m in blocked_msgs else 0
+          else:
+            fwd_bus = -1
+
+          # assume len 8
+          self.assertEqual(fwd_bus, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_subaru.py

@@ -0,0 +1,194 @@
+#!/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.safety_set_mode(10, 0)
+    cls.safety.init_tests_subaru()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+    return to_send
+
+  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.safety_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.safety_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.safety_tx_hook(self._torque_msg(t)))
+        else:
+          self.assertTrue(self.safety.safety_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.safety_tx_hook(self._torque_msg(MAX_RATE_UP)))
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(-MAX_RATE_UP)))
+
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP + 1)))
+    self.safety.set_controls_allowed(True)
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_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.safety_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.safety_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.safety_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.safety_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.safety_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.safety_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.safety_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.safety_tx_hook(self._torque_msg(t)))
+      self.assertFalse(self.safety.safety_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.safety_tx_hook(self._torque_msg(t)))
+
+      # Increase timer to update rt_torque_last
+      self.safety.set_timer(RT_INTERVAL + 1)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA - 1))))
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_RT_DELTA + 1))))
+
+
+  def test_fwd_hook(self):
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+    blocked_msgs = [290, 356, 545, 802]
+    for b in buss:
+      for m in msgs:
+        if b == 0:
+          fwd_bus = 2
+        elif b == 1:
+          fwd_bus = -1
+        elif b == 2:
+          fwd_bus = -1 if m in blocked_msgs else 0
+
+        # assume len 8
+        self.assertEqual(fwd_bus, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_toyota.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+MAX_RATE_UP = 10
+MAX_RATE_DOWN = 25
+MAX_TORQUE = 1500
+
+MAX_ACCEL = 1500
+MIN_ACCEL = -3000
+
+MAX_RT_DELTA = 375
+RT_INTERVAL = 250000
+
+MAX_TORQUE_ERROR = 350
+
+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 TestToyotaSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(2, 100)
+    cls.safety.init_tests_toyota()
+
+  def _send_msg(self, bus, addr, length):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = length
+    to_send[0].RDTR = bus << 4
+    return to_send
+
+  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)
+
+  def _torque_meas_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x260 << 21
+
+    t = twos_comp(torque, 16)
+    to_send[0].RDHR = t | ((t & 0xFF) << 16)
+    return to_send
+
+  def _torque_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x2E4 << 21
+
+    t = twos_comp(torque, 16)
+    to_send[0].RDLR = t | ((t & 0xFF) << 16)
+    return to_send
+
+  def _accel_msg(self, accel):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x343 << 21
+
+    a = twos_comp(accel, 16)
+    to_send[0].RDLR = (a & 0xFF) << 8 | (a >> 8)
+    return to_send
+
+  def _send_gas_msg(self, gas):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x2C1 << 21
+    to_send[0].RDHR = (gas & 0xFF) << 16
+
+    return to_send
+
+  def _send_interceptor_msg(self, gas, addr):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = addr << 21
+    to_send[0].RDTR = 6
+    to_send[0].RDLR = ((gas & 0xff) << 8) | ((gas & 0xff00) >> 8)
+
+    return to_send
+
+  def _pcm_cruise_msg(self, cruise_on):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x1D2 << 21
+    to_send[0].RDLR = cruise_on << 5
+
+    return to_send
+
+  def test_default_controls_not_allowed(self):
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_manually_enable_controls_allowed(self):
+    self.safety.set_controls_allowed(1)
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_enable_control_allowed_from_cruise(self):
+    self.safety.safety_rx_hook(self._pcm_cruise_msg(False))
+    self.assertFalse(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._pcm_cruise_msg(True))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_disable_control_allowed_from_cruise(self):
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._pcm_cruise_msg(False))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+  def test_prev_gas(self):
+    for g in range(0, 256):
+      self.safety.safety_rx_hook(self._send_gas_msg(g))
+      self.assertEqual(g, self.safety.get_toyota_gas_prev())
+
+  def test_prev_gas_interceptor(self):
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x0, 0x201))
+    self.assertFalse(self.safety.get_gas_interceptor_prev())
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+    self.assertTrue(self.safety.get_gas_interceptor_prev())
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x0, 0x201))
+    self.safety.set_gas_interceptor_detected(False)
+
+  def test_disengage_on_gas(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      self.safety.safety_rx_hook(self._send_gas_msg(0))
+      self.safety.set_controls_allowed(True)
+      self.safety.safety_rx_hook(self._send_gas_msg(1))
+      if long_controls_allowed:
+        self.assertFalse(self.safety.get_controls_allowed())
+      else:
+        self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.set_long_controls_allowed(True)
+
+  def test_allow_engage_with_gas_pressed(self):
+    self.safety.safety_rx_hook(self._send_gas_msg(1))
+    self.safety.set_controls_allowed(True)
+    self.safety.safety_rx_hook(self._send_gas_msg(1))
+    self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._send_gas_msg(1))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+  def test_disengage_on_gas_interceptor(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      self.safety.safety_rx_hook(self._send_interceptor_msg(0, 0x201))
+      self.safety.set_controls_allowed(True)
+      self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+      if long_controls_allowed:
+        self.assertFalse(self.safety.get_controls_allowed())
+      else:
+        self.assertTrue(self.safety.get_controls_allowed())
+      self.safety.safety_rx_hook(self._send_interceptor_msg(0, 0x201))
+      self.safety.set_gas_interceptor_detected(False)
+    self.safety.set_long_controls_allowed(True)
+
+  def test_allow_engage_with_gas_interceptor_pressed(self):
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0x1000, 0x201))
+    self.assertTrue(self.safety.get_controls_allowed())
+    self.safety.safety_rx_hook(self._send_interceptor_msg(0, 0x201))
+    self.safety.set_gas_interceptor_detected(False)
+
+  def test_accel_actuation_limits(self):
+    for long_controls_allowed in [0, 1]:
+      self.safety.set_long_controls_allowed(long_controls_allowed)
+      for accel in np.arange(MIN_ACCEL - 1000, MAX_ACCEL + 1000, 100):
+        for controls_allowed in [True, False]:
+          self.safety.set_controls_allowed(controls_allowed)
+          if controls_allowed and long_controls_allowed:
+            send = MIN_ACCEL <= accel <= MAX_ACCEL
+          else:
+            send = accel == 0
+          self.assertEqual(send, self.safety.safety_tx_hook(self._accel_msg(accel)))
+    self.safety.set_long_controls_allowed(True)
+
+  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_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)
+          else:
+            send = torque == 0
+
+          self.assertEqual(send, self.safety.safety_tx_hook(self._torque_msg(torque)))
+
+  def test_non_realtime_limit_up(self):
+    self.safety.set_controls_allowed(True)
+
+    self._set_prev_torque(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP)))
+
+    self._set_prev_torque(0)
+    self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(MAX_RATE_UP + 1)))
+
+  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.assertTrue(self.safety.safety_tx_hook(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.assertFalse(self.safety.safety_tx_hook(self._torque_msg(1000 - MAX_RATE_DOWN + 1)))
+
+  def test_exceed_torque_sensor(self):
+    self.safety.set_controls_allowed(True)
+
+    for sign in [-1, 1]:
+      self._set_prev_torque(0)
+      for t in np.arange(0, MAX_TORQUE_ERROR + 10, 10):
+        t *= sign
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+
+      self.assertFalse(self.safety.safety_tx_hook(self._torque_msg(sign * (MAX_TORQUE_ERROR + 10))))
+
+  def test_realtime_limit_up(self):
+    self.safety.set_controls_allowed(True)
+
+    for sign in [-1, 1]:
+      self.safety.init_tests_toyota()
+      self._set_prev_torque(0)
+      for t in np.arange(0, 380, 10):
+        t *= sign
+        self.safety.set_toyota_torque_meas(t, t)
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+      self.assertFalse(self.safety.safety_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_toyota_torque_meas(t, t)
+        self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(t)))
+
+      # Increase timer to update rt_torque_last
+      self.safety.set_timer(RT_INTERVAL + 1)
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * 370)))
+      self.assertTrue(self.safety.safety_tx_hook(self._torque_msg(sign * 380)))
+
+  def test_torque_measurements(self):
+    self.safety.safety_rx_hook(self._torque_meas_msg(50))
+    self.safety.safety_rx_hook(self._torque_meas_msg(-50))
+    self.safety.safety_rx_hook(self._torque_meas_msg(0))
+    self.safety.safety_rx_hook(self._torque_meas_msg(0))
+    self.safety.safety_rx_hook(self._torque_meas_msg(0))
+    self.safety.safety_rx_hook(self._torque_meas_msg(0))
+
+    self.assertEqual(-51, self.safety.get_toyota_torque_meas_min())
+    self.assertEqual(51, self.safety.get_toyota_torque_meas_max())
+
+    self.safety.safety_rx_hook(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.safety.safety_rx_hook(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())
+
+  def test_gas_interceptor_safety_check(self):
+
+    self.safety.set_controls_allowed(0)
+    self.assertTrue(self.safety.safety_tx_hook(self._send_interceptor_msg(0, 0x200)))
+    self.assertFalse(self.safety.safety_tx_hook(self._send_interceptor_msg(0x1000, 0x200)))
+    self.safety.set_controls_allowed(1)
+    self.assertTrue(self.safety.safety_tx_hook(self._send_interceptor_msg(0x1000, 0x200)))
+
+  def test_fwd_hook(self):
+
+    buss = range(0x0, 0x3)
+    msgs = range(0x1, 0x800)
+    long_controls_allowed = [0, 1]
+    toyota_camera_forwarded = [0, 1]
+
+    for tcf in toyota_camera_forwarded:
+      self.safety.set_toyota_camera_forwarded(tcf)
+      for lca in long_controls_allowed:
+        self.safety.set_long_controls_allowed(lca)
+        blocked_msgs = [0x2E4, 0x412, 0x191]
+        if lca:
+          blocked_msgs += [0x343]
+        for b in buss:
+          for m in msgs:
+            if tcf:
+              if b == 0:
+                fwd_bus = 2
+              elif b == 1:
+                fwd_bus = -1
+              elif b == 2:
+                fwd_bus = -1 if m in blocked_msgs else 0
+            else:
+              fwd_bus = -1
+
+            # assume len 8
+            self.assertEqual(fwd_bus, self.safety.safety_fwd_hook(b, self._send_msg(b, m, 8)))
+
+    self.safety.set_long_controls_allowed(True)
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety/test_toyota_ipas.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python2
+import unittest
+import numpy as np
+import libpandasafety_py
+
+IPAS_OVERRIDE_THRESHOLD = 200
+
+ANGLE_DELTA_BP = [0., 5., 15.]
+ANGLE_DELTA_V = [5., .8, .15]     # windup limit
+ANGLE_DELTA_VU = [5., 3.5, 0.4]   # unwind limit
+
+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 TestToyotaSafety(unittest.TestCase):
+  @classmethod
+  def setUp(cls):
+    cls.safety = libpandasafety_py.libpandasafety
+    cls.safety.safety_set_mode(0x1335, 66)
+    cls.safety.init_tests_toyota()
+
+  def _torque_driver_msg(self, torque):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x260 << 21
+
+    t = twos_comp(torque, 16)
+    to_send[0].RDLR = t | ((t & 0xFF) << 16)
+    return to_send
+
+  def _torque_driver_msg_array(self, torque):
+    for i in range(6):
+      self.safety.safety_rx_hook(self._torque_driver_msg(torque))
+
+  def _angle_meas_msg(self, angle):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x25 << 21
+
+    t = twos_comp(angle, 12)
+    to_send[0].RDLR = ((t & 0xF00) >> 8) | ((t & 0xFF) << 8)
+    return to_send
+
+  def _angle_meas_msg_array(self, angle):
+    for i in range(6):
+      self.safety.safety_rx_hook(self._angle_meas_msg(angle))
+
+  def _ipas_state_msg(self, state):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x262 << 21
+
+    to_send[0].RDLR = state & 0xF
+    return to_send
+
+  def _ipas_control_msg(self, angle, state):
+    # note: we command 2/3 of the angle due to CAN conversion
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0x266 << 21
+
+    t = twos_comp(angle, 12)
+    to_send[0].RDLR = ((t & 0xF00) >> 8) | ((t & 0xFF) << 8)
+    to_send[0].RDLR |= ((state & 0xf) << 4)
+
+    return to_send
+
+  def _speed_msg(self, speed):
+    to_send = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+    to_send[0].RIR = 0xb4 << 21
+    speed = int(speed * 100 * 3.6)
+
+    to_send[0].RDHR = ((speed & 0xFF) << 16) | (speed & 0xFF00)
+    return to_send
+
+  def test_ipas_override(self):
+
+    ## angle control is not active
+    self.safety.set_controls_allowed(1)
+
+    # 3 consecutive msgs where driver exceeds threshold but angle_control isn't active
+    self.safety.set_controls_allowed(1)
+    self._torque_driver_msg_array(IPAS_OVERRIDE_THRESHOLD + 1)
+    self.assertTrue(self.safety.get_controls_allowed())
+
+    self._torque_driver_msg_array(-IPAS_OVERRIDE_THRESHOLD - 1)
+    self.assertTrue(self.safety.get_controls_allowed())
+
+    # ipas state is override
+    self.safety.safety_rx_hook(self._ipas_state_msg(5))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+    ## now angle control is active
+    self.safety.safety_tx_hook(self._ipas_control_msg(0, 0))
+    self.safety.safety_rx_hook(self._ipas_state_msg(0))
+
+    # 3 consecutive msgs where driver does exceed threshold
+    self.safety.set_controls_allowed(1)
+    self._torque_driver_msg_array(IPAS_OVERRIDE_THRESHOLD + 1)
+    self.assertFalse(self.safety.get_controls_allowed())
+
+    self.safety.set_controls_allowed(1)
+    self._torque_driver_msg_array(-IPAS_OVERRIDE_THRESHOLD - 1)
+    self.assertFalse(self.safety.get_controls_allowed())
+
+    # ipas state is override and torque isn't overriding any more
+    self.safety.set_controls_allowed(1)
+    self._torque_driver_msg_array(0)
+    self.safety.safety_rx_hook(self._ipas_state_msg(5))
+    self.assertFalse(self.safety.get_controls_allowed())
+
+    # 3 consecutive msgs where driver does not exceed threshold and
+    # ipas state is not override
+    self.safety.set_controls_allowed(1)
+    self.safety.safety_rx_hook(self._ipas_state_msg(0))
+    self.assertTrue(self.safety.get_controls_allowed())
+
+    self._torque_driver_msg_array(IPAS_OVERRIDE_THRESHOLD)
+    self.assertTrue(self.safety.get_controls_allowed())
+
+    self._torque_driver_msg_array(-IPAS_OVERRIDE_THRESHOLD)
+    self.assertTrue(self.safety.get_controls_allowed())
+
+    # reset no angle control at the end of the test
+    self.safety.reset_angle_control()
+
+  def test_angle_cmd_when_disabled(self):
+
+    self.safety.set_controls_allowed(0)
+
+    # test angle cmd too far from actual
+    angle_refs = [-10, 10]
+    deltas = range(-2, 3)
+    expected_results = [False, True, True, True, False]
+
+    for a in angle_refs:
+      self._angle_meas_msg_array(a)
+      for i, d in enumerate(deltas):
+        self.assertEqual(expected_results[i], self.safety.safety_tx_hook(self._ipas_control_msg(a + d, 1)))
+
+    # test ipas state cmd enabled
+    self._angle_meas_msg_array(0)
+    self.assertEqual(0, self.safety.safety_tx_hook(self._ipas_control_msg(0, 3)))
+
+    # reset no angle control at the end of the test
+    self.safety.reset_angle_control()
+
+  def test_angle_cmd_when_enabled(self):
+
+    # ipas angle cmd should pass through when controls are enabled
+
+    self.safety.set_controls_allowed(1)
+    self._angle_meas_msg_array(0)
+    self.safety.safety_rx_hook(self._speed_msg(0.1))
+
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(0, 1)))
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(4, 1)))
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(0, 3)))
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(-4, 3)))
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(-8, 3)))
+
+    # reset no angle control at the end of the test
+    self.safety.reset_angle_control()
+
+  def test_angle_cmd_rate_when_disabled(self):
+
+    # as long as the command is close to the measured, no rate limit is enforced when
+    # controls are disabled
+    self.safety.set_controls_allowed(0)
+    self.safety.safety_rx_hook(self._angle_meas_msg(0))
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(0, 1)))
+    self.safety.safety_rx_hook(self._angle_meas_msg(100))
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(100, 1)))
+    self.safety.safety_rx_hook(self._angle_meas_msg(-100))
+    self.assertEqual(1, self.safety.safety_tx_hook(self._ipas_control_msg(-100, 1)))
+
+    # reset no angle control at the end of the test
+    self.safety.reset_angle_control()
+
+  def test_angle_cmd_rate_when_enabled(self):
+
+    # when controls are allowed, angle cmd rate limit is enforced
+    # test 1: no limitations if we stay within limits
+    speeds = [0., 1., 5., 10., 15., 100.]
+    angles = [-300, -100, -10, 0, 10, 100, 300]
+    for a in angles:
+      for s in speeds:
+
+        # first test against false positives
+        self._angle_meas_msg_array(a)
+        self.safety.safety_tx_hook(self._ipas_control_msg(a, 1))
+        self.safety.set_controls_allowed(1)
+        self.safety.safety_rx_hook(self._speed_msg(s))
+        max_delta_up = int(np.interp(s, ANGLE_DELTA_BP, ANGLE_DELTA_V) * 2 / 3. + 1.)
+        max_delta_down = int(np.interp(s, ANGLE_DELTA_BP, ANGLE_DELTA_VU) * 2 / 3. + 1.)
+        self.assertEqual(True, self.safety.safety_tx_hook(self._ipas_control_msg(a + sign(a) * max_delta_up, 1)))
+        self.assertTrue(self.safety.get_controls_allowed())
+        self.assertEqual(True, self.safety.safety_tx_hook(self._ipas_control_msg(a, 1)))
+        self.assertTrue(self.safety.get_controls_allowed())
+        self.assertEqual(True, self.safety.safety_tx_hook(self._ipas_control_msg(a - sign(a) * max_delta_down, 1)))
+        self.assertTrue(self.safety.get_controls_allowed())
+
+        # now inject too high rates
+        self.assertEqual(False, self.safety.safety_tx_hook(self._ipas_control_msg(a + sign(a) *
+                                                                                  (max_delta_up + 1), 1)))
+        self.assertFalse(self.safety.get_controls_allowed())
+        self.safety.set_controls_allowed(1)
+        self.assertEqual(True, self.safety.safety_tx_hook(self._ipas_control_msg(a + sign(a) * max_delta_up, 1)))
+        self.assertTrue(self.safety.get_controls_allowed())
+        self.assertEqual(True, self.safety.safety_tx_hook(self._ipas_control_msg(a, 1)))
+        self.assertTrue(self.safety.get_controls_allowed())
+        self.assertEqual(False, self.safety.safety_tx_hook(self._ipas_control_msg(a - sign(a) *
+                                                                                  (max_delta_down + 1), 1)))
+        self.assertFalse(self.safety.get_controls_allowed())
+
+    # reset no angle control at the end of the test
+    self.safety.reset_angle_control()
+
+  def test_angle_measured_rate(self):
+
+    speeds = [0., 1., 5., 10., 15., 100.]
+    angles = [-300, -100, -10, 0, 10, 100, 300]
+    angles = [10]
+    for a in angles:
+      for s in speeds:
+        self._angle_meas_msg_array(a)
+        self.safety.safety_tx_hook(self._ipas_control_msg(a, 1))
+        self.safety.set_controls_allowed(1)
+        self.safety.safety_rx_hook(self._speed_msg(s))
+        max_delta_up = int(np.interp(s, ANGLE_DELTA_BP, ANGLE_DELTA_V) * 2 / 3. + 1.)
+        max_delta_down = int(np.interp(s, ANGLE_DELTA_BP, ANGLE_DELTA_VU) * 2 / 3. + 1.)
+        self.safety.safety_rx_hook(self._angle_meas_msg(a))
+        self.assertTrue(self.safety.get_controls_allowed())
+        self.safety.safety_rx_hook(self._angle_meas_msg(a + 150))
+        self.assertFalse(self.safety.get_controls_allowed())
+
+    # reset no angle control at the end of the test
+    self.safety.reset_angle_control()
+
+
+if __name__ == "__main__":
+  unittest.main()

tests/safety_replay/Dockerfile

@@ -0,0 +1,20 @@
+FROM ubuntu:16.04
+
+RUN apt-get update && apt-get install -y make clang python python-pip git libarchive-dev libusb-1.0-0
+
+COPY tests/safety_replay/requirements.txt requirements.txt
+RUN pip install -r requirements.txt
+COPY tests/safety_replay/install_capnp.sh install_capnp.sh
+RUN ./install_capnp.sh
+
+RUN mkdir /openpilot
+WORKDIR /openpilot
+RUN git clone https://github.com/commaai/cereal.git || true
+WORKDIR /openpilot/cereal
+RUN git checkout f7043fde062cbfd49ec90af669901a9caba52de9
+COPY . /openpilot/panda
+
+WORKDIR /openpilot/panda/tests/safety_replay
+RUN git clone https://github.com/commaai/openpilot-tools.git tools || true
+WORKDIR tools
+RUN git checkout b6461274d684915f39dc45efc5292ea890698da9

tests/safety_replay/helpers.py

@@ -0,0 +1,104 @@
+import struct
+import panda.tests.safety.libpandasafety_py as libpandasafety_py
+
+safety_modes = {
+  "NOOUTPUT": 0,
+  "HONDA": 1,
+  "TOYOTA": 2,
+  "GM": 3,
+  "HONDA_BOSCH": 4,
+  "FORD": 5,
+  "CADILLAC": 6,
+  "HYUNDAI": 7,
+  "TESLA": 8,
+  "CHRYSLER": 9,
+  "SUBARU": 10,
+  "GM_ASCM": 0x1334,
+  "TOYOTA_IPAS": 0x1335,
+  "ALLOUTPUT": 0x1337,
+  "ELM327": 0xE327
+}
+
+def to_signed(d, bits):
+  ret = d
+  if d >= (1 << (bits - 1)):
+    ret = d - (1 << bits)
+  return ret
+
+def is_steering_msg(mode, addr):
+  ret = False
+  if mode == safety_modes["HONDA"] or mode == safety_modes["HONDA_BOSCH"]:
+    ret = (addr == 0xE4) or (addr == 0x194) or (addr == 0x33D)
+  elif mode == safety_modes["TOYOTA"]:
+    ret = addr == 0x2E4
+  elif mode == safety_modes["GM"]:
+    ret = addr == 384
+  elif mode == safety_modes["HYUNDAI"]:
+    ret = addr == 832
+  elif mode == safety_modes["CHRYSLER"]:
+    ret = addr == 0x292
+  elif mode == safety_modes["SUBARU"]:
+    ret = addr == 0x122
+  return ret
+
+def get_steer_torque(mode, to_send):
+  ret = 0
+  if mode == safety_modes["HONDA"] or mode == safety_modes["HONDA_BOSCH"]:
+    ret = to_send.RDLR & 0xFFFF0000
+  elif mode == safety_modes["TOYOTA"]:
+    ret = (to_send.RDLR & 0xFF00) | ((to_send.RDLR >> 16) & 0xFF)
+    ret = to_signed(ret, 16)
+  elif mode == safety_modes["GM"]:
+    ret = ((to_send.RDLR & 0x7) << 8) + ((to_send.RDLR & 0xFF00) >> 8)
+    ret = to_signed(ret, 11)
+  elif mode == safety_modes["HYUNDAI"]:
+    ret = ((to_send.RDLR >> 16) & 0x7ff) - 1024
+  elif mode == safety_modes["CHRYSLER"]:
+    ret = ((to_send.RDLR & 0x7) << 8) + ((to_send.RDLR & 0xFF00) >> 8) - 1024
+  elif mode == safety_modes["SUBARU"]:
+    ret = ((to_send.RDLR >> 16) & 0x1FFF)
+    ret = to_signed(ret, 13)
+  return ret
+
+def set_desired_torque_last(safety, mode, torque):
+  if mode == safety_modes["HONDA"] or mode == safety_modes["HONDA_BOSCH"]:
+    pass # honda safety mode doesn't enforce a rate on steering msgs
+  elif mode == safety_modes["TOYOTA"]:
+    safety.set_toyota_desired_torque_last(torque)
+  elif mode == safety_modes["GM"]:
+    safety.set_gm_desired_torque_last(torque)
+  elif mode == safety_modes["HYUNDAI"]:
+    safety.set_hyundai_desired_torque_last(torque)
+  elif mode == safety_modes["CHRYSLER"]:
+    safety.set_chrysler_desired_torque_last(torque)
+  elif mode == safety_modes["SUBARU"]:
+    safety.set_subaru_desired_torque_last(torque)
+
+def package_can_msg(msg):
+  addr_shift = 3 if msg.address >= 0x800 else 21
+  rdlr, rdhr = struct.unpack('II', msg.dat.ljust(8, b'\x00'))
+
+  ret = libpandasafety_py.ffi.new('CAN_FIFOMailBox_TypeDef *')
+  ret[0].RIR = msg.address << addr_shift
+  ret[0].RDTR = len(msg.dat) | ((msg.src & 0xF) << 4)
+  ret[0].RDHR = rdhr
+  ret[0].RDLR = rdlr
+
+  return ret
+
+def init_segment(safety, lr, mode):
+  sendcan = (msg for msg in lr if msg.which() == 'sendcan')
+  steering_msgs = (can for msg in sendcan for can in msg.sendcan if is_steering_msg(mode, can.address))
+
+  msg = next(steering_msgs, None)
+  if msg is None:
+    # no steering msgs
+    return
+
+  to_send = package_can_msg(msg)
+  torque = get_steer_torque(mode, to_send)
+  if torque != 0:
+    safety.set_controls_allowed(1)
+    set_desired_torque_last(safety, mode, torque)
+    assert safety.safety_tx_hook(to_send), "failed to initialize panda safety for segment"
+

tests/safety_replay/install_capnp.sh

@@ -0,0 +1,20 @@
+#!/bin/bash -e
+
+apt-get install -y autoconf curl libtool
+curl -O https://capnproto.org/capnproto-c++-0.6.1.tar.gz
+tar xvf capnproto-c++-0.6.1.tar.gz
+cd capnproto-c++-0.6.1
+./configure --prefix=/usr/local CPPFLAGS=-DPIC CFLAGS=-fPIC CXXFLAGS=-fPIC LDFLAGS=-fPIC --disable-shared --enable-static
+make -j4
+make install
+
+cd ..
+git clone https://github.com/commaai/c-capnproto.git
+cd c-capnproto
+git checkout 2e625acacf58a5f5c8828d8453d1f8dacc700a96
+git submodule update --init --recursive
+autoreconf -f -i -s
+CFLAGS="-fPIC" ./configure --prefix=/usr/local
+make -j4
+make install
+

tests/safety_replay/replay_drive.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python2
+
+import os
+import sys
+import panda.tests.safety.libpandasafety_py as libpandasafety_py
+from panda.tests.safety_replay.helpers import is_steering_msg, get_steer_torque, \
+                                              set_desired_torque_last, package_can_msg, \
+                                              init_segment, safety_modes
+from tools.lib.logreader import LogReader
+
+# replay a drive to check for safety violations
+def replay_drive(lr, safety_mode, param):
+  safety = libpandasafety_py.libpandasafety
+
+  err = safety.safety_set_mode(safety_mode, param)
+  assert err == 0, "invalid safety mode: %d" % safety_mode
+
+  if "SEGMENT" in os.environ:
+    init_segment(safety, lr, mode)
+
+  tx_tot, tx_blocked, tx_controls, tx_controls_blocked = 0, 0, 0, 0
+  blocked_addrs = set()
+  start_t = None
+
+  for msg in lr:
+    if start_t is None:
+      start_t = msg.logMonoTime
+    safety.set_timer(((msg.logMonoTime / 1000))  % 0xFFFFFFFF)
+
+    if msg.which() == 'sendcan':
+     for canmsg in msg.sendcan:
+        to_send = package_can_msg(canmsg)
+        sent = safety.safety_tx_hook(to_send)
+        if not sent:
+          tx_blocked += 1
+          tx_controls_blocked += safety.get_controls_allowed()
+          blocked_addrs.add(canmsg.address)
+
+          if "DEBUG" in os.environ:
+            print "blocked %d at %f" % (canmsg.address, (msg.logMonoTime - start_t)/(1e9))
+        tx_controls += safety.get_controls_allowed()
+        tx_tot += 1
+    elif msg.which() == 'can':
+      for canmsg in msg.can:
+        # ignore msgs we sent
+        if canmsg.src >= 128:
+          continue
+        to_push = package_can_msg(canmsg)
+        safety.safety_rx_hook(to_push)
+
+  print "total openpilot msgs:", tx_tot
+  print "total msgs with controls allowed:", tx_controls
+  print "blocked msgs:", tx_blocked
+  print "blocked with controls allowed:", tx_controls_blocked
+  print "blocked addrs:", blocked_addrs
+
+  return tx_controls_blocked == 0
+
+if __name__ == "__main__":
+  if sys.argv[2] in safety_modes:
+    mode = safety_modes[sys.argv[2]]
+  else:
+    mode = int(sys.argv[2])
+  param = 0 if len(sys.argv) < 4 else int(sys.argv[3])
+  lr = LogReader(sys.argv[1])
+
+  print "replaying drive %s with safety mode %d and param %d" % (sys.argv[1], mode, param)
+
+  replay_drive(lr, mode, param)
+

tests/safety_replay/requirements.txt

@@ -0,0 +1,8 @@
+aenum
+cffi==1.11.4
+libusb1==1.6.6
+numpy==1.14.5
+requests
+subprocess32
+libarchive
+pycapnp

tests/safety_replay/test_safety_replay.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python2
+
+import os
+import requests
+
+from helpers import safety_modes
+from replay_drive import replay_drive
+from tools.lib.logreader import LogReader
+
+BASE_URL = "https://commadataci.blob.core.windows.net/openpilotci/"
+
+# (route, safety mode, param)
+logs = [
+  ("b0c9d2329ad1606b|2019-05-30--20-23-57.bz2", "HONDA", 0), # HONDA.CIVIC
+  ("38bfd238edecbcd7|2019-06-07--10-15-25.bz2", "TOYOTA", 66), # TOYOTA.PRIUS
+  ("f89c604cf653e2bf|2018-09-29--13-46-50.bz2", "GM", 0), # GM.VOLT
+  ("0375fdf7b1ce594d|2019-05-21--20-10-33.bz2", "HONDA_BOSCH", 1), # HONDA.ACCORD
+  ("02ec6bea180a4d36|2019-04-17--11-21-35.bz2", "HYUNDAI", 0), # HYUNDAI.SANTA_FE
+  ("03efb1fda29e30fe|2019-02-21--18-03-45.bz2", "CHRYSLER", 0), # CHRYSLER.PACIFICA_2018_HYBRID
+  ("791340bc01ed993d|2019-04-08--10-26-00.bz2", "SUBARU", 0), # SUBARU.IMPREZA
+]
+
+if __name__ == "__main__":
+  for route, _, _ in logs:
+    if not os.path.isfile(route):
+      with open(route, "w") as f:
+        f.write(requests.get(BASE_URL + route).content)
+
+  failed = []
+  for route, mode, param in logs:
+    lr = LogReader(route)
+    m = safety_modes.get(mode, mode)
+
+    print "\nreplaying %s with safety mode %d and param %s" % (route, m, param)
+    if not replay_drive(lr, m, int(param)):
+      failed.append(route)
+
+    for f in failed:
+      print "\n**** failed on %s ****" % f
+    assert len(failed) == 0, "\nfailed on %d logs" % len(failed)
+

tests/standalone_test.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+import os
+import sys
+import struct
+import time
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda
+
+if __name__ == "__main__":
+  if os.getenv("WIFI") is not None:
+    p = Panda("WIFI")
+  else:
+    p = Panda()
+  print(p.get_serial())
+  print(p.health())
+
+  t1 = time.time()
+  for i in range(100):
+    p.get_serial()
+  t2 = time.time()
+  print("100 requests took %.2f ms" % ((t2-t1)*1000))
+
+  p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
+
+  a = 0
+  while True:
+    # flood
+    msg = b"\xaa"*4 + struct.pack("I", a)
+    p.can_send(0xaa, msg, 0)
+    p.can_send(0xaa, msg, 1)
+    p.can_send(0xaa, msg, 4)
+    time.sleep(0.01)
+
+    dat = p.can_recv()
+    if len(dat) > 0:
+      print(dat)
+    a += 1

tests/throughput_test.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os
+import sys
+import struct
+import time
+from tqdm import tqdm
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda, PandaWifiStreaming
+
+# test throughput between USB and wifi
+
+if __name__ == "__main__":
+  print(Panda.list())
+  p_out = Panda("108018800f51363038363036")
+  print(p_out.get_serial())
+  #p_in = Panda("02001b000f51363038363036")
+  p_in = Panda("WIFI")
+  print(p_in.get_serial())
+
+  p_in = PandaWifiStreaming()
+
+  #while True:
+  #  p_in.can_recv()
+  #sys.exit(0)
+
+  p_out.set_controls_allowed(True)
+
+  set_out, set_in = set(), set()
+
+  # drain
+  p_out.can_recv()
+  p_in.can_recv()
+
+  BATCH_SIZE = 16
+  for a in tqdm(range(0, 10000, BATCH_SIZE)):
+    for b in range(0, BATCH_SIZE):
+      msg = b"\xaa"*4 + struct.pack("I", a+b)
+      if a%1 == 0:
+        p_out.can_send(0xaa, msg, 0)
+
+    dat_out, dat_in = p_out.can_recv(), p_in.can_recv()
+    if len(dat_in) != 0:
+      print(len(dat_in))
+
+    num_out = [struct.unpack("I", i[4:])[0] for _, _, i, _ in dat_out]
+    num_in = [struct.unpack("I", i[4:])[0] for _, _, i, _ in dat_in]
+
+    set_in.update(num_in)
+    set_out.update(num_out)
+
+  # swag
+  print("waiting for packets")
+  time.sleep(2.0)
+  dat_in = p_in.can_recv()
+  print(len(dat_in))
+  num_in = [struct.unpack("I", i[4:])[0] for _, _, i, _ in dat_in]
+  set_in.update(num_in)
+
+  if len(set_out - set_in):
+    print("MISSING %d" % len(set_out - set_in))
+    if len(set_out - set_in) < 256:
+      print(map(hex, sorted(list(set_out - set_in))))

tests/tucan_loopback.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os
+import sys
+import time
+import random
+import argparse
+
+from hexdump import hexdump
+from itertools import permutations
+
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+from panda import Panda
+
+def get_test_string():
+  return b"test"+os.urandom(10)
+
+def run_test(sleep_duration):
+  pandas = Panda.list()
+  print(pandas)
+
+  if len(pandas) == 0:
+    print("NO PANDAS")
+    assert False
+
+  if len(pandas) == 1:
+    # if we only have one on USB, assume the other is on wifi
+    pandas.append("WIFI")
+  run_test_w_pandas(pandas, sleep_duration)
+
+def run_test_w_pandas(pandas, sleep_duration):
+  h = list(map(lambda x: Panda(x), pandas))
+  print("H", h)
+
+  for hh in h:
+    hh.set_controls_allowed(True)
+
+  # test both directions
+  for ho in permutations(range(len(h)), r=2):
+    print("***************** TESTING", ho)
+
+    panda0, panda1 = h[ho[0]], h[ho[1]]
+
+    if(panda0._serial == "WIFI"):
+      print("  *** Can not send can data over wifi panda. Skipping! ***")
+      continue
+
+    # **** test health packet ****
+    print("health", ho[0], h[ho[0]].health())
+
+    # **** test K/L line loopback ****
+    for bus in [2,3]:
+      # flush the output
+      h[ho[1]].kline_drain(bus=bus)
+
+      # send the characters
+      st = get_test_string()
+      st = b"\xaa"+chr(len(st)+3).encode()+st
+      h[ho[0]].kline_send(st, bus=bus, checksum=False)
+
+      # check for receive
+      ret = h[ho[1]].kline_drain(bus=bus)
+
+      print("ST Data:")
+      hexdump(st)
+      print("RET Data:")
+      hexdump(ret)
+      assert st == ret
+      print("K/L pass", bus, ho, "\n")
+      time.sleep(sleep_duration)
+
+    # **** test can line loopback ****
+#    for bus, gmlan in [(0, None), (1, False), (2, False), (1, True), (2, True)]:
+for bus, gmlan in [(0, None), (1, None)]:
+      print("\ntest can", bus)
+      # flush
+      cans_echo = panda0.can_recv()
+      cans_loop = panda1.can_recv()
+
+      if gmlan is not None:
+        panda0.set_gmlan(gmlan, bus)
+        panda1.set_gmlan(gmlan, bus)
+
+      # send the characters
+      # pick addresses high enough to not conflict with honda code
+      at = random.randint(1024, 2000)
+      st = get_test_string()[0:8]
+      panda0.can_send(at, st, bus)
+      time.sleep(0.1)
+
+      # check for receive
+      cans_echo = panda0.can_recv()
+      cans_loop = panda1.can_recv()
+
+      print("Bus", bus, "echo", cans_echo, "loop", cans_loop)
+
+      assert len(cans_echo) == 1
+      assert len(cans_loop) == 1
+
+      assert cans_echo[0][0] == at
+      assert cans_loop[0][0] == at
+
+      assert cans_echo[0][2] == st
+      assert cans_loop[0][2] == st
+
+      assert cans_echo[0][3] == 0x80 | bus
+      if cans_loop[0][3] != bus:
+        print("EXPECTED %d GOT %d" % (bus, cans_loop[0][3]))
+      assert cans_loop[0][3] == bus
+
+      print("CAN pass", bus, ho)
+      time.sleep(sleep_duration)
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser()
+  parser.add_argument("-n", type=int, help="Number of test iterations to run")
+  parser.add_argument("-sleep", type=int, help="Sleep time between tests", default=0)
+  args = parser.parse_args()
+
+  if args.n is None:
+    while True:
+      run_test(sleep_duration=args.sleep)
+  else:
+    for i in range(args.n):
+      run_test(sleep_duration=args.sleep)