.clang-tidy

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

.dir-locals.el

@@ -0,0 +1,3 @@
+((c++-mode (flycheck-gcc-language-standard . "c++11")
+           (flycheck-clang-language-standard . "c++11")
+           ))

.dockerignore

@@ -0,0 +1,38 @@
+**/.git
+.DS_Store
+*.dylib
+*.DSYM
+*.d
+*.pyc
+*.pyo
+.*.swp
+.*.swo
+.*.un~
+*.tmp
+*.o
+*.o-*
+*.os
+*.os-*
+*.so
+*.a
+
+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

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[{*.py, *.pyx, *.pxd}]
+charset = utf-8
+indent_style = space
+indent_size = 2

.gitattributes

@@ -0,0 +1,2 @@
+*.dlc filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,58 @@
+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.
+          * 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: dropdown
+    id: hw
+    attributes:
+      label: What hardware does this issue affect?
+      multiple: true
+      options:
+        - comma three
+        - comma two
+        - EON Gold
+    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
+

.github/ISSUE_TEMPLATE/car_bug_report.yml

@@ -0,0 +1,65 @@
+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: dropdown
+    id: hw
+    attributes:
+      label: What hardware does this issue affect?
+      multiple: true
+      options:
+        - comma three
+        - comma two
+        - EON Gold
+    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
+

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Discussions
+    url: https://github.com/commaai/openpilot/discussions
+    about: For questions and 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

.github/ISSUE_TEMPLATE/enhancement.md

@@ -0,0 +1,8 @@
+---
+name: Enhancement
+about: For openpilot enhancement suggestions
+title: ''
+labels: 'enhancement'
+assignees: ''
+---
+

.github/ISSUE_TEMPLATE/pc_bug_report.yml

@@ -0,0 +1,42 @@
+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
+

.github/PULL_REQUEST_TEMPLATE/bugfix.md

@@ -0,0 +1,15 @@
+---
+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. -->

.github/PULL_REQUEST_TEMPLATE/car_bugfix.md

@@ -0,0 +1,19 @@
+---
+name: Car Bug fix
+about: For vehicle/brand specifc 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]

.github/PULL_REQUEST_TEMPLATE/car_port.md

@@ -0,0 +1,15 @@
+---
+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):

.github/PULL_REQUEST_TEMPLATE/fingerprint.md

@@ -0,0 +1,11 @@
+---
+name: Fingerprint
+about: For adding fingerprints to existing cars
+title: ''
+labels: 'fingerprint'
+assignees: ''
+---
+
+Discord username: []
+
+Route: []

.github/PULL_REQUEST_TEMPLATE/refactor.md

@@ -0,0 +1,15 @@
+---
+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. -->

.github/PULL_REQUEST_TEMPLATE/tuning.md

@@ -0,0 +1,32 @@
+---
+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
+
+-->

.github/pull_request_template.md

@@ -0,0 +1,38 @@
+<!-- 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.)
+
+-->

.github/workflows/prebuilt.yaml

@@ -0,0 +1,42 @@
+name: prebuilt
+on:
+  schedule:
+    - cron: '0 * * * *'
+
+env:
+  BASE_IMAGE: openpilot-base
+  DOCKER_REGISTRY: ghcr.io/commaai
+
+  DOCKER_LOGIN: docker login ghcr.io -u adeebshihadeh -p ${{ secrets.CONTAINER_TOKEN }}
+  BUILD: |
+      docker pull $(grep -iohP '(?<=^from)\s+\S+' Dockerfile.openpilot_base) || true
+      docker pull $DOCKER_REGISTRY/$BASE_IMAGE:latest || true
+      docker build --cache-from $DOCKER_REGISTRY/$BASE_IMAGE:latest -t $DOCKER_REGISTRY/$BASE_IMAGE:latest -t $BASE_IMAGE:latest -f Dockerfile.openpilot_base .
+
+jobs:
+  build_prebuilt:
+    name: build prebuilt
+    runs-on: ubuntu-20.04
+    timeout-minutes: 60
+    if: github.repository == 'commaai/openpilot'
+    env:
+      IMAGE_NAME: openpilot-prebuilt
+    steps:
+    - name: Wait for green check mark
+      uses: lewagon/wait-on-check-action@v0.2
+      with:
+        ref: master
+        wait-interval: 30
+        running-workflow-name: 'build prebuilt'
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Build Docker image
+      run: |
+        eval "$BUILD"
+        docker pull $DOCKER_REGISTRY/$IMAGE_NAME:latest || true
+        docker build --cache-from $DOCKER_REGISTRY/$IMAGE_NAME:latest -t $DOCKER_REGISTRY/$IMAGE_NAME:latest -f Dockerfile.openpilot .
+    - name: Push to container registry
+      run: |
+        $DOCKER_LOGIN
+        docker push $DOCKER_REGISTRY/$IMAGE_NAME:latest

.github/workflows/selfdrive_tests.yaml

@@ -0,0 +1,431 @@
+name: selfdrive
+on:
+  push:
+    branches-ignore:
+      - 'testing-closet*'
+  pull_request:
+
+env:
+  BASE_IMAGE: openpilot-base
+  DOCKER_REGISTRY: ghcr.io/commaai
+
+  DOCKER_LOGIN: docker login ghcr.io -u adeebshihadeh -p ${{ secrets.CONTAINER_TOKEN }}
+  BUILD: |
+      docker pull $(grep -iohP '(?<=^from)\s+\S+' Dockerfile.openpilot_base) || true
+      docker pull $DOCKER_REGISTRY/$BASE_IMAGE:latest || true
+      docker build --cache-from $DOCKER_REGISTRY/$BASE_IMAGE:latest -t $DOCKER_REGISTRY/$BASE_IMAGE:latest -t $BASE_IMAGE:latest -f Dockerfile.openpilot_base .
+
+  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 /tmp/scons_cache:/tmp/scons_cache -v /tmp/comma_download_cache:/tmp/comma_download_cache $BASE_IMAGE /bin/sh -c
+  UNIT_TEST: coverage run --append -m unittest discover
+
+jobs:
+  # TODO: once actions/cache supports read only mode, use the cache for all jobs
+  build_release:
+    name: build release
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    env:
+      STRIPPED_DIR: tmppilot
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Check submodules
+      if: github.ref == 'refs/heads/master' && github.repository == 'commaai/openpilot'
+      run: release/check-submodules.sh
+    - name: Cache scons
+      id: scons-cache
+      # TODO: Change the version to the released version when https://github.com/actions/cache/pull/489 (or 571) is merged.
+      uses: actions/cache@03e00da99d75a2204924908e1cca7902cafce66b
+      env:
+        CACHE_SKIP_SAVE: true
+      with:
+        path: /tmp/scons_cache
+        key: scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+        restore-keys: |
+          scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+          scons-
+    - name: Strip non-release files
+      run: |
+        mkdir $STRIPPED_DIR
+        cp -pR --parents $(cat release/files_common) $STRIPPED_DIR
+        cp -pR --parents $(cat release/files_tici) $STRIPPED_DIR
+        cp -pR --parents $(cat release/files_pc) $STRIPPED_DIR
+        cp Dockerfile.openpilot_base $STRIPPED_DIR
+
+        # need this to build on x86
+        cp -pR --parents third_party/libyuv third_party/snpe selfdrive/modeld/runners $STRIPPED_DIR
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Build openpilot and run checks
+      run: |
+          cd $STRIPPED_DIR
+          ${{ env.RUN }} "CI=1 python selfdrive/manager/build.py && \
+                          python -m unittest discover selfdrive/car"
+    - name: Cleanup scons cache
+      run: |
+          cd $STRIPPED_DIR
+          ${{ env.RUN }} "scons -j$(nproc) && \
+                          rm -rf /tmp/scons_cache/* && \
+                          scons -j$(nproc) --cache-populate"
+
+  #build_mac:
+  #  name: build macos
+  #  runs-on: macos-latest
+  #  timeout-minutes: 60
+  #  steps:
+  #  - uses: actions/checkout@v2
+  #    with:
+  #      submodules: true
+  #  - name: Determine pre-existing Homebrew packages
+  #    if: steps.dependency-cache.outputs.cache-hit != 'true'
+  #    run: |
+  #      echo 'EXISTING_CELLAR<<EOF' >> $GITHUB_ENV
+  #      ls -1 /usr/local/Cellar >> $GITHUB_ENV
+  #      echo 'EOF' >> $GITHUB_ENV
+  #  - name: Cache dependencies
+  #    id: dependency-cache
+  #    uses: actions/cache@v2
+  #    with:
+  #      path: |
+  #        ~/.pyenv
+  #        ~/.local/share/virtualenvs/
+  #        /usr/local/Cellar
+  #        ~/github_brew_cache_entries.txt
+  #        /tmp/scons_cache
+  #      key: macos-${{ hashFiles('tools/mac_setup.sh', 'update_requirements.sh', 'Pipfile*') }}
+  #      restore-keys: macos-
+  #  - name: Brew link restored dependencies
+  #    run: |
+  #      if [ -f ~/github_brew_cache_entries.txt ]; then
+  #        while read pkg; do
+  #          brew link --force "$pkg" # `--force` for keg-only packages
+  #        done < ~/github_brew_cache_entries.txt
+  #      else
+  #        echo "Cache entries not found"
+  #      fi
+  #  - name: Install dependencies
+  #    run: ./tools/mac_setup.sh
+  #  - name: Build openpilot
+  #    run: |
+  #      source tools/openpilot_env.sh
+  #      pipenv run selfdrive/manager/build.py
+  #
+  #      # cleanup scons cache
+  #      rm -rf /tmp/scons_cache/
+  #      pipenv run scons -j$(nproc) --cache-populate
+  #  - name: Remove pre-existing Homebrew packages for caching
+  #    if: steps.dependency-cache.outputs.cache-hit != 'true'
+  #    run: |
+  #      cd /usr/local/Cellar
+  #      new_cellar=$(ls -1)
+  #      comm -12 <(echo "$EXISTING_CELLAR") <(echo "$new_cellar") | while read pkg; do
+  #        if [[ $pkg != "zstd" ]]; then # caching step needs zstd
+  #          rm -rf "$pkg"
+  #        fi
+  #      done
+  #      comm -13 <(echo "$EXISTING_CELLAR") <(echo "$new_cellar") | tee ~/github_brew_cache_entries.txt
+
+  build_webcam:
+    name: build webcam
+    runs-on: ubuntu-20.04
+    timeout-minutes: 90
+    env:
+      IMAGE_NAME: openpilotwebcamci
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Build Docker image
+      run: |
+        eval "$BUILD"
+        docker pull $DOCKER_REGISTRY/$IMAGE_NAME:latest || true
+        docker build --cache-from $DOCKER_REGISTRY/$IMAGE_NAME:latest -t $DOCKER_REGISTRY/$IMAGE_NAME:latest -f tools/webcam/Dockerfile .
+    - name: Build openpilot
+      run: docker run --shm-size 1G --rm -v $PWD:/tmp/openpilot -e PYTHONPATH=/tmp/openpilot $DOCKER_REGISTRY/$IMAGE_NAME /bin/sh -c "cd /tmp/openpilot && USE_WEBCAM=1 scons -j$(nproc)"
+    - name: Push to container registry
+      if: github.ref == 'refs/heads/master' && github.repository == 'commaai/openpilot'
+      run: |
+        $DOCKER_LOGIN
+        docker push $DOCKER_REGISTRY/$IMAGE_NAME:latest
+
+  docker_push:
+    name: docker push
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    if: github.ref == 'refs/heads/master' && github.event_name != 'pull_request' && github.repository == 'commaai/openpilot'
+    needs: static_analysis # hack to ensure slow tests run first since this and static_analysis are fast
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Push to container registry
+      run: |
+        $DOCKER_LOGIN
+        docker push $DOCKER_REGISTRY/$BASE_IMAGE:latest
+
+  static_analysis:
+    name: static analysis
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: pre-commit
+      run: ${{ env.RUN }} "git init && git add -A && pre-commit run --all"
+
+  valgrind:
+    name: valgrind
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Cache dependencies
+      id: dependency-cache
+      uses: actions/cache@v2
+      with:
+        path: /tmp/comma_download_cache
+        key: ${{ hashFiles('.github/workflows/selfdrive_tests.yaml', 'selfdrive/test/test_valgrind_replay.py') }}
+    - name: Cache scons
+      id: scons-cache
+      # TODO: Change the version to the released version when https://github.com/actions/cache/pull/489 (or 571) is merged.
+      uses: actions/cache@03e00da99d75a2204924908e1cca7902cafce66b
+      env:
+        CACHE_SKIP_SAVE: true
+      with:
+        path: /tmp/scons_cache
+        key: scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+        restore-keys: |
+          scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+          scons-
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Run valgrind
+      run: |
+        ${{ env.RUN }} "scons -j$(nproc) && \
+                        FILEREADER_CACHE=1 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
+    timeout-minutes: 50
+    steps:
+    - name: Get current date
+      id: date
+      run: echo "::set-output name=time::$(date +'%s')"
+    - name: Output timestamp
+      run: echo $TIMESTAMP
+      env:
+        TIMESTAMP: ${{ steps.date.outputs.time }}
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Cache scons
+      id: scons-cache
+      # TODO: Change the version to the released version when https://github.com/actions/cache/pull/489 (or 571) is merged.
+      uses: actions/cache@03e00da99d75a2204924908e1cca7902cafce66b
+      env:
+        CACHE_SKIP_SAVE: ${{ github.ref != 'refs/heads/master' || github.repository != 'commaai/openpilot' }}
+      with:
+        path: /tmp/scons_cache
+        key: scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-${{ steps.date.outputs.time }}
+        restore-keys: scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Run unit tests
+      run: |
+        ${{ env.RUN }} "export SKIP_LONG_TESTS=1 && \
+                        scons -j$(nproc) --test && \
+                        $UNIT_TEST common && \
+                        $UNIT_TEST opendbc/can && \
+                        $UNIT_TEST selfdrive/boardd && \
+                        $UNIT_TEST selfdrive/controls && \
+                        $UNIT_TEST selfdrive/monitoring && \
+                        $UNIT_TEST selfdrive/loggerd && \
+                        $UNIT_TEST selfdrive/car && \
+                        $UNIT_TEST selfdrive/locationd && \
+                        $UNIT_TEST selfdrive/athena && \
+                        $UNIT_TEST selfdrive/thermald && \
+                        $UNIT_TEST selfdrive/hardware/tici && \
+                        $UNIT_TEST tools/lib/tests && \
+                        ./selfdrive/boardd/tests/test_boardd_usbprotocol && \
+                        ./selfdrive/common/tests/test_util && \
+                        ./selfdrive/common/tests/test_swaglog && \
+                        ./selfdrive/loggerd/tests/test_logger &&\
+                        ./selfdrive/proclogd/tests/test_proclog && \
+                        ./selfdrive/ui/replay/tests/test_replay && \
+                        ./selfdrive/camerad/test/ae_gray_test && \
+                        coverage xml"
+    - name: "Upload coverage to Codecov"
+      uses: codecov/codecov-action@v2
+
+  process_replay:
+    name: process replay
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Cache dependencies
+      id: dependency-cache
+      uses: actions/cache@v2
+      with:
+        path: /tmp/comma_download_cache
+        key: ${{ hashFiles('.github/workflows/selfdrive_tests.yaml', 'selfdrive/test/process_replay/test_processes.py') }}
+    - name: Cache scons
+      id: scons-cache
+      # TODO: Change the version to the released version when https://github.com/actions/cache/pull/489 (or 571) is merged.
+      uses: actions/cache@03e00da99d75a2204924908e1cca7902cafce66b
+      env:
+        CACHE_SKIP_SAVE: true
+      with:
+        path: /tmp/scons_cache
+        key: scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+        restore-keys: |
+          scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+          scons-
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Run replay
+      run: |
+        ${{ env.RUN }} "scons -j$(nproc) && \
+                        FILEREADER_CACHE=1 CI=1 coverage run selfdrive/test/process_replay/test_processes.py && \
+                        coverage xml"
+    - name: "Upload coverage to Codecov"
+      uses: codecov/codecov-action@v2
+    - name: 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
+
+  #model_replay:
+  #  name: model replay
+  #  runs-on: ubuntu-20.04
+  #  timeout-minutes: 50
+  #  steps:
+  #  - uses: actions/checkout@v2
+  #    with:
+  #      submodules: true
+  #  - name: Build Docker image
+  #    run: eval "$BUILD"
+  #  - name: Run replay
+  #    run: |
+  #      ${{ env.RUN }} "scons -j$(nproc) && \
+  #                      selfdrive/test/process_replay/model_replay.py"
+
+  test_longitudinal:
+    name: longitudinal
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Cache scons
+      id: scons-cache
+      # TODO: Change the version to the released version when https://github.com/actions/cache/pull/489 (or 571) is merged.
+      uses: actions/cache@03e00da99d75a2204924908e1cca7902cafce66b
+      env:
+        CACHE_SKIP_SAVE: true
+      with:
+        path: /tmp/scons_cache
+        key: scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+        restore-keys: |
+          scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+          scons-
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Test longitudinal
+      run: |
+        ${{ env.RUN }} "mkdir -p selfdrive/test/out && \
+                        scons -j$(nproc) && \
+                        cd selfdrive/test/longitudinal_maneuvers && \
+                        coverage run ./test_longitudinal.py && \
+                        coverage xml"
+    - name: "Upload coverage to Codecov"
+      uses: codecov/codecov-action@v2
+    - uses: actions/upload-artifact@v2
+      if: always()
+      continue-on-error: true
+      with:
+        name: longitudinal
+        path: selfdrive/test/longitudinal_maneuvers/out/longitudinal/
+
+  test_cars:
+    name: cars
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    strategy:
+      fail-fast: false
+      matrix:
+        job: [0, 1, 2, 3]
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Cache dependencies
+      id: dependency-cache
+      uses: actions/cache@v2
+      with:
+        path: /tmp/comma_download_cache
+        key: car_models-${{ hashFiles('selfdrive/car/tests/test_models.py', 'selfdrive/car/tests/routes.py') }}-${{ matrix.job }}
+    - name: Cache scons
+      id: scons-cache
+      # TODO: Change the version to the released version when https://github.com/actions/cache/pull/489 (or 571) is merged.
+      uses: actions/cache@03e00da99d75a2204924908e1cca7902cafce66b
+      env:
+        CACHE_SKIP_SAVE: true
+      with:
+        path: /tmp/scons_cache
+        key: scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+        restore-keys: |
+          scons-${{ hashFiles('.github/workflows/selfdrive_tests.yaml') }}-
+          scons-
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Test car models
+      run: |
+        ${{ env.RUN }} "scons -j$(nproc) --test && \
+                        FILEREADER_CACHE=1 coverage run -m pytest selfdrive/car/tests/test_models.py && \
+                        coverage xml && \
+                        chmod -R 777 /tmp/comma_download_cache"
+      env:
+        NUM_JOBS: 4
+        JOB_ID: ${{ matrix.job }}
+    - name: "Upload coverage to Codecov"
+      uses: codecov/codecov-action@v2
+
+  docs:
+    name: build docs
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Build docker container
+      run: |
+        docker pull $DOCKER_REGISTRY/$BASE_IMAGE:latest || true
+        docker pull $DOCKER_REGISTRY/openpilot-docs:latest || true
+        DOCKER_BUILDKIT=1 docker build --cache-from $DOCKER_REGISTRY/openpilot-docs:latest -t $DOCKER_REGISTRY/openpilot-docs:latest -f docs/docker/Dockerfile .
+    - name: Push docker container
+      if: github.ref == 'refs/heads/master' && github.event_name != 'pull_request' && github.repository == 'commaai/openpilot'
+      run: |
+        $DOCKER_LOGIN
+        docker push $DOCKER_REGISTRY/openpilot-docs:latest

.github/workflows/tools_tests.yaml

@@ -0,0 +1,71 @@
+name: tools
+on:
+  push:
+  pull_request:
+
+env:
+  BASE_IMAGE: openpilot-base
+  DOCKER_REGISTRY: ghcr.io/commaai
+  DOCKER_LOGIN: docker login ghcr.io -u adeebshihadeh -p ${{ secrets.CONTAINER_TOKEN }}
+
+  BUILD: |
+      docker pull $(grep -iohP '(?<=^from)\s+\S+' Dockerfile.openpilot_base) || true
+      docker pull $DOCKER_REGISTRY/$BASE_IMAGE:latest || true
+      docker build --cache-from $DOCKER_REGISTRY/$BASE_IMAGE:latest -t $DOCKER_REGISTRY/$BASE_IMAGE:latest -t $BASE_IMAGE:latest -f Dockerfile.openpilot_base .
+  RUN: docker run --shm-size 1G -v $PWD:/tmp/openpilot -e PYTHONPATH=/tmp/openpilot -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e \
+       GITHUB_REPOSITORY -e GITHUB_RUN_ID -v /tmp/comma_download_cache:/tmp/comma_download_cache $BASE_IMAGE /bin/sh -c
+
+jobs:
+  plotjuggler:
+    name: plotjuggler
+    runs-on: ubuntu-20.04
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Build Docker image
+      run: eval "$BUILD"
+    - name: Unit test
+      run: |
+        ${{ env.RUN }} "scons -j$(nproc) --directory=/tmp/openpilot/cereal && \
+                        apt-get update && \
+                        apt-get install -y libdw-dev libqt5svg5-dev libqt5x11extras5-dev && \
+                        cd /tmp/openpilot/tools/plotjuggler && \
+                        ./test_plotjuggler.py"
+
+  simulator:
+    name: simulator
+    runs-on: ubuntu-20.04
+    timeout-minutes: 50
+    env:
+      IMAGE_NAME: openpilot-sim
+    if: github.repository == 'commaai/openpilot'
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    # HACK: cache LFS objects since they count against our quota
+    # https://github.com/actions/checkout/issues/165#issuecomment-657673315
+    - name: Create LFS file list
+      run: git lfs ls-files -l | cut -d' ' -f1 | sort > .lfs-assets-id
+    - name: Restore LFS cache
+      uses: actions/cache@v2
+      id: lfs-cache
+      with:
+        path: .git/lfs
+        key: ${{ runner.os }}-lfs-${{ hashFiles('.lfs-assets-id') }}
+    - name: Git LFS Pull
+      run: git lfs pull
+
+    - name: Build Docker image
+      run: |
+        eval "$BUILD"
+        docker pull $DOCKER_REGISTRY/$IMAGE_NAME:latest || true
+        docker build --cache-from $DOCKER_REGISTRY/$IMAGE_NAME:latest -t $DOCKER_REGISTRY/$IMAGE_NAME:latest -f tools/sim/Dockerfile.sim .
+    - name: Push to container registry
+      if: github.ref == 'refs/heads/master' && github.repository == 'commaai/openpilot'
+      run: |
+        $DOCKER_LOGIN
+        docker push $DOCKER_REGISTRY/$IMAGE_NAME:latest

.gitignore

@@ -1,4 +1,6 @@
 venv/
+.env
+.clang-format
 .DS_Store
 .tags
 .ipynb_checkpoints
@@ -6,9 +8,10 @@ venv/
 .overlay_init
 .overlay_consistent
 .sconsign.dblite
-.vscode
+.vscode*
 model2.png
 a.out
+.hypothesis
 
 *.dylib
 *.DSYM
@@ -31,6 +34,7 @@ a.out
 *.vcd
 config.json
 clcache
+compile_commands.json
 
 persist
 board/obj/
@@ -42,9 +46,11 @@ selfdrive/ui/_ui
 selfdrive/test/longitudinal_maneuvers/out
 selfdrive/visiond/visiond
 selfdrive/loggerd/loggerd
+selfdrive/loggerd/bootlog
 selfdrive/sensord/_gpsd
 selfdrive/sensord/_sensord
 selfdrive/camerad/camerad
+selfdrive/camerad/test/ae_gray_test
 selfdrive/modeld/_modeld
 selfdrive/modeld/_dmonitoringmodeld
 /src/
@@ -53,9 +59,10 @@ one
 openpilot
 notebooks
 xx
+yy
+hyperthneed
 panda_jungle
-apks
-openpilot-apks
+provisioning
 
 .coverage*
 coverage.xml
@@ -66,3 +73,13 @@ pandaextra
 flycheck_*
 
 cppcheck_report.txt
+comma*.sh
+
+selfdrive/modeld/thneed/compile
+models/*.thneed
+
+*.bz2
+
+build/
+
+!**/.gitkeep

.gitmodules

