ui: drop restating accel boost comments

sunnylink-hide-steering-arc-mici

openpilot/common/params_keys.h

@@ -149,6 +149,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"Version", {PERSISTENT, STRING}},
 
     // --- sunnypilot params --- //
+    {"AccelBoostSP", {PERSISTENT | BACKUP, BOOL, "1"}},
     {"ApiCache_DriveStats", {PERSISTENT, JSON}},
     {"AutoLaneChangeBsmDelay", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"AutoLaneChangeTimer", {PERSISTENT | BACKUP, INT, "0"}},
@@ -170,7 +171,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"DevUIInfo", {PERSISTENT | BACKUP, INT, "0"}},
     {"EnableCopyparty", {PERSISTENT | BACKUP, BOOL}},
     {"EnableGithubRunner", {PERSISTENT | BACKUP, BOOL}},
-    {"FollowDistanceAccelBoost", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"GreenLightAlert", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"GithubRunnerSufficientVoltage", {CLEAR_ON_MANAGER_START , BOOL}},
     {"HasAcceptedTermsSP", {PERSISTENT, STRING, "0"}},

openpilot/selfdrive/controls/tests/test_accel_boost.py

@@ -1,101 +0,0 @@
-from types import SimpleNamespace
-
-from openpilot.cereal import log
-from openpilot.common.realtime import DT_MDL
-from openpilot.common.test import OpenpilotTestCase
-from openpilot.selfdrive.controls.lib.accel_boost import (
-  AccelBoost, ACCEL_BOOST_MAX, ACCEL_BOOST_PER_OVERRIDE, ACCEL_BOOST_RATE
-)
-
-E2E_ACCEL = 0.5
-PLANNER_ACCEL = 2.0
-RATE_PER_STEP = ACCEL_BOOST_RATE * DT_MDL
-
-
-class FakeSubMaster:
-  def __init__(self, enabled=True, gas_pressed=False, v_ego=15.0,
-               personality=log.LongitudinalPersonality.standard):
-    self._messages = {
-      'selfdriveState': SimpleNamespace(enabled=enabled, personality=personality),
-      'carState': SimpleNamespace(gasPressed=gas_pressed, vEgo=v_ego),
-    }
-
-  def __getitem__(self, key):
-    return self._messages[key]
-
-
-def run_boost(boost, sm, steps=1):
-  out = E2E_ACCEL
-  for _ in range(steps):
-    out = boost.update(sm, E2E_ACCEL, PLANNER_ACCEL, PLANNER_ACCEL)
-  return out
-
-
-class TestAccelBoost(OpenpilotTestCase):
-  def _boost_to_max(self):
-    boost = AccelBoost()
-    sm = FakeSubMaster()
-    steps = round(ACCEL_BOOST_PER_OVERRIDE / RATE_PER_STEP)
-    # Eligibility is latched on a frame without gas, then applied on the next override.
-    run_boost(boost, sm)
-    for _ in range(10):
-      sm['carState'].gasPressed = True
-      run_boost(boost, sm, steps)
-      sm['carState'].gasPressed = False
-      run_boost(boost, sm)
-    return boost
-
-  def test_no_boost_without_gas(self):
-    boost = AccelBoost()
-    sm = FakeSubMaster(gas_pressed=False)
-    out = run_boost(boost, sm)
-    self.assertEqual(boost.total_boost, 0.0)
-    self.assertAlmostEqual(out, E2E_ACCEL)
-
-  def test_boost_requires_e2e_to_be_limiting(self):
-    boost = AccelBoost()
-    sm = FakeSubMaster(gas_pressed=False)
-    # Eligibility is latched before the override, so keep the e2e plan at the planner limit here.
-    boost.update(sm, E2E_ACCEL, E2E_ACCEL, E2E_ACCEL)
-    sm['carState'].gasPressed = True
-    for _ in range(10):
-      boost.update(sm, E2E_ACCEL, E2E_ACCEL, E2E_ACCEL)
-    self.assertEqual(boost.total_boost, 0.0)
-
-  def test_per_override_cap(self):
-    boost = AccelBoost()
-    sm = FakeSubMaster(gas_pressed=False)
-    run_boost(boost, sm)
-    sm['carState'].gasPressed = True
-    run_boost(boost, sm, 1000)
-    self.assertAlmostEqual(boost.total_boost, ACCEL_BOOST_PER_OVERRIDE)
-
-  def test_max_boost(self):
-    boost = self._boost_to_max()
-    self.assertAlmostEqual(boost.total_boost, ACCEL_BOOST_MAX)
-
-  def test_boost_is_applied_to_e2e_accel(self):
-    boost = self._boost_to_max()
-    sm = FakeSubMaster(gas_pressed=True)
-    out = run_boost(boost, sm)
-    self.assertAlmostEqual(out, E2E_ACCEL + boost.total_boost)
-
-  def test_boost_does_not_depend_on_following_distance(self):
-    totals = []
-    for personality in (log.LongitudinalPersonality.relaxed,
-                        log.LongitudinalPersonality.standard,
-                        log.LongitudinalPersonality.aggressive):
-      boost = AccelBoost()
-      sm = FakeSubMaster(personality=personality)
-      steps = round(ACCEL_BOOST_PER_OVERRIDE / RATE_PER_STEP)
-      run_boost(boost, sm)
-      for _ in range(10):
-        sm['carState'].gasPressed = True
-        run_boost(boost, sm, steps)
-        sm['carState'].gasPressed = False
-        run_boost(boost, sm)
-      totals.append(boost.total_boost)
-
-    self.assertEqual(len(totals), 3)
-    for total in totals:
-      self.assertAlmostEqual(total, ACCEL_BOOST_MAX)

openpilot/selfdrive/ui/mici/layouts/settings/toggles.py

@@ -21,9 +21,6 @@ class TogglesLayoutMici(NavScroller):
                                                                "Use the steering wheel distance button on supported cars.")
     self._initial_cruise_speed = InitialCruiseSpeedButton()
     self._initial_cruise_speed.set_visible(lambda: ui_state.CP is not None and ui_state.has_longitudinal_control and not ui_state.CP.pcmCruise)
