sunnypilot v2026.07.20-4574

version: sunnypilot v2026.002.000 (feature-branch) date: 2026-07-20T03:45:01 master commit: 560cde61ae
sunnypilot v2026.07.20-4574 release
2026-07-21 14:42:07 +08:00 · 2026-07-20 03:45:02 +00:00 · 2026-07-20 03:44:51 +00:00
5462 changed files with 1245792 additions and 231053 deletions
@@ -1,19 +0,0 @@
---
-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:
-...
@@ -0,0 +1,6 @@
+Wen
+REGIST
+PullRequest
+cancelled
+FOF
+NoO
@@ -1 +0,0 @@
-.Xauthority
@@ -1,6 +0,0 @@
-FROM ghcr.io/commaai/openpilot-base:latest
-
-# remove gitconfig if exists, since its gonna be replaced by host one
-RUN rm -f /root/.gitconfig
-RUN apt update && apt install -y vim net-tools usbutils htop ripgrep
-RUN pip install ipython jupyter jupyterlab
@@ -1,34 +0,0 @@
-{
-  "name": "openpilot devcontainer",
-  "build": {
-    "dockerfile": "Dockerfile"
-  },
-  "postCreateCommand": "bash -c 'if [[ $DISPLAY == *xquartz* ]]; then echo \"export DISPLAY=host.docker.internal:0\" >> /root/.bashrc; fi'",
-  "postStartCommand": "git config --file .gitmodules --get-regexp path | awk '{ print $2 }' | xargs -I{} git config --global --add safe.directory \"$PWD/{}\"",
-  "initializeCommand": ".devcontainer/setup_host.sh",
-  "privileged": true,
-  "containerEnv": {
-    "DISPLAY": "${localEnv:DISPLAY}",
-    "PYTHONPATH": "${containerWorkspaceFolder}",
-    "force_color_prompt": "1"
-  },
-  "runArgs": [
-    "--volume=/tmp/.X11-unix:/tmp/.X11-unix",
-    "--volume=${localWorkspaceFolder}/.devcontainer/.Xauthority:/root/.Xauthority",
-    "--volume=${localEnv:HOME}/.comma:/root/.comma",
-    "--volume=/tmp/comma_download_cache:/tmp/comma_download_cache",
-    "--volume=/tmp/devcontainer_scons_cache:/tmp/scons_cache",
-    "--shm-size=1G"
-  ],
-  "customizations": {
-    "vscode": {
-      "extensions": [
-        "ms-python.python",
-        "ms-vscode.cpptools",
-        "ms-toolsai.jupyter",
-        "guyskk.language-cython",
-        "lharri73.dbc"
-      ]
-    }
-  }
-}
@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-
-# setup links to Xauthority
-XAUTHORITY_LINK=".devcontainer/.Xauthority"
-rm -f $XAUTHORITY_LINK
-if [[ -z $XAUTHORITY ]]; then
-    echo "XAUTHORITY not set. Fallback to ~/.Xauthority ..."
-    if ! [[ -f $HOME/.Xauthority ]]; then
-        echo "~/.XAuthority file does not exist. GUI tools may not work properly."
-        touch $XAUTHORITY_LINK # dummy file to satisfy container volume mount
-    else
-        ln -sf $HOME/.Xauthority $XAUTHORITY_LINK
-    fi
-else
-    ln -sf $XAUTHORITY $XAUTHORITY_LINK
-fi
@@ -1,3 +0,0 @@
-((c++-mode (flycheck-gcc-language-standard . "c++11")
-           (flycheck-clang-language-standard . "c++11")
-           ))
@@ -1,41 +0,0 @@
-**/.git
-.DS_Store
-*.dylib
-*.DSYM
-*.d
-*.pyc
-*.pyo
-.*.swp
-.*.swo
-.*.un~
-*.tmp
-*.o
-*.o-*
-*.os
-*.os-*
-*.so
-*.a
-
-venv/
-.venv/
-
-notebooks
-phone
-massivemap
-neos
-installer
-chffr/app2
-chffr/backend/env
-selfdrive/nav
-selfdrive/baseui
-chffr/lib/vidindex/vidindex
-selfdrive/test/simulator2
-**/cache_data
-xx/chffr/lib/vidindex/vidindex
-xx/plus
-xx/community
-xx/projects
-!xx/projects/eon_testing_master
-!xx/projects/map3d
-xx/ops
-xx/junk
@@ -5,7 +5,7 @@ end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true

-[{*.py, *.pyx, *.pxd}]
+[*.{py,pyx,pxd}]
 charset = utf-8
 indent_style = space
 indent_size = 2
