some

#	sunnypilot/navd/navigation_desires/navigation_desires.py
#	sunnypilot/navd/navigation_helpers/nav_instructions.py
#	sunnypilot/navd/navigation_helpers/tests/test_mapbox.py
#	sunnypilot/navd/navigationd.py

.gitmodules

@@ -4,7 +4,6 @@
 [submodule "opendbc"]
   path = opendbc_repo
   url = https://github.com/sunnypilot/opendbc.git
-  branch = tn
 [submodule "msgq"]
   path = msgq_repo
   url = https://github.com/sunnypilot/msgq.git

cereal/custom.capnp

@@ -192,7 +192,6 @@ struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
   aTarget @5 :Float32;
   events @6 :List(OnroadEventSP.Event);
   e2eAlerts @7 :E2eAlerts;
-  accelPersonality @8 :AccelerationPersonality;
 
   struct DynamicExperimentalControl {
     state @0 :DynamicExperimentalControlState;
@@ -204,11 +203,7 @@ struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
       blended @1;
     }
   }
-  enum AccelerationPersonality {
-    sport @0;
-    normal @1;
-    eco @2;
-  }
+
   struct SmartCruiseControl {
     vision @0 :Vision;
     map @1 :Map;
@@ -345,7 +340,6 @@ struct OnroadEventSP @0xda96579883444c35 {
     speedLimitChanged @21;
     speedLimitPending @22;
     e2eChime @23;
-    laneChangeRoadEdge @24;
   }
 }
 
@@ -452,8 +446,6 @@ struct LiveMapDataSP @0xf416ec09499d9d19 {
 
 struct ModelDataV2SP @0xa1680744031fdb2d {
   laneTurnDirection @0 :TurnDirection;
-  leftLaneChangeEdgeBlock @1 :Bool;
-  rightLaneChangeEdgeBlock @2 :Bool;
 
   enum TurnDirection {
     none @0;
@@ -496,84 +488,11 @@ struct CustomReserved15 @0xbd443b539493bc68 {
 struct CustomReserved16 @0xfc6241ed8877b611 {
 }
 
-enum MapdExtendedOutType {
-  paths @0;
-  settings @1;
+struct CustomReserved17 @0xa30662f84033036c {
 }
 
-struct MapdExtendedOut @0xa30662f84033036c {
-  type @0 :MapdExtendedOutType;
-  json @1 :Text;
+struct CustomReserved18 @0xc86a3d38d13eb3ef {
 }
 
-enum MapdInputType {
-  download @0;
-  setTargetLateralAccel @1;
-  setSpeedLimitOffset @2;
-  setSpeedLimitControl @3;
-  setCurveSpeedControl @4;
-  setVisionCurveSpeedControl @5;
-  setLogLevel @6;
-  setVisionCurveTargetLatA @7;
-  setVisionCurveMinTargetV @8;
-  reloadSettings @9;
-  saveSettings @10;
-  setEnableSpeed @11;
-  setVisionCurveUseEnableSpeed @12;
-  setCurveUseEnableSpeed @13;
-  setSpeedLimitUseEnableSpeed @14;
-  setHoldLastSeenSpeedLimit @15;
-  setCurveTargetJerk @16;
-  setCurveTargetAccel @17;
-  setCurveTargetOffset @18;
-  setDefaultLaneWidth @19;
-  setCurveTargetLatA @20;
-  loadDefaultSettings @21;
-  loadRecommendedSettings @22;
-  setSlowDownForNextSpeedLimit @23;
-  setSpeedUpForNextSpeedLimit @24;
-  setHoldSpeedLimitWhileChangingSetSpeed @25;
-}
-
-enum SpeedLimitOffsetType {
-  static @0;
-  percent @1;
-}
-
-struct MapdIn @0xc86a3d38d13eb3ef {
-  type @0 :MapdInputType;
-  float @1 :Float32;
-  str @2 :Text;
-  bool @3 :Bool;
-}
-
-enum RoadContext {
-  freeway @0;
-  city @1;
-  unknown @2;
-}
-
-struct MapdOut @0xa4f1eb3323f5f582 {
-  wayName @0 :Text;
-  wayRef @1 :Text;
-  roadName @2 :Text;
-  speedLimit @3 :Float32;
-  nextSpeedLimit @4 :Float32;
-  nextSpeedLimitDistance @5 :Float32;
-  hazard @6 :Text;
-  nextHazard @7 :Text;
-  nextHazardDistance @8 :Float32;
-  advisorySpeed @9 :Float32;
-  nextAdvisorySpeed @10 :Float32;
-  nextAdvisorySpeedDistance @11 :Float32;
-  oneWay @12 :Bool;
-  lanes @13 :UInt8;
-  tileLoaded @14 :Bool;
-  speedLimitOffset @15 :Float32;
-  suggestedSpeed @16 :Float32;
-  estimatedRoadWidth @17 :Float32;
-  roadContext @18 :RoadContext;
-  distanceFromWayCenter @19 :Float32;
-  visionCurveSpeed @20 :Float32;
-  curveSpeed @21 :Float32;
+struct CustomReserved19 @0xa4f1eb3323f5f582 {
 }

cereal/log.capnp

@@ -2639,9 +2639,9 @@ struct Event {
     customReserved14 @140 :Custom.CustomReserved14;
     customReserved15 @141 :Custom.CustomReserved15;
     customReserved16 @142 :Custom.CustomReserved16;
-    mapdExtendedOut @143 :Custom.MapdExtendedOut;
-    mapdIn @144 :Custom.MapdIn;
-    mapdOut @145 :Custom.MapdOut;
+    customReserved17 @143 :Custom.CustomReserved17;
+    customReserved18 @144 :Custom.CustomReserved18;
+    customReserved19 @145 :Custom.CustomReserved19;
 
     # *********** legacy + deprecated ***********
     model @9 :Legacy.ModelData; # TODO: rename modelV2 and mark this as deprecated

cereal/services.py

@@ -91,7 +91,6 @@ _services: dict[str, tuple] = {
   "modelDataV2SP": (True, 20.),
   "navigationd": (True, 3.),
   "liveLocationKalman": (True, 20.),
-  "mapdOut": (True, 20., 20),
 
   # debug
   "uiDebug": (True, 0., 1),

common/params_keys.h

@@ -130,8 +130,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"Version", {PERSISTENT, STRING}},
 
     // --- sunnypilot params --- //
-    {"AccelPersonality", {PERSISTENT | BACKUP, INT, std::to_string(static_cast<int>(cereal::LongitudinalPlanSP::AccelerationPersonality::NORMAL))}},
-    {"AccelPersonalityEnabled", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ApiCache_DriveStats", {PERSISTENT, JSON}},
     {"AutoLaneChangeBsmDelay", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"AutoLaneChangeTimer", {PERSISTENT | BACKUP, INT, "0"}},
@@ -148,7 +146,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"CustomAccShortPressIncrement", {PERSISTENT | BACKUP, INT, "1"}},
     {"DeviceBootMode", {PERSISTENT | BACKUP, INT, "0"}},
     {"DevUIInfo", {PERSISTENT | BACKUP, INT, "0"}},
-    {"DynamicFollow", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"EnableCopyparty", {PERSISTENT | BACKUP, BOOL}},
     {"EnableGithubRunner", {PERSISTENT | BACKUP, BOOL}},
     {"GreenLightAlert", {PERSISTENT | BACKUP, BOOL, "0"}},
@@ -171,19 +168,11 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"QuickBootToggle", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"QuietMode", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"RainbowMode", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"RoadEdgeLaneChangeEnabled", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ShowAdvancedControls", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"TrueVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},
 
-    // toyota specific params
-    {"ToyotaAutoHold", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaEnhancedBsm", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaTSS2Long", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaStockLongitudinal", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaDriveMode", {PERSISTENT | BACKUP, BOOL, "0"}},
-
     // MADS params
     {"Mads", {PERSISTENT | BACKUP, BOOL, "1"}},
     {"MadsMainCruiseAllowed", {PERSISTENT | BACKUP, BOOL, "1"}},
@@ -239,9 +228,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"LaneTurnDesire", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"LaneTurnValue", {PERSISTENT | BACKUP, FLOAT, "19.0"}},
 
-
-	  // mapd v020
-	  {"MapdSettings", {PERSISTENT | BACKUP, JSON}},
     // mapd
     {"MapAdvisorySpeedLimit", {CLEAR_ON_ONROAD_TRANSITION, FLOAT}},
     {"MapdVersion", {PERSISTENT, STRING}},

selfdrive/car/card.py

@@ -10,7 +10,7 @@ from cereal import car, log, custom
 from openpilot.common.params import Params
 from openpilot.common.realtime import config_realtime_process, Priority, Ratekeeper
 from openpilot.common.swaglog import cloudlog, ForwardingHandler
-from opendbc.safety import ALTERNATIVE_EXPERIENCE
+
 from opendbc.car import DT_CTRL, structs
 from opendbc.car.can_definitions import CanData, CanRecvCallable, CanSendCallable
 from opendbc.car.carlog import carlog
@@ -123,13 +123,7 @@ class Car:
       self.CI, self.CP, self.CP_SP = CI, CI.CP, CI.CP_SP
       self.RI = RI
 
-    # set alternative experiences from parameters
-    sp_toyota_auto_brake_hold = self.params.get_bool("ToyotaAutoHold")
     self.CP.alternativeExperience = 0
-    if sp_toyota_auto_brake_hold:
-      self.CP.alternativeExperience |= ALTERNATIVE_EXPERIENCE.ALLOW_AEB
-
-
     # mads
     set_alternative_experience(self.CP, self.CP_SP, self.params)
     set_car_specific_params(self.CP, self.CP_SP, self.params)

selfdrive/controls/lib/desire_helper.py

@@ -58,7 +58,7 @@ class DesireHelper:
   def get_lane_change_direction(CS):
     return LaneChangeDirection.left if CS.leftBlinker else LaneChangeDirection.right
 
-  def update(self, carstate, lateral_active, lane_change_prob, left_edge_detected, right_edge_detected):
+  def update(self, carstate, lateral_active, lane_change_prob):
     self.alc.update_params()
     self.lane_turn_controller.update_params()
     v_ego = carstate.vEgo
@@ -90,8 +90,8 @@ class DesireHelper:
                          ((carstate.steeringTorque > 0 and self.lane_change_direction == LaneChangeDirection.left) or
                           (carstate.steeringTorque < 0 and self.lane_change_direction == LaneChangeDirection.right))
 
-        blindspot_detected = (((carstate.leftBlindspot or left_edge_detected) and self.lane_change_direction == LaneChangeDirection.left) or
-                              ((carstate.rightBlindspot or right_edge_detected) and self.lane_change_direction == LaneChangeDirection.right))
+        blindspot_detected = ((carstate.leftBlindspot and self.lane_change_direction == LaneChangeDirection.left) or
+                              (carstate.rightBlindspot and self.lane_change_direction == LaneChangeDirection.right))
 
         self.alc.update_lane_change(blindspot_detected, carstate.brakePressed)
 

selfdrive/controls/lib/longitudinal_mpc_lib/long_mpc.py

@@ -10,8 +10,6 @@ from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.modeld.constants import index_function
 from openpilot.selfdrive.controls.radard import _LEAD_ACCEL_TAU
 
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_personality.accel_controller import AccelPersonalityController
-from openpilot.sunnypilot.selfdrive.controls.lib.dynamic_personality.dynamic_follow import FollowDistanceController
 if __name__ == '__main__':  # generating code
   from openpilot.third_party.acados.acados_template import AcadosModel, AcadosOcp, AcadosOcpSolver
 else:
@@ -230,8 +228,6 @@ class LongitudinalMpc:
     self.solver = AcadosOcpSolverCython(MODEL_NAME, ACADOS_SOLVER_TYPE, N)
     self.reset()
     self.source = SOURCES[2]
-    self.accel_controller = AccelPersonalityController()
-    self.dynamic_follow = FollowDistanceController()
 
   def reset(self):
     # self.solver = AcadosOcpSolverCython(MODEL_NAME, ACADOS_SOLVER_TYPE, N)
@@ -332,27 +328,10 @@ class LongitudinalMpc:
     return lead_xv
 
   def update(self, radarstate, v_cruise, x, v, a, j, personality=log.LongitudinalPersonality.standard):
+    t_follow = get_T_FOLLOW(personality)
     v_ego = self.x0[1]
-
-    if self.dynamic_follow.is_enabled():
-      t_follow = self.dynamic_follow.get_follow_distance_multiplier(v_ego)
-      #print(f"DEBUG: dynamic_follow enabled, t_follow={t_follow:.3f}, v_ego={v_ego:.2f}, v_cruise={v_cruise:.2f}")
-    else:
-      t_follow = get_T_FOLLOW(personality)
-      #print(f"DEBUG: dynamic_follow disabled, using personality t_follow={t_follow:.3f}, personality={personality}")
-
     self.status = radarstate.leadOne.status or radarstate.leadTwo.status
 
-    # Get acceleration limits
-    if self.accel_controller.is_enabled():
-      min_accel = self.accel_controller.get_min_accel(v_ego)
-      #print(f"DEBUG: accel_enabled=True, min_accel={min_accel:.3f}")
-    else:
-      min_accel = CRUISE_MIN_ACCEL
-      #print(f"DEBUG: accel_enabled=False, using stock min_accel={min_accel}")
-
-    a_cruise_min = min_accel
-
     lead_xv_0 = self.process_lead(radarstate.leadOne)
     lead_xv_1 = self.process_lead(radarstate.leadTwo)
 
@@ -371,7 +350,7 @@ class LongitudinalMpc:
 
       # Fake an obstacle for cruise, this ensures smooth acceleration to set speed
       # when the leads are no factor.
-      v_lower = v_ego + (T_IDXS * a_cruise_min * 1.05)
+      v_lower = v_ego + (T_IDXS * CRUISE_MIN_ACCEL * 1.05)
       # TODO does this make sense when max_a is negative?
       v_upper = v_ego + (T_IDXS * CRUISE_MAX_ACCEL * 1.05)
       v_cruise_clipped = np.clip(v_cruise * np.ones(N+1),

selfdrive/controls/lib/longitudinal_planner.py

@@ -124,13 +124,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
     prev_accel_constraint = not (reset_state or sm['carState'].standstill)
 
     if mode == 'acc':
-      if self.accel_controller.is_enabled():
-        max_accel = self.accel_controller.get_max_accel(v_ego)
-        #print(f"Vibe personality active - max accel: {max_accel:.3f}")
-        accel_clip = [ACCEL_MIN, max_accel]
-      else:
-        accel_clip = [ACCEL_MIN, get_max_accel(v_ego)]
-
+      accel_clip = [ACCEL_MIN, get_max_accel(v_ego)]
       steer_angle_without_offset = sm['carState'].steeringAngleDeg - sm['liveParameters'].angleOffsetDeg
       accel_clip = limit_accel_in_turns(v_ego, steer_angle_without_offset, accel_clip, self.CP)
     else:
@@ -155,10 +149,6 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
     # Get new v_cruise and a_desired from Smart Cruise Control and Speed Limit Assist
     v_cruise, self.a_desired = LongitudinalPlannerSP.update_targets(self, sm, self.v_desired_filter.x, self.a_desired, v_cruise)
 
-    if sm.valid['mapdOut']:
-      if sm['mapdOut'].suggestedSpeed > 0 and v_cruise > sm['mapdOut'].suggestedSpeed:
-        v_cruise = sm['mapdOut'].suggestedSpeed
-
     if force_slow_decel:
       v_cruise = 0.0
 

selfdrive/controls/plannerd.py

@@ -27,12 +27,12 @@ def main():
   longitudinal_planner = LongitudinalPlanner(CP, CP_SP)
   pm = messaging.PubMaster(['longitudinalPlan', 'driverAssistance', 'longitudinalPlanSP'])
   sm = messaging.SubMaster(['carControl', 'carState', 'controlsState', 'liveParameters', 'radarState', 'modelV2', 'selfdriveState',
-                            'liveMapDataSP', 'carStateSP', 'mapdOut', gps_location_service],
+                            'liveMapDataSP', 'carStateSP', gps_location_service],
                            poll='carState')
 
   while True:
     sm.update()
-    #longitudinal_planner.sla.update_car_state(sm['carState'])
+    longitudinal_planner.sla.update_car_state(sm['carState'])
     if sm.updated['modelV2']:
       longitudinal_planner.update(sm)
       longitudinal_planner.publish(sm, pm)

selfdrive/modeld/SConscript

@@ -51,8 +51,8 @@ def tg_compile(flags, model_name):
 for model_name in ['driving_vision', 'driving_policy', 'dmonitoring_model']:
   flags = {
     'larch64': 'DEV=QCOM',
-    'Darwin': f'DEV=CPU HOME={os.path.expanduser("~")} IMAGE=0', # tinygrad calls brew which needs a $HOME in the env
-  }.get(arch, 'DEV=CPU CPU_LLVM=1 IMAGE=0')
+    'Darwin': 'DEV=CPU IMAGE=0',
+  }.get(arch, 'DEV=LLVM IMAGE=0')
   tg_compile(flags, model_name)
 
 # Compile BIG model if USB GPU is available

selfdrive/modeld/dmonitoringmodeld.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import os
 from openpilot.system.hardware import TICI
-os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
+os.environ['DEV'] = 'QCOM' if TICI else 'LLVM'
 from tinygrad.tensor import Tensor
 from tinygrad.dtype import dtypes
 import math

selfdrive/modeld/modeld.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import os
 from openpilot.system.hardware import TICI
-os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
+os.environ['DEV'] = 'QCOM' if TICI else 'LLVM'
 USBGPU = "USBGPU" in os.environ
 if USBGPU:
   os.environ['DEV'] = 'AMD'
@@ -33,7 +33,7 @@ from openpilot.selfdrive.modeld.runners.tinygrad_helpers import qcom_tensor_from
 
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld.modeld_base import ModelStateBase
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
+
 
 PROCESS_NAME = "selfdrive.modeld.modeld"
 SEND_RAW_PRED = os.getenv('SEND_RAW_PRED')
@@ -298,7 +298,6 @@ def main(demo=False):
   prev_action = log.ModelDataV2.Action()
 
   DH = DesireHelper()
-  RELC = RoadEdgeLaneChangeController(params.get_bool("RoadEdgeLaneChangeEnabled"))
 
   while True:
     # Keep receiving frames until we are at least 1 frame ahead of previous extra frame
@@ -396,10 +395,7 @@ def main(demo=False):
       l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
       r_lane_change_prob = desire_state[log.Desire.laneChangeRight]
       lane_change_prob = l_lane_change_prob + r_lane_change_prob
-      RELC.update(modelv2_send.modelV2.roadEdgeStds, modelv2_send.modelV2.laneLineProbs)
-      mdv2sp_send.modelDataV2SP.leftLaneChangeEdgeBlock = RELC.left_edge_detected
-      mdv2sp_send.modelDataV2SP.rightLaneChangeEdgeBlock = RELC.right_edge_detected
-      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, RELC.left_edge_detected, RELC.right_edge_detected)
+      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob)
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction

selfdrive/selfdrived/selfdrived.py

@@ -88,7 +88,7 @@ class SelfdriveD(CruiseHelper):
     # TODO: de-couple selfdrived with card/conflate on carState without introducing controls mismatches
     self.car_state_sock = messaging.sub_sock('carState', timeout=20)
 
-    ignore = self.sensor_packets + self.gps_packets + ['alertDebug'] + ['modelDataV2SP'] + ['navigationd']
+    ignore = self.sensor_packets + self.gps_packets + ['alertDebug'] + ['modelDataV2SP']
     if SIMULATION:
       ignore += ['driverCameraState', 'managerState']
     if REPLAY:
@@ -98,7 +98,7 @@ class SelfdriveD(CruiseHelper):
                                    'carOutput', 'driverMonitoringState', 'longitudinalPlan', 'livePose', 'liveDelay',
                                    'managerState', 'liveParameters', 'radarState', 'liveTorqueParameters',
                                    'controlsState', 'carControl', 'driverAssistance', 'alertDebug', 'userBookmark', 'audioFeedback',
-                                   'modelDataV2SP', 'longitudinalPlanSP', 'navigationd'] + \
+                                   'modelDataV2SP', 'longitudinalPlanSP'] + \
                                   self.camera_packets + self.sensor_packets + self.gps_packets,
                                   ignore_alive=ignore, ignore_avg_freq=ignore,
                                   ignore_valid=ignore, frequency=int(1/DT_CTRL))
