C3/C3X Aggressive Fan Curve + Toggle

C3 and C3X Cooling Curve. 10 - 16 C cooler than stock curve.

build

@@ -27,10 +27,6 @@ add_panda_targets() {
     panda_h7_remote_can_ignition_only
     panda_hkg_remote_can_ignition_only
     panda_h7_hkg_remote_can_ignition_only
-    panda_tesla_wake
-    panda_h7_tesla_wake
-    panda_tesla_wake_can_ignition_only
-    panda_h7_tesla_wake_can_ignition_only
     panda_jungle_h7
     body_h7
   )

common/params_keys.h

@@ -110,7 +110,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"LocationFilterInitialState", {PERSISTENT, BYTES}},
     {"LongitudinalManeuverMode", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},
     {"LongitudinalPersonality", {PERSISTENT, INT, std::to_string(static_cast<int>(cereal::LongitudinalPersonality::STANDARD))}},
-    {"LongitudinalPersonalityProfiles", {PERSISTENT | DONT_LOG, JSON, "{}", "{}"}},
     {"NetworkMetered", {PERSISTENT, BOOL}},
     {"ObdMultiplexingChanged", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL}},
     {"ObdMultiplexingEnabled", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL}},
@@ -352,7 +351,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"DrivingModelVersion", {PERSISTENT, STRING, "v15", "v15", 1}},
     {"DynamicPathWidth", {PERSISTENT, BOOL, "0", "0", 2, SETTINGS_SIMPLE}},
     {"DynamicPedalsOnUI", {PERSISTENT, BOOL, "1", "0", 1, SETTINGS_SIMPLE}},
-    {"GpuModelReadySound", {PERSISTENT, BOOL, "0", "0", 2, SETTINGS_SIMPLE}},
     {"EngageVolume", {PERSISTENT, INT, "101", "101", 2, SETTINGS_SIMPLE}},
     {"EVTuning", {PERSISTENT, BOOL, "0", "0", 3}},
     {"Fahrenheit", {PERSISTENT, BOOL, "0", "0", 3}},
@@ -363,7 +361,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"IgnoreIgnitionLine", {PERSISTENT, BOOL, "0", "0", 0, SETTINGS_SIMPLE}},
     {"LongPitch", {PERSISTENT, BOOL, "1", "0", 2, SETTINGS_SIMPLE}},
     {"RemoteStartBootsComma", {PERSISTENT, BOOL, "0", "0", 0, SETTINGS_SIMPLE}},
-    {"TeslaWakeOnCAN", {PERSISTENT, BOOL, "0", "0", 0, SETTINGS_SIMPLE}},
     {"RemapCancelToDistance", {PERSISTENT, BOOL, "0", "0", 0, SETTINGS_SIMPLE}},
     {"NAPAdaptiveAccel", {PERSISTENT, BOOL, "1", "1", 0, SETTINGS_SIMPLE}},
     {"NAPFollowDistance", {PERSISTENT, INT, "4", "4"}},
@@ -444,6 +441,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"IncreaseFollowingRain", {PERSISTENT, FLOAT, "0.0", "0.0", 2, SETTINGS_SIMPLE}},
     {"IncreaseFollowingRainStorm", {PERSISTENT, FLOAT, "0.0", "0.0", 2, SETTINGS_SIMPLE}},
     {"IncreaseFollowingSnow", {PERSISTENT, FLOAT, "0.0", "0.0", 2, SETTINGS_SIMPLE}},
+    {"AggressiveCoolingEnabled", {PERSISTENT, BOOL, "0", "0", 2, SETTINGS_SIMPLE}},
     {"IncreaseThermalLimits", {PERSISTENT, BOOL, "0", "0", 2, SETTINGS_SIMPLE}},
     {"IssueReported", {CLEAR_ON_MANAGER_START, JSON, "{}", "{}"}},
     {"KonikDongleId", {PERSISTENT, STRING, "", "", 0}},
@@ -468,7 +466,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"LeadDetectionThreshold", {PERSISTENT, INT, "35", "50", 3}},
     {"LeadIndicator", {PERSISTENT, BOOL, "0", "0", 2, SETTINGS_SIMPLE}},
     {"LeadInfo", {PERSISTENT, BOOL, "0", "0", 3}},
-    {"LeadInfoMode", {PERSISTENT, INT, "2", "2", 3}},
     {"LKASButtonControl", {PERSISTENT, INT, "5", "0", 2, SETTINGS_SIMPLE}},
     {"LockDoors", {PERSISTENT, BOOL, "1", "0", 0}},
     {"LockDoorsTimer", {PERSISTENT, INT, "0", "0", 0}},

common/tests/test_params.py

@@ -5,7 +5,7 @@ import threading
 import time
 import uuid
 
-from openpilot.common.params import Params, ParamKeyFlag, ParamKeyType, UnknownKeyName
+from openpilot.common.params import Params, ParamKeyFlag, UnknownKeyName
 
 class TestParams:
   def setup_method(self):
@@ -128,31 +128,6 @@ class TestParams:
     assert self.params.get("LiveParameters") is None
     assert self.params.get("LiveParameters", return_default=True) is None
 
-  def test_longitudinal_personality_profiles_json_round_trip(self):
-    key = "LongitudinalPersonalityProfiles"
-    value = {
-      "schemaVersion": 1,
-      "enabled": False,
-      "axes": {
-        "acceleration": {
-          "speed": {"unit": "mph", "values": [0.0, 11.184681, 22.369363, 33.554044, 44.738726, 55.923407, 89.477452]},
-          "value": {"unit": "m/s^2", "meaning": "maximum_requested_acceleration"},
-        },
-        "braking": {
-          "speed": {"unit": "mph", "values": [0.0, 11.184681, 22.369363, 33.554044, 44.738726, 55.923407, 89.477452]},
-          "value": {"unit": "m/s^2", "meaning": "cruise_slc_deceleration_magnitude"},
-        },
-        "following": {"speed": {"unit": "mph", "values": [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]}, "value": {"unit": "s", "meaning": "base_time_headway"}},
-      },
-      "profiles": {},
-    }
-    self.params.remove(key)
-
-    assert self.params.get_type(key) == ParamKeyType.JSON
-    assert self.params.get(key) is None
-    self.params.put(key, value)
-    assert self.params.get(key) == value
-
   def test_params_get_type(self):
     # json
     self.params.put("ApiCache_DriveStats", {"a": 0})

opendbc_repo/opendbc/car/gm/carstate.py