-    self._accel_boost_toggle = BigParamControl("extra acceleration boost", "FollowDistanceAccelBoost",
-                                               description="Adds extra acceleration on top of the stock gas-override boost.\n" +
-                                                           "The extra boost follows Following Distance: strongest when Aggressive, weakest when Relaxed.")
     is_metric_toggle = BigToggle("use metric units", initial_state=ui_state.params.get_bool("IsMetric"), toggle_callback=self._on_metric_toggle)
     ldw_toggle = BigParamControl("lane departure warnings", "IsLdwEnabled",
                                  description="Warn when you drift across a detected lane line.\n" +
@@ -43,7 +40,6 @@ class TogglesLayoutMici(NavScroller):
 
     self._scroller.add_widgets([
       self._personality_toggle,
-      self._accel_boost_toggle,
       self._initial_cruise_speed,
       is_metric_toggle,
       ldw_toggle,
@@ -55,7 +51,6 @@ class TogglesLayoutMici(NavScroller):
 
     # Toggle lists
     self._refresh_toggles = (
-      ("FollowDistanceAccelBoost", self._accel_boost_toggle),
       ("IsMetric", is_metric_toggle),
       ("IsLdwEnabled", ldw_toggle),
       ("AlwaysOnDM", always_on_dm_toggle),
@@ -97,7 +92,6 @@ class TogglesLayoutMici(NavScroller):
 
     if ui_state.CP is not None:
       self._personality_toggle.set_visible(ui_state.has_longitudinal_control)
-      self._accel_boost_toggle.set_visible(ui_state.has_longitudinal_control)
 
     # Refresh toggles from params to mirror external changes
     for key, item in self._refresh_toggles:

openpilot/selfdrive/ui/mici/onroad/augmented_road_view.py

@@ -181,8 +181,7 @@ class AugmentedRoadView(CameraView):
     self._long_indicator = LongIndicator()
     self._alert_renderer = AlertRenderer()
     self._driver_state_renderer = DriverStateRenderer()
-    self._confidence_ball = ConfidenceBall()
-    self._accel_boost_indicator = AccelBoostIndicator() if gui_app.sunnypilot_ui() else None
+    self._confidence_ball = AccelBoostIndicator(ConfidenceBall()) if gui_app.sunnypilot_ui() else ConfidenceBall()
     self._offroad_label = UnifiedLabel("start the car to\nuse sunnypilot", 54, FontWeight.DISPLAY,
                                        text_color=rl.Color(255, 255, 255, int(255 * 0.9)),
                                        alignment=TextAlignment.CENTER,
@@ -277,13 +276,7 @@ class AugmentedRoadView(CameraView):
     if show_navigation:
       self._navigation.render(rl.Rectangle(self._content_rect.x + self._content_rect.width, self.rect.y, PANEL_WIDTH, self.rect.height))
     else:
-      # The boost bar owns the side panel while the extra boost is on; the ball only shows with the feature off
-      if gui_app.sunnypilot_ui():
-        self._accel_boost_indicator.render(self.rect)
-        if not self._accel_boost_indicator.panel_in_use:
-          self._confidence_ball.render(self.rect)
-      else:
-        self._confidence_ball.render(self.rect)
+      self._confidence_ball.render(self.rect)
 
     self._bookmark_icon.render(self.rect)
 

openpilot/selfdrive/ui/sunnypilot/layouts/settings/cruise.py

@@ -30,11 +30,6 @@ ACC_NOLONG_DESCRIPTION = tr_noop("This feature can only be used with sunnypilot
 ACC_PCMCRUISE_DISABLED_DESCRIPTION = tr_noop("This feature is not supported on this platform due to vehicle limitations.")
 ONROAD_ONLY_DESCRIPTION = tr_noop("Start the vehicle to check vehicle compatibility.")
 
-ACCEL_BOOST_EXT_DESCRIPTION = tr_noop("Adds extra acceleration on top of the stock gas-override boost when you hold the gas pedal " +
-                                       "while sunnypilot longitudinal control is active. The extra boost follows the Following Distance setting: " +
-                                       "strongest when Aggressive, weakest when Relaxed. The stock boost remains active when this is off.")
-ACCEL_BOOST_EXT_NOLONG_DESCRIPTION = tr_noop("This feature requires sunnypilot longitudinal control to be available.")
-
 
 class CruiseLayout(Widget):
   def __init__(self):
@@ -62,6 +57,12 @@ class CruiseLayout(Widget):
       description=tr("Use map data to estimate the appropriate speed to drive through turns ahead."),
       param="SmartCruiseControlMap")
 
+    self.accel_boost_toggle = toggle_item_sp(
+      title=tr("Acceleration Boost"),
+      description=tr("Adds a small push on top of sunnypilot's own acceleration, stronger in Aggressive and gentler in Relaxed. " +
+                     "Eases off in curves and when sunnypilot slows or stops. Never goes past your set speed, and lead-car following still comes first."),
+      param="AccelBoostSP")
+
     self.custom_acc_toggle = toggle_item_sp(
       title=tr("Custom ACC Speed Increments"),
       description="",
@@ -81,11 +82,6 @@ class CruiseLayout(Widget):
       min_value=1, max_value=3, value_change_step=1,
       inline=True)
 
-    self.accel_boost_toggle = toggle_item_sp(
-      title=tr("Extra Acceleration Boost by Following Distance"),
-      description="",
-      param="FollowDistanceAccelBoost")
-
     self.sla_settings_button = simple_button_item_sp(
       button_text=lambda: tr("Speed Limit"),
       button_width=800,
@@ -115,7 +111,6 @@ class CruiseLayout(Widget):
     self._scroller.show_event()
     self.icbm_toggle.show_description(True)
     self.custom_acc_toggle.show_description(True)
-    self.accel_boost_toggle.show_description(True)
 
   def _set_current_panel(self, panel: PanelType):
     self._current_panel = panel
@@ -148,6 +143,8 @@ class CruiseLayout(Widget):
           self.icbm_toggle.set_description(new_desc)
           self.icbm_toggle.show_description(True)
 
+      self.accel_boost_toggle.action_item.set_enabled(has_long)
+
       if has_long or has_icbm:
         self.custom_acc_toggle.action_item.set_enabled(((has_long and not ui_state.CP.pcmCruise) or has_icbm) and ui_state.is_offroad())
         self.scc_v_toggle.action_item.set_enabled(True)
@@ -160,17 +157,11 @@ class CruiseLayout(Widget):
         self.scc_v_toggle.action_item.set_enabled(False)
         self.scc_m_toggle.action_item.set_enabled(False)
 
-      self.accel_boost_toggle.action_item.set_enabled(has_long)
-      boost_desc = tr(ACCEL_BOOST_EXT_DESCRIPTION) if has_long else tr(ACCEL_BOOST_EXT_NOLONG_DESCRIPTION)
-      if self.accel_boost_toggle.description != boost_desc:
-        self.accel_boost_toggle.set_description(boost_desc)
-        self.accel_boost_toggle.show_description(True)
-
     else:
       has_icbm = has_long = False
       self.icbm_toggle.action_item.set_enabled(False)
-      self.icbm_toggle.set_description(tr(ONROAD_ONLY_DESCRIPTION))
       self.accel_boost_toggle.action_item.set_enabled(False)
+      self.icbm_toggle.set_description(tr(ONROAD_ONLY_DESCRIPTION))
 
     show_custom_acc_desc = False
 

openpilot/selfdrive/ui/sunnypilot/mici/onroad/accel_boost_indicator.py

@@ -9,27 +9,48 @@ import pyray as rl
 from openpilot.cereal import log
 from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.selfdrive.ui.mici.onroad import SIDE_PANEL_WIDTH
+from openpilot.selfdrive.ui.mici.onroad.hud_renderer import SET_SPEED_PERSISTENCE
 from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import ACCEL_BOOST_MAX
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import Widget
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost_ext import get_accel_boost_max
 
-# The readout is wider than the side panel, so the value is right-aligned and bleeds over the camera view
-BAR_WIDTH = 24
-# Fades to white only near the profile cap, like the stock torque bar fading toward orange at high torque
-CAP_BLEND_START = 0.75
-MAX_BOOST_BLEND = 0.45
+BAR_WIDTH = 26
+BAR_RADIUS = 0.5
+TRACK_TOP_RATIO = 0.08
+TRACK_BOTTOM_RATIO = 0.92
+CAP_BLEND_START = 0.70
+MAX_BOOST_BLEND = 0.55
 
-COLOR_TRACK = rl.Color(255, 255, 255, 45)
+COLOR_TRACK = rl.Color(255, 255, 255, 32)
 COLOR_TRACK_EDGE = rl.Color(255, 255, 255, 70)
+COLOR_HIGHLIGHT = rl.Color(255, 255, 255, 45)
 
 AGGRESSIVE_COLOR = rl.Color(255, 80, 60, 255)
 STANDARD_COLOR = rl.Color(0, 230, 120, 255)
 RELAXED_COLOR = rl.Color(70, 150, 255, 255)
 
+# The personality enum is ordered aggressive, standard, relaxed, matching ACCEL_BOOST_MAX
+PROFILE_STYLES = {
+  0: (AGGRESSIVE_COLOR, ACCEL_BOOST_MAX[0]),
+  1: (STANDARD_COLOR, ACCEL_BOOST_MAX[1]),
+  2: (RELAXED_COLOR, ACCEL_BOOST_MAX[2]),
+}
+
 FADE_THRESHOLD = 0.01
 
 
+def get_boost_style(personality) -> tuple[rl.Color, float]:
+  raw = getattr(personality, "raw", personality)
+  return PROFILE_STYLES.get(int(raw), PROFILE_STYLES[1])
+
+
+def get_boost_fraction(boost: float, max_boost: float) -> float:
+  if max_boost <= 0.0:
+    return 0.0
+  return min(max(boost / max_boost, 0.0), 1.0)
+
+
 def lighten(color: rl.Color, amount: float) -> rl.Color:
   """Lerp towards white in RGB, so the hue stays put the way HSV blending would not."""
   amount = min(max(amount, 0.0), 1.0)
@@ -38,85 +59,87 @@ def lighten(color: rl.Color, amount: float) -> rl.Color:
                   int(color.b + (255 - color.b) * amount), color.a)
 
 
-def get_boost_fraction(boost: float, max_boost: float) -> float:
-  """How much of the active profile's boost budget is in use, clamped to a full bar."""
-  if max_boost <= 0.0:
-    return 0.0
-  return min(max(boost / max_boost, 0.0), 1.0)
-
-
-def get_boost_style(personality) -> tuple[rl.Color, float]:
-  if personality == log.LongitudinalPersonality.aggressive:
-    color = AGGRESSIVE_COLOR
-  elif personality == log.LongitudinalPersonality.relaxed:
-    color = RELAXED_COLOR
-  else:
-    color = STANDARD_COLOR
-
-  return color, get_accel_boost_max(personality)
-
-
 class AccelBoostIndicator(Widget):
-  def __init__(self):
+  def __init__(self, fallback: Widget | None = None, panel_width: float = SIDE_PANEL_WIDTH, bar_width: float = BAR_WIDTH):
     super().__init__()
-    self._boost_filter = FirstOrderFilter(0.0, 0.15, 1 / gui_app.target_fps)
-    self._alpha_filter = FirstOrderFilter(0.0, 0.1, 1 / gui_app.target_fps)
-    # Smoothly rescale the bar when the follow distance profile changes mid-drive
-    self._max_boost_filter = FirstOrderFilter(0.0, 0.25, 1 / gui_app.target_fps)
-    self._profile_color = STANDARD_COLOR
-    self._max_boost = 0.0
+    self._fallback = fallback
+    self._panel_width = panel_width
+    self._bar_width = bar_width
+    fps = max(gui_app.target_fps, 1)
+    self._boost_filter = FirstOrderFilter(0.0, 0.15, 1 / fps)
+    self._alpha_filter = FirstOrderFilter(0.0, 0.1, 1 / fps)
+    self._max_boost_filter = FirstOrderFilter(0.0, 0.25, 1 / fps)
+    self._profile_color, self._max_boost = PROFILE_STYLES[1]
 
-    self.panel_in_use = False
+    self._applied_time = float('-inf')
 
   def _update_state(self):
     sm = ui_state.sm
-    extra_enabled = ui_state.follow_distance_accel_boost
-    visible = (ui_state.has_longitudinal_control and sm.alive['selfdriveState'] and sm.alive['longitudinalPlan'] and
-               sm['selfdriveState'].enabled)
-    self._alpha_filter.update(1.0 if visible and extra_enabled else 0.0)
-    self._boost_filter.update(float(sm['longitudinalPlan'].accelBoost) if visible else 0.0)
+    visible = (ui_state.accel_boost and ui_state.has_longitudinal_control and sm.alive['selfdriveState'] and
+               sm.alive['longitudinalPlan'] and sm['selfdriveState'].enabled)
+    plan = sm['longitudinalPlan']
+    # boost only moves the car while e2e wins the planner's min()
+    if visible and plan.accelBoost > FADE_THRESHOLD and plan.longitudinalPlanSource == log.LongitudinalPlan.LongitudinalPlanSource.e2e:
+      self._applied_time = rl.get_time()
+    visible = visible and rl.get_time() - self._applied_time < SET_SPEED_PERSISTENCE
+    self._alpha_filter.update(1.0 if visible else 0.0)
+    self._boost_filter.update(float(plan.accelBoost) if visible else 0.0)
 
     if sm.alive['selfdriveState']:
       self._profile_color, self._max_boost = get_boost_style(sm['selfdriveState'].personality)
     self._max_boost_filter.update(self._max_boost)
 
-    # The bar owns the panel only while it is actually drawn; the ball returns when the bar fades out
-    self.panel_in_use = visible and extra_enabled
-
   def _render(self, _):
     alpha = self._alpha_filter.x
     if alpha < FADE_THRESHOLD or self._max_boost <= 0.0:
+      if self._fallback is not None:
+        self._fallback.render(self.rect)
       return
 
-    cx = self.rect.x + self.rect.width - SIDE_PANEL_WIDTH / 2
-    bar_x = cx - BAR_WIDTH / 2
-    track_top = self.rect.y + self.rect.height * 0.08
-    track_bottom = self.rect.y + self.rect.height * 0.92
+    bar_w = self._bar_width
+    cx = self.rect.x + self.rect.width - self._panel_width / 2
+    bar_x = cx - bar_w / 2
+    track_top = self.rect.y + self.rect.height * TRACK_TOP_RATIO
+    track_bottom = self.rect.y + self.rect.height * TRACK_BOTTOM_RATIO
     track_h = max(1.0, track_bottom - track_top)
+    track_rect = rl.Rectangle(bar_x, track_top, bar_w, track_h)
 
-    # track, light enough to read on the black side panel
-    rl.draw_rectangle_rounded(rl.Rectangle(bar_x, track_top, BAR_WIDTH, track_h), 0.5, 12,
+    rl.draw_rectangle_rounded(rl.Rectangle(bar_x - 3, track_top - 3, bar_w + 6, track_h + 6), BAR_RADIUS, 12,
+                              rl.Color(0, 0, 0, int(80 * alpha)))
+
+    rl.draw_rectangle_rounded(track_rect, BAR_RADIUS, 12,
                               rl.Color(COLOR_TRACK.r, COLOR_TRACK.g, COLOR_TRACK.b, int(COLOR_TRACK.a * alpha)))
-    rl.draw_rectangle_rounded_lines_ex(rl.Rectangle(bar_x, track_top, BAR_WIDTH, track_h), 0.5, 12, 1,
+    rl.draw_rectangle_rounded_lines_ex(track_rect, BAR_RADIUS, 12, 1,
                                        rl.Color(COLOR_TRACK_EDGE.r, COLOR_TRACK_EDGE.g, COLOR_TRACK_EDGE.b,
                                                 int(COLOR_TRACK_EDGE.a * alpha)))
 
-    # Scale to the current profile's cap, so a maxed boost fills the bar and a profile change rescales it
     boost = max(self._boost_filter.x, 0.0)
     ratio = get_boost_fraction(boost, self._max_boost_filter.x)
     fill_h = ratio * track_h
+    if fill_h <= 0.0:
+      return
+
     cap_blend = max(0.0, (ratio - CAP_BLEND_START) / (1.0 - CAP_BLEND_START))
     fill_color = lighten(self._profile_color, MAX_BOOST_BLEND * cap_blend)
-    if fill_h > 0.0:
-      # soft glow around the tip, like the confidence ball's gradient
-      tip_y = track_bottom - fill_h
-      glow = rl.Color(fill_color.r, fill_color.g, fill_color.b, int(70 * alpha))
-      rl.draw_circle_gradient(rl.Vector2(cx, tip_y), int(BAR_WIDTH * 0.9), glow, rl.BLANK)
+    tip_y = track_bottom - fill_h
 
-      fill = rl.Color(fill_color.r, fill_color.g, fill_color.b, int(255 * alpha))
-      if fill_h < BAR_WIDTH:
-        # Keep the cap inside the track: a fixed radius would paint below the track near zero boost
-        radius = max(1, int(fill_h / 2))
-        rl.draw_circle(int(cx), int(track_bottom - radius), radius, fill)
-      else:
-        rl.draw_rectangle_rounded(rl.Rectangle(bar_x, track_bottom - fill_h, BAR_WIDTH, fill_h), 0.5, 12, fill)
+    tip_center_y = tip_y + min(fill_h, bar_w) / 2
+    glow = rl.Color(fill_color.r, fill_color.g, fill_color.b, int(85 * alpha))
+    rl.draw_circle_gradient(rl.Vector2(cx, tip_center_y), int(bar_w * 0.85), glow, rl.BLANK)
+
+    fill = rl.Color(fill_color.r, fill_color.g, fill_color.b, int(255 * alpha))
+    if fill_h < bar_w:
+      # Keep the cap inside the track: a fixed radius would paint below the track near zero boost
+      radius = max(1, int(fill_h / 2))
+      rl.draw_circle(int(cx), int(track_bottom - radius), radius, fill)
+    else:
+      rl.draw_rectangle_rounded(rl.Rectangle(bar_x, tip_y, bar_w, fill_h), BAR_RADIUS, 12, fill)
+
+      if fill_h > 12:
+        highlight_rect = rl.Rectangle(bar_x + 4, tip_y + 5, 3, fill_h - 10)
+        rl.draw_rectangle_rounded(highlight_rect, 0.5, 8,
+                                  rl.Color(COLOR_HIGHLIGHT.r, COLOR_HIGHLIGHT.g, COLOR_HIGHLIGHT.b,
+                                           int(COLOR_HIGHLIGHT.a * alpha)))
+
+      rl.draw_circle(int(cx), int(tip_center_y), 2,
+                     rl.Color(255, 255, 255, int(150 * alpha)))

openpilot/selfdrive/ui/sunnypilot/mici/tests/test_accel_boost_indicator.py

@@ -4,56 +4,48 @@ Copyright (c) 2021-, 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 unittest
-
 from openpilot.cereal import log
-from openpilot.selfdrive.controls.lib.accel_boost import ACCEL_BOOST_MAX
-from openpilot.selfdrive.ui.sunnypilot.mici.onroad.accel_boost_indicator import (get_boost_style, get_boost_fraction, lighten,
-                                                                                AGGRESSIVE_COLOR, RELAXED_COLOR, STANDARD_COLOR)
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost_ext import (SCALE_AGGRESSIVE, SCALE_RELAXED, SCALE_STANDARD,
-                                                                        get_accel_boost_max)
+from openpilot.common.test import OpenpilotTestCase
+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.accel_boost_indicator import (
+  get_boost_style, get_boost_fraction, lighten,
+  AGGRESSIVE_COLOR, RELAXED_COLOR, STANDARD_COLOR,
+)
+from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import ACCEL_BOOST_MAX
 
 
-class TestAccelBoostIndicator(unittest.TestCase):
-  def test_bar_scales_with_following_distance(self):
-    for personality, color, scale in (
-        (log.LongitudinalPersonality.relaxed, RELAXED_COLOR, SCALE_RELAXED),
-        (log.LongitudinalPersonality.standard, STANDARD_COLOR, SCALE_STANDARD),
-        (log.LongitudinalPersonality.aggressive, AGGRESSIVE_COLOR, SCALE_AGGRESSIVE)):
-      bar_color, full_scale = get_boost_style(personality)
-      self.assertEqual(bar_color, color)
-      self.assertAlmostEqual(full_scale, ACCEL_BOOST_MAX * (1.0 + scale))
+class TestAccelBoostIndicator(OpenpilotTestCase):
+  def test_profile_styles_match_controller_caps(self):
+    for personality, color, max_boost in (
+        (log.LongitudinalPersonality.aggressive, AGGRESSIVE_COLOR, ACCEL_BOOST_MAX[0]),
+        (log.LongitudinalPersonality.standard, STANDARD_COLOR, ACCEL_BOOST_MAX[1]),
+        (log.LongitudinalPersonality.relaxed, RELAXED_COLOR, ACCEL_BOOST_MAX[2])):
+      style_color, style_max = get_boost_style(personality)
+      assert style_color == color
+      assert style_max == max_boost
+
+  def test_wire_personality_picks_the_right_profile(self):
+    msg = log.SelfdriveState.new_message()
+    msg.personality = log.LongitudinalPersonality.aggressive
+    color, max_boost = get_boost_style(msg.personality)
+    assert color == AGGRESSIVE_COLOR
+    assert max_boost == ACCEL_BOOST_MAX[0]
 
   def test_bar_fills_at_the_active_profile_cap(self):
-    caps = [get_accel_boost_max(p) for p in (log.LongitudinalPersonality.relaxed,
-                                             log.LongitudinalPersonality.standard,
-                                             log.LongitudinalPersonality.aggressive)]
-    self.assertEqual(caps, sorted(caps))
-
-    for cap in caps:
-      self.assertAlmostEqual(get_boost_fraction(cap, cap), 1.0)
-      self.assertAlmostEqual(get_boost_fraction(0.0, cap), 0.0)
-      self.assertAlmostEqual(get_boost_fraction(cap * 0.5, cap), 0.5)
+    for cap in ACCEL_BOOST_MAX:
+      assert get_boost_fraction(0.0, cap) == 0.0
+      assert get_boost_fraction(cap * 0.5, cap) == 0.5
+      assert get_boost_fraction(cap, cap) == 1.0
 
     # A boost beyond the current cap (e.g. after switching to a shorter profile) still fills the bar
-    self.assertAlmostEqual(get_boost_fraction(caps[2], caps[0]), 1.0)
-    self.assertAlmostEqual(get_boost_fraction(0.0, 0.0), 0.0)
+    assert get_boost_fraction(max(ACCEL_BOOST_MAX), min(ACCEL_BOOST_MAX)) == 1.0
+    assert get_boost_fraction(0.0, 0.0) == 0.0
 
   def test_cap_lighten_keeps_the_profile_hue(self):
     # An HSV blend towards white sweeps relaxed blue through pink, so the fill lightens in RGB instead
     relaxed = lighten(RELAXED_COLOR, 0.45)
     aggressive = lighten(AGGRESSIVE_COLOR, 0.45)
-    self.assertGreater(relaxed.b, relaxed.r)
-    self.assertGreaterEqual(relaxed.b, relaxed.g)
-    self.assertGreater(aggressive.r, aggressive.b)
-    # lighter in RGB means the dimmest channel came up towards white
-    self.assertGreater(relaxed.r, RELAXED_COLOR.r)
-    self.assertGreater(aggressive.g, AGGRESSIVE_COLOR.g)
-
-  def test_wire_personality_picks_the_right_profile(self):
-    # Over the wire personality is a capnp DynamicEnum, which compares equal to the cereal enum but hashes differently
-    msg = log.SelfdriveState.new_message()
-    msg.personality = log.LongitudinalPersonality.aggressive
-    color, full_scale = get_boost_style(msg.personality)
-    self.assertEqual(color, AGGRESSIVE_COLOR)
-    self.assertAlmostEqual(full_scale, get_accel_boost_max(log.LongitudinalPersonality.aggressive))
+    assert relaxed.b > relaxed.r
+    assert relaxed.b >= relaxed.g
+    assert aggressive.r > aggressive.b
+    assert relaxed.r > RELAXED_COLOR.r
+    assert aggressive.g > AGGRESSIVE_COLOR.g

openpilot/selfdrive/ui/sunnypilot/onroad/hud_renderer.py

@@ -8,6 +8,7 @@ import pyray as rl
 
 from openpilot.common.constants import CV
 from openpilot.selfdrive.ui.mici.onroad.torque_bar import TorqueBar
+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.accel_boost_indicator import AccelBoostIndicator
 from openpilot.selfdrive.ui.sunnypilot.onroad.developer_ui import DeveloperUiRenderer, DeveloperUiState, get_bottom_dev_ui_offset
 from openpilot.selfdrive.ui.sunnypilot.onroad.road_name import RoadNameRenderer
 from openpilot.selfdrive.ui.sunnypilot.onroad.rocket_fuel import RocketFuel
@@ -37,6 +38,7 @@ class HudRendererSP(HudRenderer):
     self.circular_alerts_renderer = CircularAlertsRenderer()
     self.speed_renderer = SpeedRenderer()
     self._torque_bar = TorqueBar(scale=3.0, always=True)
+    self._accel_boost_indicator = AccelBoostIndicator(panel_width=72, bar_width=36)
 
     self.pcm_cruise_speed: bool = True
     self.show_icbm_status: bool = False
@@ -131,11 +133,15 @@ class HudRendererSP(HudRenderer):
   def _render(self, rect: rl.Rectangle) -> None:
     super()._render(rect)
 
+    hud_rect = rect
+    if ui_state.developer_ui in (DeveloperUiState.BOTTOM, DeveloperUiState.BOTH):
+      hud_rect = rl.Rectangle(rect.x, rect.y, rect.width, rect.height - get_bottom_dev_ui_offset())
     if ui_state.torque_bar:
-      torque_rect = rect
-      if ui_state.developer_ui in (DeveloperUiState.BOTTOM, DeveloperUiState.BOTH):
-        torque_rect = rl.Rectangle(rect.x, rect.y, rect.width, rect.height - get_bottom_dev_ui_offset())
-      self._torque_bar.render(torque_rect)
+      self._torque_bar.render(hud_rect)
+    boost_rect = hud_rect
+    if ui_state.developer_ui in (DeveloperUiState.RIGHT, DeveloperUiState.BOTH):
+      boost_rect = rl.Rectangle(hud_rect.x, hud_rect.y, hud_rect.width - 230, hud_rect.height)
+    self._accel_boost_indicator.render(boost_rect)
 
     self.developer_ui.render(rect)
     self.road_name_renderer.render(rect)

openpilot/selfdrive/ui/sunnypilot/ui_state.py

@@ -44,6 +44,7 @@ class UIStateSP:
     self.screensaver = ScreenSaverSP(params=self.params)
     self.screensaver_enabled: bool = False
 
+    self.accel_boost: bool = False
     self.active_bundle = None
     self.model_runner_tinygrad: bool = False
     self.active_runner_tinygrad: bool = False
@@ -65,7 +66,6 @@ class UIStateSP:
     self.enforce_torque_control: bool = False
     self.custom_torque_params: bool = False
     self.torque_override_enabled: bool = False
-    self.follow_distance_accel_boost: bool = False
     self._sp_initialized: bool = False
 
   def update(self) -> None:
@@ -172,6 +172,7 @@ class UIStateSP:
     # stock only counts the default big model's compiled pkl. a downloaded big bundle runs on the
     # chestnut just the same, so ChestnutState has to see it as available too.
     self.chestnut_compiled = self.chestnut_compiled or self.model_runner_tinygrad
+    self.accel_boost = self.params.get_bool("AccelBoostSP")
     self.blindspot = self.params.get_bool("BlindSpot")
     self.chevron_metrics = self.params.get("ChevronInfo")
     self.custom_interactive_timeout = self.params.get("InteractivityTimeout", return_default=True)
@@ -189,7 +190,6 @@ class UIStateSP:
     self.enforce_torque_control = self.params.get_bool("EnforceTorqueControl")
     self.custom_torque_params = self.params.get_bool("CustomTorqueParams")
     self.torque_override_enabled = self.params.get_bool("TorqueParamsOverrideEnabled")
-    self.follow_distance_accel_boost = self.params.get_bool("FollowDistanceAccelBoost")
     self.torque_override_lat_accel_factor = float(self.params.get("TorqueParamsOverrideLatAccelFactor", return_default=True))
     self.torque_override_friction = float(self.params.get("TorqueParamsOverrideFriction", return_default=True))
     self.true_v_ego_ui = self.params.get_bool("TrueVEgoUI")
@@ -244,10 +244,6 @@ class UIStateSP:
       self.params.remove("IntelligentCruiseButtonManagement")
       self.has_icbm = False
 
-    # Extra boost needs sunnypilot longitudinal control; ICBM alone is not enough
-    if not has_long:
-      self.params.remove("FollowDistanceAccelBoost")
-
     # Cruise features requiring longitudinal or ICBM
     if not (has_long or self.has_icbm):
       self.params.remove("CustomAccIncrementsEnabled")

openpilot/sunnypilot/selfdrive/controls/lib/accel_boost.py

@@ -0,0 +1,67 @@
+"""
+Copyright (c) 2021-, 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 openpilot.cereal import log
+from openpilot.common.params import Params
+from openpilot.common.realtime import DT_MDL
+from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD
+
+ACCEL_BOOST_MIN_SPEED = 1.0
+ACCEL_BOOST_MAX = (0.4, 0.25, 0.1)  # aggressive, standard, relaxed, m/s^2
+ACCEL_BOOST_BUILD, ACCEL_BOOST_RELEASE = 0.2, 1.0  # m/s^3
+BRAKE_PROB = (0.1, 0.3)  # the model's brake press in 4 s: it wants to slow
+GAS_PROB = (0.6, 0.8)  # predicts a human gas press at this hypothesis at about 23%
+CURVE_LAT_ACCEL = (1.5, 2.5)
+
+
+def get_boost_max(personality=log.LongitudinalPersonality.standard):
+  if personality == log.LongitudinalPersonality.relaxed:
+    return ACCEL_BOOST_MAX[2]
+  elif personality == log.LongitudinalPersonality.standard:
+    return ACCEL_BOOST_MAX[1]
+  elif personality == log.LongitudinalPersonality.aggressive:
+    return ACCEL_BOOST_MAX[0]
+  else:
+    raise NotImplementedError("Longitudinal personality not supported")
+
+
+class AccelBoostSP:
+  def __init__(self):
+    self.params = Params()
+    self.frame = -1
+    self.enabled = False
+    self.boost = 0.0
+    self.total_boost = 0.0
+
+  def update_params(self):
+    self.frame += 1
+    if self.frame % int(PARAMS_UPDATE_PERIOD / DT_MDL) != 0:
+      return False
+    enabled = self.params.get_bool("AccelBoostSP")
+    if enabled == self.enabled:
+      return False
+    self.enabled = enabled
+    self.boost = self.total_boost = 0.0
+    return True
+
+  def update(self, sm, output_a_target_e2e, output_a_target_mpc, a_cruise):
+    model = sm['modelV2']
+    brake_probs = model.meta.disengagePredictions.brakePressProbs
+    gas_probs = model.meta.disengagePredictions.gasPressProbs
+    if not sm['selfdriveState'].enabled or len(brake_probs) < 2 or len(gas_probs) < 2:
+      self.boost = self.total_boost = 0.0
+      return output_a_target_e2e
+
+    want = max(float(np.interp(brake_probs[1], BRAKE_PROB, [1.0, 0.0])), float(np.interp(gas_probs[1], GAS_PROB, [0.0, 1.0])))
+    want = 0.0 if model.action.shouldStop else want
+    want *= float(np.interp(abs(model.action.desiredCurvature) * sm['carState'].vEgo ** 2, CURVE_LAT_ACCEL, [1.0, 0.0]))
+    target = want * get_boost_max(sm['selfdriveState'].personality)
+    self.boost = float(np.clip(target, self.boost - ACCEL_BOOST_RELEASE * DT_MDL, self.boost + ACCEL_BOOST_BUILD * DT_MDL))
+    speed_scale = np.interp(sm['carState'].vEgo, [ACCEL_BOOST_MIN_SPEED, 2 * ACCEL_BOOST_MIN_SPEED], [0.0, 1.0])
+    self.total_boost = self.boost * speed_scale * np.interp(output_a_target_e2e, [-0.7, -0.2, 5.0], [0.0, 1.0, 1.0], right=0.0)
+    return output_a_target_e2e + self.total_boost

openpilot/sunnypilot/selfdrive/controls/lib/accel_boost_ext.py

@@ -1,65 +0,0 @@
-"""
-Copyright (c) 2021-, 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 openpilot.cereal import log
-from openpilot.common.params import Params
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.controls.lib.accel_boost import AccelBoost, ACCEL_BOOST_MAX
-from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD
-
-SCALE_RELAXED = 0.3
-SCALE_STANDARD = 0.5
-SCALE_AGGRESSIVE = 0.7
-
-
-def get_accel_boost_scale(personality) -> float:
-  if personality == log.LongitudinalPersonality.aggressive:
-    return SCALE_AGGRESSIVE
-  if personality == log.LongitudinalPersonality.relaxed:
-    return SCALE_RELAXED
-  return SCALE_STANDARD
-
-
-def get_accel_boost_max(personality) -> float:
-  return ACCEL_BOOST_MAX * (1.0 + get_accel_boost_scale(personality))
-
-
-class AccelBoostExt:
-  def __init__(self, stock: AccelBoost | None = None):
-    self._stock = stock if stock is not None else AccelBoost()
-    self._extra = AccelBoost()
-    self.params = Params()
-    self.frame = -1
-    self.enabled = self.params.get_bool("FollowDistanceAccelBoost")
-
-    self.extra_boost = 0.0
-
-  @property
-  def total_boost(self) -> float:
-    return self._stock.total_boost + self.extra_boost
-
-  def _update_params(self) -> None:
-    if self.frame % int(PARAMS_UPDATE_PERIOD / DT_MDL) == 0:
-      self.enabled = self.params.get_bool("FollowDistanceAccelBoost")
-
-  def update(self, sm, output_a_target_e2e, output_a_target_mpc, a_cruise):
-    self.frame += 1
-    self._update_params()
-
-    if self.enabled and sm['selfdriveState'].enabled:
-      scale = get_accel_boost_scale(sm['selfdriveState'].personality)
-      extra_output = self._extra.update(sm, output_a_target_e2e, output_a_target_mpc, a_cruise)
-      self.extra_boost = (extra_output - output_a_target_e2e) * scale
-    else:
-      self.extra_boost = 0.0
-      self._extra.total_boost = 0.0
-      self._extra.boost_this_override = 0.0
-      self._extra.boost_eligible = False
-
-      return self._stock.update(sm, output_a_target_e2e, output_a_target_mpc, a_cruise)
-
-    target = output_a_target_e2e + self.extra_boost
-    return self._stock.update(sm, target, output_a_target_mpc, a_cruise)

openpilot/sunnypilot/selfdrive/controls/lib/longitudinal_planner.py

@@ -9,7 +9,8 @@ from openpilot.cereal import messaging, custom
 from opendbc.car import structs
 from openpilot.common.constants import CV
 from openpilot.selfdrive.car.cruise import V_CRUISE_MAX
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost_ext import AccelBoostExt
+from openpilot.selfdrive.controls.lib.accel_boost import AccelBoost
+from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import AccelBoostSP
 from openpilot.sunnypilot.selfdrive.controls.lib.e2e_alerts_helper import E2EAlertsHelper
 from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.smart_cruise_control import SmartCruiseControl
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_assist import SpeedLimitAssist
@@ -30,19 +31,11 @@ class LongitudinalPlannerSP:
     self.generation = int(model_bundle.generation) if (model_bundle := get_active_bundle()) else None
     self.source = LongitudinalPlanSource.cruise
     self.e2e_alerts_helper = E2EAlertsHelper()
+    self.accel_boost_sp = AccelBoostSP()
+    self.openpilot_longitudinal = CP.openpilotLongitudinalControl
 
     self.output_v_target = 0.
     self.output_a_target = 0.
-    self._accel_boost: AccelBoostExt | None = None
-
-  @property
-  def accel_boost(self) -> AccelBoostExt:
-    assert self._accel_boost is not None
-    return self._accel_boost
-
-  @accel_boost.setter
-  def accel_boost(self, controller) -> None:
-    self._accel_boost = AccelBoostExt(controller)
 
   def update_targets(self, sm: messaging.SubMaster, v_ego: float, a_ego: float, v_cruise: float) -> tuple[float, float]:
     CS = sm['carState']
@@ -75,6 +68,9 @@ class LongitudinalPlannerSP:
     return self.output_v_target, self.output_a_target
 
   def update(self, sm: messaging.SubMaster) -> None:
+    if self.accel_boost_sp.update_params():
+      self.accel_boost = self.accel_boost_sp if self.accel_boost_sp.enabled and self.openpilot_longitudinal else AccelBoost()
+
     self.events_sp.clear()
     self.e2e_alerts_helper.update(sm, self.events_sp)
 

openpilot/sunnypilot/selfdrive/controls/lib/tests/test_accel_boost.py

@@ -0,0 +1,81 @@
+"""
+Copyright (c) 2021-, 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 types import SimpleNamespace
+
+from openpilot.common.parameterized import parameterized
+from openpilot.common.params import Params
+from openpilot.common.realtime import DT_MDL
+from openpilot.common.test import OpenpilotTestCase
+
+from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD
+from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import AccelBoostSP, ACCEL_BOOST_MAX
+
+
+def make_sm(brake_prob=0.05, gas_prob=0.3, lat_accel=0.0, v_ego=30.0, personality=0, enabled=True, should_stop=False):
+  meta = SimpleNamespace(disengagePredictions=SimpleNamespace(brakePressProbs=[0.0, brake_prob, 0.0, 0.0, 0.0, 0.0],
+                                                              gasPressProbs=[0.0, gas_prob, 0.0, 0.0, 0.0, 0.0]))
+  action = SimpleNamespace(shouldStop=should_stop, desiredCurvature=lat_accel / v_ego ** 2)
+  return {'modelV2': SimpleNamespace(meta=meta, action=action), 'carState': SimpleNamespace(vEgo=v_ego),
+          'selfdriveState': SimpleNamespace(enabled=enabled, personality=personality)}
+
+
+def settle(sm, frames=100):
+  boost = AccelBoostSP()
+  for _ in range(frames):
+    boost.update(sm, 0.0, 9.0, 9.0)
+  return boost.total_boost
+
+
+class TestAccelBoostSP(OpenpilotTestCase):
+  @parameterized.expand([(0,), (1,), (2,)])
+  def test_personality_max(self, personality):
+    assert abs(settle(make_sm(personality=personality)) - ACCEL_BOOST_MAX[personality]) < 1e-6
+
+  def test_brake_gate_closes(self):
+    assert settle(make_sm(brake_prob=0.5)) == 0.0
+
+  def test_gas_reopens(self):
+    assert abs(settle(make_sm(brake_prob=0.5, gas_prob=0.9)) - ACCEL_BOOST_MAX[0]) < 1e-6
+
+  def test_should_stop(self):
+    assert settle(make_sm(gas_prob=0.9, should_stop=True)) == 0.0
+
+  @parameterized.expand([(1.5, 1.0), (2.0, 0.5), (2.5, 0.0), (-2.0, 0.5)])
+  def test_curve_fade(self, lat_accel, scale):
+    assert abs(settle(make_sm(lat_accel=lat_accel)) - scale * ACCEL_BOOST_MAX[0]) < 1e-6
+
+  def test_low_speed(self):
+    assert settle(make_sm(v_ego=0.5)) == 0.0
+
+  def test_disabled_resets(self):
+    boost = AccelBoostSP()
+    for _ in range(100):
+      boost.update(make_sm(), 0.0, 9.0, 9.0)
+    assert boost.update(make_sm(enabled=False), 0.0, 9.0, 9.0) == 0.0
+    assert boost.boost == 0.0 and boost.total_boost == 0.0
+
+  def test_build_and_release_rates(self):
+    boost = AccelBoostSP()
+    boost.update(make_sm(), 0.0, 9.0, 9.0)
+    assert abs(boost.total_boost - 0.01) < 1e-6
+    for _ in range(100):
+      boost.update(make_sm(), 0.0, 9.0, 9.0)
+    boost.update(make_sm(brake_prob=0.5), 0.0, 9.0, 9.0)
+    assert abs(boost.total_boost - (ACCEL_BOOST_MAX[0] - 0.05)) < 1e-6
+
+  def test_param_switch(self):
+    params = Params()
+    boost = AccelBoostSP()
+    params.put_bool("AccelBoostSP", True, block=True)
+    assert boost.update_params() and boost.enabled
+    for _ in range(100):
+      boost.update(make_sm(), 0.0, 9.0, 9.0)
+    params.put_bool("AccelBoostSP", False, block=True)
+    for _ in range(int(PARAMS_UPDATE_PERIOD / DT_MDL) - 1):
+      assert not boost.update_params()
+    assert boost.update_params() and not boost.enabled
+    assert boost.boost == 0.0 and boost.total_boost == 0.0

openpilot/sunnypilot/selfdrive/controls/lib/tests/test_accel_boost_ext.py

@@ -1,242 +0,0 @@
-"""
-Copyright (c) 2021-, 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 types import SimpleNamespace
-from unittest import mock
-
-from openpilot.cereal import log
-from openpilot.common.realtime import DT_MDL
-from openpilot.common.test import OpenpilotTestCase
-from openpilot.selfdrive.controls.lib.accel_boost import AccelBoost, ACCEL_BOOST_MAX, ACCEL_BOOST_PER_OVERRIDE, ACCEL_BOOST_RATE
-from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost_ext import AccelBoostExt, get_accel_boost_max
-from openpilot.sunnypilot.selfdrive.controls.lib.longitudinal_planner import LongitudinalPlannerSP
-
-E2E_ACCEL = 0.5
-PLANNER_ACCEL = 2.0
-STEPS_PER_OVERRIDE = round(ACCEL_BOOST_PER_OVERRIDE / (ACCEL_BOOST_RATE * DT_MDL))
-EXPECTED_SCALE = {
-  log.LongitudinalPersonality.relaxed: 0.3,
-  log.LongitudinalPersonality.standard: 0.5,
-  log.LongitudinalPersonality.aggressive: 0.7,
-}
-
-
-class FakeParams:
-  def __init__(self, enabled=True):
-    self.enabled = enabled
-
-  def get_bool(self, key):
-    return self.enabled
-
-
-class FakeSubMaster:
-  def __init__(self, enabled=True, gas_pressed=False, v_ego=15.0,
-               personality=log.LongitudinalPersonality.standard):
-    self._messages = {
-      'selfdriveState': SimpleNamespace(enabled=enabled, personality=personality),
-      'carState': SimpleNamespace(gasPressed=gas_pressed, vEgo=v_ego),
-    }
-
-  def __getitem__(self, key):
-    return self._messages[key]
-
-
-def update(boost, sm, e2e=E2E_ACCEL):
-  return boost.update(sm, e2e, PLANNER_ACCEL, PLANNER_ACCEL)
-
-
-class PlannerStub(LongitudinalPlannerSP):
-  def __init__(self):
-    self._accel_boost = None
-
-
-class TestAccelBoostExt(OpenpilotTestCase):
-  def setUp(self):
-    super().setUp()
-    self.params = FakeParams()
-    patcher = mock.patch("openpilot.sunnypilot.selfdrive.controls.lib.accel_boost_ext.Params", return_value=self.params)
-    patcher.start()
-    self.addCleanup(patcher.stop)
-
-  def _boost_to_max(self, personality):
-    boost = AccelBoostExt()
-    sm = FakeSubMaster(personality=personality)
-    # Eligibility is latched on a frame without gas, then applied on the next override.
-    update(boost, sm)
-    for _ in range(10):
-      sm['carState'].gasPressed = True
-      for _ in range(STEPS_PER_OVERRIDE):
-        update(boost, sm)
-      sm['carState'].gasPressed = False
-      update(boost, sm)
-    return boost, sm
-
-  def _applied_extra(self, boost, sm):
-    update(boost, sm)
-    return boost.extra_boost
-
-  def test_off_matches_stock_boost_exactly(self):
-    self.params.enabled = False
-    sm = FakeSubMaster()
-    stock = AccelBoost()
-    ext = AccelBoostExt()
-
-    stock_out = update(stock, sm)
-    ext_out = update(ext, sm)
-    self.assertAlmostEqual(ext_out, stock_out)
-
-    for _ in range(10):
-      sm['carState'].gasPressed = True
-      for _ in range(STEPS_PER_OVERRIDE):
-        stock_out = update(stock, sm)
-        ext_out = update(ext, sm)
-        self.assertAlmostEqual(ext_out, stock_out)
-      sm['carState'].gasPressed = False
-      stock_out = update(stock, sm)
-      ext_out = update(ext, sm)
-      self.assertAlmostEqual(ext_out, stock_out)
-
-    self.assertAlmostEqual(ext.total_boost, stock.total_boost)
-    self.assertAlmostEqual(ext._stock.total_boost, stock_out - E2E_ACCEL)
-    self.assertEqual(ext.extra_boost, 0.0)
-    self.assertEqual(ext._extra.total_boost, 0.0)
-
-  def test_no_boost_without_gas(self):
-    ext = AccelBoostExt()
-    sm = FakeSubMaster(gas_pressed=False)
-    out = update(ext, sm)
-    self.assertEqual(ext.total_boost, 0.0)
-    self.assertEqual(ext._extra.total_boost, 0.0)
-    self.assertAlmostEqual(out, E2E_ACCEL)
-
-  def test_boost_requires_e2e_to_be_limiting(self):
-    ext = AccelBoostExt()
-    sm = FakeSubMaster(gas_pressed=False)
-    ext.update(sm, E2E_ACCEL, E2E_ACCEL, E2E_ACCEL)
-    sm['carState'].gasPressed = True
-    for _ in range(10):
-      ext.update(sm, E2E_ACCEL, E2E_ACCEL, E2E_ACCEL)
-    self.assertEqual(ext.total_boost, 0.0)
-    self.assertEqual(ext._stock.total_boost, 0.0)
-    self.assertEqual(ext.extra_boost, 0.0)
-    self.assertEqual(ext._extra.total_boost, 0.0)
-
-  def test_extra_layer_per_override_cap(self):
-    ext = AccelBoostExt()
-    sm = FakeSubMaster(gas_pressed=False)
-    update(ext, sm)
-    sm['carState'].gasPressed = True
-    for _ in range(1000):
-      update(ext, sm)
-
-    self.assertAlmostEqual(ext._extra.total_boost, ACCEL_BOOST_PER_OVERRIDE)
-    applied = self._applied_extra(ext, sm)
-    expected = ACCEL_BOOST_PER_OVERRIDE * EXPECTED_SCALE[log.LongitudinalPersonality.standard]
-    self.assertAlmostEqual(applied, expected)
-
-  def test_extra_scales_with_following_distance(self):
-    applied = {}
-    for personality in (log.LongitudinalPersonality.relaxed,
-                        log.LongitudinalPersonality.standard,
-                        log.LongitudinalPersonality.aggressive):
-      ext, sm = self._boost_to_max(personality)
-      sm['carState'].gasPressed = True
-      applied[personality] = self._applied_extra(ext, sm)
-
-    for personality, value in applied.items():
-      self.assertAlmostEqual(value, ACCEL_BOOST_MAX * EXPECTED_SCALE[personality])
-
-    self.assertLess(applied[log.LongitudinalPersonality.relaxed], applied[log.LongitudinalPersonality.standard])
-    self.assertLess(applied[log.LongitudinalPersonality.standard], applied[log.LongitudinalPersonality.aggressive])
-
-  def test_capnp_dynamic_enum_personality_scales(self):
-    # Real SubMaster messages expose personality as a capnp DynamicEnum; equality still matches the enum value.
-    msg = log.SelfdriveState.new_message()
-    msg.personality = log.LongitudinalPersonality.aggressive
-    ext, sm = self._boost_to_max(msg.personality)
-    sm['carState'].gasPressed = True
-    applied = self._applied_extra(ext, sm)
-    self.assertAlmostEqual(applied, ACCEL_BOOST_MAX * EXPECTED_SCALE[log.LongitudinalPersonality.aggressive])
-
-  def test_extra_feeds_into_stock_last(self):
-    ext, sm = self._boost_to_max(log.LongitudinalPersonality.standard)
-    sm['carState'].gasPressed = True
-    inputs = []
-    original_update = AccelBoost.update
-
-    def spy(boost, sm_, e2e, mpc, cruise):
-      inputs.append(e2e)
-      return original_update(boost, sm_, e2e, mpc, cruise)
-
-    with mock.patch.object(AccelBoost, "update", spy):
-      out = update(ext, sm)
-
-    # First call is our extra layer on the raw target, last call is stock on the boosted target.
-    self.assertAlmostEqual(inputs[0], E2E_ACCEL)
-    self.assertAlmostEqual(inputs[-1], E2E_ACCEL + ext.extra_boost)
-    self.assertAlmostEqual(out, inputs[-1] + ext._stock.total_boost)
-
-  def test_extra_is_added_on_top_of_stock_boost(self):
-    ext, sm = self._boost_to_max(log.LongitudinalPersonality.aggressive)
-    sm['carState'].gasPressed = True
-    out = update(ext, sm)
-    extra = out - E2E_ACCEL - ext._stock.total_boost
-    self.assertAlmostEqual(ext._stock.total_boost, ACCEL_BOOST_MAX)
-    self.assertAlmostEqual(ext.total_boost, ACCEL_BOOST_MAX + ext.extra_boost)
-    self.assertAlmostEqual(ext._stock.total_boost, ACCEL_BOOST_MAX)
-    self.assertAlmostEqual(ext.extra_boost, ACCEL_BOOST_MAX * EXPECTED_SCALE[log.LongitudinalPersonality.aggressive])
-    self.assertAlmostEqual(extra, ext.extra_boost)
-
-  def test_sp_planner_wraps_assigned_stock_controller(self):
-    planner = PlannerStub()
-    stock = AccelBoost()
-    planner.accel_boost = stock
-
-    self.assertIsInstance(planner.accel_boost, AccelBoostExt)
-    self.assertIs(planner.accel_boost._stock, stock)
-
-  def test_wraps_existing_stock_controller(self):
-    stock = AccelBoost()
-    sm = FakeSubMaster()
-    update(stock, sm)
-    sm['carState'].gasPressed = True
-    update(stock, sm)
-
-    ext = AccelBoostExt(stock)
-    self.assertIs(ext._stock, stock)
-    self.assertAlmostEqual(ext.total_boost, stock.total_boost)
-
-  def test_boost_bar_max_matches_profile_cap(self):
-    for personality, scale in EXPECTED_SCALE.items():
-      self.assertAlmostEqual(get_accel_boost_max(personality), ACCEL_BOOST_MAX * (1.0 + scale))
-
-  def test_total_boost_is_stock_accumulated_plus_extra_applied(self):
-    ext, sm = self._boost_to_max(log.LongitudinalPersonality.aggressive)
-    sm['carState'].gasPressed = True
-    update(ext, sm)
-    self.assertAlmostEqual(ext.total_boost, ext._stock.total_boost + ext.extra_boost)
-
-  def test_turning_toggle_off_restores_stock_only(self):
-    ext, sm = self._boost_to_max(log.LongitudinalPersonality.aggressive)
-    self.assertGreater(ext._extra.total_boost, 0.0)
-
-    self.params.enabled = False
-    sm['carState'].gasPressed = True
-    # Params are re-read every PARAMS_UPDATE_PERIOD; the extra layer must clear on the next poll.
-    for _ in range(int(PARAMS_UPDATE_PERIOD / DT_MDL) + 1):
-      out = update(ext, sm)
-
-    self.assertEqual(ext._extra.total_boost, 0.0)
-    self.assertEqual(ext.extra_boost, 0.0)
-    self.assertAlmostEqual(out, E2E_ACCEL + ext._stock.total_boost)
-
-  def test_relaxing_following_distance_applies_immediately(self):
-    ext, sm = self._boost_to_max(log.LongitudinalPersonality.aggressive)
-    sm['selfdriveState'].personality = log.LongitudinalPersonality.relaxed
-    sm['carState'].gasPressed = True
-    applied = self._applied_extra(ext, sm)
-    self.assertAlmostEqual(applied, ACCEL_BOOST_MAX * EXPECTED_SCALE[log.LongitudinalPersonality.relaxed])

openpilot/sunnypilot/sunnylink/settings_ui.json

@@ -621,10 +621,10 @@
               ]
             },
             {
-              "key": "FollowDistanceAccelBoost",
+              "key": "AccelBoostSP",
               "widget": "toggle",
-              "title": "Extra Acceleration Boost by Following Distance",
-              "description": "Adds extra acceleration on top of the stock gas-override boost. The extra boost follows the Following Distance setting, strongest when Aggressive and weakest when Relaxed. The stock boost remains active when this is off.",
+              "title": "Acceleration Boost",
+              "description": "Adds a small push on top of sunnypilot's own acceleration, stronger in Aggressive and gentler in Relaxed. Eases off in curves and when sunnypilot slows or stops. Never goes past your set speed, and lead-car following still comes first.",
               "enablement": [
                 {
                   "type": "capability",
@@ -1362,7 +1362,17 @@
               "key": "TorqueBar",
               "widget": "toggle",
               "title": "Steering Arc",
-              "description": "Display steering arc on the driving screen when lateral control is enabled."
+              "description": "Display steering arc on the driving screen when lateral control is enabled.",
+              "visibility": [
+                {
+                  "type": "not",
+                  "condition": {
+                    "type": "capability",
+                    "field": "device_type",
+                    "equals": "mici"
+                  }
+                }
+              ]
             },
             {
               "key": "ShowTurnSignals",

openpilot/sunnypilot/sunnylink/settings_ui_src/pages/cruise.yaml

@@ -30,12 +30,10 @@ sections:
       label: Relaxed
     enablement:
     - $ref: '#/macros/longitudinal'
-  - key: FollowDistanceAccelBoost
+  - key: AccelBoostSP
     widget: toggle
-    title: Extra Acceleration Boost by Following Distance
-    description: Adds extra acceleration on top of the stock gas-override boost. The extra boost follows
-      the Following Distance setting, strongest when Aggressive and weakest when Relaxed. The stock boost
-      remains active when this is off.
+    title: Acceleration Boost
+    description: "Adds a small push on top of sunnypilot's own acceleration, stronger in Aggressive and gentler in Relaxed. Eases off in curves and when sunnypilot slows or stops. Never goes past your set speed, and lead-car following still comes first."
     enablement:
     - $ref: '#/macros/longitudinal'
   - key: IntelligentCruiseButtonManagement

openpilot/sunnypilot/sunnylink/settings_ui_src/pages/visuals.yaml

@@ -20,6 +20,8 @@ sections:
     widget: toggle
     title: Steering Arc
     description: Display steering arc on the driving screen when lateral control is enabled.
+    visibility:
+    - $ref: '#/macros/hide_on_mici'
   - key: ShowTurnSignals
     widget: toggle
     title: Display Turn Signals