Merge branch 'master' into trip-summary

* modeld_v2: artifact parity with upstream tg

* m

* m

* Update helpers.py

* ew

* Update convert_upstream_pkl.py

* Update test_convert_upstream_pkl.py

---------

Co-authored-by: Jason Wen <haibin.wen3@gmail.com>

.github/workflows/test_models.yml

@@ -46,6 +46,23 @@ jobs:
           CHECK_OOB: 0
           GMMU: 0
         run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py
+      - name: Resolve commaai's tinygrad pin, which their precompiled chestnut model is built and converted with
+        id: upstream-tg
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          read -r sha url < <(gh api repos/commaai/openpilot/contents/tinygrad_repo --jq '.sha + " " + .submodule_git_url')
+          echo "commaai/openpilot master pins $url@$sha, ours is $(git rev-parse HEAD:tinygrad_repo)"
+          dir="$RUNNER_TEMP/upstream_tinygrad"
+          git init -q "$dir" && git -C "$dir" fetch -q --depth 1 "$url" "$sha" && git -C "$dir" checkout -q FETCH_HEAD
+          echo "path=$dir" >> "$GITHUB_OUTPUT"
+      - name: Convert a pickled USB+AMD jit under commaai's tinygrad, as the chestnut model build does
+        env:
+          DEV: MOCKUSB+AMD
+          CHECK_OOB: 0
+          GMMU: 0
+          PYTHONPATH: ${{ steps.upstream-tg.outputs.path }}:${{ github.workspace }}
+        run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py
       - name: Where tinygrad moved, for the helper or failure point named above
         if: failure() && github.event_name == 'pull_request'
         run: |

openpilot/common/params_keys.h

@@ -200,6 +200,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ShowAdvancedControls", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"TripSummary", {PERSISTENT | BACKUP, BOOL, "1"}},
     {"TrueVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},
 
     // MADS params

openpilot/selfdrive/ui/layouts/main.py

@@ -10,6 +10,7 @@ from openpilot.selfdrive.ui.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow
 from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
+from openpilot.selfdrive.ui.sunnypilot.layouts.trip_summary import TripSummary
 
 if gui_app.sunnypilot_ui():
   from openpilot.selfdrive.ui.sunnypilot.layouts.settings.settings import SettingsLayoutSP as SettingsLayout
@@ -31,6 +32,7 @@ class MainLayout(Widget):
     self._sidebar = Sidebar()
     self._current_mode = MainState.HOME
     self._prev_onroad = False
+    self._trip_summary = TripSummary()
 
     # Initialize layouts
     self._home_layout = HomeLayout()

openpilot/selfdrive/ui/mici/layouts/main.py

@@ -10,6 +10,7 @@ from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.scroller import Scroller
 from openpilot.system.ui.lib.application import gui_app
+from openpilot.selfdrive.ui.sunnypilot.layouts.trip_summary import TripSummary
 
 if gui_app.sunnypilot_ui():
   from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
@@ -57,6 +58,7 @@ class MiciMainLayout(Scroller):
     self._setup_callbacks()
 
     gui_app.add_nav_stack_tick(self._handle_transitions)
+    self._trip_summary = TripSummary()
     gui_app.push_widget(self)
 
     # Start onboarding if terms or training not completed, make sure to push after self

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

@@ -22,7 +22,6 @@ from openpilot.common.transformations.orientation import rot_from_euler
 from enum import IntEnum
 
 if gui_app.sunnypilot_ui():
-  from openpilot.selfdrive.ui.sunnypilot.mici.onroad.augmented_road_view import AugmentedRoadViewSP
   from openpilot.selfdrive.ui.sunnypilot.mici.onroad.hud_renderer import HudRendererSP as HudRenderer
   from openpilot.selfdrive.ui.sunnypilot.ui_state import OnroadTimerStatus
 
@@ -157,10 +156,9 @@ class BookmarkIcon(Widget):
         rl.draw_texture_ex(icon, rl.Vector2(icon_x, icon_y), 0.0, 1.0, rl.Color(255, 255, 255, round(255 * alpha)))
 
 
-class AugmentedRoadView(CameraView, AugmentedRoadViewSP):
+class AugmentedRoadView(CameraView):
   def __init__(self, bookmark_callback=None, stream_type: VisionStreamType = VisionStreamType.VISION_STREAM_NARROW_ROAD):
     super().__init__("camerad", stream_type)
-    AugmentedRoadViewSP.__init__(self)
     self._bookmark_callback = bookmark_callback
     self._set_placeholder_color(rl.BLACK)
 
@@ -277,7 +275,7 @@ class AugmentedRoadView(CameraView, AugmentedRoadViewSP):
     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:
-      AugmentedRoadViewSP.render_side_panel(self, self.rect)
+      self._confidence_ball.render(self.rect)
 
     self._bookmark_icon.render(self.rect)
 

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

@@ -72,6 +72,11 @@ class VisualsLayout(Widget):
            "It is the driver's responsibility to observe their environment and make decisions accordingly."),
         None,
       ),