@@ -18,7 +18,6 @@ from opendbc.car.gm.values import (
   AccState,
   CanBus,
   CruiseButtons,
-  GM_AUTO_HOLD_CARS,
   GMFlags,
   SDGM_CAR,
   STEER_THRESHOLD,
@@ -69,18 +68,6 @@ def update_auto_hold_drive_timers(in_drive_for_hold: bool, moving_for_hold: bool
   return auto_hold_drive_time, one_pedal_drive_time
 
 
-def is_gm_auto_hold_active(car_fingerprint: str, auto_hold_engaged: bool, in_drive_for_hold: bool,
-                           cruise_available: bool, standstill: bool, gas_pressed: bool) -> bool:
-  return (
-    auto_hold_engaged and
-    car_fingerprint in GM_AUTO_HOLD_CARS and
-    in_drive_for_hold and
-    cruise_available and
-    standstill and
-    not gas_pressed
-  )
-
-
 def update_startup_acc_fault_suppression(car_fingerprint: str, system_power_mode: int,
                                           previous_system_power_mode: int, timer: float,
                                           acc_state: int, friction_brake_unavailable: bool) -> tuple[float, bool]:
@@ -444,11 +431,6 @@ class CarState(CarStateBase):
       self.auto_hold_fault_suppression_timer = max(self.auto_hold_fault_suppression_timer - DT_CTRL, 0.0)
       ret.accFaulted = False
 
-    ret.brakeHoldActive = is_gm_auto_hold_active(
-      self.CP.carFingerprint, self.auto_hold_engaged, in_drive_for_hold,
-      ret.cruiseState.available, ret.standstill, ret.gasPressed,
-    )
-
     if self.CP.enableBsm and not sdgm_non_volt:
       ret.leftBlindspot = pt_cp.vl["BCMBlindSpotMonitor"]["LeftBSM"] == 1
       ret.rightBlindspot = pt_cp.vl["BCMBlindSpotMonitor"]["RightBSM"] == 1

opendbc_repo/opendbc/car/gm/tests/test_gm.py

@@ -11,7 +11,6 @@ from opendbc.car.gm import gmcan
 from opendbc.car.gm.carstate import (
   CarState as GMCarState,
   get_hard_cruise_buttons,
-  is_gm_auto_hold_active,
   update_auto_hold_drive_timers,
   update_startup_acc_fault_suppression,
 )
@@ -211,19 +210,6 @@ class TestBoltGps:
 
 
 class TestGMCarState:
-  @parameterized.expand([
-    (CAR.BUICK_LACROSSE, True, True, True, True, False, True),
-    (CAR.CHEVROLET_VOLT, True, True, True, True, False, True),
-    (CAR.CHEVROLET_BOLT_CC_2017, True, True, True, True, False, False),
-    (CAR.BUICK_LACROSSE, True, True, True, False, False, False),
-    (CAR.BUICK_LACROSSE, True, True, True, True, True, False),
-  ])
-  def test_auto_hold_alert_state_requires_supported_complete_stop(self, car_fingerprint, engaged, in_drive,
-                                                                    cruise_available, standstill, gas_pressed, expected):
-    assert is_gm_auto_hold_active(
-      car_fingerprint, engaged, in_drive, cruise_available, standstill, gas_pressed,
-    ) is expected
-
   def test_lacrosse_startup_acc_fault_is_suppressed(self):
     timer, suppressed = update_startup_acc_fault_suppression(
       CAR.BUICK_LACROSSE, 2, 0, 0.0, 3, False,

opendbc_repo/opendbc/car/honda/carcontroller.py

@@ -23,20 +23,6 @@ from openpilot.common.params import Params
 VisualAlert = structs.CarControl.HUDControl.VisualAlert
 LongCtrlState = structs.CarControl.Actuators.LongControlState
 
-BOSCH_BRAKE_FORCE_ON = -0.12
-BOSCH_BRAKE_FORCE_RELEASE = -0.02
-
-
-def update_honda_bosch_braking(braking: bool, gas_pedal_force: float, stopping: bool, long_active: bool) -> bool:
-  """Select Bosch brake mode from the same road-load-adjusted force used for gas."""
-  if not long_active:
-    return False
-  if stopping:
-    return True
-  if braking:
-    return gas_pedal_force <= BOSCH_BRAKE_FORCE_RELEASE
-  return gas_pedal_force < BOSCH_BRAKE_FORCE_ON
-
 
 def get_civic_bosch_modified_torque_lpf_tau(torque_cmd: float, prev_torque_cmd: float, v_ego: float) -> float:
   torque_delta = abs(float(torque_cmd) - float(prev_torque_cmd))
@@ -252,7 +238,6 @@ class CarController(CarControllerBase):
     self.steering_pressed_filter_s = 0.0
     self.steering_pressed_robust_prev = False
     self.bosch_last_gas = 0.0
-    self.bosch_braking = False
     self.bosch_gas_factor = self.param_store.get_float("HondaGasFactorParams", default=1.0)
     self.bosch_wind_factor = self.param_store.get_float("HondaWindFactorParams", default=1.0)
     self.bosch_wind_factor_before_brake = self.bosch_wind_factor
@@ -487,16 +472,12 @@ class CarController(CarControllerBase):
           self.bosch_last_gas = self.gas
 
           stopping = actuators.longControlState == LongCtrlState.stopping
-          bosch_braking = None
-          if not self.mvl_accord_mode:
-            self.bosch_braking = update_honda_bosch_braking(self.bosch_braking, gas_pedal_force, stopping, CC.longActive)
-            bosch_braking = self.bosch_braking
           self.stopping_counter = self.stopping_counter + 1 if stopping else 0
           if not self.mvl_accord_mode or mvl_radar_owned:
             can_sends.extend(
               hondacan.create_acc_commands(
                 self.packer, self.CAN, CC.enabled, CC.longActive, self.accel, self.gas, self.stopping_counter, self.CP,
-                gas_force=gas_pedal_force, braking=bosch_braking,
+                gas_force=gas_pedal_force if self.mvl_accord_mode else None,
               )
             )
         else:

opendbc_repo/opendbc/car/honda/hondacan.py

@@ -71,18 +71,16 @@ def create_brake_command(packer, CAN, apply_brake, pump_on, pcm_override, pcm_ca
   return packer.make_can_msg("BRAKE_COMMAND", CAN.pt, values)
 
 
-def create_acc_commands(packer, CAN, enabled, active, accel, gas, stopping_counter, CP, gas_force=None, braking=None):
+def create_acc_commands(packer, CAN, enabled, active, accel, gas, stopping_counter, CP, gas_force=None):
   commands = []
   min_gas_accel = CarControllerParams.BOSCH_GAS_LOOKUP_BP[0]
 
   control_on = 5 if enabled else 0
   if gas_force is None:
     gas_force = accel
-  if braking is None:
-    braking = gas_force < min_gas_accel
-  braking = int(active and braking)
-  gas_command = gas if active and gas_force > min_gas_accel and not braking else -30000
+  gas_command = gas if active and gas_force > min_gas_accel else -30000
   accel_command = accel if active else 0
+  braking = 1 if active and gas_force < min_gas_accel else 0
   standstill = 1 if active and stopping_counter > 0 else 0
   standstill_release = 1 if active and stopping_counter == 0 else 0
 

opendbc_repo/opendbc/car/honda/tests/test_honda.py

@@ -7,16 +7,13 @@ from opendbc.car.structs import CarParams
 from opendbc.car import gen_empty_fingerprint
 from opendbc.car.honda.interface import CarInterface
 from opendbc.car.honda.carcontroller import (
-  BOSCH_BRAKE_FORCE_ON,
-  BOSCH_BRAKE_FORCE_RELEASE,
   CarController,
   get_civic_bosch_modified_steering_pressed,
   get_civic_bosch_modified_torque_lpf_tau,
   get_honda_bosch_wind_brake_mps2,
-  update_honda_bosch_braking,
   update_honda_bosch_live_learning,
 )
-from opendbc.car.honda.hondacan import create_acc_commands, create_lkas_hud
+from opendbc.car.honda.hondacan import create_lkas_hud
 from opendbc.car.honda.fingerprints import FW_VERSIONS
 from opendbc.car.honda.values import CAR, DBC, HONDA_BOSCH, HONDA_BOSCH_TJA_CONTROL, CarControllerParams, HondaFlags, HondaSafetyFlags, \
                                      HondaStarPilotFlags
@@ -29,67 +26,6 @@ def get_test_toggles() -> SimpleNamespace:
 
 
 class TestHondaFingerprint:
-  @staticmethod
-  def _acc_control_values(active, accel, gas=500, gas_force=0.5, braking=False):
-    class FakePacker:
-      @staticmethod
-      def make_can_msg(name, bus, values):
-        return name, bus, values
-
-    can = SimpleNamespace(pt=1)
-    cp = SimpleNamespace(carFingerprint=CAR.HONDA_CRV_5G)
-    commands = create_acc_commands(FakePacker(), can, True, active, accel, gas, 0, cp, gas_force, braking)
-    assert commands[-1][0] == "ACC_CONTROL"
-    return commands[-1][2]
-
-  def test_bosch_acc_commands_reject_fault_route_gas_brake_conflict(self):
-    braking = update_honda_bosch_braking(False, 0.2, False, True)
-    values = self._acc_control_values(True, -0.27, gas=160, gas_force=0.2, braking=braking)
-
-    assert values["GAS_COMMAND"] == 160
-    assert values["ACCEL_COMMAND"] == pytest.approx(-0.27)
-    assert values["BRAKE_REQUEST"] == 0
-    assert values["BRAKE_LIGHTS"] == 0
-
-  @pytest.mark.parametrize("active", [False, True])
-  @pytest.mark.parametrize("accel", [-3.5, -0.27, -0.2, -0.1, 0.0, 0.01, 2.0])
-  @pytest.mark.parametrize("gas_force", [-0.5, 0.0, 0.5])
-  @pytest.mark.parametrize("braking", [False, True])
-  def test_bosch_acc_commands_never_request_gas_and_braking_together(self, active, accel, gas_force, braking):
-    values = self._acc_control_values(active, accel, gas_force=gas_force, braking=braking)
-
-    assert not (values["GAS_COMMAND"] > 0 and values["BRAKE_REQUEST"] == 1)
-    assert not (values["GAS_COMMAND"] > 0 and values["BRAKE_LIGHTS"] == 1)
-    if values["GAS_COMMAND"] > 0:
-      assert active
-
-  def test_bosch_acc_commands_preserve_road_load_gas_above_brake_threshold(self):
-    values = self._acc_control_values(True, -0.27, gas=500, gas_force=0.3)
-
-    assert values["GAS_COMMAND"] == 500
-    assert values["ACCEL_COMMAND"] == pytest.approx(-0.27)
-    assert values["BRAKE_REQUEST"] == 0
-    assert values["BRAKE_LIGHTS"] == 0
-
-  def test_bosch_acc_commands_do_not_send_gas_without_positive_force(self):
-    values = self._acc_control_values(True, 0.2, gas=500, gas_force=-0.4)
-
-    assert values["GAS_COMMAND"] == -30000
-
-  def test_bosch_braking_uses_force_hysteresis(self):
-    braking = update_honda_bosch_braking(False, BOSCH_BRAKE_FORCE_ON - 0.01, False, True)
-    assert braking
-
-    braking = update_honda_bosch_braking(braking, -0.05, False, True)
-    assert braking
-
-    braking = update_honda_bosch_braking(braking, BOSCH_BRAKE_FORCE_RELEASE + 0.01, False, True)
-    assert not braking
-
-  def test_bosch_braking_preserves_stopping_and_resets_inactive(self):
-    assert update_honda_bosch_braking(False, 0.5, True, True)
-    assert not update_honda_bosch_braking(True, -1.0, False, False)
-
   def test_honda_lkas_hud_shows_lane_lines_when_lateral_only_is_active(self):
     class FakePacker:
       @staticmethod

opendbc_repo/opendbc/car/hyundai/carcontroller.py

@@ -16,7 +16,6 @@ from opendbc.car.hyundai.values import HyundaiFlags, HyundaiSafetyFlags, Hyundai
 from opendbc.car.interfaces import CarControllerBase
 from opendbc.car.vehicle_model import VehicleModel
 from openpilot.common.params import Params
-from openpilot.selfdrive.controls.lib.longitudinal_vehicle_tunes import get_hyundai_canfd_scc_jerk_limits
 from openpilot.starpilot.common.testing_grounds import testing_ground
 
 VisualAlert = structs.CarControl.HUDControl.VisualAlert
@@ -860,13 +859,14 @@ class CarController(CarControllerBase):
     can_sends = []
 
     lka_steering = self.CP.flags & HyundaiFlags.CANFD_LKA_STEERING
-    persistent_lfa_status_cars = (
+    longitudinal_active = bool(self.long_active_ecu and getattr(CC, "longActive", False))
+    lfa_status_cars = (
       CAR.HYUNDAI_IONIQ_6,
       CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN,
       CAR.KIA_EV6,
     )
     lfa_longitudinal_active = self.CP.openpilotLongitudinalControl \
-      if self.CP.carFingerprint in persistent_lfa_status_cars else self.long_active_ecu
+      if self.CP.carFingerprint in lfa_status_cars else longitudinal_active
     lka_steering_long = lka_steering and lfa_longitudinal_active
     ccnc_non_hda2 = self.CP.flags & HyundaiFlags.CCNC and not lka_steering
     use_egmp_dynamic_long_tuning = egmp_dynamic_longitudinal_tuning(self.CP) and self.long_active_ecu and \
@@ -893,7 +893,7 @@ class CarController(CarControllerBase):
 
     gear = getattr(getattr(CS, "out", None), "gearShifter", None)
     drive_gear = gear == structs.CarState.GearShifter.drive
-    if angle_lkas_alt and self.CP.carFingerprint != CAR.KIA_SPORTAGE_HEV_2026:
+    if angle_lkas_alt:
       steering_msg_active = bool(steering_msg_active and drive_gear)
     angle_lkas_alt_standstill_handoff = bool(getattr(CS.out, "standstill", False) and not CC.latActive)
     forward_stock_lkas = self.CP.carFingerprint in CANFD_ANGLE_LONGITUDINAL_CAR and angle_lkas_alt and (
@@ -923,7 +923,7 @@ class CarController(CarControllerBase):
 
     # prevent LFA from activating on LKA steering cars by sending "no lane lines detected" to ADAS ECU
     suppress_lfa = bool(lka_steering)
-    if angle_lkas_alt and self.CP.carFingerprint != CAR.KIA_SPORTAGE_HEV_2026:
+    if angle_lkas_alt:
       suppress_lfa = bool(lka_steering and drive_gear and (CC.latActive or (ccnc_angle_long and CC.enabled)))
     if self.frame % 5 == 0 and suppress_lfa:
       can_sends.append(hyundaicanfd.create_suppress_lfa(self.packer, self.CAN, CS.lfa_block_msg,
@@ -1023,11 +1023,7 @@ class CarController(CarControllerBase):
                                                                                  CC.rightBlinker))
       if self.frame % 2 == 0:
         if self.CP.carFingerprint == CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN:
-          scc_jerk_limits = get_hyundai_canfd_scc_jerk_limits(self.CP)
-          acc_kwargs = {
-            "jerk_upper": scc_jerk_limits[0],
-            "jerk_lower": scc_jerk_limits[1],
-          }
+          acc_kwargs = {}
         else:
           lead_visible, lead_distance, lead_rel_speed = self._get_canfd_scc_lead_state(CC, CS, now_nanos)
           acc_kwargs = {

opendbc_repo/opendbc/car/hyundai/fingerprints.py

@@ -185,7 +185,6 @@ FW_VERSIONS = {
     ],
     (Ecu.abs, 0x7d1, None): [
       b'\xf1\x00DN ESC \x01 102\x19\x04\x13 58910-L1300',
-      b'\xf1\x00DN ESC \x01 107 \x07\x03 58910-L1300',
       b'\xf1\x00DN ESC \x03 100 \x08\x01 58910-L0300',
       b'\xf1\x00DN ESC \x06 104\x19\x08\x01 58910-L0100',
       b'\xf1\x00DN ESC \x06 106 \x07\x01 58910-L0100',
@@ -209,7 +208,6 @@ FW_VERSIONS = {
       b'\xf1\x00DN8 MDPS C 1.00 1.01 56310L0210\x00 4DNAC102',
       b'\xf1\x00DN8 MDPS C 1.00 1.03 56310-L1010 4DNDC103',
       b'\xf1\x00DN8 MDPS C 1.00 1.03 56310-L1030 4DNDC103',
-      b'\xf1\x00DN8 MDPS C 1.00 1.03 56310-L1210 4DNDC103',
       b'\xf1\x00DN8 MDPS R 1.00 1.00 57700-L0000 4DNAP100',
       b'\xf1\x00DN8 MDPS R 1.00 1.00 57700-L0000 4DNAP101',
       b'\xf1\x00DN8 MDPS R 1.00 1.02 57700-L1000 4DNDP105',
@@ -217,7 +215,6 @@ FW_VERSIONS = {
     (Ecu.fwdCamera, 0x7c4, None): [
       b'\xf1\x00DN8 MFC  AT KOR LHD 1.00 1.02 99211-L1000 190422',
       b'\xf1\x00DN8 MFC  AT KOR LHD 1.00 1.04 99211-L1000 191016',
-      b'\xf1\x00DN8 MFC  AT KOR LHD 1.00 1.06 99211-L1000 210325',
       b'\xf1\x00DN8 MFC  AT RUS LHD 1.00 1.03 99211-L1000 190705',
       b'\xf1\x00DN8 MFC  AT USA LHD 1.00 1.00 99211-L0000 190716',
       b'\xf1\x00DN8 MFC  AT USA LHD 1.00 1.01 99211-L0000 191016',

opendbc_repo/opendbc/car/hyundai/hyundaicanfd.py

@@ -142,21 +142,7 @@ def create_steering_messages(packer, CP, CAN, enabled, lat_active, apply_torque,
     lkas_values["LKAS_ANGLE_ACTIVE"] = 2 if lat_active else 1
     lkas_values["ADAS_ACIAnglTqRedcGainVal"] = apply_torque if lat_active else 0.0
     if angle_lkas_alt:
-      if CP.carFingerprint == CAR.KIA_SPORTAGE_HEV_2026:
-        lkas_values = {
-          "LKA_OptUsmSta": 0,
-          "LKA_SysIndReq": 2 if enabled else 1,
-          "StrTqReqVal": 0,
-          "LKA_SysWrn": 0,
-          "ActToiSta": 0,
-          "LKA_UsmMod": 0,
-          "LKA_RcgSta": 3 if lat_active else 0,
-          "Damping_Gain": 100,
-          "ADAS_StrAnglReqVal": apply_angle,
-          "LKAS_ANGLE_ACTIVE": 2 if lat_active else 1,
-          "ADAS_ACIAnglTqRedcGainVal": apply_torque if lat_active else 0.0,
-        }
-      elif lat_active:
+      if lat_active:
         lkas_values = {
           "LKA_OptUsmSta": 0,
           "LKA_RcgSta": 3,

opendbc_repo/opendbc/car/hyundai/interface.py

@@ -7,6 +7,7 @@ from opendbc.car.hyundai.values import HyundaiFlags, CAR, CarControllerParams, \
                                                    CANFD_UNSUPPORTED_LONGITUDINAL_CAR, \
                                                    CANFD_SECURITYACCESS_CAR, \
                                                    CANFD_ANGLE_LONGITUDINAL_CAR, \
+                                                   CANFD_RADAR_LIVE_LONGITUDINAL_CAR, \
                                                    CANFD_RADAR_ECU_KEEPALIVE_CAR, \
                                                    RADAR_LIVE_LONGITUDINAL_CAR, \
                                                    UNSUPPORTED_LONGITUDINAL_CAR, HyundaiSafetyFlags, \

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

@@ -130,22 +130,13 @@ def get_test_toggles() -> SimpleNamespace:
 
 
 class TestHyundaiFingerprint:
-  def test_egmp_communication_control_paths(self):
+  def test_ev6_uses_stock_hda2_communication_control_path(self):
     stock_request = bytes([0x28, 0x83, 0x01])
     radar_keepalive_request = bytes([0x28, 0x01, 0x01])
 
     assert CAR.KIA_EV6 in CANFD_RADAR_LIVE_LONGITUDINAL_CAR
     assert CAR.KIA_EV6 not in CANFD_RADAR_ECU_KEEPALIVE_CAR
     assert get_communication_control_request(CAR.KIA_EV6) == stock_request
-
-    assert CAR.HYUNDAI_IONIQ_5 in CANFD_RADAR_LIVE_LONGITUDINAL_CAR
-    assert CAR.HYUNDAI_IONIQ_5 not in CANFD_RADAR_ECU_KEEPALIVE_CAR
-    assert get_communication_control_request(CAR.HYUNDAI_IONIQ_5) == stock_request
-
-    assert CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN in CANFD_RADAR_LIVE_LONGITUDINAL_CAR
-    assert CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN not in CANFD_RADAR_ECU_KEEPALIVE_CAR
-    assert get_communication_control_request(CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN) == stock_request
-
     assert get_communication_control_request(CAR.HYUNDAI_IONIQ_6) == radar_keepalive_request
 
   def test_carnival_hev_low_speed_torque_rate_limits(self):
@@ -2564,7 +2555,6 @@ class TestHyundaiFingerprint:
       "DAMP_FACTOR": 100,
     }
     cc = SimpleNamespace(enabled=True, latActive=True,
-                         longActive=False,
                          actuators=SimpleNamespace(longControlState=LongCtrlState.off),
                          leftBlinker=False, rightBlinker=False,
                          hudControl=SimpleNamespace())
@@ -2608,52 +2598,14 @@ class TestHyundaiFingerprint:
                       if controller.packer.dbc.addr_to_msg[addr].name in ("LFA", "LKAS")]
     assert steering_names == [("LFA", can_bus.ECAN), ("LKAS", can_bus.ACAN)]
 
-  @pytest.mark.parametrize(("car", "powertrain_flag"), [
-    (CAR.HYUNDAI_IONIQ_5, HyundaiFlags.EV),
-    (CAR.HYUNDAI_IONIQ_6, HyundaiFlags.EV),
-    (CAR.KIA_EV6, HyundaiFlags.EV),
-    (CAR.KIA_CARNIVAL_2025, 0),
-    (CAR.KIA_CARNIVAL_HEV_4TH_GEN, HyundaiFlags.HYBRID),
-    (CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN, HyundaiFlags.EV),
-  ])
-  def test_hda2_keeps_lfa_status_when_longitudinal_is_inactive(self, car, powertrain_flag):
-    CP = CarParams.new_message()
-    CP.carFingerprint = car
-    CP.flags = int(HyundaiFlags.CANFD | HyundaiFlags.CANFD_LKA_STEERING | powertrain_flag)
-    CP.openpilotLongitudinalControl = True
-
-    controller = CarController(DBC[CP.carFingerprint], CP)
-    cc = SimpleNamespace(
-      enabled=False, latActive=False, longActive=False,
-      actuators=SimpleNamespace(longControlState=LongCtrlState.off),
-      leftBlinker=False, rightBlinker=False, hudControl=SimpleNamespace(),
-    )
-    cs = SimpleNamespace(
-      stock_lfa_msg=None, stock_lkas_msg=None,
-      left_blindspot_from_radar=False, right_blindspot_from_radar=False,
-      out=SimpleNamespace(gearShifter=structs.CarState.GearShifter.park),
-    )
-
-    controller.frame = 1
-    controller.long_active_ecu = True
-    msgs = controller.create_canfd_msgs(0, False, 0.0, 0.0, 0.0, 0.0, False,
-                                        cc.hudControl, cs, cc, get_test_toggles(), lka_icon=1, lfa_icon=1)
-    assert any(addr == 0x12A for addr, _, _ in msgs)
-
-  @pytest.mark.parametrize("car", [
-    CAR.HYUNDAI_IONIQ_6,
-    CAR.KIA_EV6,
-    CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN,
-  ])
-  def test_egmp_persistent_lfa_status_survives_ecu_fallback_state(self, car):
+  @pytest.mark.parametrize("car", [CAR.HYUNDAI_IONIQ_6, CAR.KIA_EV6])
+  def test_egmp_keeps_lfa_status_when_longitudinal_is_inactive(self, car):
     CP = CarParams.new_message()
     CP.carFingerprint = car
     CP.flags = int(HyundaiFlags.CANFD | HyundaiFlags.EV | HyundaiFlags.CANFD_LKA_STEERING)
     CP.openpilotLongitudinalControl = True
 
     controller = CarController(DBC[CP.carFingerprint], CP)
-    controller.frame = 1
-    controller.long_active_ecu = False
     cc = SimpleNamespace(
       enabled=False, latActive=False, longActive=False,
       actuators=SimpleNamespace(longControlState=LongCtrlState.off),
@@ -2665,9 +2617,11 @@ class TestHyundaiFingerprint:
       out=SimpleNamespace(gearShifter=structs.CarState.GearShifter.park),
     )
 
-    msgs = controller.create_canfd_msgs(0, False, 0.0, 0.0, 0.0, 0.0, False,
-                                        cc.hudControl, cs, cc, get_test_toggles(), lka_icon=1, lfa_icon=1)
-    assert any(addr == 0x12A for addr, _, _ in msgs)
+    controller.frame = 1
+    for controller.long_active_ecu in (False, True):
+      msgs = controller.create_canfd_msgs(0, False, 0.0, 0.0, 0.0, 0.0, False,
+                                          cc.hudControl, cs, cc, get_test_toggles(), lka_icon=1, lfa_icon=1)
+      assert any(addr == 0x12A for addr, _, _ in msgs)
 
   def test_gv70_electrified_longitudinal_uses_hda2_scc_contract(self):
     CP = CarParams.new_message()
@@ -2801,7 +2755,7 @@ class TestHyundaiFingerprint:
     assert len([msg for msg in msgs if msg[0] == 0x110]) == expected_lkas_msgs
 
   @pytest.mark.parametrize("standstill", [False, True])
-  def test_sportage_angle_lkas_alt_keeps_status_and_suppression_alive(self, standstill):
+  def test_sportage_angle_lkas_alt_publishes_inactive_status(self, standstill):
     CP = CarParams.new_message()
     CP.carFingerprint = CAR.KIA_SPORTAGE_HEV_2026
     CP.flags = int(HyundaiFlags.CANFD | HyundaiFlags.HYBRID | HyundaiFlags.CANFD_ANGLE_STEERING |
@@ -2809,14 +2763,11 @@ class TestHyundaiFingerprint:
     CP.openpilotLongitudinalControl = False
 
     controller = CarController(DBC[CP.carFingerprint], CP)
-    controller.frame = 5
     can_bus = CanBus(CP)
     cc = SimpleNamespace(enabled=False, latActive=False,
                          actuators=SimpleNamespace(longControlState=LongCtrlState.off),
                          leftBlinker=False, rightBlinker=False, hudControl=SimpleNamespace())
-    lfa_block_msg = {f"BYTE{i}": 0 for i in range(3, 32) if i != 7}
-    lfa_block_msg["COUNTER"] = 0
-    cs = SimpleNamespace(stock_lfa_msg=None, stock_lkas_msg={}, lfa_block_msg=lfa_block_msg,
+    cs = SimpleNamespace(stock_lfa_msg=None, stock_lkas_msg={},
                          out=SimpleNamespace(standstill=standstill, steeringAngleDeg=0.0,
                                              gearShifter=structs.CarState.GearShifter.drive))
 
@@ -2824,52 +2775,14 @@ class TestHyundaiFingerprint:
                                         get_test_toggles(), lka_icon=1, lfa_icon=1)
     lkas_msgs = [msg for msg in msgs if msg[0] == 0x110]
     assert len(lkas_msgs) == 1
-    assert len([msg for msg in msgs if msg[0] == 0x362]) == 1
 
     parser = CANParser(DBC[CP.carFingerprint][Bus.pt], [("LKAS_ALT", 0)], can_bus.ACAN)
     parser.update([(1, lkas_msgs)])
     assert parser.can_valid
-    assert parser.vl["LKAS_ALT"]["LKA_OptUsmSta"] == 0
+    assert parser.vl["LKAS_ALT"]["LKA_ICON"] == 1
     assert parser.vl["LKAS_ALT"]["LKA_SysIndReq"] == 1
     assert parser.vl["LKAS_ALT"]["LKA_RcgSta"] == 0
-    assert parser.vl["LKAS_ALT"]["Damping_Gain"] == 100
     assert parser.vl["LKAS_ALT"]["LKAS_ANGLE_ACTIVE"] == 1
-    assert parser.vl["LKAS_ALT"]["ADAS_ACIAnglTqRedcGainVal"] == 0.0
-
-  def test_sportage_angle_lkas_alt_active_status_matches_vehicle_contract(self):
-    CP = CarParams.new_message()
-    CP.carFingerprint = CAR.KIA_SPORTAGE_HEV_2026
-    CP.flags = int(HyundaiFlags.CANFD | HyundaiFlags.HYBRID | HyundaiFlags.CANFD_ANGLE_STEERING |
-                   HyundaiFlags.CANFD_LKA_STEERING | HyundaiFlags.CANFD_LKA_STEERING_ALT)
-    CP.openpilotLongitudinalControl = False
-
-    controller = CarController(DBC[CP.carFingerprint], CP)
-    controller.frame = 5
-    can_bus = CanBus(CP)
-    cc = SimpleNamespace(enabled=True, latActive=True,
-                         actuators=SimpleNamespace(longControlState=LongCtrlState.off),
-                         leftBlinker=False, rightBlinker=False, hudControl=SimpleNamespace())
-    lfa_block_msg = {f"BYTE{i}": 0 for i in range(3, 32) if i != 7}
-    lfa_block_msg["COUNTER"] = 0
-    cs = SimpleNamespace(stock_lfa_msg=None, stock_lkas_msg={}, lfa_block_msg=lfa_block_msg,
-                         out=SimpleNamespace(standstill=False, steeringAngleDeg=10.0,
-                                             gearShifter=structs.CarState.GearShifter.drive))
-
-    msgs = controller.create_canfd_msgs(0, True, 0.4, 12.0, 0.0, 0.0, False, cc.hudControl, cs, cc,
-                                        get_test_toggles(), lka_icon=2, lfa_icon=2)
-    lkas_msgs = [msg for msg in msgs if msg[0] == 0x110]
-    assert len(lkas_msgs) == 1
-    assert len([msg for msg in msgs if msg[0] == 0x362]) == 1
-
-    parser = CANParser(DBC[CP.carFingerprint][Bus.pt], [("LKAS_ALT", 0)], can_bus.ACAN)
-    parser.update([(1, lkas_msgs)])
-    assert parser.can_valid
-    assert parser.vl["LKAS_ALT"]["LKA_OptUsmSta"] == 0
-    assert parser.vl["LKAS_ALT"]["LKA_SysIndReq"] == 2
-    assert parser.vl["LKAS_ALT"]["LKA_RcgSta"] == 3
-    assert parser.vl["LKAS_ALT"]["Damping_Gain"] == 100
-    assert parser.vl["LKAS_ALT"]["LKAS_ANGLE_ACTIVE"] == 2
-    assert parser.vl["LKAS_ALT"]["ADAS_ACIAnglTqRedcGainVal"] == pytest.approx(0.4)
 
   def test_ev9_inactive_angle_steering_does_not_suppress_stock_lfa(self):
     CP = CarParams.new_message()

opendbc_repo/opendbc/car/hyundai/values.py

@@ -1220,12 +1220,7 @@ CANFD_RADAR_LIVE_LONGITUDINAL_CAR = {
   CAR.HYUNDAI_IONIQ_5, CAR.HYUNDAI_IONIQ_5_PE, CAR.HYUNDAI_IONIQ_6, CAR.KIA_EV6, CAR.KIA_EV9, CAR.GENESIS_GV60_EV_1ST_GEN,
   CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN,
 }
-CANFD_RADAR_ECU_KEEPALIVE_CAR = {
-  CAR.HYUNDAI_IONIQ_5_PE,
-  CAR.HYUNDAI_IONIQ_6,
-  CAR.KIA_EV9,
-  CAR.GENESIS_GV60_EV_1ST_GEN,
-}
+CANFD_RADAR_ECU_KEEPALIVE_CAR = CANFD_RADAR_LIVE_LONGITUDINAL_CAR - {CAR.KIA_EV6}
 RADAR_LIVE_LONGITUDINAL_CAR = CANFD_RADAR_LIVE_LONGITUDINAL_CAR | {
   CAR.HYUNDAI_IONIQ,
   CAR.HYUNDAI_KONA_EV_2022,

opendbc_repo/opendbc/car/interfaces.py

@@ -109,7 +109,6 @@ class RadarInterfaceBase(ABC):
     self.CP = CP
     self.rcp = None
     self.pts: dict[int, structs.RadarData.RadarPoint] = {}
-    self.track_id: int = 0
     self.frame = 0
 
   def update(self, can_packets: list[tuple[int, list[CanData]]]) -> structs.RadarDataT | None:

opendbc_repo/opendbc/car/subaru/carcontroller.py

@@ -16,11 +16,21 @@ _SNG_ACC_MIN_DIST = 3
 _SNG_ACC_MAX_DIST = 4.5
 _LEGACY_2025_MADS_MIN_SPEED = 0.44704
 _LEGACY_2025_MADS_MAX_STEER_ANGLE = 120.0
+_LEGACY_2025_OVERRIDE_HOLD_FRAMES = 10
+_LEGACY_2025_REENGAGE_SETTLE_FRAMES = 8
+_LEGACY_2025_REENGAGE_MAX_STEER_RATE = 2.0
+_LEGACY_2025_REENGAGE_MAX_ANGLE_DELTA = 1.0
+_LEGACY_2025_RECLAIM_FRAMES = 36
+_LEGACY_2025_RECLAIM_EXPONENT = 2.5
 _ANGLE_OVERRIDE_CONFIRM_FRAMES = 2
+_ANGLE_OVERRIDE_HOLD_FRAMES = 10
+_ANGLE_REENGAGE_SETTLE_FRAMES = 8
 _ANGLE_REENGAGE_MAX_STEER_RATE = 2.0
+_ANGLE_REENGAGE_MAX_ANGLE_DELTA = 1.0
+_ANGLE_RECLAIM_FRAMES = 36
+_ANGLE_RECLAIM_EXPONENT = 2.5
 _ANGLE_MADS_MIN_SPEED = 0.44704
 _ANGLE_MADS_MAX_STEER_ANGLE = 120.0
-_ASCENT_AOL_ARM_FRAMES = 30
 _STOP_START_STARTUP_DELAY_FRAMES = 100
 # StarPilot's first populated toggle message can arrive several seconds after
 # the car controller starts while fingerprinting and settings settle.
@@ -43,9 +53,20 @@ class CarController(CarControllerBase):
     self.apply_steer_last = 0
     self.driver_override = False
     self.angle_override_confirm_frames = 0
+    self.legacy_2025_lkas_active = False
+    self.legacy_2025_handoff_active = False
+    self.legacy_2025_override_hold_frames = 0
+    self.legacy_2025_reengage_settle_frames = 0
+    self.legacy_2025_reengage_reference_angle = 0.0
+    self.legacy_2025_reclaim_frames = 0
+    self.legacy_2025_reclaim_start_angle = 0.0
     self.angle_lkas_active = False
     self.angle_handoff_active = False
-    self.ascent_aol_arm_frames = 0
+    self.angle_override_hold_frames = 0
+    self.angle_reengage_settle_frames = 0
+    self.angle_reengage_reference_angle = 0.0
+    self.angle_reclaim_frames = 0
+    self.angle_reclaim_start_angle = 0.0
 
     self.cruise_button_prev = 0
     self.steer_rate_counter = 0
@@ -125,36 +146,126 @@ class CarController(CarControllerBase):
     self.stop_start_counter = (self.stop_start_counter + 1) % 0x10
     return msg
 
+  def _reset_legacy_2025_handoff(self):
+    self.driver_override = False
+    self.angle_override_confirm_frames = 0
+    self.legacy_2025_handoff_active = False
+    self.legacy_2025_override_hold_frames = 0
+    self.legacy_2025_reengage_settle_frames = 0
+    self.legacy_2025_reengage_reference_angle = 0.0
+    self.legacy_2025_reclaim_frames = 0
+    self.legacy_2025_reclaim_start_angle = 0.0
+
+  def _legacy_2025_manual_handoff(self, CS, lkas_available):
+    if not lkas_available:
+      self._reset_legacy_2025_handoff()
+      return False
+
+    driver_override = self._update_angle_driver_override(CS)
+    if driver_override:
+      self.legacy_2025_handoff_active = True
+      self.legacy_2025_override_hold_frames = _LEGACY_2025_OVERRIDE_HOLD_FRAMES
+      self.legacy_2025_reengage_settle_frames = 0
+      self.legacy_2025_reengage_reference_angle = CS.out.steeringAngleDeg
+      self.legacy_2025_reclaim_frames = 0
+      return True
+
+    if not self.legacy_2025_handoff_active and not self.legacy_2025_lkas_active and \
+       abs(getattr(CS.out, "steeringRateDeg", 0.0)) > _LEGACY_2025_REENGAGE_MAX_STEER_RATE:
+      self.legacy_2025_handoff_active = True
+      self.legacy_2025_reengage_reference_angle = CS.out.steeringAngleDeg
+
+    if not self.legacy_2025_handoff_active:
+      return False
+
+    if self.legacy_2025_override_hold_frames > 0:
+      self.legacy_2025_override_hold_frames -= 1
+      if self.legacy_2025_override_hold_frames == 0:
+        self.legacy_2025_reengage_reference_angle = CS.out.steeringAngleDeg
+      return True
+
+    wheel_stable = abs(getattr(CS.out, "steeringRateDeg", 0.0)) <= _LEGACY_2025_REENGAGE_MAX_STEER_RATE and \
+      abs(CS.out.steeringAngleDeg - self.legacy_2025_reengage_reference_angle) <= _LEGACY_2025_REENGAGE_MAX_ANGLE_DELTA
+    if wheel_stable:
+      self.legacy_2025_reengage_settle_frames += 1
+    else:
+      self.legacy_2025_reengage_settle_frames = 0
+      self.legacy_2025_reengage_reference_angle = CS.out.steeringAngleDeg
+
+    if self.legacy_2025_reengage_settle_frames < _LEGACY_2025_REENGAGE_SETTLE_FRAMES:
+      return True
+
+    self.legacy_2025_handoff_active = False
+    self.legacy_2025_reengage_settle_frames = 0
+    self.legacy_2025_reclaim_frames = _LEGACY_2025_RECLAIM_FRAMES
+    self.legacy_2025_reclaim_start_angle = CS.out.steeringAngleDeg
+    return True
+
+  def _legacy_2025_reclaim_target(self, target_angle):
+    if self.legacy_2025_reclaim_frames <= 0:
+      return target_angle
+
+    progress = (_LEGACY_2025_RECLAIM_FRAMES - self.legacy_2025_reclaim_frames + 1) / _LEGACY_2025_RECLAIM_FRAMES
+    eased_progress = progress ** _LEGACY_2025_RECLAIM_EXPONENT
+    target_angle = self.legacy_2025_reclaim_start_angle + eased_progress * \
+      (target_angle - self.legacy_2025_reclaim_start_angle)
+    self.legacy_2025_reclaim_frames -= 1
+    return target_angle
+
   def _reset_angle_handoff(self):
     self.driver_override = False
     self.angle_override_confirm_frames = 0
     self.angle_handoff_active = False
+    self.angle_override_hold_frames = 0
+    self.angle_reengage_settle_frames = 0
+    self.angle_reengage_reference_angle = 0.0
+    self.angle_reclaim_frames = 0
+    self.angle_reclaim_start_angle = 0.0
 
-  def _angle_manual_handoff(self, CS, lat_active, use_steering_pressed=False):
+  def _angle_manual_handoff(self, CS, lat_active):
     if not lat_active:
       self._reset_angle_handoff()
       return False
 
     driver_override = self._update_angle_driver_override(CS)
-    if use_steering_pressed:
-      driver_override = driver_override or getattr(CS.out, "steeringPressed", False)
-    steering_rate = abs(getattr(CS.out, "steeringRateDeg", 0.0))
     if driver_override:
       self.angle_handoff_active = True
+      self.angle_override_hold_frames = _ANGLE_OVERRIDE_HOLD_FRAMES
+      self.angle_reengage_settle_frames = 0
+      self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
+      self.angle_reclaim_frames = 0
       return True
 
-    if self.angle_handoff_active:
-      if steering_rate > _ANGLE_REENGAGE_MAX_STEER_RATE:
-        return True
-
-      self.angle_handoff_active = False
-      return True
-
-    if not self.angle_lkas_active and steering_rate > _ANGLE_REENGAGE_MAX_STEER_RATE:
+    if not self.angle_handoff_active and not self.angle_lkas_active and \
+       abs(getattr(CS.out, "steeringRateDeg", 0.0)) > _ANGLE_REENGAGE_MAX_STEER_RATE:
       self.angle_handoff_active = True
+      self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
+
+    if not self.angle_handoff_active:
+      return False
+
+    if self.angle_override_hold_frames > 0:
+      self.angle_override_hold_frames -= 1
+      if self.angle_override_hold_frames == 0:
+        self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
       return True
 
-    return False
+    wheel_stable = abs(getattr(CS.out, "steeringRateDeg", 0.0)) <= _ANGLE_REENGAGE_MAX_STEER_RATE and \
+      abs(CS.out.steeringAngleDeg - self.angle_reengage_reference_angle) <= _ANGLE_REENGAGE_MAX_ANGLE_DELTA
+    if wheel_stable:
+      self.angle_reengage_settle_frames += 1
+    else:
+      self.angle_reengage_settle_frames = 0
+      self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
+
+    if self.angle_reengage_settle_frames < _ANGLE_REENGAGE_SETTLE_FRAMES:
+      return True
+
+    self.angle_handoff_active = False
+    self.angle_reengage_settle_frames = 0
+    self.angle_reclaim_frames = _ANGLE_RECLAIM_FRAMES
+    self.angle_reclaim_start_angle = CS.out.steeringAngleDeg
+    return True
 
   def _update_angle_driver_override(self, CS):
     """Debounce the higher-confidence raw torque override signal for angle cars."""
@@ -172,13 +283,16 @@ class CarController(CarControllerBase):
 
     return self.driver_override
 
-  def _ascent_aol_ready(self, ready):
-    if not ready:
-      self.ascent_aol_arm_frames = 0
-      return False
+  def _angle_reclaim_target(self, target_angle):
+    if self.angle_reclaim_frames <= 0:
+      return target_angle
 
-    self.ascent_aol_arm_frames = min(self.ascent_aol_arm_frames + 1, _ASCENT_AOL_ARM_FRAMES)
-    return self.ascent_aol_arm_frames >= _ASCENT_AOL_ARM_FRAMES
+    progress = (_ANGLE_RECLAIM_FRAMES - self.angle_reclaim_frames + 1) / _ANGLE_RECLAIM_FRAMES
+    eased_progress = progress ** _ANGLE_RECLAIM_EXPONENT
+    target_angle = self.angle_reclaim_start_angle + eased_progress * \
+      (target_angle - self.angle_reclaim_start_angle)
+    self.angle_reclaim_frames -= 1
+    return target_angle
 
   def lateral_angle(self, CC, CS):
     if self.CP.carFingerprint == CAR.SUBARU_LEGACY_2025:
@@ -188,11 +302,12 @@ class CarController(CarControllerBase):
       lkas_available = CC.latActive and (not mads_only or mads_only_ok) and \
         CS.out.gearShifter == structs.CarState.GearShifter.drive and not CS.out.standstill
 
-      manual_handoff = self._angle_manual_handoff(CS, lkas_available)
+      manual_handoff = self._legacy_2025_manual_handoff(CS, CC.latActive)
       lkas_active = lkas_available and not manual_handoff
 
+      steer_target = self._legacy_2025_reclaim_target(CC.actuators.steeringAngleDeg) if lkas_active else CC.actuators.steeringAngleDeg
       apply_steer = apply_std_steer_angle_limits(
-        CC.actuators.steeringAngleDeg,
+        steer_target,
         self.apply_steer_last,
         CS.out.vEgoRaw,
         CS.out.steeringAngleDeg,
@@ -200,7 +315,7 @@ class CarController(CarControllerBase):
         self.p.LEGACY_2025_ANGLE_LIMITS,
       )
       self.apply_steer_last = apply_steer
-      self.angle_lkas_active = lkas_active
+      self.legacy_2025_lkas_active = lkas_active
       return subarucan.create_steering_control_angle(self.packer, apply_steer, lkas_active, self.angle_bus)
 
     if self.CP.carFingerprint in (CAR.SUBARU_ASCENT_2023, CAR.SUBARU_OUTBACK_2023):
@@ -209,24 +324,17 @@ class CarController(CarControllerBase):
         abs(CS.out.steeringAngleDeg) < _ANGLE_MADS_MAX_STEER_ANGLE
       lkas_available = CC.latActive and (not mads_only or mads_only_ok) and \
         CS.out.gearShifter == structs.CarState.GearShifter.drive and not CS.out.standstill
-      if self.CP.carFingerprint == CAR.SUBARU_ASCENT_2023:
-        if mads_only:
-          cruise_available = getattr(getattr(CS.out, "cruiseState", None), "available", True)
-          lkas_available = self._ascent_aol_ready(lkas_available and cruise_available)
-        else:
-          self.ascent_aol_arm_frames = _ASCENT_AOL_ARM_FRAMES if lkas_available else 0
 
-      manual_handoff = self._angle_manual_handoff(
-        CS, lkas_available, use_steering_pressed=self.CP.carFingerprint == CAR.SUBARU_OUTBACK_2023,
-      )
+      manual_handoff = self._angle_manual_handoff(CS, CC.latActive)
       lkas_active = lkas_available and not manual_handoff
 
       if lkas_active and not self.angle_lkas_active:
         self.apply_steer_last = CS.out.steeringAngleDeg
 
+      steer_target = self._angle_reclaim_target(CC.actuators.steeringAngleDeg) if lkas_active else CC.actuators.steeringAngleDeg
       if self.CP.carFingerprint in (CAR.SUBARU_ASCENT_2023, CAR.SUBARU_OUTBACK_2023):
         apply_steer = apply_std_steer_angle_limits(
-          CC.actuators.steeringAngleDeg,
+          steer_target,
           self.apply_steer_last,
           CS.out.vEgoRaw,
           CS.out.steeringAngleDeg,
@@ -253,12 +361,13 @@ class CarController(CarControllerBase):
     lkas_available = CC.latActive and (not mads_only or mads_only_ok) and \
       getattr(CS.out, "gearShifter", structs.CarState.GearShifter.drive) == structs.CarState.GearShifter.drive and \
       not getattr(CS.out, "standstill", False)
-    manual_handoff = self._angle_manual_handoff(CS, lkas_available)
+    manual_handoff = self._angle_manual_handoff(CS, CC.latActive)
     lat_active = lkas_available and not self.driver_override and not manual_handoff
     if lat_active and not self.angle_lkas_active:
       self.apply_steer_last = CS.out.steeringAngleDeg
+    steer_target = self._angle_reclaim_target(CC.actuators.steeringAngleDeg) if lat_active else CC.actuators.steeringAngleDeg
     apply_steer = apply_steer_angle_limits_vm(
-      CC.actuators.steeringAngleDeg,
+      steer_target,
       self.apply_steer_last,
       CS.out.vEgoRaw,
       CS.out.steeringAngleDeg,
@@ -299,11 +408,6 @@ class CarController(CarControllerBase):
 
     return subarucan.create_steering_control(self.packer, apply_torque, apply_steer_req)
 
-  def _lkas_status_active(self, CC):
-    if self.CP.carFingerprint in (CAR.SUBARU_ASCENT_2023, CAR.SUBARU_OUTBACK_2023):
-      return self.angle_lkas_active
-    return CC.latActive
-
   def update(self, CC, CS, now_nanos, starpilot_toggles):
     actuators = CC.actuators
     hud_control = CC.hudControl
@@ -380,7 +484,7 @@ class CarController(CarControllerBase):
                                                         CC.longActive, hud_control.leadVisible,
                                                         self.status_bus))
 
-        can_sends.append(subarucan.create_es_lkas_state(self.packer, self.frame // 10, CS.es_lkas_state_msg, self._lkas_status_active(CC), hud_control.visualAlert,
+        can_sends.append(subarucan.create_es_lkas_state(self.packer, self.frame // 10, CS.es_lkas_state_msg, CC.latActive, hud_control.visualAlert,
                                                         hud_control.leftLaneVisible, hud_control.rightLaneVisible,
                                                         hud_control.leftLaneDepart, hud_control.rightLaneDepart, self.status_bus))
 

opendbc_repo/opendbc/car/subaru/tests/test_subaru.py

@@ -8,7 +8,7 @@ from opendbc.can import CANPacker, CANParser
 from opendbc.car import Bus, fw_versions, gen_empty_fingerprint, structs
 from opendbc.car.fw_query_definitions import StdQueries
 from opendbc.car.subaru import subarucan
-from opendbc.car.subaru.carcontroller import CarController, _ASCENT_AOL_ARM_FRAMES
+from opendbc.car.subaru.carcontroller import CarController
 from opendbc.car.subaru.carstate import CarState
 from opendbc.car.subaru.fingerprints import FW_VERSIONS
 from opendbc.car.fw_versions import match_fw_to_car
@@ -414,7 +414,7 @@ def test_legacy_2025_engagement_continues_from_last_sent_angle():
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(0.47)
 
 
-def test_legacy_2025_reengages_immediately_after_manual_steering_stops():
+def test_legacy_2025_waits_for_manual_steering_to_settle_before_reengaging():
   CP = CarInterface.get_non_essential_params(CAR.SUBARU_LEGACY_2025)
   controller = CarController({}, CP)
   CC = SimpleNamespace(
@@ -444,20 +444,42 @@ def test_legacy_2025_reengages_immediately_after_manual_steering_stops():
   CS.out.steeringPressed = False
   CS.out.steeringTorque = 0.0
   CS.out.steeringAngleDeg = -113.78
-  CS.out.steeringRateDeg = 0.0
   msg = controller.lateral_angle(CC, CS)
-  parser.update([(3, [msg])])
+  parser.update([(2, [msg])])
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(CS.out.steeringAngleDeg)
 
+  for i in range(9):
+    CS.out.steeringAngleDeg += 0.5
+    CS.out.steeringRateDeg = 20.0
+    msg = controller.lateral_angle(CC, CS)
+    parser.update([(3 + i, [msg])])
+    assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
+    assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(CS.out.steeringAngleDeg)
+
+  for i in range(6):
+    if i % 2:
+      CS.out.steeringAngleDeg += 0.5
+    CS.out.steeringRateDeg = 0.0 if i % 2 == 0 else 20.0
+    msg = controller.lateral_angle(CC, CS)
+    parser.update([(12 + i, [msg])])
+    assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
+    assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(CS.out.steeringAngleDeg)
+
   CS.out.steeringRateDeg = 0.0
+  for i in range(8):
+    msg = controller.lateral_angle(CC, CS)
+    parser.update([(18 + i, [msg])])
+    assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
+
+  measured_angle = CS.out.steeringAngleDeg
   msg = controller.lateral_angle(CC, CS)
-  parser.update([(4, [msg])])
+  parser.update([(26, [msg])])
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 1
-  assert -113.78 < parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] < -100.0
+  assert abs(parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] - measured_angle) < 0.1
 
 
-def test_legacy_2025_manual_handoff_reentry_uses_normal_angle_limits():
+def test_legacy_2025_manual_handoff_reclaim_is_gradual():
   CP = CarInterface.get_non_essential_params(CAR.SUBARU_LEGACY_2025)
   controller = CarController({}, CP)
   CC = SimpleNamespace(
@@ -486,24 +508,22 @@ def test_legacy_2025_manual_handoff_reentry_uses_normal_angle_limits():
   CS.out.steeringPressed = False
   CS.out.steeringTorque = 0.0
   CS.out.steeringRateDeg = 0.0
-  msg = controller.lateral_angle(CC, CS)
-  parser.update([(3, [msg])])
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
+  for i in range(19):
+    msg = controller.lateral_angle(CC, CS)
+    parser.update([(2 + i, [msg])])
 
-  msg = controller.lateral_angle(CC, CS)
-  parser.update([(4, [msg])])
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 1
-  first_reentry_angle = parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"]
-  assert CC.actuators.steeringAngleDeg < first_reentry_angle < CS.out.steeringAngleDeg
+  first_reclaim_angle = parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"]
+  assert first_reclaim_angle == pytest.approx(CS.out.steeringAngleDeg, abs=0.1)
 
-  reentry_angles = []
+  reclaim_angles = []
   for i in range(6):
     msg = controller.lateral_angle(CC, CS)
     parser.update([(20 + i, [msg])])
-    reentry_angles.append(parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"])
+    reclaim_angles.append(parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"])
 
-  assert all(reentry_angles[i] >= reentry_angles[i + 1] for i in range(len(reentry_angles) - 1))
-  assert reentry_angles[-1] > CC.actuators.steeringAngleDeg
+  assert all(reclaim_angles[i] >= reclaim_angles[i + 1] for i in range(len(reclaim_angles) - 1))
+  assert reclaim_angles[-1] > CC.actuators.steeringAngleDeg
 
 
 def test_ascent_2023_uses_gen2_angle_bus_layout():
@@ -644,7 +664,7 @@ def test_angle_controller_uses_fixed_angle_rate_limits(platform):
 
 
 @pytest.mark.parametrize("platform", (CAR.SUBARU_ASCENT_2023, CAR.SUBARU_OUTBACK_2023))
-def test_angle_controller_reengages_immediately_after_manual_steering_stops(platform):
+def test_angle_controller_yields_until_manual_steering_settles(platform):
   CP = CarInterface.get_non_essential_params(platform)
   controller = CarController({}, CP)
   CC = SimpleNamespace(enabled=True, latActive=True, actuators=SimpleNamespace(steeringAngleDeg=-10.0))
@@ -671,18 +691,18 @@ def test_angle_controller_reengages_immediately_after_manual_steering_stops(plat
   CS.out.steeringTorque = 0.0
   CS.out.steeringAngleDeg = -17.91
   CS.out.steeringRateDeg = 0.0
-  msg = controller.lateral_angle(CC, CS)
-  parser.update([(3, [msg])])
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(CS.out.steeringAngleDeg)
+  for i in range(18):
+    msg = controller.lateral_angle(CC, CS)
+    parser.update([(2 + i, [msg])])
+    assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
 
   msg = controller.lateral_angle(CC, CS)
-  parser.update([(4, [msg])])
+  parser.update([(20, [msg])])
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 1
-  assert CS.out.steeringAngleDeg < parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] < CC.actuators.steeringAngleDeg
+  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(CS.out.steeringAngleDeg, abs=0.1)
 
 
-def test_ascent_angle_controller_waits_for_parking_lot_safety_envelope():
+def test_ascent_angle_controller_blocks_parking_lot_aol_engagement():
   CP = CarInterface.get_non_essential_params(CAR.SUBARU_ASCENT_2023)
   controller = CarController({}, CP)
   CC = SimpleNamespace(enabled=False, latActive=True, actuators=SimpleNamespace(steeringAngleDeg=-206.12))
@@ -692,7 +712,6 @@ def test_ascent_angle_controller_waits_for_parking_lot_safety_envelope():
     steeringRateDeg=96.0,
     steeringTorque=7.0,
     steeringPressed=False,
-    cruiseState=SimpleNamespace(available=True),
     gearShifter=structs.CarState.GearShifter.drive,
     standstill=False,
   ))
@@ -705,77 +724,30 @@ def test_ascent_angle_controller_waits_for_parking_lot_safety_envelope():
 
   CS.out.steeringAngleDeg = -100.0
   CS.out.steeringRateDeg = 0.0
-  for frame in range(2, _ASCENT_AOL_ARM_FRAMES + 1):
+  msg = controller.lateral_angle(CC, CS)
+  parser.update([(2, [msg])])
+  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
+
+  for i in range(8):
     msg = controller.lateral_angle(CC, CS)
-    parser.update([(frame, [msg])])
+    parser.update([(3 + i, [msg])])
     assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
 
   msg = controller.lateral_angle(CC, CS)
-  parser.update([(_ASCENT_AOL_ARM_FRAMES + 1, [msg])])
+  parser.update([(11, [msg])])
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 1
 
   CS.out.gearShifter = structs.CarState.GearShifter.reverse
   msg = controller.lateral_angle(CC, CS)
-  parser.update([(_ASCENT_AOL_ARM_FRAMES + 2, [msg])])
+  parser.update([(12, [msg])])
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
   assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(CS.out.steeringAngleDeg)
 
 
-def test_ascent_aol_does_not_arm_before_cruise_main_is_available():
-  CP = CarInterface.get_non_essential_params(CAR.SUBARU_ASCENT_2023)
-  controller = CarController({}, CP)
-  CC = SimpleNamespace(enabled=False, latActive=True, actuators=SimpleNamespace(steeringAngleDeg=5.0))
-  CS = SimpleNamespace(out=SimpleNamespace(
-    vEgoRaw=10.0,
-    steeringAngleDeg=0.0,
-    steeringRateDeg=0.0,
-    steeringTorque=0.0,
-    steeringPressed=False,
-    cruiseState=SimpleNamespace(available=False),
-    gearShifter=structs.CarState.GearShifter.drive,
-    standstill=False,
-  ))
-  parser = CANParser(DBC[CP.carFingerprint][Bus.pt], [("ES_LKAS_ANGLE", 0)], CanBus.main)
-
-  for frame in range(_ASCENT_AOL_ARM_FRAMES):
-    msg = controller.lateral_angle(CC, CS)
-    parser.update([(frame + 1, [msg])])
-
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
-  assert controller.ascent_aol_arm_frames == 0
-
-  CS.out.cruiseState.available = True
-  msg = controller.lateral_angle(CC, CS)
-  parser.update([(_ASCENT_AOL_ARM_FRAMES + 1, [msg])])
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
-  assert controller.ascent_aol_arm_frames == 1
-
-
-def test_ascent_angle_controller_does_not_delay_normal_engagement():
-  CP = CarInterface.get_non_essential_params(CAR.SUBARU_ASCENT_2023)
-  controller = CarController({}, CP)
-  CC = SimpleNamespace(enabled=True, latActive=True, actuators=SimpleNamespace(steeringAngleDeg=5.0))
-  CS = SimpleNamespace(out=SimpleNamespace(
-    vEgoRaw=10.0,
-    steeringAngleDeg=0.0,
-    steeringRateDeg=0.0,
-    steeringTorque=0.0,
-    steeringPressed=False,
-    gearShifter=structs.CarState.GearShifter.drive,
-    standstill=False,
-  ))
-  parser = CANParser(DBC[CP.carFingerprint][Bus.pt], [("ES_LKAS_ANGLE", 0)], CanBus.main)
-
-  msg = controller.lateral_angle(CC, CS)
-  parser.update([(1, [msg])])
-
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 1
-
-
-def test_lkas_hud_state_uses_angle_request_state():
+def test_lkas_hud_state_uses_lateral_active():
   update_source = inspect.getsource(CarController.update)
 
-  assert "create_es_lkas_state(self.packer, self.frame // 10, CS.es_lkas_state_msg, self._lkas_status_active(CC)" in update_source
+  assert "create_es_lkas_state(self.packer, self.frame // 10, CS.es_lkas_state_msg, CC.latActive" in update_source
   assert "create_es_lkas_state(self.packer, self.frame // 10, CS.es_lkas_state_msg, CC.enabled" not in update_source
 
 
@@ -793,48 +765,3 @@ def test_lkas_hud_active_bit_follows_lateral_state(enabled, expected):
 
   assert parser.can_valid
   assert parser.vl["ES_LKAS_State"]["LKAS_ACTIVE"] == expected
-
-
-def test_outback_manual_steering_releases_angle_request_before_lkas_fault():
-  CP = CarInterface.get_non_essential_params(CAR.SUBARU_OUTBACK_2023)
-  controller = CarController({}, CP)
-  CC = SimpleNamespace(
-    enabled=False,
-    latActive=True,
-    actuators=SimpleNamespace(steeringAngleDeg=-225.0),
-  )
-  CS = SimpleNamespace(out=SimpleNamespace(
-    vEgoRaw=0.9,
-    steeringAngleDeg=-57.0,
-    steeringRateDeg=-45.0,
-    steeringTorque=-127.0,
-    steeringPressed=True,
-    gearShifter=structs.CarState.GearShifter.drive,
-    standstill=False,
-  ))
-  parser = CANParser(DBC[CP.carFingerprint][Bus.pt], [("ES_LKAS_ANGLE", 0)], CanBus.main)
-
-  msg = controller.lateral_angle(CC, CS)
-  parser.update([(1, [msg])])
-
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Request"] == 0
-  assert parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] == pytest.approx(CS.out.steeringAngleDeg)
-  assert not controller._lkas_status_active(CC)
-
-
-def test_ascent_hud_waits_for_angle_request():
-  CP = CarInterface.get_non_essential_params(CAR.SUBARU_ASCENT_2023)
-  controller = CarController({}, CP)
-  CC = SimpleNamespace(latActive=True)
-
-  assert not controller._lkas_status_active(CC)
-  controller.angle_lkas_active = True
-  assert controller._lkas_status_active(CC)
-
-
-def test_other_angle_cars_keep_lateral_status_behavior():
-  CP = CarInterface.get_non_essential_params(CAR.SUBARU_CROSSTREK_2025)
-  controller = CarController({}, CP)
-  controller.angle_lkas_active = False
-
-  assert controller._lkas_status_active(SimpleNamespace(latActive=True))

opendbc_repo/opendbc/car/volkswagen/mqbcan.py

@@ -243,8 +243,6 @@ VOLKSWAGEN_MQB_MEB_CONSTANTS: dict[int, list[int]] = {
             0xC5, 0x91, 0x0F, 0x27, 0x34, 0x04, 0x7F, 0x02],  # EA_02
     0x20A: [0x9D, 0xE8, 0x36, 0xA1, 0xCA, 0x3B, 0x1D, 0x33,
             0xE0, 0xD5, 0xBB, 0x5F, 0xAE, 0x3C, 0x31, 0x9F],  # EML_06
-    0x25D: [0xDA, 0x6B, 0x0E, 0xB2, 0x78, 0xBD, 0x5A, 0x81,
-            0x7B, 0xD6, 0x41, 0x39, 0x76, 0xB6, 0xD7, 0x35],  # KLR_01
     0x26B: [0xCE, 0xCC, 0xBD, 0x69, 0xA1, 0x3C, 0x18, 0x76,
             0x0F, 0x04, 0xF2, 0x3A, 0x93, 0x24, 0x19, 0x51],  # TA_01
     0x30C: [0x0F] * 16,  # ACC_02

opendbc_repo/opendbc/car/volkswagen/tests/test_volkswagen.py

@@ -1,16 +1,10 @@
 import random
 import re
 
-import pytest
-
-from opendbc.can.packer import CANPacker
-from opendbc.car import Bus
 from opendbc.car.structs import CarParams
 from opendbc.car.volkswagen.interface import CarInterface
+from opendbc.car.volkswagen.values import CAR, FW_QUERY_CONFIG, WMI, VolkswagenFlags, VolkswagenSafetyFlags
 from opendbc.car.volkswagen.fingerprints import FW_VERSIONS
-from opendbc.car.volkswagen.mqbcan import volkswagen_mqb_meb_checksum
-from opendbc.car.volkswagen.radar_interface import RadarInterface
-from opendbc.car.volkswagen.values import CAR, DBC, FW_QUERY_CONFIG, WMI, CanBus, VolkswagenFlags, VolkswagenSafetyFlags
 
 Ecu = CarParams.Ecu
 
@@ -66,35 +60,6 @@ class TestVolkswagenPlatformConfigs:
     assert not cp.pcmCruise
     assert cp.safetyConfigs[-1].safetyParam & VolkswagenSafetyFlags.LONG_CONTROL
 
-  @pytest.mark.parametrize("data_hex", (
-    "fc03fcfcfc0f0000",
-    "e304fcfcfc0f0000",
-    "1105fcfcfc0f0000",
-  ))
-  def test_meb_klr_checksum(self, data_hex):
-    data = bytearray.fromhex(data_hex)
-    assert volkswagen_mqb_meb_checksum(0x25D, None, data) == data[0]
-
-  def test_meb_camera_radar_tracks(self):
-    cp = self._get_meb_params(CAR.SKODA_ENYAQ_MK1)
-    radar = RadarInterface(cp)
-    packer = CANPacker(DBC[cp.carFingerprint][Bus.radar])
-    message = packer.make_can_msg("MEB_Distance_01", CanBus(cp).cam, {
-      "Distance_Status": 0,
-      "Same_Lane_01_ObjectID": 1,
-      "Same_Lane_01_Long_Distance": 25.0,
-      "Same_Lane_01_Lat_Distance": 0.5,
-      "Same_Lane_01_Rel_Velo": -2.0,
-    })
-
-    radar_data = radar.update([(1_000_000_000, [message])])
-    assert radar_data is not None
-    assert len(radar_data.points) == 1
-    assert radar_data.points[0].trackId == 0
-    assert radar_data.points[0].dRel == pytest.approx(25.0, abs=0.1)
-    assert radar_data.points[0].yRel == pytest.approx(0.5, abs=0.1)
-    assert radar_data.points[0].vRel == pytest.approx(-2.0, abs=0.1)
-
   def test_taos_longitudinal_actuator_delay(self):
     taos_cp = CarInterface.get_non_essential_params(CAR.VOLKSWAGEN_TAOS_MK1)
     golf_cp = CarInterface.get_non_essential_params(CAR.VOLKSWAGEN_GOLF_MK7)

opendbc_repo/opendbc/dbc/hyundai_can_refresh_generated.dbc

@@ -1497,7 +1497,7 @@ BO_ 913 BCM_PO_11: 8 Vector__XXX
  SG_ BCM_Door_Dri_Status : 5|1@0+ (1,0) [0|1] "" PT_ESC_ABS
  SG_ BCM_Shift_R_MT_SW_Status : 39|2@0+ (1,0) [0|3] "" PT_ESC_ABS
  SG_ LDA_BTN : 4|1@0+ (1,0) [0|1] "" XXX
- SG_ RAY_LKAS_BTN : 4|1@0+ (1,0) [0|1] "" XXX
+ SG_ RAY_LKAS_BTN : 0|2@1+ (1,0) [0|3] "" XXX
 
 BO_ 1426 LABEL11: 8 XXX
  SG_ CC_React : 34|1@1+ (1,0) [0|1] "" XXX

opendbc_repo/opendbc/safety/modes/gm.h

@@ -60,7 +60,6 @@ static bool gm_panda_3d1_sched = false;
 static bool gm_panda_paddle_sched = false;
 static bool gm_bolt_2022_pedal = false;
 static bool gm_alt_brake = false;
-static bool gm_volt_cc_gateway = false;
 static bool gm_volt_auto_hold = false;
 static bool gm_volt_one_pedal = false;
 
@@ -262,8 +261,7 @@ static void gm_rx_hook(const CANPacket_t *msg) {
     }
 
     if ((msg->addr == 0xF1U) && gm_alt_brake) {
-      const uint8_t brake_threshold = gm_volt_cc_gateway ? 21U : 6U;
-      brake_pressed = msg->data[1] >= brake_threshold;
+      brake_pressed = msg->data[1] >= 6U;
     }
 
     if ((msg->addr == 0xC9U) && (gm_hw == GM_CAM) && !gm_force_brake_c9) {
@@ -722,7 +720,7 @@ static safety_config gm_init(uint16_t param) {
   gm_cc_long = GET_FLAG(param, GM_PARAM_CC_LONG);
   gm_has_acc = !GET_FLAG(param, GM_PARAM_NO_ACC);
   gm_pedal_long = GET_FLAG(param, GM_PARAM_PEDAL_LONG);
-  gm_volt_cc_gateway = GET_FLAG(param, GM_PARAM_VOLT_CC_GATEWAY) && gm_no_camera && !gm_pedal_long && !gm_has_acc;
+  const bool gm_volt_cc_gateway = GET_FLAG(param, GM_PARAM_VOLT_CC_GATEWAY) && gm_no_camera && !gm_pedal_long && !gm_has_acc;
   enable_gas_interceptor = GET_FLAG(param, GM_PARAM_PEDAL_INTERCEPTOR);
   gm_force_ascm = GET_FLAG(param, GM_PARAM_HW_ASCM_LONG);
   gm_force_brake_c9 = GET_FLAG(param, GM_PARAM_FORCE_BRAKE_C9);

opendbc_repo/opendbc/safety/tests/test_gm.py

@@ -654,31 +654,6 @@ class TestGmCcLongitudinalNoCameraSafety(TestGmCcLongitudinalSafety):
     self.safety.init_tests()
 
 
-def test_gm_volt_cc_gateway_brake_threshold_matches_carstate():
-  safety = libsafety_py.libsafety
-  safety.set_safety_hooks(
-    CarParams.SafetyModel.gm,
-    GMSafetyFlags.FLAG_GM_NO_CAMERA |
-    GMSafetyFlags.FLAG_GM_NO_ACC |
-    GMSafetyFlags.FLAG_GM_CC_LONG |
-    GMSafetyFlags.FLAG_GM_VOLT_CC_GATEWAY,
-  )
-  safety.init_tests()
-  safety.set_controls_allowed(True)
-
-  cruise = common.make_msg(0, 0x3D1, 8, bytes([0, 0, 0, 0, 0x80, 0, 0, 0]))
-  safety.safety_rx_hook(cruise)
-  assert safety.get_controls_allowed()
-
-  noisy_brake = libsafety_py.make_CANPacket(0xF1, 0, b"\x34\x06\x05\x40\x00\x00")
-  safety.safety_rx_hook(noisy_brake)
-  assert safety.get_controls_allowed()
-
-  pressed_brake = libsafety_py.make_CANPacket(0xF1, 0, b"\x34\x15\x05\x40\x00\x00")
-  safety.safety_rx_hook(pressed_brake)
-  assert not safety.get_controls_allowed()
-
-
 class TestGmCcLongitudinalPandaSchedSafety(TestGmCcLongitudinalSafety):
   FWD_BLACKLISTED_ADDRS = {2: [0x180, 0x370], 0: [0x184, 0x3D1]}
   INTERCEPTOR_GAS_PRESSED = 596

panda/SConscript

@@ -181,11 +181,6 @@ build_project("panda_h7_remote_can_ignition_only", base_project_h7, "./board/mai
 build_project("panda_hkg_remote_can_ignition_only", base_project_f4, "./board/main.c", ["-DPANDA_HKG_REMOTE_START", "-DPANDA_IGNORE_IGNITION_LINE"])
 build_project("panda_h7_hkg_remote_can_ignition_only", base_project_h7, "./board/main.c", ["-DPANDA_HKG_REMOTE_START", "-DPANDA_IGNORE_IGNITION_LINE"])
 
-build_project("panda_tesla_wake", base_project_f4, "./board/main.c", ["-DPANDA_TESLA_WAKE_ON_CAN"])
-build_project("panda_h7_tesla_wake", base_project_h7, "./board/main.c", ["-DPANDA_TESLA_WAKE_ON_CAN"])
-build_project("panda_tesla_wake_can_ignition_only", base_project_f4, "./board/main.c", ["-DPANDA_TESLA_WAKE_ON_CAN", "-DPANDA_IGNORE_IGNITION_LINE"])
-build_project("panda_h7_tesla_wake_can_ignition_only", base_project_h7, "./board/main.c", ["-DPANDA_TESLA_WAKE_ON_CAN", "-DPANDA_IGNORE_IGNITION_LINE"])
-
 # panda jungle fw
 flags = [
   "-DPANDA_JUNGLE",

panda/board/drivers/bootkick.h

@@ -2,18 +2,18 @@
 
 bool bootkick_reset_triggered = false;
 
-void bootkick_tick(bool ignition, bool recent_heartbeat, bool wake) {
+void bootkick_tick(bool ignition, bool recent_heartbeat) {
   static uint16_t bootkick_last_serial_ptr = 0;
   static uint8_t waiting_to_boot_countdown = 0;
   static uint8_t boot_reset_countdown = 0;
   static uint8_t bootkick_harness_status_prev = HARNESS_STATUS_NC;
   static bool bootkick_ign_prev = false;
-  static bool bootkick_wake_prev = false;
   static BootState boot_state = BOOT_BOOTKICK;
   BootState boot_state_prev = boot_state;
   const bool harness_inserted = (harness.status != bootkick_harness_status_prev) && (harness.status != HARNESS_STATUS_NC);
 
-  if ((ignition && !bootkick_ign_prev) || harness_inserted || (wake && !bootkick_wake_prev && !ignition)) {
+  if ((ignition && !bootkick_ign_prev) || harness_inserted) {
+    // bootkick on rising edge of ignition or harness insertion
     boot_state = BOOT_BOOTKICK;
   } else if (recent_heartbeat) {
     // disable bootkick once openpilot is up
@@ -56,7 +56,6 @@ void bootkick_tick(bool ignition, bool recent_heartbeat, bool wake) {
 
   // update state
   bootkick_ign_prev = ignition;
-  bootkick_wake_prev = wake;
   bootkick_harness_status_prev = harness.status;
   bootkick_last_serial_ptr = uart_ring_som_debug.w_ptr_tx;
   if (waiting_to_boot_countdown > 0U) {

panda/board/drivers/bootkick_declarations.h

@@ -2,4 +2,4 @@
 
 extern bool bootkick_reset_triggered;
 
-void bootkick_tick(bool ignition, bool recent_heartbeat, bool wake);
+void bootkick_tick(bool ignition, bool recent_heartbeat);

panda/board/drivers/can_common.h

@@ -7,9 +7,7 @@ uint32_t rx_buffer_overflow = 0;
 
 can_health_t can_health[PANDA_CAN_CNT] = {{0}, {0}, {0}};
 
-bool wake_on_can = false;
-uint32_t wake_on_can_cnt = 0U;
-
+// Ignition detected from CAN meessages
 bool ignition_can = false;
 uint32_t ignition_can_cnt = 0U;
 #ifdef PANDA_HKG_REMOTE_START
@@ -227,23 +225,6 @@ void ignition_can_hook(CANPacket_t *msg) {
         ignition_can_cnt = 0U;
       }
       prev_counter_tesla = counter;
-
-      #ifdef PANDA_TESLA_WAKE_ON_CAN
-      uint32_t checksum = (msg->addr & 0xFFU) + (msg->addr >> 8U);
-      for (uint8_t i = 0U; i < 7U; i++) {
-        checksum += msg->data[i];
-      }
-      static int prev_counter_tesla_wake = -1;
-      if (!msg->extended && (msg->data[7] == (checksum & 0xFFU))) {
-        if ((prev_counter_tesla_wake != -1) && (counter == ((prev_counter_tesla_wake + 1) % 16))) {
-          wake_on_can = ((msg->data[0] >> 5U) & 0x3U) != 0U;
-          wake_on_can_cnt = 0U;
-        }
-        prev_counter_tesla_wake = counter;
-      } else {
-        prev_counter_tesla_wake = -1;
-      }
-      #endif
     }
 
     // Tesla Model S pre-AP exception
@@ -268,19 +249,6 @@ void ignition_can_hook(CANPacket_t *msg) {
       ignition_can_cnt = 0U;
     }
 
-    // Volkswagen MEB exception
-    if ((msg->addr == 0x3C0U) && (len == 4)) {
-      int counter = msg->data[1] & 0xFU;
-
-      static int prev_counter_vw_meb = -1;
-      if ((counter == ((prev_counter_vw_meb + 1) % 16)) && (prev_counter_vw_meb != -1)) {
-        // Klemmen_Status_01->ZAS_Kl_15
-        ignition_can = ((msg->data[2] >> 1) & 1U) != 0U;
-        ignition_can_cnt = 0U;
-      }
-      prev_counter_vw_meb = counter;
-    }
-
   }
 }
 

panda/board/drivers/can_common_declarations.h

@@ -28,9 +28,7 @@ extern uint32_t rx_buffer_overflow;
 
 extern can_health_t can_health[PANDA_CAN_CNT];
 
-extern bool wake_on_can;
-extern uint32_t wake_on_can_cnt;
-
+// Ignition detected from CAN meessages
 extern bool ignition_can;
 extern uint32_t ignition_can_cnt;
 

panda/board/main.c

@@ -192,7 +192,7 @@ static void tick_handler(void) {
       #ifdef PANDA_HKG_REMOTE_START
       started = started || hkg_remote_climate_wake;
       #endif
-      bootkick_tick(started, recent_heartbeat, wake_on_can);
+      bootkick_tick(started, recent_heartbeat);
 
       // increase heartbeat counter and cap it at the uint32 limit
       if (heartbeat_counter < UINT32_MAX) {
@@ -270,9 +270,6 @@ static void tick_handler(void) {
       if (ignition_can_cnt > 2U) {
         ignition_can = false;
       }
-      if (wake_on_can_cnt > 2U) {
-        wake_on_can = false;
-      }
       #ifdef PANDA_HKG_REMOTE_START
       if (hkg_remote_climate_wake_cnt > 2U) {
         hkg_remote_climate_wake = false;
@@ -283,7 +280,6 @@ static void tick_handler(void) {
       uptime_cnt += 1U;
       safety_mode_cnt += 1U;
       ignition_can_cnt += 1U;
-      wake_on_can_cnt += 1U;
       #ifdef PANDA_HKG_REMOTE_START
       hkg_remote_climate_wake_cnt += 1U;
       #endif

panda/board/obj/gitversion.h

@@ -1,2 +1,2 @@
 extern const uint8_t gitversion[19];
-const uint8_t gitversion[19] = "DEV-bf00f88b-DEBUG";
+const uint8_t gitversion[19] = "DEV-eedd73e5-DEBUG";