IQ.Pilot Release Commit @ 0798119

selfdrive/pandad/tests/test_pandad.py

@@ -0,0 +1,114 @@
+import os
+import pytest
+import time
+
+import cereal.messaging as messaging
+from cereal import log
+from openpilot.common.gpio import gpio_set, gpio_init
+from panda import Panda, PandaDFU
+from openpilot.system.manager.process_config import managed_processes
+from openpilot.system.hardware import HARDWARE
+from openpilot.system.hardware.tici.pins import GPIO
+
+HERE = os.path.dirname(os.path.realpath(__file__))
+
+
+@pytest.mark.tici
+class TestPandad:
+
+  def setup_method(self):
+    # ensure panda is up
+    if len(Panda.list()) == 0:
+      self._run_test(60)
+
+  def teardown_method(self):
+    managed_processes['pandad'].stop()
+
+  def _run_test(self, timeout=30) -> float:
+    st = time.monotonic()
+    sm = messaging.SubMaster(['pandaStates'])
+
+    managed_processes['pandad'].start()
+    while (time.monotonic() - st) < timeout:
+      sm.update(100)
+      if len(sm['pandaStates']) and sm['pandaStates'][0].pandaType != log.PandaState.PandaType.unknown:
+        break
+    dt = time.monotonic() - st
+    managed_processes['pandad'].stop()
+
+    if len(sm['pandaStates']) == 0 or sm['pandaStates'][0].pandaType == log.PandaState.PandaType.unknown:
+      raise Exception("pandad failed to start")
+
+    return dt
+
+  def _go_to_dfu(self):
+    HARDWARE.recover_internal_panda()
+    assert Panda.wait_for_dfu(None, 10)
+
+  def _assert_no_panda(self):
+    assert not Panda.wait_for_dfu(None, 3)
+    assert not Panda.wait_for_panda(None, 3)
+
+  def _flash_bootstub(self, fn):
+    self._go_to_dfu()
+    pd = PandaDFU(None)
+    if fn is None:
+      fn = os.path.join(HERE, pd.get_mcu_type().config.bootstub_fn)
+    with open(fn, "rb") as f:
+      pd.program_bootstub(f.read())
+    pd.reset()
+    HARDWARE.reset_internal_panda()
+
+  def test_in_dfu(self):
+    HARDWARE.recover_internal_panda()
+    self._run_test(60)
+
+  def test_in_bootstub(self):
+    with Panda() as p:
+      p.reset(enter_bootstub=True)
+      assert p.bootstub
+    self._run_test()
+
+  def test_internal_panda_reset(self):
+    gpio_init(GPIO.STM_RST_N, True)
+    gpio_set(GPIO.STM_RST_N, 1)
+    time.sleep(0.5)
+    assert all(not Panda(s).is_internal() for s in Panda.list())
+    self._run_test()
+
+    assert any(Panda(s).is_internal() for s in Panda.list())
+
+  def test_best_case_startup_time(self):
+    # run once so we're up to date
+    self._run_test(60)
+
+    ts = []
+    for _ in range(10):
+      # should be nearly instant this time
+      dt = self._run_test(5)
+      ts.append(dt)
+
+    # 5s for USB (due to enumeration)
+    # - 0.2s pandad -> pandad
+    # - plus some buffer
+    print("startup times", ts, sum(ts) / len(ts))
+    assert 0.1 < (sum(ts)/len(ts)) < 0.7
+
+  def test_old_spi_protocol(self):
+    # flash firmware with old SPI protocol
+    self._flash_bootstub(os.path.join(HERE, "bootstub.panda_h7_spiv0.bin"))
+    self._run_test(45)
+
+  def test_release_to_devel_bootstub(self):
+    self._flash_bootstub(None)
+    self._run_test(45)
+
+  def test_recover_from_bad_bootstub(self):
+    self._go_to_dfu()
+    with PandaDFU(None) as pd:
+      pd.program_bootstub(b"\x00"*1024)
+      pd.reset()
+    HARDWARE.reset_internal_panda()
+    self._assert_no_panda()
+
+    self._run_test(60)