@@ -230,8 +230,8 @@ class SelfdriveD(CruiseHelper):
 
       # Disable on rising edge of accelerator or brake. Also disable on brake when speed > 0
       if (CS.gasPressed and not self.CS_prev.gasPressed and self.disengage_on_accelerator) or \
-            (CS.brakePressed and (not self.CS_prev.brakePressed or not CS.standstill)) or \
-            (CS.regenBraking and (not self.CS_prev.regenBraking or not CS.standstill)):
+        (CS.brakePressed and (not self.CS_prev.brakePressed or not CS.standstill)) or \
+        (CS.regenBraking and (not self.CS_prev.regenBraking or not CS.standstill)):
         self.events.add(EventName.pedalPressed)
 
     # Create events for temperature, disk space, and memory
@@ -292,15 +292,9 @@ class SelfdriveD(CruiseHelper):
     # Handle lane change
     if self.sm['modelV2'].meta.laneChangeState == LaneChangeState.preLaneChange:
       direction = self.sm['modelV2'].meta.laneChangeDirection
-      mdv2sp = self.sm['modelDataV2SP']
-
       if (CS.leftBlindspot and direction == LaneChangeDirection.left) or \
         (CS.rightBlindspot and direction == LaneChangeDirection.right):
         self.events.add(EventName.laneChangeBlocked)
-
-      elif mdv2sp.leftLaneChangeEdgeBlock or mdv2sp.rightLaneChangeEdgeBlock:
-        self.events_sp.add(custom.OnroadEventSP.EventName.laneChangeRoadEdge)
-
       else:
         if direction == LaneChangeDirection.left:
           self.events.add(EventName.preLaneChangeLeft)

selfdrive/ui/qt/offroad/settings.cc

@@ -33,42 +33,6 @@ TogglesPanel::TogglesPanel(SettingsWindow *parent) : ListWidget(parent) {
       "../assets/icons/experimental_white.svg",
       false,
     },
-    {
-      "ToyotaDriveMode",
-      tr("Enable drive mode btn link"),
-      tr("Links cars drive mode btn with accel personalities based on personality (i.e., relaxed, standard, sport)"),
-      "../assets/offroad/icon_blank.png",
-      false,
-    },
-    {
-      "ToyotaAutoHold",
-      tr("Toyota: Auto Brake Hold FOR TSS2 HYBRID CARS"),
-      tr("As you may auto brake hold currently supported by openpilot, this feature will allow sunnypilot to automatically hold the vehicle at a stop when the lead car is stopped. (TSS2 Hybird only)"),
-      "../assets/offroad/icon_blank.png",
-      false,
-    },
-    {
-      "ToyotaEnhancedBsm",
-      tr("Toyota: Prius TSS2 BSM and some tssp"),
-      tr("Add support for BSM."),
-      "../assets/offroad/icon_blank.png",
-      false,
-    },
-    {
-      "ToyotaTSS2Long",
-      tr("Toyota: custom tune"),
-      tr("idk something gas and brake"),
-      "../assets/offroad/icon_blank.png",
-      false,
-    },
-    {
-      "ToyotaStockLongitudinal",
-      tr("Toyota: Stock Toyota Longitudinal"),
-      tr("This feature will allow sunnypilot to use the stock Toyota longitudinal control instead of the sunnypilot longitudinal control. "
-         ""),
-      "../assets/offroad/icon_blank.png",
-      false,
-    },
     {
       "DisengageOnAccelerator",
       tr("Disengage on Accelerator Pedal"),
@@ -121,15 +85,7 @@ TogglesPanel::TogglesPanel(SettingsWindow *parent) : ListWidget(parent) {
                                              "your steering wheel distance button."),
                                           "../assets/icons/speed_limit.png",
                                           longi_button_texts);
-  // accel controller
-  std::vector<QString> accel_personality_texts{tr("Sport"), tr("Normal"), tr("Eco")};
-  accel_personality_setting = new ButtonParamControlSP("AccelPersonality", tr("Acceleration Personality"),
-                                          tr("Normal is recommended. In sport mode, sunnypilot will provide aggressive acceleration for a dynamic driving experience. "
-                                             "In eco mode, sunnypilot will apply smoother and more relaxed acceleration. On supported cars, you can cycle through these "
-                                             "acceleration personality within Onroad Settings on the driving screen."),
-                                          "",
-                                          accel_personality_texts);
-  accel_personality_setting->showDescription();
+
   // set up uiState update for personality setting
   QObject::connect(uiState(), &UIState::uiUpdate, this, &TogglesPanel::updateState);
 
@@ -157,7 +113,6 @@ TogglesPanel::TogglesPanel(SettingsWindow *parent) : ListWidget(parent) {
     // insert longitudinal personality after NDOG toggle
     if (param == "DisengageOnAccelerator") {
       addItem(long_personality_setting);
-      addItem(accel_personality_setting);
     }
   }
 
@@ -178,13 +133,6 @@ void TogglesPanel::updateState(const UIState &s) {
     }
     uiState()->scene.personality = personality;
   }