@@ -0,0 +1,15 @@
+[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

.lfsconfig

@@ -0,0 +1,4 @@
+[lfs]
+	url = https://gitlab.com/commaai/openpilot-lfs.git/info/lfs
+	pushurl = ssh://git@gitlab.com/commaai/openpilot-lfs.git
+	locksverify = false

.pre-commit-config.yaml

@@ -0,0 +1,58 @@
+repos:
+-   repo: meta
+    hooks:
+    -   id: check-hooks-apply
+    -   id: check-useless-excludes
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.1.0
+    hooks:
+    -   id: check-ast
+        exclude: '^(pyextra)/'
+    -   id: check-json
+    -   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/pre-commit/mirrors-mypy
+    rev: v0.931
+    hooks:
+    -   id: mypy
+        exclude: '^(pyextra/)|(cereal/)|(rednose/)|(panda/)|(laika/)|(opendbc/)|(laika_repo/)|(rednose_repo/)/'
+        additional_dependencies: ['git+https://github.com/numpy/numpy-stubs', 'types-requests', 'types-atomicwrites',
+                                  'types-pycurl']
+-   repo: https://github.com/PyCQA/flake8
+    rev: 4.0.1
+    hooks:
+    -   id: flake8
+        exclude: '^(pyextra/)|(cereal/)|(rednose/)|(panda/)|(laika/)|(opendbc/)|(laika_repo/)|(rednose_repo/)|(selfdrive/debug/)/'
+        additional_dependencies: ['flake8-no-implicit-concat']
+        args:
+        - --indent-size=2
+        - --enable-extensions=NIC
+        - --select=F,E112,E113,E304,E502,E701,E702,E703,E71,E72,E731,W191,W6
+        - --statistics
+        - -j4
+-   repo: local
+    hooks:
+    -   id: pylint
+        name: pylint
+        entry: pylint
+        language: system
+        types: [python]
+        exclude: '^(pyextra/)|(cereal/)|(rednose/)|(panda/)|(laika/)|(laika_repo/)|(rednose_repo/)'
+-   repo: local
+    hooks:
+    -   id: cppcheck
+        name: cppcheck
+        entry: cppcheck
+        language: system
+        types: [c++]
+        exclude: '^(third_party/)|(pyextra/)|(cereal/)|(opendbc/)|(panda/)|(tools/)|(selfdrive/modeld/thneed/debug/)|(selfdrive/modeld/test/)|(selfdrive/camerad/test/)/|(installer/)'
+        args:
+        - --error-exitcode=1
+        - --language=c++
+        - --quiet
+        - --force
+        - -j8

.pylintrc

@@ -0,0 +1,476 @@
+[MASTER]
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code
+extension-pkg-whitelist=scipy cereal.messaging.messaging_pyx
+
+# Add files or directories to the blacklist. They should be base names, not
+# paths.
+ignore=CVS
+
+# Add files or directories matching the regex patterns to the blacklist. The
+# regex matches against base names, not paths.
+ignore-patterns=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Use multiple processes to speed up Pylint.
+jobs=4
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# Specify a configuration file.
+#rcfile=
+
+# When enabled, pylint would attempt to guess common misconfiguration and emit
+# user-friendly hints instead of false-positive error messages
+suggestion-mode=yes
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+disable=C,R,W0613,W0511,W0212,W0201,W0106,W0603,W0621,W0703,W1201,W1203,E1136,W1514
+
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=c-extension-no-member
+
+
+[REPORTS]
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+# Set the output format. Available formats are text, parseable, colorized, json
+# and msvs (visual studio).You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=optparse.Values,sys.exit
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes
+max-spelling-suggestions=4
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+      XXX,
+      TODO
+
+
+[SIMILARITIES]
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=capnp.* cereal.* pygame.* zmq.* setproctitle.* smbus2.* usb1.* serial.* cv2.* ft4222.* carla.*
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=flask setproctitle usb1 flask.ext.socketio smbus2 usb1.*
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The minimum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+          _cb
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Number of spaces of indent required inside a hanging  or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='  '
+
+# Maximum number of characters on a single line.
+max-line-length=100
+
+# Maximum number of lines in a module
+max-module-lines=1000
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=trailing-comma,
+               dict-separator
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[BASIC]
+
+# Naming style matching correct argument names
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style
+#argument-rgx=
+
+# Naming style matching correct attribute names
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,
+          bar,
+          baz,
+          toto,
+          tutu,
+          tata
+
+# Naming style matching correct class attribute names
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style
+#class-attribute-rgx=
+
+# Naming style matching correct class names
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-style
+#class-rgx=
+
+# Naming style matching correct constant names
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=i,
+           j,
+           k,
+           ex,
+           Run,
+           _
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style
+#inlinevar-rgx=
+
+# Naming style matching correct method names
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style
+#method-rgx=
+
+# Naming style matching correct module names
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+property-classes=abc.abstractproperty
+
+# Naming style matching correct variable names
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style
+#variable-rgx=
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in a if statement
+max-bool-expr=5
+
+# Maximum number of branch for function / method body
+max-branches=12
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,
+                  _fields,
+                  _replace,
+                  _source,
+                  _make
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[IMPORTS]
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,
+                   TERMIOS,
+                   Bastion,
+                   rexec
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+[STRING]
+
+# This flag controls whether the implicit-str-concat should generate a warning
+# on implicit string concatenation in sequences defined over several lines.
+check-str-concat-over-line-jumps=yes
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=Exception

.python-version

@@ -0,0 +1 @@
+3.8.10

CONTRIBUTING.md

@@ -1,51 +0,0 @@
-# How to contribute
-
-Our software is open source so you can solve your own problems without needing help from others. And if you solve a problem and are so kind, you can upstream it for the rest of the world to use.
-
-Most open source development activity is coordinated through our [Discord](https://discord.comma.ai). A lot of documentation is available on our [medium](https://medium.com/@comma_ai/).
-
-## Getting Started
-
- * Join our [Discord](https://discord.comma.ai)
- * Make sure you have a [GitHub account](https://github.com/signup/free)
- * Fork [our repositories](https://github.com/commaai) on GitHub
-
-## Testing
-
-### Local Testing
-
-You can test your changes on your machine by running `run_docker_tests.sh`. This will run some automated tests in docker against your code.
-
-### Automated Testing
-
-All PRs and commits are automatically checked by Github Actions. Check out `.github/workflows/` for what Github Actions runs. Any new tests should be added to Github Actions.
-
-### Code Style and Linting
-
-Code is automatically checked for style by Github Actions as part of the automated tests. You can also run these tests yourself by running `pre-commit run --all`.
-
-## Car Ports (openpilot)
-
-We've released a [Model Port guide](https://medium.com/@comma_ai/openpilot-port-guide-for-toyota-models-e5467f4b5fe6) for porting to Toyota/Lexus models.
-
-If you port openpilot to a substantially new car brand, see this more generic [Brand Port guide](https://medium.com/@comma_ai/how-to-write-a-car-port-for-openpilot-7ce0785eda84). You might also be eligible for a bounty. 
-
-## Pull Requests
-
-Pull requests should be against the master branch. Before running master on in-car hardware, you'll need to clone the submodules too. That can be done by recursively cloning the repository:
-```
-git clone https://github.com/commaai/openpilot.git --recursive
-```
-Or alternatively, when on the master branch:
-```
-git submodule init
-git submodule update
-```
-The reasons for having submodules on a dedicated repository and our new development philosophy can be found in our [post about externalization](https://medium.com/@comma_ai/a-2020-theme-externalization-13b33326d8b3).
-Modules that are in seperate repositories include:
-* apks
-* cereal
-* laika
-* opendbc
-* panda
-* rednose

Dockerfile.openpilot

@@ -0,0 +1,32 @@
+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 Pipfile Pipfile.lock $OPENPILOT_PATH
+RUN pip install --no-cache-dir pipenv==2021.5.29 pip==21.3.1 && \
+    pipenv install --system --deploy --dev --clear && \
+    pip uninstall -y pipenv
+
+COPY SConstruct ${OPENPILOT_PATH}
+
+COPY ./pyextra ${OPENPILOT_PATH}/pyextra
+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
+
+RUN scons -j$(nproc)

Dockerfile.openpilot_base

@@ -0,0 +1,32 @@
+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 && \
+    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
+
+ENV PIPENV_SYSTEM=1
+ENV PYENV_VERSION=3.8.10
+ENV PYENV_ROOT="/root/.pyenv"
+ENV PATH="$PYENV_ROOT/bin:$PYENV_ROOT/shims:$PATH"
+
+COPY Pipfile Pipfile.lock .python-version update_requirements.sh /tmp/
+COPY tools/ubuntu_setup.sh /tmp/tools/
+RUN cd /tmp && \
+    tools/ubuntu_setup.sh && \
+    rm -rf /var/lib/apt/lists/* && \
+    rm -rf /tmp/* && \
+    rm -rf /root/.cache && \
+    pip uninstall -y pipenv && \
+
+    # 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

Jenkinsfile

@@ -1,25 +1,43 @@
 def phone(String ip, String step_label, String cmd) {
-  def ci_env = "CI=1 TEST_DIR=${env.TEST_DIR} GIT_BRANCH=${env.GIT_BRANCH} GIT_COMMIT=${env.GIT_COMMIT}"
+  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 TEST_DIR=${env.TEST_DIR}
+export SOURCE_DIR=${env.SOURCE_DIR}
+export GIT_BRANCH=${env.GIT_BRANCH}
+export GIT_COMMIT=${env.GIT_COMMIT}
+
+source ~/.bash_profile
+if [ -f /TICI ]; then
+  source /etc/profile
+fi
+
+ln -snf ${env.TEST_DIR} /data/pythonpath
+
+if [ -f /EON ]; then
+  echo \$\$ > /dev/cpuset/app/tasks || true
+  echo \$PPID > /dev/cpuset/app/tasks || true
+  mkdir -p /dev/shm
+  chmod 777 /dev/shm
+fi
 
-  withCredentials([file(credentialsId: 'id_rsa_public', variable: 'key_file')]) {
-    sh label: step_label,
-        script: """
-                ssh -tt -o StrictHostKeyChecking=no -i ${key_file} -p 8022 root@${ip} '${ci_env} /usr/bin/bash -le' <<'EOF'
-echo \$\$ > /dev/cpuset/app/tasks || true
-echo \$PPID > /dev/cpuset/app/tasks || true
-mkdir -p /dev/shm
-chmod 777 /dev/shm
 cd ${env.TEST_DIR} || true
 ${cmd}
 exit 0
-EOF"""
+
+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: 60, unit: 'MINUTES') {
-      phone(device_ip, "kill old processes", "pkill -f comma || true")
       phone(device_ip, "git checkout", readFile("selfdrive/test/setup_device_ci.sh"),)
       steps.each { item ->
         phone(device_ip, item[0], item[1])
@@ -31,29 +49,37 @@ def phone_steps(String device_type, steps) {
 pipeline {
   agent none
   environment {
-    COMMA_JWT = credentials('athena-test-jwt')
     TEST_DIR = "/data/openpilot"
+    SOURCE_DIR = "/data/openpilot_source/"
   }
   options {
-      timeout(time: 1, unit: 'HOURS')
+      timeout(time: 4, unit: 'HOURS')
   }
 
   stages {
-
-    stage('Release Build') {
-      agent {
-        docker {
-          image 'python:3.7.3'
-          args '--user=root'
-        }
-      }
+    stage('build releases') {
       when {
         branch 'devel-staging'
       }
-      steps {
-        phone_steps("eon-build", [
-          ["build release2-staging and dashcam-staging", "cd release && PUSH=1 ./build_release2.sh"],
-        ])
+
+      parallel {
+        stage('release2') {
+          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
+          steps {
+            phone_steps("eon-build", [
+              ["build release2-staging & dashcam-staging", "PUSH=1 $SOURCE_DIR/release/build_release.sh"],
+            ])
+          }
+        }
+
+        stage('release3') {
+          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
+          steps {
+            phone_steps("tici", [
+              ["build release3-staging & dashcam3-staging", "PUSH=1 $SOURCE_DIR/release/build_release.sh"],
+            ])
+          }
+        }
       }
     }
 
@@ -61,89 +87,145 @@ pipeline {
       when {
         not {
           anyOf {
-            branch 'master-ci'; branch 'devel'; branch 'devel-staging'; branch 'release2'; branch 'release2-staging'; branch 'dashcam'; branch 'dashcam-staging'; branch 'testing-closet*'
+            branch 'master-ci'; branch 'devel'; branch 'devel-staging';
+            branch 'release2'; branch 'release2-staging'; branch 'dashcam'; branch 'dashcam-staging';
+            branch 'release3'; branch 'release3-staging'; branch 'dashcam3'; branch 'dashcam3-staging';
+            branch 'testing-closet*'; branch 'hotfix-*'
           }
         }
       }
 
-
       stages {
-
-        /*
-        stage('PC tests') {
-          agent {
-            dockerfile {
-              filename 'Dockerfile.openpilotci'
-              args '--privileged --shm-size=1G --user=root'
-            }
-          }
-          stages {
-            stage('Build') {
-              steps {
-                sh 'scons -j$(nproc)'
-              }
-            }
-          }
-          post {
-            always {
-              // fix permissions since docker runs as another user
-              sh "chmod -R 777 ."
-            }
-          }
-        }
-        */
-
         stage('On-device Tests') {
-          agent {
-            docker {
-              image 'python:3.7.3'
-              args '--user=root'
-            }
-          }
-
+          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
           stages {
             stage('parallel tests') {
               parallel {
-
-                stage('Devel Build') {
-                  environment {
-                    CI_PUSH = "${env.BRANCH_NAME == 'master' ? 'master-ci' : ' '}"
-                  }
+                stage('C2: build') {
                   steps {
-                    phone_steps("eon", [
-                      ["build devel", "cd release && CI_PUSH=${env.CI_PUSH} ./build_devel.sh"],
-                      ["test openpilot", "nosetests -s selfdrive/test/test_openpilot.py"],
-                      ["test cpu usage", "cd selfdrive/test/ && ./test_cpu_usage.py"],
+                    phone_steps("eon-build", [
+                      ["build master-ci", "cd $SOURCE_DIR/release && EXTRA_FILES='tools/' ./build_devel.sh"],
+                      ["build openpilot", "cd selfdrive/manager && ./build.py"],
+                      ["test manager", "python selfdrive/manager/test/test_manager.py"],
+                      ["onroad tests", "cd selfdrive/test/ && ./test_onroad.py"],
                       ["test car interfaces", "cd selfdrive/car/tests/ && ./test_car_interfaces.py"],
-                      ["test spinner build", "cd selfdrive/ui/spinner && make clean && make"],
-                      ["test text window build", "cd selfdrive/ui/text && make clean && make"],
                     ])
                   }
                 }
 
-                stage('Replay Tests') {
+                stage('C2: replay') {
                   steps {
                     phone_steps("eon2", [
-                      ["camerad/modeld replay", "cd selfdrive/test/process_replay && ./camera_replay.py"],
+                      ["build", "cd selfdrive/manager && ./build.py"],
+                      ["model replay", "cd selfdrive/test/process_replay && ./model_replay.py"],
                     ])
                   }
                 }
 
-                stage('HW + Unit Tests') {
+                stage('C2: HW + Unit Tests') {
                   steps {
                     phone_steps("eon", [
-                      ["build cereal", "SCONS_CACHE=1 scons -j4 cereal/"],
-                      ["test sounds", "nosetests -s selfdrive/test/test_sounds.py"],
-                      ["test boardd loopback", "nosetests -s selfdrive/boardd/tests/test_boardd_loopback.py"],
-                      ["test loggerd", "CI=1 python selfdrive/loggerd/tests/test_loggerd.py"],
-                      //["test camerad", "CI=1 python selfdrive/camerad/test/test_camerad.py"], // wait for shelf refactor
-                      //["test updater", "python installer/updater/test_updater.py"],
+                      ["build", "cd selfdrive/manager && ./build.py"],
+                      ["test sounds", "python selfdrive/ui/tests/test_soundd.py"],
+                      ["test boardd loopback", "python selfdrive/boardd/tests/test_boardd_loopback.py"],
+                      ["test loggerd", "python selfdrive/loggerd/tests/test_loggerd.py"],
+                      ["test encoder", "python selfdrive/loggerd/tests/test_encoder.py"],
+                      ["test logcatd", "python selfdrive/logcatd/tests/test_logcatd_android.py"],
+                      ["test updater", "python selfdrive/hardware/eon/test_neos_updater.py"],
+                    ])
+                  }
+                }
+
+                /*
+                stage('Power Consumption Tests') {
+                  steps {
+                    lock(resource: "", label: "c2-zookeeper", inversePrecedence: true, variable: 'device_ip', quantity: 1) {
+                      timeout(time: 90, unit: 'MINUTES') {
+                        sh script: "/home/batman/tools/zookeeper/enable_and_wait.py $device_ip 120", label: "turn on device"
+                        phone(device_ip, "git checkout", readFile("selfdrive/test/setup_device_ci.sh"),)
+                        phone(device_ip, "build", "scons -j4 && sync")
+                        sh script: "/home/batman/tools/zookeeper/disable.py $device_ip", label: "turn off device"
+                        sh script: "/home/batman/tools/zookeeper/enable_and_wait.py $device_ip 120", label: "turn on device"
+                        sh script: "/home/batman/tools/zookeeper/check_consumption.py 60 3", label: "idle power consumption after boot"
+                        sh script: "/home/batman/tools/zookeeper/ignition.py 1", label: "go onroad"
+                        sh script: "/home/batman/tools/zookeeper/check_consumption.py 60 10", label: "onroad power consumption"
+                        sh script: "/home/batman/tools/zookeeper/ignition.py 0", label: "go offroad"
+                        sh script: "/home/batman/tools/zookeeper/check_consumption.py 60 2", label: "idle power consumption offroad"
+                      }
+                    }
+                  }
+                }
+                */
+
+                stage('C3: build') {
+                  environment {
+                    R3_PUSH = "${env.BRANCH_NAME == 'master' ? '1' : ' '}"
+                  }
+                  steps {
+                    phone_steps("tici", [
+                      ["build master-ci", "cd $SOURCE_DIR/release && EXTRA_FILES='tools/' ./build_devel.sh"],
+                      ["build openpilot", "cd selfdrive/manager && ./build.py"],
+                      ["test manager", "python selfdrive/manager/test/test_manager.py"],
+                      ["onroad tests", "cd selfdrive/test/ && ./test_onroad.py"],
+                      ["test car interfaces", "cd selfdrive/car/tests/ && ./test_car_interfaces.py"],
+                    ])
+                  }
+                }
+
+                stage('C3: HW + Unit Tests') {
+                  steps {
+                    phone_steps("tici2", [
+                      ["build", "cd selfdrive/manager && ./build.py"],
+                      ["test boardd loopback", "python selfdrive/boardd/tests/test_boardd_loopback.py"],
+                      ["test loggerd", "python selfdrive/loggerd/tests/test_loggerd.py"],
+                      ["test encoder", "LD_LIBRARY_PATH=/usr/local/lib python selfdrive/loggerd/tests/test_encoder.py"],
+                    ])
+                  }
+                }
+
+                stage('C2: camerad') {
+                  steps {
+                    phone_steps("eon-party", [
+                      ["build", "cd selfdrive/manager && ./build.py"],
+                      ["test camerad", "python selfdrive/camerad/test/test_camerad.py"],
+                      ["test exposure", "python selfdrive/camerad/test/test_exposure.py"],
+                    ])
+                  }
+                }
+
+                stage('C3: camerad') {
+                  steps {
+                    phone_steps("tici-party", [
+                      ["build", "cd selfdrive/manager && ./build.py"],
+                      ["test camerad", "python selfdrive/camerad/test/test_camerad.py"],
+                      ["test exposure", "python selfdrive/camerad/test/test_exposure.py"],
+                    ])
+                  }
+                }
+
+                stage('C3: replay') {
+                  steps {
+                    phone_steps("tici-party", [
+                      ["build", "cd selfdrive/manager && ./build.py"],
+                      ["model replay", "cd selfdrive/test/process_replay && ./model_replay.py"],
                     ])
                   }
                 }
 
               }
             }
+
+            stage('Push master-ci') {
+              when {
+                branch 'master'
+              }
+              steps {
+                phone_steps("eon-build", [
+                  ["push devel", "cd $SOURCE_DIR/release && PUSH='master-ci' ./build_devel.sh"],
+                ])
+              }
+            }
+
           }
 
           post {
@@ -158,3 +240,4 @@ pipeline {
     }
   }
 }
+

Pipfile

@@ -0,0 +1,83 @@
+[[source]]
+name = "pypi"
+url = "https://pypi.org/simple"
+verify_ssl = true
+
+[dev-packages]
+control = "*"
+coverage = "*"
+dictdiffer = "*"
+fastcluster = "*"
+hexdump = "*"
+hypothesis = "*"
+inputs = "*"
+lru-dict = "*"
+markdown-it-py = "*"
+matplotlib = "*"
+mypy = "*"
+myst-parser = "*"
+numpy = "*"
+opencv-python-headless = "*"
+parameterized = "*"
+paramiko = "*"
+pprofile = "*"
+pre-commit = "*"
+pycurl = "*"
+pygame = "*"
+pyprof2calltree = "*"
+pytest = "*"
+pytest-xdist = "*"
+reverse_geocoder = "*"
+scipy = "*"
+sphinx = "*"
+sphinx-sitemap = "*"
+sphinx-rtd-theme = "*"
+breathe = "*"
+subprocess32 = "*"
+tenacity = "*"
+
+[packages]
+atomicwrites = "*"
+casadi = {version = "*", markers="platform_system != 'Darwin'"}
+cffi = "*"
+crcmod = "*"
+cryptography = "*"
+Cython = "*"
+flake8 = "*"
+Flask = "*"
+future-fstrings = "*"  # for acados
+gunicorn = "*"
+hexdump = "*"
+Jinja2 = "*"
+json-rpc = "*"
+libusb1 = "*"
+nose = "*"
+numpy = "*"
+onnx = "*"
+onnxruntime-gpu = {version = "*", markers="platform_system != 'Darwin'"}
+pillow = "*"
+psutil = "*"
+pycapnp = "==1.1.0"
+pycryptodome = "*"
+PyJWT = "*"
+pylint = "*"
+pyopencl = "*"
+pyserial = "*"
+python-dateutil = "*"
+PyYAML = "*"
+pyzmq = "*"
+requests = "*"
+scons = "*"
+sentry-sdk = "*"
+setproctitle = "*"
+six = "*"
+smbus2 = "*"
+sympy = "!=1.6.1"
+timezonefinder = "*"
+tqdm = "*"
+urllib3 = "*"
+utm = "*"
+websocket_client = "*"
+
+[requires]
+python_version = "3.8"

README.md

@@ -1,21 +1,14 @@
-[![](https://i.imgur.com/UelUjKAh.png)](#)
+![](https://i.imgur.com/b0ZyIx5.jpg)
 
 Table of Contents
 =======================
 
 * [What is openpilot?](#what-is-openpilot)
-* [Integration with Stock Features](#integration-with-stock-features)
-* [Supported Hardware](#supported-hardware)
-* [Supported Cars](#supported-cars)
-* [Community Maintained Cars and Features](#community-maintained-cars-and-features)
-* [Installation Instructions](#installation-instructions)
-* [Limitations of openpilot ALC and LDW](#limitations-of-openpilot-alc-and-ldw)
-* [Limitations of openpilot ACC and FCW](#limitations-of-openpilot-acc-and-fcw)
-* [Limitations of openpilot DM](#limitations-of-openpilot-dm)
+* [Running in a car](#running-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)
-* [Testing on PC](#testing-on-pc)
-* [Community and Contributing](#community-and-contributing)
 * [Directory Structure](#directory-structure)
 * [Licensing](#licensing)
 
@@ -24,317 +17,115 @@ Table of Contents
 What is openpilot?
 ------
 
-[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](#supported-cars). In addition, while openpilot is engaged, a camera based Driver Monitoring (DM) feature alerts distracted and asleep drivers.
+[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).
 
 <table>
   <tr>
-    <td><a href="https://www.youtube.com/watch?v=mgAbfr42oI8" title="YouTube" rel="noopener"><img src="https://i.imgur.com/kAtT6Ei.png"></a></td>
-    <td><a href="https://www.youtube.com/watch?v=394rJKeh76k" title="YouTube" rel="noopener"><img src="https://i.imgur.com/lTt8cS2.png"></a></td>
-    <td><a href="https://www.youtube.com/watch?v=1iNOc3cq8cs" title="YouTube" rel="noopener"><img src="https://i.imgur.com/ANnuSpe.png"></a></td>
-    <td><a href="https://www.youtube.com/watch?v=Vr6NgrB-zHw" title="YouTube" rel="noopener"><img src="https://i.imgur.com/Qypanuq.png"></a></td>
+    <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://www.youtube.com/watch?v=Ug41KIKF0oo" title="YouTube" rel="noopener"><img src="https://i.imgur.com/3caZ7xM.png"></a></td>
-    <td><a href="https://www.youtube.com/watch?v=NVR_CdG1FRg" title="YouTube" rel="noopener"><img src="https://i.imgur.com/bAZOwql.png"></a></td>
-    <td><a href="https://www.youtube.com/watch?v=tkEvIdzdfUE" title="YouTube" rel="noopener"><img src="https://i.imgur.com/EFINEzG.png"></a></td>
-    <td><a href="https://www.youtube.com/watch?v=_P-N1ewNne4" title="YouTube" rel="noopener"><img src="https://i.imgur.com/gAyAq22.png"></a></td>
+    <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>
 
-Integration with Stock Features
+
+Running in a car
 ------
 
-In all supported cars:
-* Stock Lane Keep Assist (LKA) and stock ALC are replaced by openpilot ALC, which only functions when openpilot is engaged by the user.
-* Stock LDW is replaced by openpilot LDW.
+To use openpilot in a car, you need four things
+* This software. It's free and available right here.
+* One of [the 150+ supported cars](docs/CARS.md). We support Honda, Toyota, Hyundai, Nissan, Kia, Chrysler, Lexus, Acura, Audi, VW, 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 supported device to run this software. This can be a [comma two](https://comma.ai/shop/products/two), [comma three](https://comma.ai/shop/products/three), or if you like to experiment, a [Ubuntu computer with webcams](https://github.com/commaai/openpilot/tree/master/tools/webcam).
+* A way to connect to your car. With a comma two or three, you need only a [car harness](https://comma.ai/shop/products/car-harness). With an EON Gold or PC, you also need a [black panda](https://comma.ai/shop/products/panda).
 
-Additionally, on specific supported cars (see ACC column in [supported cars](#supported-cars)):
-* Stock ACC is replaced by openpilot ACC.
-* openpilot FCW operates in addition to stock FCW.
+We have detailed instructions for [how to install the device in a car](https://comma.ai/setup).
 
-openpilot should preserve all other vehicle's stock features, including, but are not limited to: FCW, Automatic Emergency Braking (AEB), auto high-beam, blind spot warning, and side collision warning.
-
-Supported Hardware
+Running on PC
 ------
 
-At the moment, openpilot supports the [EON DevKit](https://comma.ai/shop/products/eon-dashcam-devkit) and the [comma two](https://comma.ai/shop/products/comma-two-devkit). A [car harness](https://comma.ai/shop/products/car-harness) is recommended to connect the EON or comma two to the car. For experimental purposes, openpilot can also run on an Ubuntu computer with external [webcams](https://github.com/commaai/openpilot/tree/master/tools/webcam).
+All of openpilot's services can run as normal on a PC, even without special hardware or a car. To develop or experiment with openpilot you can run openpilot on recorded or simulated data.
 
-Supported Cars
-------
+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.
 
-| Make      | Model (US Market Reference)   | Supported Package | ACC              | No ACC accel below | No ALC below      |
-| ----------| ------------------------------| ------------------| -----------------| -------------------| ------------------|
-| Acura     | ILX 2016-18                   | AcuraWatch Plus   | openpilot        | 25mph<sup>1</sup>  | 25mph             |
-| Acura     | RDX 2016-18                   | AcuraWatch Plus   | openpilot        | 25mph<sup>1</sup>  | 12mph             |
-| Acura     | RDX 2020                      | AcuraWatch        | Stock            | 0mph               | 3mph              |
-| Honda     | Accord 2018-20                | All               | Stock            | 0mph               | 3mph              |
-| Honda     | Accord Hybrid 2018-20         | All               | Stock            | 0mph               | 3mph              |
-| Honda     | Civic Hatchback 2017-19       | Honda Sensing     | Stock            | 0mph               | 12mph             |
-| Honda     | Civic Sedan/Coupe 2016-18     | Honda Sensing     | openpilot        | 0mph               | 12mph             |
-| Honda     | Civic Sedan/Coupe 2019-20     | All               | Stock            | 0mph               | 2mph<sup>2</sup>  |
-| Honda     | CR-V 2015-16                  | Touring           | openpilot        | 25mph<sup>1</sup>  | 12mph             |
-| Honda     | CR-V 2017-20                  | Honda Sensing     | Stock            | 0mph               | 12mph             |
-| Honda     | CR-V Hybrid 2017-2019         | Honda Sensing     | Stock            | 0mph               | 12mph             |
-| Honda     | Fit 2018-19                   | Honda Sensing     | openpilot        | 25mph<sup>1</sup>  | 12mph             |
-| Honda     | HR-V 2019                     | Honda Sensing     | openpilot        | 25mph<sup>1</sup>  | 12mph             |
-| Honda     | Insight 2019-20               | All               | Stock            | 0mph               | 3mph              |
-| Honda     | Odyssey 2018-20               | Honda Sensing     | openpilot        | 25mph<sup>1</sup>  | 0mph              |
-| Honda     | Passport 2019                 | All               | openpilot        | 25mph<sup>1</sup>  | 12mph             |
-| Honda     | Pilot 2016-19                 | Honda Sensing     | openpilot        | 25mph<sup>1</sup>  | 12mph             |
-| Honda     | Ridgeline 2017-20             | Honda Sensing     | openpilot        | 25mph<sup>1</sup>  | 12mph             |
-| Hyundai   | Palisade 2020                 | All               | Stock            | 0mph               | 0mph         |
-| Hyundai   | Sonata 2020                   | All               | Stock            | 0mph               | 0mph              |
-| Lexus     | CT Hybrid 2017-18             | LSS               | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Lexus     | ES 2019                       | All               | openpilot        | 0mph               | 0mph              |
-| Lexus     | ES Hybrid 2019                | All               | openpilot        | 0mph               | 0mph              |
-| Lexus     | IS 2017-2019                  | All               | Stock            | 22mph              | 0mph              |
-| Lexus     | IS Hybrid 2017                | All               | Stock            | 0mph               | 0mph              |
-| Lexus     | NX Hybrid 2018                | All               | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Lexus     | RX 2016-18                    | All               | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Lexus     | RX 2020                       | All               | openpilot        | 0mph               | 0mph              |
-| Lexus     | RX Hybrid 2016-19             | All               | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Lexus     | RX Hybrid 2020                | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Avalon 2016-18                | TSS-P             | Stock<sup>3</sup>| 20mph<sup>1</sup>  | 0mph              |
-| Toyota    | Camry 2018-20                 | All               | Stock            | 0mph<sup>4</sup>   | 0mph              |
-| Toyota    | Camry Hybrid 2018-19          | All               | Stock            | 0mph<sup>4</sup>   | 0mph              |
-| Toyota    | C-HR 2017-19                  | All               | Stock            | 0mph               | 0mph              |
-| Toyota    | C-HR Hybrid 2017-19           | All               | Stock            | 0mph               | 0mph              |
-| Toyota    | Corolla 2017-19               | All               | Stock<sup>3</sup>| 20mph<sup>1</sup>  | 0mph              |
-| Toyota    | Corolla 2020                  | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Corolla Hatchback 2019-20     | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Corolla Hybrid 2020-21        | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Highlander 2017-19            | All               | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Toyota    | Highlander 2020               | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Highlander Hybrid 2017-19     | All               | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Toyota    | Highlander Hybrid 2020        | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Prius 2016-20                 | TSS-P             | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Toyota    | Prius Prime 2017-20           | All               | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Toyota    | Rav4 2016-18                  | TSS-P             | Stock<sup>3</sup>| 20mph<sup>1</sup>  | 0mph              |
-| Toyota    | Rav4 2019-21                  | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Rav4 Hybrid 2016-18           | TSS-P             | Stock<sup>3</sup>| 0mph               | 0mph              |
-| Toyota    | Rav4 Hybrid 2019-20           | All               | openpilot        | 0mph               | 0mph              |
-| Toyota    | Sienna 2018-20                | All               | Stock<sup>3</sup>| 0mph               | 0mph              |
-
-<sup>1</sup>[Comma Pedal](https://github.com/commaai/openpilot/wiki/comma-pedal) is used to provide stop-and-go capability to some of the openpilot-supported cars that don't currently support stop-and-go. ***NOTE: The Comma Pedal is not officially supported by [comma](https://comma.ai).*** <br />
-<sup>2</sup>2019 Honda Civic 1.6L Diesel Sedan does not have ALC below 12mph. <br />
-<sup>3</sup>When disconnecting the Driver Support Unit (DSU), openpilot ACC will replace stock ACC. ***NOTE: disconnecting the DSU disables Automatic Emergency Braking (AEB).*** <br />
-<sup>4</sup>28mph for Camry 4CYL L, 4CYL LE and 4CYL SE which don't have Full-Speed Range Dynamic Radar Cruise Control. <br />
-
-Community Maintained Cars and Features
-------
-
-| Make      | Model (US Market Reference)   | Supported Package | ACC              | No ACC accel below | No ALC below |
-| ----------| ------------------------------| ------------------| -----------------| -------------------| -------------|
-| Buick     | Regal 2018<sup>1</sup>        | Adaptive Cruise   | openpilot        | 0mph               | 7mph         |
-| Cadillac  | ATS 2018<sup>1</sup>          | Adaptive Cruise   | openpilot        | 0mph               | 7mph         |
-| Chevrolet | Malibu 2017<sup>1</sup>       | Adaptive Cruise   | openpilot        | 0mph               | 7mph         |
-| Chevrolet | Volt 2017-18<sup>1</sup>      | Adaptive Cruise   | openpilot        | 0mph               | 7mph         |
-| Chrysler  | Pacifica 2017-18              | Adaptive Cruise   | Stock            | 0mph               | 9mph         |
-| Chrysler  | Pacifica 2020                 | Adaptive Cruise   | Stock            | 0mph               | 39mph        |
-| Chrysler  | Pacifica Hybrid 2017-18       | Adaptive Cruise   | Stock            | 0mph               | 9mph         |
-| Chrysler  | Pacifica Hybrid 2019-20       | Adaptive Cruise   | Stock            | 0mph               | 39mph        |
-| Genesis   | G70 2018                      | All               | Stock            | 0mph               | 0mph         |
-| Genesis   | G80 2018                      | All               | Stock            | 0mph               | 0mph         |
-| Genesis   | G90 2018                      | All               | Stock            | 0mph               | 0mph         |
-| GMC       | Acadia Denali 2018<sup>2</sup>| Adaptive Cruise   | openpilot        | 0mph               | 7mph         |
-| Holden    | Astra 2017<sup>1</sup>        | Adaptive Cruise   | openpilot        | 0mph               | 7mph         |
-| Hyundai   | Elantra 2017-19               | SCC + LKAS        | Stock            | 19mph              | 34mph        |
-| Hyundai   | Genesis 2015-16               | SCC + LKAS        | Stock            | 19mph              | 37mph        |
-| Hyundai   | Ioniq Electric 2019-20        | SCC + LKAS        | Stock            | 0mph               | 32mph        |
-| Hyundai   | Kona 2020                     | SCC + LKAS        | Stock            | 0mph               | 0mph         |
-| Hyundai   | Kona EV 2019                  | SCC + LKAS        | Stock            | 0mph               | 0mph         |
-| Hyundai   | Santa Fe 2019                 | All               | Stock            | 0mph               | 0mph         |
-| Hyundai   | Sonata 2019                   | SCC + LKAS        | Stock            | 0mph               | 0mph         |
-| Hyundai   | Veloster 2019                 | SCC + LKAS        | Stock            | 5mph               | 0mph         |
-| Jeep      | Grand Cherokee 2016-18        | Adaptive Cruise   | Stock            | 0mph               | 9mph         |
-| Jeep      | Grand Cherokee 2019-20        | Adaptive Cruise   | Stock            | 0mph               | 39mph        |
-| Kia       | Forte 2018-19                 | SCC + LKAS        | Stock            | 0mph               | 0mph         |
-| Kia       | Optima 2017                   | SCC + LKAS        | Stock            | 0mph               | 32mph        |
-| Kia       | Optima 2019                   | SCC + LKAS        | Stock            | 0mph               | 0mph         |
-| Kia       | Sorento 2018                  | SCC + LKAS        | Stock            | 0mph               | 0mph         |
-| Kia       | Stinger 2018                  | SCC + LKAS        | Stock            | 0mph               | 0mph         |
-| Nissan    | Leaf 2018-20                  | ProPILOT          | Stock            | 0mph               | 0mph         |
-| Nissan    | Rogue 2018-19                 | ProPILOT          | Stock            | 0mph               | 0mph         |
-| Nissan    | X-Trail 2017                  | ProPILOT          | Stock            | 0mph               | 0mph         |
-| Subaru    | Ascent 2019                   | EyeSight          | Stock            | 0mph               | 0mph         |
-| Subaru    | Crosstrek 2018-19             | EyeSight          | Stock            | 0mph               | 0mph         |
-| Subaru    | Forester 2019                 | EyeSight          | Stock            | 0mph               | 0mph         |
-| Subaru    | Impreza 2017-19               | EyeSight          | Stock            | 0mph               | 0mph         |
-| Volkswagen| Golf 2015-19                  | Driver Assistance | Stock            | 0mph               | 0mph         |
-
-<sup>1</sup>Requires an [OBD-II car harness](https://comma.ai/shop/products/comma-car-harness) and [community built giraffe](https://github.com/commaai/openpilot/wiki/GM). ***NOTE: disconnecting the ASCM disables Automatic Emergency Braking (AEB).*** <br />
-<sup>2</sup>Requires a custom connector for the developer [car harness](https://comma.ai/shop/products/car-harness) <br />
-
-Although it's not upstream, there's a community of people getting openpilot to run on Tesla's [here](https://tinkla.us/)
-
-Community Maintained Cars and Features are not verified by comma to meet our [safety model](SAFETY.md). Be extra cautious using them. They are only available after enabling the toggle in `Settings->Developer->Enable Community Features`.
-
-To promote a car from community maintained, it must meet a few requirements. We must own one from the brand, we must sell the harness for it, has full ISO26262 in both panda and openpilot, there must be a path forward for longitudinal control, it must have AEB still enabled, and it must support fingerprinting 2.0
-
-Installation Instructions
-------
-
-Install openpilot on an EON or comma two by entering ``https://openpilot.comma.ai`` during the installer setup.
-
-Follow these [video instructions](https://youtu.be/lcjqxCymins) to properly mount the device on the windshield. Note: openpilot features an automatic pose calibration routine and openpilot performance should not be affected by small pitch and yaw misalignments caused by imprecise device mounting.
-
-Before placing the device on your windshield, check the state and local laws and ordinances where you drive. Some state laws prohibit or restrict the placement of objects on the windshield of a motor vehicle.
-
-You will be able to engage openpilot after reviewing the onboarding screens and finishing the calibration procedure.
-
-Limitations of openpilot ALC and LDW
-------
-
-openpilot ALC and openpilot LDW do not automatically drive the vehicle or reduce the amount of attention that must be paid to operate your vehicle. The driver must always keep control of the steering wheel and be ready to correct the openpilot ALC action at all times.
-
-While changing lanes, openpilot is not capable of looking next to you or checking your blind spot. Only nudge the wheel to initiate a lane change after you have confirmed it's safe to do so.
-
-Many factors can impact the performance of openpilot ALC and openpilot LDW, causing them to be unable to function as intended. These include, but are not limited to:
-
-* Poor visibility (heavy rain, snow, fog, etc.) or weather conditions that may interfere with sensor operation.
-* The road facing camera is obstructed, covered or damaged by mud, ice, snow, etc.
-* Obstruction caused by applying excessive paint or adhesive products (such as wraps, stickers, rubber coating, etc.) onto the vehicle.
-* The device is mounted incorrectly.
-* When in sharp curves, like on-off ramps, intersections etc...; openpilot is designed to be limited in the amount of steering torque it can produce.
-* In the presence of restricted lanes or construction zones.
-* When driving on highly banked roads or in presence of strong cross-wind.
-* Extremely hot or cold temperatures.
-* Bright light (due to oncoming headlights, direct sunlight, etc.).
-* Driving on hills, narrow, or winding roads.
-
-The list above does not represent an exhaustive list of situations that may interfere with proper operation of openpilot components. It is the driver's responsibility to be in control of the vehicle at all times.
-
-Limitations of openpilot ACC and FCW
-------
-
-openpilot ACC and openpilot FCW are not systems that allow careless or inattentive driving. It is still necessary for the driver to pay close attention to the vehicle’s surroundings and to be ready to re-take control of the gas and the brake at all times.
-
-Many factors can impact the performance of openpilot ACC and openpilot FCW, causing them to be unable to function as intended. These include, but are not limited to:
-
-* Poor visibility (heavy rain, snow, fog, etc.) or weather conditions that may interfere with sensor operation.
-* The road facing camera or radar are obstructed, covered, or damaged by mud, ice, snow, etc.
-* Obstruction caused by applying excessive paint or adhesive products (such as wraps, stickers, rubber coating, etc.) onto the vehicle.
-* The device is mounted incorrectly.
-* Approaching a toll booth, a bridge or a large metal plate.
-* When driving on roads with pedestrians, cyclists, etc...
-* In presence of traffic signs or stop lights, which are not detected by openpilot at this time.
-* When the posted speed limit is below the user selected set speed. openpilot does not detect speed limits at this time.
-* In presence of vehicles in the same lane that are not moving.
-* When abrupt braking maneuvers are required. openpilot is designed to be limited in the amount of deceleration and acceleration that it can produce.
-* When surrounding vehicles perform close cut-ins from neighbor lanes.
-* Driving on hills, narrow, or winding roads.
-* Extremely hot or cold temperatures.
-* Bright light (due to oncoming headlights, direct sunlight, etc.).
-* Interference from other equipment that generates radar waves.
-
-The list above does not represent an exhaustive list of situations that may interfere with proper operation of openpilot components. It is the driver's responsibility to be in control of the vehicle at all times.
-
-Limitations of openpilot DM
-------
-
-openpilot DM should not be considered an exact measurement of the alertness of the driver.
-
-Many factors can impact the performance of openpilot DM, causing it to be unable to function as intended. These include, but are not limited to:
-
-* Low light conditions, such as driving at night or in dark tunnels.
-* Bright light (due to oncoming headlights, direct sunlight, etc.).
-* The driver's face is partially or completely outside field of view of the driver facing camera.
-* Right hand driving vehicles.
-* The driver facing camera is obstructed, covered, or damaged.
-
-The list above does not represent an exhaustive list of situations that may interfere with proper operation of openpilot components. A driver should not rely on openpilot DM to assess their level of attention.
-
-User Data and comma Account
-------
-
-By default, openpilot uploads the driving data to our servers. You can also access your data by pairing with the comma connect app ([iOS](https://apps.apple.com/us/app/comma-connect/id1456551889), [Android](https://play.google.com/store/apps/details?id=ai.comma.connect&hl=en_US)). 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 camera, 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://my.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](SAFETY.md) for more detail.
-* openpilot has software in the loop [tests](.github/workflows/test.yaml) that run on every commit.
-* The safety model code 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 EONs continuously replaying routes.
-
-Testing on PC
-------
-For simplified development and experimentation, openpilot can be run in the CARLA driving simulator, which allows you to develop openpilot without a car. The whole setup should only take a few minutes. 
-
-Steps:
-1) Start the CARLA server on first terminal
-```
-bash -c "$(curl https://raw.githubusercontent.com/commaai/openpilot/master/tools/sim/start_carla.sh)"
-```
-2) Start openpilot on second terminal
-```
-bash -c "$(curl https://raw.githubusercontent.com/commaai/openpilot/master/tools/sim/start_openpilot_docker.sh)"
-```
-3) Press 1 to engage openpilot
-
-See the full [README](tools/sim/README.md)
-
-You should also take a look at the tools directory in master: lots of tools you can use to replay driving data, test, and develop openpilot from your PC.
+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.
 
 
 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.
+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).
 
-You can add support for your car by following guides we have written for [Brand](https://medium.com/@comma_ai/how-to-write-a-car-port-for-openpilot-7ce0785eda84) and [Model](https://medium.com/@comma_ai/openpilot-port-guide-for-toyota-models-e5467f4b5fe6) 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.
+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/).
 
 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
 ------
     .
-    ├── apk                 # The apk files used for the UI
     ├── cereal              # The messaging spec and libs used for all logs
     ├── common              # Library like functionality we've developed here
-    ├── installer/updater   # Manages auto-updates of openpilot
+    ├── docs                # Documentation
     ├── opendbc             # Files showing how to interpret data from cars
     ├── panda               # Code used to communicate on CAN
-    ├── phonelibs           # Libraries used on NEOS devices
-    ├── pyextra             # Libraries used on NEOS devices
+    ├── third_party         # External libraries
+    ├── pyextra             # Extra python packages
     └── selfdrive           # Code needed to drive the car
-        ├── assets          # Fonts, images and sounds for UI
+        ├── assets          # Fonts, images, and sounds for UI
         ├── athena          # Allows communication with the app
         ├── boardd          # Daemon to talk to the board
         ├── camerad         # Driver to capture images from the camera sensors
         ├── car             # Car specific code to read states and control actuators
         ├── common          # Shared C/C++ code for the daemons
-        ├── controls        # Perception, planning and controls
+        ├── controls        # Planning and controls
         ├── debug           # Tools to help you debug and do car ports
-        ├── locationd       # Soon to be home of precise location
+        ├── locationd       # Precise localization and vehicle parameter estimation
         ├── logcatd         # Android logcat as a service
         ├── loggerd         # Logger and uploader of car data
         ├── modeld          # Driving and monitoring model runners
         ├── proclogd        # Logs information from proc
-        ├── sensord         # IMU / GPS interface code
-        ├── test            # Unit tests, system tests and a car simulator
+        ├── sensord         # IMU interface code
+        ├── test            # Unit tests, system tests, and a car simulator
         └── ui              # The UI
 
-To understand how the services interact, see `cereal/service_list.yaml`.
-
 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.
+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.

RELEASES.md

@@ -1,3 +1,216 @@
+Version 0.8.14 (2022-0X-XX)
+========================
+ * bigmodel!
+ * Toyota Alphard Hybrid 2021 support
+ * Toyota Avalon Hybrid 2022 support
+
+Version 0.8.13 (2022-02-18)
+========================
+ * Improved driver monitoring
+   * Retuned driver pose learner for relaxed driving positions
+   * Added reliance on driving model to be more scene adaptive
+   * Matched strictness between comma two and comma three
+ * Improved performance in turns by compensating for the road bank angle
+ * Improved camera focus on the comma two
+ * AGNOS 4
+   * ADB support
+   * improved cell auto configuration
+ * NEOS 19
+   * package updates
+   * stability improvements
+ * Subaru ECU firmware fingerprinting thanks to martinl!
+ * Hyundai Santa Fe Plug-in Hybrid 2022 support thanks to sunnyhaibin!
+ * Mazda CX-5 2022 support thanks to Jafaral!
+ * Subaru Impreza 2020 support thanks to martinl!
+ * Toyota Avalon 2022 support thanks to sshane!
+ * Toyota Prius v 2017 support thanks to CT921!
+ * Volkswagen Caravelle 2020 support thanks to jyoung8607!
+
+Version 0.8.12 (2021-12-15)
+========================
+ * New driving model
+   * Improved behavior around exits
+   * Better pose accuracy at high speeds, allowing max speed of 90mph
+   * Fully incorporated comma three data into all parts of training stack
+ * Improved follow distance
+ * Better longitudinal policy, especially in low speed traffic
+ * New alert sounds
+ * AGNOS 3
+   * Display burn in mitigation
+   * Improved audio amplifier configuration
+   * System reliability improvements
+   * Update Python to 3.8.10
+ * Raw logs upload moved to connect.comma.ai
+ * Fixed HUD alerts on newer Honda Bosch thanks to csouers!
+ * Audi Q3 2020-21 support thanks to jyoung8607!
+ * Lexus RC 2020 support thanks to ErichMoraga!
+
+Version 0.8.11 (2021-11-29)
+========================
+ * Support for CAN FD on the red panda
+ * Support for an external panda on the comma three
+ * Navigation: Show more detailed instructions when approaching maneuver
+ * Fixed occasional steering faults on GM cars thanks to jyoung8607!
+ * Nissan ECU firmware fingerprinting thanks to robin-reckmann, martinl, and razem-io!
+ * Cadillac Escalade ESV 2016 support thanks to Gibby!
+ * Genesis G70 2020 support thanks to tecandrew!
+ * Hyundai Santa Fe Hybrid 2022 support thanks to sunnyhaibin!
+ * Mazda CX-9 2021 support thanks to Jacar!
+ * Volkswagen Polo 2020 support thanks to jyoung8607!
+ * Volkswagen T-Roc 2021 support thanks to jyoung8607!
+
+Version 0.8.10 (2021-11-01)
+========================
+ * New driving model
+   * Trained on one million minutes!!!
+   * Fixed lead training making lead predictions significantly more accurate
+   * Fixed several localizer dataset bugs and loss function bugs, overall improved accuracy
+ * New driver monitoring model
+   * Trained on latest data from both comma two and comma three
+   * Increased model field of view by 40% on comma three
+   * Improved model stability on masked users
+   * Improved pose prediction with reworked ground-truth stack
+ * Lateral and longitudinal planning MPCs now in ACADOS
+ * Combined longitudinal MPCs
+   * All longitudinal planning now happens in a single MPC system
+   * Fixed instability in MPC problem to prevent sporadic CPU usage
+ * AGNOS 2: minor stability improvements and builder repo open sourced
+ * tools: new and improved replay thanks to deanlee!
+ * Moved community-supported cars outside of the Community Features toggle
+ * Improved FW fingerprinting reliability for Hyundai/Kia/Genesis
+ * Added prerequisites for longitudinal control on Hyundai/Kia/Genesis and Honda Bosch
+ * Audi S3 2015 support thanks to jyoung8607!
+ * Honda Freed 2020 support thanks to belm0!
+ * Hyundai Ioniq Hybrid 2020-2022 support thanks to sunnyhaibin!
+ * Hyundai Santa Fe 2022 support thanks to sunnyhaibin!
+ * Kia K5 2021 support thanks to sunnyhaibin!
+ * Škoda Kamiq 2021 support thanks to jyoung8607!
+ * Škoda Karoq 2019 support thanks to jyoung8607!
+ * Volkswagen Arteon 2021 support thanks to jyoung8607!
+ * Volkswagen California 2021 support thanks to jyoung8607!
+ * Volkswagen Taos 2022 support thanks to jyoung8607!
+
+Version 0.8.9 (2021-09-14)
+========================
+ * Improved fan control on comma three
+ * AGNOS 1.5: improved stability
+ * Honda e 2020 support
+
+Version 0.8.8 (2021-08-27)
+========================
+ * New driving model with improved laneless performance
+   * Trained on 5000+ hours of diverse driving data from 3000+ users in 40+ countries
+   * Better anti-cheating methods during simulator training ensure the model hugs less when in laneless mode
+   * All new desire ground-truthing stack makes the model better at lane changes
+ * New driver monitoring model: improved performance on comma three
+ * NEOS 18 for comma two: update packages
+ * AGNOS 1.3 for comma three: fix display init at high temperatures
+ * Improved auto-exposure on comma three
+ * Improved longitudinal control on Honda Nidec cars
+ * Hyundai Kona Hybrid 2020 support thanks to haram-KONA!
+ * Hyundai Sonata Hybrid 2021 support thanks to Matt-Wash-Burn!
+ * Kia Niro Hybrid 2021 support thanks to tetious!
+
+Version 0.8.7 (2021-07-31)
+========================
+ * comma three support!
+ * Navigation alpha for the comma three!
+ * Volkswagen T-Cross 2021 support thanks to jyoung8607!
+
+Version 0.8.6 (2021-07-21)
+========================
+ * Revamp lateral and longitudinal planners
+   * Refactor planner output API to be more readable and verbose
+   * Planners now output desired trajectories for speed, acceleration, curvature, and curvature rate
+   * Use MPC for longitudinal planning when no lead car is present, makes accel and decel smoother
+ * Remove "CHECK DRIVER FACE VISIBILITY" warning
+ * Fixed cruise fault on some TSS2.5 Camrys and international Toyotas
+ * Hyundai Elantra Hybrid 2021 support thanks to tecandrew!
+ * Hyundai Ioniq PHEV 2020 support thanks to YawWashout!
+ * Kia Niro Hybrid 2019 support thanks to jyoung8607!
+ * Škoda Octavia RS 2016 support thanks to jyoung8607!
+ * Toyota Alphard 2020 support thanks to belm0!
+ * Volkswagen Golf SportWagen 2015 support thanks to jona96!
+ * Volkswagen Touran 2017 support thanks to jyoung8607!
+
+Version 0.8.5 (2021-06-11)
+========================
+ * NEOS update: improved reliability and stability with better voltage regulator configuration
+ * Smart model-based Forward Collision Warning
+ * CAN-based fingerprinting moved behind community features toggle
+ * Improved longitudinal control on Toyotas with a comma pedal
+ * Improved auto-brightness using road-facing camera
+ * Added "Software" settings page with updater controls
+ * Audi Q2 2018 support thanks to jyoung8607!
+ * Hyundai Elantra 2021 support thanks to CruiseBrantley!
+ * Lexus UX Hybrid 2019-2020 support thanks to brianhaugen2!
+ * Toyota Avalon Hybrid 2019 support thanks to jbates9011!
+ * SEAT Leon 2017 & 2020 support thanks to jyoung8607!
+ * Škoda Octavia 2015 & 2019 support thanks to jyoung8607!
+
+Version 0.8.4 (2021-05-17)
+========================
+ * Delay controls start until system is ready
+ * Fuzzy car identification, enabled with Community Features toggle
+ * Localizer optimized for increased precision and less CPU usage
+ * Retuned lateral control to be more aggressive when model is confident
+ * Toyota Mirai 2021 support
+ * Lexus NX 300 2020 support thanks to goesreallyfast!
+ * Volkswagen Atlas 2018-19 support thanks to jyoung8607!
+
+Version 0.8.3 (2021-04-01)
+========================
+ * New model
+   * Trained on new diverse dataset from 2000+ users from 30+ countries
+   * Trained with improved segnet from the comma-pencil community project
+   * 🥬 Dramatically improved end-to-end lateral performance 🥬
+ * Toggle added to disable the use of lanelines
+ * NEOS update: update packages and support for new UI
+ * New offroad UI based on Qt
+ * Default SSH key only used for setup
+ * Kia Ceed 2019 support thanks to ZanZaD13!
+ * Kia Seltos 2021 support thanks to speedking456!
+ * Added support for many Volkswagen and Škoda models thanks to jyoung8607!
+
+Version 0.8.2 (2021-02-26)
+========================
+ * Use model points directly in MPC (no more polyfits), making lateral planning more accurate
+ * Use model heading prediction for smoother lateral control
+ * Smarter actuator delay compensation
+ * Improve qcamera resolution for improved video in explorer and connect
+ * Adjust maximum engagement speed to better fit the model's training distribution
+ * New driver monitoring model trained with 3x more diverse data
+ * Improved face detection with masks
+ * More predictable DM alerts when visibility is bad
+ * Rewritten video streaming between openpilot processes
+ * Improved longitudinal tuning on TSS2 Corolla and Rav4 thanks to briskspirit!
+ * Audi A3 2015 and 2017 support thanks to keeleysam!
+ * Nissan Altima 2020 support thanks to avolmensky!
+ * Lexus ES Hybrid 2018 support thanks to TheInventorMan!
+ * Toyota Camry Hybrid 2021 support thanks to alancyau!
+
+Version 0.8.1 (2020-12-21)
+========================
+ * Original EON is deprecated, upgrade to comma two
+ * Better model performance in heavy rain
+ * Better lane positioning in turns
+ * Fixed bug where model would cut turns on empty roads at night
+ * Fixed issue where some Toyotas would not completely stop thanks to briskspirit!
+ * Toyota Camry 2021 with TSS2.5 support
+ * Hyundai Ioniq Electric 2020 support thanks to baldwalker!
+
+Version 0.8.0 (2020-11-30)
+========================
+ * New driving model: fully 3D and improved cut-in detection
+ * UI draws 2 road edges, 4 lanelines and paths in 3D
+ * Major fixes to cut-in detection for openpilot longitudinal
+ * Grey panda is no longer supported, upgrade to comma two or black panda
+ * Lexus NX 2018 support thanks to matt12eagles!
+ * Kia Niro EV 2020 support thanks to nickn17!
+ * Toyota Prius 2021 support thanks to rav4kumar!
+ * Improved lane positioning with uncertain lanelines, wide lanes and exits
+ * Improved lateral control for Prius and Subaru
+
 Version 0.7.10 (2020-10-29)
 ========================
  * Grey panda is deprecated, upgrade to comma two or black panda

SConstruct

@@ -1,10 +1,10 @@
-import Cython
-import distutils
 import os
 import shutil
 import subprocess
 import sys
+import sysconfig
 import platform
+import numpy as np
 
 TICI = os.path.isfile('/TICI')
 Decider('MD5-timestamp')
@@ -13,13 +13,44 @@ AddOption('--test',
           action='store_true',
           help='build test files')
 
+AddOption('--extras',
+          action='store_true',
+          help='build misc extras, like setup and installer files')
+
+AddOption('--kaitai',
+          action='store_true',
+          help='Regenerate kaitai struct parsers')
+
 AddOption('--asan',
           action='store_true',
           help='turn on ASAN')
 
-# Rebuild cython extensions if python, distutils, or cython change
-cython_dependencies = [Value(v) for v in (sys.version, distutils.__version__, Cython.__version__)]
-Export('cython_dependencies')
+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('--no-thneed',
+          action='store_true',
+          dest='no_thneed',
+          help='avoid using thneed')
 
 real_arch = arch = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()
 if platform.system() == "Darwin":
@@ -29,13 +60,21 @@ if arch == "aarch64" and TICI:
   arch = "larch64"
 
 USE_WEBCAM = os.getenv("USE_WEBCAM") is not None
-QCOM_REPLAY = arch == "aarch64" and os.getenv("QCOM_REPLAY") is not None
+
+lenv = {
+  "PATH": os.environ['PATH'],
+  "LD_LIBRARY_PATH": [Dir(f"#third_party/acados/{arch}/lib").abspath],
+  "PYTHONPATH": Dir("#").abspath + ":" + Dir("#pyextra/").abspath,
+
+  "ACADOS_SOURCE_DIR": Dir("#third_party/acados/include/acados").abspath,
+  "ACADOS_PYTHON_INTERFACE_PATH": Dir("#pyextra/acados_template").abspath,
+  "TERA_PATH": Dir("#").abspath + f"/third_party/acados/{arch}/t_renderer",
+}
+
+rpath = lenv["LD_LIBRARY_PATH"].copy()
 
 if arch == "aarch64" or arch == "larch64":
-  lenv = {
-    "LD_LIBRARY_PATH": '/data/data/com.termux/files/usr/lib',
-    "PATH": os.environ['PATH'],
-  }
+  lenv["LD_LIBRARY_PATH"] += ['/data/data/com.termux/files/usr/lib']
 
   if arch == "aarch64":
     # android
@@ -43,90 +82,97 @@ if arch == "aarch64" or arch == "larch64":
     lenv["ANDROID_ROOT"] = os.environ['ANDROID_ROOT']
 
   cpppath = [
-    "#phonelibs/opencl/include",
+    "#third_party/opencl/include",
   ]
 
   libpath = [
+    "/usr/local/lib",
     "/usr/lib",
     "/system/vendor/lib64",
-    "/system/comma/usr/lib",
-    "#phonelibs/nanovg",
+    f"#third_party/acados/{arch}/lib",
   ]
 
   if arch == "larch64":
     libpath += [
-      "#phonelibs/snpe/larch64",
-      "#phonelibs/libyuv/larch64/lib",
+      "#third_party/snpe/larch64",
+      "#third_party/libyuv/larch64/lib",
       "/usr/lib/aarch64-linux-gnu"
     ]
+    cpppath += [
+      "#selfdrive/camerad/include",
+    ]
     cflags = ["-DQCOM2", "-mcpu=cortex-a57"]
     cxxflags = ["-DQCOM2", "-mcpu=cortex-a57"]
-    rpath = ["/usr/local/lib"]
+    rpath += ["/usr/local/lib"]
   else:
+    rpath = []
     libpath += [
-      "#phonelibs/snpe/aarch64",
-      "#phonelibs/libyuv/lib",
+      "#third_party/snpe/aarch64",
+      "#third_party/libyuv/lib",
       "/system/vendor/lib64"
     ]
-    cflags = ["-DQCOM", "-mcpu=cortex-a57"]
-    cxxflags = ["-DQCOM", "-mcpu=cortex-a57"]
-    rpath = []
-
-    if QCOM_REPLAY:
-      cflags += ["-DQCOM_REPLAY"]
-      cxxflags += ["-DQCOM_REPLAY"]
-
+    cflags = ["-DQCOM", "-D_USING_LIBCXX", "-mcpu=cortex-a57"]
+    cxxflags = ["-DQCOM", "-D_USING_LIBCXX", "-mcpu=cortex-a57"]
 else:
   cflags = []
   cxxflags = []
+  cpppath = []
 
-  lenv = {
-    "PATH": "#external/bin:" + os.environ['PATH'],
-  }
-  cpppath = [
-    "#external/tensorflow/include",
-  ]
-
+  # MacOS
   if arch == "Darwin":
+    brew_prefix = subprocess.check_output(['brew', '--prefix'], encoding='utf8').strip()
+    yuv_dir = "mac" if real_arch != "arm64" else "mac_arm64"
     libpath = [
-      "#phonelibs/libyuv/mac/lib",
-      "#cereal",
-      "#selfdrive/common",
-      "/usr/local/lib",
+      f"#third_party/libyuv/{yuv_dir}/lib",
+      f"{brew_prefix}/lib",
+      f"{brew_prefix}/Library",
+      f"{brew_prefix}/opt/openssl/lib",
+      f"{brew_prefix}/Cellar",
+      f"#third_party/acados/{arch}/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/include",
+    ]
+  # Linux 86_64
   else:
     libpath = [
-      "#phonelibs/snpe/x86_64-linux-clang",
-      "#phonelibs/libyuv/x64/lib",
-      "#external/tensorflow/lib",
+      "#third_party/acados/x86_64/lib",
+      "#third_party/snpe/x86_64-linux-clang",
+      "#third_party/libyuv/x64/lib",
+      "#third_party/mapbox-gl-native-qt/x86_64",
       "#cereal",
       "#selfdrive/common",
       "/usr/lib",
       "/usr/local/lib",
     ]
 
-  rpath = [
-    "phonelibs/snpe/x86_64-linux-clang",
-    "external/tensorflow/lib",
-    "cereal",
-    "selfdrive/common"
+  rpath += [
+    Dir("#third_party/snpe/x86_64-linux-clang").abspath,
+    Dir("#cereal").abspath,
+    Dir("#selfdrive/common").abspath
   ]
 
-  # allows shared libraries to work globally
-  rpath = [os.path.join(os.getcwd(), x) for x in rpath]
-
 if GetOption('asan'):
-  ccflags_asan = ["-fsanitize=address", "-fno-omit-frame-pointer"]
-  ldflags_asan = ["-fsanitize=address"]
+  ccflags = ["-fsanitize=address", "-fno-omit-frame-pointer"]
+  ldflags = ["-fsanitize=address"]
+elif GetOption('ubsan'):
+  ccflags = ["-fsanitize=undefined"]
+  ldflags = ["-fsanitize=undefined"]
 else:
-  ccflags_asan = []
-  ldflags_asan = []
+  ccflags = []
+  ldflags = []
 
-# change pythonpath to this
-lenv["PYTHONPATH"] = Dir("#").path
+# no --as-needed on mac linker
+if arch != "Darwin":
+  ldflags += ["-Wl,--as-needed", "-Wl,--no-undefined"]
+
+# Enable swaglog include in submodules
+cflags += ['-DSWAGLOG="\\"selfdrive/common/swaglog.h\\""']
+cxxflags += ['-DSWAGLOG="\\"selfdrive/common/swaglog.h\\""']
 
 env = Environment(
   ENV=lenv,
@@ -136,44 +182,43 @@ env = Environment(
     "-O2",
     "-Wunused",
     "-Werror",
+    "-Wshadow",
     "-Wno-unknown-warning-option",
     "-Wno-deprecated-register",
     "-Wno-register",
     "-Wno-inconsistent-missing-override",
     "-Wno-c99-designator",
     "-Wno-reorder-init-list",
-  ] + cflags + ccflags_asan,
+    "-Wno-error=unused-but-set-variable",
+  ] + cflags + ccflags,
 
   CPPPATH=cpppath + [
     "#",
-    "#selfdrive",
-    "#phonelibs/bzip2",
-    "#phonelibs/libyuv/include",
-    "#phonelibs/openmax/include",
-    "#phonelibs/json11",
-    "#phonelibs/curl/include",
-    "#phonelibs/libgralloc/include",
-    "#phonelibs/android_frameworks_native/include",
-    "#phonelibs/android_hardware_libhardware/include",
-    "#phonelibs/android_system_core/include",
-    "#phonelibs/linux/include",
-    "#phonelibs/snpe/include",
-    "#phonelibs/nanovg",
-    "#selfdrive/common",
-    "#selfdrive/camerad",
-    "#selfdrive/camerad/include",
-    "#selfdrive/loggerd/include",
-    "#selfdrive/modeld",
-    "#selfdrive/sensord",
-    "#selfdrive/ui",
-    "#cereal/messaging",
+    "#third_party/acados/include",
+    "#third_party/acados/include/blasfeo/include",
+    "#third_party/acados/include/hpipm/include",
+    "#third_party/catch2/include",
+    "#third_party/bzip2",
+    "#third_party/libyuv/include",
+    "#third_party/openmax/include",
+    "#third_party/json11",
+    "#third_party/curl/include",
+    "#third_party/libgralloc/include",
+    "#third_party/android_frameworks_native/include",
+    "#third_party/android_hardware_libhardware/include",
+    "#third_party/android_system_core/include",
+    "#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_asan,
+  LINKFLAGS=ldflags,
 
   RPATH=rpath,
 
@@ -181,64 +226,26 @@ env = Environment(
   CXXFLAGS=["-std=c++1z"] + cxxflags,
   LIBPATH=libpath + [
     "#cereal",
+    "#third_party",
+    "#opendbc/can",
+    "#selfdrive/boardd",
     "#selfdrive/common",
-    "#phonelibs",
-  ]
+  ],
+  CYTHONCFILESUFFIX=".cpp",
+  COMPILATIONDB_USE_ABSPATH=True,
+  tools=["default", "cython", "compilation_db"],
 )
 
-qt_env = None
-if arch in ["x86_64", "Darwin", "larch64"]:
-  qt_env = env.Clone()
+if arch == "Darwin":
+  env['RPATHPREFIX'] = "-rpath "
 
-  if arch == "Darwin":
-    qt_env['QTDIR'] = "/usr/local/opt/qt"
-    QT_BASE = "/usr/local/opt/qt/"
-    qt_dirs = [
-      QT_BASE + "include/",
-      QT_BASE + "include/QtWidgets",
-      QT_BASE + "include/QtGui",
-      QT_BASE + "include/QtCore",
-      QT_BASE + "include/QtDBus",
-      QT_BASE + "include/QtMultimedia",
-    ]
-    qt_env["LINKFLAGS"] += ["-F" + QT_BASE + "lib"]
-  else:
-    qt_env['QTDIR'] = "/usr"
-    qt_dirs = [
-      f"/usr/include/{real_arch}-linux-gnu/qt5",
-      f"/usr/include/{real_arch}-linux-gnu/qt5/QtWidgets",
-      f"/usr/include/{real_arch}-linux-gnu/qt5/QtGui",
-      f"/usr/include/{real_arch}-linux-gnu/qt5/QtCore",
-      f"/usr/include/{real_arch}-linux-gnu/qt5/QtDBus",
-      f"/usr/include/{real_arch}-linux-gnu/qt5/QtMultimedia",
-      f"/usr/include/{real_arch}-linux-gnu/qt5/QtGui/5.5.1/QtGui",
-    ]
+if GetOption('compile_db'):
+  env.CompilationDatabase('compile_commands.json')
 
-  qt_env.Tool('qt')
-  qt_env['CPPPATH'] += qt_dirs
-  qt_flags = [
-    "-D_REENTRANT",
-    "-DQT_NO_DEBUG",
-    "-DQT_WIDGETS_LIB",
-    "-DQT_GUI_LIB",
-    "-DQT_CORE_LIB"
-  ]
-  qt_env['CXXFLAGS'] += qt_flags
-
-if os.environ.get('SCONS_CACHE'):
-  cache_dir = '/tmp/scons_cache'
-
-  if os.getenv('CI'):
-    branch = os.getenv('GIT_BRANCH')
-
-    if QCOM_REPLAY:
-      cache_dir = '/tmp/scons_cache_qcom_replay'
-    elif branch is not None and branch != 'master':
-      cache_dir_branch = '/tmp/scons_cache_' + branch
-      if not os.path.isdir(cache_dir_branch) and os.path.isdir(cache_dir):
-        shutil.copytree(cache_dir, cache_dir_branch)
-      cache_dir = cache_dir_branch
-  CacheDir(cache_dir)
+# Setup cache dir
+cache_dir = '/data/scons_cache' if TICI else '/tmp/scons_cache'
+CacheDir(cache_dir)
+Clean(["."], cache_dir)
 
 node_interval = 5
 node_count = 0
@@ -261,9 +268,105 @@ def abspath(x):
     # rpath works elsewhere
     return x[0].path.rsplit("/", 1)[1][:-3]
 
-# still needed for apks
-zmq = 'zmq'
-Export('env', 'qt_env', 'arch', 'zmq', 'SHARED', 'USE_WEBCAM', 'QCOM_REPLAY')
+# Cython build enviroment
+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["LIBS"] = []
+if arch == "Darwin":
+  envCython["LINKFLAGS"] = ["-bundle", "-undefined", "dynamic_lookup"]
+elif arch == "aarch64":
+  envCython["LINKFLAGS"] = ["-shared"]
+  envCython["LIBS"] = [os.path.basename(py_include)]
+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"]
+if arch != "aarch64":
+  qt_modules += ["DBus"]
+
+qt_libs = []
+if arch == "Darwin":
+  if real_arch == "arm64":
+    qt_env['QTDIR'] = "/opt/homebrew/opt/qt@5"
+  else:
+    qt_env['QTDIR'] = "/usr/local/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"))
+elif arch == "aarch64":
+  qt_env['QTDIR'] = "/usr"
+  qt_dirs = [
+    f"/usr/include/qt",
+  ]
+  qt_dirs += [f"/usr/include/qt/Qt{m}" for m in qt_modules]
+
+  qt_libs = [f"Qt5{m}" for m in qt_modules]
+  qt_libs += ['EGL', 'GLESv3', 'c++_shared']
+else:
+  qt_env['QTDIR'] = "/usr"
+  qt_dirs = [
+    f"/usr/include/{real_arch}-linux-gnu/qt5",
+    f"/usr/include/{real_arch}-linux-gnu/qt5/QtGui/5.12.8/QtGui",
+  ]
+  qt_dirs += [f"/usr/include/{real_arch}-linux-gnu/qt5/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"]
+  elif arch != "Darwin":
+    qt_libs += ["GL"]
+
+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', 'USE_WEBCAM')
+
+SConscript(['selfdrive/common/SConscript'])
+Import('_common', '_gpucommon', '_gpu_libs')
+
+if SHARED:
+  common, gpucommon = abspath(common), abspath(gpucommon)
+else:
+  common = [_common, 'json11']
+  gpucommon = [_gpucommon] + _gpu_libs
+
+Export('common', 'gpucommon')
 
 # cereal and messaging are shared with the system
 SConscript(['cereal/SConscript'])
@@ -273,34 +376,51 @@ if SHARED:
 else:
   cereal = [File('#cereal/libcereal.a')]
   messaging = [File('#cereal/libmessaging.a')]
-Export('cereal', 'messaging')
+  visionipc = [File('#cereal/libvisionipc.a')]
 
-SConscript(['selfdrive/common/SConscript'])
-Import('_common', '_visionipc', '_gpucommon', '_gpu_libs')
+Export('cereal', 'messaging', 'visionipc')
 
-if SHARED:
-  common, visionipc, gpucommon = abspath(common), abspath(visionipc), abspath(gpucommon)
-else:
-  common = [_common, 'json11']
-  visionipc = _visionipc
-  gpucommon = [_gpucommon] + _gpu_libs
+# Build rednose library and ekf models
 
-Export('common', 'visionipc', 'gpucommon')
+rednose_config = {
+  'generated_folder': '#selfdrive/locationd/models/generated',
+  'to_build': {
+    'live': ('#selfdrive/locationd/models/live_kf.py', True, ['live_kf_constants.h']),
+    'car': ('#selfdrive/locationd/models/car_kf.py', True, []),
+  },
+}
 
+if arch not in ["aarch64", "larch64"]:
+  rednose_config['to_build'].update({
+    'gnss': ('#selfdrive/locationd/models/gnss_kf.py', True, []),
+    'loc_4': ('#selfdrive/locationd/models/loc_kf.py', True, []),
+    '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, []),
+    'lane': ('#xx/pipeline/lib/ekf/lane_kf.py', True, []),
+  })
+
+Export('rednose_config')
+SConscript(['rednose/SConscript'])
+
+# Build openpilot
+
+SConscript(['cereal/SConscript'])
+SConscript(['panda/board/SConscript'])
 SConscript(['opendbc/can/SConscript'])
 
+SConscript(['third_party/SConscript'])
+
 SConscript(['common/SConscript'])
 SConscript(['common/kalman/SConscript'])
 SConscript(['common/transformations/SConscript'])
-SConscript(['phonelibs/SConscript'])
 
 SConscript(['selfdrive/camerad/SConscript'])
 SConscript(['selfdrive/modeld/SConscript'])
 
 SConscript(['selfdrive/controls/lib/cluster/SConscript'])
-SConscript(['selfdrive/controls/lib/lateral_mpc/SConscript'])
-SConscript(['selfdrive/controls/lib/longitudinal_mpc/SConscript'])
-SConscript(['selfdrive/controls/lib/longitudinal_mpc_model/SConscript'])
+SConscript(['selfdrive/controls/lib/lateral_mpc_lib/SConscript'])
+SConscript(['selfdrive/controls/lib/longitudinal_mpc_lib/SConscript'])
 
 SConscript(['selfdrive/boardd/SConscript'])
 SConscript(['selfdrive/proclogd/SConscript'])
@@ -309,13 +429,15 @@ SConscript(['selfdrive/clocksd/SConscript'])
 SConscript(['selfdrive/loggerd/SConscript'])
 
 SConscript(['selfdrive/locationd/SConscript'])
-SConscript(['selfdrive/locationd/models/SConscript'])
 SConscript(['selfdrive/sensord/SConscript'])
 SConscript(['selfdrive/ui/SConscript'])
 
 if arch != "Darwin":
   SConscript(['selfdrive/logcatd/SConscript'])
 
+if GetOption('test'):
+  SConscript('panda/tests/safety/SConscript')
 
-if arch == "x86_64":
-  SConscript(['tools/lib/index_log/SConscript'])
+external_sconscript = GetOption('external_sconscript')
+if external_sconscript:
+  SConscript([external_sconscript])

cereal

@@ -0,0 +1 @@
+Subproject commit a818779f1a55c6bf53fa0692e31111585662b722

cereal/.gitignore

@@ -1,14 +0,0 @@
-gen
-node_modules
-package-lock.json
-*.pyc
-__pycache__
-.*.swp
-.*.swo
-libcereal*.a
-libmessaging.*
-libmessaging_shared.*
-services.h
-.sconsign.dblite
-libcereal_shared.*
-.mypy_cache/

cereal/SConscript

@@ -1,64 +0,0 @@
-Import('env', 'arch', 'zmq', 'cython_dependencies')
-
-import shutil
-
-gen_dir = Dir('gen')
-messaging_dir = Dir('messaging')
-
-# TODO: remove src-prefix and cereal from command string. can we set working directory?
-env.Command(["gen/c/include/c++.capnp.h", "gen/c/include/java.capnp.h"], [], "mkdir -p " + gen_dir.path + "/c/include && touch $TARGETS")
-env.Command(['gen/cpp/car.capnp.c++', 'gen/cpp/log.capnp.c++', 'gen/cpp/car.capnp.h', 'gen/cpp/log.capnp.h'],
-            ['car.capnp', 'log.capnp'],
-            'capnpc $SOURCES --src-prefix=cereal -o c++:' + gen_dir.path + '/cpp/')
-
-if shutil.which('capnpc-java'):
-  env.Command(['gen/java/Car.java', 'gen/java/Log.java'],
-              ['car.capnp', 'log.capnp'],
-              'capnpc $SOURCES --src-prefix=cereal -o java:' + gen_dir.path + '/java/')
-
-# TODO: remove non shared cereal and messaging
-cereal_objects = env.SharedObject([
-  'gen/cpp/car.capnp.c++',
-  'gen/cpp/log.capnp.c++',
-])
-
-env.Library('cereal', cereal_objects)
-env.SharedLibrary('cereal_shared', cereal_objects)
-
-cereal_dir = Dir('.')
-services_h = env.Command(['services.h'],
-                          ['service_list.yaml', 'services.py'],
-                          'python3 ' + cereal_dir.path + '/services.py > $TARGET')
-
-messaging_objects = env.SharedObject([
-  'messaging/messaging.cc',
-  'messaging/impl_zmq.cc',
-  'messaging/impl_msgq.cc',
-  'messaging/msgq.cc',
-  'messaging/socketmaster.cc',
-])
-
-messaging_lib = env.Library('messaging', messaging_objects)
-Depends('messaging/impl_zmq.cc', services_h)
-
-# note, this rebuilds the deps shared, zmq is statically linked to make APK happy
-# TODO: get APK to load system zmq to remove the static link
-if arch == "aarch64":
-  zmq_static = FindFile("libzmq.a", "/usr/lib")
-  shared_lib_shared_lib = [zmq_static, 'm', 'stdc++', "gnustl_shared", "kj", "capnp"]
-  env.SharedLibrary('messaging_shared', messaging_objects, LIBS=shared_lib_shared_lib)
-
-env.Program('messaging/bridge', ['messaging/bridge.cc'], LIBS=[messaging_lib, 'zmq'])
-Depends('messaging/bridge.cc', services_h)
-
-# different target?
-#env.Program('messaging/demo', ['messaging/demo.cc'], LIBS=[messaging_lib, 'zmq'])
-
-
-env.Command(['messaging/messaging_pyx.so', 'messaging/messaging_pyx.cpp'],
-            cython_dependencies + [messaging_lib, 'messaging/messaging_pyx_setup.py', 'messaging/messaging_pyx.pyx', 'messaging/messaging.pxd'],
-            "cd " + messaging_dir.path + " && python3 messaging_pyx_setup.py build_ext --inplace")
-
-
-if GetOption('test'):
-  env.Program('messaging/test_runner', ['messaging/test_runner.cc', 'messaging/msgq_tests.cc'], LIBS=[messaging_lib])

cereal/__init__.py

@@ -1,9 +0,0 @@
-# pylint: skip-file
-import os
-import capnp
-
-CEREAL_PATH = os.path.dirname(os.path.abspath(__file__))
-capnp.remove_import_hook()
-
-log = capnp.load(os.path.join(CEREAL_PATH, "log.capnp"))
-car = capnp.load(os.path.join(CEREAL_PATH, "car.capnp"))

cereal/car.capnp

@@ -1,536 +0,0 @@
-using Cxx = import "./include/c++.capnp";
-$Cxx.namespace("cereal");
-
-using Java = import "./include/java.capnp";
-$Java.package("ai.comma.openpilot.cereal");
-$Java.outerClassname("Car");
-
-@0x8e2af1e708af8b8d;
-
-# ******* events causing controls state machine transition *******
-
-struct CarEvent @0x9b1657f34caf3ad3 {
-  name @0 :EventName;
-  enable @1 :Bool;
-  noEntry @2 :Bool;
-  warning @3 :Bool;   # alerts presented only when  enabled or soft disabling
-  userDisable @4 :Bool;
-  softDisable @5 :Bool;
-  immediateDisable @6 :Bool;
-  preEnable @7 :Bool;
-  permanent @8 :Bool; # alerts presented regardless of openpilot state
-
-  enum EventName @0xbaa8c5d505f727de {
-    # TODO: copy from error list
-    canError @0;
-    steerUnavailable @1;
-    brakeUnavailable @2;
-    wrongGear @4;
-    doorOpen @5;
-    seatbeltNotLatched @6;
-    espDisabled @7;
-    wrongCarMode @8;
-    steerTempUnavailable @9;
-    reverseGear @10;
-    buttonCancel @11;
-    buttonEnable @12;
-    pedalPressed @13;
-    cruiseDisabled @14;
-    radarCanError @15;
-    speedTooLow @17;
-    outOfSpace @18;
-    overheat @19;
-    calibrationIncomplete @20;
-    calibrationInvalid @21;
-    controlsMismatch @22;
-    pcmEnable @23;
-    pcmDisable @24;
-    noTarget @25;
-    radarFault @26;
-    brakeHold @28;
-    parkBrake @29;
-    manualRestart @30;
-    lowSpeedLockout @31;
-    plannerError @32;
-    debugAlert @34;
-    steerTempUnavailableMute @35;
-    resumeRequired @36;
-    preDriverDistracted @37;
-    promptDriverDistracted @38;
-    driverDistracted @39;
-    preDriverUnresponsive @43;
-    promptDriverUnresponsive @44;
-    driverUnresponsive @45;
-    belowSteerSpeed @46;
-    lowBattery @48;
-    vehicleModelInvalid @50;
-    controlsFailed @51;
-    sensorDataInvalid @52;
-    commIssue @53;
-    tooDistracted @54;
-    posenetInvalid @55;
-    soundsUnavailable @56;
-    preLaneChangeLeft @57;
-    preLaneChangeRight @58;
-    laneChange @59;
-    invalidGiraffeToyota @60;
-    internetConnectivityNeeded @61;
-    communityFeatureDisallowed @62;
-    lowMemory @63;
-    stockAeb @64;
-    ldw @65;
-    carUnrecognized @66;
-    radarCommIssue @67;
-    driverMonitorLowAcc @68;
-    invalidLkasSetting @69;
-    speedTooHigh @70;
-    laneChangeBlocked @71;
-    relayMalfunction @72;
-    gasPressed @73;
-    stockFcw @74;
-    startup @75;
-    startupNoCar @76;
-    startupNoControl @77;
-    startupMaster @78;
-    fcw @79;
-    steerSaturated @80;
-    whitePandaUnsupported @81;
-    startupGreyPanda @82;
-    belowEngageSpeed @84;
-    noGps @85;
-    wrongCruiseMode @87;
-    modeldLagging @89;
-    deviceFalling @90;
-    fanMalfunction @91;
-
-    gasUnavailableDEPRECATED @3;
-    dataNeededDEPRECATED @16;
-    modelCommIssueDEPRECATED @27;
-    ipasOverrideDEPRECATED @33;
-    geofenceDEPRECATED @40;
-    driverMonitorOnDEPRECATED @41;
-    driverMonitorOffDEPRECATED @42;
-    calibrationProgressDEPRECATED @47;
-    invalidGiraffeHondaDEPRECATED @49;
-    canErrorPersistentDEPRECATED @83;
-    focusRecoverActiveDEPRECATED @86;
-    neosUpdateRequiredDEPRECATED @88;
-  }
-}
-
-# ******* main car state @ 100hz *******
-# all speeds in m/s
-
-struct CarState {
-  errorsDEPRECATED @0 :List(CarEvent.EventName);
-  events @13 :List(CarEvent);
-
-  # car speed
-  vEgo @1 :Float32;         # best estimate of speed
-  aEgo @16 :Float32;        # best estimate of acceleration
-  vEgoRaw @17 :Float32;     # unfiltered speed from CAN sensors
-  yawRate @22 :Float32;     # best estimate of yaw rate
-  standstill @18 :Bool;
-  wheelSpeeds @2 :WheelSpeeds;
-
-  # gas pedal, 0.0-1.0
-  gas @3 :Float32;        # this is user + computer
-  gasPressed @4 :Bool;    # this is user pedal only
-
-  # brake pedal, 0.0-1.0
-  brake @5 :Float32;      # this is user pedal only
-  brakePressed @6 :Bool;  # this is user pedal only
-  brakeLights @19 :Bool;
-
-  # steering wheel
-  steeringAngle @7 :Float32;       # deg
-  steeringRate @15 :Float32;       # deg/s
-  steeringTorque @8 :Float32;      # TODO: standardize units
-  steeringTorqueEps @27 :Float32;  # TODO: standardize units
-  steeringPressed @9 :Bool;        # if the user is using the steering wheel
-  steeringRateLimited @29 :Bool;   # if the torque is limited by the rate limiter
-  steerWarning @35 :Bool;          # temporary steer unavailble
-  steerError @36 :Bool;            # permanent steer error
-  stockAeb @30 :Bool;
-  stockFcw @31 :Bool;
-  espDisabled @32 :Bool;
-
-  # cruise state
-  cruiseState @10 :CruiseState;
-
-  # gear
-  gearShifter @14 :GearShifter;
-
-  # button presses
-  buttonEvents @11 :List(ButtonEvent);
-  leftBlinker @20 :Bool;
-  rightBlinker @21 :Bool;
-  genericToggle @23 :Bool;
-
-  # lock info
-  doorOpen @24 :Bool;
-  seatbeltUnlatched @25 :Bool;
-  canValid @26 :Bool;
-
-  # clutch (manual transmission only)
-  clutchPressed @28 :Bool;
-
-  # which packets this state came from
-  canMonoTimes @12: List(UInt64);
-
-  # blindspot sensors
-  leftBlindspot @33 :Bool; # Is there something blocking the left lane change
-  rightBlindspot @34 :Bool; # Is there something blocking the right lane change
-
-  struct WheelSpeeds {
-    # optional wheel speeds
-    fl @0 :Float32;
-    fr @1 :Float32;
-    rl @2 :Float32;
-    rr @3 :Float32;
-  }
-
-  struct CruiseState {
-    enabled @0 :Bool;
-    speed @1 :Float32;
-    available @2 :Bool;
-    speedOffset @3 :Float32;
-    standstill @4 :Bool;
-    nonAdaptive @5 :Bool;
-  }
-
-  enum GearShifter {
-    unknown @0;
-    park @1;
-    drive @2;
-    neutral @3;
-    reverse @4;
-    sport @5;
-    low @6;
-    brake @7;
-    eco @8;
-    manumatic @9;
-  }
-
-  # send on change
-  struct ButtonEvent {
-    pressed @0 :Bool;
-    type @1 :Type;
-
-    enum Type {
-      unknown @0;
-      leftBlinker @1;
-      rightBlinker @2;
-      accelCruise @3;
-      decelCruise @4;
-      cancel @5;
-      altButton1 @6;
-      altButton2 @7;
-      altButton3 @8;
-      setCruise @9;
-      resumeCruise @10;
-      gapAdjustCruise @11;
-    }
-  }
-}
-
-# ******* radar state @ 20hz *******
-
-struct RadarData @0x888ad6581cf0aacb {
-  errors @0 :List(Error);
-  points @1 :List(RadarPoint);
-
-  # which packets this state came from
-  canMonoTimes @2 :List(UInt64);
-
-  enum Error {
-    canError @0;
-    fault @1;
-    wrongConfig @2;
-  }
-
-  # similar to LiveTracks
-  # is one timestamp valid for all? I think so
-  struct RadarPoint {
-    trackId @0 :UInt64;  # no trackId reuse
-
-    # these 3 are the minimum required
-    dRel @1 :Float32; # m from the front bumper of the car
-    yRel @2 :Float32; # m
-    vRel @3 :Float32; # m/s
-
-    # these are optional and valid if they are not NaN
-    aRel @4 :Float32; # m/s^2
-    yvRel @5 :Float32; # m/s
-
-    # some radars flag measurements VS estimates
-    measured @6 :Bool;
-  }
-}
-
-# ******* car controls @ 100hz *******
-
-struct CarControl {
-  # must be true for any actuator commands to work
-  enabled @0 :Bool;
-  active @7 :Bool;
-
-  gasDEPRECATED @1 :Float32;
-  brakeDEPRECATED @2 :Float32;
-  steeringTorqueDEPRECATED @3 :Float32;
-
-  actuators @6 :Actuators;
-
-  cruiseControl @4 :CruiseControl;
-  hudControl @5 :HUDControl;
-
-  struct Actuators {
-    # range from 0.0 - 1.0
-    gas @0: Float32;
-    brake @1: Float32;
-    # range from -1.0 - 1.0
-    steer @2: Float32;
-    steerAngle @3: Float32;
-  }
-
-  struct CruiseControl {
-    cancel @0: Bool;
-    override @1: Bool;
-    speedOverride @2: Float32;
-    accelOverride @3: Float32;
-  }
-
-  struct HUDControl {
-    speedVisible @0: Bool;
-    setSpeed @1: Float32;
-    lanesVisible @2: Bool;
-    leadVisible @3: Bool;
-    visualAlert @4: VisualAlert;
-    audibleAlert @5: AudibleAlert;
-    rightLaneVisible @6: Bool;
-    leftLaneVisible @7: Bool;
-    rightLaneDepart @8: Bool;
-    leftLaneDepart @9: Bool;
-
-    enum VisualAlert {
-      # these are the choices from the Honda
-      # map as good as you can for your car
-      none @0;
-      fcw @1;
-      steerRequired @2;
-      brakePressed @3;
-      wrongGear @4;
-      seatbeltUnbuckled @5;
-      speedTooHigh @6;
-      ldw @7;
-    }
-
-    enum AudibleAlert {
-      # these are the choices from the Honda
-      # map as good as you can for your car
-      none @0;
-      chimeEngage @1;
-      chimeDisengage @2;
-      chimeError @3;
-      chimeWarning1 @4;
-      chimeWarning2 @5;
-      chimeWarningRepeat @6;
-      chimePrompt @7;
-      chimeWarning2Repeat @8;
-    }
-  }
-}
-
-# ****** car param ******
-
-struct CarParams {
-  carName @0 :Text;
-  carFingerprint @1 :Text;
-
-  enableGasInterceptor @2 :Bool;
-  enableCruise @3 :Bool;
-  enableCamera @4 :Bool;
-  enableDsu @5 :Bool; # driving support unit
-  enableApgs @6 :Bool; # advanced parking guidance system
-
-  minEnableSpeed @7 :Float32;
-  minSteerSpeed @8 :Float32;
-  safetyModel @9 :SafetyModel;
-  safetyModelPassive @42 :SafetyModel = silent;
-  safetyParam @10 :Int16;
-
-  steerMaxBP @11 :List(Float32);
-  steerMaxV @12 :List(Float32);
-  gasMaxBP @13 :List(Float32);
-  gasMaxV @14 :List(Float32);
-  brakeMaxBP @15 :List(Float32);
-  brakeMaxV @16 :List(Float32);
-
-  # things about the car in the manual
-  mass @17 :Float32;             # [kg] running weight
-  wheelbase @18 :Float32;        # [m] distance from rear to front axle
-  centerToFront @19 :Float32;   # [m] GC distance to front axle
-  steerRatio @20 :Float32;       # [] ratio between front wheels and steering wheel angles
-  steerRatioRear @21 :Float32;  # [] rear steering ratio wrt front steering (usually 0)
-
-  # things we can derive
-  rotationalInertia @22 :Float32;    # [kg*m2] body rotational inertia
-  tireStiffnessFront @23 :Float32;   # [N/rad] front tire coeff of stiff
-  tireStiffnessRear @24 :Float32;    # [N/rad] rear tire coeff of stiff
-
-  longitudinalTuning @25 :LongitudinalPIDTuning;
-  lateralParams @48 :LateralParams;
-  lateralTuning :union {
-    pid @26 :LateralPIDTuning;
-    indi @27 :LateralINDITuning;
-    lqr @40 :LateralLQRTuning;
-  }
-
-  steerLimitAlert @28 :Bool;
-  steerLimitTimer @47 :Float32;  # time before steerLimitAlert is issued
-
-  vEgoStopping @29 :Float32; # Speed at which the car goes into stopping state
-  directAccelControl @30 :Bool; # Does the car have direct accel control or just gas/brake
-  stoppingControl @31 :Bool; # Does the car allows full control even at lows speeds when stopping
-  startAccel @32 :Float32; # Required acceleraton to overcome creep braking
-  steerRateCost @33 :Float32; # Lateral MPC cost on steering rate
-  steerControlType @34 :SteerControlType;
-  radarOffCan @35 :Bool; # True when radar objects aren't visible on CAN
-
-  steerActuatorDelay @36 :Float32; # Steering wheel actuator delay in seconds
-  openpilotLongitudinalControl @37 :Bool; # is openpilot doing the longitudinal control?
-  carVin @38 :Text; # VIN number queried during fingerprinting
-  isPandaBlack @39: Bool;
-  dashcamOnly @41: Bool;
-  transmissionType @43 :TransmissionType;
-  carFw @44 :List(CarFw);
-  radarTimeStep @45: Float32 = 0.05;  # time delta between radar updates, 20Hz is very standard
-  communityFeature @46: Bool;  # true if a community maintained feature is detected
-  fingerprintSource @49: FingerprintSource;
-  networkLocation @50 :NetworkLocation;  # Where Panda/C2 is integrated into the car's CAN network
-
-  struct LateralParams {
-    torqueBP @0 :List(Int32);
-    torqueV @1 :List(Int32);
-  }
-
-  struct LateralPIDTuning {
-    kpBP @0 :List(Float32);
-    kpV @1 :List(Float32);
-    kiBP @2 :List(Float32);
-    kiV @3 :List(Float32);
-    kf @4 :Float32;
-  }
-
-  struct LongitudinalPIDTuning {
-    kpBP @0 :List(Float32);
-    kpV @1 :List(Float32);
-    kiBP @2 :List(Float32);
-    kiV @3 :List(Float32);
-    deadzoneBP @4 :List(Float32);
-    deadzoneV @5 :List(Float32);
-  }
-
-  struct LateralINDITuning {
-    outerLoopGain @0 :Float32;
-    innerLoopGain @1 :Float32;
-    timeConstant @2 :Float32;
-    actuatorEffectiveness @3 :Float32;
-  }
-
-  struct LateralLQRTuning {
-    scale @0 :Float32;
-    ki @1 :Float32;
-    dcGain @2 :Float32;
-
-    # State space system
-    a @3 :List(Float32);
-    b @4 :List(Float32);
-    c @5 :List(Float32);
-
-    k @6 :List(Float32);  # LQR gain
-    l @7 :List(Float32);  # Kalman gain
-  }
-
-  enum SafetyModel {
-    silent @0;
-    hondaNidec @1;
-    toyota @2;
-    elm327 @3;
-    gm @4;
-    hondaBoschGiraffe @5;
-    ford @6;
-    cadillac @7;
-    hyundai @8;
-    chrysler @9;
-    tesla @10;
-    subaru @11;
-    gmPassive @12;
-    mazda @13;
-    nissan @14;
-    volkswagen @15;
-    toyotaIpas @16;
-    allOutput @17;
-    gmAscm @18;
-    noOutput @19;  # like silent but without silent CAN TXs
-    hondaBoschHarness @20;
-    volkswagenPq @21;
-    subaruLegacy @22;  # pre-Global platform
-    hyundaiLegacy @23;
-    hyundaiCommunity @24;
-  }
-
-  enum SteerControlType {
-    torque @0;
-    angle @1;
-  }
-
-  enum TransmissionType {
-    unknown @0;
-    automatic @1;  # Traditional auto, including DSG
-    manual @2;  # True "stick shift" only
-    direct @3;  # Electric vehicle or other direct drive
-  }
-
-  struct CarFw {
-    ecu @0 :Ecu;
-    fwVersion @1 :Data;
-    address @2: UInt32;
-    subAddress @3: UInt8;
-  }
-
-  enum Ecu {
-    eps @0;
-    esp @1;
-    fwdRadar @2;
-    fwdCamera @3;
-    engine @4;
-    unknown @5;
-    transmission @8; # Transmission Control Module
-    srs @9; # airbag
-    gateway @10; # can gateway
-    hud @11; # heads up display
-    combinationMeter @12; # instrument cluster
-
-    # Toyota only
-    dsu @6;
-    apgs @7;
-
-    # Honda only
-    vsa @13; # Vehicle Stability Assist
-    programmedFuelInjection @14;
-    electricBrakeBooster @15;
-    shiftByWire @16;
-  }
-
-  enum FingerprintSource {
-    can @0;
-    fw @1;
-    fixed @2;
-  }
-
-  enum NetworkLocation {
-    fwdCamera @0;  # Standard/default integration at LKAS camera
-    gateway @1;    # Integration at vehicle's CAN gateway
-  }
-}

cereal/include/c++.capnp

@@ -1,26 +0,0 @@
-# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
-# Licensed under the MIT License:
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# 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.
-
-@0xbdf87d7bb8304e81;
-$namespace("capnp::annotations");
-
-annotation namespace(file): Text;
-annotation name(field, enumerant, struct, enum, interface, method, param, group, union): Text;

cereal/include/java.capnp

@@ -1,28 +0,0 @@
-# Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
-# Licensed under the MIT License:
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# 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.
-
-@0xc5f1af96651f70ea;
-
-annotation package @0x9ee4c8f803b3b596 (file) : Text;
-# Name of the package, such as "org.example.foo", in which the generated code will reside.
-
-annotation outerClassname @0x9b066bb4881f7cd3 (file) : Text;
-# Name of the outer class that will wrap the generated code.

cereal/messaging/.gitignore

@@ -1,10 +0,0 @@
-demo
-bridge
-test_runner
-*.o
-*.os
-*.d
-*.a
-*.so
-messaging_pyx.cpp
-build/

cereal/messaging/__init__.py

@@ -1,225 +0,0 @@
-# must be build with scons
-from .messaging_pyx import Context, Poller, SubSocket, PubSocket  # pylint: disable=no-name-in-module, import-error
-from .messaging_pyx import MultiplePublishersError, MessagingError  # pylint: disable=no-name-in-module, import-error
-import capnp
-
-from typing import Optional, List, Union
-
-from cereal import log
-from cereal.services import service_list
-
-assert MultiplePublishersError
-assert MessagingError
-
-# sec_since_boot is faster, but allow to run standalone too
-try:
-  from common.realtime import sec_since_boot
-except ImportError:
-  import time
-  sec_since_boot = time.time
-  print("Warning, using python time.time() instead of faster sec_since_boot")
-
-context = Context()
-
-def new_message(service: Optional[str] = None, size: Optional[int] = None) -> capnp.lib.capnp._DynamicStructBuilder:
-  dat = log.Event.new_message()
-  dat.logMonoTime = int(sec_since_boot() * 1e9)
-  dat.valid = True
-  if service is not None:
-    if size is None:
-      dat.init(service)
-    else:
-      dat.init(service, size)
-  return dat
-
-def pub_sock(endpoint: str) -> PubSocket:
-  sock = PubSocket()
-  sock.connect(context, endpoint)
-  return sock
-
-def sub_sock(endpoint: str, poller: Optional[Poller] = None, addr: str = "127.0.0.1",
-             conflate: bool = False, timeout: Optional[int] = None) -> SubSocket:
-  sock = SubSocket()
-  sock.connect(context, endpoint, addr.encode('utf8'), conflate)
-
-  if timeout is not None:
-    sock.setTimeout(timeout)
-
-  if poller is not None:
-    poller.registerSocket(sock)
-  return sock
-
-
-def drain_sock_raw(sock: SubSocket, wait_for_one: bool = False) -> List[bytes]:
-  """Receive all message currently available on the queue"""
-  ret: List[bytes] = []
-  while 1:
-    if wait_for_one and len(ret) == 0:
-      dat = sock.receive()
-    else:
-      dat = sock.receive(non_blocking=True)
-
-    if dat is None:
-      break
-
-    ret.append(dat)
-
-  return ret
-
-def drain_sock(sock: SubSocket, wait_for_one: bool = False) -> List[capnp.lib.capnp._DynamicStructReader]:
-  """Receive all message currently available on the queue"""
-  ret: List[capnp.lib.capnp._DynamicStructReader] = []
-  while 1:
-    if wait_for_one and len(ret) == 0:
-      dat = sock.receive()
-    else:
-      dat = sock.receive(non_blocking=True)
-
-    if dat is None:  # Timeout hit
-      break
-
-    dat = log.Event.from_bytes(dat)
-    ret.append(dat)
-
-  return ret
-
-
-# TODO: print when we drop packets?
-def recv_sock(sock: SubSocket, wait: bool = False) -> Union[None, capnp.lib.capnp._DynamicStructReader]:
-  """Same as drain sock, but only returns latest message. Consider using conflate instead."""
-  dat = None
-
-  while 1:
-    if wait and dat is None:
-      rcv = sock.receive()
-    else:
-      rcv = sock.receive(non_blocking=True)
-
-    if rcv is None:  # Timeout hit
-      break
-
-    dat = rcv
-
-  if dat is not None:
-    dat = log.Event.from_bytes(dat)
-
-  return dat
-
-def recv_one(sock: SubSocket) -> Union[None, capnp.lib.capnp._DynamicStructReader]:
-  dat = sock.receive()
-  if dat is not None:
-    dat = log.Event.from_bytes(dat)
-  return dat
-
-def recv_one_or_none(sock: SubSocket) -> Union[None, capnp.lib.capnp._DynamicStructReader]:
-  dat = sock.receive(non_blocking=True)
-  if dat is not None:
-    dat = log.Event.from_bytes(dat)
-  return dat
-
-def recv_one_retry(sock: SubSocket) -> capnp.lib.capnp._DynamicStructReader:
-  """Keep receiving until we get a message"""
-  while True:
-    dat = sock.receive()
-    if dat is not None:
-      return log.Event.from_bytes(dat)
-
-class SubMaster():
-  def __init__(self, services: List[str], poll: Optional[List[str]] = None,
-               ignore_alive: Optional[List[str]] = None, addr:str ="127.0.0.1"):
-    self.frame = -1
-    self.updated = {s: False for s in services}
-    self.rcv_time = {s: 0. for s in services}
-    self.rcv_frame = {s: 0 for s in services}
-    self.alive = {s: False for s in services}
-    self.sock = {}
-    self.freq = {}
-    self.data = {}
-    self.valid = {}
-    self.logMonoTime = {}
-
-    self.poller = Poller()
-    self.non_polled_services = [s for s in services if poll is not None and
-                                len(poll) and s not in poll]
-
-    if ignore_alive is not None:
-      self.ignore_alive = ignore_alive
-    else:
-      self.ignore_alive = []
-
-    for s in services:
-      if addr is not None:
-        p = self.poller if s not in self.non_polled_services else None
-        self.sock[s] = sub_sock(s, poller=p, addr=addr, conflate=True)
-      self.freq[s] = service_list[s].frequency
-
-      try:
-        data = new_message(s)
-      except capnp.lib.capnp.KjException:  # pylint: disable=c-extension-no-member
-        data = new_message(s, 0) # lists
-
-      self.data[s] = getattr(data, s)
-      self.logMonoTime[s] = 0
-      self.valid[s] = data.valid
-
-  def __getitem__(self, s: str) -> capnp.lib.capnp._DynamicStructReader:
-    return self.data[s]
-
-  def update(self, timeout: int = 1000) -> None:
-    msgs = []
-    for sock in self.poller.poll(timeout):
-      msgs.append(recv_one_or_none(sock))
-
-    # non-blocking receive for non-polled sockets
-    for s in self.non_polled_services:
-      msgs.append(recv_one_or_none(self.sock[s]))
-    self.update_msgs(sec_since_boot(), msgs)
-
-  def update_msgs(self, cur_time: float, msgs: List[capnp.lib.capnp._DynamicStructReader]) -> None:
-    self.frame += 1
-    self.updated = dict.fromkeys(self.updated, False)
-    for msg in msgs:
-      if msg is None:
-        continue
-
-      s = msg.which()
-      self.updated[s] = True
-      self.rcv_time[s] = cur_time
-      self.rcv_frame[s] = self.frame
-      self.data[s] = getattr(msg, s)
-      self.logMonoTime[s] = msg.logMonoTime
-      self.valid[s] = msg.valid
-
-    for s in self.data:
-      # arbitrary small number to avoid float comparison. If freq is 0, we can skip the check
-      if self.freq[s] > 1e-5:
-        # alive if delay is within 10x the expected frequency
-        self.alive[s] = (cur_time - self.rcv_time[s]) < (10. / self.freq[s])
-      else:
-        self.alive[s] = True
-
-  def all_alive(self, service_list=None) -> bool:
-    if service_list is None:  # check all
-      service_list = self.alive.keys()
-    return all(self.alive[s] for s in service_list if s not in self.ignore_alive)
-
-  def all_valid(self, service_list=None) -> bool:
-    if service_list is None:  # check all
-      service_list = self.valid.keys()
-    return all(self.valid[s] for s in service_list)
-
-  def all_alive_and_valid(self, service_list=None) -> bool:
-    if service_list is None:  # check all
-      service_list = self.alive.keys()
-    return self.all_alive(service_list=service_list) and self.all_valid(service_list=service_list)
-
-class PubMaster():
-  def __init__(self, services: List[str]):
-    self.sock = {}
-    for s in services:
-      self.sock[s] = pub_sock(s)
-
-  def send(self, s: str, dat: Union[bytes, capnp.lib.capnp._DynamicStructBuilder]) -> None:
-    if not isinstance(dat, bytes):
-      dat = dat.to_bytes()
-    self.sock[s].send(dat)

cereal/messaging/bridge.cc

@@ -1,64 +0,0 @@
-#include <iostream>
-#include <string>
-#include <cassert>
-#include <csignal>
-#include <map>
-
-typedef void (*sighandler_t)(int sig);
-
-#include "services.h"
-
-#include "impl_msgq.hpp"
-#include "impl_zmq.hpp"
-
-void sigpipe_handler(int sig) {
-  assert(sig == SIGPIPE);
-  std::cout << "SIGPIPE received" << std::endl;
-}
-
-static std::vector<std::string> get_services() {
-  std::vector<std::string> name_list;
-
-  for (const auto& it : services) {
-    std::string name = it.name;
-    if (name == "plusFrame" || name == "uiLayoutState") continue;
-    name_list.push_back(name);
-  }
-
-  return name_list;
-}
-
-
-int main(void){
-  signal(SIGPIPE, (sighandler_t)sigpipe_handler);
-
-  auto endpoints = get_services();
-
-  std::map<SubSocket*, PubSocket*> sub2pub;
-
-  Context *zmq_context = new ZMQContext();
-  Context *msgq_context = new MSGQContext();
-  Poller *poller = new MSGQPoller();
-
-  for (auto endpoint: endpoints){
-    SubSocket * msgq_sock = new MSGQSubSocket();
-    msgq_sock->connect(msgq_context, endpoint, "127.0.0.1", false);
-    poller->registerSocket(msgq_sock);
-
-    PubSocket * zmq_sock = new ZMQPubSocket();
-    zmq_sock->connect(zmq_context, endpoint);
-
-    sub2pub[msgq_sock] = zmq_sock;
-  }
-
-
-  while (true){
-    for (auto sub_sock : poller->poll(100)){
-      Message * msg = sub_sock->receive();
-      if (msg == NULL) continue;
-      sub2pub[sub_sock]->sendMessage(msg);
-      delete msg;
-    }
-  }
-  return 0;
-}

cereal/messaging/impl_msgq.cc

@@ -1,210 +0,0 @@
-#include <cassert>
-#include <cstring>
-#include <iostream>
-#include <cstdlib>
-#include <csignal>
-#include <cerrno>
-
-
-#include "impl_msgq.hpp"
-
-volatile sig_atomic_t msgq_do_exit = 0;
-
-void sig_handler(int signal) {
-  assert(signal == SIGINT || signal == SIGTERM);
-  msgq_do_exit = 1;
-}
-
-static size_t get_size(std::string endpoint){
-  size_t sz = DEFAULT_SEGMENT_SIZE;
-
-#if !defined(QCOM) && !defined(QCOM2)
-  if (endpoint == "frame" || endpoint == "frontFrame" || endpoint == "wideFrame"){
-    sz *= 10;
-  }
-#endif
-
-  return sz;
-}
-
-
-MSGQContext::MSGQContext() {
-}
-
-MSGQContext::~MSGQContext() {
-}
-
-void MSGQMessage::init(size_t sz) {
-  size = sz;
-  data = new char[size];
-}
-
-void MSGQMessage::init(char * d, size_t sz) {
-  size = sz;
-  data = new char[size];
-  memcpy(data, d, size);
-}
-
-void MSGQMessage::takeOwnership(char * d, size_t sz) {
-  size = sz;
-  data = d;
-}
-
-void MSGQMessage::close() {
-  if (size > 0){
-    delete[] data;
-  }
-  size = 0;
-}
-
-MSGQMessage::~MSGQMessage() {
-  this->close();
-}
-
-int MSGQSubSocket::connect(Context *context, std::string endpoint, std::string address, bool conflate){
-  assert(context);
-  assert(address == "127.0.0.1");
-
-  q = new msgq_queue_t;
-  int r = msgq_new_queue(q, endpoint.c_str(), get_size(endpoint));
-  if (r != 0){
-    return r;
-  }
-
-  msgq_init_subscriber(q);
-
-  if (conflate){
-    q->read_conflate = true;
-  }
-
-  timeout = -1;
-
-  return 0;
-}
-
-
-Message * MSGQSubSocket::receive(bool non_blocking){
-  msgq_do_exit = 0;
-
-  void (*prev_handler_sigint)(int);
-  void (*prev_handler_sigterm)(int);
-  if (!non_blocking){
-    prev_handler_sigint = std::signal(SIGINT, sig_handler);
-    prev_handler_sigterm = std::signal(SIGTERM, sig_handler);
-  }
-
-  msgq_msg_t msg;
-
-  MSGQMessage *r = NULL;
-
-  int rc = msgq_msg_recv(&msg, q);
-
-  // Hack to implement blocking read with a poller. Don't use this
-  while (!non_blocking && rc == 0 && msgq_do_exit == 0){
-    msgq_pollitem_t items[1];
-    items[0].q = q;
-
-    int t = (timeout != -1) ? timeout : 100;
-
-    int n = msgq_poll(items, 1, t);
-    rc = msgq_msg_recv(&msg, q);
-
-    // The poll indicated a message was ready, but the receive failed. Try again
-    if (n == 1 && rc == 0){
-      continue;
-    }
-
-    if (timeout != -1){
-      break;
-    }
-  }
-
-
-  if (!non_blocking){
-    std::signal(SIGINT, prev_handler_sigint);
-    std::signal(SIGTERM, prev_handler_sigterm);
-  }
-
-  errno = msgq_do_exit ? EINTR : 0;
-
-  if (rc > 0){
-    if (msgq_do_exit){
-      msgq_msg_close(&msg); // Free unused message on exit
-    } else {
-      r = new MSGQMessage;
-      r->takeOwnership(msg.data, msg.size);
-    }
-  }
-
-  return (Message*)r;
-}
-
-void MSGQSubSocket::setTimeout(int t){
-  timeout = t;
-}
-
-MSGQSubSocket::~MSGQSubSocket(){
-  if (q != NULL){
-    msgq_close_queue(q);
-    delete q;
-  }
-}
-
-int MSGQPubSocket::connect(Context *context, std::string endpoint){
-  assert(context);
-
-  q = new msgq_queue_t;
-  int r = msgq_new_queue(q, endpoint.c_str(), get_size(endpoint));
-  if (r != 0){
-    return r;
-  }
-
-  msgq_init_publisher(q);
-
-  return 0;
-}
-
-int MSGQPubSocket::sendMessage(Message *message){
-  msgq_msg_t msg;
-  msg.data = message->getData();
-  msg.size = message->getSize();
-
-  return msgq_msg_send(&msg, q);
-}
-
-int MSGQPubSocket::send(char *data, size_t size){
-  msgq_msg_t msg;
-  msg.data = data;
-  msg.size = size;
-
-  return msgq_msg_send(&msg, q);
-}
-
-MSGQPubSocket::~MSGQPubSocket(){
-  if (q != NULL){
-    msgq_close_queue(q);
-    delete q;
-  }
-}
-
-
-void MSGQPoller::registerSocket(SubSocket * socket){
-  assert(num_polls + 1 < MAX_POLLERS);
-  polls[num_polls].q = (msgq_queue_t*)socket->getRawSocket();
-
-  sockets.push_back(socket);
-  num_polls++;
-}
-
-std::vector<SubSocket*> MSGQPoller::poll(int timeout){
-  std::vector<SubSocket*> r;
-
-  msgq_poll(polls, num_polls, timeout);
-  for (size_t i = 0; i < num_polls; i++){
-    if (polls[i].revents){
-      r.push_back(sockets[i]);
-    }
-  }
-
-  return r;
-}

cereal/messaging/impl_msgq.hpp

@@ -1,64 +0,0 @@
-#pragma once
-#include "messaging.hpp"
-#include "msgq.hpp"
-#include <zmq.h>
-#include <string>
-
-#define MAX_POLLERS 128
-
-class MSGQContext : public Context {
-private:
-  void * context = NULL;
-public:
-  MSGQContext();
-  void * getRawContext() {return context;}
-  ~MSGQContext();
-};
-
-class MSGQMessage : public Message {
-private:
-  char * data;
-  size_t size;
-public:
-  void init(size_t size);
-  void init(char *data, size_t size);
-  void takeOwnership(char *data, size_t size);
-  size_t getSize(){return size;}
-  char * getData(){return data;}
-  void close();
-  ~MSGQMessage();
-};
-
-class MSGQSubSocket : public SubSocket {
-private:
-  msgq_queue_t * q = NULL;
-  int timeout;
-public:
-  int connect(Context *context, std::string endpoint, std::string address, bool conflate=false);
-  void setTimeout(int timeout);
-  void * getRawSocket() {return (void*)q;}
-  Message *receive(bool non_blocking=false);
-  ~MSGQSubSocket();
-};
-
-class MSGQPubSocket : public PubSocket {
-private:
-  msgq_queue_t * q = NULL;
-public:
-  int connect(Context *context, std::string endpoint);
-  int sendMessage(Message *message);
-  int send(char *data, size_t size);
-  ~MSGQPubSocket();
-};
-
-class MSGQPoller : public Poller {
-private:
-  std::vector<SubSocket*> sockets;
-  msgq_pollitem_t polls[MAX_POLLERS];
-  size_t num_polls = 0;
-
-public:
-  void registerSocket(SubSocket *socket);
-  std::vector<SubSocket*> poll(int timeout);
-  ~MSGQPoller(){};
-};

cereal/messaging/impl_zmq.cc

@@ -1,155 +0,0 @@
-#include <cassert>
-#include <cstring>
-#include <iostream>
-#include <cstdlib>
-#include <cerrno>
-
-#include <zmq.h>
-
-#include "services.h"
-#include "impl_zmq.hpp"
-
-static int get_port(std::string endpoint) {
-  int port = -1;
-  for (const auto& it : services) {
-    std::string name = it.name;
-    if (name == endpoint) {
-      port = it.port;
-      break;
-    }
-  }
-
-  assert(port >= 0);
-  return port;
-}
-
-ZMQContext::ZMQContext() {
-  context = zmq_ctx_new();
-}
-
-ZMQContext::~ZMQContext() {
-  zmq_ctx_term(context);
-}
-
-void ZMQMessage::init(size_t sz) {
-  size = sz;
-  data = new char[size];
-}
-
-void ZMQMessage::init(char * d, size_t sz) {
-  size = sz;
-  data = new char[size];
-  memcpy(data, d, size);
-}
-
-void ZMQMessage::close() {
-  if (size > 0){
-    delete[] data;
-  }
-  size = 0;
-}
-
-ZMQMessage::~ZMQMessage() {
-  this->close();
-}
-
-
-int ZMQSubSocket::connect(Context *context, std::string endpoint, std::string address, bool conflate){
-  sock = zmq_socket(context->getRawContext(), ZMQ_SUB);
-  if (sock == NULL){
-    return -1;
-  }
-
-  zmq_setsockopt(sock, ZMQ_SUBSCRIBE, "", 0);
-
-  if (conflate){
-    int arg = 1;
-    zmq_setsockopt(sock, ZMQ_CONFLATE, &arg, sizeof(int));
-  }
-
-  int reconnect_ivl = 500;
-  zmq_setsockopt(sock, ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl, sizeof(reconnect_ivl));
-
-  full_endpoint = "tcp://" + address + ":";
-  full_endpoint += std::to_string(get_port(endpoint));
-
-  return zmq_connect(sock, full_endpoint.c_str());
-}
-
-
-Message * ZMQSubSocket::receive(bool non_blocking){
-  zmq_msg_t msg;
-  assert(zmq_msg_init(&msg) == 0);
-
-  int flags = non_blocking ? ZMQ_DONTWAIT : 0;
-  int rc = zmq_msg_recv(&msg, sock, flags);
-  Message *r = NULL;
-
-  if (rc >= 0){
-    // Make a copy to ensure the data is aligned
-    r = new ZMQMessage;
-    r->init((char*)zmq_msg_data(&msg), zmq_msg_size(&msg));
-  }
-
-  zmq_msg_close(&msg);
-  return r;
-}
-
-void ZMQSubSocket::setTimeout(int timeout){
-  zmq_setsockopt(sock, ZMQ_RCVTIMEO, &timeout, sizeof(int));
-}
-
-ZMQSubSocket::~ZMQSubSocket(){
-  zmq_close(sock);
-}
-
-int ZMQPubSocket::connect(Context *context, std::string endpoint){
-  sock = zmq_socket(context->getRawContext(), ZMQ_PUB);
-  if (sock == NULL){
-    return -1;
-  }
-
-  full_endpoint = "tcp://*:";
-  full_endpoint += std::to_string(get_port(endpoint));
-
-  return zmq_bind(sock, full_endpoint.c_str());
-}
-
-int ZMQPubSocket::sendMessage(Message *message){
-  return zmq_send(sock, message->getData(), message->getSize(), ZMQ_DONTWAIT);
-}
-
-int ZMQPubSocket::send(char *data, size_t size){
-  return zmq_send(sock, data, size, ZMQ_DONTWAIT);
-}
-
-ZMQPubSocket::~ZMQPubSocket(){
-  zmq_close(sock);
-}
-
-
-void ZMQPoller::registerSocket(SubSocket * socket){
-  assert(num_polls + 1 < MAX_POLLERS);
-  polls[num_polls].socket = socket->getRawSocket();
-  polls[num_polls].events = ZMQ_POLLIN;
-
-  sockets.push_back(socket);
-  num_polls++;
-}
-
-std::vector<SubSocket*> ZMQPoller::poll(int timeout){
-  std::vector<SubSocket*> r;
-
-  int rc = zmq_poll(polls, num_polls, timeout);
-  if (rc < 0){
-    return r;
-  }
-
-  for (size_t i = 0; i < num_polls; i++){
-    if (polls[i].revents){
-      r.push_back(sockets[i]);
-    }
-  }
-
-  return r;
-}

cereal/messaging/impl_zmq.hpp

@@ -1,63 +0,0 @@
-#pragma once
-#include "messaging.hpp"
-#include <zmq.h>
-#include <string>
-
-#define MAX_POLLERS 128
-
-class ZMQContext : public Context {
-private:
-  void * context = NULL;
-public:
-  ZMQContext();
-  void * getRawContext() {return context;}
-  ~ZMQContext();
-};
-
-class ZMQMessage : public Message {
-private:
-  char * data;
-  size_t size;
-public:
-  void init(size_t size);
-  void init(char *data, size_t size);
-  size_t getSize(){return size;}
-  char * getData(){return data;}
-  void close();
-  ~ZMQMessage();
-};
-
-class ZMQSubSocket : public SubSocket {
-private:
-  void * sock;
-  std::string full_endpoint;
-public:
-  int connect(Context *context, std::string endpoint, std::string address, bool conflate=false);
-  void setTimeout(int timeout);
-  void * getRawSocket() {return sock;}
-  Message *receive(bool non_blocking=false);
-  ~ZMQSubSocket();
-};
-
-class ZMQPubSocket : public PubSocket {
-private:
-  void * sock;
-  std::string full_endpoint;
-public:
-  int connect(Context *context, std::string endpoint);
-  int sendMessage(Message *message);
-  int send(char *data, size_t size);
-  ~ZMQPubSocket();
-};
-
-class ZMQPoller : public Poller {
-private:
-  std::vector<SubSocket*> sockets;
-  zmq_pollitem_t polls[MAX_POLLERS];
-  size_t num_polls = 0;
-
-public:
-  void registerSocket(SubSocket *socket);
-  std::vector<SubSocket*> poll(int timeout);
-  ~ZMQPoller(){};
-};

cereal/messaging/messaging.cc

@@ -1,123 +0,0 @@
-#include "messaging.hpp"
-#include "impl_zmq.hpp"
-#include "impl_msgq.hpp"
-
-#ifdef __APPLE__
-const bool MUST_USE_ZMQ = true;
-#else
-const bool MUST_USE_ZMQ = false;
-#endif
-
-Context * Context::create(){
-  Context * c;
-  if (std::getenv("ZMQ") || MUST_USE_ZMQ){
-    c = new ZMQContext();
-  } else {
-    c = new MSGQContext();
-  }
-  return c;
-}
-
-SubSocket * SubSocket::create(){
-  SubSocket * s;
-  if (std::getenv("ZMQ") || MUST_USE_ZMQ){
-    s = new ZMQSubSocket();
-  } else {
-    s = new MSGQSubSocket();
-  }
-  return s;
-}
-
-SubSocket * SubSocket::create(Context * context, std::string endpoint){
-  SubSocket *s = SubSocket::create();
-  int r = s->connect(context, endpoint, "127.0.0.1");
-
-  if (r == 0) {
-    return s;
-  } else {
-    delete s;
-    return NULL;
-  }
-}
-
-SubSocket * SubSocket::create(Context * context, std::string endpoint, std::string address){
-  SubSocket *s = SubSocket::create();
-  int r = s->connect(context, endpoint, address);
-
-  if (r == 0) {
-    return s;
-  } else {
-    delete s;
-    return NULL;
-  }
-}
-
-SubSocket * SubSocket::create(Context * context, std::string endpoint, std::string address, bool conflate){
-  SubSocket *s = SubSocket::create();
-  int r = s->connect(context, endpoint, address, conflate);
-
-  if (r == 0) {
-    return s;
-  } else {
-    delete s;
-    return NULL;
-  }
-}
-
-PubSocket * PubSocket::create(){
-  PubSocket * s;
-  if (std::getenv("ZMQ") || MUST_USE_ZMQ){
-    s = new ZMQPubSocket();
-  } else {
-    s = new MSGQPubSocket();
-  }
-  return s;
-}
-
-PubSocket * PubSocket::create(Context * context, std::string endpoint){
-  PubSocket *s = PubSocket::create();
-  int r = s->connect(context, endpoint);
-
-  if (r == 0) {
-    return s;
-  } else {
-    delete s;
-    return NULL;
-  }
-}
-
-Poller * Poller::create(){
-  Poller * p;
-  if (std::getenv("ZMQ") || MUST_USE_ZMQ){
-    p = new ZMQPoller();
-  } else {
-    p = new MSGQPoller();
-  }
-  return p;
-}
-
-Poller * Poller::create(std::vector<SubSocket*> sockets){
-  Poller * p = Poller::create();
-
-  for (auto s : sockets){
-    p->registerSocket(s);
-  }
-  return p;
-}
-
-extern "C" Context * messaging_context_create() {
-  return Context::create();
-}
-
-extern "C" SubSocket * messaging_subsocket_create(Context* context, const char* endpoint) {
-  return SubSocket::create(context, std::string(endpoint));
-}
-
-extern "C" PubSocket * messaging_pubsocket_create(Context* context, const char* endpoint) {
-  return PubSocket::create(context, std::string(endpoint));
-}
-
-extern "C" Poller * messaging_poller_create(SubSocket** sockets, int size) {
-  std::vector<SubSocket*> socketsVec(sockets, sockets + size);
-  return Poller::create(socketsVec);
-}

cereal/messaging/messaging.hpp

@@ -1,121 +0,0 @@
-#pragma once
-#include <cstddef>
-#include <map>
-#include <string>
-#include <vector>
-#include <capnp/serialize.h>
-#include "../gen/cpp/log.capnp.h"
-
-#ifdef __APPLE__
-#define CLOCK_BOOTTIME CLOCK_MONOTONIC
-#endif
-
-#define MSG_MULTIPLE_PUBLISHERS 100
-
-class Context {
-public:
-  virtual void * getRawContext() = 0;
-  static Context * create();
-  virtual ~Context(){};
-};
-
-class Message {
-public:
-  virtual void init(size_t size) = 0;
-  virtual void init(char * data, size_t size) = 0;
-  virtual void close() = 0;
-  virtual size_t getSize() = 0;
-  virtual char * getData() = 0;
-  virtual ~Message(){};
-};
-
-
-class SubSocket {
-public:
-  virtual int connect(Context *context, std::string endpoint, std::string address, bool conflate=false) = 0;
-  virtual void setTimeout(int timeout) = 0;
-  virtual Message *receive(bool non_blocking=false) = 0;
-  virtual void * getRawSocket() = 0;
-  static SubSocket * create();
-  static SubSocket * create(Context * context, std::string endpoint);
-  static SubSocket * create(Context * context, std::string endpoint, std::string address);
-  static SubSocket * create(Context * context, std::string endpoint, std::string address, bool conflate);
-  virtual ~SubSocket(){};
-};
-
-class PubSocket {
-public:
-  virtual int connect(Context *context, std::string endpoint) = 0;
-  virtual int sendMessage(Message *message) = 0;
-  virtual int send(char *data, size_t size) = 0;
-  static PubSocket * create();
-  static PubSocket * create(Context * context, std::string endpoint);
-  virtual ~PubSocket(){};
-};
-
-class Poller {
-public:
-  virtual void registerSocket(SubSocket *socket) = 0;
-  virtual std::vector<SubSocket*> poll(int timeout) = 0;
-  static Poller * create();
-  static Poller * create(std::vector<SubSocket*> sockets);
-  virtual ~Poller(){};
-};
-
-class SubMaster {
-public:
-  SubMaster(const std::initializer_list<const char *> &service_list,
-            const char *address = nullptr, const std::initializer_list<const char *> &ignore_alive = {});
-  int update(int timeout = 1000);
-  inline bool allAlive(const std::initializer_list<const char *> &service_list = {}) { return all_(service_list, false, true); }
-  inline bool allValid(const std::initializer_list<const char *> &service_list = {}) { return all_(service_list, true, false); }
-  inline bool allAliveAndValid(const std::initializer_list<const char *> &service_list = {}) { return all_(service_list, true, true); }
-  void drain();
-  ~SubMaster();
-
-  uint64_t frame = 0;
-  bool updated(const char *name) const;
-  uint64_t rcv_frame(const char *name) const;
-  cereal::Event::Reader &operator[](const char *name);
-
-private:
-  bool all_(const std::initializer_list<const char *> &service_list, bool valid, bool alive);
-  Poller *poller_ = nullptr;
-  struct SubMessage;
-  std::map<SubSocket *, SubMessage *> messages_;
-  std::map<std::string, SubMessage *> services_;
-};
-
-class MessageBuilder : public capnp::MallocMessageBuilder {
-public:
-  MessageBuilder() = default;
-
-  cereal::Event::Builder initEvent(bool valid = true) {
-    cereal::Event::Builder event = initRoot<cereal::Event>();
-    struct timespec t;
-    clock_gettime(CLOCK_BOOTTIME, &t);
-    uint64_t current_time = t.tv_sec * 1000000000ULL + t.tv_nsec;
-    event.setLogMonoTime(current_time);
-    event.setValid(valid);
-    return event;
-  }
-
-  kj::ArrayPtr<capnp::byte> toBytes() {
-    heapArray_ = capnp::messageToFlatArray(*this);
-    return heapArray_.asBytes();
-  }
-
-private:
-  kj::Array<capnp::word> heapArray_;
-};
-
-class PubMaster {
-public:
-  PubMaster(const std::initializer_list<const char *> &service_list);
-  inline int send(const char *name, capnp::byte *data, size_t size) { return sockets_.at(name)->send((char *)data, size); }
-  int send(const char *name, MessageBuilder &msg);
-  ~PubMaster();
-
-private:
-  std::map<std::string, PubSocket *> sockets_;
-};

cereal/messaging/messaging.pxd

@@ -1,39 +0,0 @@
-# distutils: language = c++
-#cython: language_level=3
-
-from libcpp.string cimport string
-from libcpp.vector cimport vector
-from libcpp cimport bool
-
-
-cdef extern from "messaging.hpp":
-  cdef cppclass Context:
-    @staticmethod
-    Context * create()
-
-  cdef cppclass Message:
-    void init(size_t)
-    void init(char *, size_t)
-    void close()
-    size_t getSize()
-    char *getData()
-
-  cdef cppclass SubSocket:
-    @staticmethod
-    SubSocket * create()
-    int connect(Context *, string, string, bool)
-    Message * receive(bool)
-    void setTimeout(int)
-
-  cdef cppclass PubSocket:
-    @staticmethod
-    PubSocket * create()
-    int connect(Context *, string)
-    int sendMessage(Message *)
-    int send(char *, size_t)
-
-  cdef cppclass Poller:
-    @staticmethod
-    Poller * create()
-    void registerSocket(SubSocket *)
-    vector[SubSocket*] poll(int) nogil

cereal/messaging/messaging_pyx.pyx

@@ -1,151 +0,0 @@
-# distutils: language = c++
-# cython: c_string_encoding=ascii, language_level=3
-
-import sys
-from libcpp.string cimport string
-from libcpp cimport bool
-from libc cimport errno
-
-
-from messaging cimport Context as cppContext
-from messaging cimport SubSocket as cppSubSocket
-from messaging cimport PubSocket as cppPubSocket
-from messaging cimport Poller as cppPoller
-from messaging cimport Message as cppMessage
-
-
-class MessagingError(Exception):
-  pass
-
-
-class MultiplePublishersError(MessagingError):
-  pass
-
-
-cdef class Context:
-  cdef cppContext * context
-
-  def __cinit__(self):
-    self.context = cppContext.create()
-
-  def term(self):
-    del self.context
-    self.context = NULL
-
-  def __dealloc__(self):
-    pass
-    # Deleting the context will hang if sockets are still active
-    # TODO: Figure out a way to make sure the context is closed last
-    # del self.context
-
-
-cdef class Poller:
-  cdef cppPoller * poller
-  cdef list sub_sockets
-
-  def __cinit__(self):
-    self.sub_sockets = []
-    self.poller = cppPoller.create()
-
-  def __dealloc__(self):
-    del self.poller
-
-  def registerSocket(self, SubSocket socket):
-    self.sub_sockets.append(socket)
-    self.poller.registerSocket(socket.socket)
-
-  def poll(self, timeout):
-    sockets = []
-    cdef int t = timeout
-
-    with nogil:
-        result = self.poller.poll(t)
-
-    for s in result:
-        socket = SubSocket()
-        socket.setPtr(s)
-        sockets.append(socket)
-
-    return sockets
-
-cdef class SubSocket:
-  cdef cppSubSocket * socket
-  cdef bool is_owner
-
-  def __cinit__(self):
-    self.socket = cppSubSocket.create()
-    self.is_owner = True
-
-    if self.socket == NULL:
-      raise MessagingError
-
-  def __dealloc__(self):
-    if self.is_owner:
-      del self.socket
-
-  cdef setPtr(self, cppSubSocket * ptr):
-    if self.is_owner:
-      del self.socket
-
-    self.is_owner = False
-    self.socket = ptr
-
-  def connect(self, Context context, string endpoint, string address=b"127.0.0.1", bool conflate=False):
-    r = self.socket.connect(context.context, endpoint, address, conflate)
-
-    if r != 0:
-      if errno.errno == errno.EADDRINUSE:
-        raise MultiplePublishersError
-      else:
-        raise MessagingError
-
-  def setTimeout(self, int timeout):
-    self.socket.setTimeout(timeout)
-
-  def receive(self, bool non_blocking=False):
-    msg = self.socket.receive(non_blocking)
-
-    if msg == NULL:
-      # If a blocking read returns no message check errno if SIGINT was caught in the C++ code
-      if errno.errno == errno.EINTR:
-        print("SIGINT received, exiting")
-        sys.exit(1)
-
-      return None
-    else:
-      sz = msg.getSize()
-      m = msg.getData()[:sz]
-      del msg
-
-      return m
-
-
-cdef class PubSocket:
-  cdef cppPubSocket * socket
-
-  def __cinit__(self):
-    self.socket = cppPubSocket.create()
-    if self.socket == NULL:
-      raise MessagingError
-
-  def __dealloc__(self):
-    del self.socket
-
-  def connect(self, Context context, string endpoint):
-    r = self.socket.connect(context.context, endpoint)
-
-    if r != 0:
-      if errno.errno == errno.EADDRINUSE:
-        raise MultiplePublishersError
-      else:
-        raise MessagingError
-
-  def send(self, bytes data):
-    length = len(data)
-    r = self.socket.send(<char*>data, length)
-
-    if r != length:
-      if errno.errno == errno.EADDRINUSE:
-        raise MultiplePublishersError
-      else:
-        raise MessagingError

cereal/messaging/messaging_pyx_setup.py

@@ -1,58 +0,0 @@
-import os
-import subprocess
-import sysconfig
-from distutils.core import Extension, setup  # pylint: disable=import-error,no-name-in-module
-
-from Cython.Build import cythonize
-from Cython.Distutils import build_ext
-
-TICI = os.path.isfile('/TICI')
-
-def get_ext_filename_without_platform_suffix(filename):
-  name, ext = os.path.splitext(filename)
-  ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
-
-  if ext_suffix == ext:
-    return filename
-
-  ext_suffix = ext_suffix.replace(ext, '')
-  idx = name.find(ext_suffix)
-
-  if idx == -1:
-    return filename
-  else:
-    return name[:idx] + ext
-
-
-class BuildExtWithoutPlatformSuffix(build_ext):
-  def get_ext_filename(self, ext_name):
-    filename = super().get_ext_filename(ext_name)
-    return get_ext_filename_without_platform_suffix(filename)
-
-
-sourcefiles = ['messaging_pyx.pyx']
-extra_compile_args = ["-std=c++1z", "-Wno-nullability-completeness"]
-libraries = ['zmq']
-ARCH = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()  # pylint: disable=unexpected-keyword-arg
-
-if ARCH == "aarch64" and not TICI:
-  # android
-  extra_compile_args += ["-Wno-deprecated-register"]
-  libraries += ['gnustl_shared']
-
-setup(name='messaging',
-      cmdclass={'build_ext': BuildExtWithoutPlatformSuffix},
-      ext_modules=cythonize(
-        Extension(
-          "messaging_pyx",
-          language="c++",
-          sources=sourcefiles,
-          extra_compile_args=extra_compile_args,
-          libraries=libraries,
-          extra_objects=[
-            os.path.join(os.path.dirname(os.path.realpath(__file__)), '../', 'libmessaging.a'),
-          ]
-        ),
-        nthreads=4,
-      ),
-)

cereal/messaging/msgq.cc

@@ -1,467 +0,0 @@
-#include <iostream>
-#include <cassert>
-#include <cerrno>
-#include <cmath>
-#include <cstring>
-#include <cstdint>
-#include <chrono>
-#include <algorithm>
-#include <cstdlib>
-#include <csignal>
-#include <random>
-
-#include <poll.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/syscall.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <stdio.h>
-
-#include "services.h"
-
-#include "msgq.hpp"
-
-void sigusr2_handler(int signal) {
-  assert(signal == SIGUSR2);
-}
-
-uint64_t msgq_get_uid(void){
-  std::random_device rd("/dev/urandom");
-  std::uniform_int_distribution<uint64_t> distribution(0,std::numeric_limits<uint32_t>::max());
-
-  #ifdef __APPLE__
-    // TODO: this doesn't work
-    uint64_t uid = distribution(rd) << 32 | getpid();
-  #else
-    uint64_t uid = distribution(rd) << 32 | syscall(SYS_gettid);
-  #endif
-
-  return uid;
-}
-
-int msgq_msg_init_size(msgq_msg_t * msg, size_t size){
-  msg->size = size;
-  msg->data = new(std::nothrow) char[size];
-
-  return (msg->data == NULL) ? -1 : 0;
-}
-
-
-int msgq_msg_init_data(msgq_msg_t * msg, char * data, size_t size) {
-  int r = msgq_msg_init_size(msg, size);
-
-  if (r == 0)
-    memcpy(msg->data, data, size);
-
-  return r;
-}
-
-int msgq_msg_close(msgq_msg_t * msg){
-  if (msg->size > 0)
-    delete[] msg->data;
-
-  msg->size = 0;
-
-  return 0;
-}
-
-void msgq_reset_reader(msgq_queue_t * q){
-  int id = q->reader_id;
-  q->read_valids[id]->store(true);
-  q->read_pointers[id]->store(*q->write_pointer);
-}
-
-void msgq_wait_for_subscriber(msgq_queue_t *q){
-  while (*q->num_readers == 0){
-    ;
-  }
-
-  return;
-}
-
-bool service_exists(std::string path){
-  for (const auto& it : services) {
-    if (it.name == path) {
-      return true;
-    }
-  }
-  return false;
-}
-
-int msgq_new_queue(msgq_queue_t * q, const char * path, size_t size){
-  assert(size < 0xFFFFFFFF); // Buffer must be smaller than 2^32 bytes
-  if (!service_exists(std::string(path))){
-    std::cout << "Warning, " << std::string(path) << " is not in service list." << std::endl;
-  }
-  std::signal(SIGUSR2, sigusr2_handler);
-
-  const char * prefix = "/dev/shm/";
-  char * full_path = new char[strlen(path) + strlen(prefix) + 1];
-  strcpy(full_path, prefix);
-  strcat(full_path, path);
-
-  auto fd = open(full_path, O_RDWR | O_CREAT, 0777);
-  if (fd < 0) {
-    std::cout << "Warning, could not open: " << full_path << std::endl;
-    delete[] full_path;
-    return -1;
-  }
-  delete[] full_path;
-
-  int rc = ftruncate(fd, size + sizeof(msgq_header_t));
-  if (rc < 0){
-    close(fd);
-    return -1;
-  }
-  char * mem = (char*)mmap(NULL, size + sizeof(msgq_header_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-  close(fd);
-
-  if (mem == NULL){
-    return -1;
-  }
-  q->mmap_p = mem;
-
-  msgq_header_t *header = (msgq_header_t *)mem;
-
-  // Setup pointers to header segment
-  q->num_readers = reinterpret_cast<std::atomic<uint64_t>*>(&header->num_readers);
-  q->write_pointer = reinterpret_cast<std::atomic<uint64_t>*>(&header->write_pointer);
-  q->write_uid = reinterpret_cast<std::atomic<uint64_t>*>(&header->write_uid);
-
-  for (size_t i = 0; i < NUM_READERS; i++){
-    q->read_pointers[i] = reinterpret_cast<std::atomic<uint64_t>*>(&header->read_pointers[i]);
-    q->read_valids[i] = reinterpret_cast<std::atomic<uint64_t>*>(&header->read_valids[i]);
-    q->read_uids[i] = reinterpret_cast<std::atomic<uint64_t>*>(&header->read_uids[i]);
-  }
-
-  q->data = mem + sizeof(msgq_header_t);
-  q->size = size;
-  q->reader_id = -1;
-
-  q->endpoint = path;
-  q->read_conflate = false;
-
-  return 0;
-}
-
-void msgq_close_queue(msgq_queue_t *q){
-  if (q->mmap_p != NULL){
-    munmap(q->mmap_p, q->size + sizeof(msgq_header_t));
-  }
-}
-
-
-void msgq_init_publisher(msgq_queue_t * q) {
-  //std::cout << "Starting publisher" << std::endl;
-  uint64_t uid = msgq_get_uid();
-
-  *q->write_uid = uid;
-  *q->num_readers = 0;
-
-  for (size_t i = 0; i < NUM_READERS; i++){
-    *q->read_valids[i] = false;
-    *q->read_uids[i] = 0;
-  }
-
-  q->write_uid_local = uid;
-}
-
-static void thread_signal(uint32_t tid) {
-  #ifndef SYS_tkill
-    // TODO: this won't work for multithreaded programs
-    kill(tid, SIGUSR2);
-  #else
-    syscall(SYS_tkill, tid, SIGUSR2);
-  #endif
-}
-
-void msgq_init_subscriber(msgq_queue_t * q) {
-  assert(q != NULL);
-  assert(q->num_readers != NULL);
-
-  uint64_t uid = msgq_get_uid();
-
-  // Get reader id
-  while (true){
-    uint64_t cur_num_readers = *q->num_readers;
-    uint64_t new_num_readers = cur_num_readers + 1;
-
-    // No more slots available. Reset all subscribers to kick out inactive ones
-    if (new_num_readers > NUM_READERS){
-      std::cout << "Warning, evicting all subscribers!" << std::endl;
-      *q->num_readers = 0;
-
-      for (size_t i = 0; i < NUM_READERS; i++){
-        *q->read_valids[i] = false;
-
-        uint64_t old_uid = *q->read_uids[i];
-        *q->read_uids[i] = 0;
-
-        // Wake up reader in case they are in a poll
-        thread_signal(old_uid & 0xFFFFFFFF);
-      }
-
-      continue;
-    }
-
-    // Use atomic compare and swap to handle race condition
-    // where two subscribers start at the same time
-    if (std::atomic_compare_exchange_strong(q->num_readers,
-                                            &cur_num_readers,
-                                            new_num_readers)){
-      q->reader_id = cur_num_readers;
-      q->read_uid_local = uid;
-
-      // We start with read_valid = false,
-      // on the first read the read pointer will be synchronized with the write pointer
-      *q->read_valids[cur_num_readers] = false;
-      *q->read_pointers[cur_num_readers] = 0;
-      *q->read_uids[cur_num_readers] = uid;
-      break;
-    }
-  }
-
-  //std::cout << "New subscriber id: " << q->reader_id << " uid: " << q->read_uid_local << " " << q->endpoint << std::endl;
-  msgq_reset_reader(q);
-}
-
-int msgq_msg_send(msgq_msg_t * msg, msgq_queue_t *q){
-  // Die if we are no longer the active publisher
-  if (q->write_uid_local != *q->write_uid){
-    std::cout << "Killing old publisher: " << q->endpoint << std::endl;
-    errno = EADDRINUSE;
-    return -1;
-  }
-
-  uint64_t total_msg_size = ALIGN(msg->size + sizeof(int64_t));
-
-  // We need to fit at least three messages in the queue,
-  // then we can always safely access the last message
-  assert(3 * total_msg_size <= q->size);
-
-  uint64_t num_readers = *q->num_readers;
-
-  uint32_t write_cycles, write_pointer;
-  UNPACK64(write_cycles, write_pointer, *q->write_pointer);
-
-  char *p = q->data + write_pointer; // add base offset
-
-  // Check remaining space
-  // Always leave space for a wraparound tag for the next message, including alignment
-  int64_t remaining_space = q->size - write_pointer - total_msg_size - sizeof(int64_t);
-  if (remaining_space <= 0){
-    // Write -1 size tag indicating wraparound
-    *(int64_t*)p = -1;
-
-    // Invalidate all readers that are beyond the write pointer
-    // TODO: should we handle the case where a new reader shows up while this is running?
-    for (uint64_t i = 0; i < num_readers; i++){
-      uint64_t read_pointer = *q->read_pointers[i];
-      uint64_t read_cycles = read_pointer >> 32;
-      read_pointer &= 0xFFFFFFFF;
-
-      if ((read_pointer > write_pointer) && (read_cycles != write_cycles)) {
-        *q->read_valids[i] = false;
-      }
-    }
-
-    // Update global and local copies of write pointer and write_cycles
-    write_pointer = 0;
-    write_cycles = write_cycles + 1;
-    PACK64(*q->write_pointer, write_cycles, write_pointer);
-
-    // Set actual pointer to the beginning of the data segment
-    p = q->data;
-  }
-
-  // Invalidate readers that are in the area that will be written
-  uint64_t start = write_pointer;
-  uint64_t end = ALIGN(start + sizeof(int64_t) + msg->size);
-
-  for (uint64_t i = 0; i < num_readers; i++){
-    uint32_t read_cycles, read_pointer;
-    UNPACK64(read_cycles, read_pointer, *q->read_pointers[i]);
-
-    if ((read_pointer >= start) && (read_pointer < end) && (read_cycles != write_cycles)) {
-      *q->read_valids[i] = false;
-    }
-  }
-
-
-  // Write size tag
-  std::atomic<int64_t> *size_p = reinterpret_cast<std::atomic<int64_t>*>(p);
-  *size_p = msg->size;
-
-  // Copy data
-  memcpy(p + sizeof(int64_t), msg->data, msg->size);
-  __sync_synchronize();
-
-  // Update write pointer
-  uint32_t new_ptr = ALIGN(write_pointer + msg->size + sizeof(int64_t));
-  PACK64(*q->write_pointer, write_cycles, new_ptr);
-
-  // Notify readers
-  for (uint64_t i = 0; i < num_readers; i++){
-    uint64_t reader_uid = *q->read_uids[i];
-    thread_signal(reader_uid & 0xFFFFFFFF);
-  }
-
-  return msg->size;
-}
-
-
-int msgq_msg_ready(msgq_queue_t * q){
- start:
-  int id = q->reader_id;
-  assert(id >= 0); // Make sure subscriber is initialized
-
-  if (q->read_uid_local != *q->read_uids[id]){
-    std::cout << q->endpoint << ": Reader was evicted, reconnecting" << std::endl;
-    msgq_init_subscriber(q);
-    goto start;
-  }
-
-  // Check valid
-  if (!*q->read_valids[id]){
-    msgq_reset_reader(q);
-    goto start;
-  }
-
-  uint32_t read_cycles, read_pointer;
-  UNPACK64(read_cycles, read_pointer, *q->read_pointers[id]);
-
-  uint32_t write_cycles, write_pointer;
-  UNPACK64(write_cycles, write_pointer, *q->write_pointer);
-
-  // Check if new message is available
-  return (read_pointer != write_pointer);
-}
-
-int msgq_msg_recv(msgq_msg_t * msg, msgq_queue_t * q){
- start:
-  int id = q->reader_id;
-  assert(id >= 0); // Make sure subscriber is initialized
-
-  if (q->read_uid_local != *q->read_uids[id]){
-    std::cout << q->endpoint << ": Reader was evicted, reconnecting" << std::endl;
-    msgq_init_subscriber(q);
-    goto start;
-  }
-
-  // Check valid
-  if (!*q->read_valids[id]){
-    msgq_reset_reader(q);
-    goto start;
-  }
-
-  uint32_t read_cycles, read_pointer;
-  UNPACK64(read_cycles, read_pointer, *q->read_pointers[id]);
-
-  uint32_t write_cycles, write_pointer;
-  UNPACK64(write_cycles, write_pointer, *q->write_pointer);
-
-  char * p = q->data + read_pointer;
-
-  // Check if new message is available
-  if (read_pointer == write_pointer) {
-    msg->size = 0;
-    return 0;
-  }
-
-  // Read potential message size
-  std::atomic<int64_t> *size_p = reinterpret_cast<std::atomic<int64_t>*>(p);
-  std::int64_t size = *size_p;
-
-  // Check if the size that was read is valid
-  if (!*q->read_valids[id]){
-    msgq_reset_reader(q);
-    goto start;
-  }
-
-  // If size is -1 the buffer was full, and we need to wrap around
-  if (size == -1){
-    read_cycles++;
-    PACK64(*q->read_pointers[id], read_cycles, 0);
-    goto start;
-  }
-
-  // crashing is better than passing garbage data to the consumer
-  // the size will have weird value if it was overwritten by data accidentally
-  assert((uint64_t)size < q->size);
-  assert(size > 0);
-
-  uint32_t new_read_pointer = ALIGN(read_pointer + sizeof(std::int64_t) + size);
-
-  // If conflate is true, check if this is the latest message, else start over
-  if (q->read_conflate){
-    if (new_read_pointer != write_pointer){
-      // Update read pointer
-      PACK64(*q->read_pointers[id], read_cycles, new_read_pointer);
-      goto start;
-    }
-  }
-
-  // Copy message
-  if (msgq_msg_init_size(msg, size) < 0)
-    return -1;
-
-  __sync_synchronize();
-  memcpy(msg->data, p + sizeof(int64_t), size);
-  __sync_synchronize();
-
-  // Update read pointer
-  PACK64(*q->read_pointers[id], read_cycles, new_read_pointer);
-
-  // Check if the actual data that was copied is valid
-  if (!*q->read_valids[id]){
-    msgq_msg_close(msg);
-    msgq_reset_reader(q);
-    goto start;
-  }
-
-
-  return msg->size;
-}
-
-
-
-int msgq_poll(msgq_pollitem_t * items, size_t nitems, int timeout){
-  int num = 0;
-
-  // Check if messages ready
-  for (size_t i = 0; i < nitems; i++) {
-    items[i].revents = msgq_msg_ready(items[i].q);
-    if (items[i].revents) num++;
-  }
-
-  int ms = (timeout == -1) ? 100 : timeout;
-  struct timespec ts;
-  ts.tv_sec = ms / 1000;
-  ts.tv_nsec = (ms % 1000) * 1000 * 1000;
-
-
-  while (num == 0) {
-    int ret;
-
-    ret = nanosleep(&ts, &ts);
-
-    // Check if messages ready
-    for (size_t i = 0; i < nitems; i++) {
-      if (items[i].revents == 0 && msgq_msg_ready(items[i].q)){
-        num += 1;
-        items[i].revents = 1;
-      }
-    }
-
-    // exit if we had a timeout and the sleep finished
-    if (timeout != -1 && ret == 0){
-      break;
-    }
-  }
-
-  return num;
-}

cereal/messaging/msgq.hpp

@@ -1,66 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <atomic>
-
-#define DEFAULT_SEGMENT_SIZE (10 * 1024 * 1024)
-#define NUM_READERS 8
-#define ALIGN(n) ((n + (8 - 1)) & -8)
-
-#define UNPACK64(higher, lower, input) do {uint64_t tmp = input; higher = tmp >> 32; lower = tmp & 0xFFFFFFFF;} while (0)
-#define PACK64(output, higher, lower) output = ((uint64_t)higher << 32 ) | ((uint64_t)lower & 0xFFFFFFFF)
-
-struct  msgq_header_t {
-  uint64_t num_readers;
-  uint64_t write_pointer;
-  uint64_t write_uid;
-  uint64_t read_pointers[NUM_READERS];
-  uint64_t read_valids[NUM_READERS];
-  uint64_t read_uids[NUM_READERS];
-};
-
-struct msgq_queue_t {
-  std::atomic<uint64_t> *num_readers;
-  std::atomic<uint64_t> *write_pointer;
-  std::atomic<uint64_t> *write_uid;
-  std::atomic<uint64_t> *read_pointers[NUM_READERS];
-  std::atomic<uint64_t> *read_valids[NUM_READERS];
-  std::atomic<uint64_t> *read_uids[NUM_READERS];
-  char * mmap_p;
-  char * data;
-  size_t size;
-  int reader_id;
-  uint64_t read_uid_local;
-  uint64_t write_uid_local;
-
-  bool read_conflate;
-  std::string endpoint;
-};
-
-struct msgq_msg_t {
-  size_t size;
-  char * data;
-};
-
-struct msgq_pollitem_t {
-  msgq_queue_t *q;
-  int revents;
-};
-
-void msgq_wait_for_subscriber(msgq_queue_t *q);
-void msgq_reset_reader(msgq_queue_t *q);
-
-int msgq_msg_init_size(msgq_msg_t *msg, size_t size);
-int msgq_msg_init_data(msgq_msg_t *msg, char * data, size_t size);
-int msgq_msg_close(msgq_msg_t *msg);
-
-int msgq_new_queue(msgq_queue_t * q, const char * path, size_t size);
-void msgq_close_queue(msgq_queue_t *q);
-void msgq_init_publisher(msgq_queue_t * q);
-void msgq_init_subscriber(msgq_queue_t * q);
-
-int msgq_msg_send(msgq_msg_t *msg, msgq_queue_t *q);
-int msgq_msg_recv(msgq_msg_t *msg, msgq_queue_t *q);
-int msgq_msg_ready(msgq_queue_t * q);
-int msgq_poll(msgq_pollitem_t * items, size_t nitems, int timeout);

cereal/messaging/socketmaster.cc

@@ -1,170 +0,0 @@
-#include <assert.h>
-#include <time.h>
-#include "messaging.hpp"
-#include "services.h"
-
-static inline uint64_t nanos_since_boot() {
-  struct timespec t;
-  clock_gettime(CLOCK_BOOTTIME, &t);
-  return t.tv_sec * 1000000000ULL + t.tv_nsec;
-}
-
-static const service *get_service(const char *name) {
-  for (const auto &it : services) {
-    if (strcmp(it.name, name) == 0) return &it;
-  }
-  return nullptr;
-}
-
-static inline bool inList(const std::initializer_list<const char *> &list, const char *value) {
-  for (auto &v : list) {
-    if (strcmp(value, v) == 0) return true;
-  }
-  return false;
-}
-
-class MessageContext {
-public:
-  MessageContext() { ctx_ = Context::create(); }
-  ~MessageContext() { delete ctx_; }
-  Context *ctx_;
-};
-MessageContext ctx;
-
-struct SubMaster::SubMessage {
-  std::string name;
-  SubSocket *socket = nullptr;
-  int freq = 0;
-  bool updated = false, alive = false, valid = false, ignore_alive;
-  uint64_t rcv_time = 0, rcv_frame = 0;
-  void *allocated_msg_reader = nullptr;
-  capnp::FlatArrayMessageReader *msg_reader = nullptr;
-  kj::Array<capnp::word> buf;
-  cereal::Event::Reader event;
-};
-
-SubMaster::SubMaster(const std::initializer_list<const char *> &service_list, const char *address,
-                     const std::initializer_list<const char *> &ignore_alive) {
-  poller_ = Poller::create();
-  for (auto name : service_list) {
-    const service *serv = get_service(name);
-    assert(serv != nullptr);
-    SubSocket *socket = SubSocket::create(ctx.ctx_, name, address ? address : "127.0.0.1", true);
-    assert(socket != 0);
-    poller_->registerSocket(socket);
-    SubMessage *m = new SubMessage{
-      .socket = socket,
-      .freq = serv->frequency,
-      .ignore_alive = inList(ignore_alive, name),
-      .allocated_msg_reader = malloc(sizeof(capnp::FlatArrayMessageReader)),
-      .buf = kj::heapArray<capnp::word>(1024)};
-    messages_[socket] = m;
-    services_[name] = m;
-  }
-}
-
-int SubMaster::update(int timeout) {
-  if (++frame == UINT64_MAX) frame = 1;
-  for (auto &kv : messages_) kv.second->updated = false;
-
-  int updated = 0;
-  auto sockets = poller_->poll(timeout);
-  uint64_t current_time = nanos_since_boot();
-  for (auto s : sockets) {
-    Message *msg = s->receive(true);
-    if (msg == nullptr) continue;
-
-    SubMessage *m = messages_.at(s);
-    const size_t size = (msg->getSize() / sizeof(capnp::word)) + 1;
-    if (m->buf.size() < size) {
-      m->buf = kj::heapArray<capnp::word>(size);
-    }
-    memcpy(m->buf.begin(), msg->getData(), msg->getSize());
-    delete msg;
-
-    if (m->msg_reader) {
-      m->msg_reader->~FlatArrayMessageReader();
-    }
-    m->msg_reader = new (m->allocated_msg_reader) capnp::FlatArrayMessageReader(kj::ArrayPtr<capnp::word>(m->buf.begin(), size));
-    m->event = m->msg_reader->getRoot<cereal::Event>();
-    m->updated = true;
-    m->rcv_time = current_time;
-    m->rcv_frame = frame;
-    m->valid = m->event.getValid();
-
-    ++updated;
-  }
-
-  for (auto &kv : messages_) {
-    SubMessage *m = kv.second;
-    m->alive = (m->freq <= (1e-5) || ((current_time - m->rcv_time) * (1e-9)) < (10.0 / m->freq));
-  }
-  return updated;
-}
-
-bool SubMaster::all_(const std::initializer_list<const char *> &service_list, bool valid, bool alive) {
-  int found = 0;
-  for (auto &kv : messages_) {
-    SubMessage *m = kv.second;
-    if (service_list.size() == 0 || inList(service_list, m->name.c_str())) {
-      found += (!valid || m->valid) && (!alive || (m->alive && !m->ignore_alive));
-    }
-  }
-  return service_list.size() == 0 ? found == messages_.size() : found == service_list.size();
-}
-
-void SubMaster::drain() {
-  while (true) {
-    auto polls = poller_->poll(0);
-    if (polls.size() == 0)
-      break;
-
-    for (auto sock : polls) {
-      Message *msg = sock->receive(true);
-      delete msg;
-    }
-  }
-}
-
-bool SubMaster::updated(const char *name) const {
-  return services_.at(name)->updated;
-}
-
-uint64_t SubMaster::rcv_frame(const char *name) const {
-  return services_.at(name)->rcv_frame;
-}
-
-cereal::Event::Reader &SubMaster::operator[](const char *name) {
-  return services_.at(name)->event;
-};
-
-SubMaster::~SubMaster() {
-  delete poller_;
-  for (auto &kv : messages_) {
-    SubMessage *m = kv.second;
-    if (m->msg_reader) {
-      m->msg_reader->~FlatArrayMessageReader();
-    }
-    free(m->allocated_msg_reader);
-    delete m->socket;
-    delete m;
-  }
-}
-
-PubMaster::PubMaster(const std::initializer_list<const char *> &service_list) {
-  for (auto name : service_list) {
-    assert(get_service(name) != nullptr);
-    PubSocket *socket = PubSocket::create(ctx.ctx_, name);
-    assert(socket);
-    sockets_[name] = socket;
-  }
-}
-
-int PubMaster::send(const char *name, MessageBuilder &msg) {
-  auto bytes = msg.toBytes();
-  return send(name, bytes.begin(), bytes.size());
-}
-
-PubMaster::~PubMaster() {
-  for (auto s : sockets_) delete s.second;
-}

cereal/service_list.yaml

@@ -1,180 +0,0 @@
-# TODO: these port numbers are hardcoded in c, fix this
-
-# LogRotate: 8001 is a PUSH PULL socket between loggerd and visiond
-
-# all ZMQ pub sub: port, should_log, frequency, (qlog_decimation)
-
-# frame syncing packet
-frame: [8002, true, 20., 1]
-# accel, gyro, and compass
-sensorEvents: [8003, true, 100., 100]
-# GPS data, also global timestamp
-gpsNMEA: [8004, true, 9.]  # 9 msgs each sec
-# CPU+MEM+GPU+BAT temps
-thermal: [8005, true, 2., 1]
-# List(CanData), list of can messages
-can: [8006, true, 100.]
-controlsState: [8007, true, 100., 100]
-#liveEvent: [8008, true, 0.]
-model: [8009, true, 20., 5]
-features: [8010, true, 0.]
-health: [8011, true, 2., 1]
-radarState: [8012, true, 20., 5]
-#liveUI: [8014, true, 0.]
-encodeIdx: [8015, true, 20.]
-liveTracks: [8016, true, 20.]
-sendcan: [8017, true, 100.]
-logMessage: [8018, true, 0.]
-liveCalibration: [8019, true, 4., 4]
-androidLog: [8020, true, 0.]
-carState: [8021, true, 100., 10]
-# 8022 is reserved for sshd
-carControl: [8023, true, 100., 10]
-plan: [8024, true, 20., 2]
-liveLocation: [8025, true, 0., 1]
-gpsLocation: [8026, true, 1., 1]
-ethernetData: [8027, true, 0.]
-navUpdate: [8028, true, 0.]
-qcomGnss: [8029, true, 0.]
-lidarPts: [8030, true, 0.]
-procLog: [8031, true, 0.5]
-gpsLocationExternal: [8032, true, 10., 1]
-ubloxGnss: [8033, true, 10.]
-clocks: [8034, true, 1., 1]
-liveMpc: [8035, false, 20.]
-liveLongitudinalMpc: [8036, false, 20.]
-navStatus: [8038, true, 0.]
-gpsLocationTrimble: [8039, true, 0.]
-trimbleGnss: [8041, true, 0.]
-ubloxRaw: [8042, true, 20.]
-gpsPlannerPoints: [8043, true, 0.]
-gpsPlannerPlan: [8044, true, 0.]
-applanixRaw: [8046, true, 0.]
-orbLocation: [8047, true, 0.]
-trafficEvents: [8048, true, 0.]
-liveLocationTiming: [8049, true, 0.]
-orbslamCorrection: [8050, true, 0.]
-liveLocationCorrected: [8051, true, 0.]
-orbObservation: [8052, true, 0.]
-applanixLocation: [8053, true, 0.]
-liveLocationKalman: [8054, true, 20., 2]
-uiNavigationEvent: [8055, true, 0.]
-orbOdometry: [8057, true, 0.]
-orbFeatures: [8058, false, 0.]
-orbKeyFrame: [8059, true, 0.]
-uiLayoutState: [8060, true, 0.]
-frontEncodeIdx: [8061, true, 5.] # should be 20fps on tici
-orbFeaturesSummary: [8062, true, 0.]
-driverState: [8063, true, 5., 1]
-liveParameters: [8064, true, 20., 2]
-liveMapData: [8065, true, 0.]
-cameraOdometry: [8066, true, 20., 5]
-pathPlan: [8067, true, 20., 2]
-kalmanOdometry: [8068, true, 0.]
-thumbnail: [8069, true, 0.2, 1]
-carEvents: [8070, true, 1., 1]
-carParams: [8071, true, 0.02, 1]
-frontFrame: [8072, true, 10.]
-dMonitoringState: [8073, true, 5., 1]
-offroadLayout: [8074, false, 0.]
-wideEncodeIdx: [8075, true, 20.]
-wideFrame: [8076, true, 20.]
-modelV2: [8077, true, 20., 20]
-
-testModel: [8040, false, 0.]
-testLiveLocation: [8045, false, 0.]
-testJoystick: [8056, false, 0.]
-
-# 8080 is reserved for slave testing daemon
-# 8762 is reserved for logserver
-
-# manager -- base process to manage starting and stopping of all others
-#   subscribes: thermal
-
-# **** processes that communicate with the outside world ****
-
-# thermald -- decides when to start and stop onroad
-#   subscribes: health, location
-#   publishes: thermal
-
-# boardd -- communicates with the car
-#   subscribes: sendcan
-#   publishes: can, health, ubloxRaw
-
-# sensord -- publishes IMU and Magnetometer
-#   publishes: sensorEvents
-
-# gpsd -- publishes EON's gps
-#   publishes: gpsNMEA
-
-# camerad -- publishes camera frames
-#   publishes: frame, frontFrame, thumbnail
-#   subscribes: driverState
-
-# dmonitoringmodeld -- runs face detection on camera frames
-#   publishes: driverState
-
-# **** stateful data transformers ****
-
-# modeld -- runs & publishes the model
-#   publishes: model, cameraOdometry
-#   subscribes: liveCalibration, pathPlan
-
-# plannerd -- decides where to drive the car
-#   subscribes: carState, model, radarState, controlsState, liveParameters
-#   publishes:  plan, pathPlan, liveMpc, liveLongitudinalMpc
-
-# controlsd -- drives the car by sending CAN messages to panda
-#   subscribes: can, thermal, health, plan, pathPlan, dMonitoringState, liveCalibration, model
-#   publishes:  carState, carControl, sendcan, controlsState, carEvents, carParams
-
-# dmonitoringd -- processes driver monitoring data and publishes driver awareness
-#   subscribes: driverState, liveCalibration, carState, model, gpsLocation
-#   publishes: dMonitoringState
-
-# radard -- processes the radar and vision data
-#   subscribes: can, controlsState, model, liveParameters
-#   publishes:  radarState, liveTracks
-
-# params_learner -- learns vehicle params by observing the vehicle dynamics
-#   subscribes: controlsState, sensorEvents, cameraOdometry
-#   publishes: liveParameters
-
-# calibrationd -- reads posenet and applies a temporal filter on the frame region to look at
-#   subscribes: cameraOdometry
-#   publishes: liveCalibration
-
-# ubloxd -- read raw ublox data and converts them in readable format
-#   subscribes: ubloxRaw
-#   publishes: ubloxGnss
-
-# **** LOGGING SERVICE ****
-
-# loggerd
-#   subscribes: EVERYTHING
-
-# **** NON VITAL SERVICES ****
-
-# ui
-#   subscribes: thermal, model, controlsState, uiLayout, liveCalibration, radarState, liveMpc, plusFrame, liveMapData
-
-# uploader
-#   communicates through file system with loggerd
-
-# deleter
-#   communicates through file system with loggerd and uploader
-
-# logmessaged -- central logging service, can log to cloud
-#   publishes:  logMessage
-
-# logcatd -- fetches logcat info from android
-#   publishes:  androidLog
-
-# proclogd -- fetches process information
-#   publishes: procLog
-
-# tombstoned -- reports native crashes
-
-# athenad -- on request, open a sub socket and return the value
-
-# updated -- waits for network access and tries to update every hour

cereal/services.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-import os
-import yaml
-
-
-class Service():
-  def __init__(self, port, should_log, frequency, decimation=None):
-    self.port = port
-    self.should_log = should_log
-    self.frequency = frequency
-    self.decimation = decimation
-
-
-service_list_path = os.path.join(os.path.dirname(__file__), "service_list.yaml")
-
-service_list = {}
-with open(service_list_path, "r") as f:
-  for k, v in yaml.safe_load(f).items():
-    decimation = None
-    if len(v) == 4:
-      decimation = v[3]
-
-    service_list[k] = Service(v[0], v[1], v[2], decimation)
-
-if __name__ == "__main__":
-  print("/* THIS IS AN AUTOGENERATED FILE, PLEASE EDIT service_list.yaml */")
-  print("#ifndef __SERVICES_H")
-  print("#define __SERVICES_H")
-  print("struct service { char name[0x100]; int port; bool should_log; int frequency; int decimation; };")
-  print("static struct service services[] = {")
-  for k, v in service_list.items():
-    print('  { .name = "%s", .port = %d, .should_log = %s, .frequency = %d, .decimation = %d },' % (k, v.port, "true" if v.should_log else "false", v.frequency, -1 if v.decimation is None else v.decimation))
-  print("};")
-  print("#endif")

codecov.yml

@@ -0,0 +1,8 @@
+comment: false
+coverage:
+  status:
+    project:
+      default:
+        informational: true
+    patch: off
+

common/SConscript

@@ -1,14 +1,4 @@
-Import('env', 'cython_dependencies')
+Import('envCython', 'common')
 
-# Build cython clock module
-env.Command(['common_pyx.so', 'clock.cpp'],
-            cython_dependencies + ['common_pyx_setup.py', 'clock.pyx'],
-            "cd common && python3 common_pyx_setup.py build_ext --inplace")
-
-# Build cython params module
-env.Command(['params_pyx.so', 'params_pyx.cpp'],
-            cython_dependencies + [
-                'params_pyx_setup.py', 'params_pyx.pyx', 'params_pxd.pxd',
-                '#selfdrive/common/params.cc', '#selfdrive/common/params.h',
-                '#selfdrive/common/util.c', '#selfdrive/common/util.h'],
-            "cd common && python3 params_pyx_setup.py build_ext --inplace")
+envCython.Program('clock.so', 'clock.pyx')
+envCython.Program('params_pyx.so', 'params_pyx.pyx', LIBS=envCython['LIBS'] + [common, 'zmq'])

common/api/__init__.py

@@ -1,8 +1,11 @@
 import jwt
+import os
 import requests
 from datetime import datetime, timedelta
 from common.basedir import PERSIST
-from selfdrive.version import version
+from selfdrive.version import get_version
+
+API_HOST = os.getenv('API_HOST', 'https://api.commadotai.com')
 
 class Api():
   def __init__(self, dongle_id):
@@ -27,15 +30,17 @@ class Api():
       'iat': now,
       'exp': now + timedelta(hours=1)
     }
-    return jwt.encode(payload, self.private_key, algorithm='RS256').decode('utf8')
+    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):
-  backend = "https://api.commadotai.com/"
-
   headers = {}
   if access_token is not None:
-    headers['Authorization'] = "JWT "+access_token
+    headers['Authorization'] = "JWT " + access_token
 
-  headers['User-Agent'] = "openpilot-" + version
+  headers['User-Agent'] = "openpilot-" + get_version()
 
-  return requests.request(method, backend+endpoint, timeout=timeout, headers=headers, params=params)
+  return requests.request(method, API_HOST + "/" + endpoint, timeout=timeout, headers=headers, params=params)

common/apk.py

@@ -1,105 +0,0 @@
-import os
-import subprocess
-import glob
-import hashlib
-import shutil
-from common.basedir import BASEDIR
-from selfdrive.swaglog import cloudlog
-
-android_packages = ("ai.comma.plus.offroad",)
-
-def get_installed_apks():
-  dat = subprocess.check_output(["pm", "list", "packages", "-f"], encoding='utf8').strip().split("\n")
-  ret = {}
-  for x in dat:
-    if x.startswith("package:"):
-      v, k = x.split("package:")[1].split("=")
-      ret[k] = v
-  return ret
-
-def install_apk(path):
-  # can only install from world readable path
-  install_path = "/sdcard/%s" % os.path.basename(path)
-  shutil.copyfile(path, install_path)
-
-  ret = subprocess.call(["pm", "install", "-r", install_path])
-  os.remove(install_path)
-  return ret == 0
-
-def start_offroad():
-  set_package_permissions()
-  system("am start -n ai.comma.plus.offroad/.MainActivity")
-
-def set_package_permissions():
-  try:
-    output = subprocess.check_output(['dumpsys', 'package', 'ai.comma.plus.offroad'], encoding="utf-8")
-    given_permissions = output.split("runtime permissions")[1]
-  except Exception:
-    given_permissions = ""
-
-  wanted_permissions = ["ACCESS_FINE_LOCATION", "READ_PHONE_STATE", "READ_EXTERNAL_STORAGE"]
-  for permission in wanted_permissions:
-    if permission not in given_permissions:
-      pm_grant("ai.comma.plus.offroad", "android.permission."+permission)
-
-  appops_set("ai.comma.plus.offroad", "SU", "allow")
-  appops_set("ai.comma.plus.offroad", "WIFI_SCAN", "allow")
-
-def appops_set(package, op, mode):
-  system(f"LD_LIBRARY_PATH= appops set {package} {op} {mode}")
-
-def pm_grant(package, permission):
-  system(f"pm grant {package} {permission}")
-
-def system(cmd):
-  try:
-    cloudlog.info("running %s" % cmd)
-    subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
-  except subprocess.CalledProcessError as e:
-    cloudlog.event("running failed",
-      cmd=e.cmd,
-      output=e.output[-1024:],
-      returncode=e.returncode)
-
-# *** external functions ***
-
-def update_apks():
-  # install apks
-  installed = get_installed_apks()
-
-  install_apks = glob.glob(os.path.join(BASEDIR, "apk/*.apk"))
-  for apk in install_apks:
-    app = os.path.basename(apk)[:-4]
-    if app not in installed:
-      installed[app] = None
-
-  cloudlog.info("installed apks %s" % (str(installed), ))
-
-  for app in installed.keys():
-    apk_path = os.path.join(BASEDIR, "apk/"+app+".apk")
-    if not os.path.exists(apk_path):
-      continue
-
-    h1 = hashlib.sha1(open(apk_path, 'rb').read()).hexdigest()
-    h2 = None
-    if installed[app] is not None:
-      h2 = hashlib.sha1(open(installed[app], 'rb').read()).hexdigest()
-      cloudlog.info("comparing version of %s  %s vs %s" % (app, h1, h2))
-
-    if h2 is None or h1 != h2:
-      cloudlog.info("installing %s" % app)
-
-      success = install_apk(apk_path)
-      if not success:
-        cloudlog.info("needing to uninstall %s" % app)
-        system("pm uninstall %s" % app)
-        success = install_apk(apk_path)
-
-      assert success
-
-def pm_apply_packages(cmd):
-  for p in android_packages:
-    system("pm %s %s" % (cmd, p))
-
-if __name__ == "__main__":
-  update_apks()

common/basedir.py

@@ -1,8 +1,11 @@
 import os
+from pathlib import Path
+
+from selfdrive.hardware import PC
+
 BASEDIR = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../"))
 
-from common.hardware import PC
 if PC:
-  PERSIST = os.path.join(BASEDIR, "persist")
+  PERSIST = os.path.join(str(Path.home()), ".comma", "persist")
 else:
   PERSIST = "/persist"

common/clock.pyx

@@ -1,3 +1,4 @@
+# distutils: language = c++
 # cython: language_level = 3
 from posix.time cimport clock_gettime, timespec, CLOCK_MONOTONIC_RAW, clockid_t
 

common/common_pyx_setup.py

@@ -1,20 +0,0 @@
-from distutils.core import Extension, setup  # pylint: disable=import-error,no-name-in-module
-from Cython.Build import cythonize
-
-from common.cython_hacks import BuildExtWithoutPlatformSuffix
-
-sourcefiles = ['clock.pyx']
-extra_compile_args = ["-std=c++1z"]
-
-setup(name='common',
-      cmdclass={'build_ext': BuildExtWithoutPlatformSuffix},
-      ext_modules=cythonize(
-        Extension(
-          "common_pyx",
-          language="c++",
-          sources=sourcefiles,
-          extra_compile_args=extra_compile_args,
-        ),
-        nthreads=4,
-      ),
-)

common/conversions.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+class Conversions:
+  # Speed
+  MPH_TO_KPH = 1.609344
+  KPH_TO_MPH = 1. / MPH_TO_KPH
+  MS_TO_KPH = 3.6
+  KPH_TO_MS = 1. / MS_TO_KPH
+  MS_TO_MPH = MS_TO_KPH * KPH_TO_MPH
+  MPH_TO_MS = MPH_TO_KPH * KPH_TO_MS
+  MS_TO_KNOTS = 1.9438
+  KNOTS_TO_MS = 1. / MS_TO_KNOTS
+
+  # Angle
+  DEG_TO_RAD = np.pi / 180.
+  RAD_TO_DEG = 1. / DEG_TO_RAD
+
+  # Mass
+  LB_TO_KG = 0.453592

common/cython_hacks.py

@@ -1,23 +0,0 @@
-import os
-import sysconfig
-from Cython.Distutils import build_ext
-
-def get_ext_filename_without_platform_suffix(filename):
-  name, ext = os.path.splitext(filename)
-  ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
-
-  if ext_suffix == ext:
-    return filename
-
-  ext_suffix = ext_suffix.replace(ext, '')
-  idx = name.find(ext_suffix)
-
-  if idx == -1:
-    return filename
-  else:
-    return name[:idx] + ext
-
-class BuildExtWithoutPlatformSuffix(build_ext):
-  def get_ext_filename(self, ext_name):
-    filename = super().get_ext_filename(ext_name)
-    return get_ext_filename_without_platform_suffix(filename)

common/dict_helpers.py

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

common/ffi_wrapper.py

@@ -28,7 +28,7 @@ def ffi_wrap(name, c_code, c_header, tmpdir="/tmp/ccache", cflags="", libraries=
     try:
       mod = __import__(cache)
     except Exception:
-      print("cache miss {0}".format(cache))
+      print(f"cache miss {cache}")
       compile_code(cache, c_code, c_header, tmpdir, cflags, libraries)
       mod = __import__(cache)
   finally:

common/file_helpers.py

@@ -35,32 +35,10 @@ def get_tmpdir_on_same_filesystem(path):
   if len(parts) > 1 and parts[1] == "scratch":
     return "/scratch/tmp"
   elif len(parts) > 2 and parts[2] == "runner":
-    return "/{}/runner/tmp".format(parts[1])
+    return f"/{parts[1]}/runner/tmp"
   return "/tmp"
 
 
-class AutoMoveTempdir():
-  def __init__(self, target_path, temp_dir=None):
-    self._target_path = target_path
-    self._path = tempfile.mkdtemp(dir=temp_dir)
-
-  @property
-  def name(self):
-    return self._path
-
-  def close(self):
-    os.rename(self._path, self._target_path)
-
-  def __enter__(self):
-    return self
-
-  def __exit__(self, exc_type, exc_value, traceback):
-    if exc_type is None:
-      self.close()
-    else:
-      shutil.rmtree(self._path)
-
-
 class NamedTemporaryDir():
   def __init__(self, temp_dir=None):
     self._path = tempfile.mkdtemp(dir=temp_dir)
@@ -79,13 +57,41 @@ class NamedTemporaryDir():
     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():
-    file_obj = writer.get_fileobject(dir=temp_dir)
-    os.chmod(file_obj.name, 0o644)
-    return file_obj
+    return writer.get_fileobject(dir=temp_dir)
   return _get_fileobject
 
+def monkeypatch_os_link():
+  # This is neccesary on EON/C2, where os.link is patched out of python
+  if not hasattr(os, 'link'):
+    from cffi import FFI
+    ffi = FFI()
+    ffi.cdef("int link(const char *oldpath, const char *newpath);")
+    libc = ffi.dlopen(None)
+
+    def link(src, dest):
+      return libc.link(src.encode(), dest.encode())
+    os.link = link
 
 def atomic_write_on_fs_tmp(path, **kwargs):
   """Creates an atomic writer using a temporary file in a temporary directory
@@ -93,6 +99,7 @@ def atomic_write_on_fs_tmp(path, **kwargs):
   """
   # TODO(mgraczyk): This use of AtomicWriter relies on implementation details to set the temp
   #                 directory.
+  monkeypatch_os_link()
   writer = AtomicWriter(path, **kwargs)
   return writer._open(_get_fileobject_func(writer, get_tmpdir_on_same_filesystem(path)))
 
@@ -101,22 +108,6 @@ def atomic_write_in_dir(path, **kwargs):
   """Creates an atomic writer using a temporary file in the same directory
      as the destination file.
   """
+  monkeypatch_os_link()
   writer = AtomicWriter(path, **kwargs)
   return writer._open(_get_fileobject_func(writer, os.path.dirname(path)))
-
-
-def atomic_write_in_dir_neos(path, contents, mode=None):
-  """
-  Atomically writes contents to path using a temporary file in the same directory
-  as path. Useful on NEOS, where `os.link` (required by atomic_write_in_dir) is missing.
-  """
-
-  f = tempfile.NamedTemporaryFile(delete=False, prefix=".tmp", dir=os.path.dirname(path))
-  f.write(contents)
-  f.flush()
-  if mode is not None:
-    os.fchmod(f.fileno(), mode)
-  os.fsync(f.fileno())
-  f.close()
-
-  os.rename(f.name, path)

common/filter_simple.py

@@ -1,9 +1,18 @@
-class FirstOrderFilter():
+class FirstOrderFilter:
   # first order filter
-  def __init__(self, x0, ts, dt):
-    self.k = (dt / ts) / (1. + dt / ts)
+  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):
-    self.x = (1. - self.k) * self.x + self.k * x
+    if self.initialized:
+      self.x = (1. - self.alpha) * self.x + self.alpha * x
+    else:
+      self.initialized = True
+      self.x = x
     return self.x

common/gpio.py

@@ -1,11 +1,3 @@
-GPIO_HUB_RST_N = 30
-GPIO_UBLOX_RST_N = 32
-GPIO_UBLOX_SAFEBOOT_N = 33
-GPIO_UBLOX_PWR_EN = 34
-GPIO_STM_RST_N = 124
-GPIO_STM_BOOT0 = 134
-
-
 def gpio_init(pin, output):
   try:
     with open(f"/sys/class/gpio/gpio{pin}/direction", 'wb') as f:

common/hardware.py

@@ -1,57 +0,0 @@
-import os
-import random
-from typing import cast
-
-from cereal import log
-from common.hardware_android import Android
-from common.hardware_tici import Tici
-from common.hardware_base import HardwareBase
-
-EON = os.path.isfile('/EON')
-TICI = os.path.isfile('/TICI')
-PC = not (EON or TICI)
-ANDROID = EON
-
-
-NetworkType = log.ThermalData.NetworkType
-NetworkStrength = log.ThermalData.NetworkStrength
-
-
-class Pc(HardwareBase):
-  def get_sound_card_online(self):
-    return True
-
-  def get_imei(self, slot):
-    return "%015d" % random.randint(0, 1 << 32)
-
-  def get_serial(self):
-    return "cccccccc"
-
-  def get_subscriber_info(self):
-    return ""
-
-  def reboot(self, reason=None):
-    print("REBOOT!")
-
-  def get_network_type(self):
-    return NetworkType.wifi
-
-  def get_sim_info(self):
-    return {
-      'sim_id': '',
-      'mcc_mnc': None,
-      'network_type': ["Unknown"],
-      'sim_state': ["ABSENT"],
-      'data_connected': False
-    }
-
-  def get_network_strength(self, network_type):
-    return NetworkStrength.unknown
-
-
-if EON:
-  HARDWARE = cast(HardwareBase, Android())
-elif TICI:
-  HARDWARE = cast(HardwareBase, Tici())
-else:
-  HARDWARE = cast(HardwareBase, Pc())

common/hardware_base.py

@@ -1,41 +0,0 @@
-from abc import abstractmethod
-
-
-class HardwareBase:
-  @staticmethod
-  def get_cmdline():
-    with open('/proc/cmdline') as f:
-      cmdline = f.read()
-    return {kv[0]: kv[1] for kv in [s.split('=') for s in cmdline.split(' ')] if len(kv) == 2}
-
-  @abstractmethod
-  def get_sound_card_online(self):
-    pass
-
-  @abstractmethod
-  def get_imei(self, slot):
-    pass
-
-  @abstractmethod
-  def get_serial(self):
-    pass
-
-  @abstractmethod
-  def get_subscriber_info(self):
-    pass
-
-  @abstractmethod
-  def reboot(self, reason=None):
-    pass
-
-  @abstractmethod
-  def get_network_type(self):
-    pass
-
-  @abstractmethod
-  def get_sim_info(self):
-    pass
-
-  @abstractmethod
-  def get_network_strength(self, network_type):
-    pass

common/hardware_tici.py

@@ -1,59 +0,0 @@
-import serial
-
-from common.hardware_base import HardwareBase
-from cereal import log
-import subprocess
-
-
-NetworkType = log.ThermalData.NetworkType
-NetworkStrength = log.ThermalData.NetworkStrength
-
-
-def run_at_command(cmd, timeout=0.1):
-  with serial.Serial("/dev/ttyUSB2", timeout=timeout) as ser:
-    ser.write(cmd + b"\r\n")
-    ser.readline()  # Modem echos request
-    return ser.readline().decode().rstrip()
-
-
-class Tici(HardwareBase):
-  def get_sound_card_online(self):
-    return True
-
-  def get_imei(self, slot):
-    if slot != 0:
-      return ""
-
-    for _ in range(10):
-      try:
-        imei = run_at_command(b"AT+CGSN")
-        if len(imei) == 15:
-          return imei
-      except serial.SerialException:
-        pass
-
-    raise RuntimeError("Error getting IMEI")
-
-  def get_serial(self):
-    return self.get_cmdline()['androidboot.serialno']
-
-  def get_subscriber_info(self):
-    return ""
-
-  def reboot(self, reason=None):
-    subprocess.check_output(["sudo", "reboot"])
-
-  def get_network_type(self):
-    return NetworkType.wifi
-
-  def get_sim_info(self):
-    return {
-      'sim_id': '',
-      'mcc_mnc': None,
-      'network_type': ["Unknown"],
-      'sim_state': ["ABSENT"],
-      'data_connected': False
-    }
-
-  def get_network_strength(self, network_type):
-    return NetworkStrength.unknown

common/kalman/SConscript

@@ -1,6 +1,3 @@
-Import('env', 'cython_dependencies')
-
-env.Command(['simple_kalman_impl.so'],
-            cython_dependencies + ['simple_kalman_impl.pyx', 'simple_kalman_impl.pxd', 'simple_kalman_setup.py'],
-            "cd common/kalman && python3 simple_kalman_setup.py build_ext --inplace")
+Import('envCython')
 
+envCython.Program('simple_kalman_impl.so', 'simple_kalman_impl.pyx')

common/kalman/simple_kalman_impl.pyx

@@ -1,3 +1,4 @@
+# distutils: language = c++
 # cython: language_level=3
 
 cdef class KF1D:

common/kalman/simple_kalman_setup.py

@@ -1,10 +0,0 @@
-from distutils.core import Extension, setup
-
-from Cython.Build import cythonize
-
-from common.cython_hacks import BuildExtWithoutPlatformSuffix
-
-setup(name='Simple Kalman Implementation',
-      cmdclass={'build_ext': BuildExtWithoutPlatformSuffix},
-      ext_modules=cythonize(Extension("simple_kalman_impl",
-                                      ["simple_kalman_impl.pyx"])))

common/kalman/tests/test_simple_kalman.py

@@ -36,8 +36,8 @@ class TestSimpleKalman(unittest.TestCase):
     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)
+    x = self.kf.update(100)
+    self.assertEqual(x, self.kf.x)
 
   def test_old_equal_new(self):
     for _ in range(1000):
@@ -82,3 +82,6 @@ kf = KF1D(x0=[[x0_0], [x1_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()

common/lazy_property.py

@@ -0,0 +1,12 @@
+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

common/logging_extra.py

@@ -3,6 +3,7 @@ import os
 import sys
 import copy
 import json
+import uuid
 import socket
 import logging
 import traceback
@@ -62,8 +63,48 @@ class SwagFormatter(logging.Formatter):
     return record_dict
 
   def format(self, record):
+    if self.swaglogger is None:
+      raise Exception("must set swaglogger before calling format()")
     return json_robust_dumps(self.format_dict(record))
 
+class SwagLogFileFormatter(SwagFormatter):
+  def fix_kv(self, k, v):
+    # append type to names to preserve legacy naming in logs
+    # avoids overlapping key namespaces with different types
+    # e.g. log.info() creates 'msg' -> 'msg$s'
+    #      log.event() creates 'msg.health.logMonoTime' -> 'msg.health.logMonoTime$i'
+    #      because overlapping namespace 'msg' caused problems
+    if isinstance(v, (str, bytes)):
+      k += "$s"
+    elif isinstance(v, float):
+      k += "$f"
+    elif isinstance(v, bool):
+      k += "$b"
+    elif isinstance(v, int):
+      k += "$i"
+    elif isinstance(v, dict):
+      nv = {}
+      for ik, iv in v.items():
+        ik, iv = self.fix_kv(ik, iv)
+        nv[ik] = iv
+      v = nv
+    elif isinstance(v, list):
+      k += "$a"
+    return k, v
+
+  def format(self, record):
+    if isinstance(record, str):
+      v = json.loads(record)
+    else:
+      v = self.format_dict(record)
+
+    mk, mv = self.fix_kv('msg', v['msg'])
+    del v['msg']
+    v[mk] = mv
+    v['id'] = uuid.uuid4().hex
+
+    return json_robust_dumps(v)
+
 class SwagErrorFilter(logging.Filter):
   def filter(self, record):
     return record.levelno < logging.ERROR
@@ -117,6 +158,8 @@ class SwagLogger(logging.Logger):
     evt.update(kwargs)
     if 'error' in kwargs:
       self.error(evt)
+    elif 'debug' in kwargs:
+      self.debug(evt)
     else:
       self.info(evt)
 
@@ -129,33 +172,33 @@ class SwagLogger(logging.Logger):
     #On some versions of IronPython, currentframe() returns None if
     #IronPython isn't run with -X:Frames.
     if f is not None:
-        f = f.f_back
+      f = f.f_back
     orig_f = f
     while f and stacklevel > 1:
-        f = f.f_back
-        stacklevel -= 1
+      f = f.f_back
+      stacklevel -= 1
     if not f:
-        f = orig_f
+      f = orig_f
     rv = "(unknown file)", 0, "(unknown function)", None
     while hasattr(f, "f_code"):
-        co = f.f_code
-        filename = os.path.normcase(co.co_filename)
+      co = f.f_code
+      filename = os.path.normcase(co.co_filename)
 
-        # TODO: is this pylint exception correct?
-        if filename == _srcfile:  # pylint: disable=comparison-with-callable
-            f = f.f_back
-            continue
-        sinfo = None
-        if stack_info:
-            sio = io.StringIO()
-            sio.write('Stack (most recent call last):\n')
-            traceback.print_stack(f, file=sio)
-            sinfo = sio.getvalue()
-            if sinfo[-1] == '\n':
-                sinfo = sinfo[:-1]
-            sio.close()
-        rv = (co.co_filename, f.f_lineno, co.co_name, sinfo)
-        break
+      # TODO: is this pylint exception correct?
+      if filename == _srcfile:  # pylint: disable=comparison-with-callable
+        f = f.f_back
+        continue
+      sinfo = None
+      if stack_info:
+        sio = io.StringIO()
+        sio.write('Stack (most recent call last):\n')
+        traceback.print_stack(f, file=sio)
+        sinfo = sio.getvalue()
+        if sinfo[-1] == '\n':
+          sinfo = sinfo[:-1]
+        sio.close()
+      rv = (co.co_filename, f.f_lineno, co.co_name, sinfo)
+      break
     return rv
 
 if __name__ == "__main__":

common/markdown.py

@@ -0,0 +1,48 @@
+from typing import List
+
+HTML_REPLACEMENTS = [
+  (r'&', r'&'),
+  (r'"', r'"'),
+]
+
+
+def parse_markdown(text: str, tab_length: int = 2) -> str:
+  lines = text.split("\n")
+  output: List[str] = []
+  list_level = 0
+
+  def end_outstanding_lists(level: int, end_level: int) -> int:
+    while level > end_level:
+      level -= 1
+      output.append("</ul>")
+      if level > 0:
+        output.append("</li>")
+    return end_level
+
+  for i, line in enumerate(lines):
+    if i + 1 < len(lines) and lines[i + 1].startswith("==="):  # heading
+      output.append(f"<h1>{line}</h1>")
+    elif line.startswith("==="):
+      pass
+    elif line.lstrip().startswith("* "):  # list
+      line_level = 1 + line.count(" " * tab_length, 0, line.index("*"))
+      if list_level >= line_level:
+        list_level = end_outstanding_lists(list_level, line_level)
+      else:
+        list_level += 1
+        if list_level > 1:
+          output[-1] = output[-1].replace("</li>", "")
+        output.append("<ul>")
+      output.append(f"<li>{line.replace('*', '', 1).lstrip()}</li>")
+    else:
+      list_level = end_outstanding_lists(list_level, 0)
+      if len(line) > 0:
+        output.append(line)
+
+  end_outstanding_lists(list_level, 0)
+  output_str = "\n".join(output) + "\n"
+
+  for (fr, to) in HTML_REPLACEMENTS:
+    output_str = output_str.replace(fr, to)
+
+  return output_str

common/numpy_fast.py

@@ -1,6 +1,3 @@
-def int_rnd(x):
-  return int(round(x))
-
 def clip(x, lo, hi):
   return max(lo, min(hi, x))
 

common/numpy_helpers.py

@@ -0,0 +1,22 @@
+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

common/params.py

@@ -1,4 +1,19 @@
-from common.params_pyx import Params, UnknownKeyName, put_nonblocking # pylint: disable=no-name-in-module, import-error
+from common.params_pyx import Params, ParamKeyType, UnknownKeyName, put_nonblocking # pylint: disable=no-name-in-module, import-error
 assert Params
+assert ParamKeyType
 assert UnknownKeyName
 assert put_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)}")

common/params_pxd.pxd

@@ -1,16 +0,0 @@
-from libcpp.string cimport string
-from libcpp cimport bool
-
-cdef extern from "selfdrive/common/params.cc":
-  pass
-
-cdef extern from "selfdrive/common/util.c":
-  pass
-
-cdef extern from "selfdrive/common/params.h":
-  cdef cppclass Params:
-    Params(bool)
-    Params(string)
-    string get(string, bool) nogil
-    int delete_db_value(string)
-    int write_db_value(string, string)

common/params_pyx.pyx

@@ -2,81 +2,29 @@
 # cython: language_level = 3
 from libcpp cimport bool
 from libcpp.string cimport string
-from params_pxd cimport Params as c_Params
-
-import os
 import threading
-from common.basedir import BASEDIR
 
-cdef enum TxType:
-  PERSISTENT = 1
-  CLEAR_ON_MANAGER_START = 2
-  CLEAR_ON_PANDA_DISCONNECT = 3
+cdef extern from "selfdrive/common/params.h":
+  cpdef enum ParamKeyType:
+    PERSISTENT
+    CLEAR_ON_MANAGER_START
+    CLEAR_ON_IGNITION_ON
+    CLEAR_ON_IGNITION_OFF
+    ALL
+
+  cdef cppclass c_Params "Params":
+    c_Params(string) nogil
+    string get(string, bool) nogil
+    bool getBool(string) nogil
+    int remove(string) nogil
+    int put(string, string) nogil
+    int putBool(string, bool) nogil
+    bool checkKey(string) nogil
+    void clearAll(ParamKeyType)
 
-keys = {
-  b"AccessToken": [TxType.CLEAR_ON_MANAGER_START],
-  b"AthenadPid": [TxType.PERSISTENT],
-  b"CalibrationParams": [TxType.PERSISTENT],
-  b"CarBatteryCapacity": [TxType.PERSISTENT],
-  b"CarParams": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"CarParamsCache": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"CarVin": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"CommunityFeaturesToggle": [TxType.PERSISTENT],
-  b"CompletedTrainingVersion": [TxType.PERSISTENT],
-  b"DisablePowerDown": [TxType.PERSISTENT],
-  b"DisableUpdates": [TxType.PERSISTENT],
-  b"DoUninstall": [TxType.CLEAR_ON_MANAGER_START],
-  b"DongleId": [TxType.PERSISTENT],
-  b"GitBranch": [TxType.PERSISTENT],
-  b"GitCommit": [TxType.PERSISTENT],
-  b"GitRemote": [TxType.PERSISTENT],
-  b"GithubSshKeys": [TxType.PERSISTENT],
-  b"HasAcceptedTerms": [TxType.PERSISTENT],
-  b"HasCompletedSetup": [TxType.PERSISTENT],
-  b"IsDriverViewEnabled": [TxType.CLEAR_ON_MANAGER_START],
-  b"IsLdwEnabled": [TxType.PERSISTENT],
-  b"IsMetric": [TxType.PERSISTENT],
-  b"IsOffroad": [TxType.CLEAR_ON_MANAGER_START],
-  b"IsRHD": [TxType.PERSISTENT],
-  b"IsTakingSnapshot": [TxType.CLEAR_ON_MANAGER_START],
-  b"IsUpdateAvailable": [TxType.CLEAR_ON_MANAGER_START],
-  b"IsUploadRawEnabled": [TxType.PERSISTENT],
-  b"LastAthenaPingTime": [TxType.PERSISTENT],
-  b"LastUpdateTime": [TxType.PERSISTENT],
-  b"LastUpdateException": [TxType.PERSISTENT],
-  b"LiveParameters": [TxType.PERSISTENT],
-  b"OpenpilotEnabledToggle": [TxType.PERSISTENT],
-  b"LaneChangeEnabled": [TxType.PERSISTENT],
-  b"PandaFirmware": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"PandaFirmwareHex": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"PandaDongleId": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"Passive": [TxType.PERSISTENT],
-  b"RecordFront": [TxType.PERSISTENT],
-  b"ReleaseNotes": [TxType.PERSISTENT],
-  b"ShouldDoUpdate": [TxType.CLEAR_ON_MANAGER_START],
-  b"SubscriberInfo": [TxType.PERSISTENT],
-  b"TermsVersion": [TxType.PERSISTENT],
-  b"TrainingVersion": [TxType.PERSISTENT],
-  b"UpdateAvailable": [TxType.CLEAR_ON_MANAGER_START],
-  b"UpdateFailedCount": [TxType.CLEAR_ON_MANAGER_START],
-  b"Version": [TxType.PERSISTENT],
-  b"Offroad_ChargeDisabled": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"Offroad_ConnectivityNeeded": [TxType.CLEAR_ON_MANAGER_START],
-  b"Offroad_ConnectivityNeededPrompt": [TxType.CLEAR_ON_MANAGER_START],
-  b"Offroad_TemperatureTooHigh": [TxType.CLEAR_ON_MANAGER_START],
-  b"Offroad_PandaFirmwareMismatch": [TxType.CLEAR_ON_MANAGER_START, TxType.CLEAR_ON_PANDA_DISCONNECT],
-  b"Offroad_InvalidTime": [TxType.CLEAR_ON_MANAGER_START],
-  b"Offroad_IsTakingSnapshot": [TxType.CLEAR_ON_MANAGER_START],
-  b"Offroad_NeosUpdate": [TxType.CLEAR_ON_MANAGER_START],
-  b"Offroad_UpdateFailed": [TxType.CLEAR_ON_MANAGER_START],
-}
 
 def ensure_bytes(v):
-  if isinstance(v, str):
-    return v.encode()
-  else:
-    return v
-
+  return v.encode() if isinstance(v, str) else v;
 
 class UnknownKeyName(Exception):
   pass
@@ -84,38 +32,28 @@ class UnknownKeyName(Exception):
 cdef class Params:
   cdef c_Params* p
 
-  def __cinit__(self, d=None, bool persistent_params=False):
-    if d is None:
-      self.p = new c_Params(persistent_params)
-    else:
-      self.p = new c_Params(<string>d.encode())
+  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=None):
-    for key in keys:
-      if tx_type is None or tx_type in keys[key]:
-        self.delete(key)
+  def clear_all(self, tx_type=ParamKeyType.ALL):
+    self.p.clearAll(tx_type)
 
-  def manager_start(self):
-    self.clear_all(TxType.CLEAR_ON_MANAGER_START)
-
-  def panda_disconnect(self):
-    self.clear_all(TxType.CLEAR_ON_PANDA_DISCONNECT)
-
-  def get(self, key, block=False, encoding=None):
+  def check_key(self, key):
     key = ensure_bytes(key)
-
-    if key not in keys:
+    if not self.p.checkKey(key):
       raise UnknownKeyName(key)
+    return key
 
-    cdef string k = key
-    cdef bool b = block
-
+  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, b)
+      val = self.p.get(k, block)
 
     if val == b"":
       if block:
@@ -125,10 +63,14 @@ cdef class Params:
       else:
         return None
 
-    if encoding is not None:
-      return val.decode(encoding)
-    else:
-      return val
+    return val if encoding is None else val.decode(encoding)
+
+  def get_bool(self, key):
+    cdef string k = self.check_key(key)
+    cdef bool r
+    with nogil:
+      r = self.p.getBool(k)
+    return r
 
   def put(self, key, dat):
     """
@@ -137,23 +79,26 @@ cdef class Params:
     Use the put_nonblocking helper function in time sensitive code, but
     in general try to avoid writing params as much as possible.
     """
-    key = ensure_bytes(key)
-    dat = ensure_bytes(dat)
+    cdef string k = self.check_key(key)
+    cdef string dat_bytes = ensure_bytes(dat)
+    with nogil:
+      self.p.put(k, dat_bytes)
 
-    if key not in keys:
-      raise UnknownKeyName(key)
-
-    self.p.write_db_value(key, dat)
+  def put_bool(self, key, bool val):
+    cdef string k = self.check_key(key)
+    with nogil:
+      self.p.putBool(k, val)
 
   def delete(self, key):
-    key = ensure_bytes(key)
-    self.p.delete_db_value(key)
+    cdef string k = self.check_key(key)
+    with nogil:
+      self.p.remove(k)
 
-
-def put_nonblocking(key, val, d=None):
+def put_nonblocking(key, val, d=""):
   def f(key, val):
     params = Params(d)
-    params.put(key, val)
+    cdef string k = ensure_bytes(key)
+    params.put(k, val)
 
   t = threading.Thread(target=f, args=(key, val))
   t.start()

common/params_pyx_setup.py

@@ -1,33 +0,0 @@
-import os
-import subprocess
-from distutils.core import Extension, setup
-from Cython.Build import cythonize
-
-from common.cython_hacks import BuildExtWithoutPlatformSuffix
-from common.basedir import BASEDIR
-from common.hardware import TICI
-
-ARCH = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()  # pylint: disable=unexpected-keyword-arg
-
-sourcefiles = ['params_pyx.pyx']
-extra_compile_args = ["-std=c++11"]
-
-if ARCH == "aarch64":
-  if TICI:
-    extra_compile_args += ["-DQCOM2"]
-  else:
-    extra_compile_args += ["-DQCOM"]
-
-
-setup(name='common',
-      cmdclass={'build_ext': BuildExtWithoutPlatformSuffix},
-      ext_modules=cythonize(
-        Extension(
-          "params_pyx",
-          language="c++",
-          sources=sourcefiles,
-          include_dirs=[BASEDIR, os.path.join(BASEDIR, 'selfdrive')],
-          extra_compile_args=extra_compile_args
-        )
-      )
-)

common/profiler.py

@@ -42,4 +42,4 @@ class Profiler():
         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("Iter clock: %2.6f   TOTAL: %2.2f" % (self.tot/self.iter, self.tot))
+    print(f"Iter clock: {self.tot / self.iter:2.6f}   TOTAL: {self.tot:2.2f}")

common/realtime.py

@@ -3,72 +3,83 @@ import gc
 import os
 import time
 import multiprocessing
+from typing import Optional
 
-from common.hardware import PC
-from common.common_pyx import sec_since_boot  # pylint: disable=no-name-in-module, import-error
+from common.clock import sec_since_boot  # pylint: disable=no-name-in-module, import-error
+from selfdrive.hardware import PC, TICI
 
 
 # time step for each process
 DT_CTRL = 0.01  # controlsd
 DT_MDL = 0.05  # model
-DT_DMON = 0.1  # driver monitoring
 DT_TRML = 0.5  # thermald and manager
 
+# driver monitoring
+if TICI:
+  DT_DMON = 0.05
+else:
+  DT_DMON = 0.1
+
 
 class Priority:
-  MIN_REALTIME = 52 # highest android process priority is 51
-  CTRL_LOW = MIN_REALTIME
-  CTRL_HIGH = MIN_REALTIME + 1
+  # CORE 2
+  # - modeld = 55
+  # - camerad = 54
+  CTRL_LOW = 51 # plannerd & radard
+
+  # CORE 3
+  # - boardd = 55
+  CTRL_HIGH = 53
 
 
-def set_realtime_priority(level):
+def set_realtime_priority(level: int) -> None:
   if not PC:
-    os.sched_setscheduler(0, os.SCHED_FIFO, os.sched_param(level))
+    os.sched_setscheduler(0, os.SCHED_FIFO, os.sched_param(level))  # type: ignore[attr-defined]
 
 
-def set_core_affinity(core):
+def set_core_affinity(core: int) -> None:
   if not PC:
-    os.sched_setaffinity(0, [core,])
+    os.sched_setaffinity(0, [core,])   # type: ignore[attr-defined]
 
 
-def config_realtime_process(core, priority):
+def config_realtime_process(core: int, priority: int) -> None:
   gc.disable()
   set_realtime_priority(priority)
   set_core_affinity(core)
 
 
-class Ratekeeper():
-  def __init__(self, rate, print_delay_threshold=0.):
+class Ratekeeper:
+  def __init__(self, rate: int, 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 = sec_since_boot() + self._interval
     self._print_delay_threshold = print_delay_threshold
     self._frame = 0
-    self._remaining = 0
+    self._remaining = 0.0
     self._process_name = multiprocessing.current_process().name
 
   @property
-  def frame(self):
+  def frame(self) -> int:
     return self._frame
 
   @property
-  def remaining(self):
+  def remaining(self) -> float:
     return self._remaining
 
   # Maintain loop rate by calling this at the end of each loop
-  def keep_time(self):
+  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):
+  def monitor_time(self) -> bool:
     lagged = False
     remaining = self._next_frame_time - sec_since_boot()
     self._next_frame_time += self._interval
     if self._print_delay_threshold is not None and remaining < -self._print_delay_threshold:
-      print("%s lagging by %.2f ms" % (self._process_name, -remaining * 1000))
+      print(f"{self._process_name} lagging by {-remaining * 1000:.2f} ms")
       lagged = True
     self._frame += 1
     self._remaining = remaining

common/spinner.py

@@ -4,22 +4,19 @@ from common.basedir import BASEDIR
 
 
 class Spinner():
-  def __init__(self, noop=False):
-    # spinner is currently only implemented for android
-    self.spinner_proc = None
-    if not noop:
-      try:
-        self.spinner_proc = subprocess.Popen(["./spinner"],
-                                             stdin=subprocess.PIPE,
-                                             cwd=os.path.join(BASEDIR, "selfdrive", "ui", "spinner"),
-                                             close_fds=True)
-      except OSError:
-        self.spinner_proc = None
+  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):
+  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:
@@ -27,6 +24,9 @@ class Spinner():
       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:
       try:

common/string_helpers.py

@@ -0,0 +1,6 @@
+def replace_right(s, old, new, occurrence):
+  # replace_right('1232425', '2', ' ', 1) -> '12324 5'
+  # replace_right('1232425', '2', ' ', 2) -> '123 4 5'
+
+  split = s.rsplit(old, occurrence)
+  return new.join(split)

common/tests/test_file_helpers.py

@@ -0,0 +1,27 @@
+import os
+import unittest
+from uuid import uuid4
+
+from common.file_helpers import atomic_write_on_fs_tmp
+from 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()

common/tests/test_markdown.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+from markdown_it import MarkdownIt
+import os
+import unittest
+
+from common.basedir import BASEDIR
+from common.markdown import parse_markdown
+
+
+class TestMarkdown(unittest.TestCase):
+  # validate that our simple markdown parser produces the same output as `markdown_it` from pip
+  def test_current_release_notes(self):
+    self.maxDiff = None
+
+    with open(os.path.join(BASEDIR, "RELEASES.md")) as f:
+      for r in f.read().split("\n\n"):
+
+        # No hyperlink support is ok
+        if '[' in r:
+          continue
+
+        self.assertEqual(MarkdownIt().render(r), parse_markdown(r))
+
+
+if __name__ == "__main__":
+  unittest.main()

common/tests/test_numpy_fast.py

@@ -0,0 +1,26 @@
+import numpy as np
+import unittest
+
+from 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()

common/tests/test_params.py

@@ -0,0 +1,94 @@
+import threading
+import time
+import tempfile
+import shutil
+import unittest
+
+from common.params import Params, ParamKeyType, UnknownKeyName, put_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"
+    self.params.clear_all(ParamKeyType.CLEAR_ON_MANAGER_START)
+    assert self.params.get("CarParams") is None
+    assert self.params.get("DongleId") is not None
+
+  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_delete_not_there(self):
+    assert self.params.get("CarParams") is None
+    self.params.delete("CarParams")
+    assert self.params.get("CarParams") is None
+
+  def test_get_bool(self):
+    self.params.delete("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"
+
+
+if __name__ == "__main__":
+  unittest.main()

common/tests/test_xattr.py

@@ -0,0 +1,47 @@
+import os
+import tempfile
+import shutil
+import unittest
+
+from common.xattr import getxattr, setxattr, listxattr, removexattr
+
+class TestParams(unittest.TestCase):
+  USER_TEST='user.test'
+  def setUp(self):
+    self.tmpdir = tempfile.mkdtemp()
+    self.tmpfn = os.path.join(self.tmpdir, 'test.txt')
+    open(self.tmpfn, 'w').close()
+    #print("using", self.tmpfn)
+
+  def tearDown(self):
+    shutil.rmtree(self.tmpdir)
+
+  def test_getxattr_none(self):
+    a = getxattr(self.tmpfn, TestParams.USER_TEST)
+    assert a is None
+
+  def test_listxattr_none(self):
+    l = listxattr(self.tmpfn)
+    assert l == []
+
+  def test_setxattr(self):
+    setxattr(self.tmpfn, TestParams.USER_TEST, b'123')
+    a = getxattr(self.tmpfn, TestParams.USER_TEST)
+    assert a == b'123'
+
+  def test_listxattr(self):
+    setxattr(self.tmpfn, 'user.test1', b'123')
+    setxattr(self.tmpfn, 'user.test2', b'123')
+    l = listxattr(self.tmpfn)
+    assert l == ['user.test1', 'user.test2']
+
+  def test_removexattr(self):
+    setxattr(self.tmpfn, TestParams.USER_TEST, b'123')
+    a = getxattr(self.tmpfn, TestParams.USER_TEST)
+    assert a == b'123'
+    removexattr(self.tmpfn, TestParams.USER_TEST)
+    a = getxattr(self.tmpfn, TestParams.USER_TEST)
+    assert a is None
+
+if __name__ == "__main__":
+  unittest.main()