Release 260111

opendbc_repo/opendbc/car/hyundai/tests/print_platform_codes.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+from opendbc.car.structs import CarParams
+from opendbc.car.hyundai.values import PLATFORM_CODE_ECUS, get_platform_codes
+from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+
+Ecu = CarParams.Ecu
+
+if __name__ == "__main__":
+  for car_model, ecus in FW_VERSIONS.items():
+    print()
+    print(car_model)
+    for ecu in sorted(ecus):
+      if ecu[0] not in PLATFORM_CODE_ECUS:
+        continue
+
+      platform_codes = get_platform_codes(ecus[ecu])
+      codes = {code for code, _ in platform_codes}
+      dates = {date for _, date in platform_codes if date is not None}
+      print(f'  (Ecu.{ecu[0]}, {hex(ecu[1])}, {ecu[2]}):')
+      print(f'    Codes: {codes}')
+      print(f'    Dates: {dates}')

opendbc_repo/opendbc/car/hyundai/tests/test_hyundai.py

@@ -0,0 +1,247 @@
+from hypothesis import settings, given, strategies as st
+
+import pytest
+
+from opendbc.car import gen_empty_fingerprint
+from opendbc.car.structs import CarParams
+from opendbc.car.fw_versions import build_fw_dict
+from opendbc.car.hyundai.interface import CarInterface
+from opendbc.car.hyundai.hyundaicanfd import CanBus
+from opendbc.car.hyundai.radar_interface import RADAR_START_ADDR
+from opendbc.car.hyundai.values import CAMERA_SCC_CAR, CANFD_CAR, CAN_GEARS, CAR, CHECKSUM, DATE_FW_ECUS, \
+                                         HYBRID_CAR, EV_CAR, FW_QUERY_CONFIG, LEGACY_SAFETY_MODE_CAR, CANFD_FUZZY_WHITELIST, \
+                                         UNSUPPORTED_LONGITUDINAL_CAR, PLATFORM_CODE_ECUS, HYUNDAI_VERSION_REQUEST_LONG, \
+                                         HyundaiFlags, get_platform_codes, HyundaiSafetyFlags
+from opendbc.car.hyundai.fingerprints import FW_VERSIONS
+
+Ecu = CarParams.Ecu
+
+# Some platforms have date codes in a different format we don't yet parse (or are missing).
+# For now, assert list of expected missing date cars
+NO_DATES_PLATFORMS = {
+  # CAN FD
+  CAR.KIA_SPORTAGE_5TH_GEN,
+  CAR.HYUNDAI_SANTA_CRUZ_1ST_GEN,
+  CAR.HYUNDAI_TUCSON_4TH_GEN,
+  # CAN
+  CAR.HYUNDAI_ELANTRA,
+  CAR.HYUNDAI_ELANTRA_GT_I30,
+  CAR.KIA_CEED,
+  CAR.KIA_FORTE,
+  CAR.KIA_OPTIMA_G4,
+  CAR.KIA_OPTIMA_G4_FL,
+  CAR.KIA_SORENTO,
+  CAR.HYUNDAI_KONA,
+  CAR.HYUNDAI_KONA_EV,
+  CAR.HYUNDAI_KONA_EV_2022,
+  CAR.HYUNDAI_KONA_HEV,
+  CAR.HYUNDAI_SONATA_LF,
+  CAR.HYUNDAI_VELOSTER,
+  CAR.HYUNDAI_KONA_2022,
+}
+
+CANFD_EXPECTED_ECUS = {Ecu.fwdCamera, Ecu.fwdRadar}
+
+
+class TestHyundaiFingerprint:
+  def test_feature_detection(self):
+    # LKA steering
+    for lka_steering in (True, False):
+      fingerprint = gen_empty_fingerprint()
+      if lka_steering:
+        cam_can = CanBus(None, fingerprint).CAM
+        fingerprint[cam_can] = [0x50, 0x110]  # LKA steering messages
+      CP = CarInterface.get_params(CAR.KIA_EV6, fingerprint, [], False, False)
+      assert bool(CP.flags & HyundaiFlags.CANFD_LKA_STEERING) == lka_steering
+
+    # radar available
+    for radar in (True, False):
+      fingerprint = gen_empty_fingerprint()
+      if radar:
+        fingerprint[1][RADAR_START_ADDR] = 8
+      CP = CarInterface.get_params(CAR.HYUNDAI_SONATA, fingerprint, [], False, False)
+      assert CP.radarUnavailable != radar
+
+  def test_alternate_limits(self):
+    # Alternate lateral control limits, for high torque cars, verify Panda safety mode flag is set
+    fingerprint = gen_empty_fingerprint()
+    for car_model in CAR:
+      CP = CarInterface.get_params(car_model, fingerprint, [], False, False)
+      assert bool(CP.flags & HyundaiFlags.ALT_LIMITS) == bool(CP.safetyConfigs[-1].safetyParam & HyundaiSafetyFlags.ALT_LIMITS)
+
+  def test_can_features(self):
+    # Test no EV/HEV in any gear lists (should all use ELECT_GEAR)
+    assert set.union(*CAN_GEARS.values()) & (HYBRID_CAR | EV_CAR) == set()
+
+    # Test CAN FD car not in CAN feature lists
+    can_specific_feature_list = set.union(*CAN_GEARS.values(), *CHECKSUM.values(), LEGACY_SAFETY_MODE_CAR, UNSUPPORTED_LONGITUDINAL_CAR, CAMERA_SCC_CAR)
+    for car_model in CANFD_CAR:
+      assert car_model not in can_specific_feature_list, "CAN FD car unexpectedly found in a CAN feature list"
+
+  def test_hybrid_ev_sets(self):
+    assert HYBRID_CAR & EV_CAR == set(), "Shared cars between hybrid and EV"
+    assert CANFD_CAR & HYBRID_CAR == set(), "Hard coding CAN FD cars as hybrid is no longer supported"
+
+  def test_canfd_ecu_whitelist(self):
+    # Asserts only expected Ecus can exist in database for CAN-FD cars
+    for car_model in CANFD_CAR:
+      ecus = {fw[0] for fw in FW_VERSIONS[car_model].keys()}
+      ecus_not_in_whitelist = ecus - CANFD_EXPECTED_ECUS
+      ecu_strings = ", ".join([f"Ecu.{ecu}" for ecu in ecus_not_in_whitelist])
+      assert len(ecus_not_in_whitelist) == 0, \
+                       f"{car_model}: Car model has unexpected ECUs: {ecu_strings}"
+
+  def test_blacklisted_parts(self, subtests):
+    # Asserts no ECUs known to be shared across platforms exist in the database.
+    # Tucson having Santa Cruz camera and EPS for example
+    for car_model, ecus in FW_VERSIONS.items():
+      with subtests.test(car_model=car_model.value):
+        if car_model == CAR.HYUNDAI_SANTA_CRUZ_1ST_GEN:
+          pytest.skip("Skip checking Santa Cruz for its parts")
+
+        for code, _ in get_platform_codes(ecus[(Ecu.fwdCamera, 0x7c4, None)]):
+          if b"-" not in code:
+            continue
+          part = code.split(b"-")[1]
+          assert not part.startswith(b'CW'), "Car has bad part number"
+
+  def test_correct_ecu_response_database(self, subtests):
+    """
+    Assert standard responses for certain ECUs, since they can
+    respond to multiple queries with different data
+    """
+    expected_fw_prefix = HYUNDAI_VERSION_REQUEST_LONG[1:]
+    for car_model, ecus in FW_VERSIONS.items():
+      with subtests.test(car_model=car_model.value):
+        for ecu, fws in ecus.items():
+          assert all(fw.startswith(expected_fw_prefix) for fw in fws), \
+                          f"FW from unexpected request in database: {(ecu, fws)}"
+
+  @settings(max_examples=100)
+  @given(data=st.data())
+  def test_platform_codes_fuzzy_fw(self, data):
+    """Ensure function doesn't raise an exception"""
+    fw_strategy = st.lists(st.binary())
+    fws = data.draw(fw_strategy)
+    get_platform_codes(fws)
+
+  def test_expected_platform_codes(self, subtests):
+    # Ensures we don't accidentally add multiple platform codes for a car unless it is intentional
+    for car_model, ecus in FW_VERSIONS.items():
+      with subtests.test(car_model=car_model.value):
+        for ecu, fws in ecus.items():
+          if ecu[0] not in PLATFORM_CODE_ECUS:
+            continue
+
+          # Third and fourth character are usually EV/hybrid identifiers
+          codes = {code.split(b"-")[0][:2] for code, _ in get_platform_codes(fws)}
+          if car_model == CAR.HYUNDAI_PALISADE:
+            assert codes == {b"LX", b"ON"}, f"Car has unexpected platform codes: {car_model} {codes}"
+          elif car_model == CAR.HYUNDAI_KONA_EV and ecu[0] == Ecu.fwdCamera:
+            assert codes == {b"OE", b"OS"}, f"Car has unexpected platform codes: {car_model} {codes}"
+          else:
+            assert len(codes) == 1, f"Car has multiple platform codes: {car_model} {codes}"
+
+  # Tests for platform codes, part numbers, and FW dates which Hyundai will use to fuzzy
+  # fingerprint in the absence of full FW matches:
+  def test_platform_code_ecus_available(self, subtests):
+    # TODO: add queries for these non-CAN FD cars to get EPS
+    no_eps_platforms = CANFD_CAR | {CAR.KIA_SORENTO, CAR.KIA_OPTIMA_G4, CAR.KIA_OPTIMA_G4_FL, CAR.KIA_OPTIMA_H,
+                                    CAR.KIA_OPTIMA_H_G4_FL, CAR.HYUNDAI_SONATA_LF, CAR.HYUNDAI_TUCSON, CAR.GENESIS_G90, CAR.GENESIS_G80, CAR.HYUNDAI_ELANTRA}
+
+    # Asserts ECU keys essential for fuzzy fingerprinting are available on all platforms
+    for car_model, ecus in FW_VERSIONS.items():
+      with subtests.test(car_model=car_model.value):
+        for platform_code_ecu in PLATFORM_CODE_ECUS:
+          if platform_code_ecu in (Ecu.fwdRadar, Ecu.eps) and car_model == CAR.HYUNDAI_GENESIS:
+            continue
+          if platform_code_ecu == Ecu.eps and car_model in no_eps_platforms:
+            continue
+          assert platform_code_ecu in [e[0] for e in ecus]
+
+  def test_fw_format(self, subtests):
+    # Asserts:
+    # - every supported ECU FW version returns one platform code
+    # - every supported ECU FW version has a part number
+    # - expected parsing of ECU FW dates
+
+    for car_model, ecus in FW_VERSIONS.items():
+      with subtests.test(car_model=car_model.value):
+        for ecu, fws in ecus.items():
+          if ecu[0] not in PLATFORM_CODE_ECUS:
+            continue
+
+          codes = set()
+          for fw in fws:
+            result = get_platform_codes([fw])
+            assert 1 == len(result), f"Unable to parse FW: {fw}"
+            codes |= result
+
+          if ecu[0] not in DATE_FW_ECUS or car_model in NO_DATES_PLATFORMS:
+            assert all(date is None for _, date in codes)
+          else:
+            assert all(date is not None for _, date in codes)
+
+          if car_model == CAR.HYUNDAI_GENESIS:
+            pytest.skip("No part numbers for car model")
+
+          # Hyundai places the ECU part number in their FW versions, assert all parsable
+          # Some examples of valid formats: b"56310-L0010", b"56310L0010", b"56310/M6300"
+          assert all(b"-" in code for code, _ in codes), \
+                          f"FW does not have part number: {fw}"
+
+  def test_platform_codes_spot_check(self):
+    # Asserts basic platform code parsing behavior for a few cases
+    results = get_platform_codes([b"\xf1\x00DH LKAS 1.1 -150210"])
+    assert results == {(b"DH", b"150210")}
+
+    # Some cameras and all radars do not have dates
+    results = get_platform_codes([b"\xf1\x00AEhe SCC H-CUP      1.01 1.01 96400-G2000         "])
+    assert results == {(b"AEhe-G2000", None)}
+
+    results = get_platform_codes([b"\xf1\x00CV1_ RDR -----      1.00 1.01 99110-CV000         "])
+    assert results == {(b"CV1-CV000", None)}
+
+    results = get_platform_codes([
+      b"\xf1\x00DH LKAS 1.1 -150210",
+      b"\xf1\x00AEhe SCC H-CUP      1.01 1.01 96400-G2000         ",
+      b"\xf1\x00CV1_ RDR -----      1.00 1.01 99110-CV000         ",
+    ])
+    assert results == {(b"DH", b"150210"), (b"AEhe-G2000", None), (b"CV1-CV000", None)}
+
+    results = get_platform_codes([
+      b"\xf1\x00LX2 MFC  AT USA LHD 1.00 1.07 99211-S8100 220222",
+      b"\xf1\x00LX2 MFC  AT USA LHD 1.00 1.08 99211-S8100 211103",
+      b"\xf1\x00ON  MFC  AT USA LHD 1.00 1.01 99211-S9100 190405",
+      b"\xf1\x00ON  MFC  AT USA LHD 1.00 1.03 99211-S9100 190720",
+    ])
+    assert results == {(b"LX2-S8100", b"220222"), (b"LX2-S8100", b"211103"),
+                               (b"ON-S9100", b"190405"), (b"ON-S9100", b"190720")}
+
+  def test_fuzzy_excluded_platforms(self):
+    # Asserts a list of platforms that will not fuzzy fingerprint with platform codes due to them being shared.
+    # This list can be shrunk as we combine platforms and detect features
+    excluded_platforms = {
+      CAR.GENESIS_G70,            # shared platform code, part number, and date
+      CAR.GENESIS_G70_2020,
+    }
+    excluded_platforms |= CANFD_CAR - EV_CAR - CANFD_FUZZY_WHITELIST  # shared platform codes
+    excluded_platforms |= NO_DATES_PLATFORMS  # date codes are required to match
+
+    platforms_with_shared_codes = set()
+    for platform, fw_by_addr in FW_VERSIONS.items():
+      car_fw = []
+      for ecu, fw_versions in fw_by_addr.items():
+        ecu_name, addr, sub_addr = ecu
+        for fw in fw_versions:
+          car_fw.append(CarParams.CarFw(ecu=ecu_name, fwVersion=fw, address=addr,
+                                        subAddress=0 if sub_addr is None else sub_addr))
+
+      CP = CarParams(carFw=car_fw)
+      matches = FW_QUERY_CONFIG.match_fw_to_car_fuzzy(build_fw_dict(CP.carFw), CP.carVin, FW_VERSIONS)
+      if len(matches) == 1:
+        assert list(matches)[0] == platform
+      else:
+        platforms_with_shared_codes.add(platform)
+
+    assert platforms_with_shared_codes == excluded_platforms