-  if (sm.updated("longitudinalPlanSP")) {
-    auto accel_personality = sm["longitudinalPlanSP"].getLongitudinalPlanSP().getAccelPersonality();
-    if (accel_personality != s.scene.accel_personality && s.scene.started && isVisible()) {
-      accel_personality_setting->setCheckedButton(static_cast<int>(accel_personality));
-    }
-    uiState()->scene.accel_personality = accel_personality;
-  }
 }
 
 void TogglesPanel::expandToggleDescription(const QString &param) {
@@ -231,12 +179,10 @@ void TogglesPanel::updateToggles() {
       experimental_mode_toggle->setEnabled(true);
       experimental_mode_toggle->setDescription(e2e_description);
       long_personality_setting->setEnabled(true);
-      accel_personality_setting->setEnabled(true);
     } else {
       // no long for now
       experimental_mode_toggle->setEnabled(false);
       long_personality_setting->setEnabled(false);
-      accel_personality_setting->setEnabled(true);
       params.remove("ExperimentalMode");
 
       const QString unavailable = tr("Experimental mode is currently unavailable on this car since the car's stock ACC is used for longitudinal control.");

selfdrive/ui/qt/offroad/settings.h

@@ -88,7 +88,6 @@ protected:
   Params params;
   std::map<std::string, ParamControl*> toggles;
   ButtonParamControl *long_personality_setting;
-  ButtonParamControl *accel_personality_setting;
 
   virtual void updateToggles();
 };

selfdrive/ui/qt/onroad/model.cc

@@ -22,7 +22,7 @@ void ModelRenderer::draw(QPainter &painter, const QRect &surface_rect) {
 
   update_model(model, lead_one);
   drawLaneLines(painter);
-  drawPath(painter, model, surface_rect.height(), surface_rect.width());
+  drawPath(painter, model, surface_rect.height());
 
   if (longitudinal_control && sm.alive("radarState")) {
     update_leads(radar_state, model.getPosition());
@@ -92,7 +92,7 @@ void ModelRenderer::drawLaneLines(QPainter &painter) {
   }
 }
 
-void ModelRenderer::drawPath(QPainter &painter, const cereal::ModelDataV2::Reader &model, int height, int width) {
+void ModelRenderer::drawPath(QPainter &painter, const cereal::ModelDataV2::Reader &model, int height) {
   QLinearGradient bg(0, height, 0, 0);
   if (experimental_mode) {
     // The first half of track_vertices are the points for the right side of the path
@@ -127,9 +127,6 @@ void ModelRenderer::drawPath(QPainter &painter, const cereal::ModelDataV2::Reade
 
   painter.setBrush(bg);
   painter.drawPolygon(track_vertices);
-
-  //LongFuel(painter,height, width);
-  //LateralFuel(painter, height, width);
 }
 
 void ModelRenderer::updatePathGradient(QLinearGradient &bg) {
@@ -176,195 +173,6 @@ QColor ModelRenderer::blendColors(const QColor &start, const QColor &end, float
       (1 - t) * start.alphaF() + t * end.alphaF());
 }
 
-void ModelRenderer::drawGaugeBackground(QPainter &painter, qreal centerX, qreal centerY) {
-    const qreal backgroundSize = GAUGE_SIZE * BACKGROUND_SIZE_MULTIPLIER;
-
-    // Draw circular background
-    painter.setPen(Qt::NoPen);
-    painter.setBrush(BACKGROUND_COLOR);
-    painter.drawEllipse(QPointF(centerX, centerY), backgroundSize / 2, backgroundSize / 2);
-
-    // Draw border
-    QPen borderPen(BORDER_COLOR);
-    borderPen.setWidth(BORDER_PEN_WIDTH);
-    painter.setPen(borderPen);
-    painter.drawEllipse(QPointF(centerX, centerY), backgroundSize / 2 + 1, backgroundSize / 2 + 1);
-
-    // Draw background semicircle
-    QPen semicirclePen(GAUGE_BACKGROUND_COLOR);
-    semicirclePen.setWidth(GAUGE_PEN_WIDTH);
-    semicirclePen.setCapStyle(Qt::RoundCap);
-    painter.setPen(semicirclePen);
-    painter.drawArc(QRectF(centerX - GAUGE_SIZE / 2, centerY - GAUGE_SIZE / 2,
-                          GAUGE_SIZE, GAUGE_SIZE), 0, SEMICIRCLE_SPAN);
-}
-
-QColor ModelRenderer::getIndicatorColor(float absoluteValue, float lowThreshold, float highThreshold) {
-    if (absoluteValue < lowThreshold) {
-        return LOW_INDICATOR_COLOR;
-    } else if (absoluteValue < highThreshold) {
-        return MODERATE_INDICATOR_COLOR;
-    } else {
-        return HIGH_INDICATOR_COLOR;
-    }
-}
-
-int ModelRenderer::calculateSpanAngle(float absoluteValue, float maxValue) {
-    const int spanAngle = static_cast<int>(QUARTER_CIRCLE_SPAN * (absoluteValue / maxValue));
-    return std::clamp(spanAngle, 0, QUARTER_CIRCLE_SPAN);
-}
-
-void ModelRenderer::drawGaugeArc(QPainter &painter, qreal centerX, qreal centerY,
-                                float value, bool isPositive, const QString &label) {
-    const float absoluteValue = std::abs(value);
-
-    if (absoluteValue <= MIN_THRESHOLD) {
-        return; // Skip drawing if value is too small
-    }
-
-    // Set up the arc rectangle
-    const QRectF arcRect(centerX - GAUGE_SIZE / 2, centerY - GAUGE_SIZE / 2,
-                        GAUGE_SIZE, GAUGE_SIZE);
-
-    // Configure pen for the indicator arc
-    QPen indicatorPen;
-    indicatorPen.setWidth(GAUGE_PEN_WIDTH);
-    indicatorPen.setCapStyle(Qt::RoundCap);
-    painter.setPen(indicatorPen);
-
-    // Draw the arc based on direction
-    const int spanAngle = calculateSpanAngle(absoluteValue, 1.0f); // Adjust max value as needed
-    if (isPositive) {
-        painter.drawArc(arcRect, STARTING_ANGLE, spanAngle);
-    } else {
-        painter.drawArc(arcRect, STARTING_ANGLE, -spanAngle);
-    }
-
-    // Draw center label
-    painter.setPen(Qt::white);
-    QFont font = painter.font();
-    font.setPixelSize(20);
-    font.setBold(true);
-    painter.setFont(font);
-    painter.drawText(QRectF(centerX - 50, centerY + 10, 100, 20), Qt::AlignCenter, label);
-}
-
-void ModelRenderer::LongFuel(QPainter &painter, int height, int width) {
-    const qreal rectWidth = static_cast<qreal>(width);
-    const qreal rectHeight = static_cast<qreal>(height);
-
-    UIState *s = uiState();
-    if (!s || !s->sm) {
-        return; // Safety check
-    }
-
-    // Get current acceleration
-    const float currentAcceleration = (*s->sm)["carControl"].getCarControl().getActuators().getAccel();
-    const float absoluteAcceleration = std::abs(currentAcceleration);
-
-    // Calculate gauge position
-    const qreal centerX = rectWidth / 17;
-    const qreal centerY = rectHeight / 2 + 120;
-
-    // Draw gauge background
-    drawGaugeBackground(painter, centerX, centerY);
-
-    // Skip drawing arc if acceleration is too small
-    if (absoluteAcceleration <= MIN_THRESHOLD) {
-        drawGaugeArc(painter, centerX, centerY, 0.0f, true, "LONG");
-        return;
-    }
-
-    // Determine indicator color based on acceleration magnitude
-    const QColor indicatorColor = getIndicatorColor(absoluteAcceleration, 0.3f, 0.6f);
-
-    // Calculate span angle (scale for better visibility)
-    const int spanAngle = static_cast<int>(QUARTER_CIRCLE_SPAN * absoluteAcceleration);
-    const int clampedSpanAngle = std::clamp(spanAngle, 0, QUARTER_CIRCLE_SPAN);
-
-    // Draw the acceleration arc
-    QPen indicatorPen(indicatorColor);
-    indicatorPen.setWidth(GAUGE_PEN_WIDTH);
-    indicatorPen.setCapStyle(Qt::RoundCap);
-    painter.setPen(indicatorPen);
-
-    const QRectF arcRect(centerX - GAUGE_SIZE / 2, centerY - GAUGE_SIZE / 2,
-                        GAUGE_SIZE, GAUGE_SIZE);
-
-    // Draw arc based on acceleration direction
-    if (currentAcceleration > 0) {
-        painter.drawArc(arcRect, STARTING_ANGLE, -clampedSpanAngle); // Left side for positive
-    } else {
-        painter.drawArc(arcRect, STARTING_ANGLE, clampedSpanAngle);  // Right side for negative
-    }
-
-    // Draw center label
-    painter.setPen(Qt::white);
-    QFont font = painter.font();
-    font.setPixelSize(20);
-    font.setBold(true);
-    painter.setFont(font);
-    painter.drawText(QRectF(centerX - 50, centerY + 10, 100, 20), Qt::AlignCenter, "LONG");
-}
-
-void ModelRenderer::LateralFuel(QPainter &painter, int height, int width) {
-    const qreal rectWidth = static_cast<qreal>(width);
-    const qreal rectHeight = static_cast<qreal>(height);
-
-    UIState *s = uiState();
-    if (!s || !s->sm) {
-        return; // Safety check
-    }
-
-    // Get current steering angle
-    const float currentLateral = (*s->sm)["carState"].getCarState().getSteeringAngleDeg();
-    const float absoluteLateral = std::abs(currentLateral);
-
-    // Calculate gauge position
-    const qreal centerX = rectWidth / 17;
-    const qreal centerY = rectHeight / 2 - 120;
-
-    // Draw gauge background
-    drawGaugeBackground(painter, centerX, centerY);
-
-    // Skip drawing arc if lateral force is too small
-    if (absoluteLateral <= 0.1f) {
-        drawGaugeArc(painter, centerX, centerY, 0.0f, true, "LAT");
-        return;
-    }
-
-    // Determine indicator color based on lateral force magnitude
-    const QColor indicatorColor = getIndicatorColor(absoluteLateral, 5.0f, 15.0f);
-
-    // Calculate span angle (normalized to max expected steering angle)
-    const float maxSteeringAngle = 15.0f; // Adjust based on your vehicle's characteristics
-    const int spanAngle = static_cast<int>(QUARTER_CIRCLE_SPAN * (absoluteLateral / maxSteeringAngle));
-    const int clampedSpanAngle = std::clamp(spanAngle, 0, QUARTER_CIRCLE_SPAN);
-
-    // Draw the lateral arc
-    QPen indicatorPen(indicatorColor);
-    indicatorPen.setWidth(GAUGE_PEN_WIDTH);
-    indicatorPen.setCapStyle(Qt::RoundCap);
-    painter.setPen(indicatorPen);
-
-    const QRectF arcRect(centerX - GAUGE_SIZE / 2, centerY - GAUGE_SIZE / 2,
-                        GAUGE_SIZE, GAUGE_SIZE);
-
-    // Draw arc based on steering direction
-    if (currentLateral < 0) {
-        painter.drawArc(arcRect, STARTING_ANGLE, -clampedSpanAngle); // Left turn
-    } else {
-        painter.drawArc(arcRect, STARTING_ANGLE, clampedSpanAngle);  // Right turn
-    }
-
-    // Draw center label
-    painter.setPen(Qt::white);
-    QFont font = painter.font();
-    font.setPixelSize(20);
-    font.setBold(true);
-    painter.setFont(font);
-    painter.drawText(QRectF(centerX - 50, centerY + 10, 100, 20), Qt::AlignCenter, "LAT");
-}
 void ModelRenderer::drawLead(QPainter &painter, const cereal::RadarState::LeadData::Reader &lead_data,
                              const QPointF &vd, const QRect &surface_rect) {
   const float speedBuff = 10.;

selfdrive/ui/qt/onroad/model.h

@@ -29,8 +29,6 @@ public:
   ModelRenderer() {}
   void setTransform(const Eigen::Matrix3f &transform) { car_space_transform = transform; }
   void draw(QPainter &painter, const QRect &surface_rect);
-  void LongFuel(QPainter &p, int height, int width);
-  void LateralFuel(QPainter &p, int height, int width);
 
 protected:
   bool mapToScreen(float in_x, float in_y, float in_z, QPointF *out);
@@ -40,16 +38,7 @@ protected:
   void update_leads(const cereal::RadarState::Reader &radar_state, const cereal::XYZTData::Reader &line);
   virtual void update_model(const cereal::ModelDataV2::Reader &model, const cereal::RadarState::LeadData::Reader &lead);
   void drawLaneLines(QPainter &painter);
-  void drawPath(QPainter &painter, const cereal::ModelDataV2::Reader &model, int height, int width);
-
-  // Gauge helper methods
-  void drawGaugeBackground(QPainter &painter, qreal centerX, qreal centerY);
-  void drawGaugeArc(QPainter &painter, qreal centerX, qreal centerY,
-                    float value, bool isPositive, const QString &label);
-  QColor getIndicatorColor(float absoluteValue, float lowThreshold, float highThreshold);
-  int calculateSpanAngle(float absoluteValue, float maxValue);
-
-
+  void drawPath(QPainter &painter, const cereal::ModelDataV2::Reader &model, int height);
   void updatePathGradient(QLinearGradient &bg);
   QColor blendColors(const QColor &start, const QColor &end, float t);
 
@@ -66,22 +55,4 @@ protected:
   QPointF lead_vertices[2] = {};
   Eigen::Matrix3f car_space_transform = Eigen::Matrix3f::Zero();
   QRectF clip_region;
-
-  // Gauge configuration constants
-  static constexpr qreal GAUGE_SIZE = 140.0;
-  static constexpr qreal BACKGROUND_SIZE_MULTIPLIER = 1.4;
-  static constexpr qreal GAUGE_PEN_WIDTH = 30.0;
-  static constexpr qreal BORDER_PEN_WIDTH = 2.0;
-  static constexpr int SEMICIRCLE_SPAN = 180 * 16;
-  static constexpr int QUARTER_CIRCLE_SPAN = 90 * 16;
-  static constexpr int STARTING_ANGLE = 90 * 16;
-  static constexpr qreal MIN_THRESHOLD = 0.01;
-
-  // Color constants - Note: QColor cannot be constexpr, use inline static const instead
-  inline static const QColor BACKGROUND_COLOR = QColor(0, 0, 0, 80);
-  inline static const QColor BORDER_COLOR = QColor(0, 0, 0, 100);
-  inline static const QColor GAUGE_BACKGROUND_COLOR = QColor(50, 50, 50);
-  inline static const QColor LOW_INDICATOR_COLOR = QColor(23, 241, 66, 200);
-  inline static const QColor MODERATE_INDICATOR_COLOR = QColor(255, 166, 0, 200);
-  inline static const QColor HIGH_INDICATOR_COLOR = QColor(245, 0, 0, 200);
 };

selfdrive/ui/sunnypilot/qt/offroad/settings/lateral/lane_change_settings.cc

@@ -33,12 +33,6 @@ LaneChangeSettings::LaneChangeSettings(QWidget* parent) : QWidget(parent) {
       tr("Toggle to enable a delay timer for seamless lane changes when blind spot monitoring (BSM) detects a obstructing vehicle, ensuring safe maneuvering."),
       "../assets/offroad/icon_blank.png",
     },
-    {
-      "RoadEdgeLaneChangeEnabled",
-      tr("Block Lane Change: Road Edge Detection"),
-      tr("Enable this toggle to block lane change when road edge is detected on the stalk actuated side."),
-      "../assets/offroad/icon_blank.png",
-    }
   };
 
   // Controls: Auto Lane Change Timer

selfdrive/ui/sunnypilot/qt/offroad/settings/longitudinal_panel.cc

@@ -75,22 +75,6 @@ LongitudinalPanel::LongitudinalPanel(QWidget *parent) : QWidget(parent) {
 
   QObject::connect(uiState(), &UIState::offroadTransition, this, &LongitudinalPanel::refresh);
 
-  // Acceleration Personality
-  AccelPersonalityControl = new ParamControlSP("AccelPersonalityEnabled",
-    tr("Acceleration Personality"),
-    tr("Controls acceleration behavior: Eco (efficient), Normal (balanced), Sport (responsive). "
-      "Adjust how aggressively the vehicle accelerates while maintaining smooth operation."),
-    "../assets/offroad/icon_shell.png");
-  list->addItem(AccelPersonalityControl);
-
-  // Dynamic Personality
-  DynamicPersonalityControl = new ParamControlSP("DynamicFollow",
-    tr("Following Distance Personality"),
-    tr("Controls following distance and braking behavior: Relaxed (longer distance, gentler braking), Standard (balanced), Aggressive (shorter distance, firmer braking). "
-      "Fine-tune your comfort level in traffic situations."),
-    "../assets/offroad/icon_shell.png");
-  list->addItem(DynamicPersonalityControl);
-
   speedLimitSettings = new PushButtonSP(tr("Speed Limit"), 750, this);
   connect(speedLimitSettings, &QPushButton::clicked, [&]() {
     cruisePanelScroller->setLastScrollPosition();
@@ -180,10 +164,6 @@ void LongitudinalPanel::refresh(bool _offroad) {
     dynamicExperimentalControl->refresh();
     SmartCruiseControlVision->refresh();
     SmartCruiseControlMap->refresh();
-    AccelPersonalityControl->setEnabled(true);
-    DynamicPersonalityControl->setEnabled(true);
-    AccelPersonalityControl->refresh();
-    DynamicPersonalityControl->refresh();
   } else {
     has_longitudinal_control = false;
     is_pcm_cruise = false;

selfdrive/ui/sunnypilot/qt/offroad/settings/longitudinal_panel.h

@@ -36,9 +36,6 @@ private:
   ParamControl *SmartCruiseControlMap;
   ParamControl *intelligentCruiseButtonManagement = nullptr;
   ParamControl *dynamicExperimentalControl = nullptr;
-
-  ParamControlSP *AccelPersonalityControl;
-  ParamControlSP *DynamicPersonalityControl;
   SpeedLimitSettings *speedLimitScreen;
   PushButtonSP *speedLimitSettings;
 };

selfdrive/ui/sunnypilot/qt/onroad/hud.cc

@@ -44,6 +44,8 @@ void HudRendererSP::updateState(const UIState &s) {
   const auto car_params = sm["carParams"].getCarParams();
   const auto car_params_sp = sm["carParamsSP"].getCarParamsSP();
   const auto lp_sp = sm["longitudinalPlanSP"].getLongitudinalPlanSP();
+  const auto lmd = sm["liveMapDataSP"].getLiveMapDataSP();
+
   if (sm.updated("carParams")) {
     steerControlType = car_params.getSteerControlType();
   }
@@ -52,80 +54,37 @@ void HudRendererSP::updateState(const UIState &s) {
     pcmCruiseSpeed = car_params_sp.getPcmCruiseSpeed();
   }
 
-  if (sm.alive("mapdOut") && sm.rcv_frame("mapdOut") > 0) {
-    const auto mapd = sm["mapdOut"].getMapdOut();
-
-    // Road name can come from wayName, wayRef, or roadName
-    wayName = QString::fromStdString(mapd.getWayName());
-    wayRef = QString::fromStdString(mapd.getWayRef());
-    QString mapdRoadName = QString::fromStdString(mapd.getRoadName());
-
-    if (!mapdRoadName.isEmpty()) {
-      roadNameStr = mapdRoadName;
-    } else if (!wayRef.isEmpty() && !wayName.isEmpty()) {
-      roadNameStr = wayRef + " - " + wayName;
-    } else if (!wayName.isEmpty()) {
-      roadNameStr = wayName;
-    } else if (!wayRef.isEmpty()) {
-      roadNameStr = wayRef;
-    } else {
-      roadNameStr = "";
-    }
-
+  if (sm.updated("longitudinalPlanSP")) {
+    speedLimit = lp_sp.getSpeedLimit().getResolver().getSpeedLimit() * speedConv;
+    speedLimitLast = lp_sp.getSpeedLimit().getResolver().getSpeedLimitLast() * speedConv;
+    speedLimitOffset = lp_sp.getSpeedLimit().getResolver().getSpeedLimitOffset() * speedConv;
+    speedLimitValid = lp_sp.getSpeedLimit().getResolver().getSpeedLimitValid();
+    speedLimitLastValid = lp_sp.getSpeedLimit().getResolver().getSpeedLimitLastValid();
+    speedLimitFinalLast = lp_sp.getSpeedLimit().getResolver().getSpeedLimitFinalLast() * speedConv;
+    speedLimitSource = lp_sp.getSpeedLimit().getResolver().getSource();
+    speedLimitAssistState = lp_sp.getSpeedLimit().getAssist().getState();
+    speedLimitAssistActive = lp_sp.getSpeedLimit().getAssist().getActive();
+    smartCruiseControlVisionEnabled = lp_sp.getSmartCruiseControl().getVision().getEnabled();
+    smartCruiseControlVisionActive = lp_sp.getSmartCruiseControl().getVision().getActive();
+    smartCruiseControlMapEnabled = lp_sp.getSmartCruiseControl().getMap().getEnabled();
+    smartCruiseControlMapActive = lp_sp.getSmartCruiseControl().getMap().getActive();
+  }
   greenLightAlert = lp_sp.getE2eAlerts().getGreenLightAlert();
   leadDepartAlert = lp_sp.getE2eAlerts().getLeadDepartAlert();
 
-    tileLoaded = mapd.getTileLoaded();
-
-    float mapdSpeedLimitRaw = mapd.getSpeedLimit();
-    float mapdOffsetRaw = mapd.getSpeedLimitOffset();
-
-
-    mapdSpeedLimit = mapdSpeedLimitRaw * speedConv;
-    speedLimit = mapdSpeedLimit;
-    speedLimitLast = mapdSpeedLimit;
-    speedLimitOffset = mapdOffsetRaw * speedConv;
-    speedLimitValid = tileLoaded && mapdSpeedLimitRaw > 0;
-    speedLimitLastValid = speedLimitValid;
-    speedLimitFinalLast = mapdSpeedLimit + speedLimitOffset;
-
-    if (tileLoaded) {
-      speedLimitSource = 1;  // MAP
-    } else {
-      speedLimitSource = 0;  // NONE
-    }
-
-    float nextSpeedLimitRaw = mapd.getNextSpeedLimit();
-    speedLimitAheadValid = nextSpeedLimitRaw > 0 && tileLoaded;
-    speedLimitAhead = nextSpeedLimitRaw * speedConv;
-    speedLimitAheadDistance = mapd.getNextSpeedLimitDistance();
-
+  if (sm.updated("liveMapDataSP")) {
+    roadNameStr = QString::fromStdString(lmd.getRoadName());
+    speedLimitAheadValid = lmd.getSpeedLimitAheadValid();
+    speedLimitAhead = lmd.getSpeedLimitAhead() * speedConv;
+    speedLimitAheadDistance = lmd.getSpeedLimitAheadDistance();
     if (speedLimitAheadDistance < speedLimitAheadDistancePrev && speedLimitAheadValidFrame < SPEED_LIMIT_AHEAD_VALID_FRAME_THRESHOLD) {
       speedLimitAheadValidFrame++;
     } else if (speedLimitAheadDistance > speedLimitAheadDistancePrev && speedLimitAheadValidFrame > 0) {
       speedLimitAheadValidFrame--;
     }
-
-    // SCC data from mapd
-    suggestedSpeed = mapd.getSuggestedSpeed() * speedConv;
-    visionCurveSpeed = mapd.getVisionCurveSpeed() * speedConv;
-    curveSpeed = mapd.getCurveSpeed() * speedConv;
-
-    smartCruiseControlVisionEnabled = visionCurveSpeed > 0;
-    smartCruiseControlVisionActive = visionCurveSpeed > 0 && visionCurveSpeed < speedLimit;
-
-    smartCruiseControlMapEnabled = curveSpeed > 0;
-    smartCruiseControlMapActive = curveSpeed > 0 && curveSpeed < speedLimit;
-
-    advisorySpeed = mapd.getAdvisorySpeed() * speedConv;
-    nextAdvisorySpeed = mapd.getNextAdvisorySpeed() * speedConv;
-    nextAdvisorySpeedDistance = mapd.getNextAdvisorySpeedDistance();
   }
   speedLimitAheadDistancePrev = speedLimitAheadDistance;
 
-  speedLimitAssistState = 0;
-  speedLimitAssistActive = false;
-
   static int reverse_delay = 0;
   bool reverse_allowed = false;
   if (car_state.getGearShifter() != cereal::CarState::GearShifter::REVERSE) {
@@ -149,7 +108,7 @@ void HudRendererSP::updateState(const UIState &s) {
   }
 
   if (sm.updated(gps_source)) {
-    gpsAccuracy = is_gps_location_external ? gpsLocation.getHorizontalAccuracy() : 1.0;
+    gpsAccuracy = is_gps_location_external ? gpsLocation.getHorizontalAccuracy() : 1.0;  // External reports accuracy, internal does not.
     altitude = gpsLocation.getAltitude();
     bearingAccuracyDeg = gpsLocation.getBearingAccuracyDeg();
     bearingDeg = gpsLocation.getBearingDeg();
@@ -217,7 +176,12 @@ void HudRendererSP::updateState(const UIState &s) {
             navigationDistance = QString::number(std::round(dist / 50.0) * 50) + " m";
           }
         } else {
-          navigationDistance = QString::number(dist / 1000, 'f', 1) + " km";
+          float dist_km = dist / 1000;
+          if (dist_km >= 10.0) {
+            navigationDistance = QString::number(std::floor(dist_km)) + " km";
+          } else {
+            navigationDistance = QString::number(dist_km, 'f', 1) + " km";
+          }
         }
       } else {
         float dist_ft = dist * 3.28084f;
@@ -229,7 +193,12 @@ void HudRendererSP::updateState(const UIState &s) {
             navigationDistance = QString::number((std::round(dist_ft / 50.0) * 50)) + " ft";
           }
         } else {
-          navigationDistance = QString::number(dist_ft / 5280, 'f', 1) + " mi";
+          float dist_mi = dist_ft / 5280;
+          if (dist_mi >= 10.0) {
+            navigationDistance = QString::number(std::floor(dist_mi)) + " mi";
+          } else {
+            navigationDistance = QString::number(dist_mi, 'f', 1) + " mi";
+          }
         }
       }
 
@@ -323,7 +292,7 @@ void HudRendererSP::draw(QPainter &p, const QRect &surface_rect) {
     const int sign_height = 204;
     QRect sign_rect(sign_x, sign_y, sign_width, sign_height);
 
-    if (speedLimitAssistState == 1) {
+    if (speedLimitAssistState == cereal::LongitudinalPlanSP::SpeedLimit::AssistState::PRE_ACTIVE) {
       speedLimitAssistFrame++;
       showSpeedLimit = speed_limit_assist_pre_active_pulse;
       drawSpeedLimitPreActiveArrow(p, sign_rect);
@@ -336,7 +305,7 @@ void HudRendererSP::draw(QPainter &p, const QRect &surface_rect) {
       drawSpeedLimitSigns(p, sign_rect);
 
       // do not show during SLA's preActive state
-      if (speedLimitAssistState != 1) {
+      if (speedLimitAssistState != cereal::LongitudinalPlanSP::SpeedLimit::AssistState::PRE_ACTIVE) {
         drawUpcomingSpeedLimit(p);
       }
     }
@@ -676,7 +645,7 @@ void HudRendererSP::drawSpeedLimitSigns(QPainter &p, QRect &sign_rect) {
 
 void HudRendererSP::drawUpcomingSpeedLimit(QPainter &p) {
   bool speed_limit_ahead = speedLimitAheadValid && speedLimitAhead > 0 && speedLimitAhead != speedLimit && speedLimitAheadValidFrame > 0 &&
-                           tileLoaded;
+                           speedLimitSource == cereal::LongitudinalPlanSP::SpeedLimit::Source::MAP;
   if (!speed_limit_ahead) {
     return;
   }
@@ -1127,10 +1096,15 @@ void HudRendererSP::drawNavigationHUD(QPainter &p, const QRect &surface_rect) {
 
   const int container_width = 1080;
   const int container_height = 225;
-  const int container_x = (surface_rect.width() - container_width) / 2;
+  int container_x = (surface_rect.width() - container_width) / 2;
   const int container_y = 62;
   const int border_radius = 42;
 
+
+  if (speedLimitAssistState == cereal::LongitudinalPlanSP::SpeedLimit::AssistState::PRE_ACTIVE) {
+    container_x += 190;
+  }
+
   QRect container_rect(container_x, container_y, container_width, container_height);
 
   p.setPen(Qt::NoPen);
@@ -1153,7 +1127,7 @@ void HudRendererSP::drawNavigationHUD(QPainter &p, const QRect &surface_rect) {
   // Distance
   p.setFont(InterFont(48, QFont::Bold));
   p.setPen(Qt::white);
-  QRect distance_rect(icon_x, icon_y + icon_size, icon_size, 38);
+  QRect distance_rect(icon_x - 25, icon_y + icon_size, icon_size + 50, 38);
   p.drawText(distance_rect, Qt::AlignCenter, navigationDistance);
 
   const int then_section_width = 180;

selfdrive/ui/sunnypilot/qt/onroad/hud.h

@@ -85,7 +85,7 @@ private:
   bool speedLimitValid;
   bool speedLimitLastValid;
   float speedLimitFinalLast;
-  int speedLimitSource;  // 0=NONE, 1=MAP
+  cereal::LongitudinalPlanSP::SpeedLimit::Source speedLimitSource;
   bool speedLimitAheadValid;
   float speedLimitAhead;
   float speedLimitAheadDistance;
@@ -94,7 +94,7 @@ private:
   SpeedLimitMode speedLimitMode = SpeedLimitMode::OFF;
   bool roadName;
   QString roadNameStr;
-  int speedLimitAssistState;  // 0=NONE, 1=PRE_ACTIVE, etc.
+  cereal::LongitudinalPlanSP::SpeedLimit::AssistState speedLimitAssistState;
   bool speedLimitAssistActive;
   int speedLimitAssistFrame;
   QPixmap plus_arrow_up_img;
@@ -131,15 +131,4 @@ private:
   QString navigationNextModifier;
   QString navigationNextManeuverType;
   bool navigationHasNext;
-
-  QString wayName;
-  QString wayRef;
-  float mapdSpeedLimit;
-  float advisorySpeed;
-  float nextAdvisorySpeed;
-  float nextAdvisorySpeedDistance;
-  float suggestedSpeed;
-  float visionCurveSpeed;
-  float curveSpeed;
-  bool tileLoaded;
 };

selfdrive/ui/sunnypilot/qt/onroad/model.cc

@@ -48,7 +48,7 @@ void ModelRendererSP::draw(QPainter &painter, const QRect &surface_rect) {
   if (s->scene.rainbow_mode) {
     drawRainbowPath(painter, surface_rect);
   } else {
-    ModelRenderer::drawPath(painter, model, surface_rect.height(), surface_rect.width());
+    ModelRenderer::drawPath(painter, model, surface_rect.height());
   }
 
   if (longitudinal_control && sm.alive("radarState")) {

selfdrive/ui/sunnypilot/ui.cc

@@ -29,8 +29,7 @@ UIStateSP::UIStateSP(QObject *parent) : UIState(parent) {
     "wideRoadCameraState", "managerState", "selfdriveState", "longitudinalPlan",
     "modelManagerSP", "selfdriveStateSP", "longitudinalPlanSP", "backupManagerSP",
     "carControl", "gpsLocationExternal", "gpsLocation", "liveTorqueParameters",
-    "carStateSP", "liveParameters", "liveMapDataSP", "carParamsSP", "navigationd",
-    "mapdOut"
+    "carStateSP", "liveParameters", "liveMapDataSP", "carParamsSP", "navigationd"
   });
 
   // update timer

selfdrive/ui/ui.h

@@ -60,7 +60,6 @@ typedef struct UIScene {
   cereal::PandaState::PandaType pandaType;
 
   cereal::LongitudinalPersonality personality;
-  cereal::LongitudinalPlanSP::AccelerationPersonality accel_personality;
 
   float light_sensor = -1;
   bool started, ignition, is_metric, recording_audio;

sunnypilot/modeld/modeld.py

@@ -28,7 +28,6 @@ from openpilot.sunnypilot.modeld.constants import ModelConstants, Plan
 from openpilot.sunnypilot.models.helpers import get_active_bundle, get_model_path, load_metadata, prepare_inputs, load_meta_constants
 from openpilot.sunnypilot.modeld.models.commonmodel_pyx import ModelFrame, CLContext
 from openpilot.sunnypilot.modeld.modeld_base import ModelStateBase
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
 
 
 PROCESS_NAME = "selfdrive.modeld.modeld_snpe"
@@ -210,7 +209,6 @@ def main(demo=False):
   prev_action = log.ModelDataV2.Action()
 
   DH = DesireHelper()
-  RELC = RoadEdgeLaneChangeController(params.get_bool("RoadEdgeLaneChangeEnabled"))
 
   while True:
     # Keep receiving frames until we are at least 1 frame ahead of previous extra frame
@@ -316,10 +314,7 @@ def main(demo=False):
       l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
       r_lane_change_prob = desire_state[log.Desire.laneChangeRight]
       lane_change_prob = l_lane_change_prob + r_lane_change_prob
-      RELC.update(modelv2_send.modelV2.roadEdgeStds, modelv2_send.modelV2.laneLineProbs)
-      mdv2sp_send.modelDataV2SP.leftLaneChangeEdgeBlock = RELC.left_edge_detected
-      mdv2sp_send.modelDataV2SP.rightLaneChangeEdgeBlock = RELC.right_edge_detected
-      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, RELC.left_edge_detected, RELC.right_edge_detected)
+      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob)
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction

sunnypilot/modeld_v2/modeld.py

@@ -26,7 +26,6 @@ from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld.modeld_base import ModelStateBase
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 from openpilot.sunnypilot.models.runners.helpers import get_model_runner
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
 
 PROCESS_NAME = "selfdrive.modeld.modeld_tinygrad"
 
@@ -240,9 +239,6 @@ def main(demo=False):
   prev_action = log.ModelDataV2.Action()
 
   DH = DesireHelper()
-  RELC = RoadEdgeLaneChangeController(params.get_bool("RoadEdgeLaneChangeEnabled"))
-
-
 
   while True:
     # Keep receiving frames until we are at least 1 frame ahead of previous extra frame
@@ -344,10 +340,7 @@ def main(demo=False):
       l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
       r_lane_change_prob = desire_state[log.Desire.laneChangeRight]
       lane_change_prob = l_lane_change_prob + r_lane_change_prob
-      RELC.update(modelv2_send.modelV2.roadEdgeStds, modelv2_send.modelV2.laneLineProbs)
-      mdv2sp_send.modelDataV2SP.leftLaneChangeEdgeBlock = RELC.left_edge_detected
-      mdv2sp_send.modelDataV2SP.rightLaneChangeEdgeBlock = RELC.right_edge_detected
-      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, RELC.left_edge_detected, RELC.right_edge_detected)
+      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob)
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction

sunnypilot/models/fetcher.py

@@ -116,7 +116,7 @@ class ModelCache:
 
 class ModelFetcher:
   """Handles fetching and caching of model data from remote source"""
-  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-docs/refs/heads/gh-pages/docs/driving_models_v9.json"
+  MODEL_URL = "https://docs.sunnypilot.ai/driving_models_v8.json"
 
   def __init__(self, params: Params):
     self.params = params

sunnypilot/models/helpers.py

@@ -19,8 +19,8 @@ from openpilot.system.hardware.hw import Paths
 from pathlib import Path
 
 # see the README.md for more details on the model selector versioning
-CURRENT_SELECTOR_VERSION = 11
-REQUIRED_MIN_SELECTOR_VERSION = 11
+CURRENT_SELECTOR_VERSION = 10
+REQUIRED_MIN_SELECTOR_VERSION = 9
 
 USE_ONNX = os.getenv('USE_ONNX', PC)
 

sunnypilot/models/runners/model_runner.py

@@ -14,10 +14,13 @@ CUSTOM_MODEL_PATH = Paths.model_root()
 # Set QCOM environment variable for TICI devices, potentially enabling hardware acceleration
 USBGPU = "USBGPU" in os.environ
 if USBGPU:
-  os.environ['DEV'] = 'AMD'
+  os.environ['AMD'] = '1'
   os.environ['AMD_IFACE'] = 'USB'
+elif TICI:
+  os.environ['QCOM'] = '1'
 else:
-  os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
+  os.environ['LLVM'] = '1'
+  os.environ['JIT'] = '2'  # TODO: This may cause issues
 
 
 class ModelData:

sunnypilot/navd/navigation_desires/navigation_desires.py

@@ -31,14 +31,14 @@ class NavigationDesires:
     self.desire = log.Desire.none
     if self.nav_allowed and nav_msg.valid and lateral_active:
       upcoming = nav_msg.upcomingTurn
-      if upcoming == 'slightLeft' and (not CS.leftBlindspot or CS.vEgo < self._turn_speed_limit):
-        self.desire = log.Desire.keepLeft
-      elif upcoming == 'slightRight' and (not CS.rightBlindspot or CS.vEgo < self._turn_speed_limit):
-        self.desire = log.Desire.keepRight
-      elif (upcoming == 'left' and CS.steeringPressed and CS.steeringTorque > 0 and not CS.rightBlinker
+      # if upcoming == 'slightLeft' and (not CS.leftBlindspot or CS.vEgo < self._turn_speed_limit):
+      #   self.desire = log.Desire.keepLeft
+      # elif upcoming == 'slightRight' and (not CS.rightBlindspot or CS.vEgo < self._turn_speed_limit):
+      #   self.desire = log.Desire.keepRight
+      if (upcoming == 'left' and not CS.rightBlinker
             and not CS.leftBlindspot and CS.vEgo < self._turn_speed_limit):
         self.desire = log.Desire.turnLeft
-      elif (upcoming == 'right' and CS.steeringPressed and CS.steeringTorque < 0 and not CS.leftBlinker
+      elif (upcoming == 'right' and not CS.leftBlinker
             and not CS.rightBlindspot and CS.vEgo < self._turn_speed_limit):
         self.desire = log.Desire.turnRight
     return self.desire

sunnypilot/navd/navigation_desires/tests/test_navigation_desires.py

@@ -22,20 +22,20 @@ def make_car(vEgo=0, leftBlinker=False, rightBlinker=False, leftBlindspot=False,
   )
 
 NAVIGATION_PARAMS: list[tuple] = [
-  ('slightLeft', make_car(), log.Desire.keepLeft),
-  ('slightRight', make_car(), log.Desire.keepRight),
+  ('slightLeft', make_car(steeringPressed=True, steeringTorque=1), log.Desire.keepLeft),
+  ('slightRight', make_car(steeringPressed=True, steeringTorque=-1), log.Desire.keepRight),
   ('slightLeft', make_car(vEgo=9, leftBlindspot=True), log.Desire.none),
   ('slightRight', make_car(vEgo=9, rightBlindspot=True), log.Desire.none),
-  ('left', make_car(vEgo=5, leftBlinker=True, rightBlinker=False, leftBlindspot=False, steeringPressed=True, steeringTorque=1), log.Desire.turnLeft),
+  ('left', make_car(vEgo=5, leftBlinker=True, rightBlinker=False, leftBlindspot=False), log.Desire.turnLeft),
   ('left', make_car(vEgo=5, leftBlinker=False, rightBlinker=True), log.Desire.none),
-  ('right', make_car(vEgo=6, rightBlinker=True, leftBlindspot=False, steeringPressed=True, steeringTorque=-1), log.Desire.turnRight),
+  ('right', make_car(vEgo=6, rightBlinker=True, leftBlindspot=False), log.Desire.turnRight),
   ('right', make_car(vEgo=6, rightBlinker=True, rightBlindspot=True), log.Desire.none),
   ('left', make_car(vEgo=9, leftBlinker=True), log.Desire.none),
 ]
 
 INTEGRATION_PARAMS: list[tuple] = [(carstate, upcoming, log.Desire.none, expected) for upcoming, carstate, expected in NAVIGATION_PARAMS] + [
-  (make_car(vEgo=9, leftBlinker=True, steeringPressed=True, steeringTorque=1), 'slightLeft', log.Desire.turnLeft, log.Desire.keepLeft),
-  (make_car(vEgo=9, rightBlinker=True, steeringPressed=True, steeringTorque=-1), 'slightRight', log.Desire.turnRight, log.Desire.keepRight),
+  (make_car(vEgo=6, leftBlinker=True, steeringPressed=True, steeringTorque=1), 'slightLeft', log.Desire.turnLeft, log.Desire.keepLeft),
+  (make_car(vEgo=5, rightBlinker=True, steeringPressed=True, steeringTorque=-1), 'slightRight', log.Desire.turnRight, log.Desire.keepRight),
   (make_car(vEgo=9, leftBlinker=True), 'slightLeft', log.Desire.laneChangeLeft, log.Desire.laneChangeLeft),
   (make_car(vEgo=9, rightBlinker=True), 'slightRight', log.Desire.laneChangeRight, log.Desire.laneChangeRight),
   (make_car(vEgo=9), 'none', log.Desire.none, log.Desire.none),

sunnypilot/navd/navigation_helpers/nav_instructions.py

@@ -4,6 +4,8 @@ Copyright (c) 2021-, James Vecellio, Haibin Wen, sunnypilot, and a number of oth
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+import numpy as np
+
 from openpilot.common.constants import CV
 from openpilot.common.params import Params
 
@@ -109,12 +111,17 @@ class NavigationInstructions:
     self._route_loaded = False
     self._no_route = False
 
-  def get_upcoming_turn_from_progress(self, progress, current_lat, current_lon) -> str:
+  def get_upcoming_turn_from_progress(self, progress, current_lat, current_lon, v_ego: float) -> str:
     if progress and progress['next_turn']:
+      speed_breakpoints: list = [0, 5, 10, 15, 20, 25, 30, 35, 40]
+      distance_breakpoints: list = [20, 25, 30, 45, 60, 75, 90, 105, 120]
+      distance_interp = np.interp(v_ego, speed_breakpoints, distance_breakpoints)
+
       self.coord.latitude = current_lat
       self.coord.longitude = current_lon
       distance = self.coord.distance_to(progress['next_turn']['location'])
-      if distance <= 30.0:
+
+      if distance <= distance_interp:
         modifier = progress['next_turn']['modifier']
         return str(modifier)
     return 'none'

sunnypilot/navd/navigation_helpers/tests/test_mapbox.py

@@ -54,17 +54,17 @@ class TestMapbox:
         assert 'modifier' in step
 
   def test_upcoming_turn_detection(self):
-    upcoming = self.nav.get_upcoming_turn_from_progress(self.progress, self.current_lat, self.current_lon)
+    upcoming = self.nav.get_upcoming_turn_from_progress(self.progress, self.current_lat, self.current_lon, v_ego=40.0)
     assert isinstance(upcoming, str)
     assert upcoming == 'none'
 
     if self.route['steps']:
       turn_lat = self.route['steps'][1]['location'].latitude
       turn_lon = self.route['steps'][1]['location'].longitude
-      close_lat = turn_lat - 0.00025  # slightly before the turn
+      close_lat = turn_lat - 0.000175  # slightly before the turn
       if self.progress and self.progress.get('next_turn'):
         expected_turn = self.progress['next_turn']['modifier']
-        upcoming_close = self.nav.get_upcoming_turn_from_progress(self.progress, close_lat, turn_lon)
+        upcoming_close = self.nav.get_upcoming_turn_from_progress(self.progress, close_lat, turn_lon, v_ego=0.0)
         if expected_turn:
           assert upcoming_close == expected_turn == 'right', "Should be a right turn upcoming"
 

sunnypilot/navd/navigationd.py

@@ -5,6 +5,7 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import math
+import numpy as np
 
 import cereal.messaging as messaging
 from cereal import custom
@@ -24,7 +25,7 @@ class Navigationd:
     self.mapbox = MapboxIntegration()
     self.nav_instructions = NavigationInstructions()
 
-    self.sm = messaging.SubMaster(['liveLocationKalman'])
+    self.sm = messaging.SubMaster(['carState', 'liveLocationKalman'])
     self.pm = messaging.PubMaster(['navigationd'])
     self.rk = Ratekeeper(3) # 3 Hz
 
@@ -76,12 +77,13 @@ class Navigationd:
 
       self.valid = self.route is not None
 
-  def _update_navigation(self) -> tuple[str, dict | None, dict]:
+  def _update_navigation(self, v_ego) -> tuple[str, dict | None, dict]:
     banner_instructions: str = ''
     nav_data: dict = {}
     if self.allow_navigation and self.last_position is not None:
       if progress := self.nav_instructions.get_route_progress(self.last_position.latitude, self.last_position.longitude):
-        nav_data['upcoming_turn'] = self.nav_instructions.get_upcoming_turn_from_progress(progress, self.last_position.latitude, self.last_position.longitude)
+        nav_data['upcoming_turn'] = self.nav_instructions.get_upcoming_turn_from_progress(progress, self.last_position.latitude,
+                                                                                          self.last_position.longitude, v_ego)
         nav_data['current_speed_limit'] = self.nav_instructions.get_current_speed_limit_from_progress(progress, self.is_metric)
         arrived = self.nav_instructions.arrived_at_destination(progress)
 
@@ -91,7 +93,9 @@ class Navigationd:
             banner_instructions = parsed['maneuverPrimaryText']
 
         nav_data['distance_from_route'] = progress['distance_from_route']
-        large_distance = progress['distance_from_route'] > 100
+        speed_breakpoints: list = [0.0, 5.0, 10.0, 20.0, 40.0]
+        distance_list: list = [100.0, 125.0, 150.0, 200.0, 250.0]
+        large_distance: bool = progress['distance_from_route'] > float(np.interp(v_ego, speed_breakpoints, distance_list))
 
         if large_distance:
           self.cancel_route_counter = self.cancel_route_counter + 1 if progress['distance_from_route'] > NAV_CV.QUARTER_MILE else 0
@@ -106,7 +110,7 @@ class Navigationd:
         # Don't recompute in last segment to prevent reroute loops
         if self.route:
           if progress['current_step_idx'] == len(self.route['steps']) - 1:
-            self.allow_recompute = False
+            self.reroute_counter = 0
     else:
       banner_instructions = ''
       progress = None
@@ -138,7 +142,8 @@ class Navigationd:
     cloudlog.warning('navigationd init')
 
     while True:
-      self.sm.update()
+      self.sm.update(0)
+      v_ego = self.sm['carState'].vEgo
       location = self.sm['liveLocationKalman']
       localizer_valid = location.positionGeodetic.valid if location else False
 
@@ -147,7 +152,7 @@ class Navigationd:
         self.last_position = Coordinate(location.positionGeodetic.value[0], location.positionGeodetic.value[1])
 
       self._update_params()
-      banner_instructions, progress, nav_data = self._update_navigation()
+      banner_instructions, progress, nav_data = self._update_navigation(v_ego)
 
       msg = self._build_navigation_message(banner_instructions, progress, nav_data, valid=localizer_valid)
 

sunnypilot/selfdrive/controls/lib/accel_personality/accel_controller.py

@@ -1,149 +0,0 @@
-"""
-Copyright (c) 2021-, rav4kumar, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from cereal import custom
-import numpy as np
-from openpilot.common.realtime import DT_MDL
-from openpilot.common.params import Params
-
-AccelPersonality = custom.LongitudinalPlanSP.AccelerationPersonality
-
-# Acceleration Profiles
-MAX_ACCEL_PROFILES = {
-  AccelPersonality.eco:      [1.8, 1.80, 1.40, .700, .410, .30, .22, .009],
-  AccelPersonality.normal:   [1.9, 1.90, 1.50, .800, .530, .40, .26, .120],
-  AccelPersonality.sport:    [2.0, 2.00, 1.60, .900, .680, .50, .35, .200],
-}
-MAX_ACCEL_BREAKPOINTS =      [0.,  4.,   6.,   9.,   16.,  25., 30., 55.]
-
-# Braking Profiles
-MIN_ACCEL_PROFILES = {
-  AccelPersonality.eco:    [-1.20, -1.20, -1.20],
-  AccelPersonality.normal: [-1.30, -1.30, -1.30],
-  AccelPersonality.sport:  [-1.30, -1.40, -1.40],
-}
-MIN_ACCEL_BREAKPOINTS =    [5.,    10.,   36.] 
-
-
-DECEL_SMOOTH_ALPHA = 0.02  # Very aggressive smoothing for decel (lower = smoother)
-ACCEL_SMOOTH_ALPHA = 0.01  # Less aggressive for accel (higher = more responsive)
-
-# Asymmetric rate limiting
-MAX_DECEL_INCREASE_RATE = 0.1  # When braking harder (m/s² per second)
-MAX_DECEL_DECREASE_RATE = 0.30  # When releasing brake (m/s² per second)
-
-
-
-class AccelPersonalityController:
-
-  def __init__(self):
-    self.params = Params()
-    self.frame = 0
-    self.accel_personality = AccelPersonality.normal
-    self.last_max_accel = 2.0
-    self.last_min_accel = -0.01
-    self.first_run = True
-    self.param_keys = {
-      'personality': 'AccelPersonality',
-      'enabled': 'AccelPersonalityEnabled'
-    }
-    self._load_personality_from_params()
-
-  def _load_personality_from_params(self):
-    try:
-      saved = self.params.get(self.param_keys['personality'])
-      if saved is not None:
-        personality_value = int(saved)
-        if personality_value in [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]:
-          self.accel_personality = personality_value
-        else:
-          self.accel_personality = AccelPersonality.normal
-    except (ValueError, TypeError):
-      self.accel_personality = AccelPersonality.normal
-
-  def _update_from_params(self):
-    if self.frame % int(1. / DT_MDL) != 0:
-      return
-    self._load_personality_from_params()
-
-  def get_accel_personality(self) -> int:
-    self._update_from_params()
-    return int(self.accel_personality)
-
-  def set_accel_personality(self, personality: int):
-    if personality not in [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]:
-      return
-
-    self.accel_personality = personality
-    self.params.put(self.param_keys['personality'], str(personality))
-
-  def cycle_accel_personality(self) -> int:
-    personalities = [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]
-    current_idx = personalities.index(self.accel_personality)
-    next_personality = personalities[(current_idx + 1) % len(personalities)]
-    self.set_accel_personality(next_personality)
-    return int(next_personality)
-
-  def get_accel_limits(self, v_ego: float) -> tuple[float, float]:
-    v_ego = max(0.0, v_ego)
-    target_max_accel = np.interp(v_ego, MAX_ACCEL_BREAKPOINTS, MAX_ACCEL_PROFILES[self.accel_personality])
-    target_min_accel = np.interp(v_ego, MIN_ACCEL_BREAKPOINTS, MIN_ACCEL_PROFILES[self.accel_personality])
-
-    if self.first_run:
-      self.last_max_accel = target_max_accel
-      self.last_min_accel = target_min_accel
-      self.first_run = False
-      return float(target_min_accel), float(target_max_accel)
-
-    # exponential smoothing to max accel
-    self.last_max_accel = (ACCEL_SMOOTH_ALPHA * target_max_accel + (1 - ACCEL_SMOOTH_ALPHA) * self.last_max_accel)
-
-    # VERY aggressive smoothing to min accel for ultra-smooth braking
-    smoothed_decel = (DECEL_SMOOTH_ALPHA * target_min_accel + (1 - DECEL_SMOOTH_ALPHA) * self.last_min_accel)
-
-    # asymmetric rate limiting
-    decel_change = smoothed_decel - self.last_min_accel
-    if decel_change < 0:
-      max_change_per_step = MAX_DECEL_INCREASE_RATE * DT_MDL
-    else:
-      max_change_per_step = MAX_DECEL_DECREASE_RATE * DT_MDL
-
-    decel_change = np.clip(decel_change, -max_change_per_step, max_change_per_step)
-    self.last_min_accel = self.last_min_accel + decel_change
-
-    if self.last_min_accel > self.last_max_accel:
-      self.last_min_accel = self.last_max_accel - 0.1
-
-    return float(self.last_min_accel), float(self.last_max_accel)
-
-  def get_min_accel(self, v_ego: float) -> float:
-    return self.get_accel_limits(v_ego)[0]
-
-  def get_max_accel(self, v_ego: float) -> float:
-    return self.get_accel_limits(v_ego)[1]
-
-  def is_enabled(self) -> bool:
-    return self.params.get_bool(self.param_keys['enabled'])
-
-  def set_enabled(self, enabled: bool):
-    self.params.put_bool(self.param_keys['enabled'], enabled)
-
-  def toggle_enabled(self) -> bool:
-    current = self.is_enabled()
-    self.set_enabled(not current)
-    return not current
-
-  def reset(self):
-    self.accel_personality = AccelPersonality.normal
-    self.frame = 0
-    self.last_max_accel = 2.0
-    self.last_min_accel = -0.01
-    self.first_run = True
-
-  def update(self):
-    self.frame += 1
-    self._update_from_params()

sunnypilot/selfdrive/controls/lib/dynamic_personality/dynamic_follow.py

@@ -1,128 +0,0 @@
-"""
-Copyright (c) 2021-, rav4kumar, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from cereal import log
-import numpy as np
-from openpilot.common.realtime import DT_MDL
-from openpilot.common.params import Params
-
-LongPersonality = log.LongitudinalPersonality
-
-# Follow distance profiles mapped to LongPersonality
-FOLLOW_PROFILES = {
-  LongPersonality.relaxed:    [1.50, 1.50, 1.66, 1.66, 1.64, 1.89],
-  LongPersonality.standard:   [1.30, 1.30, 1.45, 1.45, 1.44, 1.50],
-  LongPersonality.aggressive: [0.97, 0.97, 1.25, 1.25, 1.24, 1.28],
-}
-
-FOLLOW_BREAKPOINTS =          [0.,   3.,   4,   11,   25.,  36]
-
-SMOOTHING_BASE = 0.99  # Base smoothing factor (higher = smoother)
-SMOOTHING_RANGE = 0.50  # Additional smoothing at high speeds
-SMOOTHING_SPEED_THRESHOLD = 36.0  # m/s (~80 mph) for max smoothing
-PERSONALITY_CHANGE_COOLDOWN_S = 0.1
-
-
-class FollowDistanceController:
-  def __init__(self):
-    self.params = Params()
-    self.frame = 0
-    self.personality = LongPersonality.standard
-    self.current_multiplier = None
-    self.first_run = True
-    self.personality_change_cooldown = 0
-    self.personality_cooldown_frames = int(PERSONALITY_CHANGE_COOLDOWN_S / DT_MDL)
-    self._load_personality()
-
-  def _load_personality(self):
-    try:
-      saved = self.params.get('LongitudinalPersonality')
-      if saved is not None:
-        val = int(saved)
-        if val in [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]:
-          self.personality = val
-    except (ValueError, TypeError):
-      pass
-
-  def _update_from_params(self):
-    if self.frame % int(1. / DT_MDL) != 0:
-      return
-
-    if self.personality_change_cooldown > 0:
-      self.personality_change_cooldown -= 1
-      return
-
-    try:
-      param = self.params.get('LongitudinalPersonality')
-      if param is not None:
-        val = int(param)
-        if val in [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]:
-          if val != self.personality:
-            self.personality = val
-            self.personality_change_cooldown = self.personality_cooldown_frames
-    except (ValueError, TypeError):
-      pass
-
-  def _get_smoothing_factor(self, v_ego: float) -> float:
-    speed_factor = np.clip(v_ego / SMOOTHING_SPEED_THRESHOLD, 0.3, 1.0)
-    return SMOOTHING_BASE + (SMOOTHING_RANGE * speed_factor)
-
-  def is_enabled(self) -> bool:
-    return self.params.get_bool('DynamicFollow')
-
-  def set_enabled(self, enabled: bool):
-    self.params.put_bool('DynamicFollow', enabled)
-
-  def toggle(self) -> bool:
-    enabled = self.is_enabled()
-    self.set_enabled(not enabled)
-    return not enabled
-
-  def get_personality(self) -> int:
-    self._update_from_params()
-    return int(self.personality)
-
-  def set_personality(self, personality: int):
-    if personality not in [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]:
-      return
-
-    self.personality = personality
-    self.params.put('LongitudinalPersonality', str(personality))
-    self.personality_change_cooldown = self.personality_cooldown_frames
-
-  def cycle_personality(self) -> int:
-    personalities = [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]
-    current_idx = personalities.index(self.personality)
-    next_personality = personalities[(current_idx + 1) % len(personalities)]
-    self.set_personality(next_personality)
-    return int(next_personality)
-
-  def get_follow_distance_multiplier(self, v_ego: float) -> float:
-    self._update_from_params()
-    v_ego = max(0.0, v_ego)
-    target = float(np.interp(v_ego, FOLLOW_BREAKPOINTS, FOLLOW_PROFILES[self.personality]))
-
-    if self.first_run:
-      self.current_multiplier = target
-      self.first_run = False
-      return self.current_multiplier
-
-    #exponential smoothing with speedadaptive factor
-    alpha = self._get_smoothing_factor(v_ego)
-    self.current_multiplier = alpha * self.current_multiplier + (1.0 - alpha) * target
-    return self.current_multiplier
-
-  def reset(self):
-    self.personality = LongPersonality.standard
-    self.frame = 0
-    self.current_multiplier = None
-    self.first_run = True
-    self.personality_change_cooldown = 0
-
-  def update(self):
-    self.frame += 1
-    self._update_from_params()

sunnypilot/selfdrive/controls/lib/longitudinal_planner.py

@@ -17,7 +17,6 @@ from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_resolve
 from openpilot.sunnypilot.selfdrive.selfdrived.events import EventsSP
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_personality.accel_controller import AccelPersonalityController
 DecState = custom.LongitudinalPlanSP.DynamicExperimentalControl.DynamicExperimentalControlState
 LongitudinalPlanSource = custom.LongitudinalPlanSP.LongitudinalPlanSource
 
@@ -25,27 +24,27 @@ LongitudinalPlanSource = custom.LongitudinalPlanSP.LongitudinalPlanSource
 class LongitudinalPlannerSP:
   def __init__(self, CP: structs.CarParams, CP_SP: structs.CarParamsSP, mpc):
     self.events_sp = EventsSP()
+    self.resolver = SpeedLimitResolver()
     self.dec = DynamicExperimentalController(CP, mpc)
-    self.accel_controller = AccelPersonalityController()
+    self.scc = SmartCruiseControl()
+    self.resolver = SpeedLimitResolver()
+    self.sla = SpeedLimitAssist(CP, CP_SP)
     self.generation = int(model_bundle.generation) if (model_bundle := get_active_bundle()) else None
     self.source = LongitudinalPlanSource.cruise
     self.e2e_alerts_helper = E2EAlertsHelper()
 
-    # Disabled controllers
-    self.scc = None
-    self.sla = None
-    self.resolver = None
-
     self.output_v_target = 0.
     self.output_a_target = 0.
 
   @property
   def mlsim(self) -> bool:
+    # If we don't have a generation set, we assume it's default model. Which as of today are mlsim.
     return bool(self.generation is None or self.generation >= 11)
 
   def get_mpc_mode(self) -> str | None:
     if not self.dec.active():
       return None
+
     return self.dec.mode()
 
   def update_targets(self, sm: messaging.SubMaster, v_ego: float, a_ego: float, v_cruise: float) -> tuple[float, float]:
@@ -53,20 +52,39 @@ class LongitudinalPlannerSP:
     v_cruise_cluster_kph = min(CS.vCruiseCluster, V_CRUISE_MAX)
     v_cruise_cluster = v_cruise_cluster_kph * CV.KPH_TO_MS
 
-    # Skip SCC and Speed Limit logic
-    self.source = LongitudinalPlanSource.cruise
-    self.output_v_target = v_cruise_cluster
-    self.output_a_target = a_ego
+    long_enabled = sm['carControl'].enabled
+    long_override = sm['carControl'].cruiseControl.override
+
+    # Smart Cruise Control
+    self.scc.update(sm, long_enabled, long_override, v_ego, a_ego, v_cruise)
+
+    # Speed Limit Resolver
+    self.resolver.update(v_ego, sm)
+
+    # Speed Limit Assist
+    has_speed_limit = self.resolver.speed_limit_valid or self.resolver.speed_limit_last_valid
+    self.sla.update(long_enabled, long_override, v_ego, a_ego, v_cruise_cluster, self.resolver.speed_limit,
+                    self.resolver.speed_limit_final_last, has_speed_limit, self.resolver.distance, self.events_sp)
+
+    targets = {
+      LongitudinalPlanSource.cruise: (v_cruise, a_ego),
+      LongitudinalPlanSource.sccVision: (self.scc.vision.output_v_target, self.scc.vision.output_a_target),
+      LongitudinalPlanSource.sccMap: (self.scc.map.output_v_target, self.scc.map.output_a_target),
+      LongitudinalPlanSource.speedLimitAssist: (self.sla.output_v_target, self.sla.output_a_target),
+    }
+
+    self.source = min(targets, key=lambda k: targets[k][0])
+    self.output_v_target, self.output_a_target = targets[self.source]
     return self.output_v_target, self.output_a_target
 
   def update(self, sm: messaging.SubMaster) -> None:
     self.events_sp.clear()
     self.dec.update(sm)
     self.e2e_alerts_helper.update(sm, self.events_sp)
-    self.accel_controller.update()
 
   def publish_longitudinal_plan_sp(self, sm: messaging.SubMaster, pm: messaging.PubMaster) -> None:
     plan_sp_send = messaging.new_message('longitudinalPlanSP')
+
     plan_sp_send.valid = sm.all_checks(service_list=['carState', 'controlsState'])
 
     longitudinalPlanSP = plan_sp_send.longitudinalPlanSP
@@ -81,10 +99,43 @@ class LongitudinalPlannerSP:
     dec.enabled = self.dec.enabled()
     dec.active = self.dec.active()
 
-    # Skip SCC and Speed Limit fields (leave zeroed)
-    longitudinalPlanSP.smartCruiseControl.vision.enabled = False
-    longitudinalPlanSP.smartCruiseControl.map.enabled = False
-    longitudinalPlanSP.speedLimit.assist.enabled = False
+    # Smart Cruise Control
+    smartCruiseControl = longitudinalPlanSP.smartCruiseControl
+    # Vision Control
+    sccVision = smartCruiseControl.vision
+    sccVision.state = self.scc.vision.state
+    sccVision.vTarget = float(self.scc.vision.output_v_target)
+    sccVision.aTarget = float(self.scc.vision.output_a_target)
+    sccVision.currentLateralAccel = float(self.scc.vision.current_lat_acc)
+    sccVision.maxPredictedLateralAccel = float(self.scc.vision.max_pred_lat_acc)
+    sccVision.enabled = self.scc.vision.is_enabled
+    sccVision.active = self.scc.vision.is_active
+    # Map Control
+    sccMap = smartCruiseControl.map
+    sccMap.state = self.scc.map.state
+    sccMap.vTarget = float(self.scc.map.output_v_target)
+    sccMap.aTarget = float(self.scc.map.output_a_target)
+    sccMap.enabled = self.scc.map.is_enabled
+    sccMap.active = self.scc.map.is_active
+
+    # Speed Limit
+    speedLimit = longitudinalPlanSP.speedLimit
+    resolver = speedLimit.resolver
+    resolver.speedLimit = float(self.resolver.speed_limit)
+    resolver.speedLimitLast = float(self.resolver.speed_limit_last)
+    resolver.speedLimitFinal = float(self.resolver.speed_limit_final)
+    resolver.speedLimitFinalLast = float(self.resolver.speed_limit_final_last)
+    resolver.speedLimitValid = self.resolver.speed_limit_valid
+    resolver.speedLimitLastValid = self.resolver.speed_limit_last_valid
+    resolver.speedLimitOffset = float(self.resolver.speed_limit_offset)
+    resolver.distToSpeedLimit = float(self.resolver.distance)
+    resolver.source = self.resolver.source
+    assist = speedLimit.assist
+    assist.state = self.sla.state
+    assist.enabled = self.sla.is_enabled
+    assist.active = self.sla.is_active
+    assist.vTarget = float(self.sla.output_v_target)
+    assist.aTarget = float(self.sla.output_a_target)
 
     # E2E Alerts
     e2eAlerts = longitudinalPlanSP.e2eAlerts

sunnypilot/selfdrive/controls/lib/relc.py

@@ -1,113 +0,0 @@
-"""
-Copyright (c) 2021-, rav4kumar, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import numpy as np
-from cereal import log
-from openpilot.common.realtime import DT_MDL
-from openpilot.common.params import Params
-
-NEARSIDE_PROB = 0.2
-EDGE_PROB = 0.35
-EDGE_REACTION_TIME = 1.0
-
-class RoadEdgeLaneChangeController:
-  def __init__(self, desire_helper):
-    self.desire_helper = desire_helper
-    self.params = Params()
-    self.enabled = self.params.get_bool("RoadEdgeLaneChangeEnabled")
-    self.left_edge_detected = False
-    self.right_edge_detected = False
-    self.left_edge_timer = 0.0
-    self.right_edge_timer = 0.0
-    self._frame = 0
-
-  def set_enabled(self, enabled):
-    self.enabled = enabled
-    if not enabled:
-      self._reset_state()
-
-  def _read_params(self) -> None:
-    if self._frame % int(1. / DT_MDL) == 0:
-      self.enabled = self.params.get_bool("RoadEdgeLaneChangeEnabled")
-
-  def _reset_state(self):
-    self.left_edge_detected = False
-    self.right_edge_detected = False
-    self.left_edge_timer = 0.0
-    self.right_edge_timer = 0.0
-
-  def _update_edge_detection(self, road_edge_stds, lane_line_probs):
-    if not self.enabled:
-      return
-
-    left_road_edge_prob = np.clip(1.0 - road_edge_stds[0], 0.0, 1.0)
-    right_road_edge_prob = np.clip(1.0 - road_edge_stds[1], 0.0, 1.0)
-
-    # Lane line probabilities: [left_outer, left_inner, right_inner, right_outer]
-    left_lane_nearside_prob = lane_line_probs[0] if len(lane_line_probs) > 0 else 0.0
-    right_lane_nearside_prob = lane_line_probs[3] if len(lane_line_probs) > 3 else 0.0
-
-    left_edge_conditions = (
-          left_road_edge_prob > EDGE_PROB and
-          left_lane_nearside_prob < NEARSIDE_PROB and
-          (len(lane_line_probs) <= 3 or right_lane_nearside_prob >= left_lane_nearside_prob)
-    )
-    right_edge_conditions = (
-          right_road_edge_prob > EDGE_PROB and
-          right_lane_nearside_prob < NEARSIDE_PROB and
-          (len(lane_line_probs) <= 0 or left_lane_nearside_prob >= right_lane_nearside_prob)
-    )
-
-    if left_edge_conditions:
-      self.left_edge_timer += DT_MDL
-      self.left_edge_detected = self.left_edge_timer > EDGE_REACTION_TIME
-    else:
-      self.left_edge_timer = 0.0
-      self.left_edge_detected = False
-
-    if right_edge_conditions:
-      self.right_edge_timer += DT_MDL
-      self.right_edge_detected = self.right_edge_timer > EDGE_REACTION_TIME
-    else:
-      self.right_edge_timer = 0.0
-      self.right_edge_detected = False
-
-  def update(self, road_edge_stds, lane_line_probs):
-    self._read_params()
-
-    if not self.enabled:
-      self._frame += 1
-      return
-
-    self._update_edge_detection(road_edge_stds, lane_line_probs)
-    self._frame += 1
-
-  def should_trigger_lane_change(self, carstate, lateral_active):
-    if not self.enabled:
-      return False, log.LaneChangeDirection.none
-    return False, log.LaneChangeDirection.none
-
-  def is_lane_change_blocked(self, direction):
-    if not self.enabled:
-      return False
-
-    if direction == log.LaneChangeDirection.left:
-      return self.left_edge_detected
-    elif direction == log.LaneChangeDirection.right:
-      return self.right_edge_detected
-
-    return False
-
-  def can_change_lane_left(self):
-    return not self.left_edge_detected if self.enabled else True
-
-  def can_change_lane_right(self):
-    return not self.right_edge_detected if self.enabled else True
-
-  @property
-  def edge_detected(self):
-    return self.left_edge_detected or self.right_edge_detected

sunnypilot/selfdrive/controls/lib/tests/test_lane_turn_desire.py

@@ -6,9 +6,6 @@ from openpilot.common.params import Params
 
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.sunnypilot.selfdrive.controls.lib.lane_turn_desire import LaneTurnController, LANE_CHANGE_SPEED_MIN
-from openpilot.sunnypilot.selfdrive.controls.lib.auto_lane_change import AutoLaneChangeMode
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
-
 
 TurnDirection = custom.ModelDataV2SP.TurnDirection
 
@@ -124,10 +121,7 @@ def set_lane_turn_params():
   (DummyCarState(vEgo=4, leftBlinker=False, rightBlinker=False), True, 1.0, log.Desire.none),  # No blinkers? no desire!
 ])
 def test_desire_helper_integration(carstate, lateral_active, lane_change_prob, expected_desire, set_lane_turn_params):
-    dh = DesireHelper()
-    relc = RoadEdgeLaneChangeController(dh)
-    relc.set_enabled(True)
-    dh.alc.lane_change_set_timer = AutoLaneChangeMode.NUDGE
-    for _ in range(10):
-        dh.update(carstate, lateral_active, lane_change_prob, left_edge_detected=relc.left_edge_detected, right_edge_detected=relc.right_edge_detected)
-    assert dh.desire == expected_desire  # The first four tests were unit tests to test the controller, where this tests the integration in desire helpers
+  dh = DesireHelper()
+  for _ in range(10):
+    dh.update(carstate, lateral_active, lane_change_prob)
+  assert dh.desire == expected_desire

sunnypilot/selfdrive/controls/lib/tests/test_relc.py

@@ -1,190 +0,0 @@
-"""
-Copyright (c) 2021-, rav4kumar, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import pytest
-from cereal import log
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController, EDGE_REACTION_TIME
-
-@pytest.fixture
-def relc_controller(mocker):
-  mock_params = mocker.patch("openpilot.sunnypilot.selfdrive.controls.lib.relc.Params")
-  mock_params.return_value.get_bool.return_value = True
-
-  DH = DesireHelper()
-  relc = RoadEdgeLaneChangeController(DH)
-  relc.set_enabled(True)
-  return relc
-
-
-def test_disable_resets_state(relc_controller):
-  relc = relc_controller
-  relc.left_edge_detected = True
-  relc.right_edge_detected = True
-  relc.left_edge_timer = 5.0
-  relc.right_edge_timer = 5.0
-
-  relc.set_enabled(False)
-
-  assert not relc.left_edge_detected
-  assert not relc.right_edge_detected
-  assert relc.left_edge_timer == 0.0
-  assert relc.right_edge_timer == 0.0
-
-
-def test_lane_change_blocked_left(relc_controller):
-  relc = relc_controller
-  relc.left_edge_detected = True
-  assert relc.is_lane_change_blocked(log.LaneChangeDirection.left)
-
-
-def test_lane_change_blocked_right(relc_controller):
-  relc = relc_controller
-  relc.right_edge_detected = True
-  assert relc.is_lane_change_blocked(log.LaneChangeDirection.right)
-
-
-def test_lane_change_not_blocked_opposite_side(relc_controller):
-  relc = relc_controller
-  relc.left_edge_detected = True
-  assert not relc.is_lane_change_blocked(log.LaneChangeDirection.right)
-
-  relc.left_edge_detected = False
-  relc.right_edge_detected = True
-  assert not relc.is_lane_change_blocked(log.LaneChangeDirection.left)
-
-
-def test_lane_change_not_blocked_when_disabled(relc_controller):
-  relc = relc_controller
-  relc.set_enabled(False)
-  relc.left_edge_detected = True
-  relc.right_edge_detected = True
-
-  assert not relc.is_lane_change_blocked(log.LaneChangeDirection.left)
-  assert not relc.is_lane_change_blocked(log.LaneChangeDirection.right)
-
-
-def test_can_change_lane_left(relc_controller):
-  relc = relc_controller
-  assert relc.can_change_lane_left()
-
-  relc.left_edge_detected = True
-  assert not relc.can_change_lane_left()
-
-
-def test_can_change_lane_right(relc_controller):
-  relc = relc_controller
-  assert relc.can_change_lane_right()
-
-  relc.right_edge_detected = True
-  assert not relc.can_change_lane_right()
-
-
-def test_can_change_lane_when_disabled(relc_controller):
-  relc = relc_controller
-  relc.set_enabled(False)
-  relc.left_edge_detected = True
-  relc.right_edge_detected = True
-
-  assert relc.can_change_lane_left()
-  assert relc.can_change_lane_right()
-
-
-def test_edge_detected_property(relc_controller):
-  relc = relc_controller
-  assert not relc.edge_detected
-
-  relc.left_edge_detected = True
-  assert relc.edge_detected
-
-  relc.left_edge_detected = False
-  relc.right_edge_detected = True
-  assert relc.edge_detected
-
-  relc.left_edge_detected = True
-  assert relc.edge_detected
-
-
-def test_should_trigger_lane_change(relc_controller):
-  relc = relc_controller
-  should_trigger, direction = relc.should_trigger_lane_change(None, True)
-  assert not should_trigger
-  assert direction == log.LaneChangeDirection.none
-
-
-def test_update_increments_frame(relc_controller):
-  relc = relc_controller
-  initial = relc._frame
-  relc.update([0.5, 0.5], [0.5, 0.5, 0.5, 0.5])
-  assert relc._frame == initial + 1
-
-
-def test_left_edge_detection(relc_controller):
-  relc = relc_controller
-  road_edge_stds = [0.0, 0.9]
-  lane_line_probs = [0.0, 0.8, 0.8, 0.8]
-
-  num_updates = int(EDGE_REACTION_TIME / DT_MDL) + 5
-  for _ in range(num_updates):
-    relc.update(road_edge_stds, lane_line_probs)
-
-  assert relc.left_edge_detected
-
-
-def test_right_edge_detection(relc_controller):
-  relc = relc_controller
-  road_edge_stds = [0.9, 0.0]
-  lane_line_probs = [0.8, 0.8, 0.8, 0.0]
-
-  num_updates = int(EDGE_REACTION_TIME / DT_MDL) + 5
-  for _ in range(num_updates):
-    relc.update(road_edge_stds, lane_line_probs)
-
-  assert relc.right_edge_detected
-
-
-def test_edge_detection_requires_time(relc_controller):
-  relc = relc_controller
-  road_edge_stds = [0.0, 0.9]
-  lane_line_probs = [0.0, 0.8, 0.8, 0.8]
-
-  num_updates = int(EDGE_REACTION_TIME / DT_MDL) - 1
-  for _ in range(num_updates):
-    relc.update(road_edge_stds, lane_line_probs)
-
-  assert not relc.left_edge_detected
-
-
-def test_edge_detection_clears(relc_controller):
-  relc = relc_controller
-  road_edge_stds = [0.0, 0.9]
-  lane_line_probs = [0.0, 0.8, 0.8, 0.8]
-
-  num_updates = int(EDGE_REACTION_TIME / DT_MDL) + 5
-  for _ in range(num_updates):
-    relc.update(road_edge_stds, lane_line_probs)
-  assert relc.left_edge_detected
-
-  road_edge_stds = [0.9, 0.9]
-  relc.update(road_edge_stds, lane_line_probs)
-
-  assert not relc.left_edge_detected
-  assert relc.left_edge_timer == 0.0
-
-
-def test_both_edges_detected(relc_controller):
-  relc = relc_controller
-  road_edge_stds = [0.0, 0.0]
-  lane_line_probs = [0.0, 0.8, 0.8, 0.0]
-
-  num_updates = int(EDGE_REACTION_TIME / DT_MDL) + 5
-  for _ in range(num_updates):
-    relc.update(road_edge_stds, lane_line_probs)
-
-  assert relc.left_edge_detected
-  assert relc.right_edge_detected

sunnypilot/selfdrive/controls/lib/vibe_personality/tests/test_vibe.py

@@ -1,314 +0,0 @@
-import pytest
-
-# Import the actual modules
-from cereal import log, custom
-from openpilot.common.realtime import DT_MDL
-
-# Import the enums we need for testing
-LongPersonality = log.LongitudinalPersonality
-AccelPersonality = custom.LongitudinalPlanSP.AccelerationPersonality
-
-
-class MockParams:
-  """Simple mock for Params class"""
-  def __init__(self):
-    self.data = {}
-    self.bool_data = {
-      'VibePersonalityEnabled': True,
-      'VibeAccelPersonalityEnabled': True,
-      'VibeFollowPersonalityEnabled': True
-    }
-
-  def get(self, key, encoding=None):
-    return self.data.get(key)
-
-  def get_bool(self, key):
-    return self.bool_data.get(key, True)
-
-  def put(self, key, value):
-    self.data[key] = value
-
-  def put_bool(self, key, value):
-    self.bool_data[key] = value
-
-  def reset_mock(self):
-    self.call_count = 0
-
-  @property
-  def call_count(self):
-    return getattr(self, '_call_count', 0)
-
-  @call_count.setter
-  def call_count(self, value):
-    self._call_count = value
-
-
-@pytest.fixture
-def mock_params():
-  """Create mock params instance"""
-  return MockParams()
-
-
-@pytest.fixture
-def controller(mock_params, monkeypatch):
-  """Create controller instance with mocked Params"""
-  # Patch the Params import in the controller module
-  monkeypatch.setattr('openpilot.sunnypilot.selfdrive.controls.lib.vibe_personality.vibe_personality.Params',
-                      lambda: mock_params)
-
-  from openpilot.sunnypilot.selfdrive.controls.lib.vibe_personality.vibe_personality import VibePersonalityController
-  return VibePersonalityController()
-
-
-class TestVibePersonalityController:
-
-  def test_initialization(self, controller):
-    """Test controller initializes with correct defaults"""
-    assert controller.frame == 0
-    assert controller.accel_personality == AccelPersonality.normal
-    assert controller.long_personality == LongPersonality.standard
-    assert 'accel_personality' in controller.param_keys
-    assert 'long_personality' in controller.param_keys
-
-  def test_frame_increment(self, controller):
-    """Test frame counter increments correctly"""
-    initial_frame = controller.frame
-    controller.update()
-    assert controller.frame == initial_frame + 1
-
-    controller.update()
-    assert controller.frame == initial_frame + 2
-
-  def test_parameter_reading_throttled(self, controller, mock_params):
-    """Test parameters are only read every DT_MDL frames"""
-    # Track calls manually
-    original_get = mock_params.get
-    call_count = 0
-
-    def counting_get(*args, **kwargs):
-      nonlocal call_count
-      call_count += 1
-      return original_get(*args, **kwargs)
-
-    mock_params.get = counting_get
-
-    # First call should read params (frame 0)
-    controller._update_from_params()
-
-    # Reset counter
-    call_count = 0
-
-    # Advance frame but not to threshold
-    controller.frame = 5  # Less than int(1/DT_MDL)
-    controller._update_from_params()
-    assert call_count == 0  # Should not read params
-
-    # Advance to threshold
-    controller.frame = int(1. / DT_MDL)  # Equal to threshold
-    controller._update_from_params()
-    assert call_count >= 2  # Should read both personality params
-
-  def test_accel_personality_management(self, controller, mock_params):
-    """Test acceleration personality setting and cycling"""
-    # Test setting valid personality
-    assert controller.set_accel_personality(AccelPersonality.eco)
-    assert controller.accel_personality == AccelPersonality.eco
-
-    assert controller.set_accel_personality(AccelPersonality.sport)
-    assert controller.accel_personality == AccelPersonality.sport
-
-    # Test setting invalid personality
-    assert not controller.set_accel_personality(999)
-    assert controller.accel_personality == AccelPersonality.sport  # Should remain unchanged
-
-    # Test cycling
-    controller.accel_personality = AccelPersonality.eco
-    next_personality = controller.cycle_accel_personality()
-    assert next_personality == AccelPersonality.normal  # should cycle to normal
-    assert controller.accel_personality == AccelPersonality.normal
-
-    next_personality = controller.cycle_accel_personality()
-    assert next_personality == AccelPersonality.sport  # should cycle to sport
-
-    next_personality = controller.cycle_accel_personality()
-    assert next_personality == AccelPersonality.eco  # should cycle back to eco
-
-  def test_long_personality_management(self, controller, mock_params):
-    """Test longitudinal personality setting and cycling"""
-    # Test setting valid personality
-    assert controller.set_long_personality(LongPersonality.relaxed)
-    assert controller.long_personality == LongPersonality.relaxed
-
-    assert controller.set_long_personality(LongPersonality.aggressive)
-    assert controller.long_personality == LongPersonality.aggressive
-
-    # Test setting invalid personality
-    assert not controller.set_long_personality(999)
-    assert controller.long_personality == LongPersonality.aggressive  # Should remain unchanged
-
-    # Test cycling
-    controller.long_personality = LongPersonality.standard
-    next_personality = controller.cycle_long_personality()
-    assert next_personality == LongPersonality.aggressive  # should cycle to aggressive
-    assert controller.long_personality == LongPersonality.aggressive
-
-    next_personality = controller.cycle_long_personality()
-    assert next_personality == LongPersonality.relaxed  # should cycle to relaxed
-
-    next_personality = controller.cycle_long_personality()
-    assert next_personality == LongPersonality.standard  # should cycle back to standard
-
-  def test_toggle_functions(self, controller, mock_params):
-    """Test toggle functionality"""
-    # Set initial state to False
-    mock_params.bool_data['VibePersonalityEnabled'] = False
-
-    result = controller.toggle_personality()
-    assert result  # Should toggle to True
-    assert mock_params.bool_data['VibePersonalityEnabled']
-
-    # Set initial state to True
-    mock_params.bool_data['VibeAccelPersonalityEnabled'] = True
-
-    result = controller.toggle_accel_personality()
-    assert not result  # Should toggle to False
-    assert not mock_params.bool_data['VibeAccelPersonalityEnabled']
-
-  def test_enable_checks(self, controller, mock_params):
-    """Test various enable state checks"""
-    # All enabled
-    mock_params.bool_data = {
-      'VibePersonalityEnabled': True,
-      'VibeAccelPersonalityEnabled': True,
-      'VibeFollowPersonalityEnabled': True
-    }
-
-    assert controller.is_enabled()
-    assert controller.is_accel_enabled()
-    assert controller.is_follow_enabled()
-
-    # Main toggle disabled
-    mock_params.bool_data['VibePersonalityEnabled'] = False
-
-    assert not controller.is_enabled()
-    assert not controller.is_accel_enabled()
-    assert not controller.is_follow_enabled()
-
-  def test_accel_limits_calculation(self, controller, mock_params):
-    """Test acceleration limits calculation"""
-    # Enable all features through mock_params bool_data
-    mock_params.bool_data = {
-      'VibePersonalityEnabled': True,
-      'VibeAccelPersonalityEnabled': True,
-      'VibeFollowPersonalityEnabled': True
-    }
-
-    # Test with different speeds and personalities
-    controller.accel_personality = 1  # normal
-    controller.long_personality = 1  # standard
-
-    limits = controller.get_accel_limits(10.0)  # 10 m/s
-    assert limits is not None
-    min_a, max_a = limits
-    assert isinstance(min_a, float)
-    assert isinstance(max_a, float)
-    assert min_a < 0  # Should be negative (braking)
-    assert max_a > 0  # Should be positive (acceleration)
-
-    # Test with disabled controller
-    mock_params.bool_data['VibePersonalityEnabled'] = False
-    limits = controller.get_accel_limits(10.0)
-    assert limits is None
-
-  def test_follow_distance_multiplier(self, controller, mock_params):
-    """Test following distance multiplier calculation"""
-    # Enable controller
-    mock_params.bool_data['VibePersonalityEnabled'] = True
-    mock_params.bool_data['VibeFollowPersonalityEnabled'] = True
-
-    # Test with different speeds and personalities
-    controller.long_personality = LongPersonality.relaxed
-
-    multiplier = controller.get_follow_distance_multiplier(15.0)  # 15 m/s
-    assert multiplier is not None
-    assert isinstance(multiplier, float)
-    assert multiplier > 0
-
-    # Test with different personality - aggressive should have shorter distance
-    controller.long_personality = LongPersonality.aggressive
-    aggressive_multiplier = controller.get_follow_distance_multiplier(15.0)
-    assert aggressive_multiplier is not None
-    assert aggressive_multiplier < multiplier  # Aggressive should have shorter distance
-
-    # Test with disabled controller
-    mock_params.bool_data['VibeFollowPersonalityEnabled'] = False
-    multiplier = controller.get_follow_distance_multiplier(15.0)
-    assert multiplier is None
-
-  def test_personality_differences(self, controller, mock_params):
-    """Test that different personalities actually produce different values"""
-    # Enable controller
-    mock_params.bool_data['VibePersonalityEnabled'] = True
-    mock_params.bool_data['VibeAccelPersonalityEnabled'] = True
-    mock_params.bool_data['VibeFollowPersonalityEnabled'] = True
-
-    # Test acceleration differences - sport should have higher max acceleration than eco
-    controller.accel_personality = AccelPersonality.eco
-    eco_limits = controller.get_accel_limits(20.0)
-
-    controller.accel_personality = AccelPersonality.sport
-    sport_limits = controller.get_accel_limits(20.0)
-
-    assert sport_limits[1] > eco_limits[1]  # Sport should have higher max acceleration
-
-    # Test following distance differences - relaxed should have longer distance than aggressive
-    controller.long_personality = LongPersonality.relaxed
-    relaxed_dist = controller.get_follow_distance_multiplier(20.0)
-
-    controller.long_personality = LongPersonality.aggressive
-    aggressive_dist = controller.get_follow_distance_multiplier(20.0)
-
-    assert relaxed_dist > aggressive_dist  # Relaxed should have longer following distance
-
-  def test_reset(self, controller):
-    """Test reset functionality"""
-    # Change some values
-    controller.accel_personality = AccelPersonality.sport
-    controller.long_personality = LongPersonality.relaxed
-    controller.frame = 100
-
-    # Reset
-    controller.reset()
-
-    # Check defaults are restored
-    assert controller.accel_personality == AccelPersonality.normal
-    assert controller.long_personality == LongPersonality.standard
-    assert controller.frame == 0
-
-  def test_edge_cases(self, controller, mock_params):
-    """Test edge cases and error handling"""
-    # Enable all features
-    mock_params.bool_data = {
-      'VibePersonalityEnabled': True,
-      'VibeAccelPersonalityEnabled': True,
-      'VibeFollowPersonalityEnabled': True
-    }
-
-    # Test with zero speed
-    limits = controller.get_accel_limits(0.0)
-    assert limits is not None
-
-    multiplier = controller.get_follow_distance_multiplier(0.0)
-    assert multiplier is not None
-
-    # Test with very high speed
-    limits = controller.get_accel_limits(100.0)
-    assert limits is not None
-
-    multiplier = controller.get_follow_distance_multiplier(100.0)
-    assert multiplier is not None
-
-    # Test interpolation works correctly
-    low_speed_limits = controller.get_accel_limits(5.0)
-    high_speed_limits = controller.get_accel_limits(50.0)
-    assert low_speed_limits[1] > high_speed_limits[1]  # Max accel should decrease with speed

sunnypilot/selfdrive/controls/lib/vibe_personality/vibe_personality.py

@@ -1,144 +0,0 @@
-"""
-Copyright (c) 2021-, rav4kumar, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from cereal import log, custom
-import numpy as np
-from openpilot.common.realtime import DT_MDL
-from openpilot.common.params import Params
-
-LongPersonality = log.LongitudinalPersonality
-AccelPersonality = custom.LongitudinalPlanSP.AccelerationPersonality
-
-# Acceleration Profiles mapped to AccelPersonality (eco/normal/sport)
-MAX_ACCEL_PROFILES = {
-    AccelPersonality.eco:       [2.0,  1.99,  1.88, 1.10, .500, .292, .15, .10],   # eco
-    AccelPersonality.normal:    [2.0,  2.00,  1.94, 1.22, .635, .33, .22, .16],   # normal
-    AccelPersonality.sport:     [2.0,  2.00,  2.00, 1.85, .800, .54, .32, .22],    # sport
-}
-MAX_ACCEL_BREAKPOINTS =         [0.,   4.,   6.,   9.,   16.,  25.,  30., 55.]
-
-# Braking profiles mapped to LongPersonality (relaxed/standard/aggressive)
-MIN_ACCEL_PROFILES = {
-    LongPersonality.relaxed:    [-.0006, -.0006, -.010,  -.30,  -1.20],  # gentler braking
-    LongPersonality.standard:   [-.0007, -.0007, -.012,  -.35,  -1.20],  # normal braking
-    LongPersonality.aggressive: [-.0020, -.0008, -.014,  -.40,  -1.20],  # more aggressive braking
-}
-MIN_ACCEL_BREAKPOINTS =         [0.,   3.0,    11.,    14,  50.]
-
-# Follow distance profiles mapped to LongPersonality (relaxed/standard/aggressive)
-FOLLOW_PROFILES = {
-    LongPersonality.relaxed:    [1.55, 1.65, 1.65, 1.80],  # more spread out
-    LongPersonality.standard:   [1.45, 1.45, 1.45, 1.55],  # balanced
-    LongPersonality.aggressive: [1.20, 1.25, 1.28, 1.35],  # tighter
-}
-FOLLOW_BREAKPOINTS =            [0.,   6.,   18.,  36.]
-
-
-class VibePersonalityController:
-    """Controller for acceleration and distance personalities"""
-
-    def __init__(self):
-        self.params = Params()
-        self.frame = 0
-        self.accel_personality = AccelPersonality.normal
-        self.long_personality = LongPersonality.standard
-        self.param_keys = {
-            'accel_personality': 'AccelPersonality',
-            'long_personality': 'LongitudinalPersonality',
-            'enabled': 'VibePersonalityEnabled',
-            'accel_enabled': 'VibeAccelPersonalityEnabled',
-            'follow_enabled': 'VibeFollowPersonalityEnabled'
-        }
-
-    def _update_from_params(self):
-        """Update personalities from params"""
-        if self.frame % int(1. / DT_MDL) != 0:
-            return
-
-        accel_personality_int = int(self.params.get(self.param_keys['accel_personality']))
-        self.accel_personality = accel_personality_int
-
-        long_personality_int = int(self.params.get(self.param_keys['long_personality']))
-        self.long_personality = long_personality_int
-
-    def _get_toggle_state(self, key: str) -> bool:
-        return self.params.get_bool(self.param_keys[key])
-
-    def _set_toggle_state(self, key: str, value: bool):
-        self.params.put_bool(self.param_keys[key], value)
-
-    def set_accel_personality(self, personality: int) -> bool:
-        self.accel_personality = personality
-        self.params.put(self.param_keys['accel_personality'], str(personality))
-        return True
-
-    def cycle_accel_personality(self) -> int:
-        personalities = [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]
-        current_idx = personalities.index(self.accel_personality)
-        next_personality = personalities[(current_idx + 1) % len(personalities)]
-        self.set_accel_personality(next_personality)
-        return int(next_personality)
-
-    def get_accel_personality(self) -> int:
-        self._update_from_params()
-        return int(self.accel_personality)
-
-    def set_long_personality(self, personality: int) -> bool:
-        self.long_personality = personality
-        self.params.put(self.param_keys['long_personality'], str(personality))
-        return True
-
-    def cycle_long_personality(self) -> int:
-        personalities = [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]
-        current_idx = personalities.index(self.long_personality)
-        next_personality = personalities[(current_idx + 1) % len(personalities)]
-        self.set_long_personality(next_personality)
-        return int(next_personality)
-
-    def get_long_personality(self) -> int:
-        self._update_from_params()
-        return int(self.long_personality)
-
-    def toggle_personality(self): return self._toggle_flag('enabled')
-    def toggle_accel_personality(self): return self._toggle_flag('accel_enabled')
-    def toggle_follow_distance_personality(self): return self._toggle_flag('follow_enabled')
-
-    def _toggle_flag(self, key):
-        current = self._get_toggle_state(key)
-        self._set_toggle_state(key, not current)
-        return not current
-
-    def set_personality_enabled(self, enabled: bool): self._set_toggle_state('enabled', enabled)
-    def is_accel_enabled(self) -> bool: return self._get_toggle_state('enabled') and self._get_toggle_state('accel_enabled')
-    def is_follow_enabled(self) -> bool: return self._get_toggle_state('enabled') and self._get_toggle_state('follow_enabled')
-    def is_enabled(self) -> bool: return self._get_toggle_state('enabled') and (self._get_toggle_state('accel_enabled') or self._get_toggle_state('follow_enabled'))
-
-    def get_accel_limits(self, v_ego: float) -> tuple[float, float]:
-        """Get acceleration limits based on current personalities."""
-        self._update_from_params()
-        max_a = np.interp(v_ego, MAX_ACCEL_BREAKPOINTS, MAX_ACCEL_PROFILES[self.accel_personality])
-        min_a = np.interp(v_ego, MIN_ACCEL_BREAKPOINTS, MIN_ACCEL_PROFILES[self.long_personality])
-        return float(min_a), float(max_a)
-
-    def get_follow_distance_multiplier(self, v_ego: float) -> float:
-        """Get dynamic following distance based on speed and personality"""
-        self._update_from_params()
-        return float(np.interp(v_ego, FOLLOW_BREAKPOINTS, FOLLOW_PROFILES[self.long_personality]))
-
-    def get_min_accel(self, v_ego: float) -> float:
-        return self.get_accel_limits(v_ego)[0]
-
-    def get_max_accel(self, v_ego: float) -> float:
-        return self.get_accel_limits(v_ego)[1]
-
-    def reset(self):
-        self.accel_personality = AccelPersonality.normal
-        self.long_personality = LongPersonality.standard
-        self.frame = 0
-
-    def update(self):
-        self.frame += 1

sunnypilot/selfdrive/selfdrived/events.py

@@ -226,12 +226,4 @@ EVENTS_SP: dict[int, dict[str, Alert | AlertCallbackType]] = {
       AlertStatus.normal, AlertSize.none,
       Priority.MID, VisualAlert.none, AudibleAlert.prompt, 3.),
   },
-
-  EventNameSP.laneChangeRoadEdge: {
-    ET.WARNING: Alert(
-      "Lane Change Unavailable: Road Edge",
-      "",
-      AlertStatus.userPrompt, AlertSize.small,
-      Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 0.1),
-  },
 }

system/manager/process_config.py

@@ -178,15 +178,14 @@ procs += [
   PythonProcess("backup_manager", "sunnypilot.sunnylink.backups.manager", and_(only_offroad, sunnylink_ready_shim)),
 
   # mapd
-  #NativeProcess("mapd", Paths.mapd_root(), ["bash", "-c", f"{MAPD_PATH} > /dev/null 2>&1"], mapd_ready),
-  #PythonProcess("mapd_manager", "sunnypilot.mapd.mapd_manager", always_run),
-  NativeProcess("mapd", "selfdrive", ["./mapd"], always_run),
+  NativeProcess("mapd", Paths.mapd_root(), ["bash", "-c", f"{MAPD_PATH} > /dev/null 2>&1"], mapd_ready),
+  PythonProcess("mapd_manager", "sunnypilot.mapd.mapd_manager", always_run),
 
   # navigationd
   PythonProcess("navigationd", "sunnypilot.navd.navigationd", only_onroad),
 
   # locationd
-  #NativeProcess("locationd_llk", "sunnypilot/selfdrive/locationd", ["./locationd"], only_onroad),
+  NativeProcess("locationd_llk", "sunnypilot/selfdrive/locationd", ["./locationd"], only_onroad),
 ]
 
 if os.path.exists("./github_runner.sh"):