Merge branch 'palisade-2023-port-1' into palisade-2023-hda2-long

This reverts commit bf26c38397.

RELEASES.md

@@ -1,6 +1,8 @@
 Version 0.9.8 (2024-XX-XX)
 ========================
 * Added toggle to enable driver monitoring even when openpilot is not engaged
+* Hyundai Palisade (with HDA II) 2023-24 support thanks to sunnyhaibin!
+* Kia Telluride (with HDA II) 2023-24 support thanks to sunnyhaibin!
 
 Version 0.9.7 (2024-06-13)
 ========================

selfdrive/car/hyundai/carcontroller.py

@@ -103,13 +103,18 @@ class CarController(CarControllerBase):
       if self.CP.flags & HyundaiFlags.ENABLE_BLINKERS:
         can_sends.append([0x7b1, 0, b"\x02\x3E\x80\x00\x00\x00\x00\x00", self.CAN.ECAN])
 
+    hda2 = self.CP.flags & HyundaiFlags.CANFD_HDA2
+    can_canfd_hybrid = self.CP.flags & HyundaiFlags.CAN_CANFD_HYBRID
+
     # CAN-FD platforms
-    if self.CP.carFingerprint in CANFD_CAR:
-      hda2 = self.CP.flags & HyundaiFlags.CANFD_HDA2
+    if self.CP.carFingerprint in CANFD_CAR or (hda2 and can_canfd_hybrid):
       hda2_long = hda2 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))
+      can_sends.extend(hyundaicanfd.create_steering_messages(self.packer, self.CP, self.CAN, CC.enabled, apply_steer_req, apply_steer,
+                                                             self.frame, torque_fault,
+                                                             hud_control.leftLaneVisible, hud_control.rightLaneVisible,
+                                                             left_lane_warning, right_lane_warning))
 
       # prevent LFA from activating on HDA2 by sending "no lane lines detected" to ADAS ECU
       if self.frame % 5 == 0 and hda2:
@@ -118,7 +123,7 @@ class CarController(CarControllerBase):
 
       # LFA and HDA icons
       if self.frame % 5 == 0 and (not hda2 or hda2_long):
-        can_sends.append(hyundaicanfd.create_lfahda_cluster(self.packer, self.CAN, CC.enabled))
+        can_sends.append(hyundaicanfd.create_lfahda_cluster(self.packer, self.CAN, CC.enabled, can_canfd_hybrid))
 
       # blinkers
       if hda2 and self.CP.flags & HyundaiFlags.ENABLE_BLINKERS:
@@ -126,14 +131,23 @@ class CarController(CarControllerBase):
 
       if self.CP.openpilotLongitudinalControl:
         if hda2:
-          can_sends.extend(hyundaicanfd.create_adrv_messages(self.packer, self.CAN, self.frame))
+          can_sends.extend(hyundaicanfd.create_adrv_messages(self.packer, self.CAN, self.frame, can_canfd_hybrid))
+          if can_canfd_hybrid:
+            can_sends.extend(hyundaicanfd.create_radar_aux_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,
-                                                           set_speed_in_units, hud_control))
+          if can_canfd_hybrid:
+            stopping = stopping and CS.out.vEgoRaw < 0.1
+            upper_jerk = 3.0 if actuators.longControlState == LongCtrlState.pid else 1.0
+            can_sends.extend(hyundaicanfd.create_acc_commands_can_canfd_hybrid(self.packer, self.CAN, CC.enabled, accel, self.accel_last, upper_jerk,
+                                                                               int(self.frame / 2), hud_control.leadVisible,
+                                                                               set_speed_in_units, stopping, CC.cruiseControl.override, hud_control))
+          else:
+            can_sends.append(hyundaicanfd.create_acc_control(self.packer, self.CAN, CC.enabled, self.accel_last, accel, stopping, CC.cruiseControl.override,
+                                                             set_speed_in_units, hud_control))
           self.accel_last = accel
       else:
         # button presses