selfdrive/pandad/tests/test_pandad_loopback.py

@@ -0,0 +1,113 @@
+import os
+import copy
+import random
+import time
+import pytest
+from collections import defaultdict
+from pprint import pprint
+
+import cereal.messaging as messaging
+from cereal import car, log
+from iqdbc.car.can_definitions import CanData
+from openpilot.common.utils import retry
+from openpilot.common.params import Params
+from openpilot.common.timeout import Timeout
+from openpilot.selfdrive.pandad import can_list_to_can_capnp
+from openpilot.system.hardware import TICI
+from openpilot.selfdrive.test.helpers import with_processes
+
+
+@retry(attempts=3)
+def setup_pandad(num_pandas):
+  params = Params()
+  params.clear_all()
+  params.put_bool("IsOnroad", False)
+
+  sm = messaging.SubMaster(['pandaStates'])
+  with Timeout(90, "pandad didn't start"):
+    while sm.recv_frame['pandaStates'] < 1 or len(sm['pandaStates']) == 0 or \
+        any(ps.pandaType == log.PandaState.PandaType.unknown for ps in sm['pandaStates']):
+      sm.update(1000)
+
+  found_pandas = len(sm['pandaStates'])
+  assert num_pandas == found_pandas, "connected pandas ({found_pandas}) doesn't match expected panda count ({num_pandas}). \
+                                      connect another panda for multipanda tests."
+
+  # pandad safety setting relies on these params
+  cp = car.CarParams.new_message()
+
+  safety_config = car.CarParams.SafetyConfig.new_message()
+  safety_config.safetyModel = car.CarParams.SafetyModel.allOutput
+  cp.safetyConfigs = [safety_config]*num_pandas
+
+  params.put_bool("IsOnroad", True)
+  params.put_bool("FirmwareQueryDone", True)
+  params.put_bool("ControlsReady", True)
+  params.put("CarParams", cp.to_bytes())
+
+  with Timeout(90, "pandad didn't set safety mode"):
+    while any(ps.safetyModel != car.CarParams.SafetyModel.allOutput for ps in sm['pandaStates']):
+      sm.update(1000)
+
+def send_random_can_messages(sendcan, count, num_pandas=1):
+  sent_msgs = defaultdict(set)
+  for _ in range(count):
+    to_send = []
+    for __ in range(random.randrange(20)):
+      bus = random.choice([b for b in range(3*num_pandas) if b % 4 != 3])
+      addr = random.randrange(1, 1<<29)
+      dat = bytes(random.getrandbits(8) for _ in range(random.randrange(1, 9)))
+      if (addr, dat) in sent_msgs[bus]:
+        continue
+      sent_msgs[bus].add((addr, dat))
+      to_send.append(CanData(addr, dat, bus))
+    sendcan.send(can_list_to_can_capnp(to_send, msgtype='sendcan'))
+  return sent_msgs
+
+
+@pytest.mark.tici
+class TestBoarddLoopback:
+  @classmethod
+  def setup_class(cls):
+    os.environ['STARTED'] = '1'
+    os.environ['BOARDD_LOOPBACK'] = '1'
+
+  @with_processes(['pandad'])
+  def test_loopback(self):
+    num_pandas = 2 if TICI and "SINGLE_PANDA" not in os.environ else 1
+    setup_pandad(num_pandas)
+
+    sendcan = messaging.pub_sock('sendcan')
+    can = messaging.sub_sock('can', conflate=False, timeout=100)
+    sm = messaging.SubMaster(['pandaStates'])
+    time.sleep(1)
+
+    n = 200
+    for i in range(n):
+      print(f"pandad loopback {i}/{n}")
+
+      sent_msgs = send_random_can_messages(sendcan, random.randrange(20, 100), num_pandas)
+
+      sent_loopback = copy.deepcopy(sent_msgs)
+      sent_loopback.update({k+128: copy.deepcopy(v) for k, v in sent_msgs.items()})
+      sent_total = {k: len(v) for k, v in sent_loopback.items()}
+      for _ in range(100 * 5):
+        sm.update(0)
+        recvd = messaging.drain_sock(can, wait_for_one=True)
+        for msg in recvd:
+          for m in msg.can:
+            key = (m.address, m.dat)
+            assert key in sent_loopback[m.src], f"got unexpected msg: {m.src=} {m.address=} {m.dat=}"
+            sent_loopback[m.src].discard(key)
+
+        if all(len(v) == 0 for v in sent_loopback.values()):
+          break
+
+      # if a set isn't empty, messages got dropped
+      pprint(sent_msgs)
+      pprint(sent_loopback)
+      print({k: len(x) for k, x in sent_loopback.items()})
+      print(sum([len(x) for x in sent_loopback.values()]))
+      pprint(sm['pandaStates'])  # may drop messages due to RX buffer overflow
+      for bus in sent_loopback.keys():
+        assert not len(sent_loopback[bus]), f"loop {i}: bus {bus} missing {len(sent_loopback[bus])} out of {sent_total[bus]} messages"

