TCPv3 plus gWM9 Model

CgWM + ST

.clang-tidy

@@ -0,0 +1,19 @@
+---
+Checks: '
+bugprone-*,
+-bugprone-integer-division,
+-bugprone-narrowing-conversions,
+performance-*,
+clang-analyzer-*,
+misc-*,
+-misc-unused-parameters,
+modernize-*,
+-modernize-avoid-c-arrays,
+-modernize-deprecated-headers,
+-modernize-use-auto,
+-modernize-use-using,
+-modernize-use-nullptr,
+-modernize-use-trailing-return-type,
+'
+CheckOptions:
+...

.dockerignore

@@ -13,6 +13,27 @@
 *.o-*
 *.os
 *.os-*
+*.so
+*.a
 
 venv/
 .venv/
+
+notebooks
+phone
+massivemap
+neos
+installer
+chffr/app2
+chffr/backend/env
+selfdrive/nav
+selfdrive/baseui
+selfdrive/test/simulator2
+**/cache_data
+xx/plus
+xx/community
+xx/projects
+!xx/projects/eon_testing_master
+!xx/projects/map3d
+xx/ops
+xx/junk

.gitattributes

@@ -7,12 +7,10 @@
 *.png filter=lfs diff=lfs merge=lfs -text
 *.gif filter=lfs diff=lfs merge=lfs -text
 *.ttf filter=lfs diff=lfs merge=lfs -text
-*.otf filter=lfs diff=lfs merge=lfs -text
 *.wav filter=lfs diff=lfs merge=lfs -text
 
 selfdrive/car/tests/test_models_segs.txt filter=lfs diff=lfs merge=lfs -text
-system/hardware/tici/updater_weston filter=lfs diff=lfs merge=lfs -text
-system/hardware/tici/updater_magic filter=lfs diff=lfs merge=lfs -text
+system/hardware/tici/updater filter=lfs diff=lfs merge=lfs -text
 third_party/**/*.a filter=lfs diff=lfs merge=lfs -text
 third_party/**/*.so filter=lfs diff=lfs merge=lfs -text
 third_party/**/*.so.* filter=lfs diff=lfs merge=lfs -text

.github/labeler.yaml

@@ -16,7 +16,7 @@ simulation:
 
 ui:
   - changed-files:
-    - any-glob-to-all-files: '{selfdrive/assets/**,selfdrive/ui/**,system/ui/**}'
+    - any-glob-to-all-files: '{selfdrive/ui/**,system/ui/**}'
 
 tools:
   - changed-files:

.github/workflows/badges.yaml

@@ -23,7 +23,7 @@ jobs:
     - uses: ./.github/workflows/setup-with-retry
     - name: Push badges
       run: |
-        ${{ env.RUN }} "python3 selfdrive/ui/translations/create_badges.py"
+        ${{ env.RUN }} "scons -j$(nproc) && python3 selfdrive/ui/translations/create_badges.py"
 
         rm .gitattributes
 

.github/workflows/build-all-tinygrad-models.yaml

@@ -74,7 +74,7 @@ jobs:
         env:
           GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
         run: |
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/${{ vars.MODELS_GITLAB }} gitlab_docs
+          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai2.git gitlab_docs
           cd gitlab_docs
           git checkout main
           git sparse-checkout set --no-cone models/
@@ -191,7 +191,7 @@ jobs:
           GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
         run: |
           echo "Cloning GitLab"
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/${{ vars.MODELS_GITLAB }} gitlab_docs
+          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai2.git gitlab_docs
           cd gitlab_docs
           echo "checkout models/${RECOMPILED_DIR}"
           git sparse-checkout set --no-cone models/${RECOMPILED_DIR}

.github/workflows/build-single-tinygrad-model.yaml

@@ -109,7 +109,7 @@ jobs:
           GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
         run: |
           echo "Cloning GitLab"
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/${{ vars.MODELS_GITLAB }} gitlab_docs
+          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai2.git gitlab_docs
           cd gitlab_docs
           echo "checkout models/${RECOMPILED_DIR}"
           git sparse-checkout set --no-cone models/${RECOMPILED_DIR}

.github/workflows/ci_weekly_run.yaml

@@ -11,7 +11,7 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  tests:
-    uses: sunnypilot/sunnypilot/.github/workflows/tests.yaml@master
+  selfdrive_tests:
+    uses: sunnypilot/sunnypilot/.github/workflows/selfdrive_tests.yaml@master
     with:
       run_number: ${{ inputs.run_number }}

.github/workflows/selfdrive_tests.yaml

@@ -1,4 +1,4 @@
-name: tests
+name: selfdrive
 
 on:
   push:
@@ -14,19 +14,18 @@ on:
         type: string
 
 concurrency:
-  group: tests-ci-run-${{ inputs.run_number }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && github.run_id || github.head_ref || github.ref }}-${{ github.workflow }}-${{ github.event_name }}
+  group: selfdrive-tests-ci-run-${{ inputs.run_number }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && github.run_id || github.head_ref || github.ref }}-${{ github.workflow }}-${{ github.event_name }}
   cancel-in-progress: true
 
 env:
   PYTHONWARNINGS: error
   BASE_IMAGE: sunnypilot-base
   AZURE_TOKEN: ${{ secrets.AZURE_COMMADATACI_OPENPILOTCI_TOKEN }}
-  MAPBOX_TOKEN_CI: ${{ secrets.MAPBOX_TOKEN_CI }}
 
   DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
   BUILD: release/ci/docker_build_sp.sh base
 
-  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -e MAPBOX_TOKEN_CI=$MAPBOX_TOKEN_CI -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
+  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
 
   PYTEST: pytest --continue-on-collection-errors --durations=0 -n logical
 
@@ -196,6 +195,8 @@ jobs:
                         # Pre-compile Python bytecode so each pytest worker doesn't need to
                         $PYTEST --collect-only -m 'not slow' -qq && \
                         MAX_EXAMPLES=1 $PYTEST -m 'not slow' && \
+                        ./selfdrive/ui/tests/create_test_translations.sh && \
+                        QT_QPA_PLATFORM=offscreen ./selfdrive/ui/tests/test_translations && \
                         chmod -R 777 /tmp/comma_download_cache"
 
   process_replay:
@@ -256,7 +257,7 @@ jobs:
       (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))
       && fromJSON('["namespace-profile-amd64-8x16", "namespace-experiments:docker.builds.local-cache=separate"]')
       || fromJSON('["ubuntu-24.04"]') }}
-    if: false  # FIXME: Started to timeout recently
+    if: (github.repository == 'commaai/openpilot') && ((github.event_name != 'pull_request') || (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))
     steps:
     - uses: actions/checkout@v4
       with:
@@ -273,28 +274,38 @@ jobs:
                         source selfdrive/test/setup_vsound.sh && \
                         CI=1 pytest -s tools/sim/tests/test_metadrive_bridge.py"
 
-  create_raylib_ui_report:
-    name: Create raylib UI Report
+  create_ui_report:
+    # This job name needs to be the same as UI_JOB_NAME in ui_preview.yaml
+    name: Create UI Report
     runs-on: ${{
       (github.repository == 'commaai/openpilot') &&
       ((github.event_name != 'pull_request') ||
       (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))
       && fromJSON('["namespace-profile-amd64-8x16", "namespace-experiments:docker.builds.local-cache=separate"]')
       || fromJSON('["ubuntu-24.04"]') }}
+    if: false  # FIXME: FrameReader is broken on CI runners
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: true
       - uses: ./.github/workflows/setup-with-retry
+      - name: caching frames
+        id: frames-cache
+        uses: actions/cache@v4
+        with:
+          path: .ci_cache/comma_download_cache
+          key: ui_screenshots_test_${{ hashFiles('selfdrive/ui/tests/test_ui/run.py') }}
       - name: Build openpilot
         run: ${{ env.RUN }} "scons -j$(nproc)"
-      - name: Create raylib UI Report
+      - name: Create Test Report
+        timeout-minutes: ${{ ((steps.frames-cache.outputs.cache-hit == 'true') && 2 || 4) }}
         run: >
-          ${{ env.RUN }} "PYTHONWARNINGS=ignore &&
-                          source selfdrive/test/setup_xvfb.sh &&
-                          python3 selfdrive/ui/tests/test_ui/raylib_screenshots.py"
-      - name: Upload Raylib UI Report
+            ${{ env.RUN }} "PYTHONWARNINGS=ignore &&
+                            source selfdrive/test/setup_xvfb.sh &&
+                            CACHE_ROOT=/tmp/comma_download_cache python3 selfdrive/ui/tests/test_ui/run.py &&
+                            chmod -R 777 /tmp/comma_download_cache"
+      - name: Upload Test Report
         uses: actions/upload-artifact@v4
         with:
-          name: raylib-report-${{ inputs.run_number || '1' }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && 'master' || github.event.number }}
-          path: selfdrive/ui/tests/test_ui/raylib_report/screenshots
+          name: report-${{ inputs.run_number || '1' }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && 'master' || github.event.number }}
+          path: selfdrive/ui/tests/test_ui/report_1/screenshots

.github/workflows/sunnypilot-build-model.yaml

@@ -156,8 +156,6 @@ jobs:
         with:
           name: models-${{ env.REF }}${{ inputs.artifact_suffix }}
           path: ${{ github.workspace }}/selfdrive/modeld/models
-      - run: |
-          rm -f ${{ github.workspace }}/selfdrive/modeld/models/{dmonitoring_model,big_driving_policy,big_driving_vision}.onnx
 
       - name: Build Model
         run: |

.github/workflows/ui_preview.yaml

@@ -1,4 +1,4 @@
-name: "raylib ui preview"
+name: "ui preview"
 on:
   push:
     branches:
@@ -8,16 +8,14 @@ on:
     branches:
       - 'master'
     paths:
-      - 'selfdrive/assets/**'
       - 'selfdrive/ui/**'
-      - 'system/ui/**'
   workflow_dispatch:
 
 env:
-  UI_JOB_NAME: "Create raylib UI Report"
+  UI_JOB_NAME: "Create UI Report"
   REPORT_NAME: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && 'master' || github.event.number }}
   SHA: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && github.sha || github.event.pull_request.head.sha }}
-  BRANCH_NAME: "openpilot/pr-${{ github.event.number }}-raylib-ui"
+  BRANCH_NAME: "openpilot/pr-${{ github.event.number }}"
 
 jobs:
   preview:
@@ -54,7 +52,7 @@ jobs:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           run_id: ${{ steps.get_run_id.outputs.run_id }}
           search_artifacts: true
-          name: raylib-report-1-${{ env.REPORT_NAME }}
+          name: report-1-${{ env.REPORT_NAME }}
           path: ${{ github.workspace }}/pr_ui
 
       - name: Getting master ui
@@ -62,23 +60,23 @@ jobs:
         with:
           repository: sunnypilot/ci-artifacts
           ssh-key: ${{ secrets.CI_ARTIFACTS_DEPLOY_KEY }}
-          path: ${{ github.workspace }}/master_ui_raylib
-          ref: openpilot_master_ui_raylib
+          path: ${{ github.workspace }}/master_ui
+          ref: openpilot_master_ui
 
       - name: Saving new master ui
         if: github.ref == 'refs/heads/master' && github.event_name == 'push'
-        working-directory: ${{ github.workspace }}/master_ui_raylib
+        working-directory: ${{ github.workspace }}/master_ui
         run: |
-          git checkout --orphan=new_master_ui_raylib
+          git checkout --orphan=new_master_ui
           git rm -rf *