@@ -1,3 +0,0 @@
-*.dlc filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-selfdrive/car/tests/test_models_segs.txt filter=lfs diff=lfs merge=lfs -text
@@ -1,47 +0,0 @@
-name: Bug report
-description: For issues with running openpilot on your comma device
-labels: ["bug"]
-body:
-
-  - type: markdown
-    attributes:
-      value: >
-        Before creating a **bug report**, please check the following:
-          * If the issue likely only affects your car model or make, go back and open a **car bug report** instead.
-          * If the issue is related to the driving or driver monitoring models, you should open a [discussion](https://github.com/commaai/openpilot/discussions/categories/model-feedback) instead.
-          * Ensure you're running the latest openpilot release.
-          * Ensure you're using officially supported hardware. Issues running on PCs have a different issue template.
-          * Ensure there isn't an existing issue for your bug. If there is, leave a comment on the existing issue.
-          * Ensure you're running stock openpilot. We cannot look into bug reports from forks.
-
-        If you're unsure whether you've hit a bug, check out the #installation-help channel in the [community Discord server](https://discord.comma.ai).
-
-  - type: textarea
-    attributes:
-      label: Describe the bug
-      description: Also include a description of how to reproduce the bug
-    validations:
-      required: true
-
-  - type: input
-    id: route
-    attributes:
-      label: Provide a route where the issue occurs
-      description: Ensure the route is fully uploaded at https://useradmin.comma.ai. We cannot look into issues without routes, or at least a Dongle ID.
-      placeholder: 77611a1fac303767|2020-05-11--16-37-07
-    validations:
-      required: true
-
-  - type: input
-    id: version
-    attributes:
-      label: openpilot version
-      description: If you're not on release, provide the commit hash
-      placeholder: 0.8.10
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: Additional info
-
@@ -1,53 +0,0 @@
-name: Car bug report
-description: For issues with a particular car make or model
-labels: ["car", "bug"]
-body:
-
-  - type: markdown
-    attributes:
-      value: >
-        Before creating a **bug report**, please check the following:
-          * Ensure you're running the latest openpilot release.
-          * Ensure you're using officially supported hardware. Issues running on PCs have a different issue template.
-          * Ensure there isn't an existing issue for your bug. If there is, leave a comment on the existing issue.
-          * Ensure you're running stock openpilot. We cannot look into bug reports from forks.
-
-        If you're unsure whether you've hit a bug, check out the #installation-help channel in the [community Discord server](https://discord.comma.ai).
-
-  - type: textarea
-    attributes:
-      label: Describe the bug
-      description: Also include a description of how to reproduce the bug
-    validations:
-      required: true
-
-  - type: input
-    id: car
-    attributes:
-      label: Which car does this affect?
-      placeholder: Toyota Prius 2017
-    validations:
-      required: true
-
-  - type: input
-    id: route
-    attributes:
-      label: Provide a route where the issue occurs
-      description: Ensure the route is fully uploaded at https://useradmin.comma.ai
-      placeholder: 77611a1fac303767|2020-05-11--16-37-07
-    validations:
-      required: true
-
-  - type: input
-    id: version
-    attributes:
-      label: openpilot version
-      description: If you're not on release, provide the commit hash
-      placeholder: 0.8.10
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: Additional info
-
@@ -1,14 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Report model bugs
-    url: https://github.com/commaai/openpilot/discussions/categories/model-feedback
-    about: Provide feedback for the driving or driver monitoring models
-  - name: Discussions
-    url: https://github.com/commaai/openpilot/discussions
-    about: For questions and general discussion about openpilot
-  - name: Community Wiki
-    url: https://github.com/commaai/openpilot/wiki
-    about: Check out our community wiki
-  - name: Community Discord
-    url: https://discord.comma.ai
-    about: Check out our community discord
@@ -1,8 +0,0 @@
---
-name: Enhancement
-about: For openpilot enhancement suggestions
-title: ''
-labels: 'enhancement'
-assignees: ''
---
-
@@ -1,42 +0,0 @@
-name: PC bug report
-description: For issues with running openpilot on PC
-labels: ["PC"]
-body:
-
-  - type: markdown
-    attributes:
-      value: >
-        Before creating a **bug report**, please check the following:
-          * Ensure you're running the latest openpilot release.
-          * Ensure there isn't an existing issue for your bug. If there is, leave a comment on the existing issue.
-          * Ensure you're running stock openpilot. We cannot look into bug reports from forks.
-
-        If you're unsure whether you've hit a bug, check out the #installation-help channel in the [community Discord server](https://discord.comma.ai).
-
-  - type: textarea
-    attributes:
-      label: Describe the bug
-      description: Also include a description of how to reproduce the bug
-    validations:
-      required: true
-
-  - type: input
-    id: os-version
-    attributes:
-      label: OS Version
-      placeholder: Ubuntu 20.04
-    validations:
-      required: true
-
-  - type: input
-    id: version
-    attributes:
-      label: openpilot version or commit
-      placeholder: bd36f2ec8d3559909678eff2690c10a520938367
-    validations:
-      required: false
-
-  - type: textarea
-    attributes:
-      label: Additional info
-
@@ -1,15 +0,0 @@
---
-name: Bug fix
-about: For openpilot bug fixes
-title: ''
-labels: 'bugfix'
-assignees: ''
---
-
-**Description**
-
-<!-- A description of the bug and the fix. Also link the issue if it exists. -->
-
-**Verification**
-
-<!-- Explain how you tested this bug fix. -->
@@ -1,19 +0,0 @@
---
-name: Car Bug fix
-about: For vehicle/brand specific bug fixes
-title: ''
-labels: 'car bug fix'
-assignees: ''
---
-
-**Description**
-
-<!-- A description of the bug and the fix. Also link the issue if it exists. -->
-
-**Verification**
-
-<!-- Explain how you tested this bug fix. -->
-
-**Route**
-
-Route: [a route with the bug fix]
@@ -1,15 +0,0 @@
---
-name: Car port
-about: For new car ports
-title: ''
-labels: 'car port'
-assignees: ''
---
-
-**Checklist**
-
- [ ] added to README
- [ ] test route added to [routes.py](https://github.com/commaai/openpilot/blob/master/selfdrive/car/tests/routes.py)
- [ ] route with openpilot:
- [ ] route with stock system:
- [ ] car harness used (if comma doesn't sell it, put N/A):
@@ -1,11 +0,0 @@
---
-name: Fingerprint
-about: For adding fingerprints to existing cars
-title: ''
-labels: 'fingerprint'
-assignees: ''
---
-
-Discord username: []
-
-Route: []
@@ -1,15 +0,0 @@
---
-name: Refactor
-about: For code refactors
-title: ''
-labels: 'refactor'
-assignees: ''
---
-
-**Description**
-
-<!-- A description of the refactor, including the goals it accomplishes. -->
-
-**Verification**
-
-<!-- Explain how you tested the refactor for regressions. -->
@@ -1,32 +0,0 @@
---
-name: Tuning
-about: For openpilot tuning changes
-title: ''
-labels: 'tuning'
-assignees: ''
---
-
-**Description**
-
-<!-- A description of what is wrong with the current tuning and how the PR addresses this. -->
-
-**Verification**
-
-<!-- To verify tuning, capture the following scenarios (broadly, not exactly), with current tune and this tune.
-Use the PlotJuggler tuning layout to compare planned versus actual behavior.
-
-Run ./juggle.py <route> --layout layouts/tuning.xml , screenshot the full tab of interest, and paste into this PR.
-
-Longitudinal:
-* Maintaining speed at 25, 40, 65mph
-* Driving up and down hills
-* Accelerating from a stop
-* Decelerating to a stop
-* Following large changes in set speed
-* Coming to a stop behind a lead car
-
-Lateral:
-* Straight driving at ~25, ~45 and ~65mph
-* Turns driving at ~25, ~45 and ~65mph
-
-->
@@ -1,38 +0,0 @@
-<!-- Please copy and paste the relevant template -->
-
-<!--- ***** Template: Car bug fix *****
-
-**Description** [](A description of the bug and the fix. Also link any relevant issues.)
-
-**Verification** [](Explain how you tested this bug fix.)
-
-**Route**
-Route: [a route with the bug fix]
-
-->
-
-<!--- ***** Template: Bug fix *****
-
-**Description** [](A description of the bug and the fix. Also link any relevant issues.)
-
-**Verification** [](Explain how you tested this bug fix.)
-
-->
-
-<!--- ***** Template: Car port *****
-
-**Checklist**
- [ ] added entry to CarInfo in selfdrive/car/*/values.py and ran `selfdrive/car/docs.py` to generate new docs
- [ ] test route added to [routes.py](https://github.com/commaai/openpilot/blob/master/selfdrive/car/tests/routes.py)
- [ ] route with openpilot:
- [ ] route with stock system:
-
-->
-
-<!--- ***** Template: Refactor *****
-
-**Description** [](A description of the refactor, including the goals it accomplishes.)
-
-**Verification** [](Explain how you tested the refactor for regressions.)
-
-->
@@ -1,33 +0,0 @@
-name: badges
-on:
-  schedule:
-    - cron: '0 * * * *'
-  workflow_dispatch:
-
-env:
-  BASE_IMAGE: openpilot-base
-  DOCKER_REGISTRY: ghcr.io/commaai
-  RUN: docker run --shm-size 1G -v $PWD:/tmp/openpilot -w /tmp/openpilot -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 $DOCKER_REGISTRY/$BASE_IMAGE:latest /bin/sh -c
-
-jobs:
-  badges:
-    name: create badges
-    runs-on: ubuntu-20.04
-    if: github.repository == 'commaai/openpilot'
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Push badges
-      run: |
-        ${{ env.RUN }} "scons -j$(nproc) && python selfdrive/ui/translations/create_badges.py"
-
-        git checkout --orphan badges
-        git rm -rf --cached .
-        git config user.email "badge-researcher@comma.ai"
-        git config user.name "Badge Researcher"
-
-        git add translation_badge.svg
-        git commit -m "Add/Update badges"
-        git push -f origin HEAD
@@ -1,33 +0,0 @@
-name: prebuilt
-on:
-  schedule:
-    - cron: '0 * * * *'
-  workflow_dispatch:
-
-env:
-  DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
-  BUILD: selfdrive/test/docker_build.sh prebuilt
-
-jobs:
-  build_prebuilt:
-    name: build prebuilt
-    runs-on: ubuntu-20.04
-    if: github.repository == 'commaai/openpilot'
-    env:
-      PUSH_IMAGE: true
-    steps:
-    - name: Wait for green check mark
-      if: ${{ github.event_name != 'workflow_dispatch' }}
-      uses: lewagon/wait-on-check-action@e2558238c09778af25867eb5de5a3ce4bbae3dcd
-      with:
-        ref: master
-        wait-interval: 30
-        running-workflow-name: 'build prebuilt'
-        check-regexp: ^((?!.*(build master-ci).*).)*$
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Build and Push docker image
-      run: |
-        $DOCKER_LOGIN
-        eval "$BUILD"
@@ -1,50 +0,0 @@
-name: release
-on:
-  schedule:
-    - cron: '0 * * * *'
-  workflow_dispatch:
-
-jobs:
-  build_masterci:
-    name: build master-ci
-    env:
-      TARGET_DIR: /tmp/openpilot
-      ImageOS: ubuntu20
-    container:
-      image: ghcr.io/commaai/openpilot-base:latest
-    runs-on: ubuntu-20.04
-    if: github.repository == 'commaai/openpilot'
-    steps:
-    - name: Install wait-on-check-action dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y libyaml-dev
-    - name: Wait for green check mark
-      if: ${{ github.event_name != 'workflow_dispatch' }}
-      uses: lewagon/wait-on-check-action@e2558238c09778af25867eb5de5a3ce4bbae3dcd
-      with:
-        ref: master
-        wait-interval: 30
-        running-workflow-name: 'build master-ci'
-        check-regexp: ^((?!.*(build prebuilt).*).)*$
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-        fetch-depth: 0
-    - name: Pull LFS
-      run: |
-        git config --global --add safe.directory '*'
-        git lfs pull
-    - name: Build master-ci
-      run: |
-        release/build_devel.sh
-    - name: Run tests
-      run: |
-        export PYTHONPATH=$TARGET_DIR
-        cd $TARGET_DIR
-        scons -j$(nproc)
-        selfdrive/car/tests/test_car_interfaces.py
-    - name: Push master-ci
-      run: |
-        unset TARGET_DIR
-        BRANCH=master-ci release/build_devel.sh
@@ -1,32 +0,0 @@
-name: repo maintenance
-
-on:
-  schedule:
-    - cron: "0 15 * * 2"
-  workflow_dispatch:
-
-jobs:
-  updates:
-    name: updates
-    runs-on: ubuntu-20.04
-    container:
-      image: ghcr.io/commaai/openpilot-base:latest
-    steps:
-    - uses: actions/checkout@v3
-    - name: poetry lock
-      run: |
-        pip install poetry
-        poetry lock
-    - name: pre-commit autoupdate
-      run: |
-        git config --global --add safe.directory '*'
-        pre-commit autoupdate
-    - name: Create Pull Request
-      uses: peter-evans/create-pull-request@5b4a9f6a9e2af26e5f02351490b90d01eb8ec1e5
-      with:
-        token: ${{ secrets.ACTIONS_CREATE_PR_PAT }}
-        commit-message: Update Python packages and pre-commit hooks
-        title: 'Update Python packages and pre-commit hooks'
-        branch: auto-package-updates
-        base: master
-        delete-branch: true
@@ -1,422 +0,0 @@
-name: selfdrive
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-
-concurrency:
-  group: ${{ 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: openpilot-base
-  CL_BASE_IMAGE: openpilot-base-cl
-  AZURE_TOKEN: ${{ secrets.AZURE_COMMADATACI_OPENPILOTCI_TOKEN }}
-
-  DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
-  BUILD: selfdrive/test/docker_build.sh base
-
-  RUN: docker run --shm-size 1G -v $PWD:/tmp/openpilot -w /tmp/openpilot -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/sh -c
-
-  BUILD_CL: selfdrive/test/docker_build.sh cl
-
-  RUN_CL: docker run --shm-size 1G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e PYTHONWARNINGS=error -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 $CL_BASE_IMAGE /bin/sh -c
-
-  UNIT_TEST: coverage run --append -m unittest discover
-  PYTEST: pytest --continue-on-collection-errors --cov --cov-report=xml --cov-append --durations=0 --durations-min=5
-
-jobs:
-  build_release:
-    name: build release
-    runs-on: ubuntu-20.04
-    env:
-      STRIPPED_DIR: /tmp/releasepilot
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Build devel
-      timeout-minutes: 1
-      run: TARGET_DIR=$STRIPPED_DIR release/build_devel.sh
-    - uses: ./.github/workflows/setup
-    - name: Check submodules
-      if: github.ref == 'refs/heads/master' && github.repository == 'commaai/openpilot'
-      timeout-minutes: 1
-      run: release/check-submodules.sh
-    - name: Build openpilot and run checks
-      timeout-minutes: ${{ ((steps.restore-scons-cache.outputs.cache-hit == 'true') && 10 || 30) }} # allow more time when we missed the scons cache
-      run: |
-        cd $STRIPPED_DIR
-        ${{ env.RUN }} "CI=1 python selfdrive/manager/build.py"
-    - name: Run tests
-      timeout-minutes: 2
-      run: |
-        cd $STRIPPED_DIR
-        ${{ env.RUN }} "release/check-dirty.sh && \
-                        python -m unittest discover selfdrive/car"
-    - name: pre-commit
-      timeout-minutes: 3
-      run: |
-        cd $GITHUB_WORKSPACE
-        cp .pre-commit-config.yaml $STRIPPED_DIR
-        cp pyproject.toml $STRIPPED_DIR
-        cp poetry.lock $STRIPPED_DIR
-        cd $STRIPPED_DIR
-        ${{ env.RUN }} "unset PYTHONWARNINGS && pre-commit run --all"
-
-  build_all:
-    name: build all
-    runs-on: ubuntu-20.04
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Build openpilot with all flags
-      timeout-minutes: ${{ ((steps.restore-scons-cache.outputs.cache-hit == 'true') && 12 || 30) }} # allow more time when we missed the scons cache
-      run: |
-        ${{ env.RUN }} "scons -j$(nproc)"
-        ${{ env.RUN }} "release/check-dirty.sh"
-    - name: Cleanup scons cache and rebuild
-      timeout-minutes: ${{ ((steps.restore-scons-cache.outputs.cache-hit == 'true') && 2 || 30) }} # allow more time when we missed the scons cache
-      run: |
-          ${{ env.RUN }} "rm -rf /tmp/scons_cache/* && \
-                          scons -j$(nproc) --cache-populate"
-    - name: Save scons cache
-      uses: actions/cache/save@v3
-      if: github.ref == 'refs/heads/master'
-      with:
-        path: .ci_cache/scons_cache
-        key: scons-${{ env.CACHE_COMMIT_DATE }}-${{ github.sha }}
-
-  build_mac:
-    name: build macos
-    runs-on: macos-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Determine pre-existing Homebrew packages
-      if: steps.dependency-cache.outputs.cache-hit != 'true'
-      run: |
-        echo 'EXISTING_CELLAR<<EOF' >> $GITHUB_ENV
-        brew list --formula -1 >> $GITHUB_ENV
-        echo 'EOF' >> $GITHUB_ENV
-    - name: Restore scons cache
-      id: scons-restore-cache
-      uses: actions/cache/restore@v3
-      with:
-        path: /tmp/scons_cache
-        key: macos_scons-${{ github.sha }}
-        restore-keys: macos_scons-
-    - name: Cache dependencies
-      id: dependency-cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          .env
-          .venv
-          ~/github_brew_cache_entries.txt
-          ~/.pyenv
-          ~/Library/Caches/pypoetry
-          /usr/local/Cellar
-          /usr/local/opt
-          /usr/local/Caskroom/gcc-arm-*
-          /opt/homebrew/Cellar
-          /opt/homebrew/opt
-          /opt/homebrew/Caskroom/gcc-arm-*
-          /Applications/ArmGNUToolchain/*/*/*
-        key: macos_deps-${{ hashFiles('tools/mac_setup.sh', 'tools/install_python_dependencies.sh', 'poetry.lock') }}
-        restore-keys: macos_deps-
-    - name: Brew link restored dependencies
-      run: |
-        if [ -f ~/github_brew_cache_entries.txt ]; then
-          brew link --force --overwrite $(cat ~/github_brew_cache_entries.txt) # `--force` for keg-only packages
-          if [ -d /Applications/ArmGNUToolchain ]; then # link gcc-arm-embedded manually
-            GCC_TOOLCHAIN="$(echo /Applications/ArmGNUToolchain/**/**/bin)"
-            echo "$GCC_TOOLCHAIN" >> $GITHUB_PATH
-          fi
-        else
-          echo "Cache entries not found"
-        fi
-    - name: Install dependencies
-      if: steps.dependency-cache.outputs.cache-hit != 'true'
-      run: ./tools/mac_setup.sh
-      env:
-        # package install has DeprecationWarnings
-        PYTHONWARNINGS: default
-    - name: Build openpilot
-      run: |
-        eval "$(pyenv init --path)"
-        poetry run scons -j$(nproc)
-    - name: Run tests
-      run: |
-        eval "$(pyenv init --path)"
-        poetry run tools/plotjuggler/test_plotjuggler.py
-    - name: Pre Cache - Cleanup scons cache
-      if: github.ref == 'refs/heads/master'
-      run: |
-        rm -rf /tmp/scons_cache/*
-        eval "$(pyenv init --path)"
-        poetry run scons -j$(nproc) --cache-populate
-    - name: Save scons cache
-      id: scons-save-cache
-      uses: actions/cache/save@v3
-      if: github.ref == 'refs/heads/master'
-      with:
-        path: /tmp/scons_cache
-        key: macos_scons-${{ github.sha }}
-    - name: Pre Cache - Remove pre-existing Homebrew packages
-      if: steps.dependency-cache.outputs.cache-hit != 'true'
-      run: |
-        new_cellar=$(brew list --formula -1)
-        exceptions="zstd lz4 xz" # caching step needs zstd
-        comm -12 <(echo "$EXISTING_CELLAR") <(echo "$new_cellar") | while read pkg; do
-          if [[ " $exceptions " != *" $pkg "* ]]; then
-            rm -rf "$(brew --cellar)/$pkg"
-          fi
-        done
-        comm -13 <(echo "$EXISTING_CELLAR") <(echo "$new_cellar") | tee ~/github_brew_cache_entries.txt
-        # .fseventsd directory causes permission errors in dep caching step
-        # its used by the system to observe changes within the directory - toolchain works without it, just remove it
-        sudo rm -rf /Applications/ArmGNUToolchain/*/*/.fseventsd
-
-  docker_push:
-    name: docker push
-    runs-on: ubuntu-20.04
-    if: github.ref == 'refs/heads/master' && github.event_name != 'pull_request' && github.repository == 'commaai/openpilot'
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Setup to push to repo
-      run: |
-        echo "PUSH_IMAGE=true" >> "$GITHUB_ENV"
-        $DOCKER_LOGIN
-    - uses: ./.github/workflows/setup
-      with:
-        git-lfs: false
-    - name: Build and push CL Docker image
-      run: |
-        eval "$BUILD_CL"
-
-  static_analysis:
-    name: static analysis
-    runs-on: ubuntu-20.04
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Build Docker image
-      run: eval "$BUILD"
-    - name: pre-commit
-      timeout-minutes: 4
-      run: ${{ env.RUN }} "unset PYTHONWARNINGS && pre-commit run --all"
-
-  valgrind:
-    name: valgrind
-    runs-on: ubuntu-20.04
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Build openpilot
-      run: ${{ env.RUN }} "scons -j$(nproc)"
-    - name: Run valgrind
-      timeout-minutes: 1
-      run: |
-        ${{ env.RUN }} "python selfdrive/test/test_valgrind_replay.py"
-    - name: Print logs
-      if: always()
-      run: cat selfdrive/test/valgrind_logs.txt
-
-  unit_tests:
-    name: unit tests
-    runs-on: ubuntu-20.04
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Build openpilot
-      timeout-minutes: ${{ ((steps.restore-scons-cache.outputs.cache-hit == 'true') && 10 || 30) }} # allow more time when we missed the scons cache
-      run: ${{ env.RUN }} "scons -j$(nproc)"
-    - name: Run unit tests
-      timeout-minutes: 40
-      run: |
-        ${{ env.RUN }} "export SKIP_LONG_TESTS=1 && \
-                        $PYTEST --rootdir . -c selfdrive/test/pytest-ci.ini && \
-                        selfdrive/locationd/test/_test_locationd_lib.py && \
-                        ./system/ubloxd/tests/test_glonass_runner && \
-                        ./selfdrive/ui/tests/create_test_translations.sh && \
-                        QT_QPA_PLATFORM=offscreen ./selfdrive/ui/tests/test_translations && \
-                        ./selfdrive/ui/tests/test_translations.py && \
-                        ./common/tests/test_common && \
-                        ./selfdrive/boardd/tests/test_boardd_usbprotocol && \
-                        ./system/loggerd/tests/test_logger &&\
-                        ./system/proclogd/tests/test_proclog && \
-                        ./tools/replay/tests/test_replay && \
-                        ./tools/cabana/tests/test_cabana && \
-                        ./system/camerad/test/ae_gray_test && \
-                        ./selfdrive/test/process_replay/test_fuzzy.py"
-    - name: "Upload coverage to Codecov"
-      uses: codecov/codecov-action@v3
-
-  process_replay:
-    name: process replay
-    runs-on: ${{ ((github.event.pull_request.head.repo.full_name == 'commaai/openpilot') || (github.repository == 'commaai/openpilot')) && 'buildjet-8vcpu-ubuntu-2004' || 'ubuntu-20.04' }}
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Cache test routes
-      id: dependency-cache
-      uses: actions/cache@v3
-      with:
-        path: .ci_cache/comma_download_cache
-        key: proc-replay-${{ hashFiles('.github/workflows/selfdrive_tests.yaml', 'selfdrive/test/process_replay/ref_commit') }}
-    - name: Build openpilot
-      run: |
-        ${{ env.RUN }} "scons -j$(nproc)"
-    - name: Run replay
-      timeout-minutes: 30
-      run: |
-        ${{ env.RUN }} "CI=1 coverage run selfdrive/test/process_replay/test_processes.py -j$(nproc) && \
-                        chmod -R 777 /tmp/comma_download_cache && \
-                        coverage xml"
-    - name: Print diff
-      id: print-diff
-      if: always()
-      run: cat selfdrive/test/process_replay/diff.txt
-    - uses: actions/upload-artifact@v2
-      if: always()
-      continue-on-error: true
-      with:
-        name: process_replay_diff.txt
-        path: selfdrive/test/process_replay/diff.txt
-    - name: Upload reference logs
-      if: ${{ failure() && steps.print-diff.outcome == 'success' && github.repository == 'commaai/openpilot' && env.AZURE_TOKEN != '' }}
-      run: |
-        ${{ env.RUN }} "unset PYTHONWARNINGS && CI=1 AZURE_TOKEN='$AZURE_TOKEN' python selfdrive/test/process_replay/test_processes.py -j$(nproc) --upload-only"
-    - name: "Upload coverage to Codecov"
-      uses: codecov/codecov-action@v3
-
-  test_modeld:
-    name: model tests
-    runs-on: ubuntu-20.04
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Build base Docker image
-      run: eval "$BUILD"
-    - name: Build Docker image
-      # Sim docker is needed to get the OpenCL drivers
-      run: eval "$BUILD_CL"
-    - name: Build openpilot
-      run: |
-        ${{ env.RUN }} "scons -j$(nproc)"
-    # PYTHONWARNINGS triggers a SyntaxError in onnxruntime
-    - name: Run model replay with ONNX
-      timeout-minutes: 2
-      run: |
-        ${{ env.RUN_CL }} "unset PYTHONWARNINGS && \
-                           ONNXCPU=1 CI=1 NO_NAV=1 coverage run selfdrive/test/process_replay/model_replay.py && \
-                           coverage xml"
-    - name: Run unit tests
-      timeout-minutes: 4
-      run: |
-        ${{ env.RUN_CL }} "unset PYTHONWARNINGS && \
-                           $UNIT_TEST selfdrive/modeld && \
-                           coverage xml"
-    - name: "Upload coverage to Codecov"
-      uses: codecov/codecov-action@v3
-
-  test_cars:
-    name: cars
-    runs-on: ubuntu-20.04
-    strategy:
-      fail-fast: false
-      matrix:
-        job: [0, 1, 2, 3, 4]
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Cache test routes
-      id: dependency-cache
-      uses: actions/cache@v3
-      with:
-        path: .ci_cache/comma_download_cache
-        key: car_models-${{ hashFiles('selfdrive/car/tests/test_models.py', 'selfdrive/car/tests/routes.py') }}-${{ matrix.job }}
-    - name: Build openpilot
-      run: ${{ env.RUN }} "scons -j$(nproc)"
-    - name: Test car models
-      timeout-minutes: 25
-      run: |
-        ${{ env.RUN }} "$PYTEST -n auto --dist=loadscope selfdrive/car/tests/test_models.py && \
-                        chmod -R 777 /tmp/comma_download_cache"
-      env:
-        NUM_JOBS: 5
-        JOB_ID: ${{ matrix.job }}
-    - name: "Upload coverage to Codecov"
-      uses: codecov/codecov-action@v3
-
-  car_docs_diff:
-    name: PR comments
-    runs-on: ubuntu-20.04
-    if: github.event_name == 'pull_request'
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-          ref: ${{ github.event.pull_request.base.ref }}
-      - uses: ./.github/workflows/setup
-      - name: Get base car info
-        run: |
-          ${{ env.RUN }} "scons -j$(nproc) && python selfdrive/debug/dump_car_info.py --path /tmp/openpilot_cache/base_car_info"
-          sudo chown -R $USER:$USER ${{ github.workspace }}
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-          path: current
-      - name: Save car docs diff
-        id: save_diff
-        run: |
-          cd current
-          ${{ env.RUN }} "scons -j$(nproc)"
-          output=$(${{ env.RUN }} "python selfdrive/debug/print_docs_diff.py --path /tmp/openpilot_cache/base_car_info")
-          output="${output//$'\n'/'%0A'}"
-          echo "::set-output name=diff::$output"
-      - name: Find comment
-        if: ${{ env.AZURE_TOKEN != '' }}
-        uses: peter-evans/find-comment@1769778a0c5bd330272d749d12c036d65e70d39d
-        id: fc
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: This PR makes changes to
-      - name: Update comment
-        if: ${{ steps.save_diff.outputs.diff != '' && env.AZURE_TOKEN != '' }}
-        uses: peter-evans/create-or-update-comment@b95e16d2859ad843a14218d1028da5b2c4cbc4b4
-        with:
-          comment-id: ${{ steps.fc.outputs.comment-id }}
-          issue-number: ${{ github.event.pull_request.number }}
-          body: "${{ steps.save_diff.outputs.diff }}"
-          edit-mode: replace
-      - name: Delete comment
-        if: ${{ steps.fc.outputs.comment-id != '' && steps.save_diff.outputs.diff == '' && env.AZURE_TOKEN != '' }}
-        uses: actions/github-script@v6
-        with:
-          script: |
-            github.rest.issues.deleteComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              comment_id: ${{ steps.fc.outputs.comment-id }}
-            })
@@ -1,51 +0,0 @@
-name: 'openpilot env setup'
-
-inputs:
-  git_lfs:
-    description: 'Whether or not to pull the git lfs'
-    required: false
-    default: 'true'
-
-runs:
-  using: "composite"
-  steps:
-    # do this after checkout to ensure our custom LFS config is used to pull from GitLab
-    - shell: bash
-      if: ${{ inputs.git_lfs == 'true' }}
-      run: git lfs pull
-
-    # build cache
-    - id: date
-      shell: bash
-      run: echo "CACHE_COMMIT_DATE=$(git log -1 --pretty='format:%cd' --date=format:'%Y-%m-%d-%H:%M')" >> $GITHUB_ENV
-    - shell: bash
-      run: echo "$CACHE_COMMIT_DATE"
-    - id: restore-scons-cache
-      uses: actions/cache/restore@v3
-      with:
-        path: .ci_cache/scons_cache
-        key: scons-${{ env.CACHE_COMMIT_DATE }}-${{ github.sha }}
-        restore-keys: |
-          scons-${{ env.CACHE_COMMIT_DATE }}-
-          scons-
-    # if we didn't get a cache hit, make the directory manually so it doesn't fail on future steps
-    - id: scons-cache-setup
-      shell: bash
-      if: steps.restore-scons-cache.outputs.cache-hit != 'true'
-      run: mkdir -p $GITHUB_WORKSPACE/.ci_cache/scons_cache
-    # as suggested here: https://github.com/moby/moby/issues/32816#issuecomment-910030001
-    - id: normalize-file-permissions
-      shell: bash
-      name: Normalize file permissions to ensure a consistent docker build cache
-      run: |
-        find . -type f -executable -not -perm 755 -exec chmod 755 {} \;
-        find . -type f -not -executable -not -perm 644 -exec chmod 644 {} \;
-    - id: setup-buildx-action
-      if: contains(runner.name, 'buildjet')
-      name: Set up Docker Buildx on buildjet to ensure a consistent cache
-      uses: docker/setup-buildx-action@v2
-      with:
-        driver: docker-container
-    # build our docker image
-    - shell: bash
-      run: eval ${{ env.BUILD }}
@@ -1,101 +0,0 @@
-name: tools
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-
-concurrency:
-  group: ${{ 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:
-  BASE_IMAGE: openpilot-base
-  CL_BASE_IMAGE: openpilot-base-cl
-  DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
-
-  BUILD: selfdrive/test/docker_build.sh base
-
-  RUN: docker run --shm-size 1G -v $GITHUB_WORKSPACE:/tmp/openpilot -w /tmp/openpilot -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/sh -c
-
-  BUILD_CL: selfdrive/test/docker_build.sh cl
-
-  RUN_CL: docker run --shm-size 1G -v $GITHUB_WORKSPACE:/tmp/openpilot -w /tmp/openpilot -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 $CL_BASE_IMAGE /bin/sh -c
-
-
-jobs:
-  plotjuggler:
-    name: plotjuggler
-    runs-on: ubuntu-20.04
-    timeout-minutes: 45
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Build Docker image
-      run: eval "$BUILD"
-    - name: Build openpilot
-      timeout-minutes: 5
-      run: ${{ env.RUN }} "scons -j$(nproc) --directory=/tmp/openpilot/cereal --minimal"
-    - name: Test PlotJuggler
-      timeout-minutes: 2
-      run: |
-        ${{ env.RUN }} "pytest tools/plotjuggler/"
-
-  simulator:
-    name: simulator
-    runs-on: ubuntu-20.04
-    if: github.repository == 'commaai/openpilot'
-    timeout-minutes: 45
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-    - name: Build base cl image
-      run: eval "$BUILD_CL"
-    - name: Setup to push to repo
-      if: github.ref == 'refs/heads/master' && github.repository == 'commaai/openpilot'
-      run: |
-        echo "PUSH_IMAGE=true" >> "$GITHUB_ENV"
-        $DOCKER_LOGIN
-    - name: Build and push sim image
-      run: |
-        selfdrive/test/docker_build.sh sim
-
-  docs:
-    name: build docs
-    runs-on: ubuntu-20.04
-    timeout-minutes: 45
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/workflows/setup
-      with:
-        git_lfs: false
-    - name: Setup to push to repo
-      if: github.ref == 'refs/heads/master' && github.event_name != 'pull_request' && github.repository == 'commaai/openpilot'
-      run: |
-        echo "PUSH_IMAGE=true" >> "$GITHUB_ENV"
-        $DOCKER_LOGIN
-    - name: Build and push docs image
-      run: |
-        selfdrive/test/docker_build.sh docs
-
-  devcontainer:
-    name: devcontainer
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Setup Dev Container CLI
-      run: npm install -g @devcontainers/cli
-    - name: Build dev container image
-      run: devcontainer build --workspace-folder .
-    - name: Run dev container
-      run: devcontainer up --workspace-folder .
-    - name: Test environment
-      run: devcontainer exec --workspace-folder . scons --dry-run
@@ -10,14 +10,23 @@ venv/
 .overlay_init
 .overlay_consistent
 .sconsign.dblite
-.vscode*
-model2.png
 a.out
 .hypothesis
+.cache/
+bin/

+# created at launch for TICI PYTHONPATH (PC uses editable installs via pyproject.toml)
+/msgq
+/opendbc
+/rednose
+/teleoprtc
+/tinygrad
+
+*.mp4
 *.dylib
 *.DSYM
 *.d
+*.pem
 *.pyc
 *.pyo
 .*.swp
@@ -34,56 +43,62 @@ a.out
 *.class
 *.pyxbldc
 *.vcd
-*.qm
+*.mo
+*_pyx.cpp
+*.stats
+*.pkl
+*.pkl*
 config.json
-clcache
 compile_commands.json
 compare_runtime*.html
+openpilot/selfdrive/modeld/models/tg_input_devices.json

-persist
-board/obj/
-selfdrive/boardd/boardd
-selfdrive/logcatd/logcatd
-selfdrive/mapd/default_speeds_by_region.json
-system/proclogd/proclogd
-selfdrive/ui/_ui
-selfdrive/ui/translations/alerts_generated.h
-selfdrive/test/longitudinal_maneuvers/out
-selfdrive/car/tests/cars_dump
-system/camerad/camerad
-system/camerad/test/ae_gray_test
-selfdrive/modeld/_modeld
-selfdrive/modeld/_navmodeld
-selfdrive/modeld/_dmonitoringmodeld
-/src/
-
-one
-notebooks
-xx
-yy
-hyperthneed
-panda_jungle
-provisioning
+# build artifacts
+docs_site/
+openpilot/selfdrive/pandad/pandad
+openpilot/cereal/services.h
+openpilot/cereal/gen
+openpilot/cereal/messaging/bridge
+openpilot/selfdrive/ui/translations/tmp
+openpilot/selfdrive/car/tests/cars_dump
+openpilot/system/camerad/camerad
+openpilot/system/camerad/test/ae_gray_test

 .coverage*
 coverage.xml
 htmlcov
-pandaextra
-
-.mypy_cache/
-flycheck_*
-
-cppcheck_report.txt
-comma*.sh
-
-selfdrive/modeld/thneed/compile
-selfdrive/modeld/models/*.thneed

+# openpilot log files
 *.bz2
+*.zst
+*.rlog

 build/

 !**/.gitkeep

-poetry.toml
-Pipfile
+
+### VisualStudioCode ###
+*.vsix
+.history
+.ionide
+.vscode/*
+.history/
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# agents
+.claude/
+.context/
+PLAN.md
+TASK.md
+CLAUDE.md
+SKILL.md
+
+### JetBrains ###
+!.idea/customTargets.xml
+!.idea/tools/*
+!.run/*
@@ -1,21 +0,0 @@
-[submodule "panda"]
-  path = panda
-  url = ../../commaai/panda.git
-[submodule "opendbc"]
-  path = opendbc
-  url = ../../commaai/opendbc.git
-[submodule "laika_repo"]
-  path = laika_repo
-  url = ../../commaai/laika.git
-[submodule "cereal"]
-  path = cereal
-  url = ../../commaai/cereal.git
-[submodule "rednose_repo"]
-  path = rednose_repo
-  url = ../../commaai/rednose.git
-[submodule "body"]
-  path = body
-  url = ../../commaai/body.git
-[submodule "tinygrad"]
-  path = tinygrad_repo
-  url = https://github.com/geohot/tinygrad.git
@@ -1,4 +0,0 @@
-[lfs]
-	url = https://gitlab.com/commaai/openpilot-lfs.git/info/lfs
-	pushurl = ssh://git@gitlab.com/commaai/openpilot-lfs.git
-	locksverify = false
@@ -1,82 +0,0 @@
-repos:
-   repo: meta
-    hooks:
-    -   id: check-hooks-apply
-    -   id: check-useless-excludes
-   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-    -   id: check-ast
-        exclude: '^(third_party)/'
-    -   id: check-json
-    -   id: check-toml
-    -   id: check-xml
-    -   id: check-yaml
-    -   id: check-merge-conflict
-    -   id: check-symlinks
-    -   id: check-added-large-files
-        args: ['--maxkb=100']
-   repo: https://github.com/codespell-project/codespell
-    rev: v2.2.5
-    hooks:
-    -   id: codespell
-        exclude: '^(third_party/)|(body/)|(cereal/)|(rednose/)|(panda/)|(laika/)|(opendbc/)|(laika_repo/)|(rednose_repo/)|(selfdrive/ui/translations/.*.ts)|(poetry.lock)'
-        args:
-        # if you've got a short variable name that's getting flagged, add it here
-        - -L bu,ro,te,ue,alo,hda,ois,nam,nams,ned,som,parm,setts,inout,warmup,bumb,nd,sie
-        - --builtins clear,rare,informal,usage,code,names,en-GB_to_en-US
-   repo: local
-    hooks:
-    -   id: mypy
-        name: mypy
-        entry: mypy
-        language: system
-        types: [python]
-        args: ['--explicit-package-bases']
-        exclude: '^(third_party/)|(cereal/)|(opendbc/)|(panda/)|(laika/)|(laika_repo/)|(rednose/)|(rednose_repo/)|(tinygrad/)|(tinygrad_repo/)|(xx/)'
-   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.287
-    hooks:
-    -   id: ruff
-        exclude: '^(third_party/)|(cereal/)|(rednose/)|(panda/)|(laika/)|(laika_repo/)|(rednose_repo/)|(tinygrad/)|(tinygrad_repo/)'
-   repo: local
-    hooks:
-    -   id: cppcheck
-        name: cppcheck
-        entry: cppcheck
-        language: system
-        types: [c++]
-        exclude: '^(third_party/)|(cereal/)|(body/)|(rednose/)|(rednose_repo/)|(opendbc/)|(panda/)|(tools/)|(selfdrive/modeld/thneed/debug/)|(selfdrive/modeld/test/)|(selfdrive/camerad/test/)|(installer/)'
-        args:
-        - --error-exitcode=1
-        - --language=c++
-        - --quiet
-        - --force
-        - -j8
-   repo: https://github.com/cpplint/cpplint
-    rev: 1.6.1
-    hooks:
-    -   id: cpplint
-        exclude: '^(third_party/)|(cereal/)|(body/)|(rednose/)|(rednose_repo/)|(opendbc/)|(panda/)|(generated/)'
-        args:
-        - --quiet
-        - --counting=total
-        - --linelength=240
-        # https://google.github.io/styleguide/cppguide.html
-        # relevant rules are whitelisted, see all options with: cpplint --filter=
-        - --filter=-build,-legal,-readability,-runtime,-whitespace,+build/include_subdir,+build/forward_decl,+build/include_what_you_use,+build/deprecated,+whitespace/comma,+whitespace/line_length,+whitespace/empty_if_body,+whitespace/empty_loop_body,+whitespace/empty_conditional_body,+whitespace/forcolon,+whitespace/parens,+whitespace/semicolon,+whitespace/tab,+readability/braces
-   repo: local
-    hooks:
-    -   id: test_translations
-        name: test translations
-        entry: selfdrive/ui/tests/test_translations.py
-        language: script
-        pass_filenames: false
-   repo: https://github.com/python-poetry/poetry
-    rev: '1.6.0'
-    hooks:
-    -   id: poetry-check
-    -   id: poetry-lock
-        name: validate poetry lock
-        args:
-        - --check
@@ -1 +1 @@
-3.11.4
+3.12.13
@@ -0,0 +1,8 @@
+{
+  "recommendations": [
+    "ms-python.python",
+    "ms-vscode.cpptools",
+    "elagil.pre-commit-helper",
+    "charliermarsh.ruff",
+  ]
+}
@@ -0,0 +1,88 @@
+{
+  "version": "0.2.0",
+  "inputs": [
+    {
+      "id": "python_process",
+      "type": "pickString",
+      "description": "Select the process to debug",
+      "options": [
+        "openpilot/selfdrive/controls/controlsd.py",
+        "openpilot/system/timed/timed.py",
+        "openpilot/tools/sim/run_bridge.py"
+      ]
+    },
+    {
+      "id": "cpp_process",
+      "type": "pickString",
+      "description": "Select the process to debug",
+      "options": [
+        "openpilot/selfdrive/ui/ui"
+      ]
+    },
+    {
+      "id": "args",
+      "description": "Arguments to pass to the process",
+      "type": "promptString"
+    },
+    {
+      "id": "replayArg",
+      "type": "promptString",
+      "description": "Enter route or segment to replay."
+    }
+  ],
+  "configurations": [
+    {
+      "name": "Python: openpilot Process",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${input:python_process}",
+      "console": "integratedTerminal",
+      "justMyCode": true,
+      "args": "${input:args}"
+    },
+    {
+      "name": "C++: openpilot Process",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/${input:cpp_process}",
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Attach LLDB to Replay drive",
+      "type": "lldb",
+      "request": "attach",
+      "pid": "${command:pickMyProcess}",
+      "sourceMap": {
+        ".": "${workspaceFolder}/opendbc/safety"
+      },
+      "initCommands": [
+        "script import time; time.sleep(3)"
+      ]
+    },
+    {
+      "name": "Replay drive",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${workspaceFolder}/opendbc/safety/tests/safety_replay/replay_drive.py",
+      "args": [
+        "${input:replayArg}"
+      ],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}"
+      },
+      "subProcess": true,
+      "stopOnEntry": false
+    }
+  ],
+  "compounds": [
+    {
+      "name": "Replay drive + Safety LLDB",
+      "configurations": [
+        "Replay drive",
+        "Attach LLDB to Replay drive"
+      ]
+    }
+  ]
+}
@@ -0,0 +1,21 @@
+{
+  "editor.tabSize": 2,
+  "editor.insertSpaces": true,
+  "editor.renderWhitespace": "trailing",
+  "files.trimTrailingWhitespace": true,
+  "search.exclude": {
+    "**/.git": true,
+    "**/.venv": true,
+    "**/__pycache__": true
+  },
+  "files.exclude": {
+    "**/.git": true,
+    "**/.venv": true,
+    "**/__pycache__": true
+  },
+  "python.analysis.exclude": [
+    "**/.git",
+    "**/.venv",
+    "**/__pycache__",
+  ]
+}
@@ -1,29 +0,0 @@
-FROM ghcr.io/commaai/openpilot-base:latest
-
-ENV PYTHONUNBUFFERED 1
-
-ENV OPENPILOT_PATH /home/batman/openpilot
-ENV PYTHONPATH ${OPENPILOT_PATH}:${PYTHONPATH}
-
-RUN mkdir -p ${OPENPILOT_PATH}
-WORKDIR ${OPENPILOT_PATH}
-
-COPY SConstruct ${OPENPILOT_PATH}
-
-COPY ./openpilot ${OPENPILOT_PATH}/openpilot
-COPY ./third_party ${OPENPILOT_PATH}/third_party
-COPY ./site_scons ${OPENPILOT_PATH}/site_scons
-COPY ./laika ${OPENPILOT_PATH}/laika
-COPY ./laika_repo ${OPENPILOT_PATH}/laika_repo
-COPY ./rednose ${OPENPILOT_PATH}/rednose
-COPY ./tools ${OPENPILOT_PATH}/tools
-COPY ./release ${OPENPILOT_PATH}/release
-COPY ./common ${OPENPILOT_PATH}/common
-COPY ./opendbc ${OPENPILOT_PATH}/opendbc
-COPY ./cereal ${OPENPILOT_PATH}/cereal
-COPY ./panda ${OPENPILOT_PATH}/panda
-COPY ./selfdrive ${OPENPILOT_PATH}/selfdrive
-COPY ./system ${OPENPILOT_PATH}/system
-COPY ./body ${OPENPILOT_PATH}/body
-
-RUN scons --cache-readonly -j$(nproc)
@@ -1,39 +0,0 @@
-FROM ubuntu:20.04
-
-ENV PYTHONUNBUFFERED 1
-
-ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends sudo tzdata locales ssh && \
-    rm -rf /var/lib/apt/lists/*
-
-RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && locale-gen
-ENV LANG en_US.UTF-8
-ENV LANGUAGE en_US:en
-ENV LC_ALL en_US.UTF-8
-
-COPY tools/install_ubuntu_dependencies.sh /tmp/tools/
-RUN cd /tmp && \
-    tools/install_ubuntu_dependencies.sh && \
-    rm -rf /var/lib/apt/lists/* && \
-    rm -rf /tmp/* && \
-    # remove unused architectures from gcc for panda
-    cd /usr/lib/gcc/arm-none-eabi/9.2.1 && \
-    rm -rf arm/ && \
-    rm -rf thumb/nofp thumb/v6* thumb/v8* thumb/v7+fp thumb/v7-r+fp.sp
-
-ENV POETRY_VIRTUALENVS_CREATE=false
-ENV PYENV_VERSION=3.11.4
-ENV PYENV_ROOT="/root/.pyenv"
-ENV PATH="$PYENV_ROOT/bin:$PYENV_ROOT/shims:$PATH"
-
-COPY pyproject.toml poetry.lock .python-version /tmp/
-COPY tools/install_python_dependencies.sh /tmp/tools/
-
-RUN cd /tmp && \
-    tools/install_python_dependencies.sh && \
-    rm -rf /tmp/* && \
-    rm -rf /root/.cache && \
-    pip uninstall -y poetry
-
-RUN sudo git config --global --add safe.directory /tmp/openpilot
@@ -1,37 +0,0 @@
-FROM ghcr.io/commaai/openpilot-base:latest
-
-RUN apt-get update && apt-get install -y --no-install-recommends\
-    apt-utils \
-    alien \
-    unzip \
-    tar \
-    curl \
-    xz-utils \
-    dbus \
-    gcc-arm-none-eabi \
-    tmux \
-    vim \
-    lsb-core \
-    libx11-6 \
-  && rm -rf /var/lib/apt/lists/*
-
-# Intel OpenCL driver
-ARG INTEL_DRIVER=l_opencl_p_18.1.0.015.tgz
-ARG INTEL_DRIVER_URL=https://registrationcenter-download.intel.com/akdlm/irc_nas/vcp/15532
-RUN mkdir -p /tmp/opencl-driver-intel
-WORKDIR /tmp/opencl-driver-intel
-RUN echo INTEL_DRIVER is $INTEL_DRIVER && \
-    curl -O $INTEL_DRIVER_URL/$INTEL_DRIVER && \
-    tar -xzf $INTEL_DRIVER && \
-    for i in $(basename $INTEL_DRIVER .tgz)/rpm/*.rpm; do alien --to-deb $i; done && \
-    dpkg -i *.deb && \
-    rm -rf $INTEL_DRIVER $(basename $INTEL_DRIVER .tgz) *.deb && \
-    mkdir -p /etc/OpenCL/vendors && \
-    echo /opt/intel/opencl_compilers_and_libraries_18.1.0.015/linux/compiler/lib/intel64_lin/libintelocl.so > /etc/OpenCL/vendors/intel.icd && \
-    rm -rf /tmp/opencl-driver-intel
-ENV NVIDIA_VISIBLE_DEVICES all
-ENV NVIDIA_DRIVER_CAPABILITIES graphics,utility,compute
-ENV QTWEBENGINE_DISABLE_SANDBOX 1
-
-RUN dbus-uuidgen > /etc/machine-id
-
@@ -1,276 +0,0 @@
-def phone(String ip, String step_label, String cmd) {
-  withCredentials([file(credentialsId: 'id_rsa', variable: 'key_file')]) {
-    def ssh_cmd = """
-ssh -tt -o StrictHostKeyChecking=no -i ${key_file} 'comma@${ip}' /usr/bin/bash <<'END'
-
-set -e
-
-export CI=1
-export PYTHONWARNINGS=error
-export LOGPRINT=debug
-export TEST_DIR=${env.TEST_DIR}
-export SOURCE_DIR=${env.SOURCE_DIR}
-export GIT_BRANCH=${env.GIT_BRANCH}
-export GIT_COMMIT=${env.GIT_COMMIT}
-export AZURE_TOKEN='${env.AZURE_TOKEN}'
-export MAPBOX_TOKEN='${env.MAPBOX_TOKEN}'
-
-export GIT_SSH_COMMAND="ssh -i /data/gitkey"
-
-source ~/.bash_profile
-if [ -f /TICI ]; then
-  source /etc/profile
-
-  if ! systemctl is-active --quiet systemd-resolved; then
-    echo "restarting resolved"
-    sudo systemctl start systemd-resolved
-    sleep 3
-  fi
-
-  # restart aux USB
-  if [ -e /sys/bus/usb/drivers/hub/3-0:1.0 ]; then
-    echo "restarting aux usb"
-    echo "3-0:1.0" | sudo tee /sys/bus/usb/drivers/hub/unbind
-    sleep 0.5
-    echo "3-0:1.0" | sudo tee /sys/bus/usb/drivers/hub/bind
-  fi
-fi
-if [ -f /data/openpilot/launch_env.sh ]; then
-  source /data/openpilot/launch_env.sh
-fi
-
-ln -snf ${env.TEST_DIR} /data/pythonpath
-
-cd ${env.TEST_DIR} || true
-${cmd}
-exit 0
-
-END"""
-
-    sh script: ssh_cmd, label: step_label
-  }
-}
-
-def phone_steps(String device_type, steps) {
-  lock(resource: "", label: device_type, inversePrecedence: true, variable: 'device_ip', quantity: 1) {
-    timeout(time: 20, unit: 'MINUTES') {
-      phone(device_ip, "git checkout", readFile("selfdrive/test/setup_device_ci.sh"),)
-      steps.each { item ->
-        phone(device_ip, item[0], item[1])
-      }
-    }
-  }
-}
-
-pipeline {
-  agent none
-  environment {
-    CI = "1"
-    PYTHONWARNINGS = "error"
-    TEST_DIR = "/data/openpilot"
-    SOURCE_DIR = "/data/openpilot_source/"
-    AZURE_TOKEN = credentials('azure_token')
-    MAPBOX_TOKEN = credentials('mapbox_token')
-  }
-  options {
-    timeout(time: 3, unit: 'HOURS')
-    disableConcurrentBuilds(abortPrevious: env.BRANCH_NAME != 'master')
-  }
-
-  stages {
-    stage('build release3-staging') {
-      agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-      when {
-        branch 'devel-staging'
-      }
-      steps {
-        phone_steps("tici-needs-can", [
-          ["build release3-staging & dashcam3-staging", "RELEASE_BRANCH=release3-staging DASHCAM_BRANCH=dashcam3-staging $SOURCE_DIR/release/build_release.sh"],
-        ])
-      }
-    }
-
-    stage('build nightly') {
-      agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-      when {
-        branch 'master-ci'
-      }
-      steps {
-        phone_steps("tici-needs-can", [
-          ["build nightly", "RELEASE_BRANCH=nightly $SOURCE_DIR/release/build_release.sh"],
-        ])
-      }
-    }
-
-    stage('openpilot tests') {
-      when {
-        not {
-          anyOf {
-            branch 'master-ci'; branch 'devel'; branch 'devel-staging';
-            branch 'release3'; branch 'release3-staging'; branch 'dashcam3'; branch 'dashcam3-staging';
-            branch 'testing-closet*'; branch 'hotfix-*'
-          }
-        }
-      }
-
-      parallel {
-
-        /*
-        stage('simulator') {
-          agent {
-            dockerfile {
-              filename 'Dockerfile.sim_nvidia'
-              dir 'tools/sim'
-              args '--user=root'
-            }
-          }
-          steps {
-            sh "git config --global --add safe.directory '*'"
-            sh "git submodule update --init --recursive"
-            sh "git lfs pull"
-            lock(resource: "", label: "simulator", inversePrecedence: true, quantity: 1) {
-              sh "${WORKSPACE}/tools/sim/build_container.sh"
-              sh "DETACH=1 ${WORKSPACE}/tools/sim/start_carla.sh"
-              sh "${WORKSPACE}/tools/sim/start_openpilot_docker.sh"
-            }
-          }
-
-          post {
-            always {
-              sh "docker kill carla_sim || true"
-              sh "rm -rf ${WORKSPACE}/* || true"
-              sh "rm -rf .* || true"
-            }
-          }
-        }
-        */
-
-        stage('PC tests') {
-          agent {
-            dockerfile {
-              filename 'Dockerfile.openpilot_base'
-              args '--user=root -v /tmp/comma_download_cache:/tmp/comma_download_cache'
-            }
-          }
-          steps {
-            sh "git config --global --add safe.directory '*'"
-            sh "git submodule update --init --depth=1 --recursive"
-            sh "git lfs pull"
-            // tests that our build system's dependencies are configured properly, needs a machine with lots of cores
-            sh "scons --clean && scons --no-cache --random -j42"
-            sh "INTERNAL_SEG_CNT=500 INTERNAL_SEG_LIST=selfdrive/car/tests/test_models_segs.txt FILEREADER_CACHE=1 \
-                pytest -n42 --dist=loadscope selfdrive/car/tests/test_models.py"
-            sh "MAX_EXAMPLES=100 pytest -n42 selfdrive/car/tests/test_car_interfaces.py"
-          }
-
-          post {
-            always {
-              sh "rm -rf ${WORKSPACE}/* || true"
-              sh "rm -rf .* || true"
-            }
-          }
-        }
-
-        stage('tizi-tests') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tizi", [
-              ["build openpilot", "cd selfdrive/manager && ./build.py"],
-              ["test boardd loopback", "SINGLE_PANDA=1 pytest selfdrive/boardd/tests/test_boardd_loopback.py"],
-              ["test pandad", "pytest selfdrive/boardd/tests/test_pandad.py"],
-              ["test sensord", "cd system/sensord/tests && pytest test_sensord.py"],
-              ["test camerad", "pytest system/camerad/test/test_camerad.py"],
-              ["test exposure", "pytest system/camerad/test/test_exposure.py"],
-              ["test amp", "pytest system/hardware/tici/tests/test_amplifier.py"],
-              ["test hw", "pytest system/hardware/tici/tests/test_hardware.py"],
-              ["test rawgpsd", "pytest system/sensord/rawgps/test_rawgps.py"],
-            ])
-          }
-        }
-
-        stage('build') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          environment {
-            R3_PUSH = "${env.BRANCH_NAME == 'master' ? '1' : ' '}"
-          }
-          steps {
-            phone_steps("tici-needs-can", [
-              ["build master-ci", "cd $SOURCE_DIR/release && TARGET_DIR=$TEST_DIR ./build_devel.sh"],
-              ["build openpilot", "cd selfdrive/manager && ./build.py"],
-              ["check dirty", "release/check-dirty.sh"],
-              ["onroad tests", "cd selfdrive/test/ && ./test_onroad.py"],
-              ["time to onroad", "cd selfdrive/test/ && pytest test_time_to_onroad.py"],
-            ])
-          }
-        }
-
-        stage('loopback-tests') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici-loopback", [
-              ["build openpilot", "cd selfdrive/manager && ./build.py"],
-              ["test boardd loopback", "pytest selfdrive/boardd/tests/test_boardd_loopback.py"],
-            ])
-          }
-        }
-
-        stage('HW + Unit Tests') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici-common", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["test pandad", "pytest selfdrive/boardd/tests/test_pandad.py"],
-              ["test power draw", "pytest system/hardware/tici/tests/test_power_draw.py"],
-              ["test encoder", "LD_LIBRARY_PATH=/usr/local/lib pytest system/loggerd/tests/test_encoder.py"],
-              ["test pigeond", "pytest system/sensord/tests/test_pigeond.py"],
-              ["test manager", "pytest selfdrive/manager/test/test_manager.py"],
-              ["test nav", "pytest selfdrive/navd/tests/"],
-            ])
-          }
-        }
-
-        stage('camerad') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici-ar0231", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["test camerad", "pytest system/camerad/test/test_camerad.py"],
-              ["test exposure", "pytest system/camerad/test/test_exposure.py"],
-            ])
-            phone_steps("tici-ox03c10", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["test camerad", "pytest system/camerad/test/test_camerad.py"],
-              ["test exposure", "pytest system/camerad/test/test_exposure.py"],
-            ])
-          }
-        }
-
-        stage('sensord') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici-lsmc", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["test sensord", "cd system/sensord/tests && pytest test_sensord.py"],
-            ])
-            phone_steps("tici-bmx-lsm", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["test sensord", "cd system/sensord/tests && pytest test_sensord.py"],
-            ])
-          }
-        }
-
-        stage('replay') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici-replay", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["model replay", "cd selfdrive/test/process_replay && ./model_replay.py"],
-            ])
-          }
-        }
-
-      }
-    }
-
-  }
-}
@@ -0,0 +1,21 @@
+# Custom MIT License
+
+Copyright (c) 2024, Haibin Wen, SUNNYPILOT LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to view and modify the Software, subject to the following conditions:
+
+1. **Permission Required**: Permission Required for Commercial, For-Profit, or Closed Source Use: Use of the Software, in whole or in part, for any commercial purposes, for-profit projects, or in closed source projects requires explicit written permission from the original author(s).
+
+2. **Redistribution**: Any redistribution of the Software, modified or unmodified, must retain this license notice and the following acknowledgment:
+   "This software is licensed under a custom license requiring permission for use."
+
+3. **Visibility**: Any project that uses the Software must visibly mention the following acknowledgment:
+   "This project uses software from Haibin Wen and SUNNYPILOT LLC and is licensed under a custom license requiring permission for use."
+
+4. **No Warranty**: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Contact sunnypilot Support <support@sunnypilot.ai> for permission requests.
+
+---
+
+Haibin Wen, SUNNYPILOT LLC
@@ -1,146 +1,74 @@
-![openpilot on the comma 3X](https://github.com/commaai/openpilot/assets/4038174/f1081737-8718-4241-a22a-3ceba526361a)
+![](https://user-images.githubusercontent.com/47793918/233812617-beab2e71-57b9-479e-8bff-c3931347ca40.png)

-Table of Contents
-=======================
+## 🌞 What is sunnypilot?
+[sunnypilot](https://github.com/sunnyhaibin/sunnypilot) is a fork of comma.ai's openpilot, an open source driver assistance system. sunnypilot offers the user a unique driving experience for over 300+ supported car makes and models with modified behaviors of driving assist engagements. sunnypilot complies with comma.ai's safety rules as accurately as possible.

-* [What is openpilot?](#what-is-openpilot)
-* [Running in a car](#running-on-a-dedicated-device-in-a-car)
-* [Running on PC](#running-on-pc)
-* [Community and Contributing](#community-and-contributing)
-* [User Data and comma Account](#user-data-and-comma-account)
-* [Safety and Testing](#safety-and-testing)
-* [Directory Structure](#directory-structure)
-* [Licensing](#licensing)
+## 💭 Join our Community Forum
+Join the official sunnypilot community forum to stay up to date with all the latest features and be a part of shaping the future of sunnypilot!
+* https://community.sunnypilot.ai/

---
+## Documentation
+https://docs.sunnypilot.ai/ is your one stop shop for everything from features to installation to FAQ about the sunnypilot

-What is openpilot?
------
+## 🚘 Running on a dedicated device in a car
+First, check out this list of items you'll need to [get started](https://community.sunnypilot.ai/t/getting-started-using-sunnypilot-in-your-supported-car/251).

-[openpilot](http://github.com/commaai/openpilot) is an open source driver assistance system. Currently, openpilot performs the functions of Adaptive Cruise Control (ACC), Automated Lane Centering (ALC), Forward Collision Warning (FCW), and Lane Departure Warning (LDW) for a growing variety of [supported car makes, models, and model years](docs/CARS.md). In addition, while openpilot is engaged, a camera-based Driver Monitoring (DM) feature alerts distracted and asleep drivers. See more about [the vehicle integration](docs/INTEGRATION.md) and [limitations](docs/LIMITATIONS.md).
+## Installation
+Next, refer to the sunnypilot community forum for [installation instructions](https://community.sunnypilot.ai/t/read-before-installing-sunnypilot/254), as well as a complete list of [Recommended Branch Installations](https://community.sunnypilot.ai/t/recommended-branch-installations/235).

-<table>
-  <tr>
-    <td><a href="https://youtu.be/NmBfgOanCyk" title="Video By Greer Viau"><img src="https://i.imgur.com/1w8c6d2.jpg"></a></td>
-    <td><a href="https://youtu.be/VHKyqZ7t8Gw" title="Video By Logan LeGrand"><img src="https://i.imgur.com/LnBucik.jpg"></a></td>
-    <td><a href="https://youtu.be/VxiR4iyBruo" title="Video By Charlie Kim"><img src="https://i.imgur.com/4Qoy48c.jpg"></a></td>
-    <td><a href="https://youtu.be/-IkImTe1NYE" title="Video By Aragon"><img src="https://i.imgur.com/04VNzPf.jpg"></a></td>
-  </tr>
-  <tr>
-    <td><a href="https://youtu.be/iIUICQkdwFQ" title="Video By Logan LeGrand"><img src="https://i.imgur.com/b1LHQTy.jpg"></a></td>
-    <td><a href="https://youtu.be/XOsa0FsVIsg" title="Video By PinoyDrives"><img src="https://i.imgur.com/6FG0Bd8.jpg"></a></td>
-    <td><a href="https://youtu.be/bCwcJ98R_Xw" title="Video By JS"><img src="https://i.imgur.com/zO18CbW.jpg"></a></td>
-    <td><a href="https://youtu.be/BQ0tF3MTyyc" title="Video By Tsai-Fi"><img src="https://i.imgur.com/eZzelq3.jpg"></a></td>
-  </tr>
-</table>
+## 🎆 Pull Requests
+We welcome both pull requests and issues on GitHub. Bug fixes are encouraged.
+
+Pull requests should be against the most current `master` branch.
+
+## 📊 User Data
+
+By default, sunnypilot uploads the driving data to comma servers. You can also access your data through [comma connect](https://connect.comma.ai/).
+
+sunnypilot is open source software. The user is free to disable data collection if they wish to do so.
+
+sunnypilot logs the road-facing camera, CAN, GPS, IMU, magnetometer, thermal sensors, crashes, and operating system logs.
+The driver-facing camera and microphone are only logged if you explicitly opt-in in settings.
+
+By using this software, you understand that use of this software or its related services will generate certain types of user data, which may be logged and stored at the sole discretion of comma. By accepting this agreement, you grant an irrevocable, perpetual, worldwide right to comma for the use of this data.
+
+## Licensing
+
+sunnypilot is released under the [MIT License](LICENSE). This repository includes original work as well as significant portions of code derived from [openpilot by comma.ai](https://github.com/commaai/openpilot), which is also released under the MIT license with additional disclaimers.
+
+The original openpilot license notice, including comma.ai’s indemnification and alpha software disclaimer, is reproduced below as required:
+
+> openpilot is released under the MIT license. Some parts of the software are released under other licenses as specified.
+>
+> Any user of this software shall indemnify and hold harmless Comma.ai, Inc. and its directors, officers, employees, agents, stockholders, affiliates, subcontractors and customers from and against all allegations, claims, actions, suits, demands, damages, liabilities, obligations, losses, settlements, judgments, costs and expenses (including without limitation attorneys’ fees and costs) which arise out of, relate to or result from any use of this software by user.
+>
+> **THIS IS ALPHA QUALITY SOFTWARE FOR RESEARCH PURPOSES ONLY. THIS IS NOT A PRODUCT.
+> YOU ARE RESPONSIBLE FOR COMPLYING WITH LOCAL LAWS AND REGULATIONS.
+> NO WARRANTY EXPRESSED OR IMPLIED.**
+
+For full license terms, please see the [`LICENSE`](LICENSE) file.
+
+## 💰 Support sunnypilot
+If you find any of the features useful, consider becoming a [sponsor on GitHub](https://github.com/sponsors/sunnyhaibin) to support future feature development and improvements.


-Running on a dedicated device in a car
------
+By becoming a sponsor, you will gain access to exclusive content, early access to new features, and the opportunity to directly influence the project's development.

-To use openpilot in a car, you need four things
-* A supported device to run this software: a [comma 3X](https://comma.ai/shop/comma-3x) or comma three.
-* This software. The setup procedure of the comma 3/3X allows the user to enter a URL for custom software.
-The URL, openpilot.comma.ai will install the release version of openpilot. To install openpilot master, you can use installer.comma.ai/commaai/master, and replacing commaai with another GitHub username can install a fork.
-* One of [the 250+ supported cars](docs/CARS.md). We support Honda, Toyota, Hyundai, Nissan, Kia, Chrysler, Lexus, Acura, Audi, VW, Ford and more. If your car is not supported but has adaptive cruise control and lane-keeping assist, it's likely able to run openpilot.
-* A [car harness](https://comma.ai/shop/products/car-harness) to connect to your car.

-We have detailed instructions for [how to mount the device in a car](https://comma.ai/setup).
+<h3>GitHub Sponsor</h3>

-Running on PC
------
+<a href="https://github.com/sponsors/sunnyhaibin">
+  <img src="https://user-images.githubusercontent.com/47793918/244135584-9800acbd-69fd-4b2b-bec9-e5fa2d85c817.png" alt="Become a Sponsor" width="300" style="max-width: 100%; height: auto;">
+</a>
+<br>

-All openpilot services can run as usual on a PC without requiring special hardware or a car. You can also run openpilot on recorded or simulated data to develop or experiment with openpilot.
+<h3>PayPal</h3>

-With openpilot's tools, you can plot logs, replay drives, and watch the full-res camera streams. See [the tools README](tools/README.md) for more information.
+<a href="https://paypal.me/sunnyhaibin0850" target="_blank">
+<img src="https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif" alt="PayPal this" title="PayPal - The safer, easier way to pay online!" border="0" />
+</a>
+<br></br>

-You can also run openpilot in simulation [with the CARLA simulator](tools/sim/README.md). This allows openpilot to drive around a virtual car on your Ubuntu machine. The whole setup should only take a few minutes but does require a decent GPU.
+Your continuous love and support are greatly appreciated! Enjoy 🥰

-A PC running openpilot can also control your vehicle if it is connected to a [webcam](https://github.com/commaai/openpilot/tree/master/tools/webcam), a [black panda](https://comma.ai/shop/products/panda), and a [harness](https://comma.ai/shop/products/car-harness).
-
-Community and Contributing
------
-
-openpilot is developed by [comma](https://comma.ai/) and by users like you. We welcome both pull requests and issues on [GitHub](http://github.com/commaai/openpilot). Bug fixes and new car ports are encouraged. Check out [the contributing docs](docs/CONTRIBUTING.md).
-
-Documentation related to openpilot development can be found on [docs.comma.ai](https://docs.comma.ai). Information about running openpilot (e.g. FAQ, fingerprinting, troubleshooting, custom forks, community hardware) should go on the [wiki](https://github.com/commaai/openpilot/wiki).
-
-You can add support for your car by following guides we have written for [Brand](https://blog.comma.ai/how-to-write-a-car-port-for-openpilot/) and [Model](https://blog.comma.ai/openpilot-port-guide-for-toyota-models/) ports. Generally, a car with adaptive cruise control and lane keep assist is a good candidate. [Join our Discord](https://discord.comma.ai) to discuss car ports: most car makes have a dedicated channel.
-
-Want to get paid to work on openpilot? [comma is hiring](https://comma.ai/jobs#open-positions).
-
-And [follow us on Twitter](https://twitter.com/comma_ai).
-
-User Data and comma Account
------
-
-By default, openpilot uploads the driving data to our servers. You can also access your data through [comma connect](https://connect.comma.ai/). We use your data to train better models and improve openpilot for everyone.
-
-openpilot is open source software: the user is free to disable data collection if they wish to do so.
-
-openpilot logs the road-facing cameras, CAN, GPS, IMU, magnetometer, thermal sensors, crashes, and operating system logs.
-The driver-facing camera is only logged if you explicitly opt-in in settings. The microphone is not recorded.
-
-By using openpilot, you agree to [our Privacy Policy](https://comma.ai/privacy). You understand that use of this software or its related services will generate certain types of user data, which may be logged and stored at the sole discretion of comma. By accepting this agreement, you grant an irrevocable, perpetual, worldwide right to comma for the use of this data.
-
-Safety and Testing
----
-
-* openpilot observes ISO26262 guidelines, see [SAFETY.md](docs/SAFETY.md) for more details.
-* openpilot has software-in-the-loop [tests](.github/workflows/selfdrive_tests.yaml) that run on every commit.
-* The code enforcing the safety model lives in panda and is written in C, see [code rigor](https://github.com/commaai/panda#code-rigor) for more details.
-* panda has software-in-the-loop [safety tests](https://github.com/commaai/panda/tree/master/tests/safety).
-* Internally, we have a hardware-in-the-loop Jenkins test suite that builds and unit tests the various processes.
-* panda has additional hardware-in-the-loop [tests](https://github.com/commaai/panda/blob/master/Jenkinsfile).
-* We run the latest openpilot in a testing closet containing 10 comma devices continuously replaying routes.
-
-Directory Structure
------
-    .
-    ├── cereal              # The messaging spec and libs used for all logs
-    ├── common              # Library like functionality we've developed here
-    ├── docs                # Documentation
-    ├── opendbc             # Files showing how to interpret data from cars
-    ├── panda               # Code used to communicate on CAN
-    ├── third_party         # External libraries
-    └── system              # Generic services
-        ├── camerad         # Driver to capture images from the camera sensors
-        ├── clocksd         # Broadcasts current time
-        ├── hardware        # Hardware abstraction classes
-        ├── logcatd         # systemd journal as a service
-        ├── loggerd         # Logger and uploader of car data
-        ├── proclogd        # Logs information from /proc
-        ├── sensord         # IMU interface code
-        └── ubloxd          # u-blox GNSS module interface code
-    └── selfdrive           # Code needed to drive the car
-        ├── assets          # Fonts, images, and sounds for UI
-        ├── athena          # Allows communication with the app
-        ├── boardd          # Daemon to talk to the board
-        ├── car             # Car specific code to read states and control actuators
-        ├── controls        # Planning and controls
-        ├── debug           # Tools to help you debug and do car ports
-        ├── locationd       # Precise localization and vehicle parameter estimation
-        ├── manager         # Daemon that starts/stops all other daemons as needed
-        ├── modeld          # Driving and monitoring model runners
-        ├── monitoring      # Daemon to determine driver attention
-        ├── navd            # Turn-by-turn navigation
-        ├── test            # Unit tests, system tests, and a car simulator
-        └── ui              # The UI
-
-Licensing
------
-
-openpilot is released under the MIT license. Some parts of the software are released under other licenses as specified.
-
-Any user of this software shall indemnify and hold harmless Comma.ai, Inc. and its directors, officers, employees, agents, stockholders, affiliates, subcontractors and customers from and against all allegations, claims, actions, suits, demands, damages, liabilities, obligations, losses, settlements, judgments, costs and expenses (including without limitation attorneys’ fees and costs) which arise out of, relate to or result from any use of this software by user.
-
-**THIS IS ALPHA QUALITY SOFTWARE FOR RESEARCH PURPOSES ONLY. THIS IS NOT A PRODUCT.
-YOU ARE RESPONSIBLE FOR COMPLYING WITH LOCAL LAWS AND REGULATIONS.
-NO WARRANTY EXPRESSED OR IMPLIED.**
-
---
-
-<img src="https://d1qb2nb5cznatu.cloudfront.net/startups/i/1061157-bc7e9bf3b246ece7322e6ffe653f6af8-medium_jpg.jpg?buster=1458363130" width="75"></img> <img src="https://cdn-images-1.medium.com/max/1600/1*C87EjxGeMPrkTuVRVWVg4w.png" width="225"></img>
-
-[![openpilot tests](https://github.com/commaai/openpilot/workflows/openpilot%20tests/badge.svg?event=push)](https://github.com/commaai/openpilot/actions)
-[![codecov](https://codecov.io/gh/commaai/openpilot/branch/master/graph/badge.svg)](https://codecov.io/gh/commaai/openpilot)
+<span>-</span> Jason, Founder of sunnypilot
@@ -1,8 +1,147 @@
-Version 0.9.5 (202X-XX-XX)
+Version 0.11.2 (2026-06-15)
 ========================
-* Hyundai Ioniq 6 2023 support thanks to sunnyhaibin, alamo3, and sshane!
+
+
+Version 0.11.1 (2026-05-18)
+========================
+* New driver monitoring model
+* Improved image processing pipeline for driver camera
+* Improved thermal policy for comma four
+* Acura MDX 2022-24 support thanks to mvl-boston!
+* Rivian R1S and R1T 2025 support thanks to lukasloetkolben!
+
+Version 0.11.0 (2026-03-17)
+========================
+* New driving model #36798
+  * Fully trained using a learned simulator
+  * Improved longitudinal performance in Experimental mode
+* Reduce comma four standby power usage by 77% to 52 mW
+* Kia K7 2017 support thanks to royjr!
+* Lexus LS 2018 support thanks to Hacheoy!
+
+Version 0.10.3 (2025-12-17)
+========================
+* New driving model #36249
+  * New temporal policy architecture
+  * New on-policy training physics noise model
+* New driver monitoring model #36409
+  * Trained on a new dataset, including comma four data
+* Improved inter-process communication memory efficiency
+
+Version 0.10.2 (2025-11-19)
+========================
+* comma four support
+
+Version 0.10.1 (2025-09-08)
+========================
+* New driving model #36276
+  * 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)
+========================
+* New driving model
+  * New training architecture
+     * Described in our CVPR paper: "Learning to Drive from a World Model"
+     * Longitudinal MPC replaced by E2E planning from World Model in Experimental Mode
+     * Action from lateral MPC as training objective replaced by E2E planning from World Model
+  * Low-speed lead car ground-truth fixes
+* Enable live-learned steering actuation delay
+* Opt-in audio recording for dashcam video
+* Acura MDX 2025 support thanks to vanillagorillaa and MVL!
+* Honda Accord 2023-25 support thanks to vanillagorillaa and MVL!
+* Honda CR-V 2023-25 support thanks to vanillagorillaa and MVL!
+* Honda Pilot 2023-25 support thanks to vanillagorillaa and MVL!
+
+Version 0.9.9 (2025-05-23)
+========================
+* New driving model
+  * New training architecture using parts from MLSIM
+* Steering actuation delay is now learned online
+* Ford Escape 2023-24 support thanks to incognitojam!
+* Ford Kuga 2024 support thanks to incognitojam!
+* Hyundai Nexo 2021 support thanks to sunnyhaibin!
+* Tesla Model 3 and Y support thanks to lukasloetkolben!
+* Lexus RC 2023 support thanks to nelsonjchen!
+
+Version 0.9.8 (2025-02-28)
+========================
+* New driving model
+  * Model now gates applying positive acceleration in Chill mode
+* New driver monitoring model
+  * Reduced false positives related to passengers
+* Image processing pipeline moved to the ISP
+  * More GPU time for bigger driving models
+  * Power draw reduced 0.5W, which means your device runs cooler
+* Added toggle to enable driver monitoring even when openpilot is not engaged
+* Localizer rewritten to remove GPS dependency at runtime
+* Firehose Mode for maximizing your training data uploads
+* Enable openpilot longitudinal control for Ford Q3 vehicles
+* New Toyota TSS2 longitudinal tune
+* Rivian R1S and R1T support thanks to lukasloetkolben!
+* Ford F-150, F-150 Hybrid, Mach-E, and Ranger support
+
+Version 0.9.7 (2024-06-13)
+========================
+* New driving model
+  * Inputs the past curvature for smoother and more accurate lateral control
+  * Simplified neural network architecture in the model's last layers
+  * Minor fixes to desire augmentation and weight decay
+* New driver monitoring model
+  * Improved end-to-end bit for phone detection
+* Adjust driving personality with the follow distance button
+* Support for hybrid variants of supported Ford models
+* Fingerprinting without the OBD-II port on all cars
+* Improved fuzzy fingerprinting for Ford and Volkswagen
+
+Version 0.9.6 (2024-02-27)
+========================
+* New driving model
+  * Vision model trained on more data
+  * Improved driving performance
+  * Directly outputs curvature for lateral control
+* New driver monitoring model
+  * Trained on larger dataset
+* Model path UI
+  * Shows where driving model wants to be
+  * Shows what model is seeing more clearly, but more jittery
+* AGNOS 9
+* comma body streaming and controls over WebRTC
+* Improved fuzzy fingerprinting for many makes and models
+* Alpha longitudinal support for new Toyota models
+* Chevrolet Equinox 2019-22 support thanks to JasonJShuler and nworb-cire!
+* Dodge Durango 2020-21 support
+* Hyundai Staria 2023 support thanks to sunnyhaibin!
+* Kia Niro Plug-in Hybrid 2022 support thanks to sunnyhaibin!
+* Lexus LC 2024 support thanks to nelsonjchen!
+* Toyota RAV4 2023-24 support
+* Toyota RAV4 Hybrid 2023-24 support
+
+Version 0.9.5 (2023-11-17)
+========================
+* New driving model
+  * Improved navigate on openpilot performance using navigation instructions as an additional model input
+  * Do lateral planning inside the model
+  * New vision transformer architecture
+* Cadillac Escalade ESV 2019 support thanks to twilsonco!
+* Hyundai Azera 2022 support thanks to sunnyhaibin!
+* Hyundai Azera Hybrid 2020 support thanks to chanhojung and haram-KONA!
+* Hyundai Custin 2023 support thanks to sunnyhaibin and Saber422!
+* Hyundai Ioniq 6 2023 support thanks to sunnyhaibin and alamo3!
 * Hyundai Kona Electric 2023 (Korean version) support thanks to sunnyhaibin and haram-KONA!
+* Kia K8 Hybrid (with HDA II) 2023 support thanks to sunnyhaibin!
+* Kia Optima Hybrid 2019 support
 * Kia Sorento Hybrid 2023 support thanks to sunnyhaibin!
+* Lexus GS F 2016 support thanks to snyperifle!
 * Lexus IS 2023 support thanks to L3R5!

 Version 0.9.4 (2023-07-27)
@@ -592,7 +731,7 @@ Version 0.5.13 (2019-05-31)
 * Reduce CPU utilization by 20% and improve stability
 * Temporarily remove mapd functionalities to improve stability
 * Add openpilot record-only mode for unsupported cars
- * Synchronize controlsd to boardd to reduce latency
+ * Synchronize controlsd to pandad to reduce latency
 * Remove panda support for Subaru giraffe

 Version 0.5.12 (2019-05-16)
@@ -928,7 +1067,7 @@ Version 0.2.8  (2017-02-27)
 Version 0.2.7  (2017-02-08)
 ===========================
 * Better performance and pictures at night
- * Fix ptr alignment issue in boardd
+ * Fix ptr alignment issue in pandad
 * Fix brake error light, fix crash if too cold

 Version 0.2.6  (2017-01-31)
@@ -960,12 +1099,12 @@ Version 0.2.2  (2017-01-10)
 Version 0.2.1  (2016-12-14)
 ===========================
 * Performance improvements, removal of more numpy
- * Fix boardd process priority
+ * Fix pandad process priority
 * Make counter timer reset on use of steering wheel

 Version 0.2  (2016-12-12)
 =========================
- * Car/Radar abstraction layers have shipped, see cereal/car.capnp
+ * Car/Radar abstraction layers have shipped, see openpilot/cereal/car.capnp
 * controlsd has been refactored
 * Shipped plant model and testing maneuvers
 * visiond exits more gracefully now
@@ -1,434 +0,0 @@
-import os
-import subprocess
-import sys
-import sysconfig
-import platform
-import numpy as np
-
-import SCons.Errors
-
-SCons.Warnings.warningAsException(True)
-
-TICI = os.path.isfile('/TICI')
-AGNOS = TICI
-
-Decider('MD5-timestamp')
-
-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('--clazy',
-          action='store_true',
-          help='build with clazy')
-
-AddOption('--compile_db',
-          action='store_true',
-          help='build clang compilation database')
-
-AddOption('--snpe',
-          action='store_true',
-          help='use SNPE on PC')
-
-AddOption('--external-sconscript',
-          action='store',
-          metavar='FILE',
-          dest='external_sconscript',
-          help='add an external SConscript to the build')
-
-AddOption('--pc-thneed',
-          action='store_true',
-          dest='pc_thneed',
-          help='use thneed on pc')
-
-AddOption('--minimal',
-          action='store_false',
-          dest='extras',
-          default=os.path.islink(Dir('#laika/').abspath),
-          help='the minimum build to run openpilot. no tests, tools, etc.')
-
-## 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 AGNOS:
-  arch = "larch64"
-assert arch in ["larch64", "aarch64", "x86_64", "Darwin"]
-
-lenv = {
-  "PATH": os.environ['PATH'],
-  "LD_LIBRARY_PATH": [Dir(f"#third_party/acados/{arch}/lib").abspath],
-  "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 = lenv["LD_LIBRARY_PATH"].copy()
-
-if arch == "larch64":
-  lenv["LD_LIBRARY_PATH"] += ['/data/data/com.termux/files/usr/lib']
-
-  cpppath = [
-    "#third_party/opencl/include",
-  ]
-
-  libpath = [
-    "/usr/local/lib",
-    "/usr/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 += [
-    Dir("#cereal").abspath,
-    Dir("#common").abspath
-  ]
-
-  # 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",
-    ]
-    lenv["DYLD_LIBRARY_PATH"] = lenv["LD_LIBRARY_PATH"]
-  # Linux
-  else:
-    libpath = [
-      f"#third_party/acados/{arch}/lib",
-      f"#third_party/libyuv/{arch}/lib",
-      f"#third_party/mapbox-gl-native-qt/{arch}",
-      "#cereal",
-      "#common",
-      "/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"]
-
-# Enable swaglog include in submodules
-cflags += ['-DSWAGLOG="\\"common/swaglog.h\\""']
-cxxflags += ['-DSWAGLOG="\\"common/swaglog.h\\""']
-
-env = Environment(
-  ENV=lenv,
-  CCFLAGS=[
-    "-g",
-    "-fPIC",
-    "-O2",
-    "-Wunused",
-    "-Werror",
-    "-Wshadow",
-    "-Wno-unknown-warning-option",
-    "-Wno-deprecated-register",
-    "-Wno-register",
-    "-Wno-inconsistent-missing-override",
-    "-Wno-c99-designator",
-    "-Wno-reorder-init-list",
-    "-Wno-error=unused-but-set-variable",
-  ] + cflags + ccflags,
-
-  CPPPATH=cpppath + [
-    "#",
-    "#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/mapbox-gl-native-qt/include",
-    "#third_party/qrcode",
-    "#third_party",
-    "#cereal",
-    "#opendbc/can",
-  ],
-
-  CC='clang',
-  CXX='clang++',
-  LINKFLAGS=ldflags,
-
-  RPATH=rpath,
-
-  CFLAGS=["-std=gnu11"] + cflags,
-  CXXFLAGS=["-std=c++1z"] + cxxflags,
-  LIBPATH=libpath + [
-    "#cereal",
-    "#third_party",
-    "#opendbc/can",
-    "#selfdrive/boardd",
-    "#common",
-  ],
-  CYTHONCFILESUFFIX=".cpp",
-  COMPILATIONDB_USE_ABSPATH=True,
-  tools=["default", "cython", "compilation_db"],
-)
-
-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 GetOption('compile_db'):
-  env.CompilationDatabase('compile_commands.json')
-
-# Setup cache dir
-cache_dir = '/data/scons_cache' if AGNOS else '/tmp/scons_cache'
-CacheDir(cache_dir)
-Clean(["."], cache_dir)
-
-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)
-
-SHARED = False
-
-# TODO: this can probably be removed
-def abspath(x):
-  if arch == 'aarch64':
-    pth = os.path.join("/data/pythonpath", x[0].path)
-    env.Depends(pth, x)
-    return File(pth)
-  else:
-    # rpath works elsewhere
-    return x[0].path.rsplit("/", 1)[1][:-3]
-
-# Cython build environment
-py_include = sysconfig.get_paths()['include']
-envCython = env.Clone()
-envCython["CPPPATH"] += [py_include, np.get_include()]
-envCython["CCFLAGS"] += ["-Wno-#warnings", "-Wno-shadow", "-Wno-deprecated-declarations"]
-envCython["CCFLAGS"].remove("-Werror")
-
-envCython["LIBS"] = []
-if arch == "Darwin":
-  envCython["LINKFLAGS"] = ["-bundle", "-undefined", "dynamic_lookup"] + darwin_rpath_link_flags
-else:
-  envCython["LINKFLAGS"] = ["-pthread", "-shared"]
-
-Export('envCython')
-
-# Qt build environment
-qt_env = env.Clone()
-qt_modules = ["Widgets", "Gui", "Core", "Network", "Concurrent", "Multimedia", "Quick", "Qml", "QuickWidgets", "Location", "Positioning", "DBus", "Xml"]
-
-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()
-
-  qt_env['QTDIR'] = qt_install_prefix
-  qt_dirs = [
-    f"{qt_install_headers}",
-    f"{qt_install_headers}/QtGui/5.12.8/QtGui",
-  ]
-  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']
-
-# compatibility for older SCons versions
-try:
-  qt_env.Tool('qt3')
-except SCons.Errors.UserError:
-  qt_env.Tool('qt')
-
-qt_env['CPPPATH'] += qt_dirs + ["#selfdrive/ui/qt/"]
-qt_flags = [
-  "-D_REENTRANT",
-  "-DQT_NO_DEBUG",
-  "-DQT_WIDGETS_LIB",
-  "-DQT_GUI_LIB",
-  "-DQT_QUICK_LIB",
-  "-DQT_QUICKWIDGETS_LIB",
-  "-DQT_QML_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', 'SHARED')
-
-SConscript(['common/SConscript'])
-Import('_common', '_gpucommon')
-
-if SHARED:
-  common, gpucommon = abspath(common), abspath(gpucommon)
-else:
-  common = [_common, 'json11']
-  gpucommon = [_gpucommon]
-
-Export('common', 'gpucommon')
-
-# cereal and messaging are shared with the system
-SConscript(['cereal/SConscript'])
-if SHARED:
-  cereal = abspath([File('cereal/libcereal_shared.so')])
-  messaging = abspath([File('cereal/libmessaging_shared.so')])
-else:
-  cereal = [File('#cereal/libcereal.a')]
-  messaging = [File('#cereal/libmessaging.a')]
-  visionipc = [File('#cereal/libvisionipc.a')]
-messaging_python = [File('#cereal/messaging/messaging_pyx.so')]
-
-Export('cereal', 'messaging', 'messaging_python', 'visionipc')
-
-# Build rednose library and ekf models
-
-rednose_deps = [
-  "#selfdrive/locationd/models/constants.py",
-  "#selfdrive/locationd/models/gnss_helpers.py",
-]
-
-rednose_config = {
-  'generated_folder': '#selfdrive/locationd/models/generated',
-  'to_build': {
-    'gnss': ('#selfdrive/locationd/models/gnss_kf.py', True, [], rednose_deps),
-    'live': ('#selfdrive/locationd/models/live_kf.py', True, ['live_kf_constants.h'], rednose_deps),
-    'car': ('#selfdrive/locationd/models/car_kf.py', True, [], rednose_deps),
-  },
-}
-
-if arch != "larch64":
-  rednose_config['to_build'].update({
-    'loc_4': ('#selfdrive/locationd/models/loc_kf.py', True, [], rednose_deps),
-    'lane': ('#selfdrive/locationd/models/lane_kf.py', True, [], rednose_deps),
-    'pos_computer_4': ('#rednose/helpers/lst_sq_computer.py', False, [], []),
-    'pos_computer_5': ('#rednose/helpers/lst_sq_computer.py', False, [], []),
-    'feature_handler_5': ('#rednose/helpers/feature_handler.py', False, [], []),
-  })
-
-Export('rednose_config')
-SConscript(['rednose/SConscript'])
-
-# Build system services
-SConscript([
-  'system/clocksd/SConscript',
-  'system/proclogd/SConscript',
-  'system/ubloxd/SConscript',
-  'system/loggerd/SConscript',
-])
-if arch != "Darwin":
-  SConscript([
-    'system/camerad/SConscript',
-    'system/sensord/SConscript',
-    'system/logcatd/SConscript',
-  ])
-
-# Build openpilot
-
-# build submodules
-SConscript([
-  'body/board/SConscript',
-  'cereal/SConscript',
-  'opendbc/can/SConscript',
-  'panda/SConscript',
-])
-
-SConscript(['third_party/SConscript'])
-
-SConscript(['selfdrive/boardd/SConscript'])
-SConscript(['selfdrive/controls/lib/lateral_mpc_lib/SConscript'])
-SConscript(['selfdrive/controls/lib/longitudinal_mpc_lib/SConscript'])
-SConscript(['selfdrive/locationd/SConscript'])
-SConscript(['selfdrive/navd/SConscript'])
-SConscript(['selfdrive/modeld/SConscript'])
-SConscript(['selfdrive/ui/SConscript'])
-
-if arch in ['x86_64', 'aarch64', 'Darwin'] and Dir('#tools/cabana/').exists() and GetOption('extras'):
-  SConscript(['tools/replay/SConscript'])
-  SConscript(['tools/cabana/SConscript'])
-
-external_sconscript = GetOption('external_sconscript')
-if external_sconscript:
-  SConscript([external_sconscript])
@@ -1,8 +0,0 @@
-comment: false
-coverage:
-  status:
-    project:
-      default:
-        informational: true
-    patch: off
-
@@ -1 +0,0 @@
-*.cpp
@@ -1,46 +0,0 @@
-Import('env', 'envCython', 'arch', 'SHARED')
-
-if SHARED:
-  fxn = env.SharedLibrary
-else:
-  fxn = env.Library
-
-common_libs = [
-  'params.cc',
-  'statlog.cc',
-  'swaglog.cc',
-  'util.cc',
-  'i2c.cc',
-  'watchdog.cc',
-  'ratekeeper.cc'
-]
-
-if arch != "Darwin":
-  common_libs.append('gpio.cc')
-
-_common = fxn('common', common_libs, LIBS="json11")
-
-files = [
-  'clutil.cc',
-]
-
-_gpucommon = fxn('gpucommon', files)
-Export('_common', '_gpucommon')
-
-if GetOption('extras'):
-  env.Program('tests/test_common',
-              ['tests/test_runner.cc', 'tests/test_util.cc', 'tests/test_swaglog.cc', 'tests/test_ratekeeper.cc'],
-              LIBS=[_common, 'json11', 'zmq', 'pthread'])
-
-# Cython bindings
-params_python = envCython.Program('params_pyx.so', 'params_pyx.pyx', LIBS=envCython['LIBS'] + [_common, 'zmq', 'json11'])
-
-SConscript([
-  'kalman/SConscript',
-  'transformations/SConscript'  
-])
-
-Import('simple_kalman_python', 'transformations_python')
-common_python = [params_python, simple_kalman_python, transformations_python]
-
-Export('common_python')
@@ -1,46 +0,0 @@
-import jwt
-import os
-import requests
-from datetime import datetime, timedelta
-from openpilot.common.basedir import PERSIST
-from openpilot.system.version import get_version
-
-API_HOST = os.getenv('API_HOST', 'https://api.commadotai.com')
-
-class Api():
-  def __init__(self, dongle_id):
-    self.dongle_id = dongle_id
-    with open(PERSIST+'/comma/id_rsa') as f:
-      self.private_key = f.read()
-
-  def get(self, *args, **kwargs):
-    return self.request('GET', *args, **kwargs)
-
-  def post(self, *args, **kwargs):
-    return self.request('POST', *args, **kwargs)
-
-  def request(self, method, endpoint, timeout=None, access_token=None, **params):
-    return api_get(endpoint, method=method, timeout=timeout, access_token=access_token, **params)
-
-  def get_token(self, expiry_hours=1):
-    now = datetime.utcnow()
-    payload = {
-      'identity': self.dongle_id,
-      'nbf': now,
-      'iat': now,
-      'exp': now + timedelta(hours=expiry_hours)
-    }
-    token = jwt.encode(payload, self.private_key, algorithm='RS256')
-    if isinstance(token, bytes):
-      token = token.decode('utf8')
-    return token
-
-
-def api_get(endpoint, method='GET', timeout=None, access_token=None, **params):
-  headers = {}
-  if access_token is not None:
-    headers['Authorization'] = "JWT " + access_token
-
-  headers['User-Agent'] = "openpilot-" + get_version()
-
-  return requests.request(method, API_HOST + "/" + endpoint, timeout=timeout, headers=headers, params=params)
@@ -1,11 +0,0 @@
-import os
-from pathlib import Path
-
-from openpilot.system.hardware import PC
-
-BASEDIR = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../"))
-
-if PC:
-  PERSIST = os.path.join(str(Path.home()), ".comma", "persist")
-else:
-  PERSIST = "/persist"
@@ -1,200 +0,0 @@
-#include "common/clutil.h"
-
-#include <cassert>
-#include <iostream>
-#include <memory>
-
-#include "common/util.h"
-#include "common/swaglog.h"
-
-namespace {  // helper functions
-
-template <typename Func, typename Id, typename Name>
-std::string get_info(Func get_info_func, Id id, Name param_name) {
-  size_t size = 0;
-  CL_CHECK(get_info_func(id, param_name, 0, NULL, &size));
-  std::string info(size, '\0');
-  CL_CHECK(get_info_func(id, param_name, size, info.data(), NULL));
-  return info;
-}
-inline std::string get_platform_info(cl_platform_id id, cl_platform_info name) { return get_info(&clGetPlatformInfo, id, name); }
-inline std::string get_device_info(cl_device_id id, cl_device_info name) { return get_info(&clGetDeviceInfo, id, name); }
-
-void cl_print_info(cl_platform_id platform, cl_device_id device) {
-  size_t work_group_size = 0;
-  cl_device_type device_type = 0;
-  clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(work_group_size), &work_group_size, NULL);
-  clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(device_type), &device_type, NULL);
-  const char *type_str = "Other...";
-  switch (device_type) {
-    case CL_DEVICE_TYPE_CPU: type_str ="CL_DEVICE_TYPE_CPU"; break;
-    case CL_DEVICE_TYPE_GPU: type_str = "CL_DEVICE_TYPE_GPU"; break;
-    case CL_DEVICE_TYPE_ACCELERATOR: type_str = "CL_DEVICE_TYPE_ACCELERATOR"; break;
-  }
-
-  LOGD("vendor: %s", get_platform_info(platform, CL_PLATFORM_VENDOR).c_str());
-  LOGD("platform version: %s", get_platform_info(platform, CL_PLATFORM_VERSION).c_str());
-  LOGD("profile: %s", get_platform_info(platform, CL_PLATFORM_PROFILE).c_str());
-  LOGD("extensions: %s", get_platform_info(platform, CL_PLATFORM_EXTENSIONS).c_str());
-  LOGD("name: %s", get_device_info(device, CL_DEVICE_NAME).c_str());
-  LOGD("device version: %s", get_device_info(device, CL_DEVICE_VERSION).c_str());
-  LOGD("max work group size: %zu", work_group_size);
-  LOGD("type = %d, %s", (int)device_type, type_str);
-}
-
-void cl_print_build_errors(cl_program program, cl_device_id device) {
-  cl_build_status status;
-  clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, NULL);
-  size_t log_size;
-  clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
-  std::string log(log_size, '\0');
-  clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, log_size, &log[0], NULL);
-
-  LOGE("build failed; status=%d, log: %s", status, log.c_str());
-}
-
-}  // namespace
-
-cl_device_id cl_get_device_id(cl_device_type device_type) {
-  cl_uint num_platforms = 0;
-  CL_CHECK(clGetPlatformIDs(0, NULL, &num_platforms));
-  std::unique_ptr<cl_platform_id[]> platform_ids = std::make_unique<cl_platform_id[]>(num_platforms);
-  CL_CHECK(clGetPlatformIDs(num_platforms, &platform_ids[0], NULL));
-
-  for (size_t i = 0; i < num_platforms; ++i) {
-    LOGD("platform[%zu] CL_PLATFORM_NAME: %s", i, get_platform_info(platform_ids[i], CL_PLATFORM_NAME).c_str());
-
-    // Get first device
-    if (cl_device_id device_id = NULL; clGetDeviceIDs(platform_ids[i], device_type, 1, &device_id, NULL) == 0 && device_id) {
-      cl_print_info(platform_ids[i], device_id);
-      return device_id;
-    }
-  }
-  LOGE("No valid openCL platform found");
-  assert(0);
-  return nullptr;
-}
-
-cl_context cl_create_context(cl_device_id device_id) {
-  return CL_CHECK_ERR(clCreateContext(NULL, 1, &device_id, NULL, NULL, &err));
-}
-
-cl_program cl_program_from_file(cl_context ctx, cl_device_id device_id, const char* path, const char* args) {
-  return cl_program_from_source(ctx, device_id, util::read_file(path), args);
-}
-
-cl_program cl_program_from_source(cl_context ctx, cl_device_id device_id, const std::string& src, const char* args) {
-  const char *csrc = src.c_str();
-  cl_program prg = CL_CHECK_ERR(clCreateProgramWithSource(ctx, 1, &csrc, NULL, &err));
-  if (int err = clBuildProgram(prg, 1, &device_id, args, NULL, NULL); err != 0) {
-    cl_print_build_errors(prg, device_id);
-    assert(0);
-  }
-  return prg;
-}
-
-cl_program cl_program_from_binary(cl_context ctx, cl_device_id device_id, const uint8_t* binary, size_t length, const char* args) {
-  cl_program prg = CL_CHECK_ERR(clCreateProgramWithBinary(ctx, 1, &device_id, &length, &binary, NULL, &err));
-  if (int err = clBuildProgram(prg, 1, &device_id, args, NULL, NULL); err != 0) {
-    cl_print_build_errors(prg, device_id);
-    assert(0);
-  }
-  return prg;
-}
-
-// Given a cl code and return a string representation
-#define CL_ERR_TO_STR(err) case err: return #err
-const char* cl_get_error_string(int err) {
-  switch (err) {
-    CL_ERR_TO_STR(CL_SUCCESS);
-    CL_ERR_TO_STR(CL_DEVICE_NOT_FOUND);
-    CL_ERR_TO_STR(CL_DEVICE_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_COMPILER_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_MEM_OBJECT_ALLOCATION_FAILURE);
-    CL_ERR_TO_STR(CL_OUT_OF_RESOURCES);
-    CL_ERR_TO_STR(CL_OUT_OF_HOST_MEMORY);
-    CL_ERR_TO_STR(CL_PROFILING_INFO_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_MEM_COPY_OVERLAP);
-    CL_ERR_TO_STR(CL_IMAGE_FORMAT_MISMATCH);
-    CL_ERR_TO_STR(CL_IMAGE_FORMAT_NOT_SUPPORTED);
-    CL_ERR_TO_STR(CL_MAP_FAILURE);
-    CL_ERR_TO_STR(CL_MISALIGNED_SUB_BUFFER_OFFSET);
-    CL_ERR_TO_STR(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST);
-    CL_ERR_TO_STR(CL_COMPILE_PROGRAM_FAILURE);
-    CL_ERR_TO_STR(CL_LINKER_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_LINK_PROGRAM_FAILURE);
-    CL_ERR_TO_STR(CL_DEVICE_PARTITION_FAILED);
-    CL_ERR_TO_STR(CL_KERNEL_ARG_INFO_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_INVALID_VALUE);
-    CL_ERR_TO_STR(CL_INVALID_DEVICE_TYPE);
-    CL_ERR_TO_STR(CL_INVALID_PLATFORM);
-    CL_ERR_TO_STR(CL_INVALID_DEVICE);
-    CL_ERR_TO_STR(CL_INVALID_CONTEXT);
-    CL_ERR_TO_STR(CL_INVALID_QUEUE_PROPERTIES);
-    CL_ERR_TO_STR(CL_INVALID_COMMAND_QUEUE);
-    CL_ERR_TO_STR(CL_INVALID_HOST_PTR);
-    CL_ERR_TO_STR(CL_INVALID_MEM_OBJECT);
-    CL_ERR_TO_STR(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);
-    CL_ERR_TO_STR(CL_INVALID_IMAGE_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_SAMPLER);
-    CL_ERR_TO_STR(CL_INVALID_BINARY);
-    CL_ERR_TO_STR(CL_INVALID_BUILD_OPTIONS);
-    CL_ERR_TO_STR(CL_INVALID_PROGRAM);
-    CL_ERR_TO_STR(CL_INVALID_PROGRAM_EXECUTABLE);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL_NAME);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL_DEFINITION);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL);
-    CL_ERR_TO_STR(CL_INVALID_ARG_INDEX);
-    CL_ERR_TO_STR(CL_INVALID_ARG_VALUE);
-    CL_ERR_TO_STR(CL_INVALID_ARG_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL_ARGS);
-    CL_ERR_TO_STR(CL_INVALID_WORK_DIMENSION);
-    CL_ERR_TO_STR(CL_INVALID_WORK_GROUP_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_WORK_ITEM_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_GLOBAL_OFFSET);
-    CL_ERR_TO_STR(CL_INVALID_EVENT_WAIT_LIST);
-    CL_ERR_TO_STR(CL_INVALID_EVENT);
-    CL_ERR_TO_STR(CL_INVALID_OPERATION);
-    CL_ERR_TO_STR(CL_INVALID_GL_OBJECT);
-    CL_ERR_TO_STR(CL_INVALID_BUFFER_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_MIP_LEVEL);
-    CL_ERR_TO_STR(CL_INVALID_GLOBAL_WORK_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_PROPERTY);
-    CL_ERR_TO_STR(CL_INVALID_IMAGE_DESCRIPTOR);
-    CL_ERR_TO_STR(CL_INVALID_COMPILER_OPTIONS);
-    CL_ERR_TO_STR(CL_INVALID_LINKER_OPTIONS);
-    CL_ERR_TO_STR(CL_INVALID_DEVICE_PARTITION_COUNT);
-    case -69: return "CL_INVALID_PIPE_SIZE";
-    case -70: return "CL_INVALID_DEVICE_QUEUE";
-    case -71: return "CL_INVALID_SPEC_ID";
-    case -72: return "CL_MAX_SIZE_RESTRICTION_EXCEEDED";
-    case -1002: return "CL_INVALID_D3D10_DEVICE_KHR";
-    case -1003: return "CL_INVALID_D3D10_RESOURCE_KHR";
-    case -1004: return "CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR";
-    case -1005: return "CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR";
-    case -1006: return "CL_INVALID_D3D11_DEVICE_KHR";
-    case -1007: return "CL_INVALID_D3D11_RESOURCE_KHR";
-    case -1008: return "CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR";
-    case -1009: return "CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR";
-    case -1010: return "CL_INVALID_DX9_MEDIA_ADAPTER_KHR";
-    case -1011: return "CL_INVALID_DX9_MEDIA_SURFACE_KHR";
-    case -1012: return "CL_DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR";
-    case -1013: return "CL_DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR";
-    case -1093: return "CL_INVALID_EGL_OBJECT_KHR";
-    case -1092: return "CL_EGL_RESOURCE_NOT_ACQUIRED_KHR";
-    case -1001: return "CL_PLATFORM_NOT_FOUND_KHR";
-    case -1057: return "CL_DEVICE_PARTITION_FAILED_EXT";
-    case -1058: return "CL_INVALID_PARTITION_COUNT_EXT";
-    case -1059: return "CL_INVALID_PARTITION_NAME_EXT";
-    case -1094: return "CL_INVALID_ACCELERATOR_INTEL";
-    case -1095: return "CL_INVALID_ACCELERATOR_TYPE_INTEL";
-    case -1096: return "CL_INVALID_ACCELERATOR_DESCRIPTOR_INTEL";
-    case -1097: return "CL_ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL";
-    case -1000: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
-    case -1098: return "CL_INVALID_VA_API_MEDIA_ADAPTER_INTEL";
-    case -1099: return "CL_INVALID_VA_API_MEDIA_SURFACE_INTEL";
-    case -1100: return "CL_VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL";
-    case -1101: return "CL_VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL";
-    default: return "CL_UNKNOWN_ERROR";
-  }
-}
@@ -1,29 +0,0 @@
-#pragma once
-
-#ifdef __APPLE__
-#include <OpenCL/cl.h>
-#else
-#include <CL/cl.h>
-#endif
-
-#include <string>
-
-#define CL_CHECK(_expr)          \
-  do {                           \
-    assert(CL_SUCCESS == (_expr)); \
-  } while (0)
-
-#define CL_CHECK_ERR(_expr)           \
-  ({                                  \
-    cl_int err = CL_INVALID_VALUE;    \
-    __typeof__(_expr) _ret = _expr;   \
-    assert(_ret&& err == CL_SUCCESS); \
-    _ret;                             \
-  })
-
-cl_device_id cl_get_device_id(cl_device_type device_type);
-cl_context cl_create_context(cl_device_id device_id);
-cl_program cl_program_from_source(cl_context ctx, cl_device_id device_id, const std::string& src, const char* args = nullptr);
-cl_program cl_program_from_binary(cl_context ctx, cl_device_id device_id, const uint8_t* binary, size_t length, const char* args = nullptr);
-cl_program cl_program_from_file(cl_context ctx, cl_device_id device_id, const char* path, const char* args);
-const char* cl_get_error_string(int err);
@@ -1,9 +0,0 @@
-# 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
@@ -1,55 +0,0 @@
-import os
-import sys
-import fcntl
-import hashlib
-import platform
-from cffi import FFI
-
-def suffix():
-  if platform.system() == "Darwin":
-    return ".dylib"
-  else:
-    return ".so"
-
-def ffi_wrap(name, c_code, c_header, tmpdir="/tmp/ccache", cflags="", libraries=None):
-  if libraries is None:
-    libraries = []
-
-  cache = name + "_" + hashlib.sha1(c_code.encode('utf-8')).hexdigest()
-  try:
-    os.mkdir(tmpdir)
-  except OSError:
-    pass
-
-  fd = os.open(tmpdir, 0)
-  fcntl.flock(fd, fcntl.LOCK_EX)
-  try:
-    sys.path.append(tmpdir)
-    try:
-      mod = __import__(cache)
-    except Exception:
-      print(f"cache miss {cache}")
-      compile_code(cache, c_code, c_header, tmpdir, cflags, libraries)
-      mod = __import__(cache)
-  finally:
-    os.close(fd)
-
-  return mod.ffi, mod.lib
-
-
-def compile_code(name, c_code, c_header, directory, cflags="", libraries=None):
-  if libraries is None:
-    libraries = []
-
-  ffibuilder = FFI()
-  ffibuilder.set_source(name, c_code, source_extension='.cpp', libraries=libraries)
-  ffibuilder.cdef(c_header)
-  os.environ['OPT'] = "-fwrapv -O2 -DNDEBUG -std=c++1z"
-  os.environ['CFLAGS'] = cflags
-  ffibuilder.compile(verbose=True, debug=False, tmpdir=directory)
-
-
-def wrap_compiled(name, directory):
-  sys.path.append(directory)
-  mod = __import__(name)
-  return mod.ffi, mod.lib
@@ -1,99 +0,0 @@
-import os
-import shutil
-import tempfile
-from atomicwrites import AtomicWriter
-
-
-def mkdirs_exists_ok(path):
-  if path.startswith(('http://', 'https://')):
-    raise ValueError('URL path')
-  try:
-    os.makedirs(path)
-  except OSError:
-    if not os.path.isdir(path):
-      raise
-
-
-def rm_not_exists_ok(path):
-  try:
-    os.remove(path)
-  except OSError:
-    if os.path.exists(path):
-      raise
-
-
-def rm_tree_or_link(path):
-  if os.path.islink(path):
-    os.unlink(path)
-  elif os.path.isdir(path):
-    shutil.rmtree(path)
-
-
-def get_tmpdir_on_same_filesystem(path):
-  normpath = os.path.normpath(path)
-  parts = normpath.split("/")
-  if len(parts) > 1 and parts[1] == "scratch":
-    return "/scratch/tmp"
-  elif len(parts) > 2 and parts[2] == "runner":
-    return f"/{parts[1]}/runner/tmp"
-  return "/tmp"
-
-
-class NamedTemporaryDir():
-  def __init__(self, temp_dir=None):
-    self._path = tempfile.mkdtemp(dir=temp_dir)
-
-  @property
-  def name(self):
-    return self._path
-
-  def close(self):
-    shutil.rmtree(self._path)
-
-  def __enter__(self):
-    return self
-
-  def __exit__(self, exc_type, exc_value, traceback):
-    self.close()
-
-
-class CallbackReader:
-  """Wraps a file, but overrides the read method to also
-  call a callback function with the number of bytes read so far."""
-  def __init__(self, f, callback, *args):
-    self.f = f
-    self.callback = callback
-    self.cb_args = args
-    self.total_read = 0
-
-  def __getattr__(self, attr):
-    return getattr(self.f, attr)
-
-  def read(self, *args, **kwargs):
-    chunk = self.f.read(*args, **kwargs)
-    self.total_read += len(chunk)
-    self.callback(*self.cb_args, self.total_read)
-    return chunk
-
-
-def _get_fileobject_func(writer, temp_dir):
-  def _get_fileobject():
-    return writer.get_fileobject(dir=temp_dir)
-  return _get_fileobject
-
-def atomic_write_on_fs_tmp(path, **kwargs):
-  """Creates an atomic writer using a temporary file in a temporary directory
-     on the same filesystem as path.
-  """
-  # TODO(mgraczyk): This use of AtomicWriter relies on implementation details to set the temp
-  #                 directory.
-  writer = AtomicWriter(path, **kwargs)
-  return writer._open(_get_fileobject_func(writer, get_tmpdir_on_same_filesystem(path)))
-
-
-def atomic_write_in_dir(path, **kwargs):
-  """Creates an atomic writer using a temporary file in the same directory
-     as the destination file.
-  """
-  writer = AtomicWriter(path, **kwargs)
-  return writer._open(_get_fileobject_func(writer, os.path.dirname(path)))
@@ -1,18 +0,0 @@
-class FirstOrderFilter:
-  # first order filter
-  def __init__(self, x0, rc, dt, initialized=True):
-    self.x = x0
-    self.dt = dt
-    self.update_alpha(rc)
-    self.initialized = initialized
-
-  def update_alpha(self, rc):
-    self.alpha = self.dt / (rc + self.dt)
-
-  def update(self, x):
-    if self.initialized:
-      self.x = (1. - self.alpha) * self.x + self.alpha * x
-    else:
-      self.initialized = True
-      self.x = x
-    return self.x
@@ -1,84 +0,0 @@
-#include "common/gpio.h"
-
-#include <string>
-
-#ifdef __APPLE__
-int gpio_init(int pin_nr, bool output) {
-  return 0;
-}
-
-int gpio_set(int pin_nr, bool high) {
-  return 0;
-}
-
-int gpiochip_get_ro_value_fd(const char* consumer_label, int gpiochiop_id, int pin_nr) {
-  return 0;
-}
-
-#else
-
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <cstring>
-#include <linux/gpio.h>
-#include <sys/ioctl.h>
-
-#include "common/util.h"
-#include "common/swaglog.h"
-
-int gpio_init(int pin_nr, bool output) {
-  char pin_dir_path[50];
-  int pin_dir_path_len = snprintf(pin_dir_path, sizeof(pin_dir_path),
-                           "/sys/class/gpio/gpio%d/direction", pin_nr);
-  if (pin_dir_path_len <= 0) {
-    return -1;
-  }
-  const char *value = output ? "out" : "in";
-  return util::write_file(pin_dir_path, (void*)value, strlen(value));
-}
-
-int gpio_set(int pin_nr, bool high) {
-  char pin_val_path[50];
-  int pin_val_path_len = snprintf(pin_val_path, sizeof(pin_val_path),
-                           "/sys/class/gpio/gpio%d/value", pin_nr);
-  if (pin_val_path_len <= 0) {
-    return -1;
-  }
-  return util::write_file(pin_val_path, (void*)(high ? "1" : "0"), 1);
-}
-
-int gpiochip_get_ro_value_fd(const char* consumer_label, int gpiochiop_id, int pin_nr) {
-
-  // Assumed that all interrupt pins are unexported and rights are given to
-  // read from gpiochip0.
-  std::string gpiochip_path = "/dev/gpiochip" + std::to_string(gpiochiop_id);
-  int fd = open(gpiochip_path.c_str(), O_RDONLY);
-  if (fd < 0) {
-    LOGE("Error opening gpiochip0 fd");
-    return -1;
-  }
-
-  // Setup event
-  struct gpioevent_request rq;
-  rq.lineoffset = pin_nr;
-  rq.handleflags = GPIOHANDLE_REQUEST_INPUT;
-
-  /* Requesting both edges as the data ready pulse from the lsm6ds sensor is
-     very short(75us) and is mostly detected as falling edge instead of rising.
-     So if it is detected as rising the following falling edge is skipped. */
-  rq.eventflags = GPIOEVENT_REQUEST_BOTH_EDGES;
-
-  strncpy(rq.consumer_label, consumer_label, std::size(rq.consumer_label) - 1);
-  int ret = util::safe_ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &rq);
-  if (ret == -1) {
-    LOGE("Unable to get line event from ioctl : %s", strerror(errno));
-    close(fd);
-    return -1;
-  }
-
-  close(fd);
-  return rq.fd;
-}
-
-#endif
@@ -1,33 +0,0 @@
-#pragma once
-
-// Pin definitions
-#ifdef QCOM2
-  #define GPIO_HUB_RST_N        30
-  #define GPIO_UBLOX_RST_N      32
-  #define GPIO_UBLOX_SAFEBOOT_N 33
-  #define GPIO_GNSS_PWR_EN      34 /* SCHEMATIC LABEL: GPIO_UBLOX_PWR_EN */
-  #define GPIO_STM_RST_N        124
-  #define GPIO_STM_BOOT0        134
-  #define GPIO_BMX_ACCEL_INT    21
-  #define GPIO_BMX_GYRO_INT     23
-  #define GPIO_BMX_MAGN_INT     87
-  #define GPIO_LSM_INT          84
-  #define GPIOCHIP_INT          0
-#else
-  #define GPIO_HUB_RST_N        0
-  #define GPIO_UBLOX_RST_N      0
-  #define GPIO_UBLOX_SAFEBOOT_N 0
-  #define GPIO_GNSS_PWR_EN      0 /* SCHEMATIC LABEL: GPIO_UBLOX_PWR_EN */
-  #define GPIO_STM_RST_N        0
-  #define GPIO_STM_BOOT0        0
-  #define GPIO_BMX_ACCEL_INT    0
-  #define GPIO_BMX_GYRO_INT     0
-  #define GPIO_BMX_MAGN_INT     0
-  #define GPIO_LSM_INT          0
-  #define GPIOCHIP_INT          0
-#endif
-
-int gpio_init(int pin_nr, bool output);
-int gpio_set(int pin_nr, bool high);
-
-int gpiochip_get_ro_value_fd(const char* consumer_label, int gpiochiop_id, int pin_nr);
@@ -1,55 +0,0 @@
-import os
-from functools import lru_cache
-from typing import Optional, List
-
-def gpio_init(pin: int, output: bool) -> None:
-  try:
-    with open(f"/sys/class/gpio/gpio{pin}/direction", 'wb') as f:
-      f.write(b"out" if output else b"in")
-  except Exception as e:
-    print(f"Failed to set gpio {pin} direction: {e}")
-
-def gpio_set(pin: int, high: bool) -> None:
-  try:
-    with open(f"/sys/class/gpio/gpio{pin}/value", 'wb') as f:
-      f.write(b"1" if high else b"0")
-  except Exception as e:
-    print(f"Failed to set gpio {pin} value: {e}")
-
-def gpio_read(pin: int) -> Optional[bool]:
-  val = None
-  try:
-    with open(f"/sys/class/gpio/gpio{pin}/value", 'rb') as f:
-      val = bool(int(f.read().strip()))
-  except Exception as e:
-    print(f"Failed to set gpio {pin} value: {e}")
-
-  return val
-
-def gpio_export(pin: int) -> None:
-  if os.path.isdir(f"/sys/class/gpio/gpio{pin}"):
-    return
-
-  try:
-    with open("/sys/class/gpio/export", 'w') as f:
-      f.write(str(pin))
-  except Exception:
-    print(f"Failed to export gpio {pin}")
-
-@lru_cache(maxsize=None)
-def get_irq_action(irq: int) -> List[str]:
-  try:
-    with open(f"/sys/kernel/irq/{irq}/actions") as f:
-      actions = f.read().strip().split(',')
-      return actions
-  except FileNotFoundError:
-    return []
-
-def get_irqs_for_action(action: str) -> List[str]:
-  ret = []
-  with open("/proc/interrupts") as f:
-    for l in f.readlines():
-      irq = l.split(':')[0].strip()
-      if irq.isdigit() and action in get_irq_action(irq):
-        ret.append(irq)
-  return ret
@@ -1,92 +0,0 @@
-#include "common/i2c.h"
-
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <unistd.h>
-
-#include <cassert>
-#include <cstdio>
-#include <stdexcept>
-
-#include "common/swaglog.h"
-#include "common/util.h"
-
-#define UNUSED(x) (void)(x)
-
-#ifdef QCOM2
-// TODO: decide if we want to install libi2c-dev everywhere
-extern "C" {
-  #include <linux/i2c-dev.h>
-  #include <i2c/smbus.h>
-}
-
-I2CBus::I2CBus(uint8_t bus_id) {
-  char bus_name[20];
-  snprintf(bus_name, 20, "/dev/i2c-%d", bus_id);
-
-  i2c_fd = HANDLE_EINTR(open(bus_name, O_RDWR));
-  if (i2c_fd < 0) {
-    throw std::runtime_error("Failed to open I2C bus");
-  }
-}
-
-I2CBus::~I2CBus() {
-  if (i2c_fd >= 0) {
-    close(i2c_fd);
-  }
-}
-
-int I2CBus::read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len) {
-  std::lock_guard lk(m);
-
-  int ret = 0;
-
-  ret = HANDLE_EINTR(ioctl(i2c_fd, I2C_SLAVE, device_address));
-  if (ret < 0) { goto fail; }
-
-  ret = i2c_smbus_read_i2c_block_data(i2c_fd, register_address, len, buffer);
-  if ((ret < 0) || (ret != len)) { goto fail; }
-
-fail:
-  return ret;
-}
-
-int I2CBus::set_register(uint8_t device_address, uint register_address, uint8_t data) {
-  std::lock_guard lk(m);
-
-  int ret = 0;
-
-  ret = HANDLE_EINTR(ioctl(i2c_fd, I2C_SLAVE, device_address));
-  if (ret < 0) { goto fail; }
-
-  ret = i2c_smbus_write_byte_data(i2c_fd, register_address, data);
-  if (ret < 0) { goto fail; }
-
-fail:
-  return ret;
-}
-
-#else
-
-I2CBus::I2CBus(uint8_t bus_id) {
-  UNUSED(bus_id);
-  i2c_fd = -1;
-}
-
-I2CBus::~I2CBus() {}
-
-int I2CBus::read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len) {
-  UNUSED(device_address);
-  UNUSED(register_address);
-  UNUSED(buffer);
-  UNUSED(len);
-  return -1;
-}
-
-int I2CBus::set_register(uint8_t device_address, uint register_address, uint8_t data) {
-  UNUSED(device_address);
-  UNUSED(register_address);
-  UNUSED(data);
-  return -1;
-}
-#endif
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <mutex>
-
-#include <sys/types.h>
-
-class I2CBus {
-  private:
-    int i2c_fd;
-    std::mutex m;
-
-  public:
-    I2CBus(uint8_t bus_id);
-    ~I2CBus();
-
-    int read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len);
-    int set_register(uint8_t device_address, uint register_address, uint8_t data);
-};
@@ -1 +0,0 @@
-simple_kalman_impl.c
@@ -1,5 +0,0 @@
-Import('envCython')
-
-simple_kalman_python = envCython.Program('simple_kalman_impl.so', 'simple_kalman_impl.pyx')
-
-Export('simple_kalman_python')
@@ -1,12 +0,0 @@
-from openpilot.common.kalman.simple_kalman_impl import KF1D as KF1D
-assert KF1D
-import numpy as np
-
-def get_kalman_gain(dt, A, C, Q, R, iterations=100):
-  P = np.zeros_like(Q)
-  for _ in range(iterations):
-    P = A.dot(P).dot(A.T) + dt * Q
-    S = C.dot(P).dot(C.T) + R
-    K = P.dot(C.T).dot(np.linalg.inv(S))
-    P = (np.eye(len(P)) - K.dot(C)).dot(P)
-  return K
@@ -1,18 +0,0 @@
-# cython: language_level = 3
-
-cdef class KF1D:
-  cdef public:
-    double x0_0
-    double x1_0
-    double K0_0
-    double K1_0
-    double A0_0
-    double A0_1
-    double A1_0
-    double A1_1
-    double C0_0
-    double C0_1
-    double A_K_0
-    double A_K_1
-    double A_K_2
-    double A_K_3
@@ -1,37 +0,0 @@
-# distutils: language = c++
-# cython: language_level=3
-
-cdef class KF1D:
-  def __init__(self, x0, A, C, K):
-    self.x0_0 = x0[0][0]
-    self.x1_0 = x0[1][0]
-    self.A0_0 = A[0][0]
-    self.A0_1 = A[0][1]
-    self.A1_0 = A[1][0]
-    self.A1_1 = A[1][1]
-    self.C0_0 = C[0]
-    self.C0_1 = C[1]
-    self.K0_0 = K[0][0]
-    self.K1_0 = K[1][0]
-
-    self.A_K_0 = self.A0_0 - self.K0_0 * self.C0_0
-    self.A_K_1 = self.A0_1 - self.K0_0 * self.C0_1
-    self.A_K_2 = self.A1_0 - self.K1_0 * self.C0_0
-    self.A_K_3 = self.A1_1 - self.K1_0 * self.C0_1
-
-  def update(self, meas):
-    cdef double x0_0 = self.A_K_0 * self.x0_0 + self.A_K_1 * self.x1_0 + self.K0_0 * meas
-    cdef double x1_0 = self.A_K_2 * self.x0_0 + self.A_K_3 * self.x1_0 + self.K1_0 * meas
-    self.x0_0 = x0_0
-    self.x1_0 = x1_0
-
-    return [self.x0_0, self.x1_0]
-
-  @property
-  def x(self):
-    return [[self.x0_0], [self.x1_0]]
-
-  @x.setter
-  def x(self, x):
-    self.x0_0 = x[0][0]
-    self.x1_0 = x[1][0]
@@ -1,23 +0,0 @@
-import numpy as np
-
-
-class KF1D:
-  # this EKF assumes constant covariance matrix, so calculations are much simpler
-  # the Kalman gain also needs to be precomputed using the control module
-
-  def __init__(self, x0, A, C, K):
-    self.x = x0
-    self.A = A
-    self.C = np.atleast_2d(C)
-    self.K = K
-
-    self.A_K = self.A - np.dot(self.K, self.C)
-
-    # K matrix needs to  be pre-computed as follow:
-    # import control
-    # (x, l, K) = control.dare(np.transpose(self.A), np.transpose(self.C), Q, R)
-    # self.K = np.transpose(K)
-
-  def update(self, meas):
-    self.x = np.dot(self.A_K, self.x) + np.dot(self.K, meas)
-    return self.x
@@ -1,87 +0,0 @@
-import unittest
-import random
-import timeit
-import numpy as np
-
-from openpilot.common.kalman.simple_kalman import KF1D
-from openpilot.common.kalman.simple_kalman_old import KF1D as KF1D_old
-
-
-class TestSimpleKalman(unittest.TestCase):
-  def setUp(self):
-    dt = 0.01
-    x0_0 = 0.0
-    x1_0 = 0.0
-    A0_0 = 1.0
-    A0_1 = dt
-    A1_0 = 0.0
-    A1_1 = 1.0
-    C0_0 = 1.0
-    C0_1 = 0.0
-    K0_0 = 0.12287673
-    K1_0 = 0.29666309
-
-    self.kf_old = KF1D_old(x0=np.array([[x0_0], [x1_0]]),
-                           A=np.array([[A0_0, A0_1], [A1_0, A1_1]]),
-                           C=np.array([C0_0, C0_1]),
-                           K=np.array([[K0_0], [K1_0]]))
-
-    self.kf = KF1D(x0=[[x0_0], [x1_0]],
-                   A=[[A0_0, A0_1], [A1_0, A1_1]],
-                   C=[C0_0, C0_1],
-                   K=[[K0_0], [K1_0]])
-
-  def test_getter_setter(self):
-    self.kf.x = [[1.0], [1.0]]
-    self.assertEqual(self.kf.x, [[1.0], [1.0]])
-
-  def update_returns_state(self):
-    x = self.kf.update(100)
-    self.assertEqual(x, self.kf.x)
-
-  def test_old_equal_new(self):
-    for _ in range(1000):
-      v_wheel = random.uniform(0, 200)
-
-      x_old = self.kf_old.update(v_wheel)
-      x = self.kf.update(v_wheel)
-
-      # Compare the output x, verify that the error is less than 1e-4
-      np.testing.assert_almost_equal(x_old[0], x[0])
-      np.testing.assert_almost_equal(x_old[1], x[1])
-
-  def test_new_is_faster(self):
-    setup = """
-import numpy as np
-
-from openpilot.common.kalman.simple_kalman import KF1D
-from openpilot.common.kalman.simple_kalman_old import KF1D as KF1D_old
-
-dt = 0.01
-x0_0 = 0.0
-x1_0 = 0.0
-A0_0 = 1.0
-A0_1 = dt
-A1_0 = 0.0
-A1_1 = 1.0
-C0_0 = 1.0
-C0_1 = 0.0
-K0_0 = 0.12287673
-K1_0 = 0.29666309
-
-kf_old = KF1D_old(x0=np.array([[x0_0], [x1_0]]),
-                  A=np.array([[A0_0, A0_1], [A1_0, A1_1]]),
-                  C=np.array([C0_0, C0_1]),
-                  K=np.array([[K0_0], [K1_0]]))
-
-kf = KF1D(x0=[[x0_0], [x1_0]],
-          A=[[A0_0, A0_1], [A1_0, A1_1]],
-          C=[C0_0, C0_1],
-          K=[[K0_0], [K1_0]])
-    """
-    kf_speed = timeit.timeit("kf.update(1234)", setup=setup, number=10000)
-    kf_old_speed = timeit.timeit("kf_old.update(1234)", setup=setup, number=10000)
-    self.assertTrue(kf_speed < kf_old_speed / 4)
-
-if __name__ == "__main__":
-  unittest.main()
@@ -1,12 +0,0 @@
-class lazy_property():
-  """Defines a property whose value will be computed only once and as needed.
-
-     This can only be used on instance methods.
-  """
-  def __init__(self, func):
-    self._func = func
-
-  def __get__(self, obj_self, cls):
-    value = self._func(obj_self)
-    setattr(obj_self, self._func.__name__, value)
-    return value
@@ -1,85 +0,0 @@
-#pragma once
-
-typedef struct vec3 {
-  float v[3];
-} vec3;
-
-typedef struct vec4 {
-  float v[4];
-} vec4;
-
-typedef struct mat3 {
-  float v[3*3];
-} mat3;
-
-typedef struct mat4 {
-  float v[4*4];
-} mat4;
-
-static inline mat3 matmul3(const mat3 &a, const mat3 &b) {
-  mat3 ret = {{0.0}};
-  for (int r=0; r<3; r++) {
-    for (int c=0; c<3; c++) {
-      float v = 0.0;
-      for (int k=0; k<3; k++) {
-        v += a.v[r*3+k] * b.v[k*3+c];
-      }
-      ret.v[r*3+c] = v;
-    }
-  }
-  return ret;
-}
-
-static inline vec3 matvecmul3(const mat3 &a, const vec3 &b) {
-  vec3 ret = {{0.0}};
-  for (int r=0; r<3; r++) {
-    for (int c=0; c<3; c++) {
-      ret.v[r] += a.v[r*3+c] * b.v[c];
-    }
-  }
-  return ret;
-}
-
-static inline mat4 matmul(const mat4 &a, const mat4 &b) {
-  mat4 ret = {{0.0}};
-  for (int r=0; r<4; r++) {
-    for (int c=0; c<4; c++) {
-      float v = 0.0;
-      for (int k=0; k<4; k++) {
-        v += a.v[r*4+k] * b.v[k*4+c];
-      }
-      ret.v[r*4+c] = v;
-    }
-  }
-  return ret;
-}
-
-static inline vec4 matvecmul(const mat4 &a, const vec4 &b) {
-  vec4 ret = {{0.0}};
-  for (int r=0; r<4; r++) {
-    for (int c=0; c<4; c++) {
-      ret.v[r] += a.v[r*4+c] * b.v[c];
-    }
-  }
-  return ret;
-}
-
-// scales the input and output space of a transformation matrix
-// that assumes pixel-center origin.
-static inline mat3 transform_scale_buffer(const mat3 &in, float s) {
-  // in_pt = ( transform(out_pt/s + 0.5) - 0.5) * s
-
-  mat3 transform_out = {{
-    1.0f/s, 0.0f, 0.5f,
-    0.0f, 1.0f/s, 0.5f,
-    0.0f, 0.0f, 1.0f,
-  }};
-
-  mat3 transform_in = {{
-    s,  0.0f, -0.5f*s,
-    0.0f, s, -0.5f*s,
-    0.0f, 0.0f, 1.0f,
-  }};
-
-  return matmul3(transform_in, matmul3(in, transform_out));
-}
@@ -1,38 +0,0 @@
-#pragma once
-
-#include <array>
-#include "common/mat.h"
-#include "system/hardware/hw.h"
-
-const int TRAJECTORY_SIZE = 33;
-const int LAT_MPC_N = 16;
-const int LON_MPC_N = 32;
-const float MIN_DRAW_DISTANCE = 10.0;
-const float MAX_DRAW_DISTANCE = 100.0;
-
-const float RYG_GREEN = 0.01165;
-const float RYG_YELLOW = 0.06157;
-
-template <typename T, size_t size>
-constexpr std::array<T, size> build_idxs(float max_val) {
-  std::array<T, size> result{};
-  for (int i = 0; i < size; ++i) {
-    result[i] = max_val * ((i / (double)(size - 1)) * (i / (double)(size - 1)));
-  }
-  return result;
-}
-
-constexpr auto T_IDXS = build_idxs<double, TRAJECTORY_SIZE>(10.0);
-constexpr auto T_IDXS_FLOAT = build_idxs<float, TRAJECTORY_SIZE>(10.0);
-constexpr auto X_IDXS = build_idxs<double, TRAJECTORY_SIZE>(192.0);
-constexpr auto X_IDXS_FLOAT = build_idxs<float, TRAJECTORY_SIZE>(192.0);
-
-const mat3 FCAM_INTRINSIC_MATRIX = (mat3){{2648.0, 0.0, 1928.0 / 2,
-                                           0.0, 2648.0, 1208.0 / 2,
-                                           0.0, 0.0, 1.0}};
-
-// tici ecam focal probably wrong? magnification is not consistent across frame
-// Need to retrain model before this can be changed
-const mat3 ECAM_INTRINSIC_MATRIX = (mat3){{567.0, 0.0, 1928.0 / 2,
-                                           0.0, 567.0, 1208.0 / 2,
-                                           0.0, 0.0, 1.0}};
@@ -1,19 +0,0 @@
-def clip(x, lo, hi):
-  return max(lo, min(hi, x))
-
-def interp(x, xp, fp):
-  N = len(xp)
-
-  def get_interp(xv):
-    hi = 0
-    while hi < N and xv > xp[hi]:
-      hi += 1
-    low = hi - 1
-    return fp[-1] if hi == N and xv > xp[low] else (
-      fp[0] if hi == 0 else
-      (xv - xp[low]) * (fp[hi] - fp[low]) / (xp[hi] - xp[low]) + fp[low])
-
-  return [get_interp(v) for v in x] if hasattr(x, '__iter__') else get_interp(x)
-
-def mean(x):
-  return sum(x) / len(x)
@@ -1,22 +0,0 @@
-import numpy as np
-
-
-def deep_interp_np(x, xp, fp, axis=None):
-  if axis is not None:
-    fp = fp.swapaxes(0,axis)
-  x = np.atleast_1d(x)
-  xp = np.array(xp)
-  if len(xp) < 2:
-    return np.repeat(fp, len(x), axis=0)
-  if min(np.diff(xp)) < 0:
-    raise RuntimeError('Bad x array for interpolation')
-  j = np.searchsorted(xp, x) - 1
-  j = np.clip(j, 0, len(xp)-2)
-  d = np.divide(x - xp[j], xp[j + 1] - xp[j], out=np.ones_like(x, dtype=np.float64), where=xp[j + 1] - xp[j] != 0)
-  vals_interp = (fp[j].T*(1 - d)).T + (fp[j + 1].T*d).T
-  if axis is not None:
-    vals_interp = vals_interp.swapaxes(0,axis)
-  if len(vals_interp) == 1:
-    return vals_interp[0]
-  else:
-    return vals_interp
@@ -1,329 +0,0 @@
-#include "common/params.h"
-
-#include <dirent.h>
-#include <sys/file.h>
-
-#include <algorithm>
-#include <csignal>
-#include <unordered_map>
-
-#include "common/swaglog.h"
-#include "common/util.h"
-#include "system/hardware/hw.h"
-
-namespace {
-
-volatile sig_atomic_t params_do_exit = 0;
-void params_sig_handler(int signal) {
-  params_do_exit = 1;
-}
-
-int fsync_dir(const std::string &path) {
-  int result = -1;
-  int fd = HANDLE_EINTR(open(path.c_str(), O_RDONLY, 0755));
-  if (fd >= 0) {
-    result = fsync(fd);
-    close(fd);
-  }
-  return result;
-}
-
-bool create_params_path(const std::string &param_path, const std::string &key_path) {
-  // Make sure params path exists
-  if (!util::file_exists(param_path) && !util::create_directories(param_path, 0775)) {
-    return false;
-  }
-
-  // See if the symlink exists, otherwise create it
-  if (!util::file_exists(key_path)) {
-    // 1) Create temp folder
-    // 2) Symlink it to temp link
-    // 3) Move symlink to <params>/d
-
-    std::string tmp_path = param_path + "/.tmp_XXXXXX";
-    // this should be OK since mkdtemp just replaces characters in place
-    char *tmp_dir = mkdtemp((char *)tmp_path.c_str());
-    if (tmp_dir == NULL) {
-      return false;
-    }
-
-    std::string link_path = std::string(tmp_dir) + ".link";
-    if (symlink(tmp_dir, link_path.c_str()) != 0) {
-      return false;
-    }
-
-    // don't return false if it has been created by other
-    if (rename(link_path.c_str(), key_path.c_str()) != 0 && errno != EEXIST) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-std::string ensure_params_path(const std::string &prefix, const std::string &path = {}) {
-  std::string params_path = path.empty() ? Path::params() : path;
-  if (!create_params_path(params_path, params_path + prefix)) {
-    throw std::runtime_error(util::string_format("Failed to ensure params path, errno=%d", errno));
-  }
-  return params_path;
-}
-
-class FileLock {
-public:
-  FileLock(const std::string &fn) {
-    fd_ = HANDLE_EINTR(open(fn.c_str(), O_CREAT, 0775));
-    if (fd_ < 0 || HANDLE_EINTR(flock(fd_, LOCK_EX)) < 0) {
-      LOGE("Failed to lock file %s, errno=%d", fn.c_str(), errno);
-    }
-  }
-  ~FileLock() { close(fd_); }
-
-private:
-  int fd_ = -1;
-};
-
-std::unordered_map<std::string, uint32_t> keys = {
-    {"AccessToken", CLEAR_ON_MANAGER_START | DONT_LOG},
-    {"ApiCache_Device", PERSISTENT},
-    {"ApiCache_DriveStats", PERSISTENT},
-    {"ApiCache_NavDestinations", PERSISTENT},
-    {"AssistNowToken", PERSISTENT},
-    {"AthenadPid", PERSISTENT},
-    {"AthenadUploadQueue", PERSISTENT},
-    {"CalibrationParams", PERSISTENT},
-    {"CameraDebugExpGain", CLEAR_ON_MANAGER_START},
-    {"CameraDebugExpTime", CLEAR_ON_MANAGER_START},
-    {"CarBatteryCapacity", PERSISTENT},
-    {"CarParams", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"CarParamsCache", CLEAR_ON_MANAGER_START},
-    {"CarParamsPersistent", PERSISTENT},
-    {"CarVin", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"CompletedTrainingVersion", PERSISTENT},
-    {"ControlsReady", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"CurrentBootlog", PERSISTENT},
-    {"CurrentRoute", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"DisableLogging", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"DisablePowerDown", PERSISTENT},
-    {"DisableUpdates", PERSISTENT},
-    {"DisengageOnAccelerator", PERSISTENT},
-    {"DmModelInitialized", CLEAR_ON_ONROAD_TRANSITION},
-    {"DongleId", PERSISTENT},
-    {"DoReboot", CLEAR_ON_MANAGER_START},
-    {"DoShutdown", CLEAR_ON_MANAGER_START},
-    {"DoUninstall", CLEAR_ON_MANAGER_START},
-    {"ExperimentalLongitudinalEnabled", PERSISTENT},
-    {"ExperimentalMode", PERSISTENT},
-    {"ExperimentalModeConfirmed", PERSISTENT},
-    {"FirmwareQueryDone", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"ForcePowerDown", PERSISTENT},
-    {"GitBranch", PERSISTENT},
-    {"GitCommit", PERSISTENT},
-    {"GitDiff", PERSISTENT},
-    {"GithubSshKeys", PERSISTENT},
-    {"GithubUsername", PERSISTENT},
-    {"GitRemote", PERSISTENT},
-    {"GsmApn", PERSISTENT},
-    {"GsmMetered", PERSISTENT},
-    {"GsmRoaming", PERSISTENT},
-    {"HardwareSerial", PERSISTENT},
-    {"HasAcceptedTerms", PERSISTENT},
-    {"IMEI", PERSISTENT},
-    {"InstallDate", PERSISTENT},
-    {"IsDriverViewEnabled", CLEAR_ON_MANAGER_START},
-    {"IsEngaged", PERSISTENT},
-    {"IsLdwEnabled", PERSISTENT},
-    {"IsMetric", PERSISTENT},
-    {"IsOffroad", CLEAR_ON_MANAGER_START},
-    {"IsOnroad", PERSISTENT},
-    {"IsRhdDetected", PERSISTENT},
-    {"IsReleaseBranch", CLEAR_ON_MANAGER_START},
-    {"IsTakingSnapshot", CLEAR_ON_MANAGER_START},
-    {"IsTestedBranch", CLEAR_ON_MANAGER_START},
-    {"IsUpdateAvailable", CLEAR_ON_MANAGER_START},
-    {"JoystickDebugMode", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
-    {"LaikadEphemerisV3", PERSISTENT | DONT_LOG},
-    {"LanguageSetting", PERSISTENT},
-    {"LastAthenaPingTime", CLEAR_ON_MANAGER_START},
-    {"LastGPSPosition", PERSISTENT},
-    {"LastManagerExitReason", CLEAR_ON_MANAGER_START},
-    {"LastOffroadStatusPacket", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
-    {"LastPowerDropDetected", CLEAR_ON_MANAGER_START},
-    {"LastSystemShutdown", CLEAR_ON_MANAGER_START},
-    {"LastUpdateException", CLEAR_ON_MANAGER_START},
-    {"LastUpdateTime", PERSISTENT},
-    {"LiveParameters", PERSISTENT},
-    {"LiveTorqueCarParams", PERSISTENT},
-    {"LiveTorqueParameters", PERSISTENT | DONT_LOG},
-    {"LongitudinalPersonality", PERSISTENT},
-    {"NavDestination", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
-    {"NavDestinationWaypoints", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
-    {"NavPastDestinations", PERSISTENT},
-    {"NavSettingLeftSide", PERSISTENT},
-    {"NavSettingTime24h", PERSISTENT},
-    {"NavdRender", PERSISTENT},
-    {"ObdMultiplexingChanged", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"ObdMultiplexingEnabled", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"Offroad_BadNvme", CLEAR_ON_MANAGER_START},
-    {"Offroad_CarUnrecognized", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"Offroad_ConnectivityNeeded", CLEAR_ON_MANAGER_START},
-    {"Offroad_ConnectivityNeededPrompt", CLEAR_ON_MANAGER_START},
-    {"Offroad_InvalidTime", CLEAR_ON_MANAGER_START},
-    {"Offroad_IsTakingSnapshot", CLEAR_ON_MANAGER_START},
-    {"Offroad_NeosUpdate", CLEAR_ON_MANAGER_START},
-    {"Offroad_NoFirmware", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"Offroad_Recalibration", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"Offroad_StorageMissing", CLEAR_ON_MANAGER_START},
-    {"Offroad_TemperatureTooHigh", CLEAR_ON_MANAGER_START},
-    {"Offroad_UnofficialHardware", CLEAR_ON_MANAGER_START},
-    {"Offroad_UpdateFailed", CLEAR_ON_MANAGER_START},
-    {"OpenpilotEnabledToggle", PERSISTENT},
-    {"PandaHeartbeatLost", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
-    {"PandaLogState", PERSISTENT},
-    {"PandaSignatures", CLEAR_ON_MANAGER_START},
-    {"Passive", PERSISTENT},
-    {"PrimeType", PERSISTENT},
-    {"RecordFront", PERSISTENT},
-    {"RecordFrontLock", PERSISTENT},  // for the internal fleet
-    {"ReplayControlsState", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"ShouldDoUpdate", CLEAR_ON_MANAGER_START},
-    {"SnoozeUpdate", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
-    {"SshEnabled", PERSISTENT},
-    {"SubscriberInfo", PERSISTENT},
-    {"TermsVersion", PERSISTENT},
-    {"Timezone", PERSISTENT},
-    {"TrainingVersion", PERSISTENT},
-    {"UbloxAvailable", PERSISTENT},
-    {"UpdateAvailable", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"UpdateFailedCount", CLEAR_ON_MANAGER_START},
-    {"UpdaterAvailableBranches", CLEAR_ON_MANAGER_START},
-    {"UpdaterCurrentDescription", CLEAR_ON_MANAGER_START},
-    {"UpdaterCurrentReleaseNotes", CLEAR_ON_MANAGER_START},
-    {"UpdaterFetchAvailable", CLEAR_ON_MANAGER_START},
-    {"UpdaterNewDescription", CLEAR_ON_MANAGER_START},
-    {"UpdaterNewReleaseNotes", CLEAR_ON_MANAGER_START},
-    {"UpdaterState", CLEAR_ON_MANAGER_START},
-    {"UpdaterTargetBranch", CLEAR_ON_MANAGER_START},
-    {"Version", PERSISTENT},
-    {"VisionRadarToggle", PERSISTENT},
-    {"WheeledBody", PERSISTENT},
-};
-
-} // namespace
-
-
-Params::Params(const std::string &path) {
-  prefix = "/" + util::getenv("OPENPILOT_PREFIX", "d");
-  params_path = ensure_params_path(prefix, path);
-}
-
-std::vector<std::string> Params::allKeys() const {
-  std::vector<std::string> ret;
-  for (auto &p : keys) {
-    ret.push_back(p.first);
-  }
-  return ret;
-}
-
-bool Params::checkKey(const std::string &key) {
-  return keys.find(key) != keys.end();
-}
-
-ParamKeyType Params::getKeyType(const std::string &key) {
-  return static_cast<ParamKeyType>(keys[key]);
-}
-
-int Params::put(const char* key, const char* value, size_t value_size) {
-  // Information about safely and atomically writing a file: https://lwn.net/Articles/457667/
-  // 1) Create temp file
-  // 2) Write data to temp file
-  // 3) fsync() the temp file
-  // 4) rename the temp file to the real name
-  // 5) fsync() the containing directory
-  std::string tmp_path = params_path + "/.tmp_value_XXXXXX";
-  int tmp_fd = mkstemp((char*)tmp_path.c_str());
-  if (tmp_fd < 0) return -1;
-
-  int result = -1;
-  do {
-    // Write value to temp.
-    ssize_t bytes_written = HANDLE_EINTR(write(tmp_fd, value, value_size));
-    if (bytes_written < 0 || (size_t)bytes_written != value_size) {
-      result = -20;
-      break;
-    }
-
-    // fsync to force persist the changes.
-    if ((result = fsync(tmp_fd)) < 0) break;
-
-    FileLock file_lock(params_path + "/.lock");
-
-    // Move temp into place.
-    if ((result = rename(tmp_path.c_str(), getParamPath(key).c_str())) < 0) break;
-
-    // fsync parent directory
-    result = fsync_dir(getParamPath());
-  } while (false);
-
-  close(tmp_fd);
-  ::unlink(tmp_path.c_str());
-  return result;
-}
-
-int Params::remove(const std::string &key) {
-  FileLock file_lock(params_path + "/.lock");
-  int result = unlink(getParamPath(key).c_str());
-  if (result != 0) {
-    return result;
-  }
-  return fsync_dir(getParamPath());
-}
-
-std::string Params::get(const std::string &key, bool block) {
-  if (!block) {
-    return util::read_file(getParamPath(key));
-  } else {
-    // blocking read until successful
-    params_do_exit = 0;
-    void (*prev_handler_sigint)(int) = std::signal(SIGINT, params_sig_handler);
-    void (*prev_handler_sigterm)(int) = std::signal(SIGTERM, params_sig_handler);
-
-    std::string value;
-    while (!params_do_exit) {
-      if (value = util::read_file(getParamPath(key)); !value.empty()) {
-        break;
-      }
-      util::sleep_for(100);  // 0.1 s
-    }
-
-    std::signal(SIGINT, prev_handler_sigint);
-    std::signal(SIGTERM, prev_handler_sigterm);
-    return value;
-  }
-}
-
-std::map<std::string, std::string> Params::readAll() {
-  FileLock file_lock(params_path + "/.lock");
-  return util::read_files_in_dir(getParamPath());
-}
-
-void Params::clearAll(ParamKeyType key_type) {
-  FileLock file_lock(params_path + "/.lock");
-
-  // 1) delete params of key_type
-  // 2) delete files that are not defined in the keys.
-  if (DIR *d = opendir(getParamPath().c_str())) {
-    struct dirent *de = NULL;
-    while ((de = readdir(d))) {
-      if (de->d_type != DT_DIR) {
-        auto it = keys.find(de->d_name);
-        if (it == keys.end() || (it->second & key_type)) {
-          unlink(getParamPath(de->d_name).c_str());
-        }
-      }
-    }
-    closedir(d);
-  }
-
-  fsync_dir(getParamPath());
-}
@@ -1,49 +0,0 @@
-#pragma once
-
-#include <map>
-#include <string>
-#include <vector>
-
-enum ParamKeyType {
-  PERSISTENT = 0x02,
-  CLEAR_ON_MANAGER_START = 0x04,
-  CLEAR_ON_ONROAD_TRANSITION = 0x08,
-  CLEAR_ON_OFFROAD_TRANSITION = 0x10,
-  DONT_LOG = 0x20,
-  ALL = 0xFFFFFFFF
-};
-
-class Params {
-public:
-  Params(const std::string &path = {});
-  std::vector<std::string> allKeys() const;
-  bool checkKey(const std::string &key);
-  ParamKeyType getKeyType(const std::string &key);
-  inline std::string getParamPath(const std::string &key = {}) {
-    return params_path + prefix + (key.empty() ? "" : "/" + key);
-  }
-
-  // Delete a value
-  int remove(const std::string &key);
-  void clearAll(ParamKeyType type);
-
-  // helpers for reading values
-  std::string get(const std::string &key, bool block = false);
-  inline bool getBool(const std::string &key, bool block = false) {
-    return get(key, block) == "1";
-  }
-  std::map<std::string, std::string> readAll();
-
-  // helpers for writing values
-  int put(const char *key, const char *val, size_t value_size);
-  inline int put(const std::string &key, const std::string &val) {
-    return put(key.c_str(), val.data(), val.size());
-  }
-  inline int putBool(const std::string &key, bool val) {
-    return put(key.c_str(), val ? "1" : "0", 1);
-  }
-
-private:
-  std::string params_path;
-  std::string prefix;
-};
@@ -1,21 +0,0 @@
-from openpilot.common.params_pyx import Params, ParamKeyType, UnknownKeyName, put_nonblocking, \
-                                        put_bool_nonblocking
-assert Params
-assert ParamKeyType
-assert UnknownKeyName
-assert put_nonblocking
-assert put_bool_nonblocking
-
-if __name__ == "__main__":
-  import sys
-
-  params = Params()
-  key = sys.argv[1]
-  assert params.check_key(key), f"unknown param: {key}"
-
-  if len(sys.argv) == 3:
-    val = sys.argv[2]
-    print(f"SET: {key} = {val}")
-    params.put(key, val)
-  elif len(sys.argv) == 2:
-    print(f"GET: {key} = {params.get(key)}")
@@ -1,111 +0,0 @@
-# distutils: language = c++
-# cython: language_level = 3
-from libcpp cimport bool
-from libcpp.string cimport string
-from libcpp.vector cimport vector
-import threading
-
-cdef extern from "common/params.h":
-  cpdef enum ParamKeyType:
-    PERSISTENT
-    CLEAR_ON_MANAGER_START
-    CLEAR_ON_ONROAD_TRANSITION
-    CLEAR_ON_OFFROAD_TRANSITION
-    ALL
-
-  cdef cppclass c_Params "Params":
-    c_Params(string) nogil
-    string get(string, bool) nogil
-    bool getBool(string, bool) nogil
-    int remove(string) nogil
-    int put(string, string) nogil
-    int putBool(string, bool) nogil
-    bool checkKey(string) nogil
-    string getParamPath(string) nogil
-    void clearAll(ParamKeyType)
-    vector[string] allKeys()
-
-
-def ensure_bytes(v):
-  return v.encode() if isinstance(v, str) else v;
-
-class UnknownKeyName(Exception):
-  pass
-
-cdef class Params:
-  cdef c_Params* p
-
-  def __cinit__(self, d=""):
-    cdef string path = <string>d.encode()
-    with nogil:
-      self.p = new c_Params(path)
-
-  def __dealloc__(self):
-    del self.p
-
-  def clear_all(self, tx_type=ParamKeyType.ALL):
-    self.p.clearAll(tx_type)
-
-  def check_key(self, key):
-    key = ensure_bytes(key)
-    if not self.p.checkKey(key):
-      raise UnknownKeyName(key)
-    return key
-
-  def get(self, key, bool block=False, encoding=None):
-    cdef string k = self.check_key(key)
-    cdef string val
-    with nogil:
-      val = self.p.get(k, block)
-
-    if val == b"":
-      if block:
-        # If we got no value while running in blocked mode
-        # it means we got an interrupt while waiting
-        raise KeyboardInterrupt
-      else:
-        return None
-
-    return val if encoding is None else val.decode(encoding)
-
-  def get_bool(self, key, bool block=False):
-    cdef string k = self.check_key(key)
-    cdef bool r
-    with nogil:
-      r = self.p.getBool(k, block)
-    return r
-
-  def put(self, key, dat):
-    """
-    Warning: This function blocks until the param is written to disk!
-    In very rare cases this can take over a second, and your code will hang.
-    Use the put_nonblocking helper function in time sensitive code, but
-    in general try to avoid writing params as much as possible.
-    """
-    cdef string k = self.check_key(key)
-    cdef string dat_bytes = ensure_bytes(dat)
-    with nogil:
-      self.p.put(k, dat_bytes)
-
-  def put_bool(self, key, bool val):
-    cdef string k = self.check_key(key)
-    with nogil:
-      self.p.putBool(k, val)
-
-  def remove(self, key):
-    cdef string k = self.check_key(key)
-    with nogil:
-      self.p.remove(k)
-
-  def get_param_path(self, key=""):
-    cdef string key_bytes = ensure_bytes(key)
-    return self.p.getParamPath(key_bytes).decode("utf-8")
-
-  def all_keys(self):
-    return self.p.allKeys()
-
-def put_nonblocking(key, val, d=""):
-  threading.Thread(target=lambda: Params(d).put(key, val)).start()
-
-def put_bool_nonblocking(key, bool val, d=""):
-  threading.Thread(target=lambda: Params(d).put_bool(key, val)).start()
@@ -1,34 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <string>
-
-#include "common/params.h"
-#include "common/util.h"
-
-class OpenpilotPrefix {
-public:
-  OpenpilotPrefix(std::string prefix = {}) {
-    if (prefix.empty()) {
-      prefix = util::random_string(15);
-    }
-    msgq_path = "/dev/shm/" + prefix;
-    bool ret = util::create_directories(msgq_path, 0777);
-    assert(ret);
-    setenv("OPENPILOT_PREFIX", prefix.c_str(), 1);
-  }
-
-  ~OpenpilotPrefix() {
-    auto param_path = Params().getParamPath();
-    if (util::file_exists(param_path)) {
-      std::string real_path = util::readlink(param_path);
-      system(util::string_format("rm %s -rf", real_path.c_str()).c_str());
-      unlink(param_path.c_str());
-    }
-    system(util::string_format("rm %s -rf", msgq_path.c_str()).c_str());
-    unsetenv("OPENPILOT_PREFIX");
-  }
-
-private:
-  std::string msgq_path;
-};
@@ -1,45 +0,0 @@
-import time
-
-class Profiler():
-  def __init__(self, enabled=False):
-    self.enabled = enabled
-    self.cp = {}
-    self.cp_ignored = []
-    self.iter = 0
-    self.start_time = time.time()
-    self.last_time = self.start_time
-    self.tot = 0.
-
-  def reset(self, enabled=False):
-    self.enabled = enabled
-    self.cp = {}
-    self.cp_ignored = []
-    self.iter = 0
-    self.start_time = time.time()
-    self.last_time = self.start_time
-
-  def checkpoint(self, name, ignore=False):
-    # ignore flag needed when benchmarking threads with ratekeeper
-    if not self.enabled:
-      return
-    tt = time.time()
-    if name not in self.cp:
-      self.cp[name] = 0.
-      if ignore:
-        self.cp_ignored.append(name)
-    self.cp[name] += tt - self.last_time
-    if not ignore:
-      self.tot += tt - self.last_time
-    self.last_time = tt
-
-  def display(self):
-    if not self.enabled:
-      return
-    self.iter += 1
-    print("******* Profiling %d *******" % self.iter)
-    for n, ms in sorted(self.cp.items(), key=lambda x: -x[1]):
-      if n in self.cp_ignored:
-        print("%30s: %9.2f  avg: %7.2f  percent: %3.0f   IGNORED" % (n, ms*1000.0, ms*1000.0/self.iter, ms/self.tot*100))
-      else:
-        print("%30s: %9.2f  avg: %7.2f  percent: %3.0f" % (n, ms*1000.0, ms*1000.0/self.iter, ms/self.tot*100))
-    print(f"Iter clock: {self.tot / self.iter:2.6f}   TOTAL: {self.tot:2.2f}")
@@ -1,95 +0,0 @@
-"""Utilities for reading real time clocks and keeping soft real time constraints."""
-import gc
-import os
-import time
-from collections import deque
-from typing import Optional, List, Union
-
-from setproctitle import getproctitle
-
-from openpilot.system.hardware import PC
-
-
-# time step for each process
-DT_CTRL = 0.01  # controlsd
-DT_MDL = 0.05  # model
-DT_TRML = 0.5  # thermald and manager
-DT_DMON = 0.05  # driver monitoring
-
-
-class Priority:
-  # CORE 2
-  # - modeld = 55
-  # - camerad = 54
-  CTRL_LOW = 51 # plannerd & radard
-
-  # CORE 3
-  # - boardd = 55
-  CTRL_HIGH = 53
-
-
-def set_realtime_priority(level: int) -> None:
-  if not PC:
-    os.sched_setscheduler(0, os.SCHED_FIFO, os.sched_param(level))
-
-
-def set_core_affinity(cores: List[int]) -> None:
-  if not PC:
-    os.sched_setaffinity(0, cores)
-
-
-def config_realtime_process(cores: Union[int, List[int]], priority: int) -> None:
-  gc.disable()
-  set_realtime_priority(priority)
-  c = cores if isinstance(cores, list) else [cores, ]
-  set_core_affinity(c)
-
-
-class Ratekeeper:
-  def __init__(self, rate: float, print_delay_threshold: Optional[float] = 0.0) -> None:
-    """Rate in Hz for ratekeeping. print_delay_threshold must be nonnegative."""
-    self._interval = 1. / rate
-    self._next_frame_time = time.monotonic() + self._interval
-    self._print_delay_threshold = print_delay_threshold
-    self._frame = 0
-    self._remaining = 0.0
-    self._process_name = getproctitle()
-    self._dts = deque([self._interval], maxlen=100)
-    self._last_monitor_time = time.monotonic()
-
-  @property
-  def frame(self) -> int:
-    return self._frame
-
-  @property
-  def remaining(self) -> float:
-    return self._remaining
-
-  @property
-  def lagging(self) -> bool:
-    avg_dt = sum(self._dts) / len(self._dts)
-    expected_dt = self._interval * (1 / 0.9)
-    return avg_dt > expected_dt
-
-  # Maintain loop rate by calling this at the end of each loop
-  def keep_time(self) -> bool:
-    lagged = self.monitor_time()
-    if self._remaining > 0:
-      time.sleep(self._remaining)
-    return lagged
-
-  # this only monitor the cumulative lag, but does not enforce a rate
-  def monitor_time(self) -> bool:
-    prev = self._last_monitor_time
-    self._last_monitor_time = time.monotonic()
-    self._dts.append(self._last_monitor_time - prev)
-
-    lagged = False
-    remaining = self._next_frame_time - time.monotonic()
-    self._next_frame_time += self._interval
-    if self._print_delay_threshold is not None and remaining < -self._print_delay_threshold:
-      print(f"{self._process_name} lagging by {-remaining * 1000:.2f} ms")
-      lagged = True
-    self._frame += 1
-    self._remaining = remaining
-    return lagged
@@ -1,52 +0,0 @@
-import os
-import subprocess
-from openpilot.common.basedir import BASEDIR
-
-
-class Spinner():
-  def __init__(self):
-    try:
-      self.spinner_proc = subprocess.Popen(["./spinner"],
-                                           stdin=subprocess.PIPE,
-                                           cwd=os.path.join(BASEDIR, "selfdrive", "ui"),
-                                           close_fds=True)
-    except OSError:
-      self.spinner_proc = None
-
-  def __enter__(self):
-    return self
-
-  def update(self, spinner_text: str):
-    if self.spinner_proc is not None:
-      self.spinner_proc.stdin.write(spinner_text.encode('utf8') + b"\n")
-      try:
-        self.spinner_proc.stdin.flush()
-      except BrokenPipeError:
-        pass
-
-  def update_progress(self, cur: float, total: float):
-    self.update(str(round(100 * cur / total)))
-
-  def close(self):
-    if self.spinner_proc is not None:
-      self.spinner_proc.kill()
-      try:
-        self.spinner_proc.communicate(timeout=2.)
-      except subprocess.TimeoutExpired:
-        print("WARNING: failed to kill spinner")
-      self.spinner_proc = None
-
-  def __del__(self):
-    self.close()
-
-  def __exit__(self, exc_type, exc_value, traceback):
-    self.close()
-
-
-if __name__ == "__main__":
-  import time
-  with Spinner() as s:
-    s.update("Spinner text")
-    time.sleep(5.0)
-  print("gone")
-  time.sleep(5.0)
@@ -1,47 +0,0 @@
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include "common/statlog.h"
-#include "common/util.h"
-
-#include <cstdarg>
-#include <stdio.h>
-#include <mutex>
-#include <zmq.h>
-
-class StatlogState : public LogState {
-  public:
-    StatlogState() : LogState("ipc:///tmp/stats") {}
-};
-
-static StatlogState s = {};
-
-static void log(const char* metric_type, const char* metric, const char* fmt, ...) {
-  std::lock_guard lk(s.lock);
-  if (!s.initialized) s.initialize();
-
-  char* value_buf = nullptr;
-  va_list args;
-  va_start(args, fmt);
-  int ret = vasprintf(&value_buf, fmt, args);
-  va_end(args);
-
-  if (ret > 0 && value_buf) {
-    char* line_buf = nullptr;
-    ret = asprintf(&line_buf, "%s:%s|%s", metric, value_buf, metric_type);
-    if (ret > 0 && line_buf) {
-      zmq_send(s.sock, line_buf, ret, ZMQ_NOBLOCK);
-      free(line_buf);
-    }
-    free(value_buf);
-  }
-}
-
-void statlog_log(const char* metric_type, const char* metric, int value) {
-  log(metric_type, metric, "%d", value);
-}
-
-void statlog_log(const char* metric_type, const char* metric, float value) {
-  log(metric_type, metric, "%f", value);
-}
@@ -1,10 +0,0 @@
-#pragma once
-
-#define STATLOG_GAUGE "g"
-#define STATLOG_SAMPLE "sa"
-
-void statlog_log(const char* metric_type, const char* metric, int value);
-void statlog_log(const char* metric_type, const char* metric, float value);
-
-#define statlog_gauge(metric, value) statlog_log(STATLOG_GAUGE, metric, value)
-#define statlog_sample(metric, value) statlog_log(STATLOG_SAMPLE, metric, value)
@@ -1,139 +0,0 @@
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include "common/swaglog.h"
-
-#include <cassert>
-#include <cstdarg>
-#include <cstring>
-#include <limits>
-#include <mutex>
-#include <string>
-
-#include <zmq.h>
-#include "third_party/json11/json11.hpp"
-
-#include "common/util.h"
-#include "common/version.h"
-#include "system/hardware/hw.h"
-
-class SwaglogState : public LogState {
- public:
-  SwaglogState() : LogState("ipc:///tmp/logmessage") {}
-
-  json11::Json::object ctx_j;
-
-  inline void initialize() {
-    ctx_j = json11::Json::object {};
-    print_level = CLOUDLOG_WARNING;
-    const char* print_lvl = getenv("LOGPRINT");
-    if (print_lvl) {
-      if (strcmp(print_lvl, "debug") == 0) {
-        print_level = CLOUDLOG_DEBUG;
-      } else if (strcmp(print_lvl, "info") == 0) {
-        print_level = CLOUDLOG_INFO;
-      } else if (strcmp(print_lvl, "warning") == 0) {
-        print_level = CLOUDLOG_WARNING;
-      }
-    }
-
-    // openpilot bindings
-    char* dongle_id = getenv("DONGLE_ID");
-    if (dongle_id) {
-      ctx_j["dongle_id"] = dongle_id;
-    }
-    char* daemon_name = getenv("MANAGER_DAEMON");
-    if (daemon_name) {
-      ctx_j["daemon"] = daemon_name;
-    }
-    ctx_j["version"] = COMMA_VERSION;
-    ctx_j["dirty"] = !getenv("CLEAN");
-
-    // device type
-    ctx_j["device"] = Hardware::get_name();
-    LogState::initialize();
-  }
-};
-
-static SwaglogState s = {};
-bool LOG_TIMESTAMPS = getenv("LOG_TIMESTAMPS");
-uint32_t NO_FRAME_ID = std::numeric_limits<uint32_t>::max();
-
-static void log(int levelnum, const char* filename, int lineno, const char* func, const char* msg, const std::string& log_s) {
-  if (levelnum >= s.print_level) {
-    printf("%s: %s\n", filename, msg);
-  }
-  zmq_send(s.sock, log_s.data(), log_s.length(), ZMQ_NOBLOCK);
-}
-
-static void cloudlog_common(int levelnum, const char* filename, int lineno, const char* func,
-                            char* msg_buf, const json11::Json::object &msg_j={}) {
-  std::lock_guard lk(s.lock);
-  if (!s.initialized) s.initialize();
-
-  json11::Json::object log_j = json11::Json::object {
-    {"ctx", s.ctx_j},
-    {"levelnum", levelnum},
-    {"filename", filename},
-    {"lineno", lineno},
-    {"funcname", func},
-    {"created", seconds_since_epoch()}
-  };
-  if (msg_j.empty()) {
-    log_j["msg"] = msg_buf;
-  } else {
-    log_j["msg"] = msg_j;
-  }
-
-  std::string log_s;
-  log_s += (char)levelnum;
-  ((json11::Json)log_j).dump(log_s);
-  log(levelnum, filename, lineno, func, msg_buf, log_s);
-
-  free(msg_buf);
-}
-
-void cloudlog_e(int levelnum, const char* filename, int lineno, const char* func,
-                const char* fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-  char* msg_buf = nullptr;
-  int ret = vasprintf(&msg_buf, fmt, args);
-  va_end(args);
-  if (ret <= 0 || !msg_buf) return;
-  cloudlog_common(levelnum, filename, lineno, func, msg_buf);
-}
-
-void cloudlog_t_common(int levelnum, const char* filename, int lineno, const char* func,
-                       uint32_t frame_id, const char* fmt, va_list args) {
-  if (!LOG_TIMESTAMPS) return;
-  char* msg_buf = nullptr;
-  int ret = vasprintf(&msg_buf, fmt, args);
-  if (ret <= 0 || !msg_buf) return;
-  json11::Json::object tspt_j = json11::Json::object{
-    {"event", msg_buf},
-    {"time", std::to_string(nanos_since_boot())}
-  };
-  if (frame_id < NO_FRAME_ID) {
-    tspt_j["frame_id"] = std::to_string(frame_id);
-  }
-  tspt_j = json11::Json::object{{"timestamp", tspt_j}};
-  cloudlog_common(levelnum, filename, lineno, func, msg_buf, tspt_j);
-}
-
-
-void cloudlog_te(int levelnum, const char* filename, int lineno, const char* func,
-                 const char* fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-  cloudlog_t_common(levelnum, filename, lineno, func, NO_FRAME_ID, fmt, args);
-  va_end(args);
-}
-void cloudlog_te(int levelnum, const char* filename, int lineno, const char* func,
-                 uint32_t frame_id, const char* fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-  cloudlog_t_common(levelnum, filename, lineno, func, frame_id, fmt, args);
-  va_end(args);
-}
@@ -1,27 +0,0 @@
-import os
-import unittest
-from uuid import uuid4
-
-from openpilot.common.file_helpers import atomic_write_on_fs_tmp
-from openpilot.common.file_helpers import atomic_write_in_dir
-
-
-class TestFileHelpers(unittest.TestCase):
-  def run_atomic_write_func(self, atomic_write_func):
-    path = f"/tmp/tmp{uuid4()}"
-    with atomic_write_func(path) as f:
-      f.write("test")
-
-    with open(path) as f:
-      self.assertEqual(f.read(), "test")
-    os.remove(path)
-
-  def test_atomic_write_on_fs_tmp(self):
-    self.run_atomic_write_func(atomic_write_on_fs_tmp)
-
-  def test_atomic_write_in_dir(self):
-    self.run_atomic_write_func(atomic_write_in_dir)
-
-
-if __name__ == "__main__":
-  unittest.main()
@@ -1,26 +0,0 @@
-import numpy as np
-import unittest
-
-from openpilot.common.numpy_fast import interp
-
-
-class InterpTest(unittest.TestCase):
-  def test_correctness_controls(self):
-    _A_CRUISE_MIN_BP = np.asarray([0., 5., 10., 20., 40.])
-    _A_CRUISE_MIN_V = np.asarray([-1.0, -.8, -.67, -.5, -.30])
-    v_ego_arr = [-1, -1e-12, 0, 4, 5, 6, 7, 10, 11, 15.2, 20, 21, 39,
-                 39.999999, 40, 41]
-
-    expected = np.interp(v_ego_arr, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V)
-    actual = interp(v_ego_arr, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V)
-
-    np.testing.assert_equal(actual, expected)
-
-    for v_ego in v_ego_arr:
-      expected = np.interp(v_ego, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V)
-      actual = interp(v_ego, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V)
-      np.testing.assert_equal(actual, expected)
-
-
-if __name__ == "__main__":
-  unittest.main()
@@ -1,120 +0,0 @@
-import os
-import threading
-import time
-import tempfile
-import shutil
-import uuid
-import unittest
-
-from openpilot.common.params import Params, ParamKeyType, UnknownKeyName, put_nonblocking, put_bool_nonblocking
-
-class TestParams(unittest.TestCase):
-  def setUp(self):
-    self.tmpdir = tempfile.mkdtemp()
-    print("using", self.tmpdir)
-    self.params = Params(self.tmpdir)
-
-  def tearDown(self):
-    shutil.rmtree(self.tmpdir)
-
-  def test_params_put_and_get(self):
-    self.params.put("DongleId", "cb38263377b873ee")
-    assert self.params.get("DongleId") == b"cb38263377b873ee"
-
-  def test_params_non_ascii(self):
-    st = b"\xe1\x90\xff"
-    self.params.put("CarParams", st)
-    assert self.params.get("CarParams") == st
-
-  def test_params_get_cleared_manager_start(self):
-    self.params.put("CarParams", "test")
-    self.params.put("DongleId", "cb38263377b873ee")
-    assert self.params.get("CarParams") == b"test"
-
-    undefined_param = self.params.get_param_path(uuid.uuid4().hex)
-    with open(undefined_param, "w") as f:
-      f.write("test")
-    assert os.path.isfile(undefined_param)
-
-    self.params.clear_all(ParamKeyType.CLEAR_ON_MANAGER_START)
-    assert self.params.get("CarParams") is None
-    assert self.params.get("DongleId") is not None
-    assert not os.path.isfile(undefined_param)
-
-  def test_params_two_things(self):
-    self.params.put("DongleId", "bob")
-    self.params.put("AthenadPid", "123")
-    assert self.params.get("DongleId") == b"bob"
-    assert self.params.get("AthenadPid") == b"123"
-
-  def test_params_get_block(self):
-    def _delayed_writer():
-      time.sleep(0.1)
-      self.params.put("CarParams", "test")
-    threading.Thread(target=_delayed_writer).start()
-    assert self.params.get("CarParams") is None
-    assert self.params.get("CarParams", True) == b"test"
-
-  def test_params_unknown_key_fails(self):
-    with self.assertRaises(UnknownKeyName):
-      self.params.get("swag")
-
-    with self.assertRaises(UnknownKeyName):
-      self.params.get_bool("swag")
-
-    with self.assertRaises(UnknownKeyName):
-      self.params.put("swag", "abc")
-
-    with self.assertRaises(UnknownKeyName):
-      self.params.put_bool("swag", True)
-
-  def test_remove_not_there(self):
-    assert self.params.get("CarParams") is None
-    self.params.remove("CarParams")
-    assert self.params.get("CarParams") is None
-
-  def test_get_bool(self):
-    self.params.remove("IsMetric")
-    self.assertFalse(self.params.get_bool("IsMetric"))
-
-    self.params.put_bool("IsMetric", True)
-    self.assertTrue(self.params.get_bool("IsMetric"))
-
-    self.params.put_bool("IsMetric", False)
-    self.assertFalse(self.params.get_bool("IsMetric"))
-
-    self.params.put("IsMetric", "1")
-    self.assertTrue(self.params.get_bool("IsMetric"))
-
-    self.params.put("IsMetric", "0")
-    self.assertFalse(self.params.get_bool("IsMetric"))
-
-  def test_put_non_blocking_with_get_block(self):
-    q = Params(self.tmpdir)
-    def _delayed_writer():
-      time.sleep(0.1)
-      put_nonblocking("CarParams", "test", self.tmpdir)
-    threading.Thread(target=_delayed_writer).start()
-    assert q.get("CarParams") is None
-    assert q.get("CarParams", True) == b"test"
-
-  def test_put_bool_non_blocking_with_get_block(self):
-    q = Params(self.tmpdir)
-    def _delayed_writer():
-      time.sleep(0.1)
-      put_bool_nonblocking("CarParams", True, self.tmpdir)
-    threading.Thread(target=_delayed_writer).start()
-    assert q.get("CarParams") is None
-    assert q.get("CarParams", True) == b"1"
-
-  def test_params_all_keys(self):
-    keys = Params().all_keys()
-
-    # sanity checks
-    assert len(keys) > 20
-    assert len(keys) == len(set(keys))
-    assert b"CarParams" in keys
-
-
-if __name__ == "__main__":
-  unittest.main()
@@ -1,16 +0,0 @@
-#include "catch2/catch.hpp"
-#include "common/ratekeeper.h"
-#include "common/timing.h"
-#include "common/util.h"
-
-TEST_CASE("RateKeeper") {
-  float freq = GENERATE(10, 50, 100);
-  RateKeeper rk("Test RateKeeper", freq);
-  for (int i = 0; i < freq; ++i) {
-    double begin = seconds_since_boot();
-    util::sleep_for(util::random_int(0, 1000.0 / freq - 1));
-    bool lagged = rk.keepTime();
-    REQUIRE(std::abs(seconds_since_boot() - begin - (1 / freq)) < 1e-3);
-    REQUIRE(lagged == false);
-  }
-}
@@ -1,6 +0,0 @@
-import datetime
-
-MIN_DATE = datetime.datetime(year=2023, month=6, day=1)
-
-def system_time_valid():
-  return datetime.datetime.now() > MIN_DATE
@@ -1,2 +0,0 @@
-transformations
-transformations.cpp
@@ -1,70 +0,0 @@
-
-Reference Frames
------
-Many reference frames are used throughout. This
-folder contains all helper functions needed to
-transform between them. Generally this is done
-by generating a rotation matrix and multiplying.
-
-
-| Name | [x, y, z] | Units | Notes |
-| :-------------: |:-------------:| :-----:| :----: |
-| Geodetic | [Latitude, Longitude, Altitude] | geodetic coordinates | Sometimes used as [lon, lat, alt], avoid this frame. |
-| ECEF | [x, y, z] | meters | We use **ITRF14 (IGS14)**, NOT NAD83. <br> This is the global Mesh3D frame. |
-| NED | [North, East, Down] | meters | Relative to earth's surface, useful for vizualizing. |
-| Device | [Forward, Right, Down] | meters | This is the Mesh3D local frame. <br> Relative to camera, **not imu.** <br> ![img](http://upload.wikimedia.org/wikipedia/commons/thumb/2/2f/RPY_angles_of_airplanes.png/440px-RPY_angles_of_airplanes.png)|
-| Calibrated | [Forward, Right, Down] | meters | This is the frame the model outputs are in. <br> More details below. <br>|
-| Car | [Forward, Right, Down] | meters | This is useful for estimating position of points on the road. <br> More details below. <br>|
-| View | [Right, Down, Forward] | meters | Like device frame, but according to camera conventions. |
-| Camera | [u, v, focal] | pixels | Like view frame, but 2d on the camera image.|
-| Normalized Camera | [u / focal, v / focal, 1] | / | |
-| Model | [u, v, focal] | pixels | The sampled rectangle of the full camera frame the model uses. |
-| Normalized Model | [u / focal, v / focal, 1] | / | |
-
-
-
-
-Orientation Conventions
------
-Quaternions, rotation matrices and euler angles are three
-equivalent representations of orientation and all three are
-used throughout the code base.
-
-For euler angles the preferred convention is [roll, pitch, yaw]
-which corresponds to rotations around the [x, y, z] axes. All
-euler angles should always be in radians or radians/s unless
-for plotting or display purposes. For quaternions the hamilton
-notations is preferred which is [q<sub>w</sub>, q<sub>x</sub>, q<sub>y</sub>, q<sub>z</sub>]. All quaternions
-should always be normalized with a strictly positive q<sub>w</sub>. **These
-quaternions are a unique representation of orientation whereas euler angles
-or rotation matrices are not.**
-
-To rotate from one frame into another with euler angles the
-convention is to rotate around roll, then pitch and then yaw,
-while rotating around the rotated axes, not the original axes.
-
-
-Car frame
------
-Device frame is aligned with the road-facing camera used by openpilot. However, when controlling the vehicle it is helpful to think in a reference frame aligned with the vehicle. These two reference frames can be different.
-
-The orientation of car frame is defined to be aligned with the car's direction of travel and the road plane when the vehicle is driving on a flat road and not turning. The origin of car frame is defined to be directly below device frame (in car frame), such that it is on the road plane. The position and orientation of this frame is not necessarily always aligned with the direction of travel or the road plane due to suspension movements and other effects.
-
-
-Calibrated frame
------
-It is helpful for openpilot's driving model to take in images that look similar when mounted differently in different cars. To achieve this we "calibrate" the images by transforming it into calibrated frame. Calibrated frame is defined to be aligned with car frame in pitch and yaw, and aligned with device frame in roll. It also has the same origin as device frame.
-
-
-Example
------
-To transform global Mesh3D positions and orientations (positions_ecef, quats_ecef) into the local frame described by the
-first position and orientation from Mesh3D one would do:
-```
-ecef_from_local = rot_from_quat(quats_ecef[0])
-local_from_ecef = ecef_from_local.T
-positions_local = np.einsum('ij,kj->ki', local_from_ecef, postions_ecef - positions_ecef[0])
-rotations_global = rot_from_quat(quats_ecef)
-rotations_local = np.einsum('ij,kjl->kil', local_from_ecef, rotations_global)
-eulers_local = euler_from_rot(rotations_local)
-```
@@ -1,5 +0,0 @@
-Import('env', 'envCython')
-
-transformations = env.Library('transformations', ['orientation.cc', 'coordinates.cc'])
-transformations_python = envCython.Program('transformations.so', 'transformations.pyx')
-Export('transformations', 'transformations_python')
@@ -1,160 +0,0 @@
-import numpy as np
-
-import openpilot.common.transformations.orientation as orient
-
-## -- hardcoded hardware params --
-eon_f_focal_length = 910.0
-eon_d_focal_length = 650.0
-tici_f_focal_length = 2648.0
-tici_e_focal_length = tici_d_focal_length = 567.0 # probably wrong? magnification is not consistent across frame
-
-eon_f_frame_size = (1164, 874)
-eon_d_frame_size = (816, 612)
-tici_f_frame_size = tici_e_frame_size = tici_d_frame_size = (1928, 1208)
-
-# aka 'K' aka camera_frame_from_view_frame
-eon_fcam_intrinsics = np.array([
-  [eon_f_focal_length,  0.0,  float(eon_f_frame_size[0])/2],
-  [0.0,  eon_f_focal_length,  float(eon_f_frame_size[1])/2],
-  [0.0,  0.0,                                          1.0]])
-eon_intrinsics = eon_fcam_intrinsics # xx
-
-eon_dcam_intrinsics = np.array([
-  [eon_d_focal_length,  0.0,  float(eon_d_frame_size[0])/2],
-  [0.0,  eon_d_focal_length,  float(eon_d_frame_size[1])/2],
-  [0.0,  0.0,                                          1.0]])
-
-tici_fcam_intrinsics = np.array([
-  [tici_f_focal_length,  0.0,  float(tici_f_frame_size[0])/2],
-  [0.0,  tici_f_focal_length,  float(tici_f_frame_size[1])/2],
-  [0.0,  0.0,                                            1.0]])
-
-tici_dcam_intrinsics = np.array([
-  [tici_d_focal_length,  0.0,  float(tici_d_frame_size[0])/2],
-  [0.0,  tici_d_focal_length,  float(tici_d_frame_size[1])/2],
-  [0.0,  0.0,                                            1.0]])
-
-tici_ecam_intrinsics = tici_dcam_intrinsics
-
-# aka 'K_inv' aka view_frame_from_camera_frame
-eon_fcam_intrinsics_inv = np.linalg.inv(eon_fcam_intrinsics)
-eon_intrinsics_inv = eon_fcam_intrinsics_inv # xx
-
-tici_fcam_intrinsics_inv = np.linalg.inv(tici_fcam_intrinsics)
-tici_ecam_intrinsics_inv = np.linalg.inv(tici_ecam_intrinsics)
-
-
-FULL_FRAME_SIZE = tici_f_frame_size
-FOCAL = tici_f_focal_length
-fcam_intrinsics = tici_fcam_intrinsics
-
-W, H = FULL_FRAME_SIZE[0], FULL_FRAME_SIZE[1]
-
-
-# device/mesh : x->forward, y-> right, z->down
-# view : x->right, y->down, z->forward
-device_frame_from_view_frame = np.array([
-  [ 0.,  0.,  1.],
-  [ 1.,  0.,  0.],
-  [ 0.,  1.,  0.]
-])
-view_frame_from_device_frame = device_frame_from_view_frame.T
-
-
-# aka 'extrinsic_matrix'
-# road : x->forward, y -> left, z->up
-def get_view_frame_from_road_frame(roll, pitch, yaw, height):
-  device_from_road = orient.rot_from_euler([roll, pitch, yaw]).dot(np.diag([1, -1, -1]))
-  view_from_road = view_frame_from_device_frame.dot(device_from_road)
-  return np.hstack((view_from_road, [[0], [height], [0]]))
-
-
-
-# aka 'extrinsic_matrix'
-def get_view_frame_from_calib_frame(roll, pitch, yaw, height):
-  device_from_calib= orient.rot_from_euler([roll, pitch, yaw])
-  view_from_calib = view_frame_from_device_frame.dot(device_from_calib)
-  return np.hstack((view_from_calib, [[0], [height], [0]]))
-
-
-def vp_from_ke(m):
-  """
-  Computes the vanishing point from the product of the intrinsic and extrinsic
-  matrices C = KE.
-
-  The vanishing point is defined as lim x->infinity C (x, 0, 0, 1).T
-  """
-  return (m[0, 0]/m[2, 0], m[1, 0]/m[2, 0])
-
-
-def roll_from_ke(m):
-  # note: different from calibration.h/RollAnglefromKE: i think that one's just wrong
-  return np.arctan2(-(m[1, 0] - m[1, 1] * m[2, 0] / m[2, 1]),
-                    -(m[0, 0] - m[0, 1] * m[2, 0] / m[2, 1]))
-
-
-def normalize(img_pts, intrinsics=fcam_intrinsics):
-  # normalizes image coordinates
-  # accepts single pt or array of pts
-  intrinsics_inv = np.linalg.inv(intrinsics)
-  img_pts = np.array(img_pts)
-  input_shape = img_pts.shape
-  img_pts = np.atleast_2d(img_pts)
-  img_pts = np.hstack((img_pts, np.ones((img_pts.shape[0], 1))))
-  img_pts_normalized = img_pts.dot(intrinsics_inv.T)
-  img_pts_normalized[(img_pts < 0).any(axis=1)] = np.nan
-  return img_pts_normalized[:, :2].reshape(input_shape)
-
-
-def denormalize(img_pts, intrinsics=fcam_intrinsics, width=np.inf, height=np.inf):
-  # denormalizes image coordinates
-  # accepts single pt or array of pts
-  img_pts = np.array(img_pts)
-  input_shape = img_pts.shape
-  img_pts = np.atleast_2d(img_pts)
-  img_pts = np.hstack((img_pts, np.ones((img_pts.shape[0], 1), dtype=img_pts.dtype)))
-  img_pts_denormalized = img_pts.dot(intrinsics.T)
-  if np.isfinite(width):
-    img_pts_denormalized[img_pts_denormalized[:, 0] > width] = np.nan
-    img_pts_denormalized[img_pts_denormalized[:, 0] < 0] = np.nan
-  if np.isfinite(height):
-    img_pts_denormalized[img_pts_denormalized[:, 1] > height] = np.nan
-    img_pts_denormalized[img_pts_denormalized[:, 1] < 0] = np.nan
-  return img_pts_denormalized[:, :2].reshape(input_shape)
-
-
-def get_calib_from_vp(vp, intrinsics=fcam_intrinsics):
-  vp_norm = normalize(vp, intrinsics)
-  yaw_calib = np.arctan(vp_norm[0])
-  pitch_calib = -np.arctan(vp_norm[1]*np.cos(yaw_calib))
-  roll_calib = 0
-  return roll_calib, pitch_calib, yaw_calib
-
-
-def device_from_ecef(pos_ecef, orientation_ecef, pt_ecef):
-  # device from ecef frame
-  # device frame is x -> forward, y-> right, z -> down
-  # accepts single pt or array of pts
-  input_shape = pt_ecef.shape
-  pt_ecef = np.atleast_2d(pt_ecef)
-  ecef_from_device_rot = orient.rotations_from_quats(orientation_ecef)
-  device_from_ecef_rot = ecef_from_device_rot.T
-  pt_ecef_rel = pt_ecef - pos_ecef
-  pt_device = np.einsum('jk,ik->ij', device_from_ecef_rot, pt_ecef_rel)
-  return pt_device.reshape(input_shape)
-
-
-def img_from_device(pt_device):
-  # img coordinates from pts in device frame
-  # first transforms to view frame, then to img coords
-  # accepts single pt or array of pts
-  input_shape = pt_device.shape
-  pt_device = np.atleast_2d(pt_device)
-  pt_view = np.einsum('jk,ik->ij', view_frame_from_device_frame, pt_device)
-
-  # This function should never return negative depths
-  pt_view[pt_view[:, 2] < 0] = np.nan
-
-  pt_img = pt_view/pt_view[:, 2:3]
-  return pt_img.reshape(input_shape)[:, :2]
-
@@ -1,43 +0,0 @@
-#pragma once
-
-#include <eigen3/Eigen/Dense>
-
-#define DEG2RAD(x) ((x) * M_PI / 180.0)
-#define RAD2DEG(x) ((x) * 180.0 / M_PI)
-
-struct ECEF {
-  double x, y, z;
-  Eigen::Vector3d to_vector(){
-    return Eigen::Vector3d(x, y, z);
-  }
-};
-
-struct NED {
-  double n, e, d;
-  Eigen::Vector3d to_vector(){
-    return Eigen::Vector3d(n, e, d);
-  }
-};
-
-struct Geodetic {
-  double lat, lon, alt;
-  bool radians=false;
-};
-
-ECEF geodetic2ecef(Geodetic g);
-Geodetic ecef2geodetic(ECEF e);
-
-class LocalCoord {
-public:
-  Eigen::Matrix3d ned2ecef_matrix;
-  Eigen::Matrix3d ecef2ned_matrix;
-  Eigen::Vector3d init_ecef;
-  LocalCoord(Geodetic g, ECEF e);
-  LocalCoord(Geodetic g) : LocalCoord(g, ::geodetic2ecef(g)) {}
-  LocalCoord(ECEF e) : LocalCoord(::ecef2geodetic(e), e) {}
-
-  NED ecef2ned(ECEF e);
-  ECEF ned2ecef(NED n);
-  NED geodetic2ned(Geodetic g);
-  Geodetic ned2geodetic(NED n);
-};
@@ -1,78 +0,0 @@
-import numpy as np
-
-from openpilot.common.transformations.orientation import rot_from_euler
-from openpilot.common.transformations.camera import (
-  FULL_FRAME_SIZE, get_view_frame_from_calib_frame, view_frame_from_device_frame,
-  eon_fcam_intrinsics, tici_ecam_intrinsics, tici_fcam_intrinsics)
-
-# segnet
-SEGNET_SIZE = (512, 384)
-
-def get_segnet_frame_from_camera_frame(segnet_size=SEGNET_SIZE, full_frame_size=FULL_FRAME_SIZE):
-  return np.array([[float(segnet_size[0]) / full_frame_size[0],  0.0],
-                   [0.0,  float(segnet_size[1]) / full_frame_size[1]]])
-segnet_frame_from_camera_frame = get_segnet_frame_from_camera_frame() # xx
-
-
-# MED model
-MEDMODEL_INPUT_SIZE = (512, 256)
-MEDMODEL_YUV_SIZE = (MEDMODEL_INPUT_SIZE[0], MEDMODEL_INPUT_SIZE[1] * 3 // 2)
-MEDMODEL_CY = 47.6
-
-medmodel_fl = 910.0
-medmodel_intrinsics = np.array([
-  [medmodel_fl,  0.0,  0.5 * MEDMODEL_INPUT_SIZE[0]],
-  [0.0,  medmodel_fl,                   MEDMODEL_CY],
-  [0.0,  0.0,                                   1.0]])
-
-
-# BIG model
-BIGMODEL_INPUT_SIZE = (1024, 512)
-BIGMODEL_YUV_SIZE = (BIGMODEL_INPUT_SIZE[0], BIGMODEL_INPUT_SIZE[1] * 3 // 2)
-
-bigmodel_fl = 910.0
-bigmodel_intrinsics = np.array([
-  [bigmodel_fl,  0.0,  0.5 * BIGMODEL_INPUT_SIZE[0]],
-  [0.0,  bigmodel_fl,             256 + MEDMODEL_CY],
-  [0.0,  0.0,                                   1.0]])
-
-
-# SBIG model (big model with the size of small model)
-SBIGMODEL_INPUT_SIZE = (512, 256)
-SBIGMODEL_YUV_SIZE = (SBIGMODEL_INPUT_SIZE[0], SBIGMODEL_INPUT_SIZE[1] * 3 // 2)
-
-sbigmodel_fl = 455.0
-sbigmodel_intrinsics = np.array([
-  [sbigmodel_fl,  0.0,  0.5 * SBIGMODEL_INPUT_SIZE[0]],
-  [0.0,  sbigmodel_fl,      0.5 * (256 + MEDMODEL_CY)],
-  [0.0,  0.0,                                     1.0]])
-
-bigmodel_frame_from_calib_frame = np.dot(bigmodel_intrinsics,
-  get_view_frame_from_calib_frame(0, 0, 0, 0))
-
-
-sbigmodel_frame_from_calib_frame = np.dot(sbigmodel_intrinsics,
-  get_view_frame_from_calib_frame(0, 0, 0, 0))
-
-medmodel_frame_from_calib_frame = np.dot(medmodel_intrinsics,
-  get_view_frame_from_calib_frame(0, 0, 0, 0))
-
-medmodel_frame_from_bigmodel_frame = np.dot(medmodel_intrinsics, np.linalg.inv(bigmodel_intrinsics))
-
-calib_from_medmodel = np.linalg.inv(medmodel_frame_from_calib_frame[:, :3])
-calib_from_sbigmodel = np.linalg.inv(sbigmodel_frame_from_calib_frame[:, :3])
-
-# This function is verified to give similar results to xx.uncommon.utils.transform_img
-def get_warp_matrix(device_from_calib_euler: np.ndarray, wide_camera: bool = False, bigmodel_frame: bool = False, tici: bool = True) -> np.ndarray:
-  if tici and wide_camera:
-    cam_intrinsics = tici_ecam_intrinsics
-  elif tici:
-    cam_intrinsics = tici_fcam_intrinsics
-  else:
-    cam_intrinsics = eon_fcam_intrinsics
-
-  calib_from_model = calib_from_sbigmodel if bigmodel_frame else calib_from_medmodel
-  device_from_calib = rot_from_euler(device_from_calib_euler)
-  camera_from_calib = cam_intrinsics @ view_frame_from_device_frame @ device_from_calib
-  warp_matrix: np.ndarray = camera_from_calib @ calib_from_model
-  return warp_matrix
@@ -1,17 +0,0 @@
-#pragma once
-#include <eigen3/Eigen/Dense>
-#include "common/transformations/coordinates.hpp"
-
-
-Eigen::Quaterniond ensure_unique(Eigen::Quaterniond quat);
-
-Eigen::Quaterniond euler2quat(Eigen::Vector3d euler);
-Eigen::Vector3d quat2euler(Eigen::Quaterniond quat);
-Eigen::Matrix3d quat2rot(Eigen::Quaterniond quat);
-Eigen::Quaterniond rot2quat(const Eigen::Matrix3d &rot);
-Eigen::Matrix3d euler2rot(Eigen::Vector3d euler);
-Eigen::Vector3d rot2euler(const Eigen::Matrix3d &rot);
-Eigen::Matrix3d rot_matrix(double roll, double pitch, double yaw);
-Eigen::Matrix3d rot(Eigen::Vector3d axis, double angle);
-Eigen::Vector3d ecef_euler_from_ned(ECEF ecef_init, Eigen::Vector3d ned_pose);
-Eigen::Vector3d ned_euler_from_ecef(ECEF ecef_init, Eigen::Vector3d ecef_pose);
@@ -1,72 +0,0 @@
-#cython: language_level=3
-from libcpp cimport bool
-
-cdef extern from "orientation.cc":
-  pass
-
-cdef extern from "orientation.hpp":
-  cdef cppclass Quaternion "Eigen::Quaterniond":
-    Quaternion()
-    Quaternion(double, double, double, double)
-    double w()
-    double x()
-    double y()
-    double z()
-
-  cdef cppclass Vector3 "Eigen::Vector3d":
-    Vector3()
-    Vector3(double, double, double)
-    double operator()(int)
-
-  cdef cppclass Matrix3 "Eigen::Matrix3d":
-    Matrix3()
-    Matrix3(double*)
-
-    double operator()(int, int)
-
-  Quaternion euler2quat(Vector3)
-  Vector3 quat2euler(Quaternion)
-  Matrix3 quat2rot(Quaternion)
-  Quaternion rot2quat(Matrix3)
-  Vector3 rot2euler(Matrix3)
-  Matrix3 euler2rot(Vector3)
-  Matrix3 rot_matrix(double, double, double)
-  Vector3 ecef_euler_from_ned(ECEF, Vector3)
-  Vector3 ned_euler_from_ecef(ECEF, Vector3)
-
-
-cdef extern from "coordinates.cc":
-  cdef struct ECEF:
-    double x
-    double y
-    double z
-
-  cdef struct NED:
-    double n
-    double e
-    double d
-
-  cdef struct Geodetic:
-    double lat
-    double lon
-    double alt
-    bool radians
-
-  ECEF geodetic2ecef(Geodetic)
-  Geodetic ecef2geodetic(ECEF)
-
-  cdef cppclass LocalCoord_c "LocalCoord":
-    Matrix3 ned2ecef_matrix
-    Matrix3 ecef2ned_matrix
-
-    LocalCoord_c(Geodetic, ECEF)
-    LocalCoord_c(Geodetic)
-    LocalCoord_c(ECEF)
-
-    NED ecef2ned(ECEF)
-    ECEF ned2ecef(NED)
-    NED geodetic2ned(Geodetic)
-    Geodetic ned2geodetic(NED)
-
-cdef extern from "coordinates.hpp":
-  pass
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
github-actions[bot]	7207274595	sunnypilot v2026.07.20-4574 version: sunnypilot v2026.002.000 (feature-branch) date: 2026-07-20T03:45:01 master commit: `560cde61ae`	2026-07-20 03:45:02 +00:00
github-actions[bot]	2f96614632	sunnypilot v2026.07.20-4574 release	2026-07-20 03:44:51 +00:00
@@ -1 +1 @@
 .11.4
 .12.13