-        can_sends.extend(self.create_button_messages(CC, CS, use_clu11=False))
+        can_sends.extend(self.create_button_messages(CC, CS, use_clu11=(hda2 and can_canfd_hybrid)))
     else:
       can_sends.append(hyundaican.create_lkas11(self.packer, self.frame, self.CP, apply_steer, apply_steer_req,
                                                 torque_fault, CS.lkas11, sys_warning, sys_state, CC.enabled,
@@ -175,12 +189,12 @@ class CarController(CarControllerBase):
     can_sends = []
     if use_clu11:
       if CC.cruiseControl.cancel:
-        can_sends.append(hyundaican.create_clu11(self.packer, self.frame, CS.clu11, Buttons.CANCEL, self.CP))
+        can_sends.append(hyundaican.create_clu11(self.packer, self.frame, CS.clu11, Buttons.CANCEL, self.CP, self.CAN))
       elif CC.cruiseControl.resume:
         # send resume at a max freq of 10Hz
         if (self.frame - self.last_button_frame) * DT_CTRL > 0.1:
           # send 25 messages at a time to increases the likelihood of resume being accepted
-          can_sends.extend([hyundaican.create_clu11(self.packer, self.frame, CS.clu11, Buttons.RES_ACCEL, self.CP)] * 25)
+          can_sends.extend([hyundaican.create_clu11(self.packer, self.frame, CS.clu11, Buttons.RES_ACCEL, self.CP, self.CAN)] * 25)
           if (self.frame - self.last_button_frame) * DT_CTRL >= 0.15:
             self.last_button_frame = self.frame
     else:

selfdrive/car/hyundai/carstate.py

@@ -8,7 +8,7 @@ from opendbc.can.parser import CANParser
 from opendbc.can.can_define import CANDefine
 from openpilot.selfdrive.car.hyundai.hyundaicanfd import CanBus
 from openpilot.selfdrive.car.hyundai.values import HyundaiFlags, CAR, DBC, CAN_GEARS, CAMERA_SCC_CAR, \
-                                                   CANFD_CAR, Buttons, CarControllerParams
+                                                   CANFD_CAR, Buttons, CarControllerParams, CAN_CANFD_HYBRID_CAR
 from openpilot.selfdrive.car.interfaces import CarStateBase
 
 PREV_BUTTON_SAMPLES = 8
@@ -27,7 +27,7 @@ class CarState(CarStateBase):
     self.gear_msg_canfd = "GEAR_ALT" if CP.flags & HyundaiFlags.CANFD_ALT_GEARS else \
                           "GEAR_ALT_2" if CP.flags & HyundaiFlags.CANFD_ALT_GEARS_2 else \
                           "GEAR_SHIFTER"
-    if CP.carFingerprint in CANFD_CAR:
+    if CP.carFingerprint in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       self.shifter_values = can_define.dv[self.gear_msg_canfd]["GEAR"]
     elif self.CP.carFingerprint in CAN_GEARS["use_cluster_gears"]:
       self.shifter_values = can_define.dv["CLU15"]["CF_Clu_Gear"]
@@ -53,7 +53,7 @@ class CarState(CarStateBase):
     self.params = CarControllerParams(CP)
 
   def update(self, cp, cp_cam):
-    if self.CP.carFingerprint in CANFD_CAR:
+    if self.CP.carFingerprint in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       return self.update_canfd(cp, cp_cam)
 
     ret = car.CarState.new_message()
@@ -107,11 +107,12 @@ class CarState(CarStateBase):
       ret.cruiseState.standstill = False
       ret.cruiseState.nonAdaptive = False
     else:
-      ret.cruiseState.available = cp_cruise.vl["SCC11"]["MainMode_ACC"] == 1
+      scc_bus = "SCC12" if self.CP.flags & HyundaiFlags.CAN_CANFD_HYBRID else "SCC11"
+      ret.cruiseState.available = cp_cruise.vl[scc_bus]["MainMode_ACC"] == 1
       ret.cruiseState.enabled = cp_cruise.vl["SCC12"]["ACCMode"] != 0
-      ret.cruiseState.standstill = cp_cruise.vl["SCC11"]["SCCInfoDisplay"] == 4.
-      ret.cruiseState.nonAdaptive = cp_cruise.vl["SCC11"]["SCCInfoDisplay"] == 2.  # Shows 'Cruise Control' on dash
-      ret.cruiseState.speed = cp_cruise.vl["SCC11"]["VSetDis"] * speed_conv
+      ret.cruiseState.standstill = cp_cruise.vl[scc_bus]["SCCInfoDisplay"] == 4.
+      ret.cruiseState.nonAdaptive = cp_cruise.vl[scc_bus]["SCCInfoDisplay"] == 2.  # Shows 'Cruise Control' on dash
+      ret.cruiseState.speed = cp_cruise.vl[scc_bus]["VSetDis"] * speed_conv
 
     # TODO: Find brake pressure
     ret.brake = 0
@@ -144,7 +145,7 @@ class CarState(CarStateBase):
 
     ret.gearShifter = self.parse_gear_shifter(self.shifter_values.get(gear))
 
-    if not self.CP.openpilotLongitudinalControl:
+    if not self.CP.openpilotLongitudinalControl and not (self.CP.flags & HyundaiFlags.CAN_CANFD_HYBRID):
       aeb_src = "FCA11" if self.CP.flags & HyundaiFlags.USE_FCA.value else "SCC12"
       aeb_sig = "FCA_CmdAct" if self.CP.flags & HyundaiFlags.USE_FCA.value else "AEB_CmdAct"
       aeb_warning = cp_cruise.vl[aeb_src]["CF_VSM_Warn"] != 0
@@ -158,8 +159,11 @@ class CarState(CarStateBase):
       ret.rightBlindspot = cp.vl["LCA11"]["CF_Lca_IndRight"] != 0
 
     # save the entire LKAS11 and CLU11
-    self.lkas11 = copy.copy(cp_cam.vl["LKAS11"])
+    if not self.CP.flags & HyundaiFlags.CAN_CANFD_HYBRID:
+      self.lkas11 = copy.copy(cp_cam.vl["LKAS11"])
     self.clu11 = copy.copy(cp.vl["CLU11"])
+    if self.CP.flags & HyundaiFlags.CAN_CANFD_HYBRID and self.CP.flags & HyundaiFlags.CANFD_HDA2:
+      self.hda2_lfa_block_msg = copy.copy(cp_cam.vl["CAM_0x2a4"])
     self.steer_state = cp.vl["MDPS12"]["CF_Mdps_ToiActive"]  # 0 NOT ACTIVE, 1 ACTIVE
     self.prev_cruise_buttons = self.cruise_buttons[-1]
     self.cruise_buttons.extend(cp.vl_all["CLU11"]["CF_Clu_CruiseSwState"])
@@ -250,12 +254,12 @@ class CarState(CarStateBase):
     return ret
 
   def get_can_parser(self, CP):
-    if CP.carFingerprint in CANFD_CAR:
+    if CP.carFingerprint in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       return self.get_can_parser_canfd(CP)
 
     messages = [
       # address, frequency
-      ("MDPS12", 50),
+      ("MDPS12", 100 if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID else 50),
       ("TCS11", 100),
       ("TCS13", 50),
       ("TCS15", 10),
@@ -269,16 +273,19 @@ class CarState(CarStateBase):
       ("SAS11", 100),
     ]
 
-    if not CP.openpilotLongitudinalControl and CP.carFingerprint not in CAMERA_SCC_CAR:
-      messages += [
-        ("SCC11", 50),
-        ("SCC12", 50),
-      ]
-      if CP.flags & HyundaiFlags.USE_FCA.value:
-        messages.append(("FCA11", 50))
+    if not CP.openpilotLongitudinalControl:
+      if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID:
+        messages.append(("SCC12", 50))
+      elif CP.carFingerprint not in CAMERA_SCC_CAR:
+        messages += [
+          ("SCC11", 50),
+          ("SCC12", 50),
+        ]
+        if CP.flags & HyundaiFlags.USE_FCA.value:
+          messages.append(("FCA11", 50))
 
     if CP.enableBsm:
-      messages.append(("LCA11", 50))
+      messages.append(("LCA11", 20 if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID else 50))
 
     if CP.flags & (HyundaiFlags.HYBRID | HyundaiFlags.EV):
       messages.append(("E_EMS11", 50))
@@ -297,16 +304,20 @@ class CarState(CarStateBase):
     else:
       messages.append(("LVR12", 100))
 
-    return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
+    bus = CanBus(CP).ECAN if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID else 0
+    return CANParser(DBC[CP.carFingerprint]["pt"], messages, bus)
 
   @staticmethod
   def get_cam_can_parser(CP):
-    if CP.carFingerprint in CANFD_CAR:
+    if CP.carFingerprint in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       return CarState.get_cam_can_parser_canfd(CP)
 
-    messages = [
-      ("LKAS11", 100)
-    ]
+    messages = []
+
+    if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID:
+      messages.append(("CAM_0x2a4", 20))
+    else:
+      messages.append(("LKAS11", 100))
 
     if not CP.openpilotLongitudinalControl and CP.carFingerprint in CAMERA_SCC_CAR:
       messages += [
@@ -317,7 +328,8 @@ class CarState(CarStateBase):
       if CP.flags & HyundaiFlags.USE_FCA.value:
         messages.append(("FCA11", 50))
 
-    return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)
+    bus = CanBus(CP).CAM if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID else 2
+    return CANParser(DBC[CP.carFingerprint]["pt"], messages, bus)
 
   def get_can_parser_canfd(self, CP):
     messages = [

selfdrive/car/hyundai/fingerprints.py

@@ -1162,4 +1162,21 @@ FW_VERSIONS = {
       b'\xf1\x00US4_ RDR -----      1.00 1.00 99110-CG000         ',
     ],
   },
+  CAR.HYUNDAI_PALISADE_2023: {
+    (Ecu.fwdCamera, 0x7c4, None): [
+      b'\xf1\x00LX2 MFC  AT USA LHD 1.00 1.04 99211-S8150 220622',
+      b'\xf1\x00ON  MFC  AT USA LHD 1.00 1.01 99211-S9150 220708',
+      b'\xf1\x00LX2 MFC  AT USA LHD 1.00 1.03 99211-S8150 220527',
+      b'\xf1\x00ON  MFC  AT USA LHD 1.00 1.00 99211-S9160 230303',
+      b'\xf1\x00LX2 MFC  AT USA LHD 1.00 1.00 99211-S8600 230317',
+      b'\xf1\x00LX2 MFC  AT USA LHD 1.00 1.01 99211-S8600 230817',
+    ],
+    (Ecu.fwdRadar, 0x7d0, None): [
+      b'\xf1\x00LX2_ SCC -----      1.00 1.01 99110-S8150         ',
+      b'\xf1\x00ON__ SCC -----      1.00 1.01 99110-S9150         ',
+      b'\xf1\x00LX2_ SCC -----      1.00 1.00 99110-S8150         ',
+      b'\xf1\x00ON__ SCC -----      1.00 1.00 99110-S9160         ',
+      b'\xf1\x00LX2_ SCC -----      1.00 1.00 99110-S8600         ',
+    ],
+  },
 }

selfdrive/car/hyundai/hyundaican.py

@@ -95,7 +95,7 @@ def create_lkas11(packer, frame, CP, apply_steer, steer_req,
   return packer.make_can_msg("LKAS11", 0, values)
 
 
-def create_clu11(packer, frame, clu11, button, CP):
+def create_clu11(packer, frame, clu11, button, CP, CAN):
   values = {s: clu11[s] for s in [
     "CF_Clu_CruiseSwState",
     "CF_Clu_CruiseSwMain",
@@ -113,7 +113,7 @@ def create_clu11(packer, frame, clu11, button, CP):
   values["CF_Clu_CruiseSwState"] = button
   values["CF_Clu_AliveCnt1"] = frame % 0x10
   # send buttons to camera on camera-scc based cars
-  bus = 2 if CP.flags & HyundaiFlags.CAMERA_SCC else 0
+  bus = 2 if CP.flags & HyundaiFlags.CAMERA_SCC else CAN.ECAN if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID else 0
   return packer.make_can_msg("CLU11", bus, values)
 
 

selfdrive/car/hyundai/hyundaicanfd.py

@@ -1,5 +1,6 @@
 from openpilot.common.numpy_fast import clip
 from openpilot.selfdrive.car import CanBusBase
+from openpilot.selfdrive.car.hyundai.hyundaican import hyundai_checksum
 from openpilot.selfdrive.car.hyundai.values import HyundaiFlags
 
 
@@ -35,7 +36,10 @@ class CanBus(CanBusBase):
     return self._cam
 
 
-def create_steering_messages(packer, CP, CAN, enabled, lat_active, apply_steer):
+def create_steering_messages(packer, CP, CAN, enabled, lat_active, apply_steer,
+                             frame, torque_fault,
+                             left_lane, right_lane,
+                             left_lane_depart, right_lane_depart):
 
   ret = []
 
@@ -54,7 +58,13 @@ def create_steering_messages(packer, CP, CAN, enabled, lat_active, apply_steer):
   if CP.flags & HyundaiFlags.CANFD_HDA2:
     hda2_lkas_msg = "LKAS_ALT" if CP.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING else "LKAS"
     if CP.openpilotLongitudinalControl:
-      ret.append(packer.make_can_msg("LFA", CAN.ECAN, values))
+      if CP.flags & HyundaiFlags.CAN_CANFD_HYBRID:
+        ret.append(create_lkas11_can_canfd_hybrid(packer, CAN, frame, apply_steer, lat_active,
+                                                  torque_fault, enabled,
+                                                  left_lane, right_lane,
+                                                  left_lane_depart, right_lane_depart))
+      else:
+        ret.append(packer.make_can_msg("LFA", CAN.ECAN, values))
     ret.append(packer.make_can_msg(hda2_lkas_msg, CAN.ACAN, values))
   else:
     ret.append(packer.make_can_msg("LFA", CAN.ECAN, values))
@@ -73,6 +83,29 @@ def create_suppress_lfa(packer, CAN, hda2_lfa_block_msg, hda2_alt_steering):
   values["RIGHT_LANE_LINE"] = 0
   return packer.make_can_msg(suppress_msg, CAN.ACAN, values)
 
+def create_lkas11_can_canfd_hybrid(packer, CAN, frame, apply_steer, steer_req,
+                                   torque_fault, enabled,
+                                   left_lane, right_lane,
+                                   left_lane_depart, right_lane_depart):
+
+  values = {
+    "CF_Lkas_LdwsLHWarning": left_lane_depart,
+    "CF_Lkas_LdwsRHWarning": right_lane_depart,
+    "CR_Lkas_StrToqReq": apply_steer,
+    "CF_Lkas_ActToi": steer_req,
+    "CF_Lkas_ToiFlt": torque_fault,  # seems to allow actuation on CR_Lkas_StrToqReq
+    "CF_Lkas_MsgCount": frame % 0xF,
+    "CF_Lkas_FcwOpt_USM": 2 if enabled else 1,
+    "CF_Lkas_LdwsActivemode": int(left_lane) + (int(right_lane) << 1),
+    "NEW_SIGNAL_1": 0,
+    "NEW_SIGNAL_5": 100,
+  }
+
+  checksum = create_checksum_can_canfd_hybrid(packer, CAN, "LKAS11", values)
+  values["CF_Lkas_Chksum"] = checksum
+
+  return packer.make_can_msg("LKAS11", CAN.ECAN, values)
+
 def create_buttons(packer, CP, CAN, cnt, btn):
   values = {
     "COUNTER": cnt,
@@ -113,12 +146,21 @@ def create_acc_cancel(packer, CP, CAN, cruise_info_copy):
   })
   return packer.make_can_msg("SCC_CONTROL", CAN.ECAN, values)
 
-def create_lfahda_cluster(packer, CAN, enabled):
+def create_lfahda_cluster(packer, CAN, enabled, can_canfd_hybrid):
+  hda_icon = "HDA_Icon_State" if can_canfd_hybrid else "HDA_ICON"
+  lfa_icon = "LFA_Icon_State" if can_canfd_hybrid else "LFA_ICON"
+
   values = {
-    "HDA_ICON": 1 if enabled else 0,
-    "LFA_ICON": 2 if enabled else 0,
+    hda_icon: 1 if enabled and not can_canfd_hybrid else 0,
+    lfa_icon: 2 if enabled else 0,
   }
-  return packer.make_can_msg("LFAHDA_CLUSTER", CAN.ECAN, values)
+
+  msg = "LFAHDA_MFC" if can_canfd_hybrid else "LFAHDA_CLUSTER"
+  if can_canfd_hybrid:
+    checksum = create_checksum_can_canfd_hybrid(packer, CAN, msg, values)
+    values["CHECKSUM"] = checksum
+
+  return packer.make_can_msg(msg, CAN.ECAN, values)
 
 
 def create_acc_control(packer, CAN, enabled, accel_last, accel, stopping, gas_override, set_speed, hud_control):
@@ -152,6 +194,56 @@ def create_acc_control(packer, CAN, enabled, accel_last, accel, stopping, gas_ov
   return packer.make_can_msg("SCC_CONTROL", CAN.ECAN, values)
 
 
+def create_acc_commands_can_canfd_hybrid(packer, CAN, enabled, accel, accel_last, upper_jerk, idx, lead_visible, set_speed, stopping, long_override, hud_control):
+  jerk = 5
+  jn = jerk / 50
+  if not enabled or long_override:
+    a_val, a_raw = 0, 0
+  else:
+    a_raw = accel
+    a_val = clip(accel, accel_last - jn, accel_last + jn)
+  ret = []
+
+  msg_values = [
+    ("SCC11", {
+      "aReqRaw": a_raw,
+      "aReqValue": a_val,
+      "JerkUpperLimit": upper_jerk,
+      "JerkLowerLimit": jerk if enabled else 1,
+    }),
+
+    ("SCC12", {
+      "MainMode_ACC": 1,
+      "ACCMode_Inactive": 0 if enabled else 1,
+      "TauGapSet": hud_control.leadDistanceBars,
+      "VSetDis": set_speed,
+      "ACC_ObjDist": 1,
+      "ACCMode": 2 if enabled and long_override else 1 if enabled else 0,
+      "StopReq": 1 if stopping else 0,
+    }),
+
+    ("SCC14", {
+      "ACC_ObjLatPos": 0,
+      "ObjValid": 0,
+      "ObjStatus": 0 if not lead_visible else 2 if lead_visible and enabled else 1,
+    }),
+
+    ("FCA11", {
+      "BYTE4": 0xC0,
+      "BYTE5": 0x3F,
+      "BYTE6": 0x7F,
+    }),
+  ]
+
+  for addr, values in msg_values:
+    values["COUNTER"] = idx % 0xF
+    checksum = create_checksum_can_canfd_hybrid(packer, CAN, addr, values)
+    values["CHECKSUM"] = checksum
+    ret.append(packer.make_can_msg(addr, CAN.ECAN, values))
+
+  return ret
+
+
 def create_spas_messages(packer, CAN, frame, left_blink, right_blink):
   ret = []
 
@@ -172,7 +264,7 @@ def create_spas_messages(packer, CAN, frame, left_blink, right_blink):
   return ret
 
 
-def create_adrv_messages(packer, CAN, frame):
+def create_adrv_messages(packer, CAN, frame, can_canfd_hybrid):
   # messages needed to car happy after disabling
   # the ADAS Driving ECU to do longitudinal control
 
@@ -182,42 +274,89 @@ def create_adrv_messages(packer, CAN, frame):
   }
   ret.append(packer.make_can_msg("ADRV_0x51", CAN.ACAN, values))
 
-  if frame % 2 == 0:
-    values = {
-      'AEB_SETTING': 0x1,  # show AEB disabled icon
-      'SET_ME_2': 0x2,
-      'SET_ME_FF': 0xff,
-      'SET_ME_FC': 0xfc,
-      'SET_ME_9': 0x9,
-    }
-    ret.append(packer.make_can_msg("ADRV_0x160", CAN.ECAN, values))
+  if not can_canfd_hybrid:
+    if frame % 2 == 0:
+      values = {
+        'AEB_SETTING': 0x1,  # show AEB disabled icon
+        'SET_ME_2': 0x2,
+        'SET_ME_FF': 0xff,
+        'SET_ME_FC': 0xfc,
+        'SET_ME_9': 0x9,
+      }
+      ret.append(packer.make_can_msg("ADRV_0x160", CAN.ECAN, values))
 
-  if frame % 5 == 0:
-    values = {
-      'SET_ME_1C': 0x1c,
-      'SET_ME_FF': 0xff,
-      'SET_ME_TMP_F': 0xf,
-      'SET_ME_TMP_F_2': 0xf,
-    }
-    ret.append(packer.make_can_msg("ADRV_0x1ea", CAN.ECAN, values))
+    if frame % 5 == 0:
+      values = {
+        'SET_ME_1C': 0x1c,
+        'SET_ME_FF': 0xff,
+        'SET_ME_TMP_F': 0xf,
+        'SET_ME_TMP_F_2': 0xf,
+      }
+      ret.append(packer.make_can_msg("ADRV_0x1ea", CAN.ECAN, values))
 
-    values = {
-      'SET_ME_E1': 0xe1,
-      'SET_ME_3A': 0x3a,
-    }
-    ret.append(packer.make_can_msg("ADRV_0x200", CAN.ECAN, values))
+      values = {
+        'SET_ME_E1': 0xe1,
+        'SET_ME_3A': 0x3a,
+      }
+      ret.append(packer.make_can_msg("ADRV_0x200", CAN.ECAN, values))
 
-  if frame % 20 == 0:
-    values = {
-      'SET_ME_15': 0x15,
-    }
-    ret.append(packer.make_can_msg("ADRV_0x345", CAN.ECAN, values))
+    if frame % 20 == 0:
+      values = {
+        'SET_ME_15': 0x15,
+      }
+      ret.append(packer.make_can_msg("ADRV_0x345", CAN.ECAN, values))
 
-  if frame % 100 == 0:
-    values = {
-      'SET_ME_22': 0x22,
-      'SET_ME_41': 0x41,
-    }
-    ret.append(packer.make_can_msg("ADRV_0x1da", CAN.ECAN, values))
+    if frame % 100 == 0:
+      values = {
+        'SET_ME_22': 0x22,
+        'SET_ME_41': 0x41,
+      }
+      ret.append(packer.make_can_msg("ADRV_0x1da", CAN.ECAN, values))
 
   return ret
+
+
+def create_radar_aux_messages(packer, CAN, frame):
+  ret = []
+
+  msg_values = [
+    ("RADAR_0x363", 2,  {
+      "FCA_ESA": 1,
+    }),
+    ("RADAR_0x398", 5,  {
+      "BYTE4": 0x80,
+      "BYTE5": 0x5D,
+    }),
+    ("RADAR_0x399", 5,  {
+      "BYTE2": 0x02,
+    }),
+    ("RADAR_0x39a", 5,  {
+      "BYTE7": 0xFF,
+    }),
+    ("RADAR_0x39b", 5,  {
+    }),
+    ("RADAR_0x39c", 5,  {
+      "BYTE5": 0xE0,
+      "BYTE6": 0x79,
+    }),
+    ("RADAR_0x43a", 20, {
+      "BYTE2": 0x07,
+    }),
+  ]
+
+  for addr, freq, values in msg_values:
+    if frame % freq == 0:
+      values["COUNTER"] = frame % 0xF
+      checksum = create_checksum_can_canfd_hybrid(packer, CAN, addr, values)
+      values["CHECKSUM"] = checksum
+      ret.append(packer.make_can_msg(addr, CAN.ECAN, values))
+
+  return ret
+
+
+def create_checksum_can_canfd_hybrid(packer, CAN, addr, values):
+  dat = packer.make_can_msg(addr, CAN.ECAN, values)[2]
+  dat = dat[1:8]
+  checksum = hyundai_checksum(dat)
+
+  return checksum

selfdrive/car/hyundai/interface.py

@@ -3,7 +3,7 @@ from panda import Panda
 from openpilot.selfdrive.car.hyundai.hyundaicanfd import CanBus
 from openpilot.selfdrive.car.hyundai.values import HyundaiFlags, CAR, DBC, CANFD_CAR, CAMERA_SCC_CAR, CANFD_RADAR_SCC_CAR, \
                                          CANFD_UNSUPPORTED_LONGITUDINAL_CAR, EV_CAR, HYBRID_CAR, LEGACY_SAFETY_MODE_CAR, \
-                                         UNSUPPORTED_LONGITUDINAL_CAR, Buttons
+                                         UNSUPPORTED_LONGITUDINAL_CAR, Buttons, CAN_CANFD_HYBRID_CAR
 from openpilot.selfdrive.car.hyundai.radar_interface import RADAR_START_ADDR
 from openpilot.selfdrive.car import create_button_events, get_safety_config
 from openpilot.selfdrive.car.interfaces import CarInterfaceBase
@@ -32,16 +32,18 @@ class CarInterface(CarInterfaceBase):
     hda2 = Ecu.adas in [fw.ecu for fw in car_fw]
     CAN = CanBus(None, hda2, fingerprint)
 
-    if candidate in CANFD_CAR:
+    # detect HDA2 with ADAS Driving ECU
+    if hda2:
+      ret.flags |= HyundaiFlags.CANFD_HDA2.value
+
+    if candidate in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       # detect if car is hybrid
       if 0x105 in fingerprint[CAN.ECAN]:
         ret.flags |= HyundaiFlags.HYBRID.value
       elif candidate in EV_CAR:
         ret.flags |= HyundaiFlags.EV.value
 
-      # detect HDA2 with ADAS Driving ECU
       if hda2:
-        ret.flags |= HyundaiFlags.CANFD_HDA2.value
         if 0x110 in fingerprint[CAN.CAM]:
           ret.flags |= HyundaiFlags.CANFD_HDA2_ALT_STEERING.value
       else:
@@ -78,8 +80,21 @@ class CarInterface(CarInterfaceBase):
     if candidate == CAR.KIA_OPTIMA_G4_FL:
       ret.steerActuatorDelay = 0.2
 
+    if candidate == CAR.HYUNDAI_PALISADE_2023:
+      for fw in car_fw:
+        if fw.ecu == "eps":
+          platform_str = "HYUNDAI_PALISADE_2023_EPS_4LXPC100" if fw.fwVersion.endswith(b'4LXPC100') else \
+            "HYUNDAI_PALISADE_2023_EPS_2427" if fw.fwVersion.endswith(b'2427') else \
+              candidate
+
+          CarInterfaceBase.configure_torque_tune(platform_str, ret.lateralTuning)
+
+          if platform_str == "HYUNDAI_PALISADE_2023_EPS_2427":
+            # We only limit in the controller, panda safety limits apply for both Palisade HDA2 and Telluride HDA2
+            ret.flags |= HyundaiFlags.ALT_LIMITS.value
+
     # *** longitudinal control ***
-    if candidate in CANFD_CAR:
+    if candidate in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       ret.experimentalLongitudinalAvailable = candidate not in (CANFD_UNSUPPORTED_LONGITUDINAL_CAR | CANFD_RADAR_SCC_CAR)
     else:
       ret.experimentalLongitudinalAvailable = candidate not in (UNSUPPORTED_LONGITUDINAL_CAR | CAMERA_SCC_CAR)
@@ -92,23 +107,22 @@ class CarInterface(CarInterfaceBase):
     ret.startAccel = 1.0
     ret.longitudinalActuatorDelay = 0.5
 
+    if ret.flags & HyundaiFlags.CAN_CANFD_HYBRID:
+      ret.stoppingDecelRate = 0.4
+
     # *** feature detection ***
-    if candidate in CANFD_CAR:
+    if candidate in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       ret.enableBsm = 0x1e5 in fingerprint[CAN.ECAN]
     else:
-      ret.enableBsm = 0x58b in fingerprint[0]
+      bus = CAN.ECAN if ret.flags & HyundaiFlags.CAN_CANFD_HYBRID else 0
+      ret.enableBsm = 0x58b in fingerprint[bus]
 
     # *** panda safety config ***
-    if candidate in CANFD_CAR:
+    if candidate in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       cfgs = [get_safety_config(car.CarParams.SafetyModel.hyundaiCanfd), ]
       if CAN.ECAN >= 4:
         cfgs.insert(0, get_safety_config(car.CarParams.SafetyModel.noOutput))
       ret.safetyConfigs = cfgs
-
-      if ret.flags & HyundaiFlags.CANFD_HDA2:
-        ret.safetyConfigs[-1].safetyParam |= Panda.FLAG_HYUNDAI_CANFD_HDA2
-        if ret.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING:
-          ret.safetyConfigs[-1].safetyParam |= Panda.FLAG_HYUNDAI_CANFD_HDA2_ALT_STEERING
       if ret.flags & HyundaiFlags.CANFD_ALT_BUTTONS:
         ret.safetyConfigs[-1].safetyParam |= Panda.FLAG_HYUNDAI_CANFD_ALT_BUTTONS
       if ret.flags & HyundaiFlags.CANFD_CAMERA_SCC:
@@ -118,11 +132,22 @@ class CarInterface(CarInterfaceBase):
         # these cars require a special panda safety mode due to missing counters and checksums in the messages
         ret.safetyConfigs = [get_safety_config(car.CarParams.SafetyModel.hyundaiLegacy)]
       else:
-        ret.safetyConfigs = [get_safety_config(car.CarParams.SafetyModel.hyundai, 0)]
+        cfgs = [get_safety_config(car.CarParams.SafetyModel.hyundai), ]
+        if CAN.ECAN >= 4:
+          cfgs.insert(0, get_safety_config(car.CarParams.SafetyModel.noOutput))
+        ret.safetyConfigs = cfgs
+        if ret.flags & HyundaiFlags.CAN_CANFD_HYBRID:
+          ret.safetyConfigs[-1].safetyParam |= Panda.FLAG_HYUNDAI_CAN_CANFD_HYBRID
 
       if candidate in CAMERA_SCC_CAR:
         ret.safetyConfigs[0].safetyParam |= Panda.FLAG_HYUNDAI_CAMERA_SCC
 
+    # these flags apply to both CANFD_CAR and CAN_CANFD_HYBRID_CAR platforms
+    if ret.flags & HyundaiFlags.CANFD_HDA2:
+      ret.safetyConfigs[-1].safetyParam |= Panda.FLAG_HYUNDAI_CANFD_HDA2
+      if ret.flags & HyundaiFlags.CANFD_HDA2_ALT_STEERING:
+        ret.safetyConfigs[-1].safetyParam |= Panda.FLAG_HYUNDAI_CANFD_HDA2_ALT_STEERING
+
     if ret.openpilotLongitudinalControl:
       ret.safetyConfigs[-1].safetyParam |= Panda.FLAG_HYUNDAI_LONG
     if ret.flags & HyundaiFlags.HYBRID:
@@ -136,6 +161,10 @@ class CarInterface(CarInterfaceBase):
 
     ret.centerToFront = ret.wheelbase * 0.4
 
+    # FIXME: Non-HDA2 2023-24 Hyundai Palisade / Kia Telluride is disabled in this branch;
+    # The non-HDA2 variant is supported in another PR: https://github.com/commaai/openpilot/pull/27478
+    ret.dashcamOnly |= candidate in (CAR.HYUNDAI_PALISADE_2023, ) and not hda2
+
     return ret
 
   @staticmethod

selfdrive/car/hyundai/values.py

@@ -25,7 +25,7 @@ class CarControllerParams:
     self.STEER_THRESHOLD = 150
     self.STEER_STEP = 1  # 100 Hz
 
-    if CP.carFingerprint in CANFD_CAR:
+    if CP.carFingerprint in (CANFD_CAR - CAN_CANFD_HYBRID_CAR):
       self.STEER_MAX = 270
       self.STEER_DRIVER_ALLOWANCE = 250
       self.STEER_DRIVER_MULTIPLIER = 2
@@ -41,14 +41,16 @@ class CarControllerParams:
       self.STEER_MAX = 255
 
     # these cars have significantly more torque than most HKG; limit to 70% of max
-    elif CP.flags & HyundaiFlags.ALT_LIMITS:
+    elif CP.flags & HyundaiFlags.ALT_LIMITS and CP.carFingerprint not in CAN_CANFD_HYBRID_CAR:
       self.STEER_MAX = 270
       self.STEER_DELTA_UP = 2
       self.STEER_DELTA_DOWN = 3
 
     # Default for most HKG
     else:
-      self.STEER_MAX = 384
+      self.STEER_MAX = 330 if CP.flags & HyundaiFlags.ALT_LIMITS else 384
+      self.STEER_DELTA_UP = 2 if CP.flags & HyundaiFlags.ALT_LIMITS else 3
+      self.STEER_DELTA_DOWN = 3 if CP.flags & HyundaiFlags.ALT_LIMITS else 7
 
 
 class HyundaiFlags(IntFlag):
@@ -95,6 +97,9 @@ class HyundaiFlags(IntFlag):
 
   MIN_STEER_32_MPH = 2 ** 23
 
+  # CAN CAN-FD hybrid architecture
+  CAN_CANFD_HYBRID = 2 ** 24
+
 
 class Footnote(Enum):
   CANFD = CarFootnote(
@@ -126,11 +131,14 @@ class HyundaiPlatformConfig(PlatformConfig):
 
 @dataclass
 class HyundaiCanFDPlatformConfig(PlatformConfig):
-  dbc_dict: DbcDict = field(default_factory=lambda: dbc_dict("hyundai_canfd", None))
+  dbc_dict: DbcDict = field(default_factory=lambda: dbc_dict("hyundai_canfd_generated", None))
 
   def init(self):
     self.flags |= HyundaiFlags.CANFD
 
+    if self.flags & HyundaiFlags.CAN_CANFD_HYBRID:
+      self.dbc_dict = dbc_dict('hyundai_palisade_2023_generated', None)
+
 
 class CAR(Platforms):
   # Hyundai
@@ -294,6 +302,14 @@ class CAR(Platforms):
     CarSpecs(mass=1999, wheelbase=2.9, steerRatio=15.6 * 1.15, tireStiffnessFactor=0.63),
     flags=HyundaiFlags.MANDO_RADAR | HyundaiFlags.CHECKSUM_CRC8,
   )
+  HYUNDAI_PALISADE_2023 = HyundaiCanFDPlatformConfig(
+    [
+      HyundaiCarDocs("Hyundai Palisade (with HDA II) 2023-24", "All", car_parts=CarParts.common([CarHarness.hyundai_r])),
+      HyundaiCarDocs("Kia Telluride (with HDA II) 2023-24", "All", car_parts=CarParts.common([CarHarness.hyundai_p])),
+    ],
+    HYUNDAI_PALISADE.specs,
+    flags=HyundaiFlags.CHECKSUM_CRC8 | HyundaiFlags.CAN_CANFD_HYBRID | HyundaiFlags.RADAR_SCC,
+  )
   HYUNDAI_VELOSTER = HyundaiPlatformConfig(
     [HyundaiCarDocs("Hyundai Veloster 2019-20", min_enable_speed=5. * CV.MPH_TO_MS, car_parts=CarParts.common([CarHarness.hyundai_e]))],
     CarSpecs(mass=2917 * CV.LB_TO_KG, wheelbase=2.8, steerRatio=13.75 * 1.15, tireStiffnessFactor=0.5),
@@ -573,7 +589,7 @@ def match_fw_to_car_fuzzy(live_fw_versions, vin, offline_fw_versions) -> set[str
   # Non-electric CAN FD platforms often do not have platform code specifiers needed
   # to distinguish between hybrid and ICE. All EVs so far are either exclusively
   # electric or specify electric in the platform code.
-  fuzzy_platform_blacklist = {str(c) for c in (CANFD_CAR - EV_CAR - CANFD_FUZZY_WHITELIST)}
+  fuzzy_platform_blacklist = {str(c) for c in (CANFD_CAR - CAN_CANFD_HYBRID_CAR - EV_CAR - CANFD_FUZZY_WHITELIST)}
   candidates: set[str] = set()
 
   for candidate, fws in offline_fw_versions.items():
@@ -732,6 +748,7 @@ CAN_GEARS = {
 
 CANFD_CAR = CAR.with_flags(HyundaiFlags.CANFD)
 CANFD_RADAR_SCC_CAR = CAR.with_flags(HyundaiFlags.RADAR_SCC)
+CAN_CANFD_HYBRID_CAR = CAR.with_flags(HyundaiFlags.CAN_CANFD_HYBRID)
 
 # These CAN FD cars do not accept communication control to disable the ADAS ECU,
 # responds with 0x7F2822 - 'conditions not correct'

selfdrive/car/tests/routes.py

@@ -131,6 +131,7 @@ 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("696748e0ac8082fb|2023-08-31--14-25-28", HYUNDAI.HYUNDAI_PALISADE_2023),  # HDA2
   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("3f29334d6134fcd4|2022-03-30--22-00-50", HYUNDAI.HYUNDAI_IONIQ_PHEV_2019),

selfdrive/car/torque_data/override.toml

@@ -68,6 +68,9 @@ legend = ["LAT_ACCEL_FACTOR", "MAX_LAT_ACCEL_MEASURED", "FRICTION"]
 "HYUNDAI_CUSTIN_1ST_GEN" = [2.5, 2.5, 0.1]
 "LEXUS_GS_F" = [2.5, 2.5, 0.08]
 "HYUNDAI_STARIA_4TH_GEN" = [1.8, 2.0, 0.15]
+"HYUNDAI_PALISADE_2023" = [2.32, 2.32, 0.05]
+"HYUNDAI_PALISADE_2023_EPS_4LXPC100" = [2.32, 2.32, 0.1]
+"HYUNDAI_PALISADE_2023_EPS_2427" = [2.5, 2.32, 0.1]
 
 # Dashcam or fallback configured as ideal car
 "MOCK" = [10.0, 10, 0.0]