+      "TripSummary": (
+        lambda: tr("Trip Summary"),
+        tr("Show a summary of distance and engagement when you shift into park after a drive."),
+        None,
+      ),
       "TrueVEgoUI": (
         lambda: tr("Speedometer: Always Display True Speed"),
         tr("For applicable vehicles, always display the true vehicle current speed from wheel speed sensors."),

openpilot/selfdrive/ui/sunnypilot/layouts/trip_summary.py

@@ -0,0 +1,199 @@
+"""
+Copyright (c) 2021-, 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 time
+import pyray as rl
+
+from opendbc.car.structs import car
+
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.onroad.augmented_road_view import BORDER_COLORS
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.widgets import Widget
+
+AUTO_DISMISS = 20.
+FADE_IN, FADE_OUT = 0.35, 0.3
+LAT = (UIStatus.ENGAGED, UIStatus.LAT_ONLY)
+LONG = (UIStatus.ENGAGED, UIStatus.LONG_ONLY)
+GEAR = car.CarState.GearShifter
+FORWARD = (GEAR.drive, GEAR.sport, GEAR.low, GEAR.brake, GEAR.eco, GEAR.manumatic)
+
+
+class TripTracker:
+  def __init__(self):
+    self.reset()
+
+  def reset(self):
+    self.segments: list[list] = []
+    self.seconds = 0.
+    self.takeovers = 0
+    self._t = None
+    self._status = None
+
+  def update(self, driving: bool):
+    now = time.monotonic()
+    if not driving:
+      self._t = None
+      self._status = None
+      return
+    dt = 0. if self._t is None else min(now - self._t, 0.5)
+    self._t = now
+    self.seconds += dt
+    if self._status not in (None, UIStatus.DISENGAGED) and ui_state.status == UIStatus.DISENGAGED:
+      self.takeovers += 1
+    self._status = ui_state.status
+    d = max(ui_state.sm["carState"].vEgo, 0.) * dt
+    if d <= 0.:
+      return
+    if self.segments and self.segments[-1][0] == ui_state.status:
+      self.segments[-1][1] += d
+    else:
+      self.segments.append([ui_state.status, d])
+
+  def total(self, statuses=None) -> float:
+    return sum(m for s, m in self.segments if statuses is None or s in statuses)
+
+
+class TripSummary:
+  def __init__(self):
+    self._trip = TripTracker()
+    self._dialog: TripSummaryDialog | None = None
+    self._gear = None
+    self._drove = False
+    gui_app.add_nav_stack_tick(self._tick)
+
+  def _tick(self):
+    gear = ui_state.sm["carState"].gearShifter if ui_state.started else None
+    self._trip.update(gear not in (None, GEAR.park))
+    self._drove |= gear in FORWARD
+    if gear == self._gear:
+      return
+    self._gear = gear
+
+    if gear not in (None, GEAR.park):
+      self._pop()
+    elif gear == GEAR.park and self._drove and ui_state.trip_summary and not ui_state.is_body and self._trip.total() > 0.:
+      self._dialog = TripSummaryDialog(self._trip, gui_app.get_active_widget(), self._pop)
+      gui_app.push_widget(self._dialog)
+    if gear is None:
+      self._trip.reset()
+    if gear in (None, GEAR.park):
+      self._drove = False
+
+  def _pop(self):
+    if self._dialog is not None and gui_app.get_active_widget() is self._dialog:
+      gui_app.pop_widget()
+    self._dialog = None
+
+
+def _ease(t: float) -> float:
+  t = min(max(t, 0.), 1.)
+  return 1 - (1 - t) ** 3
+
+
+def _fade(c, a: float) -> rl.Color:
+  r, g, b, al = c if isinstance(c, tuple) else (c.r, c.g, c.b, c.a)
+  return rl.Color(r, g, b, int(al * a))
+
+
+class TripSummaryDialog(Widget):
+  def __init__(self, trip: TripTracker, below: Widget | None, on_closed):
+    super().__init__()
+    self._below = below
+    self._on_closed = on_closed
+    self._segments = segments = trip.segments
+    total = sum(m for _, m in segments)
+
+    def pct(statuses):
+      return 100 * sum(m for s, m in segments if s in statuses) / total
+
+    dist = total * (CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH) / 3600
+    dist_fmt = "{:.1f}" if dist < 9.95 else "{:.0f}"
+    self._stats = [
+      (dist, dist_fmt, "km" if ui_state.is_metric else "mi", "driven"),
+      (pct(LAT + LONG), "{:.0f}", "%", "engaged"),
+      (pct(LAT), "{:.0f}", "%", "lateral"),
+      (pct(LONG), "{:.0f}", "%", "longitudinal"),
+    ]
+    mins = round(trip.seconds / 60)
+    self._details = [
+      (f"{mins // 60}h {mins % 60}" if mins >= 60 else f"{mins}", "min"),
+      (f"{trip.takeovers}", "takeover" if trip.takeovers == 1 else "takeovers"),
+    ]
+    self._bold = gui_app.font(FontWeight.BOLD)
+    self._semi = gui_app.font(FontWeight.SEMI_BOLD)
+    self._normal = gui_app.font(FontWeight.NORMAL)
+    self._big = gui_app.big_ui()
+    self._shown_t = rl.get_time()
+    self._closing_t: float | None = None
+    self.set_click_callback(self.close)
+
+  def close(self):
+    if self._closing_t is None:
+      self._closing_t = rl.get_time()
+
+  def _render(self, rect: rl.Rectangle):
+    t = rl.get_time() - self._shown_t
+    if self._closing_t is None and t > AUTO_DISMISS:
+      self.close()
+    out = 0. if self._closing_t is None else (rl.get_time() - self._closing_t) / FADE_OUT
+    if out >= 1.:
+      self._on_closed()
+      return
+    bg = 1 - _ease(out)
+    a = _ease(t / FADE_IN) * bg
+
+    if self._big and self._below is not None and bg < 1.:
+      self._below.render(rect)
+    rl.draw_rectangle_rec(rect, _fade(rl.BLACK, bg))
+
+    k = rect.height / 1080 * (1.0 if self._big else 1.22)
+    pad = 120 * k
+    x, w = rect.x + pad, rect.width - 2 * pad
+    y = rect.y + (rect.height - 850 * k) / 2
+
+    rl.draw_text_ex(self._bold, "trip summary", rl.Vector2(x, y), int(150 * k), 0, _fade(rl.WHITE, a))
+    y += 260 * k
+
+    col_w = w / len(self._stats)
+    for i, (target, fmt, unit, label) in enumerate(self._stats):
+      cx = x + col_w * (i + 0.5)
+      v = measure_text_cached(self._bold, fmt.format(target), int(170 * k))
+      u = measure_text_cached(self._semi, unit, int(80 * k))
+      vx = cx - (v.x + 10 * k + u.x) / 2
+      rl.draw_text_ex(self._bold, fmt.format(target), rl.Vector2(vx, y), int(170 * k), 0, _fade(rl.WHITE, a))
+      rl.draw_text_ex(self._semi, unit, rl.Vector2(vx + v.x + 10 * k, y + 75 * k), int(80 * k), 0, _fade(rl.WHITE, a))
+      lb = measure_text_cached(self._normal, label, int(70 * k))
+      rl.draw_text_ex(self._normal, label, rl.Vector2(cx - lb.x / 2, y + 180 * k), int(70 * k), 0, _fade(rl.Color(200, 200, 200, 255), a))
+    y += 330 * k
+
+    bar = rl.Rectangle(x, y, w, 90 * k)
+    total = sum(m for _, m in self._segments)
+    sx = bar.x
+    for status, m in self._segments:
+      sw = bar.width * m / total
+      rl.draw_rectangle_rec(rl.Rectangle(sx, bar.y, min(sw + 1, bar.x + bar.width - sx), bar.height), _fade(BORDER_COLORS[status], a))
+      sx += sw
+    rl.draw_rectangle_rounded_lines_ex(bar, 1.0, 20, 30 * k, _fade(rl.BLACK, a))
+
+    y += (90 + 70) * k
+
+    size = int(90 * k)
+    parts = []
+    for i, (value, unit) in enumerate(self._details):
+      if i:
+        parts.append(("     ", self._normal, None))
+      parts += [(value, self._bold, rl.WHITE), (" " + unit, self._normal, rl.Color(170, 170, 170, 255))]
+    widths = [measure_text_cached(f, t, size).x for t, f, _ in parts]
+    lx = x + (w - sum(widths)) / 2
+    for (text, font, color), tw in zip(parts, widths, strict=True):
+      if color is None:
+        rl.draw_circle(int(lx + tw / 2), int(y + size * 0.6), 12 * k, _fade(rl.Color(110, 110, 110, 255), a))
+      else:
+        rl.draw_text_ex(font, text, rl.Vector2(lx, y), size, 0, _fade(color, a))
+      lx += tw

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

@@ -1,95 +0,0 @@
-"""
-Copyright (c) 2021-, 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 math
-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.ui_state import ui_state
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import get_boost_max
-from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.widgets import Widget
-
-BAR_WIDTH = 26
-TRACK_TOP_RATIO = 0.08
-TRACK_BOTTOM_RATIO = 0.92
-CAP_BLEND_START = 0.45
-MAX_BOOST_BLEND = 0.55
-FADE_THRESHOLD = 0.01
-
-COLOR_TRACK = rl.Color(255, 255, 255, 28)
-COLOR_FILL = rl.Color(0, 230, 120, 255)
-
-
-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:
-  amount = min(max(amount, 0.0), 1.0)
-  return rl.Color(int(color.r + (255 - color.r) * amount),
-                  int(color.g + (255 - color.g) * amount),
-                  int(color.b + (255 - color.b) * amount), color.a)
-
-
-def get_boost_color(fraction: float) -> rl.Color:
-  blend = max(0.0, (fraction - CAP_BLEND_START) / (1.0 - CAP_BLEND_START))
-  return lighten(COLOR_FILL, MAX_BOOST_BLEND * blend)
-
-
-class AccelBoostIndicator(Widget):
-  def __init__(self, panel_width: float = SIDE_PANEL_WIDTH, bar_width: float = BAR_WIDTH):
-    super().__init__()
-    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(get_boost_max(), 0.25, 1 / fps)
-
-  @property
-  def holding_panel(self) -> bool:
-    return self._alpha_filter.x > FADE_THRESHOLD
-
-  def _update_state(self):
-    sm = ui_state.sm
-    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']
-    applied = visible and plan.longitudinalPlanSource == log.LongitudinalPlan.LongitudinalPlanSource.e2e
-    self._boost_filter.update(float(plan.accelBoost) if applied else 0.0)
-    self._alpha_filter.update(1.0 if visible else 0.0)
-
-    if sm.alive['selfdriveState']:
-      self._max_boost_filter.update(get_boost_max(sm['selfdriveState'].personality))
-
-  def _render(self, _):
-    alpha = self._alpha_filter.x
-    if alpha < FADE_THRESHOLD:
-      return
-
-    panel_x = max(self.rect.x, self.rect.x + self.rect.width - self._panel_width)
-    bar_x = panel_x + (self._panel_width - self._bar_width) / 2
-    track_top = self.rect.y + self.rect.height * TRACK_TOP_RATIO
-    track = rl.Rectangle(bar_x, track_top, self._bar_width,
-                         max(1.0, self.rect.height * (TRACK_BOTTOM_RATIO - TRACK_TOP_RATIO)))
-    rl.draw_rectangle_rounded(track, 0.5, 12,
-                              rl.Color(COLOR_TRACK.r, COLOR_TRACK.g, COLOR_TRACK.b, int(COLOR_TRACK.a * alpha)))
-
-    fraction = get_boost_fraction(self._boost_filter.x, self._max_boost_filter.x)
-    fill_h = fraction * track.height
-    if fill_h < 1.0:
-      return
-
-    fill_color = get_boost_color(fraction)
-    tip = track.y + track.height - fill_h
-    rl.begin_scissor_mode(int(track.x), int(tip), int(math.ceil(track.width)) + 1, int(math.ceil(fill_h)))
-    rl.draw_rectangle_rounded(track, 0.5, 12, rl.Color(fill_color.r, fill_color.g, fill_color.b, int(235 * alpha)))
-    rl.end_scissor_mode()

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

@@ -1,19 +0,0 @@
-"""
-Copyright (c) 2021-, 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 pyray as rl
-
-from openpilot.selfdrive.ui.sunnypilot.mici.onroad.accel_boost_indicator import AccelBoostIndicator
-
-
-class AugmentedRoadViewSP:
-  def __init__(self):
-    self._accel_boost_indicator = AccelBoostIndicator()
-
-  def render_side_panel(self, rect: rl.Rectangle) -> None:
-    self._accel_boost_indicator.render(rect)
-    if not self._accel_boost_indicator.holding_panel:
-      self._confidence_ball.render(rect)

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

@@ -1,36 +0,0 @@
-"""
-Copyright (c) 2021-, 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 openpilot.cereal import log
-from openpilot.common.test import OpenpilotTestCase
-from openpilot.selfdrive.ui.sunnypilot.mici.onroad.accel_boost_indicator import (
-  CAP_BLEND_START, COLOR_FILL, get_boost_color, get_boost_fraction,
-)
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import ACCEL_BOOST_MAX, get_boost_max
-
-
-class TestAccelBoostIndicator(OpenpilotTestCase):
-  def test_bar_fills_at_the_active_profile_cap(self):
-    for personality in (log.LongitudinalPersonality.aggressive, log.LongitudinalPersonality.standard,
-                        log.LongitudinalPersonality.relaxed):
-      cap = get_boost_max(personality)
-      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
-
-    assert get_boost_fraction(max(ACCEL_BOOST_MAX), min(ACCEL_BOOST_MAX)) == 1.0
-    assert get_boost_fraction(0.0, 0.0) == 0.0
-    assert get_boost_fraction(-1.0, get_boost_max()) == 0.0
-
-  def test_fill_lightens_as_boost_builds(self):
-    base = get_boost_color(0.0)
-    assert (base.r, base.g, base.b) == (COLOR_FILL.r, COLOR_FILL.g, COLOR_FILL.b)
-    assert (get_boost_color(CAP_BLEND_START).r, get_boost_color(CAP_BLEND_START).b) == (COLOR_FILL.r, COLOR_FILL.b)
-
-    full = get_boost_color(1.0)
-    assert full.r > base.r
-    assert full.b > base.b
-    assert full.g > full.r and full.g > full.b

openpilot/selfdrive/ui/sunnypilot/ui_state.py

@@ -44,11 +44,11 @@ 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
     self.blindspot: bool = False
+    self.trip_summary: bool = True
     self.chevron_metrics = None
     self.custom_interactive_timeout: int = 0
     self.developer_ui = None
@@ -172,7 +172,6 @@ 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)
@@ -187,6 +186,7 @@ class UIStateSP:
     self.standstill_timer = self.params.get_bool("StandstillTimer")
     self.sunnylink_enabled = self.params.get_bool("SunnylinkEnabled")
     self.torque_bar = self.params.get_bool("TorqueBar")
+    self.trip_summary = self.params.get_bool("TripSummary")
     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")

openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py

@@ -66,47 +66,75 @@ def _patched(buf, topo) -> tuple[bytearray, dict]:
   return blob, rows
 
 
-def _evaluate(u, env):
+def _packed_args(program) -> dict[int, int]:
+  from tinygrad.device import TinyELF
+  params = getattr(program.arg, "params", None) or ()
+  return {off: p.arg.slot for (off, _), p in zip(TinyELF.iter_sig(tuple((None, p.addrspace, p.dtype, ()) for p in params)), params, strict=True)}
+
+
+def _outer_slot(u, packed: dict[int, int]) -> int | None:
+  from tinygrad.uop.ops import Ops
+  if u.op is Ops.PARAM:
+    return None if packed else u.arg.slot
+  if u.op.name == "REFPARAM":
+    return u.arg.slot
+  if packed and u.op is Ops.LOAD and u.src[0].op is Ops.INDEX and _root(u.src[0].src[0]).op is Ops.PARAM:
+    index = _evaluate(u.src[0].src[1], {}, packed)
+    return None if index is None else packed.get(index * u.dtype.itemsize)
+  return None
+
+
+def _evaluate(u, env, packed: dict[int, int]):
   from tinygrad.uop.ops import GroupOp, Ops, exec_alu
   if u.op in (Ops.AFTER, Ops.CAST, Ops.BITCAST):
-    return _evaluate(u.src[0], env)
+    return _evaluate(u.src[0], env, packed)
   if u.op is Ops.CONST:
     return u.arg
-  if u.op in (Ops.PARAM, Ops.RANGE):
-    return env.get(u.arg.slot if u.op is Ops.PARAM else u)
+  if u.op is Ops.RANGE:
+    return env.get(u)
+  if (slot := _outer_slot(u, packed)) is not None:
+    return env.get(slot)
   if u.op is Ops.LOAD:
-    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env)
+    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env, packed)
     return struct.unpack_from(u.dtype.fmt, table.arg, index * u.dtype.itemsize)[0] if table.op is Ops.BINARY and index is not None else None
-  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env) for x in u.src]):
+  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env, packed) for x in u.src]):
     return exec_alu(u.op, u.dtype, values, *([False] if "truncate_output" in inspect.signature(exec_alu).parameters else []))
   return None
 
 
 def _input_pokes(submit, kernargs) -> dict[int, tuple[int, int]]:
   from tinygrad.uop.ops import Ops
-  outer = dict(enumerate(submit.src[1:]))
+  outer, packed = dict(enumerate(submit.src[1:])), _packed_args(submit.src[0])
   kernargs_params = {i for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]) is kernargs}
   inputs = {i: _root(a.src[0]).arg.slot for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]).op is Ops.PARAM}
   pokes = {}
   for call in (u for u in submit.src[0].src[0].toposort() if u.op is Ops.CALL and len(u.src) > 3):
     _, address, value, *_ = call.src[1:]
-    used = list({x.arg.slot for x in value.toposort() if x.op is Ops.PARAM} & inputs.keys())
-    if len(used) != 1 or not kernargs_params & {x.arg.slot for x in address.toposort() if x.op is Ops.PARAM}:
+    used = list({slot for x in value.toposort() if (slot := _outer_slot(x, packed)) is not None} & inputs.keys())
+    if len(used) != 1 or not kernargs_params & {_outer_slot(x, packed) for x in address.toposort()}:
       continue
     ranges = list(dict.fromkeys(x for x in (*address.toposort(), *value.toposort()) if x.op is Ops.RANGE))
     for trip in itertools.product(*[range(int(r.vmax) + 1) for r in ranges]):
       env = dict.fromkeys(outer, 0) | dict(zip(ranges, trip, strict=True))
-      if (offset := _evaluate(address, env)) % 8 == 0:
-        pokes[offset] = (inputs[used[0]], _evaluate(value, env))
+      if (offset := _evaluate(address, env, packed)) % 8 == 0:
+        pokes[offset] = (inputs[used[0]], _evaluate(value, env, packed))
   return pokes
 
 
-def _elf(image: bytes, rodata: int) -> bytes:
-  names, offset, data, headers = b"\0.text\0.rodata\0.shstrtab\0", 64, b"", []
-  for name, kind, address, content in [(0, 0, 0, b""), (1, 1, ALIGNMENT, image[:rodata]), (7, 1, ALIGNMENT + rodata, image[rodata:]), (15, 3, 0, names)]:
-    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, 2 if kind == 1 else 0, address, offset, len(content), 0, 0, 1, 0))
+def _elf(image: bytes, rodata: int, entry: int) -> bytes:
+  spans = [(".text", 0, rodata), (".rodata", rodata, len(image))] if entry < rodata else \
+          [(".data", 0, rodata), (".rodata", rodata, entry), (".text", entry, len(image))]
+  sections, names = [(0, 0, 0, 0, b"")], b"\0"
+  for name, start, end in (span for span in spans if span[1] < span[2]):
+    sections.append((len(names), 1, 6 if name == ".text" else 2, ALIGNMENT + start, image[start:end]))
+    names += name.encode() + b"\0"
+  sections.append((len(names), 3, 0, 0, names + b".shstrtab\0"))
+  offset, data, headers = 64, b"", []
+  for name, kind, flags, address, content in sections:
+    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, flags, address, offset, len(content), 0, 0, 1, 0))
     data, offset = data + content, offset + len(content)