selfdrive/pandad/tests/test_pandad_spi.py

@@ -0,0 +1,102 @@
+import os
+import time
+import numpy as np
+import pytest
+import random
+
+import cereal.messaging as messaging
+from cereal.services import SERVICE_LIST
+from openpilot.selfdrive.test.helpers import with_processes
+from openpilot.selfdrive.pandad.tests.test_pandad_loopback import setup_pandad, send_random_can_messages
+
+JUNGLE_SPAM = "JUNGLE_SPAM" in os.environ
+
+@pytest.mark.tici
+class TestBoarddSpi:
+  @classmethod
+  def setup_class(cls):
+    os.environ['STARTED'] = '1'
+    os.environ['SPI_ERR_PROB'] = '0.001'
+    if not JUNGLE_SPAM:
+      os.environ['BOARDD_LOOPBACK'] = '1'
+
+  @with_processes(['pandad'])
+  def test_spi_corruption(self, subtests):
+    setup_pandad(1)
+
+    sendcan = messaging.pub_sock('sendcan')
+    socks = {s: messaging.sub_sock(s, conflate=False, timeout=100) for s in ('can', 'pandaStates', 'peripheralState')}
+    time.sleep(2)
+    for s in socks.values():
+      messaging.drain_sock_raw(s)
+
+    total_recv_count = 0
+    total_sent_count = 0
+    sent_msgs = {bus: list() for bus in range(3)}
+
+    st = time.monotonic()
+    ts = {s: list() for s in socks.keys()}
+    for _ in range(int(os.getenv("TEST_TIME", "20"))):
+      # send some CAN messages
+      if not JUNGLE_SPAM:
+        sent = send_random_can_messages(sendcan, random.randrange(2, 20))
+        for k, v in sent.items():
+          sent_msgs[k].extend(list(v))
+          total_sent_count += len(v)
+
+      for service, sock in socks.items():
+        for m in messaging.drain_sock(sock):
+          ts[service].append(m.logMonoTime)
+
+          # sanity check for corruption
+          assert m.valid or (service == "can")
+          if service == "can":
+            for msg in m.can:
+              if JUNGLE_SPAM:
+                # PandaJungle.set_generated_can(True)
+                i = msg.address - 0x200
+                assert msg.address >= 0x200
+                assert msg.src == (i%3)
+                assert msg.dat == b"\xff"*(i%8)
+                total_recv_count += 1
+                continue
+
+              if msg.src > 4:
+                continue
+              key = (msg.address, msg.dat)
+              assert key in sent_msgs[msg.src], f"got unexpected msg: {msg.src=} {msg.address=} {msg.dat=}"
+              # TODO: enable this
+              #sent_msgs[msg.src].remove(key)
+              total_recv_count += 1
+          elif service == "pandaStates":
+            assert len(m.pandaStates) == 1
+            ps = m.pandaStates[0]
+            assert ps.uptime < 1000
+            assert ps.pandaType == "tres"
+            assert ps.ignitionLine
+            assert not ps.ignitionCan
+            assert 4000 < ps.voltage < 14000
+          elif service == "peripheralState":
+            ps = m.peripheralState
+            assert ps.pandaType == "tres"
+            assert 4000 < ps.voltage < 14000
+            assert 50 < ps.current < 1000
+            assert ps.fanSpeedRpm < 10000
+
+      time.sleep(0.5)
+    et = time.monotonic() - st
+
+    print("\n======== timing report ========")
+    for service, times in ts.items():
+      dts = np.diff(times)/1e6
+      print(service.ljust(17), f"{np.mean(dts):7.2f} {np.min(dts):7.2f} {np.max(dts):7.2f}")
+      with subtests.test(msg="timing check", service=service):
+        edt = 1e3 / SERVICE_LIST[service].frequency
+        assert edt*0.9 < np.mean(dts) < edt*1.1
+        assert np.max(dts) < edt*8
+        assert np.min(dts) < edt
+        assert len(dts) >= ((et-0.5)*SERVICE_LIST[service].frequency*0.8)
+
+    with subtests.test(msg="CAN traffic"):
+      print(f"Sent {total_sent_count} CAN messages, got {total_recv_count} back. {total_recv_count/(total_sent_count+1e-4):.2%} received")
+      assert total_recv_count > 20