-          git branch -D openpilot_master_ui_raylib
-          git branch -m openpilot_master_ui_raylib
+          git branch -D openpilot_master_ui
+          git branch -m openpilot_master_ui
           git config user.name "GitHub Actions Bot"
           git config user.email "<>"
           mv ${{ github.workspace }}/pr_ui/*.png .
           git add .
-          git commit -m "raylib screenshots for commit ${{ env.SHA }}"
-          git push origin openpilot_master_ui_raylib --force
+          git commit -m "screenshots for commit ${{ env.SHA }}"
+          git push origin openpilot_master_ui --force
 
       - name: Finding diff
         if: github.event_name == 'pull_request_target'
@@ -96,7 +94,7 @@ jobs:
           for ((i=0; i<${#A[*]}; i=i+1));
           do
             # Check if the master file exists
-            if [ ! -f "${{ github.workspace }}/master_ui_raylib/${A[$i]}.png" ]; then
+            if [ ! -f "${{ github.workspace }}/master_ui/${A[$i]}.png" ]; then
               # This is a new file in PR UI that doesn't exist in master
               DIFF="${DIFF}<details open>"
               DIFF="${DIFF}<summary>${A[$i]} : \$\${\\color{cyan}\\text{NEW}}\$\$</summary>"
@@ -108,12 +106,12 @@ jobs:
 
               DIFF="${DIFF}</table>"
               DIFF="${DIFF}</details>"
-            elif ! compare -fuzz 2% -highlight-color DeepSkyBlue1 -lowlight-color Black -compose Src ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_diff.png; then
+            elif ! compare -fuzz 2% -highlight-color DeepSkyBlue1 -lowlight-color Black -compose Src ${{ github.workspace }}/master_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_diff.png; then
               convert ${{ github.workspace }}/pr_ui/${A[$i]}_diff.png -transparent black mask.png
-              composite mask.png ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png composite_diff.png
-              convert -delay 100 ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png composite_diff.png -loop 0 ${{ github.workspace }}/pr_ui/${A[$i]}_diff.gif
+              composite mask.png ${{ github.workspace }}/master_ui/${A[$i]}.png composite_diff.png
+              convert -delay 100 ${{ github.workspace }}/master_ui/${A[$i]}.png composite_diff.png -loop 0 ${{ github.workspace }}/pr_ui/${A[$i]}_diff.gif
 
-              mv ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_master_ref.png
+              mv ${{ github.workspace }}/master_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_master_ref.png
 
               DIFF="${DIFF}<details open>"
               DIFF="${DIFF}<summary>${A[$i]} : \$\${\\color{red}\\text{DIFFERENT}}\$\$</summary>"
@@ -151,7 +149,7 @@ jobs:
 
       - name: Saving proposed ui
         if: github.event_name == 'pull_request_target'
-        working-directory: ${{ github.workspace }}/master_ui_raylib
+        working-directory: ${{ github.workspace }}/master_ui
         run: |
           git config user.name "GitHub Actions Bot"
           git config user.email "<>"
@@ -159,7 +157,7 @@ jobs:
           git rm -rf *
           mv ${{ github.workspace }}/pr_ui/* .
           git add .
-          git commit -m "raylib screenshots for PR #${{ github.event.number }}"
+          git commit -m "screenshots for PR #${{ github.event.number }}"
           git push origin ${{ env.BRANCH_NAME }} --force
 
       - name: Comment Screenshots on PR
@@ -167,9 +165,9 @@ jobs:
         uses: thollander/actions-comment-pull-request@v2
         with:
           message: |
-            <!-- _(run_id_screenshots_raylib **${{ github.run_id }}**)_ -->
-            ## raylib UI Preview
+            <!-- _(run_id_screenshots **${{ github.run_id }}**)_ -->
+            ## UI Preview
             ${{ steps.find_diff.outputs.DIFF }}
-          comment_tag: run_id_screenshots_raylib
+          comment_tag: run_id_screenshots
           pr_number: ${{ github.event.number }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -10,6 +10,7 @@ venv/
 .overlay_init
 .overlay_consistent
 .sconsign.dblite
+model2.png
 a.out
 .hypothesis
 .cache/
@@ -36,23 +37,29 @@ a.out
 *.class
 *.pyxbldc
 *.vcd
-*.mo
+*.qm
 *_pyx.cpp
-*.stats
 config.json
 clcache
 compile_commands.json
 compare_runtime*.html
 
+persist
 selfdrive/pandad/pandad
 cereal/services.h
 cereal/gen
 cereal/messaging/bridge
+selfdrive/mapd/default_speeds_by_region.json
 selfdrive/ui/translations/tmp
+selfdrive/test/longitudinal_maneuvers/out
 selfdrive/car/tests/cars_dump
 system/camerad/camerad
 system/camerad/test/ae_gray_test
 
+notebooks
+hyperthneed
+provisioning
+
 .coverage*
 coverage.xml
 htmlcov
@@ -69,7 +76,6 @@ sunnypilot/modeld*/thneed/compile
 sunnypilot/modeld*/models/*.thneed
 sunnypilot/modeld*/models/*.pkl
 
-# openpilot log files
 *.bz2
 *.zst
 

.gitmodules

@@ -15,7 +15,7 @@
   url = https://github.com/commaai/teleoprtc
 [submodule "tinygrad"]
   path = tinygrad_repo
-  url = https://github.com/commaai/tinygrad.git
+  url = https://github.com/tinygrad/tinygrad.git
 [submodule "sunnypilot/neural_network_data"]
   path = sunnypilot/neural_network_data
   url = https://github.com/sunnypilot/neural-network-data.git

CHANGELOG.md

@@ -1,30 +1,6 @@
-sunnypilot Version 2025.003.000 (20xx-xx-xx)
+sunnypilot Version 2025.002.000 (2025-xx-xx)
 ========================
 
-sunnypilot Version 2025.002.000 (2025-11-06)
-========================
-* What's Changed (sunnypilot/sunnypilot)
-  * models: bump model json to v8 by @Discountchubbs
-  * Bug: Model UI Crash Fix by @nayan8teen
-  * controlsd: add `CP_SP` to `get_pid_accel_limits` by @THERoenPR
-  * sunnylink: update uploader button logic to support novice tier and above by @devtekve
-  * Tesla: Coop Steering by @AmyJeanes
-  * ui: update discord references and add forum widget by @devtekve
-  * ui: Fix spacing in sunnylink panel by @devtekve
-  * docs: Update README installation branches and discord links by @mpurnell1 in
-  * stats: sunnylink integration by @devtekve
-  * bug: Fix initial registration for sunnylink by @devtekve
-* What's Changed (sunnypilot/opendbc)
-  * Honda: add brake hold messages for Clarity by @mvl-boston
-  * interface: add `CP_SP` to `get_pid_accel_limits` method signature by @roenthomas
-  * Honda: use fixed accel min/max constants for Gas Interceptor by @roenthomas
-  * Tesla: Coop Steering by @AmyJeanes
-* New Contributors (sunnypilot/sunnypilot)
-  * @THERoenPR made their first contribution in "controlsd: add `CP_SP` to `get_pid_accel_limits`"
-  * @AmyJeanes made their first contribution in "Tesla: Coop Steering"
-  * @mpurnell1 made their first contribution in "docs: Update README installation branches and discord links"
-* Full Changelog: https://github.com/sunnypilot/sunnypilot/compare/v2025.001.000...v2025.002.000
-
 sunnypilot Version 2025.001.000 (2025-10-25)
 ========================
 * 🛠️ Major rewrite

Dockerfile.openpilot

@@ -9,6 +9,4 @@ WORKDIR ${OPENPILOT_PATH}
 
 COPY . ${OPENPILOT_PATH}/
 
-ENV UV_BIN="/home/batman/.local/bin/"
-ENV PATH="$UV_BIN:$PATH"
-RUN UV_PROJECT_ENVIRONMENT=$VIRTUAL_ENV uv run scons --cache-readonly -j$(nproc)
+RUN scons --cache-readonly -j$(nproc)

Jenkinsfile

@@ -167,7 +167,7 @@ node {
   env.GIT_COMMIT = checkout(scm).GIT_COMMIT
 
   def excludeBranches = ['__nightly', 'devel', 'devel-staging', 'release3', 'release3-staging',
-                         'release-tici', 'release-tizi', 'release-tizi-staging', 'testing-closet*', 'hotfix-*']
+                         'release-tici', 'testing-closet*', 'hotfix-*']
   def excludeRegex = excludeBranches.join('|').replaceAll('\\*', '.*')
 
   if (env.BRANCH_NAME != 'master' && !env.BRANCH_NAME.contains('__jenkins_loop_')) {
@@ -178,8 +178,8 @@ node {
 
   try {
     if (env.BRANCH_NAME == 'devel-staging') {
-      deviceStage("build release-tizi-staging", "tizi-needs-can", [], [
-        step("build release-tizi-staging", "RELEASE_BRANCH=release-tizi-staging $SOURCE_DIR/release/build_release.sh"),
+      deviceStage("build release3-staging", "tizi-needs-can", [], [
+        step("build release3-staging", "RELEASE_BRANCH=release3-staging $SOURCE_DIR/release/build_release.sh"),
       ])
     }
 

RELEASES.md

@@ -1,20 +1,13 @@
-Version 0.10.2 (2025-11-23)
-========================
-
 Version 0.10.1 (2025-09-08)
 ========================
-* New driving model #36276
+* New driving model
   * World Model: removed global localization inputs
   * World Model: 2x the number of parameters
   * World Model: trained on 4x the number of segments
-  * VAE Compression Model: new architecture and training objective
   * Driving Vision Model: trained on 4x the number of segments
-* New Driver Monitoring model #36198
-* Acura TLX 2021 support thanks to MVL!
 * Honda City 2023 support thanks to vanillagorillaa and drFritz!
 * Honda N-Box 2018 support thanks to miettal!
 * Honda Odyssey 2021-25 support thanks to csouers and MVL!
-* Honda Passport 2026 support thanks to vanillagorillaa and MVL!
 
 Version 0.10.0 (2025-08-05)
 ========================

SConstruct

@@ -3,52 +3,176 @@ import subprocess
 import sys
 import sysconfig
 import platform
-import shlex
 import numpy as np
 
 import SCons.Errors
 
 SCons.Warnings.warningAsException(True)
 
+# pending upstream fix - https://github.com/SCons/scons/issues/4461
+#SetOption('warn', 'all')
+
+TICI = os.path.isfile('/TICI')
+AGNOS = TICI
+
 Decider('MD5-timestamp')
 
 SetOption('num_jobs', max(1, int(os.cpu_count()/2)))
 
-AddOption('--kaitai', action='store_true', help='Regenerate kaitai struct parsers')
-AddOption('--asan', action='store_true', help='turn on ASAN')
-AddOption('--ubsan', action='store_true', help='turn on UBSan')
-AddOption('--mutation', action='store_true', help='generate mutation-ready code')
-AddOption('--ccflags', action='store', type='string', default='', help='pass arbitrary flags over the command line')
+AddOption('--kaitai',
+          action='store_true',
+          help='Regenerate kaitai struct parsers')
+
+AddOption('--asan',
+          action='store_true',
+          help='turn on ASAN')
+
+AddOption('--ubsan',
+          action='store_true',
+          help='turn on UBSan')
+
+AddOption('--coverage',
+          action='store_true',
+          help='build with test coverage options')
+
+AddOption('--clazy',
+          action='store_true',
+          help='build with clazy')
+
+AddOption('--ccflags',
+          action='store',
+          type='string',
+          default='',
+          help='pass arbitrary flags over the command line')
+
+AddOption('--external-sconscript',
+          action='store',
+          metavar='FILE',
+          dest='external_sconscript',
+          help='add an external SConscript to the build')
+
+AddOption('--mutation',
+          action='store_true',
+          help='generate mutation-ready code')
+
 AddOption('--minimal',
           action='store_false',
           dest='extras',
-          default=os.path.exists(File('#.gitattributes').abspath), # minimal by default on release branch (where there's no LFS)
+          default=os.path.exists(File('#.lfsconfig').abspath), # minimal by default on release branch (where there's no LFS)
           help='the minimum build to run openpilot. no tests, tools, etc.')
 
-# Detect platform
-arch = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()
+AddOption('--stock-ui',
+          action='store_true',
+          dest='stock_ui',
+          default=False,
+          help='Build stock openpilot UI instead of sunnypilot UI')
+
+## Architecture name breakdown (arch)
+## - larch64: linux tici aarch64
+## - aarch64: linux pc aarch64
+## - x86_64:  linux pc x64
+## - Darwin:  mac x64 or arm64
+real_arch = arch = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()
 if platform.system() == "Darwin":
   arch = "Darwin"
   brew_prefix = subprocess.check_output(['brew', '--prefix'], encoding='utf8').strip()
-elif arch == "aarch64" and os.path.isfile('/TICI'):
+elif arch == "aarch64" and AGNOS:
   arch = "larch64"
-assert arch in [
-  "larch64",  # linux tici arm64
-  "aarch64",  # linux pc arm64
-  "x86_64",   # linux pc x64
-  "Darwin",   # macOS arm64 (x86 not supported)
-]
+assert arch in ["larch64", "aarch64", "x86_64", "Darwin"]
+
+lenv = {
+  "PATH": os.environ['PATH'],
+  "PYTHONPATH": Dir("#").abspath + ':' + Dir(f"#third_party/acados").abspath,
+
+  "ACADOS_SOURCE_DIR": Dir("#third_party/acados").abspath,
+  "ACADOS_PYTHON_INTERFACE_PATH": Dir("#third_party/acados/acados_template").abspath,
+  "TERA_PATH": Dir("#").abspath + f"/third_party/acados/{arch}/t_renderer"
+}
+
+rpath = []
+
+if arch == "larch64":
+  cpppath = [
+    "#third_party/opencl/include",
+  ]
+
+  libpath = [
+    "/usr/local/lib",
+    "/system/vendor/lib64",
+    f"#third_party/acados/{arch}/lib",
+  ]
+
+  libpath += [
+    "#third_party/snpe/larch64",
+    "#third_party/libyuv/larch64/lib",
+    "/usr/lib/aarch64-linux-gnu"
+  ]
+  cflags = ["-DQCOM2", "-mcpu=cortex-a57"]
+  cxxflags = ["-DQCOM2", "-mcpu=cortex-a57"]
+  rpath += ["/usr/local/lib"]
+else:
+  cflags = []
+  cxxflags = []
+  cpppath = []
+  rpath += []
+
+  # MacOS
+  if arch == "Darwin":
+    libpath = [
+      f"#third_party/libyuv/{arch}/lib",
+      f"#third_party/acados/{arch}/lib",
+      f"{brew_prefix}/lib",
+      f"{brew_prefix}/opt/openssl@3.0/lib",
+      "/System/Library/Frameworks/OpenGL.framework/Libraries",
+    ]
+
+    cflags += ["-DGL_SILENCE_DEPRECATION"]
+    cxxflags += ["-DGL_SILENCE_DEPRECATION"]
+    cpppath += [
+      f"{brew_prefix}/include",
+      f"{brew_prefix}/opt/openssl@3.0/include",
+    ]
+  # Linux
+  else:
+    libpath = [
+      f"#third_party/acados/{arch}/lib",
+      f"#third_party/libyuv/{arch}/lib",
+      "/usr/lib",
+      "/usr/local/lib",
+    ]
+
+    if arch == "x86_64":
+      libpath += [
+        f"#third_party/snpe/{arch}"
+      ]
+      rpath += [
+        Dir(f"#third_party/snpe/{arch}").abspath,
+      ]
+
+if GetOption('asan'):
+  ccflags = ["-fsanitize=address", "-fno-omit-frame-pointer"]
+  ldflags = ["-fsanitize=address"]
+elif GetOption('ubsan'):
+  ccflags = ["-fsanitize=undefined"]
+  ldflags = ["-fsanitize=undefined"]
+else:
+  ccflags = []
+  ldflags = []
+
+# no --as-needed on mac linker
+if arch != "Darwin":
+  ldflags += ["-Wl,--as-needed", "-Wl,--no-undefined"]
+
+if not GetOption('stock_ui'):
+  cflags += ["-DSUNNYPILOT"]
+  cxxflags += ["-DSUNNYPILOT"]
+
+ccflags_option = GetOption('ccflags')
+if ccflags_option:
+  ccflags += ccflags_option.split(' ')
 
 env = Environment(
-  ENV={
-    "PATH": os.environ['PATH'],
-    "PYTHONPATH": Dir("#").abspath + ':' + Dir(f"#third_party/acados").abspath,
-    "ACADOS_SOURCE_DIR": Dir("#third_party/acados").abspath,
-    "ACADOS_PYTHON_INTERFACE_PATH": Dir("#third_party/acados/acados_template").abspath,
-    "TERA_PATH": Dir("#").abspath + f"/third_party/acados/{arch}/t_renderer"
-  },
-  CC='clang',
-  CXX='clang++',
+  ENV=lenv,
   CCFLAGS=[
     "-g",
     "-fPIC",
@@ -61,32 +185,37 @@ env = Environment(
     "-Wno-c99-designator",
     "-Wno-reorder-init-list",
     "-Wno-vla-cxx-extension",
-  ],
-  CFLAGS=["-std=gnu11"],
-  CXXFLAGS=["-std=c++1z"],
-  CPPPATH=[
+  ] + cflags + ccflags,
+
+  CPPPATH=cpppath + [
     "#",
-    "#msgq",
-    "#third_party",
-    "#third_party/json11",
-    "#third_party/linux/include",
     "#third_party/acados/include",
     "#third_party/acados/include/blasfeo/include",
     "#third_party/acados/include/hpipm/include",
     "#third_party/catch2/include",
     "#third_party/libyuv/include",
+    "#third_party/json11",
+    "#third_party/linux/include",
     "#third_party/snpe/include",
+    "#third_party",
+    "#msgq",
   ],
-  LIBPATH=[
-    "#common",
+
+  CC='clang',
+  CXX='clang++',
+  LINKFLAGS=ldflags,
+
+  RPATH=rpath,
+
+  CFLAGS=["-std=gnu11"] + cflags,
+  CXXFLAGS=["-std=c++1z"] + cxxflags,
+  LIBPATH=libpath + [
     "#msgq_repo",
     "#third_party",
     "#selfdrive/pandad",
+    "#common",
     "#rednose/helpers",
-    f"#third_party/libyuv/{arch}/lib",
-    f"#third_party/acados/{arch}/lib",
   ],
-  RPATH=[],
   CYTHONCFILESUFFIX=".cpp",
   COMPILATIONDB_USE_ABSPATH=True,
   REDNOSE_ROOT="#",
@@ -94,72 +223,30 @@ env = Environment(
   toolpath=["#site_scons/site_tools", "#rednose_repo/site_scons/site_tools"],
 )
 
-# Arch-specific flags and paths
-if arch == "larch64":
-  env.Append(CPPPATH=["#third_party/opencl/include"])
-  env.Append(LIBPATH=[
-    "/usr/local/lib",
-    "/system/vendor/lib64",
-    "/usr/lib/aarch64-linux-gnu",
-    "#third_party/snpe/larch64",
-  ])
-  arch_flags = ["-D__TICI__", "-mcpu=cortex-a57", "-DQCOM2"]
-  env.Append(CCFLAGS=arch_flags)
-  env.Append(CXXFLAGS=arch_flags)
-elif arch == "Darwin":
-  env.Append(LIBPATH=[
-    f"{brew_prefix}/lib",
-    f"{brew_prefix}/opt/openssl@3.0/lib",
-    f"{brew_prefix}/opt/llvm/lib/c++",
-    "/System/Library/Frameworks/OpenGL.framework/Libraries",
-  ])
-  env.Append(CCFLAGS=["-DGL_SILENCE_DEPRECATION"])
-  env.Append(CXXFLAGS=["-DGL_SILENCE_DEPRECATION"])
-  env.Append(CPPPATH=[
-    f"{brew_prefix}/include",
-    f"{brew_prefix}/opt/openssl@3.0/include",
-  ])
-else:
-  env.Append(LIBPATH=[
-    "/usr/lib",
-    "/usr/local/lib",
-  ])
+if arch == "Darwin":
+  # RPATH is not supported on macOS, instead use the linker flags
+  darwin_rpath_link_flags = [f"-Wl,-rpath,{path}" for path in env["RPATH"]]
+  env["LINKFLAGS"] += darwin_rpath_link_flags
 
-  if arch == "x86_64":
-    env.Append(LIBPATH=[
-      f"#third_party/snpe/{arch}"
-    ])
-    env.Append(RPATH=[
-      Dir(f"#third_party/snpe/{arch}").abspath,
-    ])
+env.CompilationDatabase('compile_commands.json')
 
-# Sanitizers and extra CCFLAGS from CLI
-if GetOption('asan'):
-  env.Append(CCFLAGS=["-fsanitize=address", "-fno-omit-frame-pointer"])
-  env.Append(LINKFLAGS=["-fsanitize=address"])
-elif GetOption('ubsan'):
-  env.Append(CCFLAGS=["-fsanitize=undefined"])
-  env.Append(LINKFLAGS=["-fsanitize=undefined"])
+# Setup cache dir
+default_cache_dir = '/data/scons_cache' if AGNOS else '/tmp/scons_cache'
+cache_dir = ARGUMENTS.get('cache_dir', default_cache_dir)
+CacheDir(cache_dir)
+Clean(["."], cache_dir)
 
-_extra_cc = shlex.split(GetOption('ccflags') or '')
-if _extra_cc:
-  env.Append(CCFLAGS=_extra_cc)
-
-# no --as-needed on mac linker
-if arch != "Darwin":
-  env.Append(LINKFLAGS=["-Wl,--as-needed", "-Wl,--no-undefined"])
-
-# progress output
 node_interval = 5
 node_count = 0
 def progress_function(node):
   global node_count
   node_count += node_interval
   sys.stderr.write("progress: %d\n" % node_count)
+
 if os.environ.get('SCONS_PROGRESS'):
   Progress(progress_function, interval=node_interval)
 
-# ********** Cython build environment **********
+# Cython build environment
 py_include = sysconfig.get_paths()['include']
 envCython = env.Clone()
 envCython["CPPPATH"] += [py_include, np.get_include()]
@@ -168,27 +255,84 @@ envCython["CCFLAGS"].remove("-Werror")
 
 envCython["LIBS"] = []
 if arch == "Darwin":
-  envCython["LINKFLAGS"] = env["LINKFLAGS"] + ["-bundle", "-undefined", "dynamic_lookup"]
+  envCython["LINKFLAGS"] = ["-bundle", "-undefined", "dynamic_lookup"] + darwin_rpath_link_flags
 else:
   envCython["LINKFLAGS"] = ["-pthread", "-shared"]
 
 np_version = SCons.Script.Value(np.__version__)
 Export('envCython', 'np_version')
 
-Export('env', 'arch')
+# Qt build environment
+qt_env = env.Clone()
+qt_modules = ["Widgets", "Gui", "Core", "Network", "Concurrent", "DBus", "Xml"]
 
-# Setup cache dir
-cache_dir = '/data/scons_cache' if arch == "larch64" else '/tmp/scons_cache'
-CacheDir(cache_dir)
-Clean(["."], cache_dir)
+qt_libs = []
+if arch == "Darwin":
+  qt_env['QTDIR'] = f"{brew_prefix}/opt/qt@5"
+  qt_dirs = [
+    os.path.join(qt_env['QTDIR'], "include"),
+  ]
+  qt_dirs += [f"{qt_env['QTDIR']}/include/Qt{m}" for m in qt_modules]
+  qt_env["LINKFLAGS"] += ["-F" + os.path.join(qt_env['QTDIR'], "lib")]
+  qt_env["FRAMEWORKS"] += [f"Qt{m}" for m in qt_modules] + ["OpenGL"]
+  qt_env.AppendENVPath('PATH', os.path.join(qt_env['QTDIR'], "bin"))
+else:
+  qt_install_prefix = subprocess.check_output(['qmake', '-query', 'QT_INSTALL_PREFIX'], encoding='utf8').strip()
+  qt_install_headers = subprocess.check_output(['qmake', '-query', 'QT_INSTALL_HEADERS'], encoding='utf8').strip()
 
-# ********** start building stuff **********
+  qt_env['QTDIR'] = qt_install_prefix
+  qt_dirs = [
+    f"{qt_install_headers}",
+  ]
+
+  qt_gui_path = os.path.join(qt_install_headers, "QtGui")
+  qt_gui_dirs = [d for d in os.listdir(qt_gui_path) if os.path.isdir(os.path.join(qt_gui_path, d))]
+  qt_dirs += [f"{qt_install_headers}/QtGui/{qt_gui_dirs[0]}/QtGui", ] if qt_gui_dirs else []
+  qt_dirs += [f"{qt_install_headers}/Qt{m}" for m in qt_modules]
+
+  qt_libs = [f"Qt5{m}" for m in qt_modules]
+  if arch == "larch64":
+    qt_libs += ["GLESv2", "wayland-client"]
+    qt_env.PrependENVPath('PATH', Dir("#third_party/qt5/larch64/bin/").abspath)
+  elif arch != "Darwin":
+    qt_libs += ["GL"]
+qt_env['QT3DIR'] = qt_env['QTDIR']
+qt_env.Tool('qt3')
+
+qt_env['CPPPATH'] += qt_dirs + ["#third_party/qrcode"]
+qt_flags = [
+  "-D_REENTRANT",
+  "-DQT_NO_DEBUG",
+  "-DQT_WIDGETS_LIB",
+  "-DQT_GUI_LIB",
+  "-DQT_CORE_LIB",
+  "-DQT_MESSAGELOGCONTEXT",
+]
+qt_env['CXXFLAGS'] += qt_flags
+qt_env['LIBPATH'] += ['#selfdrive/ui', ]
+qt_env['LIBS'] = qt_libs
+
+if GetOption("clazy"):
+  checks = [
+    "level0",
+    "level1",
+    "no-range-loop",
+    "no-non-pod-global-static",
+  ]
+  qt_env['CXX'] = 'clazy'
+  qt_env['ENV']['CLAZY_IGNORE_DIRS'] = qt_dirs[0]
+  qt_env['ENV']['CLAZY_CHECKS'] = ','.join(checks)
+
+Export('env', 'qt_env', 'arch', 'real_arch')
 
 # Build common module
 SConscript(['common/SConscript'])
-Import('_common')
+Import('_common', '_gpucommon')
+
 common = [_common, 'json11', 'zmq']
-Export('common')
+gpucommon = [_gpucommon]
+
+Export('common', 'gpucommon')
 
 # Build messaging (cereal + msgq + socketmaster + their dependencies)
 # Enable swaglog include in submodules
@@ -231,5 +375,6 @@ if Dir('#tools/cabana/').exists() and GetOption('extras'):
   if arch != "larch64":
     SConscript(['tools/cabana/SConscript'])
 
-
-env.CompilationDatabase('compile_commands.json')
+external_sconscript = GetOption('external_sconscript')
+if external_sconscript:
+  SConscript([external_sconscript])

cereal/custom.capnp

@@ -369,7 +369,6 @@ struct CarControlSP @0xa5cd762cd951a455 {
   leadOne @2 :LeadData;
   leadTwo @3 :LeadData;
   intelligentCruiseButtonManagement @4 :IntelligentCruiseButtonManagement;
-  speed @5 :Float32;
 
   struct Param {
     key @0 :Text;
@@ -455,20 +454,7 @@ struct ModelDataV2SP @0xa1680744031fdb2d {
   }
 }
 
-struct Navigationd @0xcb9fd56c7057593a {
-  upcomingTurn @0 :Text;
-  currentSpeedLimit @1 :UInt16;
-  bannerInstructions @2 :Text;
-  distanceFromRoute @3 :Float32;
-  allManeuvers @4 :List(Maneuver);
-  valid @5 :Bool;
-
-  struct Maneuver {
-    distance @0 :Float32;
-    type @1 :Text;
-    modifier @2 :Text;
-    instruction @3 :Text;
-  }
+struct CustomReserved10 @0xcb9fd56c7057593a {
 }
 
 struct CustomReserved11 @0xc2243c65e0340384 {

cereal/log.capnp

@@ -918,8 +918,6 @@ struct ControlsState @0x97ff69c53601abf1 {
     saturated @7 :Bool;
     actualLateralAccel @9 :Float32;
     desiredLateralAccel @10 :Float32;
-    desiredLateralJerk @11 :Float32;
-    version @12 :Int32;
    }
 
   struct LateralLQRState {
@@ -2148,10 +2146,13 @@ struct Joystick {
 struct DriverStateV2 {
   frameId @0 :UInt32;
   modelExecutionTime @1 :Float32;
+  dspExecutionTimeDEPRECATED @2 :Float32;
   gpuExecutionTime @8 :Float32;
   rawPredictions @3 :Data;
 
+  poorVisionProb @4 :Float32;
   wheelOnRightProb @5 :Float32;
+
   leftDriverData @6 :DriverData;
   rightDriverData @7 :DriverData;
 
@@ -2166,13 +2167,10 @@ struct DriverStateV2 {
     leftBlinkProb @7 :Float32;
     rightBlinkProb @8 :Float32;
     sunglassesProb @9 :Float32;
+    occludedProb @10 :Float32;
+    readyProb @11 :List(Float32);
     notReadyProb @12 :List(Float32);
-    occludedProbDEPRECATED @10 :Float32;
-    readyProbDEPRECATED @11 :List(Float32);
   }
-
-  dspExecutionTimeDEPRECATED @2 :Float32;
-  poorVisionProbDEPRECATED @4 :Float32;
 }
 
 struct DriverStateDEPRECATED @0xb83c6cc593ed0a00 {
@@ -2224,7 +2222,6 @@ struct DriverMonitoringState @0xb83cda094a1da284 {
   hiStdCount @14 :UInt32;
   isActiveMode @16 :Bool;
   isRHD @4 :Bool;
-  uncertainCount @19 :UInt32;
 
   isPreviewDEPRECATED @15 :Bool;
   rhdCheckedDEPRECATED @5 :Bool;
@@ -2635,7 +2632,7 @@ struct Event {
     carStateSP @114 :Custom.CarStateSP;
     liveMapDataSP @115 :Custom.LiveMapDataSP;
     modelDataV2SP @116 :Custom.ModelDataV2SP;
-    navigationd @136 :Custom.Navigationd;
+    customReserved10 @136 :Custom.CustomReserved10;
     customReserved11 @137 :Custom.CustomReserved11;
     customReserved12 @138 :Custom.CustomReserved12;
     customReserved13 @139 :Custom.CustomReserved13;

cereal/services.py

@@ -89,7 +89,6 @@ _services: dict[str, tuple] = {
   "carStateSP": (True, 100., 10),
   "liveMapDataSP": (True, 1., 1),
   "modelDataV2SP": (True, 20.),
-  "navigationd": (True, 3.),
   "liveLocationKalman": (True, 20.),
 
   # debug

common/SConscript

@@ -4,12 +4,18 @@ common_libs = [
   'params.cc',
   'swaglog.cc',
   'util.cc',
-  'ratekeeper.cc',
-  'clutil.cc',
+  'watchdog.cc',
+  'ratekeeper.cc'
 ]
 
 _common = env.Library('common', common_libs, LIBS="json11")
-Export('_common')
+
+files = [
+  'clutil.cc',
+]
+
+_gpucommon = env.Library('gpucommon', files)
+Export('_common', '_gpucommon')
 
 if GetOption('extras'):
   env.Program('tests/test_common',

common/api/__init__.py

@@ -14,13 +14,9 @@ class Api:
   def post(self, *args, **kwargs):
     return self.service.post(*args, **kwargs)
 
-  def get_token(self, payload_extra=None, expiry_hours=1):
-    return self.service.get_token(payload_extra, expiry_hours)
+  def get_token(self, expiry_hours=1):
+    return self.service.get_token(expiry_hours)
 
 
 def api_get(endpoint, method='GET', timeout=None, access_token=None, **params):
   return CommaConnectApi(None).api_get(endpoint, method, timeout, access_token, **params)
-
-
-def get_key_pair():
-  return CommaConnectApi(None).get_key_pair()

common/api/base.py

@@ -1,22 +1,18 @@
 import jwt
-import os
 import requests
 import unicodedata
 from datetime import datetime, timedelta, UTC
 from openpilot.system.hardware.hw import Paths
 from openpilot.system.version import get_version
 
-       # name : jwt signature algorithm
-KEYS = {"id_rsa" : "RS256",
-        "id_ecdsa" : "ES256"}
-
 
 class BaseApi:
   def __init__(self, dongle_id, api_host, user_agent="openpilot-"):
     self.dongle_id = dongle_id
     self.api_host = api_host
     self.user_agent = user_agent
-    self.jwt_algorithm, self.private_key, _ = self.get_key_pair()
+    with open(f'{Paths.persist_root()}/comma/id_rsa') as f:
+      self.private_key = f.read()
 
   def get(self, *args, **kwargs):
     return self.request('GET', *args, **kwargs)
@@ -27,7 +23,7 @@ class BaseApi:
   def request(self, method, endpoint, timeout=None, access_token=None, **params):
     return self.api_get(endpoint, method=method, timeout=timeout, access_token=access_token, **params)
 
-  def _get_token(self, payload_extra=None, expiry_hours=1, **extra_payload):
+  def _get_token(self, expiry_hours=1, **extra_payload):
     now = datetime.now(UTC).replace(tzinfo=None)
     payload = {
       'identity': self.dongle_id,
@@ -36,15 +32,13 @@ class BaseApi:
       'exp': now + timedelta(hours=expiry_hours),
       **extra_payload
     }
-    if payload_extra is not None:
-      payload.update(payload_extra)
-    token = jwt.encode(payload, self.private_key, algorithm=self.jwt_algorithm)
+    token = jwt.encode(payload, self.private_key, algorithm='RS256')
     if isinstance(token, bytes):
       token = token.decode('utf8')
     return token
 
-  def get_token(self, payload_extra=None, expiry_hours=1):
-    return self._get_token(payload_extra, expiry_hours)
+  def get_token(self, expiry_hours=1):
+    return self._get_token(expiry_hours)
 
   def remove_non_ascii_chars(self, text):
     normalized_text = unicodedata.normalize('NFD', text)
@@ -60,11 +54,3 @@ class BaseApi:
     headers['User-Agent'] = self.user_agent + version
 
     return requests.request(method, f"{self.api_host}/{endpoint}", timeout=timeout, headers=headers, json=json, params=params)
-
-  @staticmethod
-  def get_key_pair():
-    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'):
-        with open(Paths.persist_root() + f'/comma/{key}') as private, open(Paths.persist_root() + f'/comma/{key}.pub') as public:
-          return KEYS[key], private.read(), public.read()
-    return None, None, None

common/dict_helpers.py

@@ -0,0 +1,9 @@
+# remove all keys that end in DEPRECATED
+def strip_deprecated_keys(d):
+  for k in list(d.keys()):
+    if isinstance(k, str):
+      if k.endswith('DEPRECATED'):
+        d.pop(k)
+      elif isinstance(d[k], dict):
+        strip_deprecated_keys(d[k])
+  return d

common/file_helpers.py

@@ -2,14 +2,9 @@ import io
 import os
 import tempfile
 import contextlib
-import subprocess
-import time
-import functools
-from subprocess import Popen, PIPE, TimeoutExpired
 import zstandard as zstd
-from openpilot.common.swaglog import cloudlog
 
-LOG_COMPRESSION_LEVEL = 10  # little benefit up to level 15. level ~17 is a small step change
+LOG_COMPRESSION_LEVEL = 10 # little benefit up to level 15. level ~17 is a small step change
 
 
 class CallbackReader:
@@ -32,7 +27,7 @@ class CallbackReader:
 
 
 @contextlib.contextmanager
-def atomic_write_in_dir(path: str, mode: str = 'w', buffering: int = -1, encoding: str | None = None, newline: str | None = None,
+def atomic_write_in_dir(path: str, mode: str = 'w', buffering: int = -1, encoding: str = None, newline: str = None,
                         overwrite: bool = False):
   """Write to a file atomically using a temporary file in the same directory as the destination file."""
   dir_name = os.path.dirname(path)
@@ -61,58 +56,3 @@ def get_upload_stream(filepath: str, should_compress: bool) -> tuple[io.Buffered
     compressed_size = compressed_stream.tell()
     compressed_stream.seek(0)
     return compressed_stream, compressed_size
-
-
-# remove all keys that end in DEPRECATED
-def strip_deprecated_keys(d):
-  for k in list(d.keys()):
-    if isinstance(k, str):
-      if k.endswith('DEPRECATED'):
-        d.pop(k)
-      elif isinstance(d[k], dict):
-        strip_deprecated_keys(d[k])
-  return d
-
-
-def run_cmd(cmd: list[str], cwd=None, env=None) -> str:
-  return subprocess.check_output(cmd, encoding='utf8', cwd=cwd, env=env).strip()
-
-
-def run_cmd_default(cmd: list[str], default: str = "", cwd=None, env=None) -> str:
-  try:
-    return run_cmd(cmd, cwd=cwd, env=env)
-  except subprocess.CalledProcessError:
-    return default
-
-
-@contextlib.contextmanager
-def managed_proc(cmd: list[str], env: dict[str, str]):
-  proc = Popen(cmd, env=env, stdout=PIPE, stderr=PIPE)
-  try:
-    yield proc
-  finally:
-    if proc.poll() is None:
-      proc.terminate()
-    try:
-      proc.wait(timeout=5)
-    except TimeoutExpired:
-      proc.kill()
-
-
-def retry(attempts=3, delay=1.0, ignore_failure=False):
-  def decorator(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-      for _ in range(attempts):
-        try:
-          return func(*args, **kwargs)
-        except Exception:
-          cloudlog.exception(f"{func.__name__} failed, trying again")
-          time.sleep(delay)
-
-      if ignore_failure:
-        cloudlog.error(f"{func.__name__} failed after retry")
-      else:
-        raise Exception(f"{func.__name__} failed after retry")
-    return wrapper
-  return decorator

common/git.py

@@ -1,6 +1,6 @@
 from functools import cache
 import subprocess
-from openpilot.common.utils import run_cmd, run_cmd_default
+from openpilot.common.run import run_cmd, run_cmd_default
 
 
 @cache

common/model.h

@@ -1 +1 @@
-#define DEFAULT_MODEL "The Cool People (Default)"
+#define DEFAULT_MODEL "TCPv3 + gWMv9 (Default)"

common/params_keys.h

@@ -66,7 +66,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"IsTakingSnapshot", {CLEAR_ON_MANAGER_START, BOOL}},
     {"IsTestedBranch", {CLEAR_ON_MANAGER_START, BOOL}},
     {"JoystickDebugMode", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},
-    {"LanguageSetting", {PERSISTENT | BACKUP, STRING, "en"}},
+    {"LanguageSetting", {PERSISTENT | BACKUP, STRING, "main_en"}},
     {"LastAthenaPingTime", {CLEAR_ON_MANAGER_START, INT}},
     {"LastGPSPosition", {PERSISTENT, STRING}},
     {"LastManagerExitReason", {CLEAR_ON_MANAGER_START, STRING}},
@@ -97,7 +97,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"Offroad_TemperatureTooHigh", {CLEAR_ON_MANAGER_START, JSON}},
     {"Offroad_UnregisteredHardware", {CLEAR_ON_MANAGER_START, JSON}},
     {"Offroad_UpdateFailed", {CLEAR_ON_MANAGER_START, JSON}},
-    {"Offroad_DriverMonitoringUncertain", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
     {"OnroadCycleRequested", {CLEAR_ON_MANAGER_START, BOOL}},
     {"OpenpilotEnabledToggle", {PERSISTENT | BACKUP, BOOL, "1"}},
     {"PandaHeartbeatLost", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},
@@ -109,7 +108,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"RecordFront", {PERSISTENT | BACKUP, BOOL}},
     {"RecordFrontLock", {PERSISTENT, BOOL}},  // for the internal fleet
     {"SecOCKey", {PERSISTENT | DONT_LOG | BACKUP, STRING}},
-    {"ShowDebugInfo", {PERSISTENT, BOOL}},
     {"RouteCount", {PERSISTENT, INT, "0"}},
     {"SnoozeUpdate", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},
     {"SshEnabled", {PERSISTENT | BACKUP, BOOL}},
@@ -173,7 +171,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ShowAdvancedControls", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"sunnypilot_ui", {PERSISTENT, BOOL, "1"}},
     {"TrueVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},
 
     // MADS params
@@ -190,15 +187,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
     {"ModelManager_ModelsCache", {PERSISTENT | BACKUP, JSON}},
 
-    // Navigation params
-    {"AllowNavigation", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"MapboxFavorites", {PERSISTENT | BACKUP, STRING}},
-    {"MapboxToken", {PERSISTENT | BACKUP, STRING}},
-    {"MapboxSettings", {CLEAR_ON_MANAGER_START, JSON}},
-    {"MapboxRoute", {PERSISTENT, STRING}},
-    {"MapboxRecompute", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"NavDesiresAllowed", {PERSISTENT | BACKUP, BOOL, "0"}},
-
     // Neural Network Lateral Control
     {"NeuralNetworkLateralControl", {PERSISTENT | BACKUP, BOOL, "0"}},
 

common/pid.py

@@ -2,10 +2,11 @@ import numpy as np
 from numbers import Number
 
 class PIDController:
-  def __init__(self, k_p, k_i, k_d=0., pos_limit=1e308, neg_limit=-1e308, rate=100):
+  def __init__(self, k_p, k_i, k_f=0., k_d=0., pos_limit=1e308, neg_limit=-1e308, rate=100):
     self._k_p = k_p
     self._k_i = k_i
     self._k_d = k_d
+    self.k_f = k_f   # feedforward gain
     if isinstance(self._k_p, Number):
       self._k_p = [[0], [self._k_p]]
     if isinstance(self._k_i, Number):
@@ -15,7 +16,7 @@ class PIDController:
 
     self.set_limits(pos_limit, neg_limit)
 
-    self.i_dt = 1.0 / rate
+    self.i_rate = 1.0 / rate
     self.speed = 0.0
 
     self.reset()
@@ -45,12 +46,12 @@ class PIDController:
 
   def update(self, error, error_rate=0.0, speed=0.0, feedforward=0., freeze_integrator=False):
     self.speed = speed
-    self.p = self.k_p * float(error)
-    self.d = self.k_d * error_rate
-    self.f = feedforward
+    self.p = float(error) * self.k_p
+    self.f = feedforward * self.k_f
+    self.d = error_rate * self.k_d
 
     if not freeze_integrator:
-      i = self.i + self.k_i * self.i_dt * error
+      i = self.i + error * self.k_i * self.i_rate
 
       # Don't allow windup if already clipping
       test_control = self.p + i + self.d + self.f

common/retry.py

@@ -0,0 +1,30 @@
+import time
+import functools
+
+from openpilot.common.swaglog import cloudlog
+
+
+def retry(attempts=3, delay=1.0, ignore_failure=False):
+  def decorator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      for _ in range(attempts):
+        try:
+          return func(*args, **kwargs)
+        except Exception:
+          cloudlog.exception(f"{func.__name__} failed, trying again")
+          time.sleep(delay)
+
+      if ignore_failure:
+        cloudlog.error(f"{func.__name__} failed after retry")
+      else:
+        raise Exception(f"{func.__name__} failed after retry")
+    return wrapper
+  return decorator
+
+
+if __name__ == "__main__":
+  @retry(attempts=10)
+  def abc():
+    raise ValueError("abc failed :(")
+  abc()

common/run.py

@@ -0,0 +1,28 @@
+import subprocess
+from contextlib import contextmanager
+from subprocess import Popen, PIPE, TimeoutExpired
+
+
+def run_cmd(cmd: list[str], cwd=None, env=None) -> str:
+  return subprocess.check_output(cmd, encoding='utf8', cwd=cwd, env=env).strip()
+
+
+def run_cmd_default(cmd: list[str], default: str = "", cwd=None, env=None) -> str:
+  try:
+    return run_cmd(cmd, cwd=cwd, env=env)
+  except subprocess.CalledProcessError:
+    return default
+
+
+@contextmanager
+def managed_proc(cmd: list[str], env: dict[str, str]):
+  proc = Popen(cmd, env=env, stdout=PIPE, stderr=PIPE)
+  try:
+    yield proc
+  finally:
+    if proc.poll() is None:
+      proc.terminate()
+    try:
+      proc.wait(timeout=5)
+    except TimeoutExpired:
+      proc.kill()

common/tests/test_file_helpers.py

@@ -1,7 +1,7 @@
 import os
 from uuid import uuid4
 
-from openpilot.common.utils import atomic_write_in_dir
+from openpilot.common.file_helpers import atomic_write_in_dir
 
 
 class TestFileHelpers:

common/version.h

@@ -1 +1 @@
-#define COMMA_VERSION "0.10.2"
+#define COMMA_VERSION "0.10.1"

common/watchdog.cc

@@ -0,0 +1,12 @@
+#include <string>
+
+#include "common/watchdog.h"
+#include "common/util.h"
+#include "system/hardware/hw.h"
+
+const std::string watchdog_fn_prefix = Path::shm_path() + "/wd_";  // + <pid>
+
+bool watchdog_kick(uint64_t ts) {
+  static std::string fn = watchdog_fn_prefix + std::to_string(getpid());
+  return util::write_file(fn.c_str(), &ts, sizeof(ts), O_WRONLY | O_CREAT) > 0;
+}

common/watchdog.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <cstdint>
+
+bool watchdog_kick(uint64_t ts);

common/watchdog.py

@@ -0,0 +1,22 @@
+import os
+import time
+import struct
+from openpilot.system.hardware.hw import Paths
+
+WATCHDOG_FN = f"{Paths.shm_path()}/wd_"
+_LAST_KICK = 0.0
+
+def kick_watchdog():
+  global _LAST_KICK
+  current_time = time.monotonic()
+
+  if current_time - _LAST_KICK < 1.0:
+    return
+
+  try:
+    with open(f"{WATCHDOG_FN}{os.getpid()}", 'wb') as f:
+      f.write(struct.pack('<Q', int(current_time * 1e9)))
+      f.flush()
+    _LAST_KICK = current_time
+  except OSError:
+    pass

docs/car-porting/car-state-signals.md

@@ -1,65 +0,0 @@
-# CarState signals
-
-## Required for basic lateral control
-
-* `brakePressed`
-* `cruiseState`
-* `doorOpen`
-* `espDisabled`
-* `gasPressed`
-* `gearShifter`
-* `leftBlinker` / `rightBlinker`
-* `seatbeltUnlatched`
-* `standstill`
-* `steeringAngleDeg`
-* `steeringPressed`
-* `steeringTorque`
-* `steerFaultPermanent`
-* `steerFaultTemporary`
-* `vCruise`
-* `wheelSpeeds.[fl|fr|rl|rr]`: Speed of each of the car's four wheels, in m/s. The car's CAN bus often broadcasts the
-speed in kph, so the helper function `parse_wheel_speeds` performs this conversion by default.
-
-## Recommended / Required for openpilot longitudinal control
-
-* `accFaulted`
-* `espActive`
-* `parkingBrake`
-
-## Application Dependent
-
-* `blockPcmEnable`
-* `buttonEnable`
-* `brakeHoldActive`
-* `carFaultedNonCritical`
-* `invalidLkasSetting`
-* `lowSpeedAlert`
-* `regenBraking`
-* `steeringAngleOffsetDeg`
-* `steeringDisengage`
-* `steeringTorqueEps`
-* `stockLkas`
-* `vCruiseCluster`
-* `vEgoCluster`
-* `vehicleSensorsInvalid`
-
-## Automatically populated
-
-* `buttonEvents`
-
-These values are populated automatically by `parse_wheel_speeds`:
-
-* `aEgo`: Acceleration of the ego vehicle, Kalman filtered derivative of `vEgo`.
-* `vEgo`: Speed of the ego vehicle, Kalman filtered from `vEgoRaw`.
-* `vEgoRaw`: Speed of the ego vehicle, based on the average of all four wheel speeds, unfiltered.
-
-## Optional
-
-* `brake`
-* `charging`
-* `fuelGauge`
-* `leftBlindspot` / `rightBlindspot`
-* `steeringRateDeg`
-* `stockAeb`
-* `stockFcw`
-* `yawRate`

docs/car-porting/reverse-engineering.md

@@ -1,85 +0,0 @@
-# Stimulus-Response Tests
-
-These are example test drives that can help identify the CAN bus messaging necessary for ADAS control. Each scripted
-test should be done in a separate route (ignition cycle). These tests are a guide, not necessarily exhaustive.
-
-While testing, constant power to the comma device is highly recommended, using [comma power](https://comma.ai/shop/comma-power) if
-necessary to make sure all test activity is fully captured and for ease of uploading. If constant power isn't
-available, keep the ignition on for at least one minute after your test to make sure power loss doesn't result
-in loss of the last minute of testing data.
-
-## Stationary ignition-only tests, part 1
-
-1. Ignition on, but don't start engine, remain in Park
-2. Open and close each door in a defined order: driver, passenger, rear left, rear right
-3. Re-enter the vehicle, close the driver's door, and fasten the driver's seatbelt
-4. Slowly press and release the accelerator pedal 3 times
-5. Slowly press and release the brake pedal 3 times
-6. Hold the brake and move the gearshift to reverse, then neutral, then drive, then sport/eco/etc if applicable
-7. Return to Park, ignition off
-
-Brake-pressed information may show up in several messages and signals, both as on/off states and as a percentage or
-pressure. It may reflect a switch on the driver's brake pedal, or a pressure-threshold state, or signals to turn on
-the rear brake lights. Start by identifying all the potential signals, and confirm while driving with ACC later.
-
-Locate signals for all four door states if possible, but some cars only expose the driver's door state on the ADAS bus.
-Driver/passenger door signals may or may not change positions for LHD vs RHD cars. For cars where only the driver's
-door signal is available, the same signal may follow the driver.
-
-## Stationary ignition-only tests, part 2
-
-1. Ignition on, but don't start engine, remain in Park
-2. Press each ACC button in a defined order: main switch on/off, set, resume, cancel, accel, decel, gap adjust
-3. Set the left turn signal for about five seconds
-4. Operate the left turn signal one time in its touch-to-pass mode
-5. Set the right turn signal for about five seconds
-6. Operate the right turn signal one time in its touch-to-pass mode
-7. Set the hazard / emergency indicator switch for about five seconds
-8. Ignition off
-
-Your vehicle may have a momentary-press main ACC switch or a physical toggle that remains set. Actual ACC engagement
-isn't necessary for purposes of detecting the ACC button presses.
-
-## Steering angle and steering torque tests
-
-Power steering should be available. On ICE cars, engine RPM may be present.
-
-1. Ignition on, start engine if applicable, remain in Park
-2. Rotate the steering wheel as follows, with a few seconds pause between each step
-   * Start as close to exact center as possible
-   * Turn to 45 degrees right and hold
-   * Turn to 90 degrees right and hold
-   * Turn to 180 degrees right and hold
-   * Turn to full lock right and hold, with firm pressure against lock
-   * Release the wheel and allow it to bounce back slightly from lock
-   * Turn to 180 degrees left and hold
-   * Return to center and release
-3. Ignition off
-
-Performing the full test to the right, followed by an abbreviated test to the left, helps give additional confirmation
-of signal scale, and sign/direction for both the steering wheel angle and driver input torque signals.
-
-## Low speed / parking lot driving tests
-
-Before this test, drive to a place like an empty parking lot where you are free to drive in a series of curves.
-
-1. Ignition on, start engine if applicable, prepare to drive
-2. Slowly (10-20mph at most) drive a figure-8 if possible, or at least one sharp left and one sharp right.
-3. Come to a complete stop
-4. When and where safe, drive in reverse for a short distance (10-15 feet)
-5. Park the car in a safe place, ignition off
-
-## High speed / highway driving tests
-
-Select a place and time where you can safely set cruise control at normal travel speeds with little interference from
-traffic ahead, and safely test the response of your factory lane guidance system.
-
-1. Ignition on, start engine if applicable, prepare to drive
-2. When safely able, engage adaptive cruise control below 50 mph
-3. When safely able, use the ACC buttons to accelerate to 50mph, then 55mph, then 60mph
-4. Disengage adaptive cruise
-5. When safely able, allow your factory lane guidance to prevent lane departures, 2-3 times on both the left and right
-
-The series of setpoints can be adjusted to local traffic regulations, and of course metric units. The specific cruise
-setpoints are useful for locating the ACC HUD signals later, and confirming their precise scaling. When the car reaches
-and holds the setpoint, that can also provide additional confirmation of wheel speed scaling.

launch_env.sh

@@ -6,17 +6,8 @@ export NUMEXPR_NUM_THREADS=1
 export OPENBLAS_NUM_THREADS=1
 export VECLIB_MAXIMUM_THREADS=1
 
-# models get lower priority than ui
-# - ui is ~5ms
-# - modeld is 20ms
-# - DM is 10ms
-# in order to run ui at 60fps (16.67ms), we need to allow
-# it to preempt the model workloads. we have enough
-# headroom for this until ui is moved to the CPU.
-export QCOM_PRIORITY=12
-
 if [ -z "$AGNOS_VERSION" ]; then
-  export AGNOS_VERSION="15"
+  export AGNOS_VERSION="13.1"
 fi
 
 export STAGING_ROOT="/data/safe_staging"

pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
   # core
   "cffi",
   "scons",
-  "pycapnp==2.1.0",
+  "pycapnp",
   "Cython",
   "setuptools",
   "numpy >=2.0",
@@ -72,9 +72,7 @@ dependencies = [
   "zstandard",
 
   # ui
-  "raylib < 5.5.0.3", # TODO: unpin when they fix https://github.com/electronstudio/raylib-python-cffi/issues/186
   "qrcode",
-  "mapbox-earcut",
 ]
 
 [project.optional-dependencies]
@@ -121,6 +119,7 @@ dev = [
   "tabulate",
   "types-requests",
   "types-tabulate",
+  "raylib",
 ]
 
 tools = [
@@ -178,7 +177,7 @@ quiet-level = 3
 # if you've got a short variable name that's getting flagged, add it here
 ignore-words-list = "bu,ro,te,ue,alo,hda,ois,nam,nams,ned,som,parm,setts,inout,warmup,bumb,nd,sie,preints,whit,indexIn,ws,uint,grey,deque,stdio,amin,BA,LITE,atEnd,UIs,errorString,arange,FocusIn,od,tim,relA,hist,copyable,jupyter,thead,TGE,abl,lite"
 builtin = "clear,rare,informal,code,names,en-GB_to_en-US"
-skip = "./third_party/*, ./tinygrad/*, ./tinygrad_repo/*, ./msgq/*, ./panda/*, ./opendbc/*, ./opendbc_repo/*, ./rednose/*, ./rednose_repo/*, ./teleoprtc/*, ./teleoprtc_repo/*, *.po, uv.lock, *.onnx, ./cereal/gen/*, */c_generated_code/*, docs/assets/*, tools/plotjuggler/layouts/*"
+skip = "./third_party/*, ./tinygrad/*, ./tinygrad_repo/*, ./msgq/*, ./panda/*, ./opendbc/*, ./opendbc_repo/*, ./rednose/*, ./rednose_repo/*, ./teleoprtc/*, ./teleoprtc_repo/*, *.ts, uv.lock, *.onnx, ./cereal/gen/*, */c_generated_code/*, docs/assets/*, tools/plotjuggler/layouts/*"
 
 [tool.mypy]
 python_version = "3.11"
@@ -236,6 +235,7 @@ lint.ignore = [
   "B027",
   "B024",
   "NPY002",  # new numpy random syntax is worse
+  "UP038",   # (x, y) -> x|y for isinstance
 ]
 line-length = 160
 target-version ="py311"
@@ -263,13 +263,8 @@ lint.flake8-implicit-str-concat.allow-multiline = false
 "tools".msg = "Use openpilot.tools"
 "pytest.main".msg = "pytest.main requires special handling that is easy to mess up!"
 "unittest".msg = "Use pytest"
-"time.time".msg = "Use time.monotonic"
-
-# raylib banned APIs
 "pyray.measure_text_ex".msg = "Use openpilot.system.ui.lib.text_measure"
-"pyray.is_mouse_button_pressed".msg = "This can miss events. Use Widget._handle_mouse_press"
-"pyray.is_mouse_button_released".msg = "This can miss events. Use Widget._handle_mouse_release"
-"pyray.draw_text".msg = "Use a function (such as rl.draw_font_ex) that takes font as an argument"
+"time.time".msg = "Use time.monotonic"
 
 [tool.ruff.format]
 quote-style = "preserve"

release/pack.py

@@ -12,7 +12,7 @@ from openpilot.common.basedir import BASEDIR
 
 
 DIRS = ['cereal', 'openpilot']
-EXTS = ['.png', '.py', '.ttf', '.capnp', '.json', '.fnt', '.mo']
+EXTS = ['.png', '.py', '.ttf', '.capnp']
 INTERPRETER = '/usr/bin/env python3'
 
 

selfdrive/SConscript

@@ -3,4 +3,4 @@ SConscript(['controls/lib/lateral_mpc_lib/SConscript'])
 SConscript(['controls/lib/longitudinal_mpc_lib/SConscript'])
 SConscript(['locationd/SConscript'])
 SConscript(['modeld/SConscript'])
-SConscript(['ui/SConscript'])
+SConscript(['ui/SConscript'])

selfdrive/assets/.gitignore

@@ -1,4 +1,2 @@
 *.cc
-fonts/*.fnt
-fonts/*.png
 translations_assets.qrc

selfdrive/assets/fonts/process.py

@@ -1,128 +0,0 @@
-#!/usr/bin/env python3
-from pathlib import Path
-import json
-
-import pyray as rl
-
-FONT_DIR = Path(__file__).resolve().parent
-SELFDRIVE_DIR = FONT_DIR.parents[1]
-TRANSLATIONS_DIR = SELFDRIVE_DIR / "ui" / "translations"
-LANGUAGES_FILE = TRANSLATIONS_DIR / "languages.json"
-
-GLYPH_PADDING = 6
-EXTRA_CHARS = "–‑✓×°§•€£¥"
-UNIFONT_LANGUAGES = {"ar", "th", "zh-CHT", "zh-CHS", "ko", "ja"}
-
-
-def _languages():
-  if not LANGUAGES_FILE.exists():
-    return {}
-  with LANGUAGES_FILE.open(encoding="utf-8") as f:
-    return json.load(f)
-
-
-def _char_sets():
-  base = set(map(chr, range(32, 127))) | set(EXTRA_CHARS)
-  unifont = set(base)
-
-  for language, code in _languages().items():
-    unifont.update(language)
-    po_path = TRANSLATIONS_DIR / f"app_{code}.po"
-    try:
-      chars = set(po_path.read_text(encoding="utf-8"))
-    except FileNotFoundError:
-      continue
-    (unifont if code in UNIFONT_LANGUAGES else base).update(chars)
-
-  return tuple(sorted(ord(c) for c in base)), tuple(sorted(ord(c) for c in unifont))
-
-
-def _glyph_metrics(glyphs, rects, codepoints):
-  entries = []
-  min_offset_y, max_extent = None, 0
-  for idx, codepoint in enumerate(codepoints):
-    glyph = glyphs[idx]
-    rect = rects[idx]
-    width = int(round(rect.width))
-    height = int(round(rect.height))
-    offset_y = int(round(glyph.offsetY))
-    min_offset_y = offset_y if min_offset_y is None else min(min_offset_y, offset_y)
-    max_extent = max(max_extent, offset_y + height)
-    entries.append({
-      "id": codepoint,
-      "x": int(round(rect.x)),
-      "y": int(round(rect.y)),
-      "width": width,
-      "height": height,
-      "xoffset": int(round(glyph.offsetX)),
-      "yoffset": offset_y,
-      "xadvance": int(round(glyph.advanceX)),
-    })
-
-  if min_offset_y is None:
-    raise RuntimeError("No glyphs were generated")
-
-  line_height = int(round(max_extent - min_offset_y))
-  base = int(round(max_extent))
-  return entries, line_height, base
-
-
-def _write_bmfont(path: Path, font_size: int, face: str, atlas_name: str, line_height: int, base: int, atlas_size, entries):
-  lines = [
-    f"info face=\"{face}\" size=-{font_size} bold=0 italic=0 charset=\"\" unicode=1 stretchH=100 smooth=0 aa=1 padding=0,0,0,0 spacing=0,0 outline=0",
-    f"common lineHeight={line_height} base={base} scaleW={atlas_size[0]} scaleH={atlas_size[1]} pages=1 packed=0 alphaChnl=0 redChnl=4 greenChnl=4 blueChnl=4",
-    f"page id=0 file=\"{atlas_name}\"",
-    f"chars count={len(entries)}",
-  ]
-  for entry in entries:
-    lines.append(
-      ("char id={id:<4} x={x:<5} y={y:<5} width={width:<5} height={height:<5} " +
-       "xoffset={xoffset:<5} yoffset={yoffset:<5} xadvance={xadvance:<5} page=0  chnl=15").format(**entry)
-    )
-  path.write_text("\n".join(lines) + "\n")
-
-
-def _process_font(font_path: Path, codepoints: tuple[int, ...]):
-  print(f"Processing {font_path.name}...")
-
-  font_size = {
-    "unifont.otf": 16,  # unifont is only 16x8 or 16x16 pixels per glyph
-  }.get(font_path.name, 200)
-
-  data = font_path.read_bytes()
-  file_buf = rl.ffi.new("unsigned char[]", data)
-  cp_buffer = rl.ffi.new("int[]", codepoints)
-  cp_ptr = rl.ffi.cast("int *", cp_buffer)
-  glyphs = rl.load_font_data(rl.ffi.cast("unsigned char *", file_buf), len(data), font_size, cp_ptr, len(codepoints), rl.FontType.FONT_DEFAULT)
-  if glyphs == rl.ffi.NULL:
-    raise RuntimeError("raylib failed to load font data")
-
-  rects_ptr = rl.ffi.new("Rectangle **")
-  image = rl.gen_image_font_atlas(glyphs, rects_ptr, len(codepoints), font_size, GLYPH_PADDING, 0)
-  if image.width == 0 or image.height == 0:
-    raise RuntimeError("raylib returned an empty atlas")
-
-  rects = rects_ptr[0]
-  atlas_name = f"{font_path.stem}.png"
-  atlas_path = FONT_DIR / atlas_name
-  entries, line_height, base = _glyph_metrics(glyphs, rects, codepoints)
-
-  if not rl.export_image(image, atlas_path.as_posix()):
-    raise RuntimeError("Failed to export atlas image")
-
-  _write_bmfont(FONT_DIR / f"{font_path.stem}.fnt", font_size, font_path.stem, atlas_name, line_height, base, (image.width, image.height), entries)
-
-
-def main():
-  base_cp, unifont_cp = _char_sets()
-  fonts = sorted(FONT_DIR.glob("*.ttf")) + sorted(FONT_DIR.glob("*.otf"))
-  for font in fonts:
-    if "emoji" in font.name.lower():
-      continue
-    glyphs = unifont_cp if font.stem.lower().startswith("unifont") else base_cp
-    _process_font(font, glyphs)
-  return 0
-
-
-if __name__ == "__main__":
-  raise SystemExit(main())

selfdrive/car/tests/test_car_interfaces.py

@@ -62,8 +62,8 @@ class TestCarInterfaces:
     #  hypothesis also slows down significantly with just one more message draw
     LongControl(car_params, car_params_sp)
     if car_params.steerControlType == CarParams.SteerControlType.angle:
-      LatControlAngle(car_params, car_params_sp, car_interface, DT_CTRL)
+      LatControlAngle(car_params, car_params_sp, car_interface)
     elif car_params.lateralTuning.which() == 'pid':
-      LatControlPID(car_params, car_params_sp, car_interface, DT_CTRL)
+      LatControlPID(car_params, car_params_sp, car_interface)
     elif car_params.lateralTuning.which() == 'torque':
-      LatControlTorque(car_params, car_params_sp, car_interface, DT_CTRL)
+      LatControlTorque(car_params, car_params_sp, car_interface)

selfdrive/car/tests/test_models.py

@@ -189,7 +189,7 @@ class TestCarModelBase(unittest.TestCase):
       if tuning == 'pid':
         self.assertTrue(len(self.CP.lateralTuning.pid.kpV))
       elif tuning == 'torque':
-        self.assertTrue(self.CP.lateralTuning.torque.latAccelFactor > 0)
+        self.assertTrue(self.CP.lateralTuning.torque.kf > 0)
       else:
         raise Exception("unknown tuning")
 

selfdrive/controls/controlsd.py

@@ -8,7 +8,7 @@ from cereal import car, log
 import cereal.messaging as messaging
 from openpilot.common.constants import CV
 from openpilot.common.params import Params
-from openpilot.common.realtime import config_realtime_process, DT_CTRL, Priority, Ratekeeper
+from openpilot.common.realtime import config_realtime_process, Priority, Ratekeeper
 from openpilot.common.swaglog import cloudlog
 
 from opendbc.car.car_helpers import interfaces
@@ -19,7 +19,6 @@ from openpilot.selfdrive.controls.lib.latcontrol_pid import LatControlPID
 from openpilot.selfdrive.controls.lib.latcontrol_angle import LatControlAngle, STEER_ANGLE_SATURATION_THRESHOLD
 from openpilot.selfdrive.controls.lib.latcontrol_torque import LatControlTorque
 from openpilot.selfdrive.controls.lib.longcontrol import LongControl
-from openpilot.selfdrive.modeld.modeld import LAT_SMOOTH_SECONDS
 from openpilot.selfdrive.locationd.helpers import PoseCalibrator, Pose
 
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
@@ -46,7 +45,7 @@ class Controls(ControlsExt, ModelStateBase):
 
     self.CI = interfaces[self.CP.carFingerprint](self.CP, self.CP_SP)
 
-    self.sm = messaging.SubMaster(['liveDelay', 'liveParameters', 'liveTorqueParameters', 'modelV2', 'selfdriveState',
+    self.sm = messaging.SubMaster(['liveParameters', 'liveTorqueParameters', 'modelV2', 'selfdriveState',
                                    'liveCalibration', 'livePose', 'longitudinalPlan', 'carState', 'carOutput',
                                    'driverMonitoringState', 'onroadEvents', 'driverAssistance', 'liveDelay'] + self.sm_services_ext,
                                   poll='selfdriveState')
@@ -63,11 +62,11 @@ class Controls(ControlsExt, ModelStateBase):
     self.VM = VehicleModel(self.CP)
     self.LaC: LatControl
     if self.CP.steerControlType == car.CarParams.SteerControlType.angle:
-      self.LaC = LatControlAngle(self.CP, self.CP_SP, self.CI, DT_CTRL)
+      self.LaC = LatControlAngle(self.CP, self.CP_SP, self.CI)
     elif self.CP.lateralTuning.which() == 'pid':
-      self.LaC = LatControlPID(self.CP, self.CP_SP, self.CI, DT_CTRL)
+      self.LaC = LatControlPID(self.CP, self.CP_SP, self.CI)
     elif self.CP.lateralTuning.which() == 'torque':
-      self.LaC = LatControlTorque(self.CP, self.CP_SP, self.CI, DT_CTRL)
+      self.LaC = LatControlTorque(self.CP, self.CP_SP, self.CI)
 
   def update(self):
     self.sm.update(15)
@@ -140,12 +139,11 @@ class Controls(ControlsExt, ModelStateBase):
     # Reset desired curvature to current to avoid violating the limits on engage
     new_desired_curvature = model_v2.action.desiredCurvature if CC.latActive else self.curvature
     self.desired_curvature, curvature_limited = clip_curvature(CS.vEgo, self.desired_curvature, new_desired_curvature, lp.roll)
-    lat_delay = self.sm["liveDelay"].lateralDelay + LAT_SMOOTH_SECONDS
 
     actuators.curvature = self.desired_curvature
     steer, steeringAngleDeg, lac_log = self.LaC.update(CC.latActive, CS, self.VM, lp,
                                                        self.steer_limited_by_safety, self.desired_curvature,
-                                                       self.calibrated_pose, curvature_limited, lat_delay)
+                                                       self.calibrated_pose, curvature_limited)  # TODO what if not available
     actuators.torque = float(steer)
     actuators.steeringAngleDeg = float(steeringAngleDeg)
     # Ensure no NaNs/Infs

selfdrive/controls/lib/desire_helper.py

@@ -3,7 +3,6 @@ from openpilot.common.constants import CV
 from openpilot.common.realtime import DT_MDL
 from openpilot.sunnypilot.selfdrive.controls.lib.auto_lane_change import AutoLaneChangeController, AutoLaneChangeMode
 from openpilot.sunnypilot.selfdrive.controls.lib.lane_turn_desire import LaneTurnController
-from openpilot.sunnypilot.navd.navigation_desires.navigation_desires import NavigationDesires
 
 LaneChangeState = log.LaneChangeState
 LaneChangeDirection = log.LaneChangeDirection
@@ -52,7 +51,6 @@ class DesireHelper:
     self.alc = AutoLaneChangeController(self)
     self.lane_turn_controller = LaneTurnController(self)
     self.lane_turn_direction = TurnDirection.none
-    self.navigation_desires = NavigationDesires()
 
   @staticmethod
   def get_lane_change_direction(CS):
@@ -145,7 +143,3 @@ class DesireHelper:
         self.desire = log.Desire.none
 
     self.alc.update_state()
-
-    nav_desire = self.navigation_desires.update(carstate, lateral_active)
-    if nav_desire != log.Desire.none and (self.desire == log.Desire.none or self.desire in (log.Desire.turnLeft, log.Desire.turnRight)):
-      self.desire = nav_desire

selfdrive/controls/lib/drive_helpers.py

@@ -22,7 +22,7 @@ def smooth_value(val, prev_val, tau, dt=DT_MDL):
   alpha = 1 - np.exp(-dt/tau) if tau > 0 else 1
   return alpha * val + (1 - alpha) * prev_val
 
-def clip_curvature(v_ego, prev_curvature, new_curvature, roll) -> tuple[float, bool]:
+def clip_curvature(v_ego, prev_curvature, new_curvature, roll):
   # This function respects ISO lateral jerk and acceleration limits + a max curvature
   v_ego = max(v_ego, MIN_SPEED)
   max_curvature_rate = MAX_LATERAL_JERK / (v_ego ** 2)  # inexact calculation, check https://github.com/commaai/openpilot/pull/24755

selfdrive/controls/lib/latcontrol.py

@@ -1,31 +1,31 @@
 import numpy as np
 from abc import abstractmethod, ABC
-from openpilot.selfdrive.locationd.helpers import Pose
+
+from openpilot.common.realtime import DT_CTRL
 
 
 class LatControl(ABC):
-  def __init__(self, CP, CP_SP, CI, dt):
-    self.dt = dt
+  def __init__(self, CP, CP_SP, CI):
+    self.sat_count_rate = 1.0 * DT_CTRL
     self.sat_limit = CP.steerLimitTimer
-    self.sat_time = 0.
+    self.sat_count = 0.
     self.sat_check_min_speed = 10.
 
     # we define the steer torque scale as [-1.0...1.0]
     self.steer_max = 1.0
 
   @abstractmethod
-  def update(self, active: bool, CS, VM, params, steer_limited_by_safety: bool, desired_curvature: float, calibrated_pose: Pose,
-             curvature_limited: bool, lat_delay: float):
+  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
     pass
 
   def reset(self):
-    self.sat_time = 0.
+    self.sat_count = 0.
 
   def _check_saturation(self, saturated, CS, steer_limited_by_safety, curvature_limited):
     # Saturated only if control output is not being limited by car torque/angle rate limits
     if (saturated or curvature_limited) and CS.vEgo > self.sat_check_min_speed and not steer_limited_by_safety and not CS.steeringPressed:
-      self.sat_time += self.dt
+      self.sat_count += self.sat_count_rate
     else:
-      self.sat_time -= self.dt
-    self.sat_time = np.clip(self.sat_time, 0.0, self.sat_limit)
-    return self.sat_time > (self.sat_limit - 1e-3)
+      self.sat_count -= self.sat_count_rate
+    self.sat_count = np.clip(self.sat_count, 0.0, self.sat_limit)
+    return self.sat_count > (self.sat_limit - 1e-3)

selfdrive/controls/lib/latcontrol_angle.py

@@ -8,12 +8,12 @@ STEER_ANGLE_SATURATION_THRESHOLD = 2.5  # Degrees
 
 
 class LatControlAngle(LatControl):
-  def __init__(self, CP, CP_SP, CI, dt):
-    super().__init__(CP, CP_SP, CI, dt)
+  def __init__(self, CP, CP_SP, CI):
+    super().__init__(CP, CP_SP, CI)
     self.sat_check_min_speed = 5.
     self.use_steer_limited_by_safety = CP.brand == "tesla"
 
-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited, lat_delay):
+  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
     angle_log = log.ControlsState.LateralAngleState.new_message()
 
     if not active:

selfdrive/controls/lib/latcontrol_pid.py

@@ -6,15 +6,14 @@ from openpilot.common.pid import PIDController
 
 
 class LatControlPID(LatControl):
-  def __init__(self, CP, CP_SP, CI, dt):
-    super().__init__(CP, CP_SP, CI, dt)
+  def __init__(self, CP, CP_SP, CI):
+    super().__init__(CP, CP_SP, CI)
     self.pid = PIDController((CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV),
                              (CP.lateralTuning.pid.kiBP, CP.lateralTuning.pid.kiV),
-                             pos_limit=self.steer_max, neg_limit=-self.steer_max)
-    self.ff_factor = CP.lateralTuning.pid.kf
+                             k_f=CP.lateralTuning.pid.kf, pos_limit=self.steer_max, neg_limit=-self.steer_max)
     self.get_steer_feedforward = CI.get_steer_feedforward_function()
 
-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited, lat_delay):
+  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
     pid_log = log.ControlsState.LateralPIDState.new_message()
     pid_log.steeringAngleDeg = float(CS.steeringAngleDeg)
     pid_log.steeringRateDeg = float(CS.steeringRateDeg)
@@ -31,7 +30,7 @@ class LatControlPID(LatControl):
 
     else:
       # offset does not contribute to resistive torque
-      ff = self.ff_factor * self.get_steer_feedforward(angle_steers_des_no_offset, CS.vEgo)
+      ff = self.get_steer_feedforward(angle_steers_des_no_offset, CS.vEgo)
       freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5
 
       output_torque = self.pid.update(error,

selfdrive/controls/lib/latcontrol_torque.py

@@ -1,11 +1,9 @@
 import math
 import numpy as np
-from collections import deque
 
 from cereal import log
 from opendbc.car.lateral import FRICTION_THRESHOLD, get_friction
 from openpilot.common.constants import ACCELERATION_DUE_TO_GRAVITY
-from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.selfdrive.controls.lib.latcontrol import LatControl
 from openpilot.common.pid import PIDController
 
@@ -17,34 +15,25 @@ from openpilot.sunnypilot.selfdrive.controls.lib.latcontrol_torque_ext import La
 # wheel slip, or to speed.
 
 # This controller applies torque to achieve desired lateral
-# accelerations. To compensate for the low speed effects the
-# proportional gain is increased at low speeds by the PID controller.
-# Additionally, there is friction in the steering wheel that needs
-# to be overcome to move it at all, this is compensated for too.
+# accelerations. To compensate for the low speed effects we
+# use a LOW_SPEED_FACTOR in the error. Additionally, there is
+# friction in the steering wheel that needs to be overcome to
+# move it at all, this is compensated for too.
 
-KP = 1.0
-KI = 0.3
-KD = 0.0
-INTERP_SPEEDS = [1, 1.5, 2.0, 3.0, 5, 7.5, 10, 15, 30]
-KP_INTERP = [250, 120, 65, 30, 11.5, 5.5, 3.5, 2.0, KP]
+LOW_SPEED_X = [0, 10, 20, 30]
+LOW_SPEED_Y = [15, 13, 10, 5]
 
-LP_FILTER_CUTOFF_HZ = 1.2
-LAT_ACCEL_REQUEST_BUFFER_SECONDS = 1.0
-VERSION = 0
 
 class LatControlTorque(LatControl):
-  def __init__(self, CP, CP_SP, CI, dt):
-    super().__init__(CP, CP_SP, CI, dt)
+  def __init__(self, CP, CP_SP, CI):
+    super().__init__(CP, CP_SP, CI)
     self.torque_params = CP.lateralTuning.torque.as_builder()
     self.torque_from_lateral_accel = CI.torque_from_lateral_accel()
     self.lateral_accel_from_torque = CI.lateral_accel_from_torque()
-    self.pid = PIDController([INTERP_SPEEDS, KP_INTERP], KI, KD, rate=1/self.dt)
+    self.pid = PIDController(self.torque_params.kp, self.torque_params.ki,
+                             k_f=self.torque_params.kf)
     self.update_limits()
     self.steering_angle_deadzone_deg = self.torque_params.steeringAngleDeadzoneDeg
-    self.lat_accel_request_buffer_len = int(LAT_ACCEL_REQUEST_BUFFER_SECONDS / self.dt)
-    self.lat_accel_request_buffer = deque([0.] * self.lat_accel_request_buffer_len , maxlen=self.lat_accel_request_buffer_len)
-    self.previous_measurement = 0.0
-    self.measurement_rate_filter = FirstOrderFilter(0.0, 1 / (2 * np.pi * LP_FILTER_CUTOFF_HZ), self.dt)
 
     self.extension = LatControlTorqueExt(self, CP, CP_SP, CI)
 
@@ -58,68 +47,57 @@ class LatControlTorque(LatControl):
     self.pid.set_limits(self.lateral_accel_from_torque(self.steer_max, self.torque_params),
                         self.lateral_accel_from_torque(-self.steer_max, self.torque_params))
 
-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited, lat_delay):
+  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
     # Override torque params from extension
     if self.extension.update_override_torque_params(self.torque_params):
       self.update_limits()
 
     pid_log = log.ControlsState.LateralTorqueState.new_message()
-    pid_log.version = VERSION
     if not active:
       output_torque = 0.0
       pid_log.active = False
     else:
-      measured_curvature = -VM.calc_curvature(math.radians(CS.steeringAngleDeg - params.angleOffsetDeg), CS.vEgo, params.roll)
+      actual_curvature = -VM.calc_curvature(math.radians(CS.steeringAngleDeg - params.angleOffsetDeg), CS.vEgo, params.roll)
       roll_compensation = params.roll * ACCELERATION_DUE_TO_GRAVITY
       curvature_deadzone = abs(VM.calc_curvature(math.radians(self.steering_angle_deadzone_deg), CS.vEgo, 0.0))
+
+      desired_lateral_accel = desired_curvature * CS.vEgo ** 2
+      actual_lateral_accel = actual_curvature * CS.vEgo ** 2
       lateral_accel_deadzone = curvature_deadzone * CS.vEgo ** 2
 
-      delay_frames = int(np.clip(lat_delay / self.dt, 1, self.lat_accel_request_buffer_len))
-      expected_lateral_accel = self.lat_accel_request_buffer[-delay_frames]
-      # TODO factor out lateral jerk from error to later replace it with delay independent alternative
-      future_desired_lateral_accel = desired_curvature * CS.vEgo ** 2
-      self.lat_accel_request_buffer.append(future_desired_lateral_accel)
-      gravity_adjusted_future_lateral_accel = future_desired_lateral_accel - roll_compensation
-      desired_lateral_jerk = (future_desired_lateral_accel - expected_lateral_accel) / lat_delay
-
-      measurement = measured_curvature * CS.vEgo ** 2
-      measurement_rate = self.measurement_rate_filter.update((measurement - self.previous_measurement) / self.dt)
-      self.previous_measurement = measurement
-
-      setpoint = lat_delay * desired_lateral_jerk + expected_lateral_accel
-      error = setpoint - measurement
+      low_speed_factor = np.interp(CS.vEgo, LOW_SPEED_X, LOW_SPEED_Y)**2
+      setpoint = desired_lateral_accel + low_speed_factor * desired_curvature
+      measurement = actual_lateral_accel + low_speed_factor * actual_curvature
+      gravity_adjusted_lateral_accel = desired_lateral_accel - roll_compensation
 
       # do error correction in lateral acceleration space, convert at end to handle non-linear torque responses correctly
-      pid_log.error = float(error)
-      ff = gravity_adjusted_future_lateral_accel
+      pid_log.error = float(setpoint - measurement)
+      ff = gravity_adjusted_lateral_accel
       # latAccelOffset corrects roll compensation bias from device roll misalignment relative to car roll
       ff -= self.torque_params.latAccelOffset
-      # TODO jerk is weighted by lat_delay for legacy reasons, but should be made independent of it
-      ff += get_friction(error, lateral_accel_deadzone, FRICTION_THRESHOLD, self.torque_params)
+      ff += get_friction(desired_lateral_accel - actual_lateral_accel, lateral_accel_deadzone, FRICTION_THRESHOLD, self.torque_params)
 
       freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5
       output_lataccel = self.pid.update(pid_log.error,
-                                       -measurement_rate,
-                                        feedforward=ff,
-                                        speed=CS.vEgo,
-                                        freeze_integrator=freeze_integrator)
+                                      feedforward=ff,
+                                      speed=CS.vEgo,
+                                      freeze_integrator=freeze_integrator)
       output_torque = self.torque_from_lateral_accel(output_lataccel, self.torque_params)
 
       # Lateral acceleration torque controller extension updates
       # Overrides pid_log.error and output_torque
       pid_log, output_torque = self.extension.update(CS, VM, self.pid, params, ff, pid_log, setpoint, measurement, calibrated_pose, roll_compensation,
-                                                     future_desired_lateral_accel, measurement, lateral_accel_deadzone, gravity_adjusted_future_lateral_accel,
-                                                     desired_curvature, measured_curvature, steer_limited_by_safety, output_torque)
+                                                     desired_lateral_accel, actual_lateral_accel, lateral_accel_deadzone, gravity_adjusted_lateral_accel,
+                                                     desired_curvature, actual_curvature, steer_limited_by_safety, output_torque)
 
       pid_log.active = True
       pid_log.p = float(self.pid.p)
       pid_log.i = float(self.pid.i)
       pid_log.d = float(self.pid.d)
       pid_log.f = float(self.pid.f)
-      pid_log.output = float(-output_torque) # TODO: log lat accel?
-      pid_log.actualLateralAccel = float(measurement)
-      pid_log.desiredLateralAccel = float(setpoint)
-      pid_log.desiredLateralJerk = float(desired_lateral_jerk)
+      pid_log.output = float(-output_torque)  # TODO: log lat accel?
+      pid_log.actualLateralAccel = float(actual_lateral_accel)
+      pid_log.desiredLateralAccel = float(desired_lateral_accel)
       pid_log.saturated = bool(self._check_saturation(self.steer_max - abs(output_torque) < 1e-3, CS, steer_limited_by_safety, curvature_limited))
 
     # TODO left is positive in this convention

selfdrive/controls/lib/longcontrol.py

@@ -54,7 +54,7 @@ class LongControl:
     self.long_control_state = LongCtrlState.off
     self.pid = PIDController((CP.longitudinalTuning.kpBP, CP.longitudinalTuning.kpV),
                              (CP.longitudinalTuning.kiBP, CP.longitudinalTuning.kiV),
-                             rate=1 / DT_CTRL)
+                             k_f=CP.longitudinalTuning.kf, rate=1 / DT_CTRL)
     self.last_output_accel = 0.0
 
   def reset(self):

selfdrive/controls/tests/test_latcontrol.py

@@ -7,7 +7,6 @@ from opendbc.car.toyota.values import CAR as TOYOTA
 from opendbc.car.nissan.values import CAR as NISSAN
 from opendbc.car.gm.values import CAR as GM
 from opendbc.car.vehicle_model import VehicleModel
-from openpilot.common.realtime import DT_CTRL
 from openpilot.selfdrive.car.helpers import convert_to_capnp
 from openpilot.selfdrive.controls.lib.latcontrol_pid import LatControlPID
 from openpilot.selfdrive.controls.lib.latcontrol_torque import LatControlTorque
@@ -30,7 +29,7 @@ class TestLatControl:
     CP_SP = convert_to_capnp(CP_SP)
     VM = VehicleModel(CP)
 
-    controller = controller(CP.as_reader(), CP_SP.as_reader(), CI, DT_CTRL)
+    controller = controller(CP.as_reader(), CP_SP.as_reader(), CI)
 
     CS = car.CarState.new_message()
     CS.vEgo = 30
@@ -43,13 +42,13 @@ class TestLatControl:
 
     # Saturate for curvature limited and controller limited
     for _ in range(1000):
-      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, True, 0.2)
+      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, True)
     assert lac_log.saturated
 
     for _ in range(1000):
-      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, False, 0.2)
+      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, False)
     assert not lac_log.saturated
 
     for _ in range(1000):
-      _, _, lac_log = controller.update(True, CS, VM, params, False, 1, pose, False, 0.2)
+      _, _, lac_log = controller.update(True, CS, VM, params, False, 1, pose, False)
     assert lac_log.saturated

selfdrive/debug/qlog_size.py

@@ -6,7 +6,7 @@ from collections import defaultdict
 import matplotlib.pyplot as plt
 
 from cereal.services import SERVICE_LIST
-from openpilot.common.utils import LOG_COMPRESSION_LEVEL
+from openpilot.common.file_helpers import LOG_COMPRESSION_LEVEL
 from openpilot.tools.lib.logreader import LogReader
 from tqdm import tqdm
 

selfdrive/locationd/torqued.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-import os
 import numpy as np
 from collections import deque, defaultdict
 
@@ -251,8 +250,6 @@ class TorqueEstimator(ParameterEstimator, TorqueEstimatorExt):
 def main(demo=False):
   config_realtime_process([0, 1, 2, 3], 5)
 
-  DEBUG = bool(int(os.getenv("DEBUG", "0")))
-
   pm = messaging.PubMaster(['liveTorqueParameters'])
   sm = messaging.SubMaster(['carControl', 'carOutput', 'carState', 'liveCalibration', 'livePose', 'liveDelay'], poll='livePose')
 
@@ -271,7 +268,7 @@ def main(demo=False):
 
     # 4Hz driven by livePose
     if sm.frame % 5 == 0:
-      pm.send('liveTorqueParameters', estimator.get_msg(valid=sm.all_checks(), with_points=DEBUG))
+      pm.send('liveTorqueParameters', estimator.get_msg(valid=sm.all_checks()))
 
     # Cache points every 60 seconds while onroad
     if sm.frame % 240 == 0:

selfdrive/modeld/SConscript

@@ -1,11 +1,11 @@
 import os
 import glob
 
-Import('env', 'envCython', 'arch', 'cereal', 'messaging', 'common', 'visionipc', 'transformations')
+Import('env', 'envCython', 'arch', 'cereal', 'messaging', 'common', 'gpucommon', 'visionipc', 'transformations')
 lenv = env.Clone()
 lenvCython = envCython.Clone()
 
-libs = [cereal, messaging, visionipc, common, 'capnp', 'kj', 'pthread']
+libs = [cereal, messaging, visionipc, gpucommon, common, 'capnp', 'kj', 'pthread']
 frameworks = []
 
 common_src = [
@@ -51,8 +51,8 @@ def tg_compile(flags, model_name):
 for model_name in ['driving_vision', 'driving_policy', 'dmonitoring_model']:
   flags = {
     'larch64': 'DEV=QCOM',
-    'Darwin': f'DEV=CPU HOME={os.path.expanduser("~")} IMAGE=0', # tinygrad calls brew which needs a $HOME in the env
-  }.get(arch, 'DEV=CPU CPU_LLVM=1 IMAGE=0')
+    'Darwin': 'DEV=CPU IMAGE=0',
+  }.get(arch, 'DEV=LLVM IMAGE=0')
   tg_compile(flags, model_name)
 
 # Compile BIG model if USB GPU is available

selfdrive/modeld/dmonitoringmodeld.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import os
 from openpilot.system.hardware import TICI
-os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
+os.environ['DEV'] = 'QCOM' if TICI else 'LLVM'
 from tinygrad.tensor import Tensor
 from tinygrad.dtype import dtypes
 import math
@@ -25,13 +25,13 @@ from openpilot.selfdrive.modeld.runners.tinygrad_helpers import qcom_tensor_from
 MODEL_WIDTH, MODEL_HEIGHT = DM_INPUT_SIZE
 CALIB_LEN = 3
 FEATURE_LEN = 512
-OUTPUT_SIZE = 83 + FEATURE_LEN
+OUTPUT_SIZE = 84 + FEATURE_LEN
 
 PROCESS_NAME = "selfdrive.modeld.dmonitoringmodeld"
 SEND_RAW_PRED = os.getenv('SEND_RAW_PRED')
 MODEL_PKL_PATH = Path(__file__).parent / 'models/dmonitoring_model_tinygrad.pkl'
 
-# TODO: slice from meta
+
 class DriverStateResult(ctypes.Structure):
   _fields_ = [
     ("face_orientation", ctypes.c_float*3),
@@ -46,8 +46,8 @@ class DriverStateResult(ctypes.Structure):
     ("left_blink_prob", ctypes.c_float),
     ("right_blink_prob", ctypes.c_float),
     ("sunglasses_prob", ctypes.c_float),
-    ("_unused_c", ctypes.c_float),
-    ("_unused_d", ctypes.c_float*4),
+    ("occluded_prob", ctypes.c_float),
+    ("ready_prob", ctypes.c_float*4),
     ("not_ready_prob", ctypes.c_float*2)]
 
 
@@ -55,6 +55,7 @@ class DMonitoringModelResult(ctypes.Structure):
   _fields_ = [
     ("driver_state_lhd", DriverStateResult),
     ("driver_state_rhd", DriverStateResult),
+    ("poor_vision_prob", ctypes.c_float),
     ("wheel_on_right_prob", ctypes.c_float),
     ("features", ctypes.c_float*FEATURE_LEN)]
 
@@ -106,6 +107,8 @@ def fill_driver_state(msg, ds_result: DriverStateResult):
   msg.leftBlinkProb = float(sigmoid(ds_result.left_blink_prob))
   msg.rightBlinkProb = float(sigmoid(ds_result.right_blink_prob))
   msg.sunglassesProb = float(sigmoid(ds_result.sunglasses_prob))
+  msg.occludedProb = float(sigmoid(ds_result.occluded_prob))
+  msg.readyProb = [float(sigmoid(x)) for x in ds_result.ready_prob]
   msg.notReadyProb = [float(sigmoid(x)) for x in ds_result.not_ready_prob]
 
 
@@ -116,6 +119,7 @@ def get_driverstate_packet(model_output: np.ndarray, frame_id: int, location_ts:
   ds.frameId = frame_id
   ds.modelExecutionTime = execution_time
   ds.gpuExecutionTime = gpu_execution_time
+  ds.poorVisionProb = float(sigmoid(model_result.poor_vision_prob))
   ds.wheelOnRightProb = float(sigmoid(model_result.wheel_on_right_prob))
   ds.rawPredictions = model_output.tobytes() if SEND_RAW_PRED else b''
   fill_driver_state(ds.leftDriverData, model_result.driver_state_lhd)

selfdrive/modeld/modeld.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import os
 from openpilot.system.hardware import TICI
-os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
+os.environ['DEV'] = 'QCOM' if TICI else 'LLVM'
 USBGPU = "USBGPU" in os.environ
 if USBGPU:
   os.environ['DEV'] = 'AMD'

selfdrive/modeld/models/README.md

@@ -62,5 +62,6 @@ Refer to **slice_outputs** and **parse_vision_outputs/parse_policy_outputs** in
     * (deprecated) distracted probabilities: 2
     * using phone probability: 1
     * distracted probability: 1
-  * common outputs 1
+  * common outputs 2
+    * poor camera vision probability: 1
     * left hand drive probability: 1

selfdrive/modeld/models/dmonitoring_model.current

@@ -0,0 +1,2 @@
+fa69be01-b430-4504-9d72-7dcb058eb6dd
+d9fb22d1c4fa3ca3d201dbc8edf1d0f0918e53e6

selfdrive/monitoring/helpers.py

@@ -4,13 +4,11 @@ import numpy as np
 from cereal import car, log
 import cereal.messaging as messaging
 from openpilot.selfdrive.selfdrived.events import Events
-from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
 from openpilot.common.realtime import DT_DMON
 from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.common.params import Params
 from openpilot.common.stat_live import RunningStatFilter
 from openpilot.common.transformations.camera import DEVICE_CAMERAS
-from openpilot.system.hardware import HARDWARE
 
 EventName = log.OnroadEvent.EventName
 
@@ -36,13 +34,12 @@ class DRIVER_MONITOR_SETTINGS:
     self._SG_THRESHOLD = 0.9
     self._BLINK_THRESHOLD = 0.865
 
-    if HARDWARE.get_device_type() == 'mici':
-      self._EE_THRESH11 = 0.75
-    else:
-      self._EE_THRESH11 = 0.4
+    self._EE_THRESH11 = 0.4
     self._EE_THRESH12 = 15.0
     self._EE_MAX_OFFSET1 = 0.06
     self._EE_MIN_OFFSET1 = 0.025
+    self._EE_THRESH21 = 0.01
+    self._EE_THRESH22 = 0.35
 
     self._POSE_PITCH_THRESHOLD = 0.3133
     self._POSE_PITCH_THRESHOLD_SLACK = 0.3237
@@ -58,9 +55,6 @@ class DRIVER_MONITOR_SETTINGS:
     self._YAW_MAX_OFFSET = 0.289
     self._YAW_MIN_OFFSET = -0.0246
 
-    self._DCAM_UNCERTAIN_ALERT_THRESHOLD = 0.1
-    self._DCAM_UNCERTAIN_ALERT_COUNT = int(60  / self._DT_DMON)
-    self._DCAM_UNCERTAIN_RESET_COUNT = int(20  / self._DT_DMON)
     self._POSESTD_THRESHOLD = 0.3
     self._HI_STD_FALLBACK_TIME = int(10  / self._DT_DMON)  # fall back to wheel touch if model is uncertain for 10s
     self._DISTRACTED_FILTER_TS = 0.25  # 0.6Hz
@@ -143,8 +137,11 @@ class DriverMonitoring:
     self.pose = DriverPose(self.settings._POSE_OFFSET_MAX_COUNT)
     self.blink = DriverBlink()
     self.eev1 = 0.
+    self.eev2 = 1.
     self.ee1_offseter = RunningStatFilter(max_trackable=self.settings._POSE_OFFSET_MAX_COUNT)
+    self.ee2_offseter = RunningStatFilter(max_trackable=self.settings._POSE_OFFSET_MAX_COUNT)
     self.ee1_calibrated = False
+    self.ee2_calibrated = False
 
     self.always_on = always_on
     self.distracted_types = []
@@ -162,9 +159,6 @@ class DriverMonitoring:
     self.hi_stds = 0
     self.threshold_pre = self.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
     self.threshold_prompt = self.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
-    self.dcam_uncertain_cnt = 0
-    self.dcam_uncertain_alerted = False # once per drive
-    self.dcam_reset_cnt = 0
 
     self.params = Params()
     self.too_distracted = self.params.get_bool("DriverTooDistracted")
@@ -252,7 +246,7 @@ class DriverMonitoring:
 
     return distracted_types
 
-  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged, standstill):
+  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged):
     rhd_pred = driver_state.wheelOnRightProb
     # calibrates only when there's movement and either face detected
     if car_speed > self.settings._WHEELPOS_CALIB_MIN_SPEED and (driver_state.leftDriverData.faceProb > self.settings._FACE_THRESHOLD or
@@ -268,7 +262,7 @@ class DriverMonitoring:
     driver_data = driver_state.rightDriverData if self.wheel_on_right else driver_state.leftDriverData
     if not all(len(x) > 0 for x in (driver_data.faceOrientation, driver_data.facePosition,
                                     driver_data.faceOrientationStd, driver_data.facePositionStd,
-                                    driver_data.notReadyProb)):
+                                    driver_data.readyProb, driver_data.notReadyProb)):
       return
 
     self.face_detected = driver_data.faceProb > self.settings._FACE_THRESHOLD
@@ -285,6 +279,7 @@ class DriverMonitoring:
     self.blink.right = driver_data.rightBlinkProb * (driver_data.rightEyeProb > self.settings._EYE_THRESHOLD) \
                                                                   * (driver_data.sunglassesProb < self.settings._SG_THRESHOLD)
     self.eev1 = driver_data.notReadyProb[0]
+    self.eev2 = driver_data.readyProb[0]
 
     self.distracted_types = self._get_distracted_types()
     self.driver_distracted = (DistractedType.DISTRACTED_E2E in self.distracted_types or DistractedType.DISTRACTED_POSE in self.distracted_types
@@ -298,20 +293,12 @@ class DriverMonitoring:
       self.pose.pitch_offseter.push_and_update(self.pose.pitch)
       self.pose.yaw_offseter.push_and_update(self.pose.yaw)
       self.ee1_offseter.push_and_update(self.eev1)
+      self.ee2_offseter.push_and_update(self.eev2)
 
     self.pose.calibrated = self.pose.pitch_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT and \
                                        self.pose.yaw_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT
     self.ee1_calibrated = self.ee1_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT
-
-    if self.face_detected and not self.driver_distracted:
-      if model_std_max > self.settings._DCAM_UNCERTAIN_ALERT_THRESHOLD:
-        if not standstill:
-          self.dcam_uncertain_cnt += 1
-          self.dcam_reset_cnt = 0
-      else:
-        self.dcam_reset_cnt += 1
-        if self.dcam_reset_cnt > self.settings._DCAM_UNCERTAIN_RESET_COUNT:
-          self.dcam_uncertain_cnt = 0
+    self.ee2_calibrated = self.ee2_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT
 
     self.is_model_uncertain = self.hi_stds > self.settings._HI_STD_FALLBACK_TIME
     self._set_timers(self.face_detected and not self.is_model_uncertain)
@@ -389,10 +376,6 @@ class DriverMonitoring:
     if alert is not None:
       self.current_events.add(alert)
 
-    if self.dcam_uncertain_cnt > self.settings._DCAM_UNCERTAIN_ALERT_COUNT and not self.dcam_uncertain_alerted:
-      set_offroad_alert("Offroad_DriverMonitoringUncertain", True)
-      self.dcam_uncertain_alerted = True
-
 
   def get_state_packet(self, valid=True):
     # build driverMonitoringState packet
@@ -414,7 +397,6 @@ class DriverMonitoring:
       "hiStdCount": self.hi_stds,
       "isActiveMode": self.active_monitoring_mode,
       "isRHD": self.wheel_on_right,
-      "uncertainCount": self.dcam_uncertain_cnt,
     }
     return dat
 
@@ -430,8 +412,7 @@ class DriverMonitoring:
       driver_state=sm['driverStateV2'],
       cal_rpy=sm['liveCalibration'].rpyCalib,
       car_speed=sm['carState'].vEgo,
-      op_engaged=sm['selfdriveState'].enabled or sm['carControl'].latActive,
-      standstill=sm['carState'].standstill,
+      op_engaged=sm['selfdriveState'].enabled or sm['carControl'].latActive
     )
 
     # Update distraction events

selfdrive/monitoring/test_monitoring.py

@@ -25,6 +25,7 @@ def make_msg(face_detected, distracted=False, model_uncertain=False):
   ds.leftDriverData.faceOrientationStd = [1.*model_uncertain, 1.*model_uncertain, 1.*model_uncertain]
   ds.leftDriverData.facePositionStd = [1.*model_uncertain, 1.*model_uncertain]
   # TODO: test both separately when e2e is used
+  ds.leftDriverData.readyProb = [0., 0., 0., 0.]
   ds.leftDriverData.notReadyProb = [0., 0.]
   return ds
 
@@ -53,7 +54,7 @@ class TestMonitoring:
     DM = DriverMonitoring()
     events = []
     for idx in range(len(msgs)):
-      DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx], standstill[idx])
+      DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx])
       # cal_rpy and car_speed don't matter here
 
       # evaluate events at 10Hz for tests

selfdrive/pandad/pandad.cc

@@ -80,7 +80,7 @@ Panda *connect(std::string serial="", uint32_t index=0) {
   }
   //panda->enable_deepsleep();
 
-  for (int i = 0; i < PANDA_CAN_CNT; i++) {
+  for (int i = 0; i < PANDA_BUS_CNT; i++) {
     panda->set_can_fd_auto(i, true);
   }
 

selfdrive/pandad/tests/test_pandad.py

@@ -5,7 +5,8 @@ import time
 import cereal.messaging as messaging
 from cereal import log
 from openpilot.common.gpio import gpio_set, gpio_init
-from panda import Panda, PandaDFU
+from panda import Panda, PandaDFU, PandaProtocolMismatch
+from openpilot.common.retry import retry
 from openpilot.system.manager.process_config import managed_processes
 from openpilot.system.hardware import HARDWARE
 from openpilot.system.hardware.tici.pins import GPIO
@@ -49,7 +50,8 @@ class TestPandad:
     assert not Panda.wait_for_dfu(None, 3)
     assert not Panda.wait_for_panda(None, 3)
 
-  def _flash_bootstub(self, fn):
+  @retry(attempts=3)
+  def _flash_bootstub_and_test(self, fn, expect_mismatch=False):
     self._go_to_dfu()
     pd = PandaDFU(None)
     if fn is None:
@@ -59,6 +61,16 @@ class TestPandad:
     pd.reset()
     HARDWARE.reset_internal_panda()
 
+    assert Panda.wait_for_panda(None, 10)
+    if expect_mismatch:
+      with pytest.raises(PandaProtocolMismatch):
+        Panda()
+    else:
+      with Panda() as p:
+        assert p.bootstub
+
+    self._run_test(45)
+
   def test_in_dfu(self):
     HARDWARE.recover_internal_panda()
     self._run_test(60)
@@ -94,14 +106,13 @@ class TestPandad:
     print("startup times", ts, sum(ts) / len(ts))
     assert 0.1 < (sum(ts)/len(ts)) < 0.7
 
-  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_protocol_version_check(self):
+    # flash old fw
+    fn = os.path.join(HERE, "bootstub.panda_h7_spiv0.bin")
+    self._flash_bootstub_and_test(fn, expect_mismatch=True)
 
   def test_release_to_devel_bootstub(self):
-    self._flash_bootstub(None)
-    self._run_test(45)
+    self._flash_bootstub_and_test(None)
 
   def test_recover_from_bad_bootstub(self):
     self._go_to_dfu()

selfdrive/pandad/tests/test_pandad_loopback.py

@@ -9,7 +9,7 @@ from pprint import pprint
 import cereal.messaging as messaging
 from cereal import car, log
 from opendbc.car.can_definitions import CanData
-from openpilot.common.utils import retry
+from openpilot.common.retry import retry
 from openpilot.common.params import Params
 from openpilot.common.timeout import Timeout
 from openpilot.selfdrive.pandad import can_list_to_can_capnp

selfdrive/selfdrived/alerts_offroad.json

@@ -41,10 +41,6 @@
     "text": "OpenStreetMap database is out of date. New maps must be downloaded if you wish to continue using OpenStreetMap data for Enhanced Speed Control and road name display.\n\n%1",
     "severity": 0
   },
-  "Offroad_DriverMonitoringUncertain": {
-    "text": "openpilot detected poor visibility for driver monitoring. Ensure the device has a clear view of the driver. This can be checked using Settings -> Device -> Driver Camera Preview. Extreme lighting conditions and/or unconventional mounting positions may also trigger this alert.",
-    "severity": 0
-  },
   "Offroad_ExcessiveActuation": {
     "text": "openpilot detected excessive %1 actuation on your last drive. Please contact support at https://comma.ai/support and share your device's Dongle ID for troubleshooting.",
     "severity": 1,

selfdrive/selfdrived/events.py

@@ -80,7 +80,7 @@ def below_engage_speed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.
 
 def below_steer_speed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
   return Alert(
-    f"Steer Assist Unavailable Below {get_display_speed(CP.minSteerSpeed, metric)}",
+    f"Steer Unavailable Below {get_display_speed(CP.minSteerSpeed, metric)}",
     "",
     AlertStatus.userPrompt, AlertSize.small,
     Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 0.4)
@@ -322,7 +322,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
 
   EventName.steerTempUnavailableSilent: {
     ET.WARNING: Alert(
-      "Steering Assist Temporarily Unavailable",
+      "Steering Temporarily Unavailable",
       "",
       AlertStatus.userPrompt, AlertSize.small,
       Priority.LOW, VisualAlert.steerRequired, AudibleAlert.prompt, 1.8),
@@ -568,7 +568,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
   },
 
   EventName.steerTempUnavailable: {
-    ET.SOFT_DISABLE: soft_disable_alert("Steering Assist Temporarily Unavailable"),
+    ET.SOFT_DISABLE: soft_disable_alert("Steering Temporarily Unavailable"),
     ET.NO_ENTRY: NoEntryAlert("Steering Temporarily Unavailable"),
   },
 

selfdrive/test/process_replay/ref_commit

@@ -1 +1 @@
-b508f43fb0481bce0859c9b6ab4f45ee690b8dab
+afcab1abb62b9d5678342956cced4712f44e909e

selfdrive/test/setup_device_ci.sh

@@ -42,7 +42,6 @@ sudo systemctl restart NetworkManager
 sudo systemctl disable ssh-param-watcher.path
 sudo systemctl disable ssh-param-watcher.service
 sudo mount -o ro,remount /
-sudo systemctl stop power_monitor
 
 while true; do
   if ! sudo systemctl is-active -q ssh; then
@@ -55,6 +54,7 @@ while true; do
   #  /data/ciui.py &
   #fi
 
+  awk '{print \$1}' /proc/uptime > /var/tmp/power_watchdog
   sleep 5s
 done
 

selfdrive/test/test_onroad.py

@@ -32,7 +32,7 @@ CPU usage budget
 TEST_DURATION = 25
 LOG_OFFSET = 8
 
-MAX_TOTAL_CPU = 350.  # total for all 8 cores
+MAX_TOTAL_CPU = 300.  # total for all 8 cores
 PROCS = {
   # Baseline CPU usage by process
   "selfdrive.controls.controlsd": 16.0,
@@ -42,7 +42,7 @@ PROCS = {
   "./encoderd": 13.0,
   "./camerad": 10.0,
   "selfdrive.controls.plannerd": 8.0,
-  "selfdrive.ui.ui": 40.0,
+  "./ui": 18.0,
   "system.sensord.sensord": 13.0,
   "selfdrive.controls.radard": 2.0,
   "selfdrive.modeld.modeld": 22.0,
@@ -206,8 +206,7 @@ class TestOnroad:
     result += "-------------- UI Draw Timing ------------------\n"
     result += "------------------------------------------------\n"
 
-    # skip first few frames -- connecting to vipc
-    ts = self.ts['uiDebug']['drawTimeMillis'][15:]
+    ts = self.ts['uiDebug']['drawTimeMillis']
     result += f"min  {min(ts):.2f}ms\n"
     result += f"max  {max(ts):.2f}ms\n"
     result += f"std  {np.std(ts):.2f}ms\n"
@@ -216,7 +215,7 @@ class TestOnroad:
     print(result)
 
     assert max(ts) < 250.
-    assert np.mean(ts) < 20.  # TODO: ~6-11ms, increase consistency
+    assert np.mean(ts) < 10.
     #self.assertLess(np.std(ts), 5.)
 
     # some slow frames are expected since camerad/modeld can preempt ui
@@ -286,7 +285,7 @@ class TestOnroad:
 
     # check for big leaks. note that memory usage is
     # expected to go up while the MSGQ buffers fill up
-    assert np.average(mems) <= 85, "Average memory usage above 85%"
+    assert np.average(mems) <= 65, "Average memory usage above 65%"
     assert np.max(np.diff(mems)) <= 4, "Max memory increase too high"
     assert np.average(np.diff(mems)) <= 1, "Average memory increase too high"
 

selfdrive/ui/.gitignore

@@ -1 +1,14 @@
+moc_*
+*.moc
+
+translations/main_test_en.*
+
+ui
+mui
+watch3
 installer/installers/*
+qt/setup/setup
+qt/setup/reset
+qt/setup/wifi
+qt/setup/updater
+translations/alerts_generated.h

selfdrive/ui/SConscript

@@ -1,37 +1,75 @@
-import os
-import re
 import json
-from pathlib import Path
-Import('env', 'arch', 'common')
+Import('env', 'qt_env', 'arch', 'common', 'messaging', 'visionipc', 'transformations')
 
-# build the fonts
-generator = File("#selfdrive/assets/fonts/process.py")
-source_files = Glob("#selfdrive/assets/fonts/*.ttf") + Glob("#selfdrive/assets/fonts/*.otf")
-output_files = [
-  (f.abspath.split('.')[0] + ".fnt", f.abspath.split('.')[0] + ".png")
-  for f in source_files
-  if "NotoColor" not in f.name
-]
-env.Command(
-  target=output_files,
-  source=[generator, source_files],
-  action=f"python3 {generator}",
-)
+base_libs = [common, messaging, visionipc, transformations,
+             'm', 'OpenCL', 'ssl', 'crypto', 'pthread'] + qt_env["LIBS"]
 
-# compile gettext .po -> .mo translations
+if arch == 'larch64':
+  base_libs.append('EGL')
+
+if arch == "Darwin":
+  del base_libs[base_libs.index('OpenCL')]
+  qt_env['FRAMEWORKS'] += ['OpenCL']
+
+sp_widgets_src = []
+sp_qt_src = []
+sp_qt_util = []
+if not GetOption('stock_ui'):
+  SConscript(['sunnypilot/SConscript'])
+  Import('sp_widgets_src', 'sp_qt_src', 'sp_qt_util')
+
+# FIXME: remove this once we're on 5.15 (24.04)
+qt_env['CXXFLAGS'] += ["-Wno-deprecated-declarations"]
+
+qt_util = qt_env.Library("qt_util", ["#selfdrive/ui/qt/api.cc", "#selfdrive/ui/qt/util.cc"] + sp_qt_util, LIBS=base_libs)
+widgets_src = ["qt/widgets/input.cc", "qt/widgets/wifi.cc", "qt/prime_state.cc",
+               "qt/widgets/ssh_keys.cc", "qt/widgets/toggle.cc", "qt/widgets/controls.cc",
+               "qt/widgets/offroad_alerts.cc", "qt/widgets/prime.cc", "qt/widgets/keyboard.cc",
+               "qt/widgets/scrollview.cc", "qt/widgets/cameraview.cc", "#third_party/qrcode/QrCode.cc",
+               "qt/request_repeater.cc", "qt/qt_window.cc", "qt/network/networking.cc", "qt/network/wifi_manager.cc"] + sp_widgets_src
+
+widgets = qt_env.Library("qt_widgets", widgets_src, LIBS=base_libs)
+Export('widgets')
+qt_libs = [widgets, qt_util] + base_libs
+
+qt_src = ["main.cc", "ui.cc", "qt/sidebar.cc", "qt/body.cc",
+          "qt/window.cc", "qt/home.cc", "qt/offroad/settings.cc", "qt/offroad/offroad_home.cc",
+          "qt/offroad/software_settings.cc", "qt/offroad/developer_panel.cc", "qt/offroad/onboarding.cc",
+          "qt/offroad/driverview.cc", "qt/offroad/experimental_mode.cc", "qt/offroad/firehose.cc",
+          "qt/onroad/onroad_home.cc", "qt/onroad/annotated_camera.cc", "qt/onroad/model.cc",
+          "qt/onroad/buttons.cc", "qt/onroad/alerts.cc", "qt/onroad/driver_monitoring.cc", "qt/onroad/hud.cc"] + sp_qt_src
+
+# build translation files
 with open(File("translations/languages.json").abspath) as f:
   languages = json.loads(f.read())
+translation_sources = [f"#selfdrive/ui/translations/{l}.ts" for l in languages.values()]
+translation_targets = [src.replace(".ts", ".qm") for src in translation_sources]
+lrelease_bin = 'third_party/qt5/larch64/bin/lrelease' if arch == 'larch64' else 'lrelease'
 
-po_sources = [f"#selfdrive/ui/translations/app_{l}.po" for l in languages.values()]
-po_sources = [src for src in po_sources if os.path.exists(File(src).abspath)]
-mo_targets = [src.replace(".po", ".mo") for src in po_sources]
-mo_build = []
-for src, tgt in zip(po_sources, mo_targets):
-  mo_build.append(env.Command(tgt, src, "msgfmt -o $TARGET $SOURCE"))
-mo_alias = env.Alias('mo', mo_build)
-env.AlwaysBuild(mo_alias)
+lrelease = qt_env.Command(translation_targets, translation_sources, f"{lrelease_bin} $SOURCES")
+qt_env.NoClean(translation_sources)
+qt_env.Precious(translation_sources)
 
+# create qrc file for compiled translations to include with assets
+translations_assets_src = "#selfdrive/assets/translations_assets.qrc"
+with open(File(translations_assets_src).abspath, 'w') as f:
+  f.write('<!DOCTYPE RCC><RCC version="1.0">\n<qresource>\n')
+  f.write('\n'.join([f'<file alias="{l}">../ui/translations/{l}.qm</file>' for l in languages.values()]))
+  f.write('\n</qresource>\n</RCC>')
+
+# build assets
+assets = "#selfdrive/assets/assets.cc"
+assets_src = "#selfdrive/assets/assets.qrc"
+qt_env.Command(assets, [assets_src, translations_assets_src], f"rcc $SOURCES -o $TARGET")
+qt_env.Depends(assets, Glob('#selfdrive/assets/*', exclude=[assets, assets_src, translations_assets_src, "#selfdrive/assets/assets.o"]) + [lrelease])
+asset_obj = qt_env.Object("assets", assets)
+
+# build main UI
+qt_env.Program("ui", qt_src + [asset_obj], LIBS=qt_libs)
 if GetOption('extras'):
+  qt_src.remove("main.cc")  # replaced by test_runner
+  qt_env.Program('tests/test_translations', [asset_obj, 'tests/test_runner.cc', 'tests/test_translations.cc'] + qt_src, LIBS=qt_libs)
+
   # build installers
   if arch != "Darwin":
     raylib_env = env.Clone()
@@ -40,7 +78,7 @@ if GetOption('extras'):
 
     raylib_libs = common + ["raylib"]
     if arch == "larch64":
-      raylib_libs += ["GLESv2", "EGL", "gbm", "drm"]
+      raylib_libs += ["GLESv2", "wayland-client", "wayland-egl", "EGL"]
     else:
       raylib_libs += ["GL"]
 

selfdrive/ui/__init__.py

@@ -1 +0,0 @@
-UI_BORDER_SIZE = 30

selfdrive/ui/installer/installer.cc

@@ -5,7 +5,6 @@
 
 #include "common/swaglog.h"
 #include "common/util.h"
-#include "system/hardware/hw.h"
 #include "third_party/raylib/include/raylib.h"
 
 int freshClone();
@@ -39,27 +38,6 @@ extern const uint8_t inter_ttf_end[] asm("_binary_selfdrive_ui_installer_inter_a
 
 Font font;
 
-std::vector<std::string> tici_prebuilt_branches = {"release3", "release-tizi", "release3-staging", "nightly", "nightly-dev"};
-std::string migrated_branch;
-
-void branchMigration() {
-  migrated_branch = BRANCH_STR;
-  cereal::InitData::DeviceType device_type = Hardware::get_device_type();
-  if (device_type == cereal::InitData::DeviceType::TICI) {
-    if (std::find(tici_prebuilt_branches.begin(), tici_prebuilt_branches.end(), BRANCH_STR) != tici_prebuilt_branches.end()) {
-      migrated_branch = "release-tici";
-    } else if (BRANCH_STR == "master") {
-      migrated_branch = "master-tici";
-    }
-  } else if (device_type == cereal::InitData::DeviceType::TIZI) {
-    if (BRANCH_STR == "release3") {
-      migrated_branch = "release-tizi";
-    } else if (BRANCH_STR == "release3-staging") {
-      migrated_branch = "release-tizi-staging";
-    }
-  }
-}
-
 void run(const char* cmd) {
   int err = std::system(cmd);
   assert(err == 0);
@@ -109,7 +87,7 @@ int doInstall() {
 int freshClone() {
   LOGD("Doing fresh clone");
   std::string cmd = util::string_format("git clone --progress %s -b %s --depth=1 --recurse-submodules %s 2>&1",
-                                        GIT_URL.c_str(), migrated_branch.c_str(), TMP_INSTALL_PATH);
+                                        GIT_URL.c_str(), BRANCH_STR.c_str(), TMP_INSTALL_PATH);
   return executeGitCommand(cmd);
 }
 
@@ -117,11 +95,11 @@ int cachedFetch(const std::string &cache) {
   LOGD("Fetching with cache: %s", cache.c_str());
 
   run(util::string_format("cp -rp %s %s", cache.c_str(), TMP_INSTALL_PATH).c_str());
-  run(util::string_format("cd %s && git remote set-branches --add origin %s", TMP_INSTALL_PATH, migrated_branch.c_str()).c_str());
+  run(util::string_format("cd %s && git remote set-branches --add origin %s", TMP_INSTALL_PATH, BRANCH_STR.c_str()).c_str());
 
   renderProgress(10);
 
-  return executeGitCommand(util::string_format("cd %s && git fetch --progress origin %s 2>&1", TMP_INSTALL_PATH, migrated_branch.c_str()));
+  return executeGitCommand(util::string_format("cd %s && git fetch --progress origin %s 2>&1", TMP_INSTALL_PATH, BRANCH_STR.c_str()));
 }
 
 int executeGitCommand(const std::string &cmd) {
@@ -164,8 +142,8 @@ void cloneFinished(int exitCode) {
   // ensure correct branch is checked out
   int err = chdir(TMP_INSTALL_PATH);
   assert(err == 0);
-  run(("git checkout " + migrated_branch).c_str());
-  run(("git reset --hard origin/" + migrated_branch).c_str());
+  run(("git checkout " + BRANCH_STR).c_str());
+  run(("git reset --hard origin/" + BRANCH_STR).c_str());
   run("git submodule update --init");
 
   // move into place
@@ -215,8 +193,6 @@ int main(int argc, char *argv[]) {
   font = LoadFontFromMemory(".ttf", inter_ttf, inter_ttf_end - inter_ttf, FONT_SIZE, NULL, 0);
   SetTextureFilter(font.texture, TEXTURE_FILTER_BILINEAR);
 
-  branchMigration();
-
   if (util::file_exists(CONTINUE_PATH)) {
     finishInstall();
   } else {

selfdrive/ui/layouts/home.py

@@ -8,9 +8,7 @@ from openpilot.selfdrive.ui.widgets.exp_mode_button import ExperimentalModeButto
 from openpilot.selfdrive.ui.widgets.prime import PrimeWidget
 from openpilot.selfdrive.ui.widgets.setup import SetupWidget
 from openpilot.system.ui.lib.text_measure import measure_text_cached
-from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
-from openpilot.system.ui.lib.multilang import tr, trn
-from openpilot.system.ui.widgets.label import gui_label
+from openpilot.system.ui.lib.application import gui_app, FontWeight, DEFAULT_TEXT_COLOR
 from openpilot.system.ui.widgets import Widget
 
 HEADER_HEIGHT = 80
@@ -37,17 +35,12 @@ class HomeLayout(Widget):
     self.update_alert = UpdateAlert()
     self.offroad_alert = OffroadAlert()
 
-    self._layout_widgets = {HomeLayoutState.UPDATE: self.update_alert, HomeLayoutState.ALERTS: self.offroad_alert}
-
     self.current_state = HomeLayoutState.HOME
     self.last_refresh = 0
     self.settings_callback: callable | None = None
 
     self.update_available = False
     self.alert_count = 0
-    self._version_text = ""
-    self._prev_update_available = False
-    self._prev_alerts_present = False
 
     self.header_rect = rl.Rectangle(0, 0, 0, 0)
     self.content_rect = rl.Rectangle(0, 0, 0, 0)
@@ -63,30 +56,14 @@ class HomeLayout(Widget):
     self._exp_mode_button = ExperimentalModeButton()
     self._setup_callbacks()
 
-  def show_event(self):
-    self._exp_mode_button.show_event()
-    self.last_refresh = time.monotonic()
-    self._refresh()
-
   def _setup_callbacks(self):
     self.update_alert.set_dismiss_callback(lambda: self._set_state(HomeLayoutState.HOME))
     self.offroad_alert.set_dismiss_callback(lambda: self._set_state(HomeLayoutState.HOME))
-    self._exp_mode_button.set_click_callback(lambda: self.settings_callback() if self.settings_callback else None)
 
   def set_settings_callback(self, callback: Callable):
     self.settings_callback = callback
 
   def _set_state(self, state: HomeLayoutState):
-    # propagate show/hide events
-    if state != self.current_state:
-      if state == HomeLayoutState.HOME:
-        self._exp_mode_button.show_event()
-
-      if state in self._layout_widgets:
-        self._layout_widgets[state].show_event()
-      if self.current_state in self._layout_widgets:
-        self._layout_widgets[self.current_state].hide_event()
-
     self.current_state = state
 
   def _render(self, rect: rl.Rectangle):
@@ -95,6 +72,7 @@ class HomeLayout(Widget):
       self._refresh()
       self.last_refresh = current_time
 
+    self._handle_input()
     self._render_header()
 
     # Render content based on current state
@@ -105,7 +83,7 @@ class HomeLayout(Widget):
     elif self.current_state == HomeLayoutState.ALERTS:
       self._render_alerts_view()
 
-  def _update_state(self):
+  def _update_layout_rects(self):
     self.header_rect = rl.Rectangle(
       self._rect.x + CONTENT_MARGIN, self._rect.y + CONTENT_MARGIN, self._rect.width - 2 * CONTENT_MARGIN, HEADER_HEIGHT
     )
@@ -132,54 +110,59 @@ class HomeLayout(Widget):
     self.alert_notif_rect.x = notif_x
     self.alert_notif_rect.y = self.header_rect.y + (self.header_rect.height - 60) // 2
 
-  def _handle_mouse_release(self, mouse_pos: MousePos):
-    super()._handle_mouse_release(mouse_pos)
+  def _handle_input(self):
+    if not rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT):
+      return
+
+    mouse_pos = rl.get_mouse_position()
 
     if self.update_available and rl.check_collision_point_rec(mouse_pos, self.update_notif_rect):
       self._set_state(HomeLayoutState.UPDATE)
-    elif self.alert_count > 0 and rl.check_collision_point_rec(mouse_pos, self.alert_notif_rect):
+      return
+
+    if self.alert_count > 0 and rl.check_collision_point_rec(mouse_pos, self.alert_notif_rect):
       self._set_state(HomeLayoutState.ALERTS)
+      return
+
+    # Content area input handling
+    if self.current_state == HomeLayoutState.UPDATE:
+      self.update_alert.handle_input(mouse_pos, True)
+    elif self.current_state == HomeLayoutState.ALERTS:
+      self.offroad_alert.handle_input(mouse_pos, True)
 
   def _render_header(self):
     font = gui_app.font(FontWeight.MEDIUM)
 
-    version_text_width = self.header_rect.width
-
     # Update notification button
     if self.update_available:
-      version_text_width -= self.update_notif_rect.width
-
       # Highlight if currently viewing updates
-      highlight_color = rl.Color(75, 95, 255, 255) if self.current_state == HomeLayoutState.UPDATE else rl.Color(54, 77, 239, 255)
+      highlight_color = rl.Color(255, 140, 40, 255) if self.current_state == HomeLayoutState.UPDATE else rl.Color(255, 102, 0, 255)
       rl.draw_rectangle_rounded(self.update_notif_rect, 0.3, 10, highlight_color)
 
-      text = tr("UPDATE")
-      text_size = measure_text_cached(font, text, HEAD_BUTTON_FONT_SIZE)
-      text_x = self.update_notif_rect.x + (self.update_notif_rect.width - text_size.x) // 2
-      text_y = self.update_notif_rect.y + (self.update_notif_rect.height - text_size.y) // 2
+      text = "UPDATE"
+      text_width = measure_text_cached(font, text, HEAD_BUTTON_FONT_SIZE).x
+      text_x = self.update_notif_rect.x + (self.update_notif_rect.width - text_width) // 2
+      text_y = self.update_notif_rect.y + (self.update_notif_rect.height - HEAD_BUTTON_FONT_SIZE) // 2
       rl.draw_text_ex(font, text, rl.Vector2(int(text_x), int(text_y)), HEAD_BUTTON_FONT_SIZE, 0, rl.WHITE)
 
     # Alert notification button
     if self.alert_count > 0:
-      version_text_width -= self.alert_notif_rect.width
-
       # Highlight if currently viewing alerts
       highlight_color = rl.Color(255, 70, 70, 255) if self.current_state == HomeLayoutState.ALERTS else rl.Color(226, 44, 44, 255)
       rl.draw_rectangle_rounded(self.alert_notif_rect, 0.3, 10, highlight_color)
 
-      alert_text = trn("{} ALERT", "{} ALERTS", self.alert_count).format(self.alert_count)
-      text_size = measure_text_cached(font, alert_text, HEAD_BUTTON_FONT_SIZE)
-      text_x = self.alert_notif_rect.x + (self.alert_notif_rect.width - text_size.x) // 2
-      text_y = self.alert_notif_rect.y + (self.alert_notif_rect.height - text_size.y) // 2
+      alert_text = f"{self.alert_count} ALERT{'S' if self.alert_count > 1 else ''}"
+      text_width = measure_text_cached(font, alert_text, HEAD_BUTTON_FONT_SIZE).x
+      text_x = self.alert_notif_rect.x + (self.alert_notif_rect.width - text_width) // 2
+      text_y = self.alert_notif_rect.y + (self.alert_notif_rect.height - HEAD_BUTTON_FONT_SIZE) // 2
       rl.draw_text_ex(font, alert_text, rl.Vector2(int(text_x), int(text_y)), HEAD_BUTTON_FONT_SIZE, 0, rl.WHITE)
 
     # Version text (right aligned)
-    if self.update_available or self.alert_count > 0:
-      version_text_width -= SPACING * 1.5
-
-    version_rect = rl.Rectangle(self.header_rect.x + self.header_rect.width - version_text_width, self.header_rect.y,
-                                version_text_width, self.header_rect.height)
-    gui_label(version_rect, self._version_text, 48, rl.WHITE, alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT)
+    version_text = self._get_version_text()
+    text_width = measure_text_cached(gui_app.font(FontWeight.NORMAL), version_text, 48).x
+    version_x = self.header_rect.x + self.header_rect.width - text_width
+    version_y = self.header_rect.y + (self.header_rect.height - 48) // 2
+    rl.draw_text_ex(gui_app.font(FontWeight.NORMAL), version_text, rl.Vector2(int(version_x), int(version_y)), 48, 0, DEFAULT_TEXT_COLOR)
 
   def _render_home_content(self):
     self._render_left_column()
@@ -210,23 +193,20 @@ class HomeLayout(Widget):
     self._setup_widget.render(setup_rect)
 
   def _refresh(self):
-    self._version_text = self._get_version_text()
-    update_available = self.update_alert.refresh()
-    alert_count = self.offroad_alert.refresh()
-    alerts_present = alert_count > 0
+    # TODO: implement _update_state with a timer
+    self.update_available = self.update_alert.refresh()
+    self.alert_count = self.offroad_alert.refresh()
+    self._update_state_priority(self.update_available, self.alert_count > 0)
+
+  def _update_state_priority(self, update_available: bool, alerts_present: bool):
+    current_state = self.current_state
 
-    # Show panels on transition from no alert/update to any alerts/update
     if not update_available and not alerts_present:
-      self._set_state(HomeLayoutState.HOME)
-    elif update_available and ((not self._prev_update_available) or (not alerts_present and self.current_state == HomeLayoutState.ALERTS)):
-      self._set_state(HomeLayoutState.UPDATE)
-    elif alerts_present and ((not self._prev_alerts_present) or (not update_available and self.current_state == HomeLayoutState.UPDATE)):
-      self._set_state(HomeLayoutState.ALERTS)
-
-    self.update_available = update_available
-    self.alert_count = alert_count
-    self._prev_update_available = update_available
-    self._prev_alerts_present = alerts_present
+      self.current_state = HomeLayoutState.HOME
+    elif update_available and (current_state == HomeLayoutState.HOME or (not alerts_present and current_state == HomeLayoutState.ALERTS)):
+      self.current_state = HomeLayoutState.UPDATE
+    elif alerts_present and (current_state == HomeLayoutState.HOME or (not update_available and current_state == HomeLayoutState.UPDATE)):
+      self.current_state = HomeLayoutState.ALERTS
 
   def _get_version_text(self) -> str:
     brand = "openpilot"

selfdrive/ui/layouts/main.py

@@ -1,18 +1,13 @@
 import pyray as rl
 from enum import IntEnum
 import cereal.messaging as messaging
-from openpilot.system.ui.lib.application import gui_app
 from openpilot.selfdrive.ui.layouts.sidebar import Sidebar, SIDEBAR_WIDTH
 from openpilot.selfdrive.ui.layouts.home import HomeLayout
 from openpilot.selfdrive.ui.layouts.settings.settings import SettingsLayout, PanelType
 from openpilot.selfdrive.ui.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.system.ui.widgets import Widget
-from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow
 
-from openpilot.common.params import Params
-if Params().get_bool("sunnypilot_ui"):
-  from openpilot.selfdrive.ui.sunnypilot.layouts.settings.settings import SettingsLayoutSP as SettingsLayout
 
 class MainState(IntEnum):
   HOME = 0
@@ -39,23 +34,16 @@ class MainLayout(Widget):
     # Set callbacks
     self._setup_callbacks()
 
-    # Start onboarding if terms or training not completed
-    self._onboarding_window = OnboardingWindow()
-    if not self._onboarding_window.completed:
-      gui_app.set_modal_overlay(self._onboarding_window)
-
   def _render(self, _):
     self._handle_onroad_transition()
     self._render_main_content()
 
   def _setup_callbacks(self):
     self._sidebar.set_callbacks(on_settings=self._on_settings_clicked,
-                                on_flag=self._on_bookmark_clicked,
-                                open_settings=lambda: self.open_settings(PanelType.TOGGLES))
+                                on_flag=self._on_bookmark_clicked)
     self._layouts[MainState.HOME]._setup_widget.set_open_settings_callback(lambda: self.open_settings(PanelType.FIREHOSE))
-    self._layouts[MainState.HOME].set_settings_callback(lambda: self.open_settings(PanelType.TOGGLES))
     self._layouts[MainState.SETTINGS].set_callbacks(on_close=self._set_mode_for_state)
-    self._layouts[MainState.ONROAD].set_click_callback(self._on_onroad_clicked)
+    self._layouts[MainState.ONROAD].set_callbacks(on_click=self._on_onroad_clicked)
     device.add_interactive_timeout_callback(self._set_mode_for_state)
 
   def _update_layout_rects(self):

selfdrive/ui/layouts/onboarding.py

@@ -1,214 +0,0 @@
-import os
-import re
-import threading
-from enum import IntEnum
-
-import pyray as rl
-from openpilot.common.basedir import BASEDIR
-from openpilot.system.ui.lib.application import FontWeight, gui_app
-from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets.button import Button, ButtonStyle
-from openpilot.system.ui.widgets.label import Label
-from openpilot.selfdrive.ui.ui_state import ui_state
-
-DEBUG = False
-
-STEP_RECTS = [rl.Rectangle(104, 800, 633, 175), rl.Rectangle(1835, 0, 2159, 1080), rl.Rectangle(1835, 0, 2156, 1080),
-              rl.Rectangle(1526, 473, 427, 472), rl.Rectangle(1643, 441, 217, 223), rl.Rectangle(1835, 0, 2155, 1080),
-              rl.Rectangle(1786, 591, 267, 236), rl.Rectangle(1353, 0, 804, 1080), rl.Rectangle(1458, 485, 633, 211),
-              rl.Rectangle(95, 794, 1158, 187), rl.Rectangle(1560, 170, 392, 397), rl.Rectangle(1835, 0, 2159, 1080),
-              rl.Rectangle(1351, 0, 807, 1080), rl.Rectangle(1835, 0, 2158, 1080), rl.Rectangle(1531, 82, 441, 920),
-              rl.Rectangle(1336, 438, 490, 393), rl.Rectangle(1835, 0, 2159, 1080), rl.Rectangle(1835, 0, 2159, 1080),
-              rl.Rectangle(87, 795, 1187, 186)]
-
-DM_RECORD_STEP = 9
-DM_RECORD_YES_RECT = rl.Rectangle(695, 794, 558, 187)
-
-RESTART_TRAINING_RECT = rl.Rectangle(87, 795, 472, 186)
-
-
-class OnboardingState(IntEnum):
-  TERMS = 0
-  ONBOARDING = 1
-  DECLINE = 2
-
-
-class TrainingGuide(Widget):
-  def __init__(self, completed_callback=None):
-    super().__init__()
-    self._completed_callback = completed_callback
-
-    self._step = 0
-    self._load_image_paths()
-
-    # Load first image now so we show something immediately
-    self._textures = [gui_app.texture(self._image_paths[0])]
-    self._image_objs = []
-
-    threading.Thread(target=self._preload_thread, daemon=True).start()
-
-  def _load_image_paths(self):
-    paths = [fn for fn in os.listdir(os.path.join(BASEDIR, "selfdrive/assets/training")) if re.match(r'^step\d*\.png$', fn)]
-    paths = sorted(paths, key=lambda x: int(re.search(r'\d+', x).group()))
-    self._image_paths = [os.path.join(BASEDIR, "selfdrive/assets/training", fn) for fn in paths]
-
-  def _preload_thread(self):
-    # PNG loading is slow in raylib, so we preload in a thread and upload to GPU in main thread
-    # We've already loaded the first image on init
-    for path in self._image_paths[1:]:
-      self._image_objs.append(gui_app._load_image_from_path(path))
-
-  def _handle_mouse_release(self, mouse_pos):
-    if rl.check_collision_point_rec(mouse_pos, STEP_RECTS[self._step]):
-      # Record DM camera?
-      if self._step == DM_RECORD_STEP:
-        yes = rl.check_collision_point_rec(mouse_pos, DM_RECORD_YES_RECT)
-        print(f"putting RecordFront to {yes}")
-        ui_state.params.put_bool("RecordFront", yes)
-
-      # Restart training?
-      elif self._step == len(self._image_paths) - 1:
-        if rl.check_collision_point_rec(mouse_pos, RESTART_TRAINING_RECT):
-          self._step = -1
-
-      self._step += 1
-
-      # Finished?
-      if self._step >= len(self._image_paths):
-        self._step = 0
-        if self._completed_callback:
-          self._completed_callback()
-
-  def _update_state(self):
-    if len(self._image_objs):
-      self._textures.append(gui_app._load_texture_from_image(self._image_objs.pop(0)))
-
-  def _render(self, _):
-    # Safeguard against fast tapping
-    step = min(self._step, len(self._textures) - 1)
-    rl.draw_texture(self._textures[step], 0, 0, rl.WHITE)
-
-    # progress bar
-    if 0 < step < len(STEP_RECTS) - 1:
-      h = 20
-      w = int((step / (len(STEP_RECTS) - 1)) * self._rect.width)
-      rl.draw_rectangle(int(self._rect.x), int(self._rect.y + self._rect.height - h),
-                        w, h, rl.Color(70, 91, 234, 255))
-
-    if DEBUG:
-      rl.draw_rectangle_lines_ex(STEP_RECTS[step], 3, rl.RED)
-
-    return -1
-
-
-class TermsPage(Widget):
-  def __init__(self, on_accept=None, on_decline=None):
-    super().__init__()
-    self._on_accept = on_accept
-    self._on_decline = on_decline
-
-    self._title = Label(tr("Welcome to openpilot"), font_size=90, font_weight=FontWeight.BOLD, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)
-    self._desc = Label(tr("You must accept the Terms and Conditions to use openpilot. Read the latest terms at https://comma.ai/terms before continuing."),
-                       font_size=90, font_weight=FontWeight.MEDIUM, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)
-
-    self._decline_btn = Button(tr("Decline"), click_callback=on_decline)
-    self._accept_btn = Button(tr("Agree"), button_style=ButtonStyle.PRIMARY, click_callback=on_accept)
-
-  def _render(self, _):
-    welcome_x = self._rect.x + 165
-    welcome_y = self._rect.y + 165
-    welcome_rect = rl.Rectangle(welcome_x, welcome_y, self._rect.width - welcome_x, 90)
-    self._title.render(welcome_rect)
-
-    desc_x = welcome_x
-    # TODO: Label doesn't top align when wrapping
-    desc_y = welcome_y - 100
-    desc_rect = rl.Rectangle(desc_x, desc_y, self._rect.width - desc_x, self._rect.height - desc_y - 250)
-    self._desc.render(desc_rect)
-
-    btn_y = self._rect.y + self._rect.height - 160 - 45
-    btn_width = (self._rect.width - 45 * 3) / 2
-    self._decline_btn.render(rl.Rectangle(self._rect.x + 45, btn_y, btn_width, 160))
-    self._accept_btn.render(rl.Rectangle(self._rect.x + 45 * 2 + btn_width, btn_y, btn_width, 160))
-
-    if DEBUG:
-      rl.draw_rectangle_lines_ex(welcome_rect, 3, rl.RED)
-      rl.draw_rectangle_lines_ex(desc_rect, 3, rl.RED)
-
-    return -1
-
-
-class DeclinePage(Widget):
-  def __init__(self, back_callback=None):
-    super().__init__()
-    self._text = Label(tr("You must accept the Terms and Conditions in order to use openpilot."),
-                       font_size=90, font_weight=FontWeight.MEDIUM, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)
-    self._back_btn = Button(tr("Back"), click_callback=back_callback)
-    self._uninstall_btn = Button(tr("Decline, uninstall openpilot"), button_style=ButtonStyle.DANGER,
-                                 click_callback=self._on_uninstall_clicked)
-
-  def _on_uninstall_clicked(self):
-    ui_state.params.put_bool("DoUninstall", True)
-    gui_app.request_close()
-
-  def _render(self, _):
-    btn_y = self._rect.y + self._rect.height - 160 - 45
-    btn_width = (self._rect.width - 45 * 3) / 2
-    self._back_btn.render(rl.Rectangle(self._rect.x + 45, btn_y, btn_width, 160))
-    self._uninstall_btn.render(rl.Rectangle(self._rect.x + 45 * 2 + btn_width, btn_y, btn_width, 160))
-
-    # text rect in middle of top and button
-    text_height = btn_y - (200 + 45)
-    text_rect = rl.Rectangle(self._rect.x + 165, self._rect.y + (btn_y - text_height) / 2 + 10, self._rect.width - (165 * 2), text_height)
-    if DEBUG:
-      rl.draw_rectangle_lines_ex(text_rect, 3, rl.RED)
-    self._text.render(text_rect)
-
-
-class OnboardingWindow(Widget):
-  def __init__(self):
-    super().__init__()
-    self._current_terms_version = ui_state.params.get("TermsVersion")
-    self._current_training_version = ui_state.params.get("TrainingVersion")
-    self._accepted_terms: bool = ui_state.params.get("HasAcceptedTerms") == self._current_terms_version
-    self._training_done: bool = ui_state.params.get("CompletedTrainingVersion") == self._current_training_version
-
-    self._state = OnboardingState.TERMS if not self._accepted_terms else OnboardingState.ONBOARDING
-
-    # Windows
-    self._terms = TermsPage(on_accept=self._on_terms_accepted, on_decline=self._on_terms_declined)
-    self._training_guide: TrainingGuide | None = None
-    self._decline_page = DeclinePage(back_callback=self._on_decline_back)
-
-  @property
-  def completed(self) -> bool:
-    return self._accepted_terms and self._training_done
-
-  def _on_terms_declined(self):
-    self._state = OnboardingState.DECLINE
-
-  def _on_decline_back(self):
-    self._state = OnboardingState.TERMS
-
-  def _on_terms_accepted(self):
-    ui_state.params.put("HasAcceptedTerms", self._current_terms_version)
-    self._state = OnboardingState.ONBOARDING
-    if self._training_done:
-      gui_app.set_modal_overlay(None)
-
-  def _on_completed_training(self):
-    ui_state.params.put("CompletedTrainingVersion", self._current_training_version)
-    gui_app.set_modal_overlay(None)
-
-  def _render(self, _):
-    if self._training_guide is None:
-      self._training_guide = TrainingGuide(completed_callback=self._on_completed_training)
-
-    if self._state == OnboardingState.TERMS:
-      self._terms.render(self._rect)
-    if self._state == OnboardingState.ONBOARDING:
-      self._training_guide.render(self._rect)
-    elif self._state == OnboardingState.DECLINE:
-      self._decline_page.render(self._rect)
-    return -1

selfdrive/ui/layouts/settings/developer.py

@@ -1,33 +1,20 @@
 from openpilot.common.params import Params
 from openpilot.selfdrive.ui.widgets.ssh_key import ssh_key_item
-from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.list_view import toggle_item
 from openpilot.system.ui.widgets.scroller import Scroller
-from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
-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
-
-if Params().get_bool("sunnypilot_ui"):
-  from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp as toggle_item
 
 # Description constants
 DESCRIPTIONS = {
-  'enable_adb': tr_noop(
+  'enable_adb': (
     "ADB (Android Debug Bridge) allows connecting to your device over USB or over the network. " +
     "See https://docs.comma.ai/how-to/connect-to-comma for more info."
   ),
-  'ssh_key': tr_noop(
+  'joystick_debug_mode': "Preview the driver facing camera to ensure that driver monitoring has good visibility. (vehicle must be off)",
+  'ssh_key': (
     "Warning: This grants SSH access to all public keys in your GitHub settings. Never enter a GitHub username " +
     "other than your own. A comma employee will NEVER ask you to add their GitHub username."
   ),
-  'alpha_longitudinal': tr_noop(
-    "<b>WARNING: openpilot longitudinal control is in alpha for this car and will disable Automatic Emergency Braking (AEB).</b><br><br>" +
-    "On this car, openpilot defaults to the car's built-in ACC instead of openpilot's longitudinal control. " +
-    "Enable this to switch to openpilot longitudinal control. Enabling Experimental mode is recommended when enabling openpilot longitudinal control alpha. " +
-    "Changing this setting will restart openpilot if the car is powered on."
-  ),
 }
 
 
@@ -35,154 +22,40 @@ class DeveloperLayout(Widget):
   def __init__(self):
     super().__init__()
     self._params = Params()
-    self._is_release = self._params.get_bool("IsReleaseBranch")
+    items = [
+      toggle_item(
+        "Enable ADB",
+        description=DESCRIPTIONS["enable_adb"],
+        initial_state=self._params.get_bool("AdbEnabled"),
+        callback=self._on_enable_adb,
+      ),
+      ssh_key_item("SSH Key", description=DESCRIPTIONS["ssh_key"]),
+      toggle_item(
+        "Joystick Debug Mode",
+        description=DESCRIPTIONS["joystick_debug_mode"],
+        initial_state=self._params.get_bool("JoystickDebugMode"),
+        callback=self._on_joystick_debug_mode,
+      ),
+      toggle_item(
+        "Longitudinal Maneuver Mode",
+        description="",
+        initial_state=self._params.get_bool("LongitudinalManeuverMode"),
+        callback=self._on_long_maneuver_mode,
+      ),
+      toggle_item(
+        "openpilot Longitudinal Control (Alpha)",
+        description="",
+        initial_state=self._params.get_bool("AlphaLongitudinalEnabled"),
+        callback=self._on_alpha_long_enabled,
+      ),
+    ]
 
-    # Build items and keep references for callbacks/state updates
-    self._adb_toggle = toggle_item(
-      lambda: tr("Enable ADB"),
-      description=lambda: tr(DESCRIPTIONS["enable_adb"]),
-      initial_state=self._params.get_bool("AdbEnabled"),
-      callback=self._on_enable_adb,
-      enabled=ui_state.is_offroad,
-    )
-
-    # SSH enable toggle + SSH key management
-    self._ssh_toggle = toggle_item(
-      lambda: tr("Enable SSH"),
-      description="",
-      initial_state=self._params.get_bool("SshEnabled"),
-      callback=self._on_enable_ssh,
-    )
-    self._ssh_keys = ssh_key_item(lambda: tr("SSH Keys"), description=lambda: tr(DESCRIPTIONS["ssh_key"]))
-
-    self._joystick_toggle = toggle_item(
-      lambda: tr("Joystick Debug Mode"),
-      description="",
-      initial_state=self._params.get_bool("JoystickDebugMode"),
-      callback=self._on_joystick_debug_mode,
-      enabled=ui_state.is_offroad,
-    )
-
-    self._long_maneuver_toggle = toggle_item(
-      lambda: tr("Longitudinal Maneuver Mode"),
-      description="",
-      initial_state=self._params.get_bool("LongitudinalManeuverMode"),
-      callback=self._on_long_maneuver_mode,
-    )
-
-    self._alpha_long_toggle = toggle_item(
-      lambda: tr("openpilot Longitudinal Control (Alpha)"),
-      description=lambda: tr(DESCRIPTIONS["alpha_longitudinal"]),
-      initial_state=self._params.get_bool("AlphaLongitudinalEnabled"),
-      callback=self._on_alpha_long_enabled,
-      enabled=lambda: not ui_state.engaged,
-    )
-
-    self._ui_debug_toggle = toggle_item(
-      lambda: tr("UI Debug Mode"),
-      description="",
-      initial_state=self._params.get_bool("ShowDebugInfo"),
-      callback=self._on_enable_ui_debug,
-    )
-    self._on_enable_ui_debug(self._params.get_bool("ShowDebugInfo"))
-
-    self._scroller = Scroller([
-      self._adb_toggle,
-      self._ssh_toggle,
-      self._ssh_keys,
-      self._joystick_toggle,
-      self._long_maneuver_toggle,
-      self._alpha_long_toggle,
-      self._ui_debug_toggle,
-    ], line_separator=True, spacing=0)
-
-    # Toggles should be not available to change in onroad state
-    ui_state.add_offroad_transition_callback(self._update_toggles)
+    self._scroller = Scroller(items, line_separator=True, spacing=0)
 
   def _render(self, rect):
     self._scroller.render(rect)
 
-  def show_event(self):
-    self._scroller.show_event()
-    self._update_toggles()
-
-  def _update_toggles(self):
-    ui_state.update_params()
-
-    # Hide non-release toggles on release builds
-    # TODO: we can do an onroad cycle, but alpha long toggle requires a deinit function to re-enable radar and not fault
-    for item in (self._joystick_toggle, self._long_maneuver_toggle, self._alpha_long_toggle):
-      item.set_visible(not self._is_release)
-
-    # CP gating
-    if ui_state.CP is not None:
-      alpha_avail = ui_state.CP.alphaLongitudinalAvailable
-      if not alpha_avail or self._is_release:
-        self._alpha_long_toggle.set_visible(False)
-        self._params.remove("AlphaLongitudinalEnabled")
-      else:
-        self._alpha_long_toggle.set_visible(True)
-
-      long_man_enabled = ui_state.has_longitudinal_control and ui_state.is_offroad()
-      self._long_maneuver_toggle.action_item.set_enabled(long_man_enabled)
-      if not long_man_enabled:
-        self._long_maneuver_toggle.action_item.set_state(False)
-        self._params.put_bool("LongitudinalManeuverMode", False)
-    else:
-      self._long_maneuver_toggle.action_item.set_enabled(False)
-      self._alpha_long_toggle.set_visible(False)
-
-    # TODO: make a param control list item so we don't need to manage internal state as much here
-    # refresh toggles from params to mirror external changes
-    for key, item in (
-      ("AdbEnabled", self._adb_toggle),
-      ("SshEnabled", self._ssh_toggle),
-      ("JoystickDebugMode", self._joystick_toggle),
-      ("LongitudinalManeuverMode", self._long_maneuver_toggle),
-      ("AlphaLongitudinalEnabled", self._alpha_long_toggle),
-      ("ShowDebugInfo", self._ui_debug_toggle),
-    ):
-      item.action_item.set_state(self._params.get_bool(key))
-
-  def _on_enable_ui_debug(self, state: bool):
-    self._params.put_bool("ShowDebugInfo", state)
-    gui_app.set_show_touches(state)
-    gui_app.set_show_fps(state)
-
-  def _on_enable_adb(self, state: bool):
-    self._params.put_bool("AdbEnabled", state)
-
-  def _on_enable_ssh(self, state: bool):
-    self._params.put_bool("SshEnabled", state)
-
-  def _on_joystick_debug_mode(self, state: bool):
-    self._params.put_bool("JoystickDebugMode", state)
-    self._params.put_bool("LongitudinalManeuverMode", False)
-    self._long_maneuver_toggle.action_item.set_state(False)
-
-  def _on_long_maneuver_mode(self, state: bool):
-    self._params.put_bool("LongitudinalManeuverMode", state)
-    self._params.put_bool("JoystickDebugMode", False)
-    self._joystick_toggle.action_item.set_state(False)
-
-  def _on_alpha_long_enabled(self, state: bool):
-    if state:
-      def confirm_callback(result: int):
-        if result == DialogResult.CONFIRM:
-          self._params.put_bool("AlphaLongitudinalEnabled", True)
-          self._params.put_bool("OnroadCycleRequested", True)
-          self._update_toggles()
-        else:
-          self._alpha_long_toggle.action_item.set_state(False)
-
-      # show confirmation dialog
-      content = (f"<h1>{self._alpha_long_toggle.title}</h1><br>" +
-                 f"<p>{self._alpha_long_toggle.description}</p>")
-
-      dlg = ConfirmDialog(content, tr("Enable"), rich=True)
-      gui_app.set_modal_overlay(dlg, callback=confirm_callback)
-
-    else:
-      self._params.put_bool("AlphaLongitudinalEnabled", False)
-      self._params.put_bool("OnroadCycleRequested", True)
-      self._update_toggles()
+  def _on_enable_adb(self): pass
+  def _on_joystick_debug_mode(self): pass
+  def _on_long_maneuver_mode(self): pass
+  def _on_alpha_long_enabled(self): pass

selfdrive/ui/layouts/settings/device.py

@@ -1,30 +1,29 @@
 import os
-import math
+import json
 
-from cereal import messaging, log
 from openpilot.common.basedir import BASEDIR
 from openpilot.common.params import Params
-from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.ui.onroad.driver_camera_dialog import DriverCameraDialog
 from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.selfdrive.ui.layouts.onboarding import TrainingGuide
 from openpilot.selfdrive.ui.widgets.pairing_dialog import PairingDialog
 from openpilot.system.hardware import TICI
-from openpilot.system.ui.lib.application import FontWeight, gui_app
-from openpilot.system.ui.lib.multilang import multilang, tr, tr_noop
+from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import Widget, DialogResult
-from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog, alert_dialog
-from openpilot.system.ui.widgets.html_render import HtmlModal
+from openpilot.system.ui.widgets.confirm_dialog import confirm_dialog, alert_dialog
+from openpilot.system.ui.widgets.html_render import HtmlRenderer
 from openpilot.system.ui.widgets.list_view import text_item, button_item, dual_button_item
 from openpilot.system.ui.widgets.option_dialog import MultiOptionDialog
 from openpilot.system.ui.widgets.scroller import Scroller
 
 # Description constants
 DESCRIPTIONS = {
-  'pair_device': tr_noop("Pair your device with comma connect (connect.comma.ai) and claim your comma prime offer."),
-  'driver_camera': tr_noop("Preview the driver facing camera to ensure that driver monitoring has good visibility. (vehicle must be off)"),
-  'reset_calibration': tr_noop("openpilot requires the device to be mounted within 4° left or right and within 5° up or 9° down."),
-  'review_guide': tr_noop("Review the rules, features, and limitations of openpilot"),
+  'pair_device': "Pair your device with comma connect (connect.comma.ai) and claim your comma prime offer.",
+  'driver_camera': "Preview the driver facing camera to ensure that driver monitoring has good visibility. (vehicle must be off)",
+  'reset_calibration': (
+      "openpilot requires the device to be mounted within 4° left or right and within 5° " +
+      "up or 9° down. openpilot is continuously calibrating, resetting is rarely required."
+  ),
+  'review_guide': "Review the rules, features, and limitations of openpilot",
 }
 
 
@@ -36,61 +35,49 @@ class DeviceLayout(Widget):
     self._select_language_dialog: MultiOptionDialog | None = None
     self._driver_camera: DriverCameraDialog | None = None
     self._pair_device_dialog: PairingDialog | None = None
-    self._fcc_dialog: HtmlModal | None = None
-    self._training_guide: TrainingGuide | None = None
+    self._fcc_dialog: HtmlRenderer | None = None
 
     items = self._initialize_items()
     self._scroller = Scroller(items, line_separator=True, spacing=0)
 
-    ui_state.add_offroad_transition_callback(self._offroad_transition)
-
   def _initialize_items(self):
-    self._pair_device_btn = button_item(lambda: tr("Pair Device"), lambda: tr("PAIR"), lambda: tr(DESCRIPTIONS['pair_device']), callback=self._pair_device)
-    self._pair_device_btn.set_visible(lambda: not ui_state.prime_state.is_paired())
-
-    self._reset_calib_btn = button_item(lambda: tr("Reset Calibration"), lambda: tr("RESET"), lambda: tr(DESCRIPTIONS['reset_calibration']),
-                                        callback=self._reset_calibration_prompt)
-    self._reset_calib_btn.set_description_opened_callback(self._update_calib_description)
-
-    self._power_off_btn = dual_button_item(lambda: tr("Reboot"), lambda: tr("Power Off"),
-                                           left_callback=self._reboot_prompt, right_callback=self._power_off_prompt)
+    dongle_id = self._params.get("DongleId") or "N/A"
+    serial = self._params.get("HardwareSerial") or "N/A"
 
     items = [
-      text_item(lambda: tr("Dongle ID"), self._params.get("DongleId") or (lambda: tr("N/A"))),
-      text_item(lambda: tr("Serial"), self._params.get("HardwareSerial") or (lambda: tr("N/A"))),
-      self._pair_device_btn,
-      button_item(lambda: tr("Driver Camera"), lambda: tr("PREVIEW"), lambda: tr(DESCRIPTIONS['driver_camera']),
-                  callback=self._show_driver_camera, enabled=ui_state.is_offroad),
-      self._reset_calib_btn,
-      button_item(lambda: tr("Review Training Guide"), lambda: tr("REVIEW"), lambda: tr(DESCRIPTIONS['review_guide']),
-                  self._on_review_training_guide, enabled=ui_state.is_offroad),
-      regulatory_btn := button_item(lambda: tr("Regulatory"), lambda: tr("VIEW"), callback=self._on_regulatory, enabled=ui_state.is_offroad),
-      button_item(lambda: tr("Change Language"), lambda: tr("CHANGE"), callback=self._show_language_dialog),
-      self._power_off_btn,
+      text_item("Dongle ID", dongle_id),
+      text_item("Serial", serial),
+      button_item("Pair Device", "PAIR", DESCRIPTIONS['pair_device'], callback=self._pair_device),
+      button_item("Driver Camera", "PREVIEW", DESCRIPTIONS['driver_camera'], callback=self._show_driver_camera, enabled=ui_state.is_offroad),
+      button_item("Reset Calibration", "RESET", DESCRIPTIONS['reset_calibration'], callback=self._reset_calibration_prompt),
+      regulatory_btn := button_item("Regulatory", "VIEW", callback=self._on_regulatory),
+      button_item("Review Training Guide", "REVIEW", DESCRIPTIONS['review_guide'], self._on_review_training_guide),
+      button_item("Change Language", "CHANGE", callback=self._show_language_selection, enabled=ui_state.is_offroad),
+      dual_button_item("Reboot", "Power Off", left_callback=self._reboot_prompt, right_callback=self._power_off_prompt),
     ]
     regulatory_btn.set_visible(TICI)
     return items
 
-  def _offroad_transition(self):
-    self._power_off_btn.action_item.right_button.set_visible(ui_state.is_offroad())
-
-  def show_event(self):
-    self._scroller.show_event()
-
   def _render(self, rect):
     self._scroller.render(rect)
 
-  def _show_language_dialog(self):
-    def handle_language_selection(result: int):
-      if result == 1 and self._select_language_dialog:
-        selected_language = multilang.languages[self._select_language_dialog.selection]
-        multilang.change_language(selected_language)
-        self._update_calib_description()
-      self._select_language_dialog = None
+  def _show_language_selection(self):
+    try:
+      languages_file = os.path.join(BASEDIR, "selfdrive/ui/translations/languages.json")
+      with open(languages_file, encoding='utf-8') as f:
+        languages = json.load(f)
 
-    self._select_language_dialog = MultiOptionDialog(tr("Select a language"), multilang.languages, multilang.codes[multilang.language],
-                                                     option_font_weight=FontWeight.UNIFONT)
-    gui_app.set_modal_overlay(self._select_language_dialog, callback=handle_language_selection)
+      self._select_language_dialog = MultiOptionDialog("Select a language", languages)
+      gui_app.set_modal_overlay(self._select_language_dialog, callback=self._handle_language_selection)
+    except FileNotFoundError:
+      pass
+
+  def _handle_language_selection(self, result: int):
+    if result == 1 and self._select_language_dialog:
+      selected_language = self._select_language_dialog.selection
+      self._params.put("LanguageSetting", selected_language)
+
+    self._select_language_dialog = None
 
   def _show_driver_camera(self):
     if not self._driver_camera:
@@ -100,80 +87,34 @@ class DeviceLayout(Widget):
 
   def _reset_calibration_prompt(self):
     if ui_state.engaged:
-      gui_app.set_modal_overlay(alert_dialog(tr("Disengage to Reset Calibration")))
+      gui_app.set_modal_overlay(lambda: alert_dialog("Disengage to Reset Calibration"))
       return
 
-    def reset_calibration(result: int):
-      # Check engaged again in case it changed while the dialog was open
-      if ui_state.engaged or result != DialogResult.CONFIRM:
-        return
+    gui_app.set_modal_overlay(
+      lambda: confirm_dialog("Are you sure you want to reset calibration?", "Reset"),
+      callback=self._reset_calibration,
+    )
 
-      self._params.remove("CalibrationParams")
-      self._params.remove("LiveTorqueParameters")
-      self._params.remove("LiveParameters")
-      self._params.remove("LiveParametersV2")
-      self._params.remove("LiveDelay")
-      self._params.put_bool("OnroadCycleRequested", True)
-      self._update_calib_description()
+  def _reset_calibration(self, result: int):
+    if ui_state.engaged or result != DialogResult.CONFIRM:
+      return
 
-    dialog = ConfirmDialog(tr("Are you sure you want to reset calibration?"), tr("Reset"))
-    gui_app.set_modal_overlay(dialog, callback=reset_calibration)
-
-  def _update_calib_description(self):
-    desc = tr(DESCRIPTIONS['reset_calibration'])
-
-    calib_bytes = self._params.get("CalibrationParams")
-    if calib_bytes:
-      try:
-        calib = messaging.log_from_bytes(calib_bytes, log.Event).liveCalibration
-
-        if calib.calStatus != log.LiveCalibrationData.Status.uncalibrated:
-          pitch = math.degrees(calib.rpyCalib[1])
-          yaw = math.degrees(calib.rpyCalib[2])
-          desc += tr(" Your device is pointed {:.1f}° {} and {:.1f}° {}.").format(abs(pitch), tr("down") if pitch > 0 else tr("up"),
-                                                                                  abs(yaw), tr("left") if yaw > 0 else tr("right"))
-      except Exception:
-        cloudlog.exception("invalid CalibrationParams")
-
-    lag_perc = 0
-    lag_bytes = self._params.get("LiveDelay")
-    if lag_bytes:
-      try:
-        lag_perc = messaging.log_from_bytes(lag_bytes, log.Event).liveDelay.calPerc
-      except Exception:
-        cloudlog.exception("invalid LiveDelay")
-    if lag_perc < 100:
-      desc += tr("<br><br>Steering lag calibration is {}% complete.").format(lag_perc)
-    else:
-      desc += tr("<br><br>Steering lag calibration is complete.")
-
-    torque_bytes = self._params.get("LiveTorqueParameters")
-    if torque_bytes:
-      try:
-        torque = messaging.log_from_bytes(torque_bytes, log.Event).liveTorqueParameters
-        # don't add for non-torque cars
-        if torque.useParams:
-          torque_perc = torque.calPerc
-          if torque_perc < 100:
-            desc += tr(" Steering torque response calibration is {}% complete.").format(torque_perc)
-          else:
-            desc += tr(" Steering torque response calibration is complete.")
-      except Exception:
-        cloudlog.exception("invalid LiveTorqueParameters")
-
-    desc += "<br><br>"
-    desc += tr("openpilot is continuously calibrating, resetting is rarely required. " +
-               "Resetting calibration will restart openpilot if the car is powered on.")
-
-    self._reset_calib_btn.set_description(desc)
+    self._params.remove("CalibrationParams")
+    self._params.remove("LiveTorqueParameters")
+    self._params.remove("LiveParameters")
+    self._params.remove("LiveParametersV2")
+    self._params.remove("LiveDelay")
+    self._params.put_bool("OnroadCycleRequested", True)
 
   def _reboot_prompt(self):
     if ui_state.engaged:
-      gui_app.set_modal_overlay(alert_dialog(tr("Disengage to Reboot")))
+      gui_app.set_modal_overlay(lambda: alert_dialog("Disengage to Reboot"))
       return
 
-    dialog = ConfirmDialog(tr("Are you sure you want to reboot?"), tr("Reboot"))
-    gui_app.set_modal_overlay(dialog, callback=self._perform_reboot)
+    gui_app.set_modal_overlay(
+      lambda: confirm_dialog("Are you sure you want to reboot?", "Reboot"),
+      callback=self._perform_reboot,
+    )
 
   def _perform_reboot(self, result: int):
     if not ui_state.engaged and result == DialogResult.CONFIRM:
@@ -181,11 +122,13 @@ class DeviceLayout(Widget):
 
   def _power_off_prompt(self):
     if ui_state.engaged:
-      gui_app.set_modal_overlay(alert_dialog(tr("Disengage to Power Off")))
+      gui_app.set_modal_overlay(lambda: alert_dialog("Disengage to Power Off"))
       return
 
-    dialog = ConfirmDialog(tr("Are you sure you want to power off?"), tr("Power Off"))
-    gui_app.set_modal_overlay(dialog, callback=self._perform_power_off)
+    gui_app.set_modal_overlay(
+      lambda: confirm_dialog("Are you sure you want to power off?", "Power Off"),
+      callback=self._perform_power_off,
+    )
 
   def _perform_power_off(self, result: int):
     if not ui_state.engaged and result == DialogResult.CONFIRM:
@@ -198,13 +141,10 @@ class DeviceLayout(Widget):
 
   def _on_regulatory(self):
     if not self._fcc_dialog:
-      self._fcc_dialog = HtmlModal(os.path.join(BASEDIR, "selfdrive/assets/offroad/fcc.html"))
-    gui_app.set_modal_overlay(self._fcc_dialog)
+      self._fcc_dialog = HtmlRenderer(os.path.join(BASEDIR, "selfdrive/assets/offroad/fcc.html"))
 
-  def _on_review_training_guide(self):
-    if not self._training_guide:
-      def completed_callback():
-        gui_app.set_modal_overlay(None)
+    gui_app.set_modal_overlay(self._fcc_dialog,
+      callback=lambda result: setattr(self, '_fcc_dialog', None),
+    )
 
-      self._training_guide = TrainingGuide(completed_callback=completed_callback)
-    gui_app.set_modal_overlay(self._training_guide)
+  def _on_review_training_guide(self): pass

selfdrive/ui/layouts/settings/firehose.py

@@ -7,23 +7,21 @@ from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.athena.registration import UNREGISTERED_DONGLE_ID
-from openpilot.system.ui.lib.application import gui_app, FontWeight, FONT_SCALE
-from openpilot.system.ui.lib.multilang import tr, trn, tr_noop
-from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.scroll_panel import GuiScrollPanel
 from openpilot.system.ui.lib.wrap_text import wrap_text
 from openpilot.system.ui.widgets import Widget
 from openpilot.selfdrive.ui.lib.api_helpers import get_token
 
-TITLE = tr_noop("Firehose Mode")
-DESCRIPTION = tr_noop(
+TITLE = "Firehose Mode"
+DESCRIPTION = (
   "openpilot learns to drive by watching humans, like you, drive.\n\n"
   + "Firehose Mode allows you to maximize your training data uploads to improve "
   + "openpilot's driving models. More data means bigger models, which means better Experimental Mode."
 )
-INSTRUCTIONS = tr_noop(
+INSTRUCTIONS = (
   "For maximum effectiveness, bring your device inside and connect to a good USB-C adapter and Wi-Fi weekly.\n\n"
-  + "Firehose Mode can also work while you're driving if connected to a hotspot or unlimited SIM card.\n\n\n"
+  + "Firehose Mode can also work while you're driving if connected to a hotspot or unlimited SIM card.\n\n"
   + "Frequently Asked Questions\n\n"
   + "Does it matter how or where I drive? Nope, just drive as you normally would.\n\n"
   + "Do all of my segments get pulled in Firehose Mode? No, we selectively pull a subset of your segments.\n\n"
@@ -45,16 +43,12 @@ class FirehoseLayout(Widget):
     self.params = Params()
     self.segment_count = self._get_segment_count()
     self.scroll_panel = GuiScrollPanel()
-    self._content_height = 0
 
     self.running = True
     self.update_thread = threading.Thread(target=self._update_loop, daemon=True)
     self.update_thread.start()
     self.last_update_time = 0
 
-  def show_event(self):
-    self.scroll_panel.set_offset(0)
-
   def _get_segment_count(self) -> int:
     stats = self.params.get(self.PARAM_KEY)
     if not stats:
@@ -72,72 +66,97 @@ class FirehoseLayout(Widget):
 
   def _render(self, rect: rl.Rectangle):
     # Calculate content dimensions
-    content_rect = rl.Rectangle(rect.x, rect.y, rect.width, self._content_height)
+    content_width = rect.width - 80
+    content_height = self._calculate_content_height(int(content_width))
+    content_rect = rl.Rectangle(rect.x, rect.y, rect.width, content_height)
 
     # Handle scrolling and render with clipping
-    scroll_offset = self.scroll_panel.update(rect, content_rect)
+    scroll_offset = self.scroll_panel.handle_scroll(rect, content_rect)
     rl.begin_scissor_mode(int(rect.x), int(rect.y), int(rect.width), int(rect.height))
-    self._content_height = self._render_content(rect, scroll_offset)
+    self._render_content(rect, scroll_offset)
     rl.end_scissor_mode()
 
-  def _render_content(self, rect: rl.Rectangle, scroll_offset: float) -> int:
-    x = int(rect.x + 40)
-    y = int(rect.y + 40 + scroll_offset)
-    w = int(rect.width - 80)
+  def _calculate_content_height(self, content_width: int) -> int:
+    height = 80  # Top margin
 
-    # Title (centered)
-    title_text = tr(TITLE)  # live translate
-    title_font = gui_app.font(FontWeight.MEDIUM)
-    text_width = measure_text_cached(title_font, title_text, 100).x
-    title_x = rect.x + (rect.width - text_width) / 2
-    rl.draw_text_ex(title_font, title_text, rl.Vector2(title_x, y), 100, 0, rl.WHITE)
-    y += 200
+    # Title
+    height += 100 + 40
 
     # Description
-    y = self._draw_wrapped_text(x, y, w, tr(DESCRIPTION), gui_app.font(FontWeight.NORMAL), 45, rl.WHITE)
-    y += 40 + 20
+    desc_font = gui_app.font(FontWeight.NORMAL)
+    desc_lines = wrap_text(desc_font, DESCRIPTION, 45, content_width)
+    height += len(desc_lines) * 45 + 40
+
+    # Status section
+    height += 32  # Separator
+    status_text, _ = self._get_status()
+    status_lines = wrap_text(gui_app.font(FontWeight.BOLD), status_text, 60, content_width)
+    height += len(status_lines) * 60 + 20
+
+    # Contribution count (if available)
+    if self.segment_count > 0:
+      contrib_text = f"{self.segment_count} segment(s) of your driving is in the training dataset so far."
+      contrib_lines = wrap_text(gui_app.font(FontWeight.BOLD), contrib_text, 52, content_width)
+      height += len(contrib_lines) * 52 + 20
+
+    # Instructions section
+    height += 32  # Separator
+    inst_lines = wrap_text(gui_app.font(FontWeight.NORMAL), INSTRUCTIONS, 40, content_width)
+    height += len(inst_lines) * 40 + 40  # Bottom margin
+
+    return height
+
+  def _render_content(self, rect: rl.Rectangle, scroll_offset: rl.Vector2):
+    x = int(rect.x + 40)
+    y = int(rect.y + 40 + scroll_offset.y)
+    w = int(rect.width - 80)
+
+    # Title
+    title_font = gui_app.font(FontWeight.MEDIUM)
+    rl.draw_text_ex(title_font, TITLE, rl.Vector2(x, y), 100, 0, rl.WHITE)
+    y += 140
+
+    # Description
+    y = self._draw_wrapped_text(x, y, w, DESCRIPTION, gui_app.font(FontWeight.NORMAL), 45, rl.WHITE)
+    y += 40
 
     # Separator
     rl.draw_rectangle(x, y, w, 2, self.GRAY)
-    y += 30 + 20
+    y += 30
 
     # Status
     status_text, status_color = self._get_status()
     y = self._draw_wrapped_text(x, y, w, status_text, gui_app.font(FontWeight.BOLD), 60, status_color)
-    y += 20 + 20
+    y += 20
 
     # Contribution count (if available)
     if self.segment_count > 0:
-      contrib_text = trn("{} segment of your driving is in the training dataset so far.",
-                         "{} segments of your driving is in the training dataset so far.", self.segment_count).format(self.segment_count)
+      contrib_text = f"{self.segment_count} segment(s) of your driving is in the training dataset so far."
       y = self._draw_wrapped_text(x, y, w, contrib_text, gui_app.font(FontWeight.BOLD), 52, rl.WHITE)
-      y += 20 + 20
+      y += 20
 
     # Separator
     rl.draw_rectangle(x, y, w, 2, self.GRAY)
-    y += 30 + 20
+    y += 30
 
     # Instructions
-    y = self._draw_wrapped_text(x, y, w, tr(INSTRUCTIONS), gui_app.font(FontWeight.NORMAL), 40, self.LIGHT_GRAY)
+    self._draw_wrapped_text(x, y, w, INSTRUCTIONS, gui_app.font(FontWeight.NORMAL), 40, self.LIGHT_GRAY)
 
-    # bottom margin + remove effect of scroll offset
-    return int(round(y - self.scroll_panel.offset + 40))
-
-  def _draw_wrapped_text(self, x, y, width, text, font, font_size, color):
-    wrapped = wrap_text(font, text, font_size, width)
+  def _draw_wrapped_text(self, x, y, width, text, font, size, color):
+    wrapped = wrap_text(font, text, size, width)
     for line in wrapped:
-      rl.draw_text_ex(font, line, rl.Vector2(x, y), font_size, 0, color)
-      y += font_size * FONT_SCALE
-    return round(y)
+      rl.draw_text_ex(font, line, rl.Vector2(x, y), size, 0, color)
+      y += size
+    return y
 
   def _get_status(self) -> tuple[str, rl.Color]:
     network_type = ui_state.sm["deviceState"].networkType
     network_metered = ui_state.sm["deviceState"].networkMetered
 
     if not network_metered and network_type != 0:  # Not metered and connected
-      return tr("ACTIVE"), self.GREEN
+      return "ACTIVE", self.GREEN
     else:
-      return tr("INACTIVE: connect to an unmetered network"), self.RED
+      return "INACTIVE: connect to an unmetered network", self.RED
 
   def _fetch_firehose_stats(self):
     try:

selfdrive/ui/layouts/settings/settings.py

@@ -8,16 +8,18 @@ from openpilot.selfdrive.ui.layouts.settings.firehose import FirehoseLayout
 from openpilot.selfdrive.ui.layouts.settings.software import SoftwareLayout
 from openpilot.selfdrive.ui.layouts.settings.toggles import TogglesLayout
 from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
-from openpilot.system.ui.lib.multilang import tr, tr_noop
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.lib.wifi_manager import WifiManager
 from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets.network import NetworkUI
+from openpilot.system.ui.widgets.network import WifiManagerUI
+
+# Settings close button
+SETTINGS_CLOSE_TEXT = "×"
+SETTINGS_CLOSE_TEXT_Y_OFFSET = 8  # The '×' character isn't quite vertically centered in the font so we need to offset it a bit to fully center it
 
 # Constants
 SIDEBAR_WIDTH = 500
 CLOSE_BTN_SIZE = 200
-CLOSE_ICON_SIZE = 70
 NAV_BTN_HEIGHT = 110
 PANEL_MARGIN = 50
 
@@ -56,16 +58,15 @@ class SettingsLayout(Widget):
     wifi_manager.set_active(False)
 
     self._panels = {
-      PanelType.DEVICE: PanelInfo(tr_noop("Device"), DeviceLayout()),
-      PanelType.NETWORK: PanelInfo(tr_noop("Network"), NetworkUI(wifi_manager)),
-      PanelType.TOGGLES: PanelInfo(tr_noop("Toggles"), TogglesLayout()),
-      PanelType.SOFTWARE: PanelInfo(tr_noop("Software"), SoftwareLayout()),
-      PanelType.FIREHOSE: PanelInfo(tr_noop("Firehose"), FirehoseLayout()),
-      PanelType.DEVELOPER: PanelInfo(tr_noop("Developer"), DeveloperLayout()),
+      PanelType.DEVICE: PanelInfo("Device", DeviceLayout()),
+      PanelType.NETWORK: PanelInfo("Network", WifiManagerUI(wifi_manager)),
+      PanelType.TOGGLES: PanelInfo("Toggles", TogglesLayout()),
+      PanelType.SOFTWARE: PanelInfo("Software", SoftwareLayout()),
+      PanelType.FIREHOSE: PanelInfo("Firehose", FirehoseLayout()),
+      PanelType.DEVELOPER: PanelInfo("Developer", DeveloperLayout()),
     }
 
     self._font_medium = gui_app.font(FontWeight.MEDIUM)
-    self._close_icon = gui_app.texture("icons/close2.png", CLOSE_ICON_SIZE, CLOSE_ICON_SIZE)
 
     # Callbacks
     self._close_callback: Callable | None = None
@@ -95,21 +96,12 @@ class SettingsLayout(Widget):
     close_color = CLOSE_BTN_PRESSED if pressed else CLOSE_BTN_COLOR
     rl.draw_rectangle_rounded(close_btn_rect, 1.0, 20, close_color)
 
-    icon_color = rl.Color(255, 255, 255, 255) if not pressed else rl.Color(220, 220, 220, 255)
-    icon_dest = rl.Rectangle(
-      close_btn_rect.x + (close_btn_rect.width - self._close_icon.width) / 2,
-      close_btn_rect.y + (close_btn_rect.height - self._close_icon.height) / 2,
-      self._close_icon.width,
-      self._close_icon.height,
-    )
-    rl.draw_texture_pro(
-      self._close_icon,
-      rl.Rectangle(0, 0, self._close_icon.width, self._close_icon.height),
-      icon_dest,
-      rl.Vector2(0, 0),
-      0,
-      icon_color,
+    close_text_size = measure_text_cached(self._font_medium, SETTINGS_CLOSE_TEXT, 140)
+    close_text_pos = rl.Vector2(
+      close_btn_rect.x + (close_btn_rect.width - close_text_size.x) / 2,
+      close_btn_rect.y + (close_btn_rect.height - close_text_size.y) / 2 - SETTINGS_CLOSE_TEXT_Y_OFFSET,
     )
+    rl.draw_text_ex(self._font_medium, SETTINGS_CLOSE_TEXT, close_text_pos, 140, 0, TEXT_SELECTED)
 
     # Store close button rect for click detection
     self._close_btn_rect = close_btn_rect
@@ -123,12 +115,11 @@ class SettingsLayout(Widget):
       is_selected = panel_type == self._current_panel
       text_color = TEXT_SELECTED if is_selected else TEXT_NORMAL
       # Draw button text (right-aligned)
-      panel_name = tr(panel_info.name)
-      text_size = measure_text_cached(self._font_medium, panel_name, 65)
+      text_size = measure_text_cached(self._font_medium, panel_info.name, 65)
       text_pos = rl.Vector2(
         button_rect.x + button_rect.width - text_size.x, button_rect.y + (button_rect.height - text_size.y) / 2
       )
-      rl.draw_text_ex(self._font_medium, panel_name, text_pos, 65, 0, text_color)
+      rl.draw_text_ex(self._font_medium, panel_info.name, text_pos, 65, 0, text_color)
 
       # Store button rect for click detection
       panel_info.button_rect = button_rect

selfdrive/ui/layouts/settings/software.py

@@ -1,194 +1,42 @@
-import os
-import time
-import datetime
-from openpilot.common.time_helpers import system_time_valid
-from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.common.params import Params
 from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.lib.multilang import tr, trn
 from openpilot.system.ui.widgets import Widget, DialogResult
-from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
-from openpilot.system.ui.widgets.list_view import button_item, text_item, ListItem
-from openpilot.system.ui.widgets.option_dialog import MultiOptionDialog
+from openpilot.system.ui.widgets.confirm_dialog import confirm_dialog
+from openpilot.system.ui.widgets.list_view import button_item, text_item
 from openpilot.system.ui.widgets.scroller import Scroller
 
-# TODO: remove this. updater fails to respond on startup if time is not correct
-UPDATED_TIMEOUT = 10  # seconds to wait for updated to respond
-
-
-def time_ago(date: datetime.datetime | None) -> str:
-  if not date:
-    return tr("never")
-
-  if not system_time_valid():
-    return date.strftime("%a %b %d %Y")
-
-  now = datetime.datetime.now(datetime.UTC)
-  if date.tzinfo is None:
-    date = date.replace(tzinfo=datetime.UTC)
-
-  diff_seconds = int((now - date).total_seconds())
-  if diff_seconds < 60:
-    return tr("now")
-  if diff_seconds < 3600:
-    m = diff_seconds // 60
-    return trn("{} minute ago", "{} minutes ago", m).format(m)
-  if diff_seconds < 86400:
-    h = diff_seconds // 3600
-    return trn("{} hour ago", "{} hours ago", h).format(h)
-  if diff_seconds < 604800:
-    d = diff_seconds // 86400
-    return trn("{} day ago", "{} days ago", d).format(d)
-  return date.strftime("%a %b %d %Y")
-
 
 class SoftwareLayout(Widget):
   def __init__(self):
     super().__init__()
 
-    self._onroad_label = ListItem(lambda: tr("Updates are only downloaded while the car is off."))
-    self._version_item = text_item(lambda: tr("Current Version"), ui_state.params.get("UpdaterCurrentDescription") or "")
-    self._download_btn = button_item(lambda: tr("Download"), lambda: tr("CHECK"), callback=self._on_download_update)
+    self._params = Params()
+    items = self._init_items()
+    self._scroller = Scroller(items, line_separator=True, spacing=0)
 
-    # Install button is initially hidden
-    self._install_btn = button_item(lambda: tr("Install Update"), lambda: tr("INSTALL"), callback=self._on_install_update)
-    self._install_btn.set_visible(False)
-
-    # Track waiting-for-updater transition to avoid brief re-enable while still idle
-    self._waiting_for_updater = False
-    self._waiting_start_ts: float = 0.0
-
-    # Branch switcher
-    self._branch_btn = button_item(lambda: tr("Target Branch"), lambda: tr("SELECT"), callback=self._on_select_branch)
-    self._branch_btn.set_visible(not ui_state.params.get_bool("IsTestedBranch"))
-    self._branch_btn.action_item.set_value(ui_state.params.get("UpdaterTargetBranch") or "")
-    self._branch_dialog: MultiOptionDialog | None = None
-
-    self._scroller = Scroller([
-      self._onroad_label,
-      self._version_item,
-      self._download_btn,
-      self._install_btn,
-      self._branch_btn,
-      button_item(lambda: tr("Uninstall"), lambda: tr("UNINSTALL"), callback=self._on_uninstall),
-    ], line_separator=True, spacing=0)
-
-  def show_event(self):
-    self._scroller.show_event()
+  def _init_items(self):
+    items = [
+      text_item("Current Version", ""),
+      button_item("Download", "CHECK", callback=self._on_download_update),
+      button_item("Install Update", "INSTALL", callback=self._on_install_update),
+      button_item("Target Branch", "SELECT", callback=self._on_select_branch),
+      button_item("Uninstall", "UNINSTALL", callback=self._on_uninstall),
+    ]
+    return items
 
   def _render(self, rect):
     self._scroller.render(rect)
 
-  def _update_state(self):
-    # Show/hide onroad warning
-    self._onroad_label.set_visible(ui_state.is_onroad())
-
-    # Update current version and release notes
-    current_desc = ui_state.params.get("UpdaterCurrentDescription") or ""
-    current_release_notes = (ui_state.params.get("UpdaterCurrentReleaseNotes") or b"").decode("utf-8", "replace")
-    self._version_item.action_item.set_text(current_desc)
-    self._version_item.set_description(current_release_notes)
-
-    # Update download button visibility and state
-    self._download_btn.set_visible(ui_state.is_offroad())
-
-    updater_state = ui_state.params.get("UpdaterState") or "idle"
-    failed_count = ui_state.params.get("UpdateFailedCount") or 0
-    fetch_available = ui_state.params.get_bool("UpdaterFetchAvailable")
-    update_available = ui_state.params.get_bool("UpdateAvailable")
-
-    if updater_state != "idle":
-      # Updater responded
-      self._waiting_for_updater = False
-      self._download_btn.action_item.set_enabled(False)
-      self._download_btn.action_item.set_value(updater_state)
-    else:
-      if failed_count > 0:
-        self._download_btn.action_item.set_value(tr("failed to check for update"))
-        self._download_btn.action_item.set_text(tr("CHECK"))
-      elif fetch_available:
-        self._download_btn.action_item.set_value(tr("update available"))
-        self._download_btn.action_item.set_text(tr("DOWNLOAD"))
-      else:
-        last_update = ui_state.params.get("LastUpdateTime")
-        if last_update:
-          formatted = time_ago(last_update)
-          self._download_btn.action_item.set_value(tr("up to date, last checked {}").format(formatted))
-        else:
-          self._download_btn.action_item.set_value(tr("up to date, last checked never"))
-        self._download_btn.action_item.set_text(tr("CHECK"))
-
-      # If we've been waiting too long without a state change, reset state
-      if self._waiting_for_updater and (time.monotonic() - self._waiting_start_ts > UPDATED_TIMEOUT):
-        self._waiting_for_updater = False
-
-      # Only enable if we're not waiting for updater to flip out of idle
-      self._download_btn.action_item.set_enabled(not self._waiting_for_updater)
-
-    # Update target branch button value
-    current_branch = ui_state.params.get("UpdaterTargetBranch") or ""
-    self._branch_btn.action_item.set_value(current_branch)
-
-    # Update install button
-    self._install_btn.set_visible(ui_state.is_offroad() and update_available)
-    if update_available:
-      new_desc = ui_state.params.get("UpdaterNewDescription") or ""
-      new_release_notes = (ui_state.params.get("UpdaterNewReleaseNotes") or b"").decode("utf-8", "replace")
-      self._install_btn.action_item.set_text(tr("INSTALL"))
-      self._install_btn.action_item.set_value(new_desc)
-      self._install_btn.set_description(new_release_notes)
-      # Enable install button for testing (like Qt showEvent)
-      self._install_btn.action_item.set_enabled(True)
-    else:
-      self._install_btn.set_visible(False)
-
-  def _on_download_update(self):
-    # Check if we should start checking or start downloading
-    self._download_btn.action_item.set_enabled(False)
-    if self._download_btn.action_item.text == tr("CHECK"):
-      # Start checking for updates
-      self._waiting_for_updater = True
-      self._waiting_start_ts = time.monotonic()
-      os.system("pkill -SIGUSR1 -f system.updated.updated")
-    else:
-      # Start downloading
-      self._waiting_for_updater = True
-      self._waiting_start_ts = time.monotonic()
-      os.system("pkill -SIGHUP -f system.updated.updated")
+  def _on_download_update(self): pass
+  def _on_install_update(self): pass
+  def _on_select_branch(self): pass
 
   def _on_uninstall(self):
     def handle_uninstall_confirmation(result):
       if result == DialogResult.CONFIRM:
-        ui_state.params.put_bool("DoUninstall", True)
+        self._params.put_bool("DoUninstall", True)
 
-    dialog = ConfirmDialog(tr("Are you sure you want to uninstall?"), tr("Uninstall"))
-    gui_app.set_modal_overlay(dialog, callback=handle_uninstall_confirmation)
-
-  def _on_install_update(self):
-    # Trigger reboot to install update
-    self._install_btn.action_item.set_enabled(False)
-    ui_state.params.put_bool("DoReboot", True)
-
-  def _on_select_branch(self):
-    # Get available branches and order
-    current_git_branch = ui_state.params.get("GitBranch") or ""
-    branches_str = ui_state.params.get("UpdaterAvailableBranches") or ""
-    branches = [b for b in branches_str.split(",") if b]
-
-    for b in [current_git_branch, "devel-staging", "devel", "nightly", "nightly-dev", "master"]:
-      if b in branches:
-        branches.remove(b)
-        branches.insert(0, b)
-
-    current_target = ui_state.params.get("UpdaterTargetBranch") or ""
-    self._branch_dialog = MultiOptionDialog(tr("Select a branch"), branches, current_target)
-
-    def handle_selection(result):
-      # Confirmed selection
-      if result == DialogResult.CONFIRM and self._branch_dialog is not None and self._branch_dialog.selection:
-        selection = self._branch_dialog.selection
-        ui_state.params.put("UpdaterTargetBranch", selection)
-        self._branch_btn.action_item.set_value(selection)
-        os.system("pkill -SIGUSR1 -f system.updated.updated")
-      self._branch_dialog = None
-
-    gui_app.set_modal_overlay(self._branch_dialog, callback=handle_selection)
+    gui_app.set_modal_overlay(
+      lambda: confirm_dialog("Are you sure you want to uninstall?", "Uninstall"),
+      callback=handle_uninstall_confirmation,
+    )

selfdrive/ui/layouts/settings/toggles.py

@@ -1,40 +1,28 @@
-from cereal import log
-from openpilot.common.params import Params, UnknownKeyName
+from openpilot.common.params import Params
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.list_view import multiple_button_item, toggle_item
 from openpilot.system.ui.widgets.scroller import Scroller
-from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
-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.selfdrive.ui.ui_state import ui_state
-
-if Params().get_bool("sunnypilot_ui"):
-  from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp as toggle_item
-  from openpilot.system.ui.sunnypilot.widgets.list_view import multiple_button_item_sp as multiple_button_item
-
-PERSONALITY_TO_INT = log.LongitudinalPersonality.schema.enumerants
 
 # Description constants
 DESCRIPTIONS = {
-  "OpenpilotEnabledToggle": tr_noop(
+  "OpenpilotEnabledToggle": (
     "Use the openpilot system for adaptive cruise control and lane keep driver assistance. " +
     "Your attention is required at all times to use this feature."
   ),
-  "DisengageOnAccelerator": tr_noop("When enabled, pressing the accelerator pedal will disengage openpilot."),
-  "LongitudinalPersonality": tr_noop(
+  "DisengageOnAccelerator": "When enabled, pressing the accelerator pedal will disengage openpilot.",
+  "LongitudinalPersonality": (
     "Standard is recommended. In aggressive mode, openpilot will follow lead cars closer and be more aggressive with the gas and brake. " +
     "In relaxed mode openpilot will stay further away from lead cars. On supported cars, you can cycle through these personalities with " +
     "your steering wheel distance button."
   ),
-  "IsLdwEnabled": tr_noop(
+  "IsLdwEnabled": (
     "Receive alerts to steer back into the lane when your vehicle drifts over a detected lane line " +
     "without a turn signal activated while driving over 31 mph (50 km/h)."
   ),
-  "AlwaysOnDM": tr_noop("Enable driver monitoring even when openpilot is not engaged."),
-  'RecordFront': tr_noop("Upload data from the driver facing camera and help improve the driver monitoring algorithm."),
-  "IsMetric": tr_noop("Display speed in km/h instead of mph."),
-  "RecordAudio": tr_noop("Record and store microphone audio while driving. The audio will be included in the dashcam video in comma connect."),
+  "AlwaysOnDM": "Enable driver monitoring even when openpilot is not engaged.",
+  'RecordFront': "Upload data from the driver facing camera and help improve the driver monitoring algorithm.",
+  "IsMetric": "Display speed in km/h instead of mph.",
+  "RecordAudio": "Record and store microphone audio while driving. The audio will be included in the dashcam video in comma connect.",
 }
 
 
@@ -42,207 +30,66 @@ class TogglesLayout(Widget):
   def __init__(self):
     super().__init__()
     self._params = Params()
-    self._is_release = self._params.get_bool("IsReleaseBranch")
-
-    # param, title, desc, icon, needs_restart
-    self._toggle_defs = {
-      "OpenpilotEnabledToggle": (
-        lambda: tr("Enable openpilot"),
+    items = [
+      toggle_item(
+        "Enable openpilot",
         DESCRIPTIONS["OpenpilotEnabledToggle"],
-        "chffr_wheel.png",
-        True,
+        self._params.get_bool("OpenpilotEnabledToggle"),
+        icon="chffr_wheel.png",
       ),
-      "ExperimentalMode": (
-        lambda: tr("Experimental Mode"),
-        "",
-        "experimental_white.png",
-        False,
+      toggle_item(
+        "Experimental Mode",
+        initial_state=self._params.get_bool("ExperimentalMode"),
+        icon="experimental_white.png",
       ),
-      "DisengageOnAccelerator": (
-        lambda: tr("Disengage on Accelerator Pedal"),
+      toggle_item(
+        "Disengage on Accelerator Pedal",
         DESCRIPTIONS["DisengageOnAccelerator"],
-        "disengage_on_accelerator.png",
-        False,
+        self._params.get_bool("DisengageOnAccelerator"),
+        icon="disengage_on_accelerator.png",
       ),
-      "IsLdwEnabled": (
-        lambda: tr("Enable Lane Departure Warnings"),
+      multiple_button_item(
+        "Driving Personality",
+        DESCRIPTIONS["LongitudinalPersonality"],
+        buttons=["Aggressive", "Standard", "Relaxed"],
+        button_width=255,
+        callback=self._set_longitudinal_personality,
+        selected_index=self._params.get("LongitudinalPersonality", return_default=True),
+        icon="speed_limit.png"
+      ),
+      toggle_item(
+        "Enable Lane Departure Warnings",
         DESCRIPTIONS["IsLdwEnabled"],
-        "warning.png",
-        False,
+        self._params.get_bool("IsLdwEnabled"),
+        icon="warning.png",
       ),
-      "AlwaysOnDM": (
-        lambda: tr("Always-On Driver Monitoring"),
+      toggle_item(
+        "Always-On Driver Monitoring",
         DESCRIPTIONS["AlwaysOnDM"],
-        "monitoring.png",
-        False,
+        self._params.get_bool("AlwaysOnDM"),
+        icon="monitoring.png",
       ),
-      "RecordFront": (
-        lambda: tr("Record and Upload Driver Camera"),
+      toggle_item(
+        "Record and Upload Driver Camera",
         DESCRIPTIONS["RecordFront"],
-        "monitoring.png",
-        True,
+        self._params.get_bool("RecordFront"),
+        icon="monitoring.png",
       ),
-      "RecordAudio": (
-        lambda: tr("Record and Upload Microphone Audio"),
+      toggle_item(
+        "Record Microphone Audio",
         DESCRIPTIONS["RecordAudio"],
-        "microphone.png",
-        True,
+        self._params.get_bool("RecordAudio"),
+        icon="microphone.png",
       ),
-      "IsMetric": (
-        lambda: tr("Use Metric System"),
-        DESCRIPTIONS["IsMetric"],
-        "metric.png",
-        False,
+      toggle_item(
+        "Use Metric System", DESCRIPTIONS["IsMetric"], self._params.get_bool("IsMetric"), icon="metric.png"
       ),
-    }
+    ]
 
-    self._long_personality_setting = multiple_button_item(
-      lambda: tr("Driving Personality"),
-      lambda: tr(DESCRIPTIONS["LongitudinalPersonality"]),
-      buttons=[lambda: tr("Aggressive"), lambda: tr("Standard"), lambda: tr("Relaxed")],
-      button_width=255,
-      callback=self._set_longitudinal_personality,
-      selected_index=self._params.get("LongitudinalPersonality", return_default=True),
-      icon="speed_limit.png"
-    )
-
-    self._toggles = {}
-    self._locked_toggles = set()
-    for param, (title, desc, icon, needs_restart) in self._toggle_defs.items():
-      toggle = toggle_item(
-        title,
-        desc,
-        self._params.get_bool(param),
-        callback=lambda state, p=param: self._toggle_callback(state, p),
-        icon=icon,
-      )
-
-      try:
-        locked = self._params.get_bool(param + "Lock")
-      except UnknownKeyName:
-        locked = False
-      toggle.action_item.set_enabled(not locked)
-
-      # Make description callable for live translation
-      additional_desc = ""
-      if needs_restart and not locked:
-        additional_desc = tr("Changing this setting will restart openpilot if the car is powered on.")
-      toggle.set_description(lambda og_desc=toggle.description, add_desc=additional_desc: tr(og_desc) + (" " + tr(add_desc) if add_desc else ""))
-
-      # track for engaged state updates
-      if locked:
-        self._locked_toggles.add(param)
-
-      self._toggles[param] = toggle
-
-      # insert longitudinal personality after NDOG toggle
-      if param == "DisengageOnAccelerator":
-        self._toggles["LongitudinalPersonality"] = self._long_personality_setting
-
-    self._update_experimental_mode_icon()
-    self._scroller = Scroller(list(self._toggles.values()), line_separator=True, spacing=0)
-
-    ui_state.add_engaged_transition_callback(self._update_toggles)
-
-  def _update_state(self):
-    if ui_state.sm.updated["selfdriveState"]:
-      personality = PERSONALITY_TO_INT[ui_state.sm["selfdriveState"].personality]
-      if personality != ui_state.personality and ui_state.started:
-        self._long_personality_setting.action_item.set_selected_button(personality)
-      ui_state.personality = personality
-
-  def show_event(self):
-    self._scroller.show_event()
-    self._update_toggles()
-
-  def _update_toggles(self):
-    ui_state.update_params()
-
-    e2e_description = tr(
-      "openpilot defaults to driving in chill mode. Experimental mode enables alpha-level features that aren't ready for chill mode. " +
-      "Experimental features are listed below:<br>" +
-      "<h4>End-to-End Longitudinal Control</h4><br>" +
-      "Let the driving model control the gas and brakes. openpilot will drive as it thinks a human would, including stopping for red lights and stop signs. " +
-      "Since the driving model decides the speed to drive, the set speed will only act as an upper bound. This is an alpha quality feature; " +
-      "mistakes should be expected.<br>" +
-      "<h4>New Driving Visualization</h4><br>" +
-      "The driving visualization will transition to the road-facing wide-angle camera at low speeds to better show some turns. " +
-      "The Experimental mode logo will also be shown in the top right corner."
-    )
-
-    if ui_state.CP is not None:
-      if ui_state.has_longitudinal_control:
-        self._toggles["ExperimentalMode"].action_item.set_enabled(True)
-        self._toggles["ExperimentalMode"].set_description(e2e_description)
-        self._long_personality_setting.action_item.set_enabled(True)
-      else:
-        # no long for now
-        self._toggles["ExperimentalMode"].action_item.set_enabled(False)
-        self._toggles["ExperimentalMode"].action_item.set_state(False)
-        self._long_personality_setting.action_item.set_enabled(False)
-        self._params.remove("ExperimentalMode")
-
-        unavailable = tr("Experimental mode is currently unavailable on this car since the car's stock ACC is used for longitudinal control.")
-
-        long_desc = unavailable + " " + tr("openpilot longitudinal control may come in a future update.")
-        if ui_state.CP.alphaLongitudinalAvailable:
-          if self._is_release:
-            long_desc = unavailable + " " + tr("An alpha version of openpilot longitudinal control can be tested, along with " +
-                                               "Experimental mode, on non-release branches.")
-          else:
-            long_desc = tr("Enable the openpilot longitudinal control (alpha) toggle to allow Experimental mode.")
-
-        self._toggles["ExperimentalMode"].set_description("<b>" + long_desc + "</b><br><br>" + e2e_description)
-    else:
-      self._toggles["ExperimentalMode"].set_description(e2e_description)
-
-    self._update_experimental_mode_icon()
-
-    # TODO: make a param control list item so we don't need to manage internal state as much here
-    # refresh toggles from params to mirror external changes
-    for param in self._toggle_defs:
-      self._toggles[param].action_item.set_state(self._params.get_bool(param))
-
-    # these toggles need restart, block while engaged
-    for toggle_def in self._toggle_defs:
-      if self._toggle_defs[toggle_def][3] and toggle_def not in self._locked_toggles:
-        self._toggles[toggle_def].action_item.set_enabled(not ui_state.engaged)
+    self._scroller = Scroller(items, line_separator=True, spacing=0)
 
   def _render(self, rect):
     self._scroller.render(rect)
 
-  def _update_experimental_mode_icon(self):
-    icon = "experimental.png" if self._toggles["ExperimentalMode"].action_item.get_state() else "experimental_white.png"
-    self._toggles["ExperimentalMode"].set_icon(icon)
-
-  def _handle_experimental_mode_toggle(self, state: bool):
-    confirmed = self._params.get_bool("ExperimentalModeConfirmed")
-    if state and not confirmed:
-      def confirm_callback(result: int):
-        if result == DialogResult.CONFIRM:
-          self._params.put_bool("ExperimentalMode", True)
-          self._params.put_bool("ExperimentalModeConfirmed", True)
-        else:
-          self._toggles["ExperimentalMode"].action_item.set_state(False)
-        self._update_experimental_mode_icon()
-
-      # show confirmation dialog
-      content = (f"<h1>{self._toggles['ExperimentalMode'].title}</h1><br>" +
-                 f"<p>{self._toggles['ExperimentalMode'].description}</p>")
-      dlg = ConfirmDialog(content, tr("Enable"), rich=True)
-      gui_app.set_modal_overlay(dlg, callback=confirm_callback)
-    else:
-      self._update_experimental_mode_icon()
-      self._params.put_bool("ExperimentalMode", state)
-
-  def _toggle_callback(self, state: bool, param: str):
-    if param == "ExperimentalMode":
-      self._handle_experimental_mode_toggle(state)
-      return
-
-    self._params.put_bool(param, state)
-    if self._toggle_defs[param][3]:
-      self._params.put_bool("OnroadCycleRequested", True)
-
   def _set_longitudinal_personality(self, button_index: int):
     self._params.put("LongitudinalPersonality", button_index)

selfdrive/ui/layouts/sidebar.py

@@ -4,8 +4,7 @@ from dataclasses import dataclass
 from collections.abc import Callable
 from cereal import log
 from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos, FONT_SCALE
-from openpilot.system.ui.lib.multilang import tr, tr_noop
+from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.widgets import Widget
 
@@ -24,6 +23,7 @@ NetworkType = log.DeviceState.NetworkType
 
 # Color scheme
 class Colors:
+  SIDEBAR_BG = rl.Color(57, 57, 57, 255)
   WHITE = rl.WHITE
   WHITE_DIM = rl.Color(255, 255, 255, 85)
   GRAY = rl.Color(84, 84, 84, 255)
@@ -40,13 +40,13 @@ class Colors:
 
 
 NETWORK_TYPES = {
-  NetworkType.none: tr_noop("--"),
-  NetworkType.wifi: tr_noop("Wi-Fi"),
-  NetworkType.ethernet: tr_noop("ETH"),
-  NetworkType.cell2G: tr_noop("2G"),
-  NetworkType.cell3G: tr_noop("3G"),
-  NetworkType.cell4G: tr_noop("LTE"),
-  NetworkType.cell5G: tr_noop("5G"),
+  NetworkType.none: "Offline",
+  NetworkType.wifi: "WiFi",
+  NetworkType.cell2G: "2G",
+  NetworkType.cell3G: "3G",
+  NetworkType.cell4G: "LTE",
+  NetworkType.cell5G: "5G",
+  NetworkType.ethernet: "Ethernet",
 }
 
 
@@ -68,33 +68,27 @@ class Sidebar(Widget):
     self._net_type = NETWORK_TYPES.get(NetworkType.none)
     self._net_strength = 0
 
-    self._temp_status = MetricData(tr_noop("TEMP"), tr_noop("GOOD"), Colors.GOOD)
-    self._panda_status = MetricData(tr_noop("VEHICLE"), tr_noop("ONLINE"), Colors.GOOD)
-    self._connect_status = MetricData(tr_noop("CONNECT"), tr_noop("OFFLINE"), Colors.WARNING)
-    self._recording_audio = False
+    self._temp_status = MetricData("TEMP", "GOOD", Colors.GOOD)
+    self._panda_status = MetricData("VEHICLE", "ONLINE", Colors.GOOD)
+    self._connect_status = MetricData("CONNECT", "OFFLINE", Colors.WARNING)
 
     self._home_img = gui_app.texture("images/button_home.png", HOME_BTN.width, HOME_BTN.height)
     self._flag_img = gui_app.texture("images/button_flag.png", HOME_BTN.width, HOME_BTN.height)
     self._settings_img = gui_app.texture("images/button_settings.png", SETTINGS_BTN.width, SETTINGS_BTN.height)
-    self._mic_img = gui_app.texture("icons/microphone.png", 30, 30)
-    self._mic_indicator_rect = rl.Rectangle(0, 0, 0, 0)
     self._font_regular = gui_app.font(FontWeight.NORMAL)
     self._font_bold = gui_app.font(FontWeight.SEMI_BOLD)
 
     # Callbacks
     self._on_settings_click: Callable | None = None
     self._on_flag_click: Callable | None = None
-    self._open_settings_callback: Callable | None = None
 
-  def set_callbacks(self, on_settings: Callable | None = None, on_flag: Callable | None = None,
-                    open_settings: Callable | None = None):
+  def set_callbacks(self, on_settings: Callable | None = None, on_flag: Callable | None = None):
     self._on_settings_click = on_settings
     self._on_flag_click = on_flag
-    self._open_settings_callback = open_settings
 
   def _render(self, rect: rl.Rectangle):
     # Background
-    rl.draw_rectangle_rec(rect, rl.BLACK)
+    rl.draw_rectangle_rec(rect, Colors.SIDEBAR_BG)
 
     self._draw_buttons(rect)
     self._draw_network_indicator(rect)
@@ -107,14 +101,13 @@ class Sidebar(Widget):
 
     device_state = sm['deviceState']
 
-    self._recording_audio = ui_state.recording_audio
     self._update_network_status(device_state)
     self._update_temperature_status(device_state)
     self._update_connection_status(device_state)
     self._update_panda_status()
 
   def _update_network_status(self, device_state):
-    self._net_type = NETWORK_TYPES.get(device_state.networkType.raw, tr_noop("Unknown"))
+    self._net_type = NETWORK_TYPES.get(device_state.networkType.raw, "Unknown")
     strength = device_state.networkStrength
     self._net_strength = max(0, min(5, strength.raw + 1)) if strength > 0 else 0
 
@@ -122,26 +115,26 @@ class Sidebar(Widget):
     thermal_status = device_state.thermalStatus
 
     if thermal_status == ThermalStatus.green:
-      self._temp_status.update(tr_noop("TEMP"), tr_noop("GOOD"), Colors.GOOD)
+      self._temp_status.update("TEMP", "GOOD", Colors.GOOD)
     elif thermal_status == ThermalStatus.yellow:
-      self._temp_status.update(tr_noop("TEMP"), tr_noop("OK"), Colors.WARNING)
+      self._temp_status.update("TEMP", "OK", Colors.WARNING)
     else:
-      self._temp_status.update(tr_noop("TEMP"), tr_noop("HIGH"), Colors.DANGER)
+      self._temp_status.update("TEMP", "HIGH", Colors.DANGER)
 
   def _update_connection_status(self, device_state):
     last_ping = device_state.lastAthenaPingTime
     if last_ping == 0:
-      self._connect_status.update(tr_noop("CONNECT"), tr_noop("OFFLINE"), Colors.WARNING)
+      self._connect_status.update("CONNECT", "OFFLINE", Colors.WARNING)
     elif time.monotonic_ns() - last_ping < 80_000_000_000:  # 80 seconds in nanoseconds
-      self._connect_status.update(tr_noop("CONNECT"), tr_noop("ONLINE"), Colors.GOOD)
+      self._connect_status.update("CONNECT", "ONLINE", Colors.GOOD)
     else:
-      self._connect_status.update(tr_noop("CONNECT"), tr_noop("ERROR"), Colors.DANGER)
+      self._connect_status.update("CONNECT", "ERROR", Colors.DANGER)
 
   def _update_panda_status(self):
     if ui_state.panda_type == log.PandaState.PandaType.unknown:
-      self._panda_status.update(tr_noop("NO"), tr_noop("PANDA"), Colors.DANGER)
+      self._panda_status.update("NO", "PANDA", Colors.DANGER)
     else:
-      self._panda_status.update(tr_noop("VEHICLE"), tr_noop("ONLINE"), Colors.GOOD)
+      self._panda_status.update("VEHICLE", "ONLINE", Colors.GOOD)
 
   def _handle_mouse_release(self, mouse_pos: MousePos):
     if rl.check_collision_point_rec(mouse_pos, SETTINGS_BTN):
@@ -150,9 +143,6 @@ class Sidebar(Widget):
     elif rl.check_collision_point_rec(mouse_pos, HOME_BTN) and ui_state.started:
       if self._on_flag_click:
         self._on_flag_click()
-    elif self._recording_audio and rl.check_collision_point_rec(mouse_pos, self._mic_indicator_rect):
-      if self._open_settings_callback:
-        self._open_settings_callback()
 
   def _draw_buttons(self, rect: rl.Rectangle):
     mouse_pos = rl.get_mouse_position()
@@ -170,17 +160,6 @@ class Sidebar(Widget):
     tint = Colors.BUTTON_PRESSED if (ui_state.started and flag_pressed) else Colors.BUTTON_NORMAL
     rl.draw_texture(button_img, int(HOME_BTN.x), int(HOME_BTN.y), tint)
 
-    # Microphone button
-    if self._recording_audio:
-      self._mic_indicator_rect = rl.Rectangle(rect.x + rect.width - 130, rect.y + 245, 75, 40)
-
-      mic_pressed = mouse_down and rl.check_collision_point_rec(mouse_pos, self._mic_indicator_rect)
-      bg_color = rl.Color(Colors.DANGER.r, Colors.DANGER.g, Colors.DANGER.b, int(255 * 0.65)) if mic_pressed else Colors.DANGER
-
-      rl.draw_rectangle_rounded(self._mic_indicator_rect, 1, 10, bg_color)
-      rl.draw_texture(self._mic_img, int(self._mic_indicator_rect.x + (self._mic_indicator_rect.width - self._mic_img.width) / 2),
-                      int(self._mic_indicator_rect.y + (self._mic_indicator_rect.height - self._mic_img.height) / 2), Colors.WHITE)
-
   def _draw_network_indicator(self, rect: rl.Rectangle):
     # Signal strength dots
     x_start = rect.x + 58
@@ -197,7 +176,7 @@ class Sidebar(Widget):
     # Network type text
     text_y = rect.y + 247
     text_pos = rl.Vector2(rect.x + 58, text_y)
-    rl.draw_text_ex(self._font_regular, tr(self._net_type), text_pos, FONT_SIZE, 0, Colors.WHITE)
+    rl.draw_text_ex(self._font_regular, self._net_type, text_pos, FONT_SIZE, 0, Colors.WHITE)
 
   def _draw_metrics(self, rect: rl.Rectangle):
     metrics = [(self._temp_status, 338), (self._panda_status, 496), (self._connect_status, 654)]
@@ -210,15 +189,15 @@ class Sidebar(Widget):
     # Draw colored left edge (clipped rounded rectangle)
     edge_rect = rl.Rectangle(metric_rect.x + 4, metric_rect.y + 4, 100, 118)
     rl.begin_scissor_mode(int(metric_rect.x + 4), int(metric_rect.y), 18, int(metric_rect.height))
-    rl.draw_rectangle_rounded(edge_rect, 0.3, 10, metric.color)
+    rl.draw_rectangle_rounded(edge_rect, 0.18, 10, metric.color)
     rl.end_scissor_mode()
 
     # Draw border
-    rl.draw_rectangle_rounded_lines_ex(metric_rect, 0.3, 10, 2, Colors.METRIC_BORDER)
+    rl.draw_rectangle_rounded_lines_ex(metric_rect, 0.15, 10, 2, Colors.METRIC_BORDER)
 
     # Draw label and value
-    labels = [tr(metric.label), tr(metric.value)]
-    text_y = metric_rect.y + (metric_rect.height / 2 - len(labels) * FONT_SIZE * FONT_SCALE)
+    labels = [metric.label, metric.value]
+    text_y = metric_rect.y + (metric_rect.height / 2 - len(labels) * FONT_SIZE)
     for text in labels:
       text_size = measure_text_cached(self._font_bold, text, FONT_SIZE)
       text_y += text_size.y

selfdrive/ui/lib/api_helpers.py

@@ -1,16 +1,12 @@
 import time
 from functools import lru_cache
 from openpilot.common.api import Api
-from openpilot.common.time_helpers import system_time_valid
 
 TOKEN_EXPIRY_HOURS = 2
 
 
 @lru_cache(maxsize=1)
 def _get_token(dongle_id: str, t: int):
-  if not system_time_valid():
-    raise RuntimeError("System time is not valid, cannot generate token")
-
   return Api(dongle_id).get_token(expiry_hours=TOKEN_EXPIRY_HOURS)
 
 

selfdrive/ui/lib/prime_state.py

@@ -11,14 +11,14 @@ from openpilot.selfdrive.ui.lib.api_helpers import get_token
 
 
 class PrimeType(IntEnum):
-  UNKNOWN = -2
-  UNPAIRED = -1
-  NONE = 0
-  MAGENTA = 1
-  LITE = 2
-  BLUE = 3
-  MAGENTA_NEW = 4
-  PURPLE = 5
+  UNKNOWN = -2,
+  UNPAIRED = -1,
+  NONE = 0,
+  MAGENTA = 1,
+  LITE = 2,
+  BLUE = 3,
+  MAGENTA_NEW = 4,
+  PURPLE = 5,
 
 
 class PrimeState:
@@ -33,6 +33,7 @@ class PrimeState:
 
     self._running = False
     self._thread = None
+    self.start()
 
   def _load_initial_state(self) -> PrimeType:
     prime_type_str = os.getenv("PRIME_TYPE") or self._params.get("PrimeType")
@@ -95,9 +96,5 @@ class PrimeState:
     with self._lock:
       return bool(self.prime_type > PrimeType.NONE)
 
-  def is_paired(self) -> bool:
-    with self._lock:
-      return self.prime_type > PrimeType.UNPAIRED
-
   def __del__(self):
     self.stop()

selfdrive/ui/main.cc

@@ -0,0 +1,36 @@
+#include <sys/resource.h>
+
+#include <QApplication>
+#include <QTranslator>
+
+#include "system/hardware/hw.h"
+#include "selfdrive/ui/qt/util.h"
+#include "selfdrive/ui/qt/window.h"
+
+#ifdef SUNNYPILOT
+#include "selfdrive/ui/sunnypilot/qt/window.h"
+#define MainWindow MainWindowSP
+#else
+#include "selfdrive/ui/qt/qt_window.h"
+#endif
+
+int main(int argc, char *argv[]) {
+  setpriority(PRIO_PROCESS, 0, -20);
+
+  qInstallMessageHandler(swagLogMessageHandler);
+  initApp(argc, argv);
+
+  QTranslator translator;
+  QString translation_file = QString::fromStdString(Params().get("LanguageSetting"));
+  if (!translator.load(QString(":/%1").arg(translation_file)) && translation_file.length()) {
+    qCritical() << "Failed to load translation file:" << translation_file;
+  }
+
+  QApplication a(argc, argv);
+  a.installTranslator(&translator);
+
+  MainWindow w;
+  setMainWindow(&w);
+  a.installEventFilter(&w);
+  return a.exec();
+}

selfdrive/ui/onroad/alert_renderer.py

@@ -4,11 +4,10 @@ from dataclasses import dataclass
 from cereal import messaging, log
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.hardware import TICI
-from openpilot.system.ui.lib.application import gui_app, FontWeight
-from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.lib.application import gui_app, FontWeight, DEFAULT_FPS
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets.label import Label
+from openpilot.system.ui.widgets.label import gui_text_box
 
 AlertSize = log.SelfdriveState.AlertSize
 AlertStatus = log.SelfdriveState.AlertStatus
@@ -22,19 +21,14 @@ ALERT_FONT_SMALL = 66
 ALERT_FONT_MEDIUM = 74
 ALERT_FONT_BIG = 88
 
-ALERT_HEIGHTS = {
-  AlertSize.small: 271,
-  AlertSize.mid: 420,
-}
-
 SELFDRIVE_STATE_TIMEOUT = 5  # Seconds
 SELFDRIVE_UNRESPONSIVE_TIMEOUT = 10  # Seconds
 
 # Constants
 ALERT_COLORS = {
-  AlertStatus.normal: rl.Color(0x15, 0x15, 0x15, 0xF1),      # #151515 with alpha 0xF1
-  AlertStatus.userPrompt: rl.Color(0xDA, 0x6F, 0x25, 0xF1),  # #DA6F25 with alpha 0xF1
-  AlertStatus.critical: rl.Color(0xC9, 0x22, 0x31, 0xF1),    # #C92231 with alpha 0xF1
+  AlertStatus.normal: rl.Color(0, 0, 0, 235),  # Black
+  AlertStatus.userPrompt: rl.Color(0xFE, 0x8C, 0x34, 235),  # Orange
+  AlertStatus.critical: rl.Color(0xC9, 0x22, 0x31, 235),  # Red
 }
 
 
@@ -48,24 +42,24 @@ class Alert:
 
 # Pre-defined alert instances
 ALERT_STARTUP_PENDING = Alert(
-  text1=tr("openpilot Unavailable"),
-  text2=tr("Waiting to start"),
+  text1="openpilot Unavailable",
+  text2="Waiting to start",
   size=AlertSize.mid,
   status=AlertStatus.normal,
 )
 
 ALERT_CRITICAL_TIMEOUT = Alert(
-  text1=tr("TAKE CONTROL IMMEDIATELY"),
-  text2=tr("System Unresponsive"),
+  text1="TAKE CONTROL IMMEDIATELY",
+  text2="System Unresponsive",
   size=AlertSize.full,
   status=AlertStatus.critical,
 )
 
 ALERT_CRITICAL_REBOOT = Alert(
-  text1=tr("System Unresponsive"),
-  text2=tr("Reboot Device"),
-  size=AlertSize.mid,
-  status=AlertStatus.normal,
+  text1="System Unresponsive",
+  text2="Reboot Device",
+  size=AlertSize.full,
+  status=AlertStatus.critical,
 )
 
 
@@ -75,20 +69,14 @@ class AlertRenderer(Widget):
     self.font_regular: rl.Font = gui_app.font(FontWeight.NORMAL)
     self.font_bold: rl.Font = gui_app.font(FontWeight.BOLD)
 
-    # font size is set dynamically
-    self._full_text1_label = Label("", font_size=0, font_weight=FontWeight.BOLD, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER,
-                                   text_alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP)
-    self._full_text2_label = Label("", font_size=ALERT_FONT_BIG, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER,
-                                   text_alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP)
-
   def get_alert(self, sm: messaging.SubMaster) -> Alert | None:
     """Generate the current alert based on selfdrive state."""
     ss = sm['selfdriveState']
 
     # Check if selfdriveState messages have stopped arriving
-    recv_frame = sm.recv_frame['selfdriveState']
     if not sm.updated['selfdriveState']:
-      time_since_onroad = time.monotonic() - ui_state.started_time
+      recv_frame = sm.recv_frame['selfdriveState']
+      time_since_onroad = (sm.frame - ui_state.started_frame) / DEFAULT_FPS
 
       # 1. Never received selfdriveState since going onroad
       waiting_for_startup = recv_frame < ui_state.started_frame
@@ -107,17 +95,13 @@ class AlertRenderer(Widget):
     if ss.alertSize == 0:
       return None
 
-    # Don't get old alert
-    if recv_frame < ui_state.started_frame:
-      return None
-
     # Return current alert
     return Alert(text1=ss.alertText1, text2=ss.alertText2, size=ss.alertSize.raw, status=ss.alertStatus.raw)
 
-  def _render(self, rect: rl.Rectangle):
+  def _render(self, rect: rl.Rectangle) -> bool:
     alert = self.get_alert(ui_state.sm)
     if not alert:
-      return
+      return False
 
     alert_rect = self._get_alert_rect(rect, alert.size)
     self._draw_background(alert_rect, alert)
@@ -129,14 +113,21 @@ class AlertRenderer(Widget):
       alert_rect.height - 2 * ALERT_PADDING
     )
     self._draw_text(text_rect, alert)
+    return True
 
   def _get_alert_rect(self, rect: rl.Rectangle, size: int) -> rl.Rectangle:
     if size == AlertSize.full:
       return rect
 
-    h = ALERT_HEIGHTS.get(size, rect.height)
-    return rl.Rectangle(rect.x + ALERT_MARGIN, rect.y + rect.height - h + ALERT_MARGIN,
-                        rect.width - ALERT_MARGIN * 2, h - ALERT_MARGIN * 2)
+    height = (ALERT_FONT_MEDIUM + 2 * ALERT_PADDING if size == AlertSize.small else
+              ALERT_FONT_BIG + ALERT_LINE_SPACING + ALERT_FONT_SMALL + 2 * ALERT_PADDING)
+
+    return rl.Rectangle(
+      rect.x + ALERT_MARGIN,
+      rect.y + rect.height - ALERT_MARGIN - height,
+      rect.width - 2 * ALERT_MARGIN,
+      height
+    )
 
   def _draw_background(self, rect: rl.Rectangle, alert: Alert) -> None:
     color = ALERT_COLORS.get(alert.status, ALERT_COLORS[AlertStatus.normal])
@@ -159,17 +150,13 @@ class AlertRenderer(Widget):
     else:
       is_long = len(alert.text1) > 15
       font_size1 = 132 if is_long else 177
+      align_ment = rl.GuiTextAlignment.TEXT_ALIGN_CENTER
+      vertical_align = rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE
+      text_rect = rl.Rectangle(rect.x, rect.y, rect.width, rect.height // 2)
 
-      top_offset = 200 if is_long or '\n' in alert.text1 else 270
-      title_rect = rl.Rectangle(rect.x, rect.y + top_offset, rect.width, 600)
-      self._full_text1_label.set_font_size(font_size1)
-      self._full_text1_label.set_text(alert.text1)
-      self._full_text1_label.render(title_rect)
-
-      bottom_offset = 361 if is_long else 420
-      subtitle_rect = rl.Rectangle(rect.x, rect.y + rect.height - bottom_offset, rect.width, 300)
-      self._full_text2_label.set_text(alert.text2)
-      self._full_text2_label.render(subtitle_rect)
+      gui_text_box(text_rect, alert.text1, font_size1, alignment=align_ment, alignment_vertical=vertical_align, font_weight=FontWeight.BOLD)
+      text_rect.y = rect.y + rect.height // 2
+      gui_text_box(text_rect, alert.text2, ALERT_FONT_BIG, alignment=align_ment)
 
   def _draw_centered(self, text, rect, font, font_size, center_y=True, color=rl.WHITE) -> None:
     text_size = measure_text_cached(font, text, font_size)

selfdrive/ui/onroad/augmented_road_view.py

@@ -1,10 +1,9 @@
-import time
 import numpy as np
 import pyray as rl
-from cereal import log, messaging
+from collections.abc import Callable
+from cereal import log
 from msgq.visionipc import VisionStreamType
-from openpilot.selfdrive.ui import UI_BORDER_SIZE
-from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus, UI_BORDER_SIZE
 from openpilot.selfdrive.ui.onroad.alert_renderer import AlertRenderer
 from openpilot.selfdrive.ui.onroad.driver_state import DriverStateRenderer
 from openpilot.selfdrive.ui.onroad.hud_renderer import HudRenderer
@@ -21,14 +20,13 @@ WIDE_CAM = VisionStreamType.VISION_STREAM_WIDE_ROAD
 DEFAULT_DEVICE_CAMERA = DEVICE_CAMERAS["tici", "ar0231"]
 
 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
+  UIStatus.DISENGAGED: rl.Color(0x17, 0x33, 0x49, 0xC8),   # Blue for disengaged state
+  UIStatus.OVERRIDE: rl.Color(0x91, 0x9B, 0x95, 0xF1),     # Gray for override state
+  UIStatus.ENGAGED: rl.Color(0x17, 0x86, 0x44, 0xF1),      # Green for engaged state
 }
 
 WIDE_CAM_MAX_SPEED = 10.0  # m/s (22 mph)
 ROAD_CAM_MIN_SPEED = 15.0  # m/s (34 mph)
-INF_POINT = np.array([1000.0, 0.0, 0.0])
 
 
 class AugmentedRoadView(CameraView):
@@ -40,7 +38,9 @@ class AugmentedRoadView(CameraView):
     self.view_from_calib = view_frame_from_device_frame.copy()
     self.view_from_wide_calib = view_frame_from_device_frame.copy()
 
-    self._matrix_cache_key = (0, 0.0, 0.0, stream_type)
+    self._last_calib_time: float = 0
+    self._last_rect_dims = (0.0, 0.0)
+    self._last_stream_type = stream_type
     self._cached_matrix: np.ndarray | None = None
     self._content_rect = rl.Rectangle()
 
@@ -49,12 +49,14 @@ class AugmentedRoadView(CameraView):
     self.alert_renderer = AlertRenderer()
     self.driver_state_renderer = DriverStateRenderer()
 
-    # debug
-    self._pm = messaging.PubMaster(['uiDebug'])
+    # Callbacks
+    self._click_callback: Callable | None = None
+
+  def set_callbacks(self, on_click: Callable | None = None):
+    self._click_callback = on_click
 
   def _render(self, rect):
     # Only render when system is started to avoid invalid data access
-    start_draw = time.monotonic()
     if not ui_state.started:
       return
 
@@ -71,6 +73,9 @@ class AugmentedRoadView(CameraView):
       rect.height - 2 * UI_BORDER_SIZE,
     )
 
+    # Draw colored border based on driving state
+    self._draw_border(rect)
+
     # Enable scissor mode to clip all rendering within content rectangle boundaries
     # This creates a rendering viewport that prevents graphics from drawing outside the border
     rl.begin_scissor_mode(
@@ -86,8 +91,8 @@ class AugmentedRoadView(CameraView):
     # Draw all UI overlays
     self.model_renderer.render(self._content_rect)
     self._hud_renderer.render(self._content_rect)
-    self.alert_renderer.render(self._content_rect)
-    self.driver_state_renderer.render(self._content_rect)
+    if not self.alert_renderer.render(self._content_rect):
+      self.driver_state_renderer.render(self._content_rect)
 
     # Custom UI extension point - add custom overlays here
     # Use self._content_rect for positioning within camera bounds
@@ -95,29 +100,15 @@ class AugmentedRoadView(CameraView):
     # End clipping region
     rl.end_scissor_mode()
 
-    # Draw colored border based on driving state
-    self._draw_border(rect)
-
-    # publish uiDebug
-    msg = messaging.new_message('uiDebug')
-    msg.uiDebug.drawTimeMillis = (time.monotonic() - start_draw) * 1000
-    self._pm.send('uiDebug', msg)
-
-  def _handle_mouse_press(self, _):
-    if not self._hud_renderer.user_interacting() and self._click_callback is not None:
-      self._click_callback()
-
-  def _handle_mouse_release(self, _):
-    # We only call click callback on press if not interacting with HUD
-    pass
+    # Handle click events if no HUD interaction occurred
+    if not self._hud_renderer.handle_mouse_event():
+      if self._click_callback and rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT):
+        if rl.check_collision_point_rec(rl.get_mouse_position(), self._content_rect):
+          self._click_callback()
 
   def _draw_border(self, rect: rl.Rectangle):
-    rl.draw_rectangle_lines_ex(rect, UI_BORDER_SIZE, rl.BLACK)
-    border_roundness = 0.12
     border_color = BORDER_COLORS.get(ui_state.status, BORDER_COLORS[UIStatus.DISENGAGED])
-    border_rect = rl.Rectangle(rect.x + UI_BORDER_SIZE, rect.y + UI_BORDER_SIZE,
-                               rect.width - 2 * UI_BORDER_SIZE, rect.height - 2 * UI_BORDER_SIZE)
-    rl.draw_rectangle_rounded_lines_ex(border_rect, border_roundness, 10, UI_BORDER_SIZE, border_color)
+    rl.draw_rectangle_lines_ex(rect, UI_BORDER_SIZE, border_color)
 
   def _switch_stream_if_needed(self, sm):
     if sm['selfdriveState'].experimentalMode and WIDE_CAM in self.available_streams:
@@ -160,13 +151,12 @@ class AugmentedRoadView(CameraView):
 
   def _calc_frame_matrix(self, rect: rl.Rectangle) -> np.ndarray:
     # Check if we can use cached matrix
-    cache_key = (
-      ui_state.sm.recv_frame['liveCalibration'],
-      self._content_rect.width,
-      self._content_rect.height,
-      self.stream_type
-    )
-    if cache_key == self._matrix_cache_key and self._cached_matrix is not None:
+    calib_time = ui_state.sm.recv_frame['liveCalibration']
+    current_dims = (self._content_rect.width, self._content_rect.height)
+    if (self._last_calib_time == calib_time and
+        self._last_rect_dims == current_dims and
+        self._last_stream_type == self.stream_type and
+        self._cached_matrix is not None):
       return self._cached_matrix
 
     # Get camera configuration
@@ -177,8 +167,9 @@ class AugmentedRoadView(CameraView):
     zoom = 2.0 if is_wide_camera else 1.1
 
     # Calculate transforms for vanishing point
+    inf_point = np.array([1000.0, 0.0, 0.0])
     calib_transform = intrinsic @ calibration
-    kep = calib_transform @ INF_POINT
+    kep = calib_transform @ inf_point
 
     # Calculate center points and dimensions
     x, y = self._content_rect.x, self._content_rect.y
@@ -201,7 +192,9 @@ class AugmentedRoadView(CameraView):
       x_offset, y_offset = 0, 0
 
     # Cache the computed transformation matrix to avoid recalculations
-    self._matrix_cache_key = cache_key
+    self._last_calib_time = calib_time
+    self._last_rect_dims = current_dims
+    self._last_stream_type = self.stream_type
     self._cached_matrix = np.array([
       [zoom * 2 * cx / w, 0, -x_offset / w * 2],
       [0, zoom * 2 * cy / h, -y_offset / h * 2],

selfdrive/ui/onroad/cameraview.py

@@ -8,7 +8,6 @@ from openpilot.system.hardware import TICI
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.egl import init_egl, create_egl_image, destroy_egl_image, bind_egl_image_to_texture, EGLImage
 from openpilot.system.ui.widgets import Widget
-from openpilot.selfdrive.ui.ui_state import ui_state
 
 CONNECTION_RETRY_INTERVAL = 0.2  # seconds between connection attempts
 
@@ -68,7 +67,6 @@ else:
 class CameraView(Widget):
   def __init__(self, name: str, stream_type: VisionStreamType):
     super().__init__()
-    # TODO: implement a receiver and connect thread
     self._name = name
     # Primary stream
     self.client = VisionIpcClient(name, stream_type, conflate=True)
@@ -105,20 +103,6 @@ class CameraView(Widget):
       self.egl_texture = rl.load_texture_from_image(temp_image)
       rl.unload_image(temp_image)
 
-    ui_state.add_offroad_transition_callback(self._offroad_transition)
-
-  def _offroad_transition(self):
-    # Reconnect if not first time going onroad
-    if ui_state.is_onroad() and self.frame is not None:
-      # Prevent old frames from showing when going onroad. Qt has a separate thread
-      # which drains the VisionIpcClient SubSocket for us. Re-connecting is not enough
-      # and only clears internal buffers, not the message queue.
-      self.frame = None
-      self.available_streams.clear()
-      if self.client:
-        del self.client
-      self.client = VisionIpcClient(self._name, self._stream_type, conflate=True)
-
   def _set_placeholder_color(self, color: rl.Color):
     """Set a placeholder color to be drawn when no frame is available."""
     self._placeholder_color = color
@@ -155,8 +139,6 @@ class CameraView(Widget):
     if self.shader and self.shader.id:
       rl.unload_shader(self.shader)
 
-    self.frame = None
-    self.available_streams.clear()
     self.client = None
 
   def __del__(self):
@@ -193,9 +175,6 @@ class CameraView(Widget):
     if buffer:
       self._texture_needs_update = True
       self.frame = buffer
-    elif not self.client.is_connected():
-      # ensure we clear the displayed frame when the connection is lost
-      self.frame = None
 
     if not self.frame:
       self._draw_placeholder(rect)

selfdrive/ui/onroad/driver_camera_dialog.py

@@ -3,9 +3,8 @@ import pyray as rl
 from msgq.visionipc import VisionStreamType
 from openpilot.selfdrive.ui.onroad.cameraview import CameraView
 from openpilot.selfdrive.ui.onroad.driver_state import DriverStateRenderer
-from openpilot.selfdrive.ui.ui_state import ui_state, device
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.lib.application import gui_app, FontWeight
-from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets.label import gui_label
 
 
@@ -13,25 +12,17 @@ class DriverCameraDialog(CameraView):
   def __init__(self):
     super().__init__("camerad", VisionStreamType.VISION_STREAM_DRIVER)
     self.driver_state_renderer = DriverStateRenderer()
-    # TODO: this can grow unbounded, should be given some thought
-    device.add_interactive_timeout_callback(self.stop_dmonitoringmodeld)
-    ui_state.params.put_bool("IsDriverViewEnabled", True)
-
-  def stop_dmonitoringmodeld(self):
-    ui_state.params.put_bool("IsDriverViewEnabled", False)
-    gui_app.set_modal_overlay(None)
-
-  def _handle_mouse_release(self, _):
-    super()._handle_mouse_release(_)
-    self.stop_dmonitoringmodeld()
 
   def _render(self, rect):
     super()._render(rect)
 
+    if rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT):
+      return 1
+
     if not self.frame:
       gui_label(
         rect,
-        tr("camera starting"),
+        "camera starting",
         font_size=100,
         font_weight=FontWeight.BOLD,
         alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER,