Update exp_button.py

ui: update non-inline action button positioning in `ListViewSP`

.github/workflows/tests.yaml

@@ -107,8 +107,8 @@ jobs:
 
   build_mac:
     name: build macOS
-    if: false # tmp disable due to brew install not working
     runs-on: ${{ ((github.repository == 'commaai/openpilot') && ((github.event_name != 'pull_request') || (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))) && 'namespace-profile-macos-8x14' || 'macos-latest' }}
+    if: false  # There'll be one day that this works. That day is not today.
     steps:
     - uses: actions/checkout@v4
       with:

common/params_keys.h

@@ -95,7 +95,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"Offroad_NeosUpdate", {CLEAR_ON_MANAGER_START, JSON}},
     {"Offroad_NoFirmware", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
     {"Offroad_Recalibration", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
-    {"Offroad_StorageMissing", {CLEAR_ON_MANAGER_START, JSON}},
     {"Offroad_TemperatureTooHigh", {CLEAR_ON_MANAGER_START, JSON}},
     {"Offroad_UnregisteredHardware", {CLEAR_ON_MANAGER_START, JSON}},
     {"Offroad_UpdateFailed", {CLEAR_ON_MANAGER_START, JSON}},
@@ -214,6 +213,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"SubaruStopAndGo", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"SubaruStopAndGoManualParkingBrake", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"TeslaCoopSteering", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"ToyotaEnforceStockLongitudinal", {PERSISTENT | BACKUP, BOOL, "0"}},
 
     {"DynamicExperimentalControl", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"BlindSpot", {PERSISTENT | BACKUP, BOOL, "0"}},

docs/CONTRIBUTING.md

@@ -39,7 +39,7 @@ All of these are examples of good PRs:
 ### First contribution
 
 [Projects / openpilot bounties](https://github.com/orgs/commaai/projects/26/views/1?pane=info) is the best place to get started and goes in-depth on what's expected when working on a bounty.
-There's lot of bounties that don't require a comma 3/3X or a car.
+There's lot of bounties that don't require a comma 3X or a car.
 
 ## Pull Requests
 

docs/how-to/connect-to-comma.md

@@ -1,11 +1,11 @@
-# connect to a comma 3/3X
+# connect to a comma 3X
 
-A comma 3/3X is a normal [Linux](https://github.com/commaai/agnos-builder) computer that exposes [SSH](https://wiki.archlinux.org/title/Secure_Shell) and a [serial console](https://wiki.archlinux.org/title/Working_with_the_serial_console).
+A comma 3X is a normal [Linux](https://github.com/commaai/agnos-builder) computer that exposes [SSH](https://wiki.archlinux.org/title/Secure_Shell) and a [serial console](https://wiki.archlinux.org/title/Working_with_the_serial_console).
 
 ## Serial Console
 
 On both the comma three and 3X, the serial console is accessible from the main OBD-C port.
-Connect the comma 3/3X to your computer with a normal USB C cable, or use a [comma serial](https://comma.ai/shop/comma-serial) for steady 12V power.
+Connect the comma 3X to your computer with a normal USB C cable, or use a [comma serial](https://comma.ai/shop/comma-serial) for steady 12V power.
 
 On the comma three, the serial console is exposed through a UART-to-USB chip, and `tools/scripts/serial.sh` can be used to connect.
 
@@ -45,7 +45,7 @@ In order to use ADB on your device, you'll need to perform the following steps u
     * Here's an example command for connecting to your device using its tethered connection: `adb connect 192.168.43.1:5555`
 
 > [!NOTE]
-> The default port for ADB is 5555 on the comma 3/3X.
+> The default port for ADB is 5555 on the comma 3X.
 
 For more info on ADB, see the [Android Debug Bridge (ADB) documentation](https://developer.android.com/tools/adb).
 

docs/how-to/replay-a-drive.md

@@ -8,7 +8,7 @@ Replaying is a critical tool for openpilot development and debugging.
 Just run `tools/replay/replay --demo`.
 
 ## Replaying CAN data
-*Hardware required: jungle and comma 3/3X*
+*Hardware required: jungle and comma 3X*
 
 1. Connect your PC to a jungle.
 2.

docs/how-to/turn-the-speed-blue.md

@@ -3,7 +3,7 @@
 
 In 30 minutes, we'll get an openpilot development environment set up on your computer and make some changes to openpilot's UI.
 
-And if you have a comma 3/3X, we'll deploy the change to your device for testing.
+And if you have a comma 3X, we'll deploy the change to your device for testing.
 
 ## 1. Set up your development environment
 

launch_openpilot.sh

@@ -1,3 +1,20 @@
 #!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+# On any failure, run the fallback launcher
+trap 'exec ./launch_chffrplus.sh' ERR
+C3_LAUNCH_SH="./sunnypilot/system/hardware/c3/launch_chffrplus.sh"
+
+MODEL="$(tr -d '\0' < "/sys/firmware/devicetree/base/model")"
+export MODEL
+
+if [ "$MODEL" = "comma tici" ]; then
+  # Force a failure if the launcher doesn't exist
+  [ -x "$C3_LAUNCH_SH" ] || false
+
+  # If it exists, run it
+  exec "$C3_LAUNCH_SH"
+fi
 
 exec ./launch_chffrplus.sh

mkdocs.yml

@@ -21,7 +21,7 @@ nav:
     - What is openpilot?: getting-started/what-is-openpilot.md
   - How-to:
     - Turn the speed blue: how-to/turn-the-speed-blue.md
-    - Connect to a comma 3/3X: how-to/connect-to-comma.md
+    - Connect to a comma 3X: how-to/connect-to-comma.md
     # - Make your first pull request: how-to/make-first-pr.md
     #- Replay a drive: how-to/replay-a-drive.md
   - Concepts:

selfdrive/monitoring/helpers.py

@@ -449,7 +449,8 @@ class DriverMonitoring:
       rpyCalib = [0., 0., 0.]
     else:
       highway_speed = sm['carState'].vEgo
-      enabled = sm['selfdriveState'].enabled
+      # TODO-SP: unit test to assert both control checks are always present
+      enabled = sm['selfdriveState'].enabled or sm['carControl'].latActive
       wrong_gear = sm['carState'].gearShifter not in (car.CarState.GearShifter.drive, car.CarState.GearShifter.low)
       standstill = sm['carState'].standstill
       driver_engaged = sm['carState'].steeringPressed or sm['carState'].gasPressed

selfdrive/pandad/pandad.py

@@ -99,11 +99,6 @@ def main() -> None:
       cloudlog.event("pandad.flash_and_connect", count=count)
       params.remove("PandaSignatures")
 
-      # TODO: remove this in the next AGNOS
-      # wait until USB is up before counting
-      if time.monotonic() < 60.:
-        no_internal_panda_count = 0
-
       # Handle missing internal panda
       if no_internal_panda_count > 0:
         if no_internal_panda_count == 3:

selfdrive/pandad/tests/test_pandad.py

@@ -21,8 +21,6 @@ class TestPandad:
     if len(Panda.list()) == 0:
       self._run_test(60)
 
-    self.spi = HARDWARE.get_device_type() != 'tici'
-
   def teardown_method(self):
     managed_processes['pandad'].stop()
 
@@ -94,14 +92,12 @@ class TestPandad:
     # - 0.2s pandad -> pandad
     # - plus some buffer
     print("startup times", ts, sum(ts) / len(ts))
-    assert 0.1 < (sum(ts)/len(ts)) < (0.7 if self.spi else 5.0)
+    assert 0.1 < (sum(ts)/len(ts)) < 0.7
 
-  def test_protocol_version_check(self):
-    if not self.spi:
-      pytest.skip("SPI test")
-    # flash old fw
-    fn = os.path.join(HERE, "bootstub.panda_h7_spiv0.bin")
-    self._flash_bootstub_and_test(fn, expect_mismatch=True)
+  def test_old_spi_protocol(self):
+    # flash firmware with old SPI protocol
+    self._flash_bootstub(os.path.join(HERE, "bootstub.panda_h7_spiv0.bin"))
+    self._run_test(45)
 
   def test_release_to_devel_bootstub(self):
     self._flash_bootstub(None)

selfdrive/pandad/tests/test_pandad_spi.py

@@ -6,7 +6,6 @@ import random
 
 import cereal.messaging as messaging
 from cereal.services import SERVICE_LIST
-from openpilot.system.hardware import HARDWARE
 from openpilot.selfdrive.test.helpers import with_processes
 from openpilot.selfdrive.pandad.tests.test_pandad_loopback import setup_pandad, send_random_can_messages
 
@@ -16,8 +15,6 @@ JUNGLE_SPAM = "JUNGLE_SPAM" in os.environ
 class TestBoarddSpi:
   @classmethod
   def setup_class(cls):
-    if HARDWARE.get_device_type() == 'tici':
-      pytest.skip("only for spi pandas")
     os.environ['STARTED'] = '1'
     os.environ['SPI_ERR_PROB'] = '0.001'
     if not JUNGLE_SPAM:

selfdrive/selfdrived/alerts_offroad.json

@@ -29,10 +29,6 @@
     "text": "Failed to register with comma.ai backend. It will not connect or upload to comma.ai servers, and receives no support from comma.ai. If this is a device purchased at comma.ai/shop, open a ticket at https://comma.ai/support.",
     "severity": 1
   },
-  "Offroad_StorageMissing": {
-    "text": "NVMe drive not mounted.",
-    "severity": 1
-  },
   "Offroad_CarUnrecognized": {
     "text": "sunnypilot was unable to identify your car. Your car is either unsupported or its ECUs are not recognized. Please submit a pull request to add the firmware versions to the proper vehicle. Need help? Join discord.comma.ai.",
     "severity": 0

selfdrive/selfdrived/selfdrived.py

@@ -21,7 +21,6 @@ from openpilot.selfdrive.selfdrived.helpers import ExcessiveActuationCheck
 from openpilot.selfdrive.selfdrived.state import StateMachine
 from openpilot.selfdrive.selfdrived.alertmanager import AlertManager, set_offroad_alert
 
-from openpilot.system.hardware import HARDWARE
 from openpilot.system.version import get_build_metadata
 from openpilot.system.hardware import HARDWARE
 
@@ -144,14 +143,7 @@ class SelfdriveD(CruiseHelper):
     self.state_machine = StateMachine()
     self.rk = Ratekeeper(100, print_delay_threshold=None)
 
-    # some comma three with NVMe experience NVMe dropouts mid-drive that
-    # cause loggerd to crash on write, so ignore it only on that platform
-    self.ignored_processes = set()
-    nvme_expected = os.path.exists('/dev/nvme0n1') or (not os.path.isfile("/persist/comma/living-in-the-moment"))
-    if HARDWARE.get_device_type() == 'tici' and nvme_expected:
-      self.ignored_processes = {'loggerd', }
-
-    self.ignored_processes.update({'mapd'})
+    self.ignored_processes = {'mapd', }
 
     # Determine startup event
     is_remote = build_metadata.openpilot.comma_remote or build_metadata.openpilot.sunnypilot_remote

selfdrive/ui/mici/layouts/main.py

@@ -11,6 +11,9 @@ from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.scroller import Scroller
 from openpilot.system.ui.lib.application import gui_app
 
+if gui_app.sunnypilot_ui():
+  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
+
 
 ONROAD_DELAY = 2.5  # seconds
 

selfdrive/ui/mici/onroad/confidence_ball.py

@@ -6,6 +6,8 @@ from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.common.filter_simple import FirstOrderFilter
 
+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.confidence_ball import ConfidenceBallSP
+
 
 def draw_circle_gradient(center_x: float, center_y: float, radius: int,
                          top: rl.Color, bottom: rl.Color) -> None:
@@ -21,9 +23,10 @@ def draw_circle_gradient(center_x: float, center_y: float, radius: int,
                20, rl.BLACK)
 
 
-class ConfidenceBall(Widget):
+class ConfidenceBall(Widget, ConfidenceBallSP):
   def __init__(self, demo: bool = False):
-    super().__init__()
+    Widget.__init__(self)
+    ConfidenceBallSP.__init__(self)
     self._demo = demo
     self._confidence_filter = FirstOrderFilter(-0.5, 0.5, 1 / gui_app.target_fps)
 
@@ -37,6 +40,8 @@ class ConfidenceBall(Widget):
     # animate status dot in from bottom
     if ui_state.status == UIStatus.DISENGAGED:
       self._confidence_filter.update(-0.5)
+    elif ui_state.status in (UIStatus.LAT_ONLY, UIStatus.LONG_ONLY):
+      self._confidence_filter.update(1 - max(self.get_animate_status_probs() or [1]))
     else:
       self._confidence_filter.update((1 - max(ui_state.sm['modelV2'].meta.disengagePredictions.brakeDisengageProbs or [1])) *
                                                         (1 - max(ui_state.sm['modelV2'].meta.disengagePredictions.steerOverrideProbs or [1])))
@@ -65,6 +70,9 @@ class ConfidenceBall(Widget):
         top_dot_color = rl.Color(255, 0, 21, 255)
         bottom_dot_color = rl.Color(255, 0, 89, 255)
 
+    elif ui_state.status in (UIStatus.LAT_ONLY, UIStatus.LONG_ONLY):
+      top_dot_color = bottom_dot_color = self.get_lat_long_dot_color()
+
     elif ui_state.status == UIStatus.OVERRIDE:
       top_dot_color = rl.Color(255, 255, 255, 255)
       bottom_dot_color = rl.Color(82, 82, 82, 255)

selfdrive/ui/mici/onroad/model_renderer.py

@@ -12,6 +12,8 @@ from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
 from openpilot.system.ui.widgets import Widget
 
+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.model_renderer import LANE_LINE_COLORS_SP
+
 CLIP_MARGIN = 500
 MIN_DRAW_DISTANCE = 10.0
 MAX_DRAW_DISTANCE = 100.0
@@ -32,6 +34,7 @@ LANE_LINE_COLORS = {
   UIStatus.DISENGAGED: rl.Color(200, 200, 200, 255),
   UIStatus.OVERRIDE: rl.Color(255, 255, 255, 255),
   UIStatus.ENGAGED: rl.Color(0, 255, 64, 255),
+  **LANE_LINE_COLORS_SP,
 }
 
 

selfdrive/ui/mici/onroad/torque_bar.py

@@ -185,13 +185,13 @@ class TorqueBar(Widget):
 
     # animate alpha and angle span
     if not self._demo:
-      self._torque_line_alpha_filter.update(ui_state.status != UIStatus.DISENGAGED)
+      self._torque_line_alpha_filter.update(ui_state.status not in (UIStatus.DISENGAGED, UIStatus.LONG_ONLY))
     else:
       self._torque_line_alpha_filter.update(1.0)
 
     torque_line_bg_alpha = np.interp(abs(self._torque_filter.x), [0.5, 1.0], [0.25, 0.5])
     torque_line_bg_color = rl.Color(255, 255, 255, int(255 * torque_line_bg_alpha * self._torque_line_alpha_filter.x))
-    if ui_state.status != UIStatus.ENGAGED and not self._demo:
+    if ui_state.status not in (UIStatus.ENGAGED, UIStatus.LAT_ONLY) and not self._demo:
       torque_line_bg_color = rl.Color(255, 255, 255, int(255 * 0.15 * self._torque_line_alpha_filter.x))
 
     # draw curved line polygon torque bar
@@ -234,7 +234,7 @@ class TorqueBar(Widget):
       max(0, abs(self._torque_filter.x) - 0.75) * 4,
     )
 
-    if ui_state.status != UIStatus.ENGAGED and not self._demo:
+    if ui_state.status not in (UIStatus.ENGAGED, UIStatus.LAT_ONLY) and not self._demo:
       start_color = end_color = rl.Color(255, 255, 255, int(255 * 0.35 * self._torque_line_alpha_filter.x))
 
     gradient = Gradient(

selfdrive/ui/onroad/augmented_road_view.py

@@ -17,6 +17,8 @@ from openpilot.common.transformations.orientation import rot_from_euler
 if gui_app.sunnypilot_ui():
   from openpilot.selfdrive.ui.sunnypilot.onroad.hud_renderer import HudRendererSP as HudRenderer
 
+from openpilot.selfdrive.ui.sunnypilot.onroad.augmented_road_view import BORDER_COLORS_SP
+
 OpState = log.SelfdriveState.OpenpilotState
 CALIBRATED = log.LiveCalibrationData.Status.calibrated
 ROAD_CAM = VisionStreamType.VISION_STREAM_ROAD
@@ -27,6 +29,7 @@ BORDER_COLORS = {
   UIStatus.DISENGAGED: rl.Color(0x12, 0x28, 0x39, 0xFF),  # Blue for disengaged state
   UIStatus.OVERRIDE: rl.Color(0x89, 0x92, 0x8D, 0xFF),  # Gray for override state
   UIStatus.ENGAGED: rl.Color(0x16, 0x7F, 0x40, 0xFF),  # Green for engaged state
+  **BORDER_COLORS_SP,
 }
 
 WIDE_CAM_MAX_SPEED = 10.0  # m/s (22 mph)

selfdrive/ui/onroad/exp_button.py

@@ -50,7 +50,12 @@ class ExpButton(Widget):
 
     texture = self._txt_exp if self._held_or_actual_mode() else self._txt_wheel
     rl.draw_circle(center_x, center_y, self._rect.width / 2, self._black_bg)
-    rl.draw_texture(texture, center_x - texture.width // 2, center_y - texture.height // 2, self._white_color)
+
+    src_rect = rl.Rectangle(0.0, 0.0, texture.width, texture.height)
+    dest_rect = rl.Rectangle(center_x, center_y, texture.width, texture.height)
+    origin = rl.Vector2(texture.width / 2.0, texture.height / 2.0)
+    rotation = -ui_state.sm['carState'].steeringAngleDeg
+    rl.draw_texture_pro(texture, src_rect, dest_rect, origin, rotation, self._white_color)
 
   def _held_or_actual_mode(self):
     now = time.monotonic()

selfdrive/ui/onroad/model_renderer.py

@@ -11,6 +11,8 @@ from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
 from openpilot.system.ui.widgets import Widget
 
+from openpilot.selfdrive.ui.sunnypilot.onroad.model_renderer import ChevronMetrics, ModelRendererSP
+
 CLIP_MARGIN = 500
 MIN_DRAW_DISTANCE = 10.0
 MAX_DRAW_DISTANCE = 100.0
@@ -41,9 +43,11 @@ class LeadVehicle:
   fill_alpha: int = 0
 
 
-class ModelRenderer(Widget):
+class ModelRenderer(Widget, ChevronMetrics, ModelRendererSP):
   def __init__(self):
-    super().__init__()
+    Widget.__init__(self)
+    ChevronMetrics.__init__(self)
+    ModelRendererSP.__init__(self)
     self._longitudinal_control = False
     self._experimental_mode = False
     self._blend_filter = FirstOrderFilter(1.0, 0.25, 1 / gui_app.target_fps)
@@ -128,6 +132,7 @@ class ModelRenderer(Widget):
 
     if render_lead_indicator and radar_state:
       self._draw_lead_indicator()
+      self.chevron_metrics.draw_lead_status(sm, radar_state, self._rect, self._lead_vehicles)
 
   def _update_raw_points(self, model):
     """Update raw 3D points from model data"""
@@ -281,6 +286,10 @@ class ModelRenderer(Widget):
     allow_throttle = sm['longitudinalPlan'].allowThrottle or not self._longitudinal_control
     self._blend_filter.update(int(allow_throttle))
 
+    if ui_state.rainbow_path:
+      self.rainbow_path.draw_rainbow_path(self._rect, self._path)
+      return
+
     if self._experimental_mode:
       # Draw with acceleration coloring
       if len(self._exp_gradient.colors) > 1:

selfdrive/ui/soundd.py

@@ -27,7 +27,7 @@ AMBIENT_DB = 30 # DB where MIN_VOLUME is applied
 DB_SCALE = 30 # AMBIENT_DB + DB_SCALE is where MAX_VOLUME is applied
 
 VOLUME_BASE = 20
-if HARDWARE.get_device_type() in ("tizi", "tici"):
+if HARDWARE.get_device_type() == "tizi":
   VOLUME_BASE = 10
 
 AudibleAlert = car.CarControl.HUDControl.AudibleAlert
@@ -55,7 +55,7 @@ sound_list: dict[int, tuple[str, int | None, float]] = {
 
   **sound_list_sp,
 }
-if HARDWARE.get_device_type() in ("tizi", "tici"):
+if HARDWARE.get_device_type() == "tizi":
   sound_list.update({
     AudibleAlert.engage: ("engage_tizi.wav", 1, MAX_VOLUME),
     AudibleAlert.disengage: ("disengage_tizi.wav", 1, MAX_VOLUME),

selfdrive/ui/sunnypilot/layouts/settings/vehicle/__init__.py

@@ -23,7 +23,7 @@ class VehicleLayout(Widget):
     self._current_brand = None
     self._platform_selector = PlatformSelector(self._update_brand_settings)
 
-    self._vehicle_item = ListItemSP(title=self._platform_selector.text, action_item=ButtonAction(text=tr("Select")),
+    self._vehicle_item = ListItemSP(title=self._platform_selector.text, action_item=ButtonAction(text=tr("SELECT")),
                                     callback=self._platform_selector._on_clicked)
     self._vehicle_item.title_color = self._platform_selector.color
     self._legend_widget = LegendWidget(self._platform_selector)
@@ -42,7 +42,7 @@ class VehicleLayout(Widget):
   def _update_brand_settings(self):
     self._vehicle_item._title = self._platform_selector.text
     self._vehicle_item.title_color = self._platform_selector.color
-    vehicle_text = tr("Remove") if ui_state.params.get("CarPlatformBundle") else tr("Select")
+    vehicle_text = tr("REMOVE") if ui_state.params.get("CarPlatformBundle") else tr("SELECT")
     self._vehicle_item.action_item.set_text(vehicle_text)
 
     brand = self.get_brand()

selfdrive/ui/sunnypilot/layouts/settings/vehicle/brands/toyota.py

@@ -5,11 +5,55 @@ 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.selfdrive.ui.sunnypilot.layouts.settings.vehicle.brands.base import BrandSettings
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.multilang import tr, tr_noop
+from openpilot.system.ui.widgets import DialogResult
+from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
+from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
+
+
+DESCRIPTIONS = {
+  'enforce_stock_longitudinal': tr_noop(
+    'sunnypilot will not take over control of gas and brakes. Factory Toyota longitudinal control will be used.'
+  ),
+}
 
 
 class ToyotaSettings(BrandSettings):
   def __init__(self):
     super().__init__()
 
+    self.enforce_stock_longitudinal = toggle_item_sp(
+      lambda: tr("Enforce Factory Longitudinal Control"),
+      description=lambda: tr(DESCRIPTIONS["enforce_stock_longitudinal"]),
+      initial_state=ui_state.params.get_bool("ToyotaEnforceStockLongitudinal"),
+      callback=self._on_enable_enforce_stock_longitudinal,
+      enabled=lambda: not ui_state.engaged,
+    )
+
+    self.items = [self.enforce_stock_longitudinal, ]
+
+  def _on_enable_enforce_stock_longitudinal(self, state: bool):
+    if state:
+      def confirm_callback(result: int):
+        if result == DialogResult.CONFIRM:
+          ui_state.params.put_bool("ToyotaEnforceStockLongitudinal", True)
+          if ui_state.params.get_bool("AlphaLongitudinalEnabled"):
+            ui_state.params.put_bool("AlphaLongitudinalEnabled", False)
+          ui_state.params.put_bool("OnroadCycleRequested", True)
+        else:
+          self.enforce_stock_longitudinal.action_item.set_state(False)
+
+      content = (f"<h1>{self.enforce_stock_longitudinal.title}</h1><br>" +
+                 f"<p>{self.enforce_stock_longitudinal.description}</p>")
+
+      dlg = ConfirmDialog(content, tr("Enable"), rich=True)
+      gui_app.set_modal_overlay(dlg, callback=confirm_callback)
+
+    else:
+      ui_state.params.put_bool("ToyotaEnforceStockLongitudinal", False)
+      ui_state.params.put_bool("OnroadCycleRequested", True)
+
   def update_settings(self):
     pass

selfdrive/ui/sunnypilot/mici/layouts/settings.py

@@ -0,0 +1,39 @@
+"""
+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 enum import IntEnum
+
+from openpilot.selfdrive.ui.mici.layouts.settings import settings as OP
+from openpilot.selfdrive.ui.mici.widgets.button import BigButton
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
+
+ICON_SIZE = 70
+
+OP.PanelType = IntEnum(  # type: ignore
+  "PanelType",
+  [es.name for es in OP.PanelType] + [
+    "SUNNYLINK",
+  ],
+  start=0,
+)
+
+
+class SettingsLayoutSP(OP.SettingsLayout):
+  def __init__(self):
+    OP.SettingsLayout.__init__(self)
+
+    sunnylink_btn = BigButton("sunnylink", "", "icons_mici/settings/developer/ssh.png")
+    sunnylink_btn.set_click_callback(lambda: self._set_current_panel(OP.PanelType.SUNNYLINK))
+    self._panels.update({
+      OP.PanelType.SUNNYLINK: OP.PanelInfo("sunnylink", SunnylinkLayoutMici(back_callback=lambda: self._set_current_panel(None))),
+    })
+
+    items = self._scroller._items.copy()
+
+    items.insert(1, sunnylink_btn)
+    self._scroller._items.clear()
+    for item in items:
+      self._scroller.add_widget(item)

selfdrive/ui/sunnypilot/mici/layouts/sunnylink.py

@@ -0,0 +1,192 @@
+"""
+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 collections.abc import Callable
+
+import pyray as rl
+from cereal import custom
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialogV2
+from openpilot.selfdrive.ui.sunnypilot.mici.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
+from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.system.ui.lib.multilang import tr
+
+from openpilot.system.ui.widgets.scroller import Scroller
+from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigToggle
+from openpilot.system.ui.lib.application import gui_app, MousePos
+from openpilot.system.ui.widgets import NavWidget
+from openpilot.selfdrive.ui.ui_state import ui_state
+
+
+class SunnylinkLayoutMici(NavWidget):
+  def __init__(self, back_callback: Callable):
+    super().__init__()
+    self.set_back_callback(back_callback)
+    self._restore_in_progress = False
+    self._backup_in_progress = False
+    self._sunnylink_enabled = ui_state.params.get("SunnylinkEnabled")
+
+    self._sunnylink_toggle = BigToggle(text="",
+                                       initial_state=self._sunnylink_enabled,
+                                       toggle_callback=SunnylinkLayoutMici._sunnylink_toggle_callback)
+    self._sunnylink_sponsor_button = SunnylinkPairBigButton(sponsor_pairing=False)
+    self._sunnylink_pair_button = SunnylinkPairBigButton(sponsor_pairing=True)
+    self._backup_btn = BigButton(tr("backup settings"), "", "")
+    self._backup_btn.set_click_callback(lambda: self._handle_backup_restore_btn(restore=False))
+    self._restore_btn = BigButton(tr("restore settings"), "", "")
+    self._restore_btn.set_click_callback(lambda: self._handle_backup_restore_btn(restore=True))
+    self._sunnylink_uploader_toggle = BigToggle(text=tr("sunnylink uploader"), initial_state=False,
+                                                toggle_callback=SunnylinkLayoutMici._sunnylink_uploader_callback)
+
+    self._scroller = Scroller([
+      self._sunnylink_toggle,
+      self._sunnylink_sponsor_button,
+      self._sunnylink_pair_button,
+      self._backup_btn,
+      self._restore_btn,
+      self._sunnylink_uploader_toggle
+    ], snap_items=False)
+
+  def _update_state(self):
+    super()._update_state()
+    self._sunnylink_enabled = ui_state.sunnylink_enabled
+    self._sunnylink_toggle.set_text(tr("enable sunnylink"))
+    self._sunnylink_pair_button.set_visible(self._sunnylink_enabled)
+    self._sunnylink_sponsor_button.set_visible(self._sunnylink_enabled)
+    self._backup_btn.set_visible(self._sunnylink_enabled)
+    self._restore_btn.set_visible(self._sunnylink_enabled)
+    self._sunnylink_uploader_toggle.set_visible(self._sunnylink_enabled)
+    self.handle_backup_restore_progress()
+
+    if ui_state.sunnylink_state.is_sponsor():
+      self._sunnylink_sponsor_button.set_text(tr("thanks"))
+      self._sunnylink_sponsor_button.set_value(ui_state.sunnylink_state.get_sponsor_tier().name.lower())
+      self._sunnylink_sponsor_button.set_enabled(False)
+    else:
+      self._sunnylink_sponsor_button.set_text(tr("sponsor"))
+      self._sunnylink_sponsor_button.set_value("")
+
+    if ui_state.sunnylink_state.is_paired():
+      self._sunnylink_pair_button.set_text(tr("paired"))
+    else:
+      self._sunnylink_pair_button.set_text(tr("pair"))
+
+  def show_event(self):
+    super().show_event()
+    self._scroller.show_event()
+    ui_state.update_params()
+
+  def _render(self, rect: rl.Rectangle):
+    self._scroller.render(rect)
+
+  @staticmethod
+  def _sunnylink_toggle_callback(state: bool):
+    ui_state.params.put_bool("SunnylinkEnabled", state)
+    ui_state.update_params()
+
+  @staticmethod
+  def _sunnylink_uploader_callback(state: bool):
+    ui_state.params.put_bool("EnableSunnylinkUploader", state)
+
+  def _handle_backup_restore_btn(self, restore: bool = False):
+    lbl = tr("slide to restore") if restore else tr("slide to backup")
+    icon = "icons_mici/settings/device/update.png"
+    dlg = BigConfirmationDialogV2(lbl, icon, confirm_callback=self._restore_handler if restore else self._backup_handler)
+    gui_app.set_modal_overlay(dlg)
+
+  def _backup_handler(self):
+    self._backup_in_progress = True
+    self._backup_btn.set_enabled(False)
+    ui_state.params.put_bool("BackupManager_CreateBackup", True)
+
+  def _restore_handler(self):
+    self._restore_in_progress = True
+    self._restore_btn.set_enabled(False)
+    ui_state.params.put("BackupManager_RestoreVersion", "latest")
+
+  def handle_backup_restore_progress(self):
+    sunnylink_backup_manager = ui_state.sm["backupManagerSP"]
+
+    backup_status = sunnylink_backup_manager.backupStatus
+    restore_status = sunnylink_backup_manager.restoreStatus
+    backup_progress = sunnylink_backup_manager.backupProgress
+    restore_progress = sunnylink_backup_manager.restoreProgress
+
+    if self._backup_in_progress:
+      self._restore_btn.set_enabled(False)
+      self._backup_btn.set_enabled(False)
+
+      if backup_status == custom.BackupManagerSP.Status.inProgress:
+        self._backup_in_progress = True
+        self._backup_btn.set_text(tr("backing up"))
+        text = tr(f"{backup_progress}%")
+        self._backup_btn.set_value(text)
+
+      elif backup_status == custom.BackupManagerSP.Status.failed:
+        self._backup_in_progress = False
+        self._backup_btn.set_enabled(not ui_state.is_onroad())
+        self._backup_btn.set_text(tr("backup"))
+        self._backup_btn.set_value(tr("failed"))
+
+      elif (backup_status == custom.BackupManagerSP.Status.completed or
+            (backup_status == custom.BackupManagerSP.Status.idle and backup_progress == 100.0)):
+        self._backup_in_progress = False
+        gui_app.set_modal_overlay(BigDialog(title=tr("settings backed up"), description=""))
+        self._backup_btn.set_enabled(not ui_state.is_onroad())
+
+    elif self._restore_in_progress:
+      self._restore_btn.set_enabled(False)
+      self._backup_btn.set_enabled(False)
+
+      if restore_status == custom.BackupManagerSP.Status.inProgress:
+        self._restore_in_progress = True
+        self._restore_btn.set_text(tr("restoring"))
+        text = tr(f"{restore_progress}%")
+        self._restore_btn.set_value(text)
+
+      elif restore_status == custom.BackupManagerSP.Status.failed:
+        self._restore_in_progress = False
+        self._restore_btn.set_enabled(not ui_state.is_onroad())
+        self._restore_btn.set_text(tr("restore"))
+        self._restore_btn.set_value(tr("failed"))
+        gui_app.set_modal_overlay(BigDialog(title=tr("unable to restore"), description="try again later."))
+
+      elif (restore_status == custom.BackupManagerSP.Status.completed or
+            (restore_status == custom.BackupManagerSP.Status.idle and restore_progress == 100.0)):
+        self._restore_in_progress = False
+        gui_app.set_modal_overlay(BigConfirmationDialogV2(
+          title="slide to restart", icon="icons_mici/settings/device/reboot.png",
+          confirm_callback=lambda: gui_app.request_close()))
+
+    else:
+      can_enable = self._sunnylink_enabled and not ui_state.is_onroad()
+      self._backup_btn.set_enabled(can_enable)
+      self._backup_btn.set_text(tr("backup settings"))
+      self._backup_btn.set_value("")
+      self._restore_btn.set_enabled(can_enable)
+      self._restore_btn.set_text(tr("restore settings"))
+      self._restore_btn.set_value("")
+
+
+class SunnylinkPairBigButton(BigButton):
+  def __init__(self, sponsor_pairing: bool = False):
+    self.sponsor_pairing = sponsor_pairing
+    super().__init__("", "", "")
+
+  def _update_state(self):
+    super()._update_state()
+
+  def _handle_mouse_release(self, mouse_pos: MousePos):
+    super()._handle_mouse_release(mouse_pos)
+
+    dlg: BigDialog | SunnylinkPairingDialog | None = None
+    if UNREGISTERED_SUNNYLINK_DONGLE_ID == (ui_state.params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID):
+      dlg = BigDialog(tr("sunnylink Dongle ID not found. Please reboot & try again."), "")
+    elif self.sponsor_pairing:
+      dlg = SunnylinkPairingDialog(sponsor_pairing=True)
+    elif not self.sponsor_pairing:
+      dlg = SunnylinkPairingDialog(sponsor_pairing=False)
+    if dlg:
+      gui_app.set_modal_overlay(dlg)

selfdrive/ui/sunnypilot/mici/onroad/confidence_ball.py

@@ -0,0 +1,26 @@
+"""
+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.selfdrive.ui.onroad.augmented_road_view import BORDER_COLORS
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
+
+
+class ConfidenceBallSP:
+  @staticmethod
+  def get_animate_status_probs():
+    if ui_state.status == UIStatus.LAT_ONLY:
+      return ui_state.sm['modelV2'].meta.disengagePredictions.steerOverrideProbs
+
+    # UIStatus.LONG_ONLY
+    return ui_state.sm['modelV2'].meta.disengagePredictions.brakeDisengageProbs
+
+  @staticmethod
+  def get_lat_long_dot_color():
+    if ui_state.status == UIStatus.LAT_ONLY:
+      return BORDER_COLORS[UIStatus.LAT_ONLY]
+
+    # UIStatus.LONG_ONLY
+    return BORDER_COLORS[UIStatus.LONG_ONLY]

selfdrive/ui/sunnypilot/mici/onroad/model_renderer.py

@@ -0,0 +1,13 @@
+"""
+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.ui_state import UIStatus
+
+LANE_LINE_COLORS_SP = {
+  UIStatus.LAT_ONLY: rl.Color(0, 255, 64, 255),
+  UIStatus.LONG_ONLY: rl.Color(0, 255, 64, 255),
+}

selfdrive/ui/sunnypilot/mici/widgets/sunnylink_pairing_dialog.py

@@ -0,0 +1,57 @@
+"""
+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 base64
+
+import pyray as rl
+from openpilot.common.swaglog import cloudlog
+from openpilot.selfdrive.ui.mici.widgets.pairing_dialog import PairingDialog
+from openpilot.sunnypilot.sunnylink.api import SunnylinkApi, UNREGISTERED_SUNNYLINK_DONGLE_ID, API_HOST
+from openpilot.system.ui.lib.application import FontWeight, gui_app
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.widgets import NavWidget
+from openpilot.system.ui.widgets.label import MiciLabel
+
+
+class SunnylinkPairingDialog(PairingDialog):
+  """Dialog for device pairing with QR code."""
+
+  def __init__(self, sponsor_pairing: bool = False):
+    PairingDialog.__init__(self)
+    self._sponsor_pairing = sponsor_pairing
+    label_text = tr("pair with sunnylink") if sponsor_pairing else tr("become a sunnypilot sponsor")
+    self._pair_label = MiciLabel(label_text, 48, font_weight=FontWeight.BOLD,
+                                 color=rl.Color(255, 255, 255, int(255 * 0.9)), line_height=40, wrap_text=True)
+
+  def _get_pairing_url(self) -> str:
+    qr_string = "https://github.com/sponsors/sunnyhaibin"
+
+    if self._sponsor_pairing:
+      try:
+        sl_dongle_id = self._params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID
+        token = SunnylinkApi(sl_dongle_id).get_token()
+        inner_string = f"1|{sl_dongle_id}|{token}"
+        payload_bytes = base64.b64encode(inner_string.encode('utf-8')).decode('utf-8')
+        qr_string = f"{API_HOST}/sso?state={payload_bytes}"
+      except Exception:
+        cloudlog.exception("Failed to get pairing token")
+
+    return qr_string
+
+  def _update_state(self):
+    NavWidget._update_state(self)
+
+
+if __name__ == "__main__":
+  gui_app.init_window("pairing device")
+  pairing = SunnylinkPairingDialog(sponsor_pairing=True)
+  try:
+    for _ in gui_app.render():
+      result = pairing.render(rl.Rectangle(0, 0, gui_app.width, gui_app.height))
+      if result != -1:
+        break
+  finally:
+    del pairing

selfdrive/ui/sunnypilot/onroad/augmented_road_view.py

@@ -0,0 +1,13 @@
+"""
+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.ui_state import UIStatus
+
+BORDER_COLORS_SP = {
+  UIStatus.LAT_ONLY: rl.Color(0x00, 0xC8, 0xC8, 0xFF),  # Cyan for lateral-only state
+  UIStatus.LONG_ONLY: rl.Color(0x96, 0x1C, 0xA8, 0xFF),  # Purple for longitudinal-only state
+}

selfdrive/ui/sunnypilot/onroad/chevron_metrics.py

@@ -0,0 +1,147 @@
+"""
+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 numpy as np
+
+import pyray as rl
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+
+
+class ChevronOptions:
+  OFF = 0
+  DISTANCE_ONLY = 1
+  SPEED_ONLY = 2
+  TTC_ONLY = 3
+  ALL = 4
+
+
+class ChevronMetrics:
+  def __init__(self):
+    self._lead_status_alpha: float = 0.0
+    self._font = gui_app.font(FontWeight.SEMI_BOLD)
+
+  def update_alpha(self, has_lead: bool):
+    """Update the alpha value for fade in/out animation"""
+    if not has_lead:
+      self._lead_status_alpha = max(0.0, self._lead_status_alpha - 0.05)
+    else:
+      self._lead_status_alpha = min(1.0, self._lead_status_alpha + 0.1)
+
+  def should_render(self) -> bool:
+    """Check if dev UI should be rendered"""
+    return ui_state.chevron_metrics != ChevronOptions.OFF and self._lead_status_alpha > 0.0
+
+  def _draw_lead(self, lead_data, lead_vehicle, v_ego: float, rect: rl.Rectangle):
+    """Draw lead vehicle status information (distance, speed, TTC)"""
+    if not self.should_render():
+      return
+
+    d_rel = lead_data.dRel
+    v_rel = lead_data.vRel
+
+    if not lead_vehicle.chevron or len(lead_vehicle.chevron) < 2:
+      return
+
+    chevron_x = lead_vehicle.chevron[1][0]
+    chevron_y = lead_vehicle.chevron[1][1]
+    sz = np.clip((25 * 30) / (d_rel / 3 + 30), 15.0, 30.0) * 2.35
+
+    text_lines = self._build_text_lines(d_rel, v_rel, v_ego)
+    if not text_lines:
+      return
+
+    self._render_text_lines(text_lines, chevron_x, chevron_y, sz, rect)
+
+  @staticmethod
+  def _build_text_lines(d_rel: float, v_rel: float, v_ego: float) -> list[str]:
+    """Build text lines based on chevron info setting"""
+    text_lines = []
+
+    # Distance
+    if ui_state.chevron_metrics == ChevronOptions.DISTANCE_ONLY or ui_state.chevron_metrics == ChevronOptions.ALL:
+      val = max(0.0, d_rel)
+      unit = "m" if ui_state.is_metric else "ft"
+      if not ui_state.is_metric:
+        val *= 3.28084
+      text_lines.append(f"{val:.0f} {unit}")
+
+    # Speed
+    if ui_state.chevron_metrics == ChevronOptions.SPEED_ONLY or ui_state.chevron_metrics == ChevronOptions.ALL:
+      multiplier = CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH
+      val = max(0.0, (v_rel + v_ego) * multiplier)
+      unit = "km/h" if ui_state.is_metric else "mph"
+      text_lines.append(f"{val:.0f} {unit}")
+
+    # Time to collision
+    if ui_state.chevron_metrics == ChevronOptions.TTC_ONLY or ui_state.chevron_metrics == ChevronOptions.ALL:
+      val = (d_rel / v_ego) if (d_rel > 0 and v_ego > 0) else 0.0
+      ttc_text = f"{val:.1f} s" if (0 < val < 200) else "---"
+      text_lines.append(ttc_text)
+
+    return text_lines
+
+  def _render_text_lines(self, text_lines: list[str], chevron_x: float, chevron_y: float,
+                         sz: float, rect: rl.Rectangle):
+    """Render text lines with proper centering and positioning"""
+    font_size = 40
+    line_height = 50
+    margin = 20
+
+    text_y = chevron_y + sz + 15
+    total_height = len(text_lines) * line_height
+
+    # Adjust Y position if text would go off screen
+    if text_y + total_height > rect.height - margin:
+      y_max = min(chevron_y, rect.height - margin)
+      text_y = y_max - 15 - total_height
+      text_y = max(margin, text_y)
+
+    alpha = int(255 * self._lead_status_alpha)
+    text_color = rl.Color(255, 255, 255, alpha)
+    shadow_color = rl.Color(0, 0, 0, int(200 * self._lead_status_alpha))
+
+    for i, line in enumerate(text_lines):
+      y = int(text_y + (i * line_height))
+      if y + line_height > rect.height - margin:
+        break
+
+      # Measure actual text width for proper centering
+      text_size = measure_text_cached(self._font, line, font_size, 0)
+      text_width = text_size.x
+
+      # Center the text horizontally on the chevron
+      x = int(chevron_x - text_width / 2)
+      x = int(np.clip(x, margin, rect.width - text_width - margin))
+
+      # Draw shadow
+      rl.draw_text_ex(self._font, line, rl.Vector2(x + 2, y + 2), font_size, 0, shadow_color)
+      # Draw text
+      rl.draw_text_ex(self._font, line, rl.Vector2(x, y), font_size, 0, text_color)
+
+  def draw_lead_status(self, sm, radar_state, rect, lead_vehicles):
+    lead_one = radar_state.leadOne
+    lead_two = radar_state.leadTwo
+
+    has_lead_one = lead_one.status if lead_one else False
+    has_lead_two = lead_two.status if lead_two else False
+
+    self.update_alpha(has_lead_one or has_lead_two)
+
+    if not self.should_render():
+      return
+
+    v_ego = sm['carState'].vEgo
+
+    if has_lead_one and lead_vehicles[0].chevron:
+      self._draw_lead(lead_one, lead_vehicles[0], v_ego, rect)
+
+    if has_lead_two and lead_vehicles[1].chevron:
+      d_rel_diff = abs(lead_one.dRel - lead_two.dRel) if has_lead_one else float('inf')
+      if d_rel_diff > 3.0:
+        self._draw_lead(lead_two, lead_vehicles[1], v_ego, rect)

selfdrive/ui/sunnypilot/onroad/model_renderer.py

@@ -0,0 +1,14 @@
+"""
+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.selfdrive.ui.sunnypilot.onroad.chevron_metrics import ChevronMetrics
+from openpilot.selfdrive.ui.sunnypilot.onroad.rainbow_path import RainbowPath
+
+
+class ModelRendererSP:
+  def __init__(self):
+    self.rainbow_path = RainbowPath()
+    self.chevron_metrics = ChevronMetrics()

selfdrive/ui/sunnypilot/onroad/rainbow_path.py

@@ -0,0 +1,78 @@
+"""
+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 colorsys
+import pyray as rl
+from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
+
+
+class RainbowPath:
+  DEFAULT_NUM_SEGMENTS = 8
+  DEFAULT_SPEED = 50.0  # degrees per second
+  DEFAULT_SATURATION = 0.9
+  DEFAULT_LIGHTNESS = 0.6
+  BASE_ALPHA = 0.8
+  ALPHA_FADE = 0.3  # Alpha reduction from bottom to top
+
+  def __init__(self, num_segments: int = None, speed: float = None, saturation: float = None, lightness: float = None):
+    self.num_segments = num_segments if num_segments is not None else self.DEFAULT_NUM_SEGMENTS
+    self.speed = speed if speed is not None else self.DEFAULT_SPEED
+    self.saturation = saturation if saturation is not None else self.DEFAULT_SATURATION
+    self.lightness = lightness if lightness is not None else self.DEFAULT_LIGHTNESS
+
+  def set_speed(self, speed: float):
+    self.speed = speed
+
+  def set_num_segments(self, num_segments: int):
+    self.num_segments = num_segments
+
+  def set_saturation(self, saturation: float):
+    self.saturation = max(0.0, min(1.0, saturation))
+
+  def set_lightness(self, lightness: float):
+    self.lightness = max(0.0, min(1.0, lightness))
+
+  def get_gradient(self) -> Gradient:
+    time_offset = time.monotonic()
+    hue_offset = (time_offset * self.speed) % 360.0
+
+    segment_colors = []
+    gradient_stops = []
+
+    for i in range(self.num_segments):
+      position = i / (self.num_segments - 1)
+      hue = (hue_offset + position * 360.0) % 360.0
+      alpha = self.BASE_ALPHA * (1.0 - position * self.ALPHA_FADE)
+      color = self._hsla_to_color(
+        hue / 360.0,
+        self.saturation,
+        self.lightness,
+        alpha
+      )
+      gradient_stops.append(position)
+      segment_colors.append(color)
+
+    return Gradient(
+      start=(0.0, 1.0),  # Bottom of path
+      end=(0.0, 0.0),  # Top of path
+      colors=segment_colors,
+      stops=gradient_stops,
+    )
+
+  @staticmethod
+  def _hsla_to_color(h: float, s: float, l: float, a: float) -> rl.Color:
+    rgb = colorsys.hls_to_rgb(h, l, s)
+    return rl.Color(
+      int(rgb[0] * 255),
+      int(rgb[1] * 255),
+      int(rgb[2] * 255),
+      int(a * 255)
+    )
+
+  def draw_rainbow_path(self, rect, path):
+    gradient = self.get_gradient()
+    draw_polygon(rect, path.projected_points, gradient=gradient)

selfdrive/ui/sunnypilot/ui_state.py

@@ -4,10 +4,13 @@ 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 cereal import messaging, custom
+from cereal import messaging, log, custom
 from openpilot.common.params import Params
 from openpilot.sunnypilot.sunnylink.sunnylink_state import SunnylinkState
 
+OpenpilotState = log.SelfdriveState.OpenpilotState
+MADSState = custom.ModularAssistiveDrivingSystem.ModularAssistiveDrivingSystemState
+
 
 class UIStateSP:
   def __init__(self):
@@ -22,9 +25,48 @@ class UIStateSP:
   def update(self) -> None:
     self.sunnylink_state.start()
 
+  @staticmethod
+  def update_status(ss, ss_sp, onroad_evt) -> str:
+    state = ss.state
+    mads = ss_sp.mads
+    mads_state = mads.state
+
+    if state == OpenpilotState.preEnabled:
+      return "override"
+
+    if state == OpenpilotState.overriding:
+      if not mads.available:
+        return "override"
+
+      if any(e.overrideLongitudinal for e in onroad_evt):
+        return "override"
+
+    if mads_state in (MADSState.paused, MADSState.overriding):
+      return "override"
+
+    # MADS specific statuses
+    if not mads.available:
+      return "engaged" if ss.enabled else "disengaged"
+
+    if not mads.enabled and not ss.enabled:
+      return "disengaged"
+
+    if mads.enabled and ss.enabled:
+      return "engaged"
+
+    if mads.enabled:
+      return "lat_only"
+
+    if ss.enabled:
+      return "long_only"
+
+    return "disengaged"
+
   def update_params(self) -> None:
     CP_SP_bytes = self.params.get("CarParamsSPPersistent")
     if CP_SP_bytes is not None:
       self.CP_SP = messaging.log_from_bytes(CP_SP_bytes, custom.CarParamsSP)
     self.sunnylink_enabled = self.params.get_bool("SunnylinkEnabled")
     self.developer_ui = self.params.get("DevUIInfo")
+    self.rainbow_path = self.params.get_bool("RainbowMode")
+    self.chevron_metrics = self.params.get("ChevronInfo")

selfdrive/ui/tests/test_ui/run.py

@@ -1,310 +0,0 @@
-#!/usr/bin/env python3
-import capnp
-import pathlib
-import shutil
-import sys
-import os
-import pywinctl
-import pyautogui
-import pickle
-import time
-from collections import namedtuple
-
-from cereal import car, log
-from msgq.visionipc import VisionIpcServer, VisionStreamType
-from cereal.messaging import PubMaster, log_from_bytes, sub_sock
-from openpilot.common.basedir import BASEDIR
-from openpilot.common.params import Params
-from openpilot.common.prefix import OpenpilotPrefix
-from openpilot.common.transformations.camera import CameraConfig, DEVICE_CAMERAS
-from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
-from openpilot.selfdrive.test.helpers import with_processes
-from openpilot.selfdrive.test.process_replay.migration import migrate, migrate_controlsState, migrate_carState
-from openpilot.tools.lib.logreader import LogReader
-from openpilot.tools.lib.framereader import FrameReader
-from openpilot.tools.lib.route import Route
-from openpilot.tools.lib.cache import DEFAULT_CACHE_DIR
-
-UI_DELAY = 0.1 # may be slower on CI?
-TEST_ROUTE = "a2a0ccea32023010|2023-07-27--13-01-19"
-
-STREAMS: list[tuple[VisionStreamType, CameraConfig, bytes]] = []
-OFFROAD_ALERTS = ['Offroad_StorageMissing', 'Offroad_IsTakingSnapshot']
-DATA: dict[str, capnp.lib.capnp._DynamicStructBuilder] = dict.fromkeys(
-  ["carParams", "deviceState", "pandaStates", "controlsState", "selfdriveState",
-  "liveCalibration", "modelV2", "radarState", "driverMonitoringState", "carState",
-  "driverStateV2", "roadCameraState", "wideRoadCameraState", "driverCameraState"], None)
-
-def setup_homescreen(click, pm: PubMaster):
-  pass
-
-def setup_settings_device(click, pm: PubMaster):
-  click(100, 100)
-
-def setup_settings_toggles(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(278, 600)
-  time.sleep(UI_DELAY)
-
-def setup_settings_software(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(278, 720)
-  time.sleep(UI_DELAY)
-
-def setup_settings_firehose(click, pm: PubMaster):
-  click(1780, 730)
-
-def setup_settings_developer(click, pm: PubMaster):
-  CP = car.CarParams()
-  CP.alphaLongitudinalAvailable = True
-  Params().put("CarParamsPersistent", CP.to_bytes())
-
-  setup_settings_device(click, pm)
-  click(278, 970)
-  time.sleep(UI_DELAY)
-
-def setup_onroad(click, pm: PubMaster):
-  vipc_server = VisionIpcServer("camerad")
-  for stream_type, cam, _ in STREAMS:
-    vipc_server.create_buffers(stream_type, 5, cam.width, cam.height)
-  vipc_server.start_listener()
-
-  uidebug_received_cnt = 0
-  packet_id = 0
-  uidebug_sock = sub_sock('uiDebug')
-
-  # Condition check for uiDebug processing
-  check_uidebug = DATA['deviceState'].deviceState.started and not DATA['carParams'].carParams.notCar
-
-  # Loop until 20 'uiDebug' messages are received
-  while uidebug_received_cnt <= 20:
-    for service, data in DATA.items():
-      if data:
-        data.clear_write_flag()
-        pm.send(service, data)
-
-    for stream_type, _, image in STREAMS:
-      vipc_server.send(stream_type, image, packet_id, packet_id, packet_id)
-
-    if check_uidebug:
-      while uidebug_sock.receive(non_blocking=True):
-        uidebug_received_cnt += 1
-    else:
-      uidebug_received_cnt += 1
-
-    packet_id += 1
-    time.sleep(0.05)
-
-def setup_onroad_disengaged(click, pm: PubMaster):
-  DATA['selfdriveState'].selfdriveState.enabled = False
-  setup_onroad(click, pm)
-  DATA['selfdriveState'].selfdriveState.enabled = True
-
-def setup_onroad_override(click, pm: PubMaster):
-  DATA['selfdriveState'].selfdriveState.state = log.SelfdriveState.OpenpilotState.overriding
-  setup_onroad(click, pm)
-  DATA['selfdriveState'].selfdriveState.state = log.SelfdriveState.OpenpilotState.enabled
-
-
-def setup_onroad_wide(click, pm: PubMaster):
-  DATA['selfdriveState'].selfdriveState.experimentalMode = True
-  DATA["carState"].carState.vEgo = 1
-  setup_onroad(click, pm)
-
-def setup_onroad_sidebar(click, pm: PubMaster):
-  setup_onroad(click, pm)
-  click(500, 500)
-  setup_onroad(click, pm)
-
-def setup_onroad_wide_sidebar(click, pm: PubMaster):
-  setup_onroad_wide(click, pm)
-  click(500, 500)
-  setup_onroad_wide(click, pm)
-
-def setup_body(click, pm: PubMaster):
-  DATA['carParams'].carParams.brand = "body"
-  DATA['carParams'].carParams.notCar = True
-  DATA['carState'].carState.charging = True
-  DATA['carState'].carState.fuelGauge = 50.0
-  setup_onroad(click, pm)
-
-def setup_keyboard(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(250, 965)
-  click(1930, 420)
-
-def setup_keyboard_uppercase(click, pm: PubMaster):
-  setup_keyboard(click, pm)
-  click(200, 800)
-
-def setup_driver_camera(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(1950, 435)
-  DATA['deviceState'].deviceState.started = False
-  setup_onroad(click, pm)
-  DATA['deviceState'].deviceState.started = True
-
-def setup_onroad_alert(click, pm: PubMaster, text1, text2, size, status=log.SelfdriveState.AlertStatus.normal):
-  print(f'setup onroad alert, size: {size}')
-  state = DATA['selfdriveState']
-  origin_state_bytes = state.to_bytes()
-  cs = state.selfdriveState
-  cs.alertText1 = text1
-  cs.alertText2 = text2
-  cs.alertSize = size
-  cs.alertStatus = status
-  cs.alertType = "test_onroad_alert"
-  setup_onroad(click, pm)
-  DATA['selfdriveState'] = log_from_bytes(origin_state_bytes).as_builder()
-
-def setup_onroad_alert_small(click, pm: PubMaster):
-  setup_onroad_alert(click, pm, 'This is a small alert message', '', log.SelfdriveState.AlertSize.small)
-
-def setup_onroad_alert_mid(click, pm: PubMaster):
-  setup_onroad_alert(click, pm, 'Medium Alert', 'This is a medium alert message', log.SelfdriveState.AlertSize.mid)
-
-def setup_onroad_alert_full(click, pm: PubMaster):
-  setup_onroad_alert(click, pm, 'Full Alert', 'This is a full alert message', log.SelfdriveState.AlertSize.full)
-
-def setup_offroad_alert(click, pm: PubMaster):
-  for alert in OFFROAD_ALERTS:
-    set_offroad_alert(alert, True)
-
-  # Toggle between settings and home to refresh the offroad alert widget
-  setup_settings_device(click, pm)
-  click(240, 216)
-
-def setup_update_available(click, pm: PubMaster):
-  Params().put_bool("UpdateAvailable", True)
-  release_notes_path = os.path.join(BASEDIR, "RELEASES.md")
-  with open(release_notes_path) as file:
-    release_notes = file.read().split('\n\n', 1)[0]
-  Params().put("UpdaterNewReleaseNotes", release_notes + "\n")
-
-  setup_settings_device(click, pm)
-  click(240, 216)
-
-def setup_pair_device(click, pm: PubMaster):
-  click(1950, 435)
-  click(1800, 900)
-
-CASES = {
-  "homescreen": setup_homescreen,
-  "prime": setup_homescreen,
-  "pair_device": setup_pair_device,
-  "settings_device": setup_settings_device,
-  "settings_toggles": setup_settings_toggles,
-  "settings_software": setup_settings_software,
-  "settings_firehose": setup_settings_firehose,
-  "settings_developer": setup_settings_developer,
-  "onroad": setup_onroad,
-  "onroad_disengaged": setup_onroad_disengaged,
-  "onroad_override": setup_onroad_override,
-  "onroad_sidebar": setup_onroad_sidebar,
-  "onroad_alert_small": setup_onroad_alert_small,
-  "onroad_alert_mid": setup_onroad_alert_mid,
-  "onroad_alert_full": setup_onroad_alert_full,
-  "onroad_wide": setup_onroad_wide,
-  "onroad_wide_sidebar": setup_onroad_wide_sidebar,
-  "driver_camera": setup_driver_camera,
-  "body": setup_body,
-  "offroad_alert": setup_offroad_alert,
-  "update_available": setup_update_available,
-  "keyboard": setup_keyboard,
-  "keyboard_uppercase": setup_keyboard_uppercase
-}
-
-TEST_DIR = pathlib.Path(__file__).parent
-
-TEST_OUTPUT_DIR = TEST_DIR / "report_1"
-SCREENSHOTS_DIR = TEST_OUTPUT_DIR / "screenshots"
-
-
-class TestUI:
-  def __init__(self):
-    os.environ["SCALE"] = "1"
-    sys.modules["mouseinfo"] = False
-
-  def setup(self):
-    self.pm = PubMaster(list(DATA.keys()))
-    DATA['deviceState'].deviceState.networkType = log.DeviceState.NetworkType.wifi
-    DATA['deviceState'].deviceState.lastAthenaPingTime = 0
-    for _ in range(10):
-      self.pm.send('deviceState', DATA['deviceState'])
-      DATA['deviceState'].clear_write_flag()
-      time.sleep(0.05)
-    try:
-      self.ui = pywinctl.getWindowsWithTitle("ui")[0]
-    except Exception as e:
-      print(f"failed to find ui window, assuming that it's in the top left (for Xvfb) {e}")
-      self.ui = namedtuple("bb", ["left", "top", "width", "height"])(0,0,2160,1080)
-
-  def screenshot(self, name):
-    im = pyautogui.screenshot(SCREENSHOTS_DIR / f"{name}.png", region=(self.ui.left, self.ui.top, self.ui.width, self.ui.height))
-    assert im.width == 2160
-    assert im.height == 1080
-
-  def click(self, x, y, *args, **kwargs):
-    pyautogui.click(self.ui.left + x, self.ui.top + y, *args, **kwargs)
-    time.sleep(UI_DELAY) # give enough time for the UI to react
-
-  @with_processes(["ui"])
-  def test_ui(self, name, setup_case):
-    self.setup()
-    setup_case(self.click, self.pm)
-    self.screenshot(name)
-
-def create_screenshots():
-  if TEST_OUTPUT_DIR.exists():
-    shutil.rmtree(TEST_OUTPUT_DIR)
-
-  SCREENSHOTS_DIR.mkdir(parents=True)
-
-  route = Route(TEST_ROUTE)
-
-  segnum = 2
-  lr = LogReader(route.qlog_paths()[segnum])
-  DATA['carParams'] = next((event.as_builder() for event in lr if event.which() == 'carParams'), None)
-  for event in migrate(lr, [migrate_controlsState, migrate_carState]):
-    if event.which() in DATA:
-      DATA[event.which()] = event.as_builder()
-
-    if all(DATA.values()):
-      break
-
-  cam = DEVICE_CAMERAS[("tici", "ar0231")]
-
-  frames_cache = f'{DEFAULT_CACHE_DIR}/ui_frames'
-  if os.path.isfile(frames_cache):
-    with open(frames_cache, 'rb') as f:
-      frames = pickle.load(f)
-      road_img = frames[0]
-      wide_road_img = frames[1]
-      driver_img = frames[2]
-  else:
-    with open(frames_cache, 'wb') as f:
-      road_img = FrameReader(route.camera_paths()[segnum], pix_fmt="nv12").get(0)
-      wide_road_img = FrameReader(route.ecamera_paths()[segnum], pix_fmt="nv12").get(0)
-      driver_img = FrameReader(route.dcamera_paths()[segnum], pix_fmt="nv12").get(0)
-      pickle.dump([road_img, wide_road_img, driver_img], f)
-
-  STREAMS.append((VisionStreamType.VISION_STREAM_ROAD, cam.fcam, road_img.flatten().tobytes()))
-  STREAMS.append((VisionStreamType.VISION_STREAM_WIDE_ROAD, cam.ecam, wide_road_img.flatten().tobytes()))
-  STREAMS.append((VisionStreamType.VISION_STREAM_DRIVER, cam.dcam, driver_img.flatten().tobytes()))
-
-  t = TestUI()
-
-  for name, setup in CASES.items():
-    with OpenpilotPrefix():
-      params = Params()
-      params.put("DongleId", "123456789012345")
-      if name == 'prime':
-        params.put('PrimeType', 1)
-      elif name == 'pair_device':
-        params.put('ApiCache_Device', {"is_paired":0, "prime_type":-1})
-
-      t.test_ui(name, setup)
-
-if __name__ == "__main__":
-  print("creating test screenshots")
-  create_screenshots()

selfdrive/ui/ui_state.py

@@ -21,6 +21,8 @@ class UIStatus(Enum):
   DISENGAGED = "disengaged"
   ENGAGED = "engaged"
   OVERRIDE = "override"
+  LAT_ONLY = "lat_only"
+  LONG_ONLY = "long_only"
 
 
 class UIState(UIStateSP):
@@ -98,7 +100,7 @@ class UIState(UIStateSP):
 
   @property
   def engaged(self) -> bool:
-    return self.started and self.sm["selfdriveState"].enabled
+    return self.started and (self.sm["selfdriveState"].enabled or self.sm["selfdriveStateSP"].mads.enabled)
 
   def is_onroad(self) -> bool:
     return self.started
@@ -133,10 +135,7 @@ class UIState(UIStateSP):
     # Handle wide road camera state updates
     if self.sm.updated["wideRoadCameraState"]:
       cam_state = self.sm["wideRoadCameraState"]
-
-      # Scale factor based on sensor type
-      scale = 6.0 if cam_state.sensor == 'ar0231' else 1.0
-      self.light_sensor = max(100.0 - scale * cam_state.exposureValPercent, 0.0)
+      self.light_sensor = max(100.0 - cam_state.exposureValPercent, 0.0)
     elif not self.sm.alive["wideRoadCameraState"] or not self.sm.valid["wideRoadCameraState"]:
       self.light_sensor = -1
 
@@ -159,6 +158,8 @@ class UIState(UIStateSP):
       else:
         self.status = UIStatus.ENGAGED if ss.enabled else UIStatus.DISENGAGED
 
+      self.status = UIStatus(UIStateSP.update_status(ss, self.sm["selfdriveStateSP"], self.sm["onroadEvents"]))
+
     # Check for engagement state changes
     if self.engaged != self._engaged_prev:
       for callback in self._engaged_transition_callbacks:

sunnypilot/selfdrive/car/interfaces.py

@@ -114,7 +114,7 @@ def initialize_params(params) -> list[dict[str, Any]]:
 
   # hyundai
   keys.extend([
-    "HyundaiLongitudinalTuning"
+    "HyundaiLongitudinalTuning",
   ])
 
   # subaru
@@ -128,4 +128,9 @@ def initialize_params(params) -> list[dict[str, Any]]:
     "TeslaCoopSteering",
   ])
 
+  # toyota
+  keys.extend([
+    "ToyotaEnforceStockLongitudinal",
+  ])
+
   return [{k: params.get(k, return_default=True)} for k in keys]

sunnypilot/sunnylink/athena/sunnylinkd.py

@@ -42,6 +42,12 @@ METADATA_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__f
 
 params = Params()
 
+# Parameters that should never be remotely modified for security reasons
+BLOCKED_PARAMS = {
+  "GithubUsername",  # Could grant SSH access
+  "GithubSshKeys",   # Direct SSH key injection
+}
+
 
 def handle_long_poll(ws: WebSocket, exit_event: threading.Event | None) -> None:
   cloudlog.info("sunnylinkd.handle_long_poll started")
@@ -248,6 +254,11 @@ def getParams(params_keys: list[str], compression: bool = False) -> str | dict[s
 @dispatcher.add_method
 def saveParams(params_to_update: dict[str, str], compression: bool = False) -> None:
   for key, value in params_to_update.items():
+    # disallow modifications to blocked parameters
+    if key in BLOCKED_PARAMS:
+      cloudlog.warning(f"sunnylinkd.saveParams.blocked: Attempted to modify blocked parameter '{key}'")
+      continue
+
     try:
       save_param_from_base64_encoded_string(key, value, compression)
     except Exception as e:

sunnypilot/sunnylink/athena/tests/test_sunnylinkd.py

@@ -0,0 +1,59 @@
+"""
+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.sunnypilot.sunnylink.athena import sunnylinkd
+
+
+class TestSunnylinkdMethods:
+  def setup_method(self):
+    self.saved_params = []
+
+    self.original_save = sunnylinkd.save_param_from_base64_encoded_string
+
+    def mock_save_param(key, value, compression=False):
+      self.saved_params.append((key, value, compression))
+
+    sunnylinkd.save_param_from_base64_encoded_string = mock_save_param
+
+  def teardown_method(self):
+    sunnylinkd.save_param_from_base64_encoded_string = self.original_save
+
+  def test_saveParams_blocked(self):
+    blocked_params = {
+      "GithubUsername": "attacker",
+      "GithubSshKeys": "ssh-rsa attacker_key",
+    }
+
+    sunnylinkd.saveParams(blocked_params)
+
+    assert len(self.saved_params) == 0
+
+  def test_saveParams_allowed(self):
+    allowed_params = {
+      "SpeedLimitOffset": "5",
+      "MyCustomParam": "123"
+    }
+
+    sunnylinkd.saveParams(allowed_params)
+
+    # verify content
+    assert len(self.saved_params) == 2
+    keys_saved = [p[0] for p in self.saved_params]
+    assert "SpeedLimitOffset" in keys_saved
+    assert "MyCustomParam" in keys_saved
+
+  def test_saveParams_mixed(self):
+    mixed_params = {
+      "GithubUsername": "attacker",
+      "SpeedLimitOffset": "10"
+    }
+
+    sunnylinkd.saveParams(mixed_params)
+
+    # should save allowed one
+    assert len(self.saved_params) == 1
+    assert self.saved_params[0][0] == "SpeedLimitOffset"
+    assert self.saved_params[0][1] == "10"

sunnypilot/sunnylink/backups/manager.py

@@ -19,7 +19,7 @@ from openpilot.system.version import get_version
 
 from cereal import messaging, custom
 from openpilot.sunnypilot.sunnylink.api import SunnylinkApi
-from openpilot.sunnypilot.sunnylink.backups.utils import decrypt_compressed_data, encrypt_compress_data, SnakeCaseEncoder
+from openpilot.sunnypilot.sunnylink.backups.utils import decrypt_compressed_data, encrypt_compressed_data, SnakeCaseEncoder
 from openpilot.sunnypilot.sunnylink.utils import get_param_as_byte, save_param_from_base64_encoded_string
 
 
@@ -95,7 +95,7 @@ class BackupManagerSP:
 
       # Serialize and encrypt config data
       config_json = json.dumps(config_data)
-      encrypted_config = encrypt_compress_data(config_json, use_aes_256=True)
+      encrypted_config = encrypt_compressed_data(config_json, use_aes_256=True)
       self._update_progress(50.0, OperationType.BACKUP)
 
       backup_info = custom.BackupManagerSP.BackupInfo()

sunnypilot/sunnylink/backups/utils.py

@@ -4,9 +4,9 @@ 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 base64
 import hashlib
+import os
 import zlib
 import re
 import json
@@ -14,8 +14,9 @@ from pathlib import Path
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives.asymmetric import rsa, ec
 
+from openpilot.common.api.base import KEYS
 from openpilot.sunnypilot.sunnylink.backups.AESCipher import AESCipher
 from openpilot.system.hardware.hw import Paths
 
@@ -27,37 +28,43 @@ class KeyDerivation:
       return f.read()
 
   @staticmethod
-  def derive_aes_key_iv_from_rsa(key_path: str, use_aes_256: bool) -> tuple[bytes, bytes]:
-    rsa_key_pem: bytes = KeyDerivation._load_key(key_path)
-    key_plain = rsa_key_pem.decode(errors="ignore")
+  def derive_aes_key_iv(key_path: str, use_aes_256: bool) -> tuple[bytes, bytes]:
+    key_pem: bytes = KeyDerivation._load_key(key_path)
+    key_plain = key_pem.decode(errors="ignore")
 
     if "private" in key_plain.lower():
-      private_key = serialization.load_pem_private_key(rsa_key_pem, password=None, backend=default_backend())
-      if not isinstance(private_key, rsa.RSAPrivateKey):
-        raise ValueError("Invalid RSA key format: Unable to determine if key is public or private.")
-
-      der_data = private_key.private_bytes(
-        encoding=serialization.Encoding.DER,
-        format=serialization.PrivateFormat.TraditionalOpenSSL,
-        encryption_algorithm=serialization.NoEncryption()
-      )
+      private_key = serialization.load_pem_private_key(key_pem, password=None, backend=default_backend())
+      if isinstance(private_key, (rsa.RSAPrivateKey, ec.EllipticCurvePrivateKey)):
+        public_key = private_key.public_key()
+      else:
+        raise ValueError("Invalid key format: Unable to determine if key is public or private.")
     elif "public" in key_plain.lower():
-      public_key = serialization.load_pem_public_key(rsa_key_pem, backend=default_backend())
-      if not isinstance(public_key, rsa.RSAPublicKey):
-        raise ValueError("Invalid RSA key format: Unable to determine if key is public or private.")
-
-      der_data = public_key.public_bytes(encoding=serialization.Encoding.DER, format=serialization.PublicFormat.PKCS1)
+      public_key = serialization.load_pem_public_key(key_pem, backend=default_backend())  # type: ignore[assignment]
+      if not isinstance(public_key, (rsa.RSAPublicKey, ec.EllipticCurvePublicKey)):
+        raise ValueError("Invalid key format: Unable to determine if key is public or private.")
     else:
-      raise ValueError("Unknown key format: Unable to determine if key is public or private.")
+      raise ValueError("Invalid key format: Unable to determine if key is public or private.")
 
-    sha256_hash = hashlib.sha256(der_data).digest()
-    aes_key = sha256_hash[:32] if use_aes_256 else sha256_hash[:16]
-    aes_iv = sha256_hash[16:32]
+    if isinstance(public_key, rsa.RSAPublicKey):
+      der_data = public_key.public_bytes(encoding=serialization.Encoding.DER, format=serialization.PublicFormat.PKCS1)
+    elif isinstance(public_key, ec.EllipticCurvePublicKey):
+      der_data = public_key.public_bytes(encoding=serialization.Encoding.DER, format=serialization.PublicFormat.SubjectPublicKeyInfo)
+    else:
+      raise ValueError("Unsupported key type.")
 
-    return aes_key, aes_iv
+    if use_aes_256:
+      # AES-256-CBC
+      key = hashlib.sha256(der_data).digest()
+      iv = hashlib.md5(der_data).digest()
+    else:
+      # AES-128-CBC
+      key = hashlib.md5(der_data).digest()
+      iv = hashlib.md5(der_data).digest()  # Insecure IV reuse, kept for compatibility
+
+    return key, iv
 
 
-def qUncompress(data):
+def uncompress_dat(data):
   """
   Decompress data using zlib.
 
@@ -71,7 +78,7 @@ def qUncompress(data):
   return zlib.decompress(data_stripped_4)
 
 
-def qCompress(data):
+def compress_dat(data):
   """
   Compress data using zlib.
 
@@ -85,6 +92,19 @@ def qCompress(data):
   return b"ZLIB" + compressed_data
 
 
+def get_key_path(use_aes_256=False) -> str:
+  key_path = ""
+  for key in KEYS:
+    if os.path.isfile(Paths.persist_root() + f'/comma/{key}') and os.path.isfile(Paths.persist_root() + f'/comma/{key}.pub'):
+      key_path = str(Path(Paths.persist_root() + f'/comma/{key}') if use_aes_256 else Path(Paths.persist_root() + f'/comma/{key}.pub'))
+      break
+
+  if not key_path:
+    raise FileNotFoundError("No valid key pair found in persist storage.")
+
+  return key_path
+
+
 def decrypt_compressed_data(encrypted_base64, use_aes_256=False):
   """
   Decrypt and decompress data from base64 string.
@@ -96,18 +116,17 @@ def decrypt_compressed_data(encrypted_base64, use_aes_256=False):
   Returns:
       str: Decrypted and decompressed string
   """
-  key_path = Path(f"{Paths.persist_root()}/comma/id_rsa") if use_aes_256 else Path(f"{Paths.persist_root()}/comma/id_rsa.pub")
   try:
     # Decode base64
     encrypted_data = base64.b64decode(encrypted_base64)
 
     # Decrypt
-    key, iv = KeyDerivation.derive_aes_key_iv_from_rsa(str(key_path), use_aes_256)
+    key, iv = KeyDerivation.derive_aes_key_iv(get_key_path(use_aes_256), use_aes_256)
     cipher = AESCipher(key, iv)
     decrypted_data = cipher.decrypt(encrypted_data)
 
     # Decompress
-    decompressed_data = qUncompress(decrypted_data)
+    decompressed_data = uncompress_dat(decrypted_data)
 
     # Decode UTF-8
     result = decompressed_data.decode('utf-8')
@@ -117,7 +136,7 @@ def decrypt_compressed_data(encrypted_base64, use_aes_256=False):
     return ""
 
 
-def encrypt_compress_data(text, use_aes_256=True):
+def encrypt_compressed_data(text, use_aes_256=True):
   """
   Compress and encrypt string data to base64.
 
@@ -128,16 +147,15 @@ def encrypt_compress_data(text, use_aes_256=True):
   Returns:
       str: Base64 encoded encrypted data
   """
-  key_path = Path(f"{Paths.persist_root()}/comma/id_rsa") if use_aes_256 else Path(f"{Paths.persist_root()}/comma/id_rsa.pub")
   try:
     # Encode to UTF-8
     text_bytes = text.encode('utf-8')
 
     # Compress
-    compressed_data = qCompress(text_bytes)
+    compressed_data = compress_dat(text_bytes)
 
     # Encrypt
-    key, iv = KeyDerivation.derive_aes_key_iv_from_rsa(str(key_path), use_aes_256)
+    key, iv = KeyDerivation.derive_aes_key_iv(get_key_path(use_aes_256), use_aes_256)
     cipher = AESCipher(key, iv)
     encrypted_data = cipher.encrypt(compressed_data)
 

sunnypilot/sunnylink/params_metadata.json

@@ -1037,6 +1037,10 @@
     "max": 5.0,
     "step": 0.1
   },
+  "ToyotaEnforceStockLongitudinal": {
+    "title": "Toyota: Enforce Factory Longitudinal Control",
+    "description": "When enabled, sunnypilot will not take over control of gas and brakes. Factory Toyota longitudinal control will be used."
+  },
   "TrainingVersion": {
     "title": "Training Version",
     "description": ""

system/camerad/SConscript

@@ -4,7 +4,7 @@ libs = [common, 'OpenCL', messaging, visionipc]
 
 if arch != "Darwin":
   camera_obj = env.Object(['cameras/camera_qcom2.cc', 'cameras/camera_common.cc', 'cameras/spectra.cc',
-                           'cameras/cdm.cc', 'sensors/ar0231.cc', 'sensors/ox03c10.cc', 'sensors/os04c10.cc'])
+                           'cameras/cdm.cc', 'sensors/ox03c10.cc', 'sensors/os04c10.cc'])
   env.Program('camerad', ['main.cc', camera_obj], LIBS=libs)
 
 if GetOption("extras") and arch == "x86_64":

system/camerad/cameras/hw.h

@@ -13,7 +13,7 @@ typedef enum {
   ISP_BPS_PROCESSED,  // fully processed image through the BPS
 } SpectraOutputType;
 
-// For the comma 3/3X three camera platform
+// For the comma 3X three camera platform
 
 struct CameraConfig {
   int camera_num;

system/camerad/cameras/spectra.cc

@@ -1004,9 +1004,8 @@ bool SpectraCamera::openSensor() {
   };
 
   // Figure out which sensor we have
-  if (!init_sensor_lambda(new AR0231) &&
-      !init_sensor_lambda(new OX03C10) &&
-      !init_sensor_lambda(new OS04C10)) {
+  if (!init_sensor_lambda(new OS04C10) &&
+      !init_sensor_lambda(new OX03C10)) {
     LOGE("** sensor %d FAILED bringup, disabling", cc.camera_num);
     enabled = false;
     return false;

system/camerad/sensors/ar0231.cc

@@ -1,136 +0,0 @@
-#include <cassert>
-#include <cmath>
-
-#include "system/camerad/sensors/sensor.h"
-
-namespace {
-
-const size_t AR0231_REGISTERS_HEIGHT = 2;
-// TODO: this extra height is universal and doesn't apply per camera
-const size_t AR0231_STATS_HEIGHT = 2 + 8;
-
-const float sensor_analog_gains_AR0231[] = {
-    1.0 / 8.0, 2.0 / 8.0, 2.0 / 7.0, 3.0 / 7.0,  // 0, 1, 2, 3
-    3.0 / 6.0, 4.0 / 6.0, 4.0 / 5.0, 5.0 / 5.0,  // 4, 5, 6, 7
-    5.0 / 4.0, 6.0 / 4.0, 6.0 / 3.0, 7.0 / 3.0,  // 8, 9, 10, 11
-    7.0 / 2.0, 8.0 / 2.0, 8.0 / 1.0};            // 12, 13, 14, 15 = bypass
-
-}  // namespace
-
-AR0231::AR0231() {
-  image_sensor = cereal::FrameData::ImageSensor::AR0231;
-  bayer_pattern = CAM_ISP_PATTERN_BAYER_GRGRGR;
-  pixel_size_mm = 0.003;
-  data_word = true;
-  frame_width = 1928;
-  frame_height = 1208;
-  frame_stride = (frame_width * 12 / 8) + 4;
-  extra_height = AR0231_REGISTERS_HEIGHT + AR0231_STATS_HEIGHT;
-
-  registers_offset = 0;
-  frame_offset = AR0231_REGISTERS_HEIGHT;
-  stats_offset = AR0231_REGISTERS_HEIGHT + frame_height;
-
-  start_reg_array.assign(std::begin(start_reg_array_ar0231), std::end(start_reg_array_ar0231));
-  init_reg_array.assign(std::begin(init_array_ar0231), std::end(init_array_ar0231));
-  probe_reg_addr = 0x3000;
-  probe_expected_data = 0x354;
-  bits_per_pixel = 12;
-  mipi_format = CAM_FORMAT_MIPI_RAW_12;
-  frame_data_type = 0x12;  // Changing stats to 0x2C doesn't work, so change pixels to 0x12 instead
-  mclk_frequency = 19200000; //Hz
-
-  readout_time_ns = 22850000;
-
-  dc_gain_factor = 2.5;
-  dc_gain_min_weight = 0;
-  dc_gain_max_weight = 1;
-  dc_gain_on_grey = 0.2;
-  dc_gain_off_grey = 0.3;
-  exposure_time_min = 2;       // with HDR, fastest ss
-  exposure_time_max = 0x0855;  // with HDR, slowest ss, 40ms
-  analog_gain_min_idx = 0x1;   // 0.25x
-  analog_gain_rec_idx = 0x6;   // 0.8x
-  analog_gain_max_idx = 0xD;   // 4.0x
-  analog_gain_cost_delta = 0;
-  analog_gain_cost_low = 0.1;
-  analog_gain_cost_high = 5.0;
-  for (int i = 0; i <= analog_gain_max_idx; i++) {
-    sensor_analog_gains[i] = sensor_analog_gains_AR0231[i];
-  }
-  min_ev = exposure_time_min * sensor_analog_gains[analog_gain_min_idx];
-  max_ev = exposure_time_max * dc_gain_factor * sensor_analog_gains[analog_gain_max_idx];
-  target_grey_factor = 1.0;
-
-  black_level = 168;
-  color_correct_matrix = {
-    0x000000af, 0x00000ff9, 0x00000fd8,
-    0x00000fbc, 0x000000bb, 0x00000009,
-    0x00000fb6, 0x00000fe0, 0x000000ea,
-  };
-  for (int i = 0; i < 65; i++) {
-    float fx = i / 64.0;
-    const float gamma_k = 0.75;
-    const float gamma_b = 0.125;
-    const float mp = 0.01; // ideally midpoint should be adaptive
-    const float rk = 9 - 100*mp;
-    // poly approximation for s curve
-    fx = (fx > mp) ?
-      ((rk * (fx-mp) * (1-(gamma_k*mp+gamma_b)) * (1+1/(rk*(1-mp))) / (1+rk*(fx-mp))) + gamma_k*mp + gamma_b) :
-      ((rk * (fx-mp) * (gamma_k*mp+gamma_b) * (1+1/(rk*mp)) / (1-rk*(fx-mp))) + gamma_k*mp + gamma_b);
-    gamma_lut_rgb.push_back((uint32_t)(fx*1023.0 + 0.5));
-  }
-  prepare_gamma_lut();
-  linearization_lut = {
-    0x02000000, 0x02000000, 0x02000000, 0x02000000,
-    0x020007ff, 0x020007ff, 0x020007ff, 0x020007ff,
-    0x02000bff, 0x02000bff, 0x02000bff, 0x02000bff,
-    0x020017ff, 0x020017ff, 0x020017ff, 0x020017ff,
-    0x02001bff, 0x02001bff, 0x02001bff, 0x02001bff,
-    0x020023ff, 0x020023ff, 0x020023ff, 0x020023ff,
-    0x00003fff, 0x00003fff, 0x00003fff, 0x00003fff,
-    0x00003fff, 0x00003fff, 0x00003fff, 0x00003fff,
-    0x00003fff, 0x00003fff, 0x00003fff, 0x00003fff,
-  };
-  linearization_pts = {0x07ff0bff, 0x17ff1bff, 0x23ff3fff, 0x3fff3fff};
-  vignetting_lut = {
-    0x00eaa755, 0x00cf2679, 0x00bc05e0, 0x00acc566, 0x00a1450a, 0x009984cc, 0x0095a4ad, 0x009584ac, 0x009944ca, 0x00a0c506, 0x00ac0560, 0x00bb25d9, 0x00ce2671, 0x00e90748, 0x01112889, 0x014a2a51, 0x01984cc2,
-    0x00db06d8, 0x00c30618, 0x00afe57f, 0x00a0a505, 0x009524a9, 0x008d646b, 0x0089844c, 0x0089644b, 0x008d2469, 0x0094a4a5, 0x009fe4ff, 0x00af0578, 0x00c20610, 0x00d986cc, 0x00fda7ed, 0x01320990, 0x017aebd7,
-    0x00d1868c, 0x00baa5d5, 0x00a7853c, 0x009844c2, 0x008cc466, 0x0085a42d, 0x0083641b, 0x0083641b, 0x0085842c, 0x008c4462, 0x0097a4bd, 0x00a6c536, 0x00b9a5cd, 0x00d06683, 0x00f1678b, 0x01226913, 0x0167ab3d,
-    0x00cd0668, 0x00b625b1, 0x00a30518, 0x0093c49e, 0x00884442, 0x00830418, 0x0080e407, 0x0080c406, 0x0082e417, 0x0087c43e, 0x00932499, 0x00a22511, 0x00b525a9, 0x00cbe65f, 0x00eb0758, 0x011a68d3, 0x015daaed,
-    0x00cc4662, 0x00b565ab, 0x00a24512, 0x00930498, 0x0087843c, 0x0082a415, 0x00806403, 0x00806403, 0x00828414, 0x00870438, 0x00926493, 0x00a1850c, 0x00b465a3, 0x00cb2659, 0x00ea2751, 0x011928c9, 0x015c2ae1,
-    0x00cf667b, 0x00b885c4, 0x00a5652b, 0x009624b1, 0x008aa455, 0x00846423, 0x00822411, 0x00822411, 0x00844422, 0x008a2451, 0x009564ab, 0x00a48524, 0x00b785bc, 0x00ce4672, 0x00ee6773, 0x011e88f4, 0x0162eb17,
-    0x00d6c6b6, 0x00bf65fb, 0x00ac4562, 0x009d04e8, 0x0091848c, 0x0089c44e, 0x00862431, 0x00860430, 0x0089844c, 0x00910488, 0x009c64e3, 0x00ab655b, 0x00be65f3, 0x00d566ab, 0x00f847c2, 0x012b2959, 0x01726b93,
-    0x00e3e71f, 0x00ca0650, 0x00b705b8, 0x00a7a53d, 0x009c24e1, 0x009484a4, 0x00908484, 0x00908484, 0x009424a1, 0x009bc4de, 0x00a70538, 0x00b625b1, 0x00c90648, 0x00e26713, 0x0108e847, 0x013fe9ff, 0x018bcc5e,
-    0x00f807c0, 0x00d966cb, 0x00c5862c, 0x00b625b1, 0x00aaa555, 0x00a30518, 0x009f04f8, 0x009f04f8, 0x00a2a515, 0x00aa2551, 0x00b585ac, 0x00c4a625, 0x00d846c2, 0x00f647b2, 0x0121a90d, 0x015e4af2, 0x01b8cdc6,
-    0x011548aa, 0x00f1678b, 0x00d886c4, 0x00c86643, 0x00bce5e7, 0x00b545aa, 0x00b1658b, 0x00b1458a, 0x00b505a8, 0x00bc85e4, 0x00c7c63e, 0x00d786bc, 0x00efe77f, 0x0113489a, 0x0144ea27, 0x01888c44, 0x01fdcfee,
-    0x013e49f2, 0x0113e89f, 0x00f5a7ad, 0x00e0c706, 0x00d30698, 0x00cb665b, 0x00c7663b, 0x00c7663b, 0x00cb0658, 0x00d2a695, 0x00dfe6ff, 0x00f467a3, 0x01122891, 0x013be9df, 0x01750ba8, 0x01cfae7d, 0x025912c8,
-    0x01766bb3, 0x01446a23, 0x011fc8fe, 0x0105e82f, 0x00f467a3, 0x00e9874c, 0x00e46723, 0x00e44722, 0x00e92749, 0x00f3a79d, 0x0104c826, 0x011e48f2, 0x01424a12, 0x01738b9c, 0x01bf6dfb, 0x023611b0, 0x02ced676,
-    0x01cf8e7c, 0x01866c33, 0x015aaad5, 0x013ae9d7, 0x01250928, 0x011768bb, 0x0110a885, 0x01108884, 0x0116e8b7, 0x01242921, 0x0139a9cd, 0x0158eac7, 0x01840c20, 0x01cb0e58, 0x0233719b, 0x02b9d5ce, 0x03645b22,
-  };
-}
-
-std::vector<i2c_random_wr_payload> AR0231::getExposureRegisters(int exposure_time, int new_exp_g, bool dc_gain_enabled) const {
-  uint16_t analog_gain_reg = 0xFF00 | (new_exp_g << 4) | new_exp_g;
-  return {
-    {0x3366, analog_gain_reg},
-    {0x3362, (uint16_t)(dc_gain_enabled ? 0x1 : 0x0)},
-    {0x3012, (uint16_t)exposure_time},
-  };
-}
-
-int AR0231::getSlaveAddress(int port) const {
-  assert(port >= 0 && port <= 2);
-  return (int[]){0x20, 0x30, 0x20}[port];
-}
-
-float AR0231::getExposureScore(float desired_ev, int exp_t, int exp_g_idx, float exp_gain, int gain_idx) const {
-  // Cost of ev diff
-  float score = std::abs(desired_ev - (exp_t * exp_gain)) * 10;
-  // Cost of absolute gain
-  float m = exp_g_idx > analog_gain_rec_idx ? analog_gain_cost_high : analog_gain_cost_low;
-  score += std::abs(exp_g_idx - (int)analog_gain_rec_idx) * m;
-  // Cost of changing gain
-  score += std::abs(exp_g_idx - gain_idx) * (score + 1.0) / 10.0;
-  return score;
-}

system/camerad/sensors/ar0231_registers.h

@@ -1,121 +0,0 @@
-#pragma once
-
-const struct i2c_random_wr_payload start_reg_array_ar0231[] = {{0x301A, 0x91C}};
-const struct i2c_random_wr_payload stop_reg_array_ar0231[] = {{0x301A, 0x918}};
-
-const struct i2c_random_wr_payload init_array_ar0231[] = {
-  {0x301A, 0x0018}, // RESET_REGISTER
-
-  // **NOTE**: if this is changed, readout_time_ns must be updated in the Sensor config
-
-  // CLOCK Settings
-  // input clock is 19.2 / 2 * 0x37 = 528 MHz
-  // pixclk is 528 / 6 = 88 MHz
-  // full roll time is 1000/(PIXCLK/(LINE_LENGTH_PCK*FRAME_LENGTH_LINES)) = 39.99 ms
-  // img  roll time is 1000/(PIXCLK/(LINE_LENGTH_PCK*Y_OUTPUT_CONTROL))   = 22.85 ms
-  {0x302A, 0x0006}, // VT_PIX_CLK_DIV
-  {0x302C, 0x0001}, // VT_SYS_CLK_DIV
-  {0x302E, 0x0002}, // PRE_PLL_CLK_DIV
-  {0x3030, 0x0037}, // PLL_MULTIPLIER
-  {0x3036, 0x000C}, // OP_PIX_CLK_DIV
-  {0x3038, 0x0001}, // OP_SYS_CLK_DIV
-
-  // FORMAT
-  {0x3040, 0xC000}, // READ_MODE
-  {0x3004, 0x0000}, // X_ADDR_START_
-  {0x3008, 0x0787}, // X_ADDR_END_
-  {0x3002, 0x0000}, // Y_ADDR_START_
-  {0x3006, 0x04B7}, // Y_ADDR_END_
-  {0x3032, 0x0000}, // SCALING_MODE
-  {0x30A2, 0x0001}, // X_ODD_INC_
-  {0x30A6, 0x0001}, // Y_ODD_INC_
-  {0x3402, 0x0788}, // X_OUTPUT_CONTROL
-  {0x3404, 0x04B8}, // Y_OUTPUT_CONTROL
-  {0x3064, 0x1982}, // SMIA_TEST
-  {0x30BA, 0x11F2}, // DIGITAL_CTRL
-
-  // Enable external trigger and disable GPIO outputs
-  {0x30CE, 0x0120}, // SLAVE_SH_SYNC_MODE | FRAME_START_MODE
-  {0x340A, 0xE0},   // GPIO3_INPUT_DISABLE | GPIO2_INPUT_DISABLE | GPIO1_INPUT_DISABLE
-  {0x340C, 0x802},  // GPIO_HIDRV_EN | GPIO0_ISEL=2
-
-  // Readout timing
-  {0x300C, 0x0672}, // LINE_LENGTH_PCK (valid for 3-exposure HDR)
-  {0x300A, 0x0855}, // FRAME_LENGTH_LINES
-  {0x3042, 0x0000}, // EXTRA_DELAY
-
-  // Readout Settings
-  {0x31AE, 0x0204}, // SERIAL_FORMAT, 4-lane MIPI
-  {0x31AC, 0x0C0C}, // DATA_FORMAT_BITS, 12 -> 12
-  {0x3342, 0x1212}, // MIPI_F1_PDT_EDT
-  {0x3346, 0x1212}, // MIPI_F2_PDT_EDT
-  {0x334A, 0x1212}, // MIPI_F3_PDT_EDT
-  {0x334E, 0x1212}, // MIPI_F4_PDT_EDT
-  {0x3344, 0x0011}, // MIPI_F1_VDT_VC
-  {0x3348, 0x0111}, // MIPI_F2_VDT_VC
-  {0x334C, 0x0211}, // MIPI_F3_VDT_VC
-  {0x3350, 0x0311}, // MIPI_F4_VDT_VC
-  {0x31B0, 0x0053}, // FRAME_PREAMBLE
-  {0x31B2, 0x003B}, // LINE_PREAMBLE
-  {0x301A, 0x001C}, // RESET_REGISTER
-
-  // Noise Corrections
-  {0x3092, 0x0C24}, // ROW_NOISE_CONTROL
-  {0x337A, 0x0C80}, // DBLC_SCALE0
-  {0x3370, 0x03B1}, // DBLC
-  {0x3044, 0x0400}, // DARK_CONTROL
-
-  // Enable temperature sensor
-  {0x30B4, 0x0007}, // TEMPSENS0_CTRL_REG
-  {0x30B8, 0x0007}, // TEMPSENS1_CTRL_REG
-
-  // Enable dead pixel correction using
-  // the 1D line correction scheme
-  {0x31E0, 0x0003},
-
-  // HDR Settings
-  {0x3082, 0x0004}, // OPERATION_MODE_CTRL
-  {0x3238, 0x0444}, // EXPOSURE_RATIO
-
-  {0x1008, 0x0361}, // FINE_INTEGRATION_TIME_MIN
-  {0x100C, 0x0589}, // FINE_INTEGRATION_TIME2_MIN
-  {0x100E, 0x07B1}, // FINE_INTEGRATION_TIME3_MIN
-  {0x1010, 0x0139}, // FINE_INTEGRATION_TIME4_MIN
-
-  // TODO: do these have to be lower than LINE_LENGTH_PCK?
-  {0x3014, 0x08CB}, // FINE_INTEGRATION_TIME_
-  {0x321E, 0x0894}, // FINE_INTEGRATION_TIME2
-
-  {0x31D0, 0x0000}, // COMPANDING, no good in 10 bit?
-  {0x33DA, 0x0000}, // COMPANDING
-  {0x318E, 0x0200}, // PRE_HDR_GAIN_EN
-
-  // DLO Settings
-  {0x3100, 0x4000}, // DLO_CONTROL0
-  {0x3280, 0x0CCC}, // T1 G1
-  {0x3282, 0x0CCC}, // T1 R
-  {0x3284, 0x0CCC}, // T1 B
-  {0x3286, 0x0CCC}, // T1 G2
-  {0x3288, 0x0FA0}, // T2 G1
-  {0x328A, 0x0FA0}, // T2 R
-  {0x328C, 0x0FA0}, // T2 B
-  {0x328E, 0x0FA0}, // T2 G2
-
-   // Initial Gains
-  {0x3022, 0x0001}, // GROUPED_PARAMETER_HOLD_
-  {0x3366, 0xFF77}, // ANALOG_GAIN (1x)
-
-  {0x3060, 0x3333}, // ANALOG_COLOR_GAIN
-
-  {0x3362, 0x0000}, // DC GAIN
-
-  {0x305A, 0x00F8}, // red gain
-  {0x3058, 0x0122}, // blue gain
-  {0x3056, 0x009A}, // g1 gain
-  {0x305C, 0x009A}, // g2 gain
-
-  {0x3022, 0x0000}, // GROUPED_PARAMETER_HOLD_
-
-  // Initial Integration Time
-  {0x3012, 0x0005},
-};

system/camerad/sensors/sensor.h

@@ -10,7 +10,6 @@
 #include "media/cam_sensor.h"
 
 #include "cereal/gen/cpp/log.capnp.h"
-#include "system/camerad/sensors/ar0231_registers.h"
 #include "system/camerad/sensors/ox03c10_registers.h"
 #include "system/camerad/sensors/os04c10_registers.h"
 
@@ -88,17 +87,6 @@ public:
   };
 };
 
-class AR0231 : public SensorInfo {
-public:
-  AR0231();
-  std::vector<i2c_random_wr_payload> getExposureRegisters(int exposure_time, int new_exp_g, bool dc_gain_enabled) const override;
-  float getExposureScore(float desired_ev, int exp_t, int exp_g_idx, float exp_gain, int gain_idx) const override;
-  int getSlaveAddress(int port) const override;
-
-private:
-  mutable std::map<uint16_t, std::pair<int, int>> ar0231_register_lut;
-};
-
 class OX03C10 : public SensorInfo {
 public:
   OX03C10();

system/hardware/hardwared.py

@@ -6,7 +6,6 @@ import struct
 import threading
 import time
 from collections import OrderedDict, namedtuple
-from pathlib import Path
 
 import psutil
 
@@ -345,12 +344,6 @@ def hardware_thread(end_event, hw_queue) -> None:
     show_alert = (not onroad_conditions["device_temp_good"] or not startup_conditions["device_temp_engageable"]) and onroad_conditions["ignition"]
     set_offroad_alert_if_changed("Offroad_TemperatureTooHigh", show_alert, extra_text=extra_text)
 
-    # TODO: this should move to TICI.initialize_hardware, but we currently can't import params there
-    if TICI and HARDWARE.get_device_type() == "tici":
-      if not os.path.isfile("/persist/comma/living-in-the-moment"):
-        if not Path("/data/media").is_mount():
-          set_offroad_alert_if_changed("Offroad_StorageMissing", True)
-
     # Handle offroad/onroad transition
     should_start = all(onroad_conditions.values())
     if started_ts is None:

system/hardware/tici/agnos.json

@@ -23,14 +23,14 @@
   },
   {
     "name": "abl",
-    "url": "https://commadist.azureedge.net/agnosupdate/abl-32a2174b5f764e95dfc54cf358ba01752943b1b3b90e626149c3da7d5f1830b6.img.xz",
-    "hash": "32a2174b5f764e95dfc54cf358ba01752943b1b3b90e626149c3da7d5f1830b6",
-    "hash_raw": "32a2174b5f764e95dfc54cf358ba01752943b1b3b90e626149c3da7d5f1830b6",
+    "url": "https://commadist.azureedge.net/agnosupdate/abl-556bbb4ed1c671402b217bd2f3c07edce4f88b0bbd64e92241b82e396aa9ebee.img.xz",
+    "hash": "556bbb4ed1c671402b217bd2f3c07edce4f88b0bbd64e92241b82e396aa9ebee",
+    "hash_raw": "556bbb4ed1c671402b217bd2f3c07edce4f88b0bbd64e92241b82e396aa9ebee",
     "size": 274432,
     "sparse": false,
     "full_check": true,
     "has_ab": true,
-    "ondevice_hash": "32a2174b5f764e95dfc54cf358ba01752943b1b3b90e626149c3da7d5f1830b6"
+    "ondevice_hash": "556bbb4ed1c671402b217bd2f3c07edce4f88b0bbd64e92241b82e396aa9ebee"
   },
   {
     "name": "aop",
@@ -56,14 +56,14 @@
   },
   {
     "name": "boot",
-    "url": "https://commadist.azureedge.net/agnosupdate/boot-0191529aa97d90d1fa04b472d80230b777606459e1e1e9e2323c9519839827b4.img.xz",
-    "hash": "0191529aa97d90d1fa04b472d80230b777606459e1e1e9e2323c9519839827b4",
-    "hash_raw": "0191529aa97d90d1fa04b472d80230b777606459e1e1e9e2323c9519839827b4",
-    "size": 18515968,
+    "url": "https://commadist.azureedge.net/agnosupdate/boot-90bd687e9e407834d4ee1b07f3d05527dfae0ff09c0cacd64cfd6097f6b10e2c.img.xz",
+    "hash": "90bd687e9e407834d4ee1b07f3d05527dfae0ff09c0cacd64cfd6097f6b10e2c",
+    "hash_raw": "90bd687e9e407834d4ee1b07f3d05527dfae0ff09c0cacd64cfd6097f6b10e2c",
+    "size": 17496064,
     "sparse": false,
     "full_check": true,
     "has_ab": true,
-    "ondevice_hash": "492ae27f569e8db457c79d0e358a7a6297d1a1c685c2b1ae6deba7315d3a6cb0"
+    "ondevice_hash": "35014c39b55010ac955c10f808b088e74259147c7a8cbf989b3dff7d95a1e8ae"
   },
   {
     "name": "system",
@@ -81,4 +81,4 @@
       "size": 4718592000
     }
   }
-]
+]

system/hardware/tici/amplifier.py

@@ -61,18 +61,6 @@ BASE_CONFIG = [
 ]
 
 CONFIGS = {
-  "tici": [
-    AmpConfig("Right speaker output from right DAC", 0b1, 0x2C, 0, 0b11111111),
-    AmpConfig("Right Speaker Mixer Gain", 0b00, 0x2D, 2, 0b00001100),
-    AmpConfig("Right speaker output volume", 0x1c, 0x3E, 0, 0b00011111),
-    AmpConfig("DAI2 EQ enable", 0b1, 0x49, 1, 0b00000010),
-
-    *configs_from_eq_params(0x84, EQParams(0x274F, 0xC0FF, 0x3BF9, 0x0B3C, 0x1656)),
-    *configs_from_eq_params(0x8E, EQParams(0x1009, 0xC6BF, 0x2952, 0x1C97, 0x30DF)),
-    *configs_from_eq_params(0x98, EQParams(0x0F75, 0xCBE5, 0x0ED2, 0x2528, 0x3E42)),
-    *configs_from_eq_params(0xA2, EQParams(0x091F, 0x3D4C, 0xCE11, 0x1266, 0x2807)),
-    *configs_from_eq_params(0xAC, EQParams(0x0A9E, 0x3F20, 0xE573, 0x0A8B, 0x3A3B)),
-  ],
   "tizi": [
     AmpConfig("Left speaker output from left DAC", 0b1, 0x2B, 0, 0b11111111),
     AmpConfig("Right speaker output from right DAC", 0b1, 0x2C, 0, 0b11111111),

system/hardware/tici/hardware.py

@@ -446,9 +446,6 @@ class Tici(HardwareBase):
 
     # pandad core
     affine_irq(3, "spi_geni")         # SPI
-    if "tici" in self.get_device_type():
-      affine_irq(3, "xhci-hcd:usb3")  # aux panda USB (or potentially anything else on USB)
-      affine_irq(3, "xhci-hcd:usb1")  # internal panda USB (also modem)
     try:
       pid = subprocess.check_output(["pgrep", "-f", "spi0"], encoding='utf8').strip()
       subprocess.call(["sudo", "chrt", "-f", "-p", "1", pid])
@@ -467,22 +464,20 @@ class Tici(HardwareBase):
 
     cmds = []
 
-    if self.get_device_type() in ("tici", "tizi"):
+    if self.get_device_type() in ("tizi", ):
       # clear out old blue prime initial APN
       os.system('mmcli -m any --3gpp-set-initial-eps-bearer-settings="apn="')
 
       cmds += [
+        # SIM hot swap
+        'AT+QSIMDET=1,0',
+        'AT+QSIMSTAT=1',
+
         # configure modem as data-centric
         'AT+QNVW=5280,0,"0102000000000000"',
         'AT+QNVFW="/nv/item_files/ims/IMS_enable",00',
         'AT+QNVFW="/nv/item_files/modem/mmode/ue_usage_setting",01',
       ]
-      if self.get_device_type() == "tizi":
-        # SIM hot swap, not routed on tici
-        cmds += [
-          'AT+QSIMDET=1,0',
-          'AT+QSIMSTAT=1',
-        ]
     elif manufacturer == 'Cavli Inc.':
       cmds += [
         'AT^SIMSWAP=1',     # use SIM slot, instead of internal eSIM

system/hardware/tici/pins.py

@@ -1,5 +1,3 @@
-# TODO: these are also defined in a header
-
 # GPIO pin definitions
 class GPIO:
   # both GPIO_STM_RST_N and GPIO_LTE_RST_N are misnamed, they are high to reset
@@ -26,7 +24,4 @@ class GPIO:
   CAM2_RSTN = 12
 
   # Sensor interrupts
-  BMX055_ACCEL_INT = 21
-  BMX055_GYRO_INT = 23
-  BMX055_MAGN_INT = 87
   LSM_INT = 84

system/sensord/sensord.py

@@ -97,7 +97,7 @@ def main() -> None:
     (LSM6DS3_Gyro(I2C_BUS_IMU), "gyroscope", True),
     (LSM6DS3_Temp(I2C_BUS_IMU), "temperatureSensor", False),
   ]
-  if HARDWARE.get_device_type() in ("tizi", "tici"):
+  if HARDWARE.get_device_type() == "tizi":
     sensors_cfg.append(
       (MMC5603NJ_Magn(I2C_BUS_IMU), "magnetometer", False),
     )

system/ui/lib/application.py

@@ -23,7 +23,7 @@ from openpilot.common.realtime import Ratekeeper
 
 from openpilot.system.ui.sunnypilot.lib.application import GuiApplicationExt
 
-_DEFAULT_FPS = int(os.getenv("FPS", {'tizi': 20, "tici": 20}.get(HARDWARE.get_device_type(), 60)))
+_DEFAULT_FPS = int(os.getenv("FPS", {'tizi': 20}.get(HARDWARE.get_device_type(), 60)))
 FPS_LOG_INTERVAL = 5  # Seconds between logging FPS drops
 FPS_DROP_THRESHOLD = 0.9  # FPS drop threshold for triggering a warning
 FPS_CRITICAL_THRESHOLD = 0.5  # Critical threshold for triggering strict actions

system/ui/sunnypilot/widgets/list_view.py

@@ -15,6 +15,7 @@ from openpilot.system.ui.widgets.button import Button, ButtonStyle
 from openpilot.system.ui.widgets.label import gui_label
 from openpilot.system.ui.widgets.list_view import ListItem, ToggleAction, ItemAction, MultipleButtonAction, ButtonAction, \
                                                   _resolve_value, BUTTON_WIDTH, BUTTON_HEIGHT, TEXT_PADDING
+from openpilot.system.ui.widgets.scroller_tici import LineSeparator, LINE_COLOR, LINE_PADDING
 from openpilot.system.ui.sunnypilot.lib.styles import style
 from openpilot.system.ui.sunnypilot.widgets.option_control import OptionControlSP, LABEL_WIDTH
 
@@ -179,13 +180,8 @@ class ListItemSP(ListItem):
       return rl.Rectangle(0, 0, 0, 0)
 
     if not self.inline:
-      has_description = bool(self.description) and self.description_visible
-
-      if has_description:
-        action_y = item_rect.y + self._text_size.y + style.ITEM_PADDING * 3
-      else:
-        action_y = item_rect.y + item_rect.height - style.BUTTON_HEIGHT - style.ITEM_PADDING * 1.5
-
+      text_size = measure_text_cached(self._font, self.title, style.ITEM_TEXT_FONT_SIZE)
+      action_y = item_rect.y + text_size.y + style.ITEM_PADDING * 3
       return rl.Rectangle(item_rect.x + style.ITEM_PADDING, action_y, item_rect.width - (style.ITEM_PADDING * 2), style.BUTTON_HEIGHT)
 
     right_width = self.action_item.get_width_hint()
@@ -312,3 +308,15 @@ def button_item_sp(title: str | Callable[[], str], button_text: str | Callable[[
                    callback: Callable | None = None, enabled: bool | Callable[[], bool] = True) -> ListItemSP:
   action = ButtonActionSP(text=button_text, enabled=enabled)
   return ListItemSP(title=title, description=description, action_item=action, callback=callback)
+
+
+class LineSeparatorSP(LineSeparator):
+  def __init__(self, height: int = 1):
+    super().__init__()
+    self._rect = rl.Rectangle(0, 0, 0, height)
+
+  def _render(self, _):
+    line_y = int(self._rect.y + self._rect.height // 2)
+    rl.draw_line(int(self._rect.x) + LINE_PADDING, line_y,
+                 int(self._rect.x + self._rect.width) - LINE_PADDING, line_y,
+                 LINE_COLOR)

system/ui/tici_reset.py

@@ -13,7 +13,6 @@ from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.button import Button, ButtonStyle
 from openpilot.system.ui.widgets.label import gui_label, gui_text_box
 
-NVME = "/dev/nvme0n1"
 USERDATA = "/dev/disk/by-partlabel/userdata"
 TIMEOUT = 3*60
 
@@ -49,10 +48,6 @@ class Reset(Widget):
     if PC:
       return
 
-    # Best effort to wipe NVME
-    os.system(f"sudo umount {NVME}")
-    os.system(f"yes | sudo mkfs.ext4 {NVME}")
-
     # Removing data and formatting
     rm = os.system("sudo rm -rf /data/*")
     os.system(f"sudo umount {USERDATA}")