selfdrive/pandad/tests/test_pandad_usbprotocol.cc

@@ -0,0 +1,135 @@
+#define CATCH_CONFIG_MAIN
+#define CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include "catch2/catch.hpp"
+#include "cereal/messaging/messaging.h"
+#include "common/util.h"
+#include "selfdrive/pandad/panda.h"
+
+struct PandaTest : public Panda {
+  PandaTest(uint32_t bus_offset, int can_list_size, cereal::PandaState::PandaType hw_type);
+  void test_can_send();
+  void test_can_recv(uint32_t chunk_size = 0);
+  void test_chunked_can_recv();
+
+  std::map<int, std::string> test_data;
+  int can_list_size = 0;
+  int total_pakets_size = 0;
+  MessageBuilder msg;
+  capnp::List<cereal::CanData>::Reader can_data_list;
+};
+
+PandaTest::PandaTest(uint32_t bus_offset_, int can_list_size, cereal::PandaState::PandaType hw_type) : can_list_size(can_list_size), Panda(bus_offset_) {
+  this->hw_type = hw_type;
+  int data_limit = ((hw_type == cereal::PandaState::PandaType::RED_PANDA) ? std::size(dlc_to_len) : 8);
+  // prepare test data
+  for (int i = 0; i < data_limit; ++i) {
+    std::random_device rd;
+    std::independent_bits_engine<std::default_random_engine, CHAR_BIT, unsigned char> rbe(rd());
+
+    int data_len = dlc_to_len[i];
+    std::string bytes(data_len, '\0');
+    std::generate(bytes.begin(), bytes.end(), std::ref(rbe));
+    test_data[data_len] = bytes;
+  }
+
+  // generate can messages for this panda
+  auto can_list = msg.initEvent().initSendcan(can_list_size);
+  for (uint8_t i = 0; i < can_list_size; ++i) {
+    auto can = can_list[i];
+    uint32_t id = util::random_int(0, std::size(dlc_to_len) - 1);
+    const std::string &dat = test_data[dlc_to_len[id]];
+    can.setAddress(i);
+    can.setSrc(util::random_int(0, 2) + bus_offset);
+    can.setDat(kj::ArrayPtr((uint8_t *)dat.data(), dat.size()));
+    total_pakets_size += sizeof(can_header) + dat.size();
+  }
+
+  can_data_list = can_list.asReader();
+  INFO("test " << can_list_size << " packets, total size " << total_pakets_size);
+}
+
+void PandaTest::test_can_send() {
+  std::vector<uint8_t> unpacked_data;
+  this->pack_can_buffer(can_data_list, [&](uint8_t *chunk, size_t size) {
+    unpacked_data.insert(unpacked_data.end(), chunk, &chunk[size]);
+  });
+  REQUIRE(unpacked_data.size() == total_pakets_size);
+
+  int cnt = 0;
+  INFO("test can message integrity");
+  for (int pos = 0, pckt_len = 0; pos < unpacked_data.size(); pos += pckt_len) {
+    can_header header;
+    memcpy(&header, &unpacked_data[pos], sizeof(can_header));
+    const uint8_t data_len = dlc_to_len[header.data_len_code];
+    pckt_len = sizeof(can_header) + data_len;
+
+    REQUIRE(header.addr == cnt);
+    REQUIRE(test_data.find(data_len) != test_data.end());
+    const std::string &dat = test_data[data_len];
+    REQUIRE(memcmp(dat.data(), &unpacked_data[pos + sizeof(can_header)], dat.size()) == 0);
+    ++cnt;
+  }
+  REQUIRE(cnt == can_list_size);
+}
+
+void PandaTest::test_can_recv(uint32_t rx_chunk_size) {
+  std::vector<can_frame> frames;
+  this->pack_can_buffer(can_data_list, [&](uint8_t *data, uint32_t size) {
+    if (rx_chunk_size == 0) {
+      REQUIRE(this->unpack_can_buffer(data, size, frames));
+    } else {
+      this->receive_buffer_size = 0;
+      uint32_t pos = 0;
+
+      while (pos < size) {
+        uint32_t chunk_size = std::min(rx_chunk_size, size - pos);
+        memcpy(&this->receive_buffer[this->receive_buffer_size], &data[pos], chunk_size);
+        this->receive_buffer_size += chunk_size;
+        pos += chunk_size;
+
+        REQUIRE(this->unpack_can_buffer(this->receive_buffer, this->receive_buffer_size, frames));
+      }
+    }
+  });
+
+  REQUIRE(frames.size() == can_list_size);
+  for (int i = 0; i < frames.size(); ++i) {
+    REQUIRE(frames[i].address == i);
+    REQUIRE(test_data.find(frames[i].dat.size()) != test_data.end());
+    const std::string &dat = test_data[frames[i].dat.size()];
+    REQUIRE(memcmp(dat.data(), frames[i].dat.data(), dat.size()) == 0);
+  }
+}
+
+TEST_CASE("send/recv CAN 2.0 packets") {
+  auto bus_offset = GENERATE(0, 4);
+  auto can_list_size = GENERATE(1, 3, 5, 10, 30, 60, 100, 200);
+  PandaTest test(bus_offset, can_list_size, cereal::PandaState::PandaType::DOS);
+
+  SECTION("can_send") {
+    test.test_can_send();
+  }
+  SECTION("can_receive") {
+    test.test_can_recv();
+  }
+  SECTION("chunked_can_receive") {
+    test.test_can_recv(0x40);
+  }
+}
+
+TEST_CASE("send/recv CAN FD packets") {
+  auto bus_offset = GENERATE(0, 4);
+  auto can_list_size = GENERATE(1, 3, 5, 10, 30, 60, 100, 200);
+  PandaTest test(bus_offset, can_list_size, cereal::PandaState::PandaType::RED_PANDA);
+
+  SECTION("can_send") {
+    test.test_can_send();
+  }
+  SECTION("can_receive") {
+    test.test_can_recv();
+  }
+  SECTION("chunked_can_receive") {
+    test.test_can_recv(0x40);
+  }
+}