-  return b"\x7fELF\x02\x01\x01" + bytes(9) + struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, 4, 3) + data + b"".join(headers)
+  header = struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, len(sections), len(sections) - 1)
+  return b"\x7fELF\x02\x01\x01" + bytes(9) + header + data + b"".join(headers)
 
 
 def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
@@ -155,7 +183,7 @@ def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
     if image_alloc not in programs:
       image = bytes(_patched(image_alloc, topo)[0])
       rodata = next(r for r in range(0, len(image) - 24, 64) if r + struct.unpack_from("<q", image, r + 16)[0] == entry)
-      programs[image_alloc] = blob.add(_elf(image, rodata))
+      programs[image_alloc] = blob.add(_elf(image, rodata, entry))
     start, size = _view(arguments.src[0])
     args = []
     for slot in range(start, start + unwrap(size), 8):

openpilot/sunnypilot/modeld_v2/helpers.py

@@ -264,8 +264,8 @@ def _program_uop(call: dict, lib: bytes):
     parameter = UOp.param(call["globals"][compact_slot], _dtype(dtype), math.prod(shape))
     image = (shape[0], shape[1]) if len(shape) == 3 and shape[2] == 4 else None
     parameters.append(parameter.replace(arg=_fields(parameter.arg, name=name, image=image)))
