From fe1690d48d586b051cffdcf4b1d2de5cc12d1569 Mon Sep 17 00:00:00 2001 From: Jason Wen Date: Sat, 22 Feb 2025 01:07:42 -0800 Subject: [PATCH] Hyundai CAN-FD: Refactor HDA2 with available steering types (#1782) * Hyundai CAN-FD: Refactor HDA2 with available steering types * add comments --- opendbc/car/hyundai/carcontroller.py | 20 ++--- opendbc/car/hyundai/carstate.py | 8 +- opendbc/car/hyundai/hyundaicanfd.py | 30 +++---- opendbc/car/hyundai/interface.py | 26 +++--- opendbc/car/hyundai/tests/test_hyundai.py | 10 +-- opendbc/car/hyundai/values.py | 17 ++-- opendbc/car/tests/routes.py | 10 +-- opendbc/safety/safety/safety_hyundai_canfd.h | 86 +++++++++---------- opendbc/safety/safety/safety_hyundai_common.h | 8 +- opendbc/safety/tests/common.py | 2 +- opendbc/safety/tests/test_hyundai_canfd.py | 30 +++---- 11 files changed, 126 insertions(+), 121 deletions(-) diff --git a/opendbc/car/hyundai/carcontroller.py b/opendbc/car/hyundai/carcontroller.py index 4c345c7d..ed825e63 100644 --- a/opendbc/car/hyundai/carcontroller.py +++ b/opendbc/car/hyundai/carcontroller.py @@ -93,7 +93,7 @@ class CarController(CarControllerBase): if self.frame % 100 == 0 and not (self.CP.flags & HyundaiFlags.CANFD_CAMERA_SCC) and self.CP.openpilotLongitudinalControl: # for longitudinal control, either radar or ADAS driving ECU addr, bus = 0x7d0, 0 - if self.CP.flags & HyundaiFlags.CANFD_HDA2.value: + if self.CP.flags & HyundaiFlags.CANFD_LKA_STEERING.value: addr, bus = 0x730, self.CAN.ECAN can_sends.append(make_tester_present_msg(addr, bus, suppress_response=True)) @@ -103,27 +103,27 @@ class CarController(CarControllerBase): # CAN-FD platforms if self.CP.flags & HyundaiFlags.CANFD: - hda2 = self.CP.flags & HyundaiFlags.CANFD_HDA2 - hda2_long = hda2 and self.CP.openpilotLongitudinalControl + lka_steering = self.CP.flags & HyundaiFlags.CANFD_LKA_STEERING + lka_steering_long = lka_steering and self.CP.openpilotLongitudinalControl # steering control can_sends.extend(hyundaicanfd.create_steering_messages(self.packer, self.CP, self.CAN, CC.enabled, apply_steer_req, apply_steer)) - # prevent LFA from activating on HDA2 by sending "no lane lines detected" to ADAS ECU - if self.frame % 5 == 0 and hda2: - can_sends.append(hyundaicanfd.create_suppress_lfa(self.packer, self.CAN, CS.hda2_lfa_block_msg, - self.CP.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING)) + # prevent LFA from activating on LKA steering cars by sending "no lane lines detected" to ADAS ECU + if self.frame % 5 == 0 and lka_steering: + can_sends.append(hyundaicanfd.create_suppress_lfa(self.packer, self.CAN, CS.lfa_block_msg, + self.CP.flags & HyundaiFlags.CANFD_LKA_STEERING_ALT)) # LFA and HDA icons - if self.frame % 5 == 0 and (not hda2 or hda2_long): + if self.frame % 5 == 0 and (not lka_steering or lka_steering_long): can_sends.append(hyundaicanfd.create_lfahda_cluster(self.packer, self.CAN, CC.enabled)) # blinkers - if hda2 and self.CP.flags & HyundaiFlags.ENABLE_BLINKERS: + if lka_steering and self.CP.flags & HyundaiFlags.ENABLE_BLINKERS: can_sends.extend(hyundaicanfd.create_spas_messages(self.packer, self.CAN, self.frame, CC.leftBlinker, CC.rightBlinker)) if self.CP.openpilotLongitudinalControl: - if hda2: + if lka_steering: can_sends.extend(hyundaicanfd.create_adrv_messages(self.packer, self.CAN, self.frame)) if self.frame % 2 == 0: can_sends.append(hyundaicanfd.create_acc_control(self.packer, self.CAN, CC.enabled, self.accel_last, accel, stopping, CC.cruiseControl.override, diff --git a/opendbc/car/hyundai/carstate.py b/opendbc/car/hyundai/carstate.py index babcbc71..58b086a1 100644 --- a/opendbc/car/hyundai/carstate.py +++ b/opendbc/car/hyundai/carstate.py @@ -269,8 +269,8 @@ class CarState(CarStateBase): self.buttons_counter = cp.vl[self.cruise_btns_msg_canfd]["COUNTER"] ret.accFaulted = cp.vl["TCS"]["ACCEnable"] != 0 # 0 ACC CONTROL ENABLED, 1-3 ACC CONTROL DISABLED - if self.CP.flags & HyundaiFlags.CANFD_HDA2: - self.hda2_lfa_block_msg = copy.copy(cp_cam.vl["CAM_0x362"] if self.CP.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING + if self.CP.flags & HyundaiFlags.CANFD_LKA_STEERING: + self.lfa_block_msg = copy.copy(cp_cam.vl["CAM_0x362"] if self.CP.flags & HyundaiFlags.CANFD_LKA_STEERING_ALT else cp_cam.vl["CAM_0x2a4"]) ret.buttonEvents = [*create_button_events(self.cruise_buttons[-1], prev_cruise_buttons, BUTTONS_DICT), @@ -317,8 +317,8 @@ class CarState(CarStateBase): ] cam_messages = [] - if CP.flags & HyundaiFlags.CANFD_HDA2: - block_lfa_msg = "CAM_0x362" if CP.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING else "CAM_0x2a4" + if CP.flags & HyundaiFlags.CANFD_LKA_STEERING: + block_lfa_msg = "CAM_0x362" if CP.flags & HyundaiFlags.CANFD_LKA_STEERING_ALT else "CAM_0x2a4" cam_messages += [(block_lfa_msg, 20)] elif CP.flags & HyundaiFlags.CANFD_CAMERA_SCC: cam_messages += [ diff --git a/opendbc/car/hyundai/hyundaicanfd.py b/opendbc/car/hyundai/hyundaicanfd.py index 8b18338b..6d79e9b8 100644 --- a/opendbc/car/hyundai/hyundaicanfd.py +++ b/opendbc/car/hyundai/hyundaicanfd.py @@ -4,17 +4,17 @@ from opendbc.car.hyundai.values import HyundaiFlags class CanBus(CanBusBase): - def __init__(self, CP, fingerprint=None, hda2=None) -> None: + def __init__(self, CP, fingerprint=None, lka_steering=None) -> None: super().__init__(CP, fingerprint) - if hda2 is None: - hda2 = CP.flags & HyundaiFlags.CANFD_HDA2.value if CP is not None else False + if lka_steering is None: + lka_steering = CP.flags & HyundaiFlags.CANFD_LKA_STEERING.value if CP is not None else False - # On the CAN-FD platforms, the LKAS camera is on both A-CAN and E-CAN. HDA2 cars - # have a different harness than the HDA1 and non-HDA variants in order to split + # On the CAN-FD platforms, the LKAS camera is on both A-CAN and E-CAN. LKA steering cars + # have a different harness than the LFA steering variants in order to split # a different bus, since the steering is done by different ECUs. self._a, self._e = 1, 0 - if hda2: + if lka_steering: self._a, self._e = 0, 1 self._a += self.offset @@ -50,22 +50,22 @@ def create_steering_messages(packer, CP, CAN, enabled, lat_active, apply_steer): "NEW_SIGNAL_2": 0, } - if CP.flags & HyundaiFlags.CANFD_HDA2: - hda2_lkas_msg = "LKAS_ALT" if CP.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING else "LKAS" + if CP.flags & HyundaiFlags.CANFD_LKA_STEERING: + lkas_msg = "LKAS_ALT" if CP.flags & HyundaiFlags.CANFD_LKA_STEERING_ALT else "LKAS" if CP.openpilotLongitudinalControl: ret.append(packer.make_can_msg("LFA", CAN.ECAN, values)) - ret.append(packer.make_can_msg(hda2_lkas_msg, CAN.ACAN, values)) + ret.append(packer.make_can_msg(lkas_msg, CAN.ACAN, values)) else: ret.append(packer.make_can_msg("LFA", CAN.ECAN, values)) return ret -def create_suppress_lfa(packer, CAN, hda2_lfa_block_msg, hda2_alt_steering): - suppress_msg = "CAM_0x362" if hda2_alt_steering else "CAM_0x2a4" - msg_bytes = 32 if hda2_alt_steering else 24 +def create_suppress_lfa(packer, CAN, lfa_block_msg, lka_steering_alt): + suppress_msg = "CAM_0x362" if lka_steering_alt else "CAM_0x2a4" + msg_bytes = 32 if lka_steering_alt else 24 - values = {f"BYTE{i}": hda2_lfa_block_msg[f"BYTE{i}"] for i in range(3, msg_bytes) if i != 7} - values["COUNTER"] = hda2_lfa_block_msg["COUNTER"] + values = {f"BYTE{i}": lfa_block_msg[f"BYTE{i}"] for i in range(3, msg_bytes) if i != 7} + values["COUNTER"] = lfa_block_msg["COUNTER"] values["SET_ME_0"] = 0 values["SET_ME_0_2"] = 0 values["LEFT_LANE_LINE"] = 0 @@ -79,7 +79,7 @@ def create_buttons(packer, CP, CAN, cnt, btn): "CRUISE_BUTTONS": btn, } - bus = CAN.ECAN if CP.flags & HyundaiFlags.CANFD_HDA2 else CAN.CAM + bus = CAN.ECAN if CP.flags & HyundaiFlags.CANFD_LKA_STEERING else CAN.CAM return packer.make_can_msg("CRUISE_BUTTONS", bus, values) def create_acc_cancel(packer, CP, CAN, cruise_info_copy): diff --git a/opendbc/car/hyundai/interface.py b/opendbc/car/hyundai/interface.py index 20a6e20d..68eded7d 100644 --- a/opendbc/car/hyundai/interface.py +++ b/opendbc/car/hyundai/interface.py @@ -20,8 +20,8 @@ class CarInterface(CarInterfaceBase): ret.brand = "hyundai" cam_can = CanBus(None, fingerprint).CAM - hda2 = 0x50 in fingerprint[cam_can] or 0x110 in fingerprint[cam_can] - CAN = CanBus(None, fingerprint, hda2) + lka_steering = 0x50 in fingerprint[cam_can] or 0x110 in fingerprint[cam_can] + CAN = CanBus(None, fingerprint, lka_steering) if ret.flags & HyundaiFlags.CANFD: # Shared configuration for CAN-FD cars @@ -31,19 +31,19 @@ class CarInterface(CarInterfaceBase): if 0x105 in fingerprint[CAN.ECAN]: ret.flags |= HyundaiFlags.HYBRID.value - # detect HDA2 with ADAS Driving ECU - if hda2: - ret.flags |= HyundaiFlags.CANFD_HDA2.value + if lka_steering: + # detect LKA steering + ret.flags |= HyundaiFlags.CANFD_LKA_STEERING.value if 0x110 in fingerprint[CAN.CAM]: - ret.flags |= HyundaiFlags.CANFD_HDA2_ALT_STEERING.value + ret.flags |= HyundaiFlags.CANFD_LKA_STEERING_ALT.value else: - # non-HDA2 + # no LKA steering if 0x1cf not in fingerprint[CAN.ECAN]: ret.flags |= HyundaiFlags.CANFD_ALT_BUTTONS.value if not ret.flags & HyundaiFlags.RADAR_SCC: ret.flags |= HyundaiFlags.CANFD_CAMERA_SCC.value - # Some HDA2 cars have alternative messages for gear checks + # Some LKA steering cars have alternative messages for gear checks # ICE cars do not have 0x130; GEARS message on 0x40 or 0x70 instead if 0x130 not in fingerprint[CAN.ECAN]: if 0x40 not in fingerprint[CAN.ECAN]: @@ -56,10 +56,10 @@ class CarInterface(CarInterfaceBase): cfgs.insert(0, get_safety_config(structs.CarParams.SafetyModel.noOutput)) ret.safetyConfigs = cfgs - if ret.flags & HyundaiFlags.CANFD_HDA2: - ret.safetyConfigs[-1].safetyParam |= HyundaiSafetyFlags.CANFD_HDA2.value - if ret.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING: - ret.safetyConfigs[-1].safetyParam |= HyundaiSafetyFlags.CANFD_HDA2_ALT_STEERING.value + if ret.flags & HyundaiFlags.CANFD_LKA_STEERING: + ret.safetyConfigs[-1].safetyParam |= HyundaiSafetyFlags.CANFD_LKA_STEERING.value + if ret.flags & HyundaiFlags.CANFD_LKA_STEERING_ALT: + ret.safetyConfigs[-1].safetyParam |= HyundaiSafetyFlags.CANFD_LKA_STEERING_ALT.value if ret.flags & HyundaiFlags.CANFD_ALT_BUTTONS: ret.safetyConfigs[-1].safetyParam |= HyundaiSafetyFlags.CANFD_ALT_BUTTONS.value if ret.flags & HyundaiFlags.CANFD_CAMERA_SCC: @@ -133,7 +133,7 @@ class CarInterface(CarInterfaceBase): def init(CP, can_recv, can_send): if CP.openpilotLongitudinalControl and not (CP.flags & (HyundaiFlags.CANFD_CAMERA_SCC | HyundaiFlags.CAMERA_SCC)): addr, bus = 0x7d0, 0 - if CP.flags & HyundaiFlags.CANFD_HDA2.value: + if CP.flags & HyundaiFlags.CANFD_LKA_STEERING.value: addr, bus = 0x730, CanBus(CP).ECAN disable_ecu(can_recv, can_send, bus=bus, addr=addr, com_cont_req=b'\x28\x83\x01') diff --git a/opendbc/car/hyundai/tests/test_hyundai.py b/opendbc/car/hyundai/tests/test_hyundai.py index c484afee..ce8ce06d 100644 --- a/opendbc/car/hyundai/tests/test_hyundai.py +++ b/opendbc/car/hyundai/tests/test_hyundai.py @@ -44,14 +44,14 @@ CANFD_EXPECTED_ECUS = {Ecu.fwdCamera, Ecu.fwdRadar} class TestHyundaiFingerprint: def test_feature_detection(self): - # HDA2 - for hda2 in (True, False): + # LKA steering + for lka_steering in (True, False): fingerprint = gen_empty_fingerprint() - if hda2: + if lka_steering: cam_can = CanBus(None, fingerprint).CAM - fingerprint[cam_can] = [0x50, 0x110] # HDA2 steering messages + fingerprint[cam_can] = [0x50, 0x110] # LKA steering messages CP = CarInterface.get_params(CAR.KIA_EV6, fingerprint, [], False, False) - assert bool(CP.flags & HyundaiFlags.CANFD_HDA2) == hda2 + assert bool(CP.flags & HyundaiFlags.CANFD_LKA_STEERING) == lka_steering # radar available for radar in (True, False): diff --git a/opendbc/car/hyundai/values.py b/opendbc/car/hyundai/values.py index 9cc4eba5..df132b90 100644 --- a/opendbc/car/hyundai/values.py +++ b/opendbc/car/hyundai/values.py @@ -55,15 +55,20 @@ class HyundaiSafetyFlags(IntFlag): HYBRID_GAS = 2 LONG = 4 CAMERA_SCC = 8 - CANFD_HDA2 = 16 + CANFD_LKA_STEERING = 16 CANFD_ALT_BUTTONS = 32 ALT_LIMITS = 64 - CANFD_HDA2_ALT_STEERING = 128 + CANFD_LKA_STEERING_ALT = 128 class HyundaiFlags(IntFlag): # Dynamic Flags - CANFD_HDA2 = 1 + + # Default assumption: all cars use LFA (ADAS) steering from the camera. + # CANFD_LKA_STEERING/CANFD_LKA_STEERING_ALT cars typically have both LKA (camera) and LFA (ADAS) steering messages, + # with LKA commands forwarded to the ADAS DRV ECU. + # Most HDA2 trims are assumed to be equipped with the ADAS DRV ECU, though some variants may not be equipped with one. + CANFD_LKA_STEERING = 1 CANFD_ALT_BUTTONS = 2 CANFD_ALT_GEARS = 2 ** 2 CANFD_CAMERA_SCC = 2 ** 3 @@ -73,7 +78,7 @@ class HyundaiFlags(IntFlag): CANFD_ALT_GEARS_2 = 2 ** 6 SEND_LFA = 2 ** 7 USE_FCA = 2 ** 8 - CANFD_HDA2_ALT_STEERING = 2 ** 9 + CANFD_LKA_STEERING_ALT = 2 ** 9 # these cars use a different gas signal HYBRID = 2 ** 10 @@ -703,7 +708,7 @@ FW_QUERY_CONFIG = FwQueryConfig( ), # CAN & CAN FD query to understand the three digit date code - # HDA2 cars usually use 6 digit date codes, so skip bus 1 + # LKA steering cars usually use 6 digit date codes, so skip bus 1 Request( [HYUNDAI_ECU_MANUFACTURING_DATE], [HYUNDAI_VERSION_RESPONSE], @@ -737,7 +742,7 @@ FW_QUERY_CONFIG = FwQueryConfig( CAR.KIA_CEED, CAR.KIA_SELTOS], }, extra_ecus=[ - (Ecu.adas, 0x730, None), # ADAS Driving ECU on HDA2 platforms + (Ecu.adas, 0x730, None), # ADAS Driving ECU on platforms with LKA steering (Ecu.parkingAdas, 0x7b1, None), # ADAS Parking ECU (may exist on all platforms) (Ecu.hvac, 0x7b3, None), # HVAC Control Assembly (Ecu.cornerRadar, 0x7b7, None), diff --git a/opendbc/car/tests/routes.py b/opendbc/car/tests/routes.py index 00ef5a7e..b6ba5b1b 100644 --- a/opendbc/car/tests/routes.py +++ b/opendbc/car/tests/routes.py @@ -117,7 +117,7 @@ routes = [ CarTestRoute("afe09b9f5d3f3548/00000011--15fefe1c50", HYUNDAI.GENESIS_GV70_ELECTRIFIED_1ST_GEN), CarTestRoute("afe09b9f5d3f3548/0000001b--a1129a4a15", HYUNDAI.GENESIS_GV70_ELECTRIFIED_1ST_GEN), # openpilot longitudinal enabled CarTestRoute("6b301bf83f10aa90|2020-11-22--16-45-07", HYUNDAI.GENESIS_G80), - CarTestRoute("66eaa6c3b6b2afc6/00000009--3a5199aabe", HYUNDAI.GENESIS_G80_2ND_GEN_FL), # HDA2 + CarTestRoute("66eaa6c3b6b2afc6/00000009--3a5199aabe", HYUNDAI.GENESIS_G80_2ND_GEN_FL), # LKA steering CarTestRoute("0bbe367c98fa1538|2023-09-16--00-16-49", HYUNDAI.HYUNDAI_CUSTIN_1ST_GEN), CarTestRoute("f0709d2bc6ca451f|2022-10-15--08-13-54", HYUNDAI.HYUNDAI_SANTA_CRUZ_1ST_GEN), CarTestRoute("4dbd55df87507948|2022-03-01--09-45-38", HYUNDAI.HYUNDAI_SANTA_FE), @@ -143,8 +143,8 @@ routes = [ CarTestRoute("fc19648042eb6896|2023-08-16--11-43-27", HYUNDAI.KIA_SORENTO_HEV_4TH_GEN, segment=14), CarTestRoute("628935d7d3e5f4f7|2022-11-30--01-12-46", HYUNDAI.KIA_SORENTO_HEV_4TH_GEN), # plug-in hybrid CarTestRoute("9c917ba0d42ffe78|2020-04-17--12-43-19", HYUNDAI.HYUNDAI_PALISADE), - CarTestRoute("05a8f0197fdac372|2022-10-19--14-14-09", HYUNDAI.HYUNDAI_IONIQ_5), # HDA2 - CarTestRoute("eb4eae1476647463|2023-08-26--18-07-04", HYUNDAI.HYUNDAI_IONIQ_6, segment=6), # HDA2 + CarTestRoute("05a8f0197fdac372|2022-10-19--14-14-09", HYUNDAI.HYUNDAI_IONIQ_5), # LKA steering + CarTestRoute("eb4eae1476647463|2023-08-26--18-07-04", HYUNDAI.HYUNDAI_IONIQ_6, segment=6), # LKA steering CarTestRoute("3f29334d6134fcd4|2022-03-30--22-00-50", HYUNDAI.HYUNDAI_IONIQ_PHEV_2019), CarTestRoute("fa8db5869167f821|2021-06-10--22-50-10", HYUNDAI.HYUNDAI_IONIQ_PHEV), CarTestRoute("e1107f9d04dfb1e2|2023-09-05--22-32-12", HYUNDAI.HYUNDAI_IONIQ_PHEV), # openpilot longitudinal enabled @@ -162,8 +162,8 @@ routes = [ CarTestRoute("5dddcbca6eb66c62|2020-07-26--13-24-19", HYUNDAI.KIA_STINGER), CarTestRoute("5b50b883a4259afb|2022-11-09--15-00-42", HYUNDAI.KIA_STINGER_2022), CarTestRoute("d624b3d19adce635|2020-08-01--14-59-12", HYUNDAI.HYUNDAI_VELOSTER), - CarTestRoute("d545129f3ca90f28|2022-10-19--09-22-54", HYUNDAI.KIA_EV6), # HDA2 - CarTestRoute("68d6a96e703c00c9|2022-09-10--16-09-39", HYUNDAI.KIA_EV6), # HDA1 + CarTestRoute("d545129f3ca90f28|2022-10-19--09-22-54", HYUNDAI.KIA_EV6), # LKA steering + CarTestRoute("68d6a96e703c00c9|2022-09-10--16-09-39", HYUNDAI.KIA_EV6), # LFA steering CarTestRoute("9b25e8c1484a1b67|2023-04-13--10-41-45", HYUNDAI.KIA_EV6), CarTestRoute("007d5e4ad9f86d13|2021-09-30--15-09-23", HYUNDAI.KIA_K5_2021), CarTestRoute("c58dfc9fc16590e0|2023-01-14--13-51-48", HYUNDAI.KIA_K5_HEV_2020), diff --git a/opendbc/safety/safety/safety_hyundai_canfd.h b/opendbc/safety/safety/safety_hyundai_canfd.h index b42889bb..9ec75d37 100644 --- a/opendbc/safety/safety/safety_hyundai_canfd.h +++ b/opendbc/safety/safety/safety_hyundai_canfd.h @@ -24,10 +24,10 @@ {.msg = {{0x1a0, (scc_bus), 32, .check_checksum = true, .max_counter = 0xffU, .frequency = 50U}, { 0 }, { 0 }}}, \ static bool hyundai_canfd_alt_buttons = false; -static bool hyundai_canfd_hda2_alt_steering = false; +static bool hyundai_canfd_lka_steering_alt = false; -static int hyundai_canfd_hda2_get_lkas_addr(void) { - return hyundai_canfd_hda2_alt_steering ? 0x110 : 0x50; +static int hyundai_canfd_get_lka_addr(void) { + return hyundai_canfd_lka_steering_alt ? 0x110 : 0x50; } static uint8_t hyundai_canfd_get_counter(const CANPacket_t *to_push) { @@ -49,7 +49,7 @@ static void hyundai_canfd_rx_hook(const CANPacket_t *to_push) { int bus = GET_BUS(to_push); int addr = GET_ADDR(to_push); - const int pt_bus = hyundai_canfd_hda2 ? 1 : 0; + const int pt_bus = hyundai_canfd_lka_steering ? 1 : 0; const int scc_bus = hyundai_camera_scc ? 2 : pt_bus; if (bus == pt_bus) { @@ -108,12 +108,12 @@ static void hyundai_canfd_rx_hook(const CANPacket_t *to_push) { } } - const int steer_addr = hyundai_canfd_hda2 ? hyundai_canfd_hda2_get_lkas_addr() : 0x12a; + const int steer_addr = hyundai_canfd_lka_steering ? hyundai_canfd_get_lka_addr() : 0x12a; bool stock_ecu_detected = (addr == steer_addr) && (bus == 0); if (hyundai_longitudinal) { - // on HDA2, ensure ADRV ECU is still knocked out + // on LKA steering cars, ensure ADRV ECU is still knocked out // on others, ensure accel msg is blocked from camera - const int stock_scc_bus = hyundai_canfd_hda2 ? 1 : 0; + const int stock_scc_bus = hyundai_canfd_lka_steering ? 1 : 0; stock_ecu_detected = stock_ecu_detected || ((addr == 0x1a0) && (bus == stock_scc_bus)); } generic_rx_checks(stock_ecu_detected); @@ -143,7 +143,7 @@ static bool hyundai_canfd_tx_hook(const CANPacket_t *to_send) { int addr = GET_ADDR(to_send); // steering - const int steer_addr = (hyundai_canfd_hda2 && !hyundai_longitudinal) ? hyundai_canfd_hda2_get_lkas_addr() : 0x12a; + const int steer_addr = (hyundai_canfd_lka_steering && !hyundai_longitudinal) ? hyundai_canfd_get_lka_addr() : 0x12a; if (addr == steer_addr) { int desired_torque = (((GET_BYTE(to_send, 6) & 0xFU) << 7U) | (GET_BYTE(to_send, 5) >> 1U)) - 1024U; bool steer_req = GET_BIT(to_send, 52U); @@ -166,7 +166,7 @@ static bool hyundai_canfd_tx_hook(const CANPacket_t *to_send) { } // UDS: only tester present ("\x02\x3E\x80\x00\x00\x00\x00\x00") allowed on diagnostics address - if ((addr == 0x730) && hyundai_canfd_hda2) { + if ((addr == 0x730) && hyundai_canfd_lka_steering) { if ((GET_BYTES(to_send, 0, 4) != 0x00803E02U) || (GET_BYTES(to_send, 4, 4) != 0x0U)) { tx = false; } @@ -204,18 +204,18 @@ static int hyundai_canfd_fwd_hook(int bus_num, int addr) { bus_fwd = 2; } if (bus_num == 2) { - // LKAS for HDA2, LFA for HDA1 - int hda2_lfa_block_addr = hyundai_canfd_hda2_alt_steering ? 0x362 : 0x2a4; - bool is_lkas_msg = ((addr == hyundai_canfd_hda2_get_lkas_addr()) || (addr == hda2_lfa_block_addr)) && hyundai_canfd_hda2; - bool is_lfa_msg = ((addr == 0x12a) && !hyundai_canfd_hda2); + // LKAS for cars with LKAS and LFA messages, LFA for cars with no LKAS messages + int lfa_block_addr = hyundai_canfd_lka_steering_alt ? 0x362 : 0x2a4; + bool is_lka_msg = ((addr == hyundai_canfd_get_lka_addr()) || (addr == lfa_block_addr)) && hyundai_canfd_lka_steering; + bool is_lfa_msg = ((addr == 0x12a) && !hyundai_canfd_lka_steering); // HUD icons - bool is_lfahda_msg = ((addr == 0x1e0) && !hyundai_canfd_hda2); + bool is_lfahda_msg = ((addr == 0x1e0) && !hyundai_canfd_lka_steering); - // CRUISE_INFO for non-HDA2, we send our own longitudinal commands - bool is_scc_msg = ((addr == 0x1a0) && hyundai_longitudinal && !hyundai_canfd_hda2); + // SCC_CONTROL for camera SCC cars, we send our own longitudinal commands + bool is_scc_msg = ((addr == 0x1a0) && hyundai_longitudinal && !hyundai_canfd_lka_steering); - bool block_msg = is_lkas_msg || is_lfa_msg || is_lfahda_msg || is_scc_msg; + bool block_msg = is_lka_msg || is_lfa_msg || is_lfahda_msg || is_scc_msg; if (!block_msg) { bus_fwd = 0; } @@ -225,22 +225,22 @@ static int hyundai_canfd_fwd_hook(int bus_num, int addr) { } static safety_config hyundai_canfd_init(uint16_t param) { - const int HYUNDAI_PARAM_CANFD_HDA2_ALT_STEERING = 128; + const int HYUNDAI_PARAM_CANFD_LKA_STEERING_ALT = 128; const int HYUNDAI_PARAM_CANFD_ALT_BUTTONS = 32; - static const CanMsg HYUNDAI_CANFD_HDA2_TX_MSGS[] = { + static const CanMsg HYUNDAI_CANFD_LKA_STEERING_TX_MSGS[] = { {0x50, 0, 16}, // LKAS {0x1CF, 1, 8}, // CRUISE_BUTTON {0x2A4, 0, 24}, // CAM_0x2A4 }; - static const CanMsg HYUNDAI_CANFD_HDA2_ALT_STEERING_TX_MSGS[] = { + static const CanMsg HYUNDAI_CANFD_LKA_STEERING_ALT_TX_MSGS[] = { {0x110, 0, 32}, // LKAS_ALT {0x1CF, 1, 8}, // CRUISE_BUTTON {0x362, 0, 32}, // CAM_0x362 }; - static const CanMsg HYUNDAI_CANFD_HDA2_LONG_TX_MSGS[] = { + static const CanMsg HYUNDAI_CANFD_LKA_STEERING_LONG_TX_MSGS[] = { {0x50, 0, 16}, // LKAS {0x1CF, 1, 8}, // CRUISE_BUTTON {0x2A4, 0, 24}, // CAM_0x2A4 @@ -256,7 +256,7 @@ static safety_config hyundai_canfd_init(uint16_t param) { {0x1DA, 1, 32}, // ADRV_0x1da }; - static const CanMsg HYUNDAI_CANFD_HDA1_TX_MSGS[] = { + static const CanMsg HYUNDAI_CANFD_LFA_STEERING_TX_MSGS[] = { {0x12A, 0, 16}, // LFA {0x1A0, 0, 32}, // CRUISE_INFO {0x1CF, 2, 8}, // CRUISE_BUTTON @@ -268,50 +268,50 @@ static safety_config hyundai_canfd_init(uint16_t param) { gen_crc_lookup_table_16(0x1021, hyundai_canfd_crc_lut); hyundai_canfd_alt_buttons = GET_FLAG(param, HYUNDAI_PARAM_CANFD_ALT_BUTTONS); - hyundai_canfd_hda2_alt_steering = GET_FLAG(param, HYUNDAI_PARAM_CANFD_HDA2_ALT_STEERING); + hyundai_canfd_lka_steering_alt = GET_FLAG(param, HYUNDAI_PARAM_CANFD_LKA_STEERING_ALT); - // no long for radar-SCC HDA1 yet - if (!hyundai_canfd_hda2 && !hyundai_camera_scc) { + // no long for radar-SCC with LFA steering yet + if (!hyundai_canfd_lka_steering && !hyundai_camera_scc) { hyundai_longitudinal = false; } safety_config ret; if (hyundai_longitudinal) { - if (hyundai_canfd_hda2) { - static RxCheck hyundai_canfd_hda2_long_rx_checks[] = { + if (hyundai_canfd_lka_steering) { + static RxCheck hyundai_canfd_lka_steering_long_rx_checks[] = { HYUNDAI_CANFD_COMMON_RX_CHECKS(1) HYUNDAI_CANFD_BUTTONS_ADDR_CHECK(1) }; - ret = BUILD_SAFETY_CFG(hyundai_canfd_hda2_long_rx_checks, HYUNDAI_CANFD_HDA2_LONG_TX_MSGS); + ret = BUILD_SAFETY_CFG(hyundai_canfd_lka_steering_long_rx_checks, HYUNDAI_CANFD_LKA_STEERING_LONG_TX_MSGS); } else { static RxCheck hyundai_canfd_long_alt_buttons_rx_checks[] = { HYUNDAI_CANFD_COMMON_RX_CHECKS(0) HYUNDAI_CANFD_ALT_BUTTONS_ADDR_CHECK(0) }; - // Longitudinal checks for HDA1 + // Longitudinal checks for LFA steering static RxCheck hyundai_canfd_long_rx_checks[] = { HYUNDAI_CANFD_COMMON_RX_CHECKS(0) HYUNDAI_CANFD_BUTTONS_ADDR_CHECK(0) }; - ret = hyundai_canfd_alt_buttons ? BUILD_SAFETY_CFG(hyundai_canfd_long_alt_buttons_rx_checks, HYUNDAI_CANFD_HDA1_TX_MSGS) : \ - BUILD_SAFETY_CFG(hyundai_canfd_long_rx_checks, HYUNDAI_CANFD_HDA1_TX_MSGS); + ret = hyundai_canfd_alt_buttons ? BUILD_SAFETY_CFG(hyundai_canfd_long_alt_buttons_rx_checks, HYUNDAI_CANFD_LFA_STEERING_TX_MSGS) : \ + BUILD_SAFETY_CFG(hyundai_canfd_long_rx_checks, HYUNDAI_CANFD_LFA_STEERING_TX_MSGS); } } else { - if (hyundai_canfd_hda2) { - // *** HDA2 checks *** - // E-CAN is on bus 1, ADAS unit sends SCC messages on HDA2. + if (hyundai_canfd_lka_steering) { + // *** LKA steering checks *** + // E-CAN is on bus 1, SCC messages are sent on cars with ADRV ECU. // Does not use the alt buttons message - static RxCheck hyundai_canfd_hda2_rx_checks[] = { + static RxCheck hyundai_canfd_lka_steering_rx_checks[] = { HYUNDAI_CANFD_COMMON_RX_CHECKS(1) HYUNDAI_CANFD_BUTTONS_ADDR_CHECK(1) HYUNDAI_CANFD_SCC_ADDR_CHECK(1) }; - ret = hyundai_canfd_hda2_alt_steering ? BUILD_SAFETY_CFG(hyundai_canfd_hda2_rx_checks, HYUNDAI_CANFD_HDA2_ALT_STEERING_TX_MSGS) : \ - BUILD_SAFETY_CFG(hyundai_canfd_hda2_rx_checks, HYUNDAI_CANFD_HDA2_TX_MSGS); + ret = hyundai_canfd_lka_steering_alt ? BUILD_SAFETY_CFG(hyundai_canfd_lka_steering_rx_checks, HYUNDAI_CANFD_LKA_STEERING_ALT_TX_MSGS) : \ + BUILD_SAFETY_CFG(hyundai_canfd_lka_steering_rx_checks, HYUNDAI_CANFD_LKA_STEERING_TX_MSGS); } else if (!hyundai_camera_scc) { static RxCheck hyundai_canfd_radar_scc_alt_buttons_rx_checks[] = { HYUNDAI_CANFD_COMMON_RX_CHECKS(0) @@ -326,17 +326,17 @@ static safety_config hyundai_canfd_init(uint16_t param) { HYUNDAI_CANFD_SCC_ADDR_CHECK(0) }; - ret = hyundai_canfd_alt_buttons ? BUILD_SAFETY_CFG(hyundai_canfd_radar_scc_alt_buttons_rx_checks, HYUNDAI_CANFD_HDA1_TX_MSGS) : \ - BUILD_SAFETY_CFG(hyundai_canfd_radar_scc_rx_checks, HYUNDAI_CANFD_HDA1_TX_MSGS); + ret = hyundai_canfd_alt_buttons ? BUILD_SAFETY_CFG(hyundai_canfd_radar_scc_alt_buttons_rx_checks, HYUNDAI_CANFD_LFA_STEERING_TX_MSGS) : \ + BUILD_SAFETY_CFG(hyundai_canfd_radar_scc_rx_checks, HYUNDAI_CANFD_LFA_STEERING_TX_MSGS); } else { - // *** Non-HDA2 checks *** + // *** LFA steering checks *** static RxCheck hyundai_canfd_alt_buttons_rx_checks[] = { HYUNDAI_CANFD_COMMON_RX_CHECKS(0) HYUNDAI_CANFD_ALT_BUTTONS_ADDR_CHECK(0) HYUNDAI_CANFD_SCC_ADDR_CHECK(2) }; - // Camera sends SCC messages on HDA1. + // Camera sends SCC messages on LFA steering cars. // Both button messages exist on some platforms, so we ensure we track the correct one using flag static RxCheck hyundai_canfd_rx_checks[] = { HYUNDAI_CANFD_COMMON_RX_CHECKS(0) @@ -344,8 +344,8 @@ static safety_config hyundai_canfd_init(uint16_t param) { HYUNDAI_CANFD_SCC_ADDR_CHECK(2) }; - ret = hyundai_canfd_alt_buttons ? BUILD_SAFETY_CFG(hyundai_canfd_alt_buttons_rx_checks, HYUNDAI_CANFD_HDA1_TX_MSGS) : \ - BUILD_SAFETY_CFG(hyundai_canfd_rx_checks, HYUNDAI_CANFD_HDA1_TX_MSGS); + ret = hyundai_canfd_alt_buttons ? BUILD_SAFETY_CFG(hyundai_canfd_alt_buttons_rx_checks, HYUNDAI_CANFD_LFA_STEERING_TX_MSGS) : \ + BUILD_SAFETY_CFG(hyundai_canfd_rx_checks, HYUNDAI_CANFD_LFA_STEERING_TX_MSGS); } } diff --git a/opendbc/safety/safety/safety_hyundai_common.h b/opendbc/safety/safety/safety_hyundai_common.h index d83b3964..8c8c8759 100644 --- a/opendbc/safety/safety/safety_hyundai_common.h +++ b/opendbc/safety/safety/safety_hyundai_common.h @@ -30,8 +30,8 @@ bool hyundai_longitudinal = false; extern bool hyundai_camera_scc; bool hyundai_camera_scc = false; -extern bool hyundai_canfd_hda2; -bool hyundai_canfd_hda2 = false; +extern bool hyundai_canfd_lka_steering; +bool hyundai_canfd_lka_steering = false; extern bool hyundai_alt_limits; bool hyundai_alt_limits = false; @@ -42,13 +42,13 @@ void hyundai_common_init(uint16_t param) { const int HYUNDAI_PARAM_EV_GAS = 1; const int HYUNDAI_PARAM_HYBRID_GAS = 2; const int HYUNDAI_PARAM_CAMERA_SCC = 8; - const int HYUNDAI_PARAM_CANFD_HDA2 = 16; + const int HYUNDAI_PARAM_CANFD_LKA_STEERING = 16; const int HYUNDAI_PARAM_ALT_LIMITS = 64; // TODO: shift this down with the rest of the common flags hyundai_ev_gas_signal = GET_FLAG(param, HYUNDAI_PARAM_EV_GAS); hyundai_hybrid_gas_signal = !hyundai_ev_gas_signal && GET_FLAG(param, HYUNDAI_PARAM_HYBRID_GAS); hyundai_camera_scc = GET_FLAG(param, HYUNDAI_PARAM_CAMERA_SCC); - hyundai_canfd_hda2 = GET_FLAG(param, HYUNDAI_PARAM_CANFD_HDA2); + hyundai_canfd_lka_steering = GET_FLAG(param, HYUNDAI_PARAM_CANFD_LKA_STEERING); hyundai_alt_limits = GET_FLAG(param, HYUNDAI_PARAM_ALT_LIMITS); hyundai_last_button_interaction = HYUNDAI_PREV_BUTTON_SAMPLES; diff --git a/opendbc/safety/tests/common.py b/opendbc/safety/tests/common.py index 2287227e..27a978a6 100644 --- a/opendbc/safety/tests/common.py +++ b/opendbc/safety/tests/common.py @@ -773,7 +773,7 @@ class PandaSafetyTest(PandaSafetyTestBase): continue # overlapping TX addrs, but they're not actuating messages for either car - if attr == 'TestHyundaiCanfdHDA2LongEV' and current_test.startswith('TestToyota'): + if attr == 'TestHyundaiCanfdLKASteeringLongEV' and current_test.startswith('TestToyota'): tx = list(filter(lambda m: m[0] not in [0x160, ], tx)) # Volkswagen MQB longitudinal actuating message overlaps with the Subaru lateral actuating message diff --git a/opendbc/safety/tests/test_hyundai_canfd.py b/opendbc/safety/tests/test_hyundai_canfd.py index 65814da4..c0712e54 100755 --- a/opendbc/safety/tests/test_hyundai_canfd.py +++ b/opendbc/safety/tests/test_hyundai_canfd.py @@ -81,7 +81,7 @@ class TestHyundaiCanfdBase(HyundaiButtonBase, common.PandaCarSafetyTest, common. return self.packer.make_can_msg_panda("CRUISE_BUTTONS", bus, values) -class TestHyundaiCanfdHDA1Base(TestHyundaiCanfdBase): +class TestHyundaiCanfdLFASteeringBase(TestHyundaiCanfdBase): TX_MSGS = [[0x12A, 0], [0x1A0, 1], [0x1CF, 0], [0x1E0, 0]] RELAY_MALFUNCTION_ADDRS = {0: (0x12A,)} # LFA @@ -95,7 +95,7 @@ class TestHyundaiCanfdHDA1Base(TestHyundaiCanfdBase): @classmethod def setUpClass(cls): super().setUpClass() - if cls.__name__ in ("TestHyundaiCanfdHDA1", "TestHyundaiCanfdHDA1AltButtons"): + if cls.__name__ in ("TestHyundaiCanfdLFASteering", "TestHyundaiCanfdLFASteeringAltButtons"): cls.packer = None cls.safety = None raise unittest.SkipTest @@ -121,7 +121,7 @@ class TestHyundaiCanfdHDA1Base(TestHyundaiCanfdBase): {"GAS_MSG": ("ACCELERATOR_ALT", "ACCELERATOR_PEDAL"), "SCC_BUS": 2, "SAFETY_PARAM": HyundaiSafetyFlags.HYBRID_GAS | HyundaiSafetyFlags.CAMERA_SCC}, ]) -class TestHyundaiCanfdHDA1(TestHyundaiCanfdHDA1Base): +class TestHyundaiCanfdLFASteering(TestHyundaiCanfdLFASteeringBase): pass @@ -139,7 +139,7 @@ class TestHyundaiCanfdHDA1(TestHyundaiCanfdHDA1Base): {"GAS_MSG": ("ACCELERATOR_ALT", "ACCELERATOR_PEDAL"), "SCC_BUS": 2, "SAFETY_PARAM": HyundaiSafetyFlags.HYBRID_GAS | HyundaiSafetyFlags.CAMERA_SCC}, ]) -class TestHyundaiCanfdHDA1AltButtons(TestHyundaiCanfdHDA1Base): +class TestHyundaiCanfdLFASteeringAltButtons(TestHyundaiCanfdLFASteeringBase): SAFETY_PARAM: int @@ -166,7 +166,7 @@ class TestHyundaiCanfdHDA1AltButtons(TestHyundaiCanfdHDA1Base): self.assertFalse(self._tx(self._button_msg(btn))) -class TestHyundaiCanfdHDA2EV(TestHyundaiCanfdBase): +class TestHyundaiCanfdLKASteeringEV(TestHyundaiCanfdBase): TX_MSGS = [[0x50, 0], [0x1CF, 1], [0x2A4, 0]] RELAY_MALFUNCTION_ADDRS = {0: (0x50,)} # LKAS @@ -181,12 +181,12 @@ class TestHyundaiCanfdHDA2EV(TestHyundaiCanfdBase): def setUp(self): self.packer = CANPackerPanda("hyundai_canfd") self.safety = libsafety_py.libsafety - self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiCanfd, HyundaiSafetyFlags.CANFD_HDA2 | HyundaiSafetyFlags.EV_GAS) + self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiCanfd, HyundaiSafetyFlags.CANFD_LKA_STEERING | HyundaiSafetyFlags.EV_GAS) self.safety.init_tests() # TODO: Handle ICE and HEV configurations once we see cars that use the new messages -class TestHyundaiCanfdHDA2EVAltSteering(TestHyundaiCanfdBase): +class TestHyundaiCanfdLKASteeringAltEV(TestHyundaiCanfdBase): TX_MSGS = [[0x110, 0], [0x1CF, 1], [0x362, 0]] RELAY_MALFUNCTION_ADDRS = {0: (0x110,)} # LKAS_ALT @@ -201,12 +201,12 @@ class TestHyundaiCanfdHDA2EVAltSteering(TestHyundaiCanfdBase): def setUp(self): self.packer = CANPackerPanda("hyundai_canfd") self.safety = libsafety_py.libsafety - self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiCanfd, HyundaiSafetyFlags.CANFD_HDA2 | HyundaiSafetyFlags.EV_GAS | - HyundaiSafetyFlags.CANFD_HDA2_ALT_STEERING) + self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiCanfd, HyundaiSafetyFlags.CANFD_LKA_STEERING | HyundaiSafetyFlags.EV_GAS | + HyundaiSafetyFlags.CANFD_LKA_STEERING_ALT) self.safety.init_tests() -class TestHyundaiCanfdHDA2LongEV(HyundaiLongitudinalBase, TestHyundaiCanfdHDA2EV): +class TestHyundaiCanfdLKASteeringLongEV(HyundaiLongitudinalBase, TestHyundaiCanfdLKASteeringEV): TX_MSGS = [[0x50, 0], [0x1CF, 1], [0x2A4, 0], [0x51, 0], [0x730, 1], [0x12a, 1], [0x160, 1], [0x1e0, 1], [0x1a0, 1], [0x1ea, 1], [0x200, 1], [0x345, 1], [0x1da, 1]] @@ -223,7 +223,7 @@ class TestHyundaiCanfdHDA2LongEV(HyundaiLongitudinalBase, TestHyundaiCanfdHDA2EV def setUp(self): self.packer = CANPackerPanda("hyundai_canfd") self.safety = libsafety_py.libsafety - self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiCanfd, HyundaiSafetyFlags.CANFD_HDA2 | + self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiCanfd, HyundaiSafetyFlags.CANFD_LKA_STEERING | HyundaiSafetyFlags.LONG | HyundaiSafetyFlags.EV_GAS) self.safety.init_tests() @@ -235,14 +235,14 @@ class TestHyundaiCanfdHDA2LongEV(HyundaiLongitudinalBase, TestHyundaiCanfdHDA2EV return self.packer.make_can_msg_panda("SCC_CONTROL", 1, values) -# Tests HDA1 longitudinal for ICE, hybrid, EV +# Tests longitudinal for ICE, hybrid, EV cars with LFA steering @parameterized_class([ - # Camera SCC is the only supported configuration for HDA1 longitudinal, TODO: allow radar SCC + # Camera SCC is the only supported configuration for LFA steering cars, TODO: allow radar SCC {"GAS_MSG": ("ACCELERATOR_BRAKE_ALT", "ACCELERATOR_PEDAL_PRESSED"), "SAFETY_PARAM": HyundaiSafetyFlags.LONG}, {"GAS_MSG": ("ACCELERATOR", "ACCELERATOR_PEDAL"), "SAFETY_PARAM": HyundaiSafetyFlags.LONG | HyundaiSafetyFlags.EV_GAS}, {"GAS_MSG": ("ACCELERATOR_ALT", "ACCELERATOR_PEDAL"), "SAFETY_PARAM": HyundaiSafetyFlags.LONG | HyundaiSafetyFlags.HYBRID_GAS}, ]) -class TestHyundaiCanfdHDA1Long(HyundaiLongitudinalBase, TestHyundaiCanfdHDA1Base): +class TestHyundaiCanfdLFASteeringLong(HyundaiLongitudinalBase, TestHyundaiCanfdLFASteeringBase): FWD_BLACKLISTED_ADDRS = {2: [0x12a, 0x1e0, 0x1a0]} @@ -257,7 +257,7 @@ class TestHyundaiCanfdHDA1Long(HyundaiLongitudinalBase, TestHyundaiCanfdHDA1Base @classmethod def setUpClass(cls): - if cls.__name__ == "TestHyundaiCanfdHDA1Long": + if cls.__name__ == "TestHyundaiCanfdLFASteeringLong": cls.safety = None raise unittest.SkipTest