-  info = _fields(ProgramInfo, global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), globals=tuple(call["globals"]),
-                 outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=_fields(Target, **call["target"]))
+  info = _fields(ProgramInfo, global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), params=tuple(parameters),
+                 globals=tuple(call["globals"]), outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=_fields(Target, **call["target"]))
   return UOp(Ops.PROGRAM, src=(UOp(Ops.SINK, arg=KernelInfo(name=call["name"])), UOp(Ops.LINEAR, src=tuple(parameters)),
                                UOp(Ops.SOURCE, arg=""), UOp(Ops.BINARY, arg=lib)), arg=info)
 

openpilot/sunnypilot/modeld_v2/modeld.py

@@ -242,7 +242,7 @@ class ModelState(ModelStateBase):
       desired_curvature = get_curvature_from_output(model_output, curvature_plan, v_ego, lat_action_t, self.mlsim)
     else:
       desired_accel = model_output['action'][0, 1]
-      desired_curvature = model_output['action'][0, 0] / (max(1.0, v_ego))**2
+      desired_curvature = model_output['action'][0, 0] / (max(2.5, v_ego))**2
     if blendful is not None:
       desired_curvature += blendful(desired_curvature)
 

openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py

@@ -6,6 +6,7 @@ See the LICENSE.md file in the root directory for more details.
 """
 import os
 import re
+import struct
 import sys
 import tempfile
 import unittest
@@ -25,8 +26,8 @@ if sys.platform == "darwin" and os.environ.get("DEV", "").startswith("MOCKUSB"):
 
 from openpilot.common.test import OpenpilotTestCase
 from openpilot.sunnypilot.modeld_v2 import convert_upstream_pkl
-from openpilot.sunnypilot.modeld_v2.convert_upstream_pkl import convert
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, load_model
+from openpilot.sunnypilot.modeld_v2.convert_upstream_pkl import _elf, convert
+from openpilot.sunnypilot.modeld_v2.helpers import ALIGNMENT, PlainJit, load_model
 from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame
 
 IMG, DESIRE, STATE, OUT = (6, 8, 8), (8,), (4, 16), (1, 32)
@@ -119,3 +120,18 @@ class TestConvertUpstreamPkl(OpenpilotTestCase):
     bundle = load_model(out, cache=False, verify=True)
     assert bundle["metadata"] == {"name": "tiny"} and bundle["input_specs"] == self.input_specs and bundle["output_specs"] == self.output_specs
     self.assert_matches_eager(bundle["run"], 6)
+
+
+class TestKernelElf(OpenpilotTestCase):
+  def test_sections_follow_the_code(self):
+    from tinygrad.runtime.support.elf import elf_loader
+    code = bytes(range(1, 129))
+    for rodata, entry in ((len(code), 0), (0, 256)):
+      image = bytearray(code + bytes(64) if entry < rodata else bytes(256) + code)
+      struct.pack_into("<q", image, rodata + 16, entry - rodata)
+      loaded, sections, _ = elf_loader(_elf(bytes(image), rodata, entry))
+      headers = {section.name: section.header for section in sections}
+      assert bytes(loaded[ALIGNMENT:]) == bytes(image), "the uploaded program differs from the pickle's"
+      assert headers[".rodata"].sh_addr == ALIGNMENT + rodata, "the loader reads the kernel descriptor at .rodata"
+      text = headers[".text"]
+      assert text.sh_addr <= ALIGNMENT + entry < text.sh_addr + text.sh_size, "the amd mock sizes the code from the entry to the end of .text"

openpilot/sunnypilot/sunnylink/settings_ui.json

@@ -1412,6 +1412,12 @@
                 }
               ]
             },
+            {
+              "key": "TripSummary",
+              "widget": "toggle",
+              "title": "Trip Summary",
+              "description": "Show a summary of distance and engagement when you shift into park after a drive."
+            },
             {
               "key": "RocketFuel",
               "widget": "toggle",

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

@@ -39,6 +39,10 @@ sections:
     description: Show a timer on the HUD when the car is at a standstill.
     visibility:
     - $ref: '#/macros/hide_on_mici'
+  - key: TripSummary
+    widget: toggle
+    title: Trip Summary
+    description: Show a summary of distance and engagement when you shift into park after a drive.
   - key: RocketFuel
     widget: toggle
     title: Real-time Acceleration Bar

release/ci/model_generator.py

@@ -13,26 +13,41 @@ from pathlib import Path
 from datetime import datetime, UTC
 
 
+_VERSION_REGEX = re.compile(r'^(?:\d+[a-zA-Z]+|\d+[vVbB]\d+|[vVbB]\d+|\d{4})$')
+_DECIMAL_VERSION_REGEX = re.compile(r'^([vVbB]?)(\d+(?:\.\d+)+)$')
+
+
+def _version(word: str) -> str | None:
+  match = _DECIMAL_VERSION_REGEX.match(word.strip('()[]{}.,;:'))
+  if match:
+    return match.group(1).upper() + match.group(2)
+  stripped = re.sub(r'[^a-zA-Z0-9]', '', word)
+  return stripped.upper() if _VERSION_REGEX.match(stripped) else None
+
+
+def _truncate(short_name: str) -> str:
+  return short_name[:8].rstrip('.')
+
+
 def create_short_name(full_name: str) -> str:
-  # Remove parentheses and extract alphanumeric words
+  # Remove parentheses and extract alphanumeric words, keeping decimals for versioning
   clean_name = re.sub(r'\([^)]*\)', '', full_name)
-  words = [re.sub(r'[^a-zA-Z0-9]', '', word) for word in clean_name.split() if re.sub(r'[^a-zA-Z0-9]', '', word)]
+  words = [re.sub(r'[^a-zA-Z0-9.]', '', word) for word in clean_name.split()]
+  words = [word for word in words if word]
 
   if len(words) == 1:
-    return words[0][:8].upper()
+    return _truncate((_version(words[0]) or words[0]).upper())
 
-  # Handle special case: Name + Version (e.g., "Word A1" -> "WordA1")
-  if len(words) == 2 and re.match(r'^[A-Za-z]\d+$', words[1]):
-    return (words[0] + words[1])[:8].upper()
+  # Handle special case: Name + Version (e.g., "Word A1" -> "WordA1", "Model v1.1" -> "ModelV1.1")
+  if len(words) == 2 and re.match(r'^[A-Za-z]?\d+$', words[1]):
+    return _truncate((words[0] + (_version(words[1]) or words[1])).upper())
 
   result = ""
   for word in words:
     # Version or number patterns
-    if (re.match(r'^\d+[a-zA-Z]+$', word) or
-        re.match(r'^\d+[vVbB]\d+$', word) or
-        re.match(r'^[vVbB]\d+$', word) or
-        re.match(r'^\d{4}$', word)):
-      result += word.upper()
+    version = _version(word)
+    if version:
+      result += version
     # All uppercase abbreviations (2-3 letters)
     elif re.match(r'^[A-Z]{2,3}$', word):
       result += word
@@ -45,7 +60,7 @@ def create_short_name(full_name: str) -> str:
       result += word
     else:
       result += word[0].upper()
-  return result[:8]
+  return _truncate(result)
 
 
 def create_pkl_name(full_name: str) -> str: