Revert "Reapply "Reapply "ICBM?"""

This reverts commit 649dc17f8a.

.codespellignore

@@ -0,0 +1,6 @@
+Wen
+REGIST
+PullRequest
+cancelled
+FOF
+NoO

.dockerignore

@@ -0,0 +1,18 @@
+**/.git
+.DS_Store
+*.dylib
+*.DSYM
+*.d
+*.pyc
+*.pyo
+.*.swp
+.*.swo
+.*.un~
+*.tmp
+*.o
+*.o-*
+*.os
+*.os-*
+
+venv/
+.venv/

.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

.gitignore

@@ -1,4 +1,6 @@
 venv/
+.venv/
+.ci_cache
 .env
 .clang-format
 .DS_Store
@@ -8,11 +10,13 @@ venv/
 .overlay_init
 .overlay_consistent
 .sconsign.dblite
-.vscode*
-model2.png
 a.out
 .hypothesis
+.cache/
 
+/docs_site/
+
+*.mp4
 *.dylib
 *.DSYM
 *.d
@@ -32,36 +36,22 @@ a.out
 *.class
 *.pyxbldc
 *.vcd
+*.mo
+*_pyx.cpp
+*.stats
 config.json
 clcache
 compile_commands.json
+compare_runtime*.html
 
-persist
-board/obj/
-selfdrive/boardd/boardd
-selfdrive/logcatd/logcatd
-selfdrive/mapd/default_speeds_by_region.json
-system/proclogd/proclogd
-selfdrive/ui/_ui
-selfdrive/test/longitudinal_maneuvers/out
-selfdrive/visiond/visiond
-selfdrive/sensord/_gpsd
-selfdrive/sensord/_sensord
+selfdrive/pandad/pandad
+cereal/services.h
+cereal/gen
+cereal/messaging/bridge
+selfdrive/ui/translations/tmp
+selfdrive/car/tests/cars_dump
 system/camerad/camerad
 system/camerad/test/ae_gray_test
-selfdrive/modeld/_modeld
-selfdrive/modeld/_dmonitoringmodeld
-/src/
-
-one
-/body/
-openpilot
-notebooks
-xx
-yy
-hyperthneed
-panda_jungle
-provisioning
 
 .coverage*
 coverage.xml
@@ -74,11 +64,42 @@ flycheck_*
 cppcheck_report.txt
 comma*.sh
 
-selfdrive/modeld/thneed/compile
-selfdrive/modeld/models/*.thneed
+selfdrive/modeld/models/*.pkl
+sunnypilot/modeld*/thneed/compile
+sunnypilot/modeld*/models/*.thneed
+sunnypilot/modeld*/models/*.pkl
 
+# openpilot log files
 *.bz2
+*.zst
 
 build/
 
 !**/.gitkeep
+
+poetry.toml
+Pipfile
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+### JetBrains ###
+!.idea/customTargets.xml
+!.idea/tools/*
+!.run/*

.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+  "recommendations": [
+    "ms-python.python",
+    "ms-vscode.cpptools",
+    "elagil.pre-commit-helper",
+    "charliermarsh.ruff",
+  ]
+}

.vscode/launch.json

@@ -0,0 +1,85 @@
+{
+  "version": "0.2.0",
+  "inputs": [
+    {
+      "id": "python_process",
+      "type": "pickString",
+      "description": "Select the process to debug",
+      "options": [
+        "selfdrive/controls/controlsd.py",
+        "system/timed/timed.py",
+        "tools/sim/run_bridge.py"
+      ]
+    },
+    {
+      "id": "cpp_process",
+      "type": "pickString",
+      "description": "Select the process to debug",
+      "options": [
+        "selfdrive/ui/ui"
+      ]
+    },
+    {
+      "id": "args",
+      "description": "Arguments to pass to the process",
+      "type": "promptString"
+    },
+    {
+      "id": "replayArg",
+      "type": "promptString",
+      "description": "Enter route or segment to replay."
+    }
+  ],
+  "configurations": [
+    {
+      "name": "Python: openpilot Process",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${input:python_process}",
+      "console": "integratedTerminal",
+      "justMyCode": true,
+      "args": "${input:args}"
+    },
+    {
+      "name": "C++: openpilot Process",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/${input:cpp_process}",
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Attach LLDB to Replay drive",
+      "type": "lldb",
+      "request": "attach",
+      "pid": "${command:pickMyProcess}",
+      "initCommands": [
+        "script import time; time.sleep(3)"
+      ]
+    },
+    {
+      "name": "Replay drive",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${workspaceFolder}/opendbc/safety/tests/safety_replay/replay_drive.py",
+      "args": [
+        "${input:replayArg}"
+      ],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}"
+      },
+      "subProcess": true,
+      "stopOnEntry": false
+    }
+  ],
+  "compounds": [
+    {
+      "name": "Replay drive + Safety LLDB",
+      "configurations": [
+        "Replay drive",
+        "Attach LLDB to Replay drive"
+      ]
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,27 @@
+{
+  "editor.tabSize": 2,
+  "editor.insertSpaces": true,
+  "editor.renderWhitespace": "trailing",
+  "files.trimTrailingWhitespace": true,
+  "search.exclude": {
+    "**/.git": true,
+    "**/.venv": true,
+    "**/__pycache__": true
+  },
+  "files.exclude": {
+    "**/.git": true,
+    "**/.venv": true,
+    "**/__pycache__": true
+  },
+  "python.analysis.exclude": [
+    "**/.git",
+    "**/.venv",
+    "**/__pycache__",
+    // exclude directories that should be using the symlinked version
+    "common/**",
+    "selfdrive/**",
+    "system/**",
+    "third_party/**",
+    "tools/**",
+  ]
+}

Dockerfile.openpilot

@@ -0,0 +1,14 @@
+FROM ghcr.io/commaai/openpilot-base:latest
+
+ENV PYTHONUNBUFFERED=1
+
+ENV OPENPILOT_PATH=/home/batman/openpilot
+
+RUN mkdir -p ${OPENPILOT_PATH}
+WORKDIR ${OPENPILOT_PATH}
+
+COPY . ${OPENPILOT_PATH}/
+
+ENV UV_BIN="/home/batman/.local/bin/"
+ENV PATH="$UV_BIN:$PATH"
+RUN UV_PROJECT_ENVIRONMENT=$VIRTUAL_ENV uv run scons --cache-readonly -j$(nproc)

Dockerfile.openpilot_base

@@ -0,0 +1,82 @@
+FROM ubuntu:24.04
+
+ENV PYTHONUNBUFFERED=1
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends sudo tzdata locales ssh pulseaudio xvfb x11-xserver-utils gnome-screenshot python3-tk python3-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && locale-gen
+ENV LANG=en_US.UTF-8
+ENV LANGUAGE=en_US:en
+ENV LC_ALL=en_US.UTF-8
+
+COPY tools/install_ubuntu_dependencies.sh /tmp/tools/
+RUN /tmp/tools/install_ubuntu_dependencies.sh && \
+    rm -rf /var/lib/apt/lists/* /tmp/* && \
+    cd /usr/lib/gcc/arm-none-eabi/* && \
+    rm -rf arm/ thumb/nofp thumb/v6* thumb/v8* thumb/v7+fp thumb/v7-r+fp.sp
+
+# Add OpenCL
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    apt-utils \
+    alien \
+    unzip \
+    tar \
+    curl \
+    xz-utils \
+    dbus \
+    gcc-arm-none-eabi \
+    tmux \
+    vim \
+    libx11-6 \
+    wget \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /tmp/opencl-driver-intel && \
+    cd /tmp/opencl-driver-intel && \
+    wget https://github.com/intel/llvm/releases/download/2024-WW14/oclcpuexp-2024.17.3.0.09_rel.tar.gz && \
+    wget https://github.com/oneapi-src/oneTBB/releases/download/v2021.12.0/oneapi-tbb-2021.12.0-lin.tgz && \
+    mkdir -p /opt/intel/oclcpuexp_2024.17.3.0.09_rel && \
+    cd /opt/intel/oclcpuexp_2024.17.3.0.09_rel && \
+    tar -zxvf /tmp/opencl-driver-intel/oclcpuexp-2024.17.3.0.09_rel.tar.gz && \
+    mkdir -p /etc/OpenCL/vendors && \
+    echo /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64/libintelocl.so > /etc/OpenCL/vendors/intel_expcpu.icd && \
+    cd /opt/intel && \
+    tar -zxvf /tmp/opencl-driver-intel/oneapi-tbb-2021.12.0-lin.tgz && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbb.so /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbbmalloc.so /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbb.so.12 /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbbmalloc.so.2 /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    mkdir -p /etc/ld.so.conf.d && \
+    echo /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 > /etc/ld.so.conf.d/libintelopenclexp.conf && \
+    ldconfig -f /etc/ld.so.conf.d/libintelopenclexp.conf && \
+    cd / && \
+    rm -rf /tmp/opencl-driver-intel
+
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV NVIDIA_DRIVER_CAPABILITIES=graphics,utility,compute
+ENV QTWEBENGINE_DISABLE_SANDBOX=1
+
+RUN dbus-uuidgen > /etc/machine-id
+RUN apt-get update && apt-get install -y fonts-noto-cjk fonts-noto-color-emoji
+
+ARG USER=batman
+ARG USER_UID=1001
+RUN useradd -m -s /bin/bash -u $USER_UID $USER
+RUN usermod -aG sudo $USER
+RUN echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
+USER $USER
+
+COPY --chown=$USER pyproject.toml uv.lock /home/$USER
+COPY --chown=$USER tools/install_python_dependencies.sh /home/$USER/tools/
+
+ENV VIRTUAL_ENV=/home/$USER/.venv
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+RUN cd /home/$USER && \
+    tools/install_python_dependencies.sh && \
+    rm -rf tools/ pyproject.toml uv.lock .cache
+
+USER root
+RUN sudo git config --global --add safe.directory /tmp/openpilot

Dockerfile.sunnypilot

@@ -0,0 +1,12 @@
+FROM ghcr.io/sunnypilot/sunnypilot-base:latest
+
+ENV PYTHONUNBUFFERED=1
+
+ENV OPENPILOT_PATH=/home/batman/openpilot
+
+RUN mkdir -p ${OPENPILOT_PATH}
+WORKDIR ${OPENPILOT_PATH}
+
+COPY . ${OPENPILOT_PATH}/
+
+RUN scons --cache-readonly -j$(nproc)

Dockerfile.sunnypilot_base

@@ -0,0 +1,83 @@
+FROM ubuntu:24.04
+
+ENV PYTHONUNBUFFERED=1
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends sudo tzdata locales ssh pulseaudio xvfb x11-xserver-utils gnome-screenshot python3-tk python3-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && locale-gen
+ENV LANG=en_US.UTF-8
+ENV LANGUAGE=en_US:en
+ENV LC_ALL=en_US.UTF-8
+
+COPY tools/install_ubuntu_dependencies.sh /tmp/tools/
+RUN /tmp/tools/install_ubuntu_dependencies.sh && \
+    rm -rf /var/lib/apt/lists/* /tmp/* && \
+    cd /usr/lib/gcc/arm-none-eabi/* && \
+    rm -rf arm/ thumb/nofp thumb/v6* thumb/v8* thumb/v7+fp thumb/v7-r+fp.sp
+
+# Add OpenCL
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    apt-utils \
+    alien \
+    unzip \
+    tar \
+    curl \
+    xz-utils \
+    dbus \
+    gcc-arm-none-eabi \
+    tmux \
+    vim \
+    libx11-6 \
+    wget \
+    rsync \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /tmp/opencl-driver-intel && \
+    cd /tmp/opencl-driver-intel && \
+    wget https://github.com/intel/llvm/releases/download/2024-WW14/oclcpuexp-2024.17.3.0.09_rel.tar.gz && \
+    wget https://github.com/oneapi-src/oneTBB/releases/download/v2021.12.0/oneapi-tbb-2021.12.0-lin.tgz && \
+    mkdir -p /opt/intel/oclcpuexp_2024.17.3.0.09_rel && \
+    cd /opt/intel/oclcpuexp_2024.17.3.0.09_rel && \
+    tar -zxvf /tmp/opencl-driver-intel/oclcpuexp-2024.17.3.0.09_rel.tar.gz && \
+    mkdir -p /etc/OpenCL/vendors && \
+    echo /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64/libintelocl.so > /etc/OpenCL/vendors/intel_expcpu.icd && \
+    cd /opt/intel && \
+    tar -zxvf /tmp/opencl-driver-intel/oneapi-tbb-2021.12.0-lin.tgz && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbb.so /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbbmalloc.so /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbb.so.12 /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    ln -s /opt/intel/oneapi-tbb-2021.12.0/lib/intel64/gcc4.8/libtbbmalloc.so.2 /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 && \
+    mkdir -p /etc/ld.so.conf.d && \
+    echo /opt/intel/oclcpuexp_2024.17.3.0.09_rel/x64 > /etc/ld.so.conf.d/libintelopenclexp.conf && \
+    ldconfig -f /etc/ld.so.conf.d/libintelopenclexp.conf && \
+    cd / && \
+    rm -rf /tmp/opencl-driver-intel
+
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV NVIDIA_DRIVER_CAPABILITIES=graphics,utility,compute
+ENV QTWEBENGINE_DISABLE_SANDBOX=1
+
+RUN dbus-uuidgen > /etc/machine-id
+RUN apt-get update && apt-get install -y fonts-noto-cjk fonts-noto-color-emoji
+
+ARG USER=batman
+ARG USER_UID=1001
+RUN useradd -m -s /bin/bash -u $USER_UID $USER
+RUN usermod -aG sudo $USER
+RUN echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
+USER $USER
+
+COPY --chown=$USER pyproject.toml uv.lock /home/$USER
+COPY --chown=$USER tools/install_python_dependencies.sh /home/$USER/tools/
+
+ENV VIRTUAL_ENV=/home/$USER/.venv
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+RUN cd /home/$USER && \
+    tools/install_python_dependencies.sh && \
+    rm -rf tools/ pyproject.toml uv.lock .cache
+
+USER root
+RUN sudo git config --global --add safe.directory /tmp/openpilot

Jenkinsfile

@@ -1,164 +0,0 @@
-def phone(String ip, String step_label, String cmd) {
-  withCredentials([file(credentialsId: 'id_rsa', variable: 'key_file')]) {
-    def ssh_cmd = """
-ssh -tt -o StrictHostKeyChecking=no -i ${key_file} 'comma@${ip}' /usr/bin/bash <<'END'
-
-set -e
-
-export CI=1
-export TEST_DIR=${env.TEST_DIR}
-export SOURCE_DIR=${env.SOURCE_DIR}
-export GIT_BRANCH=${env.GIT_BRANCH}
-export GIT_COMMIT=${env.GIT_COMMIT}
-export AZURE_TOKEN='${env.AZURE_TOKEN}'
-
-source ~/.bash_profile
-if [ -f /TICI ]; then
-  source /etc/profile
-fi
-
-ln -snf ${env.TEST_DIR} /data/pythonpath
-
-cd ${env.TEST_DIR} || true
-${cmd}
-exit 0
-
-END"""
-
-    sh script: ssh_cmd, label: step_label
-  }
-}
-
-def phone_steps(String device_type, steps) {
-  lock(resource: "", label: device_type, inversePrecedence: true, variable: 'device_ip', quantity: 1) {
-    timeout(time: 20, unit: 'MINUTES') {
-      phone(device_ip, "git checkout", readFile("selfdrive/test/setup_device_ci.sh"),)
-      steps.each { item ->
-        phone(device_ip, item[0], item[1])
-      }
-    }
-  }
-}
-
-pipeline {
-  agent none
-  environment {
-    CI = "1"
-    TEST_DIR = "/data/openpilot"
-    SOURCE_DIR = "/data/openpilot_source/"
-    AZURE_TOKEN = credentials('azure_token')
-  }
-  options {
-    timeout(time: 4, unit: 'HOURS')
-  }
-
-  stages {
-    stage('build release3') {
-      agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-      when {
-        branch 'devel-staging'
-      }
-      steps {
-        phone_steps("tici", [
-          ["build release3-staging & dashcam3-staging", "PUSH=1 $SOURCE_DIR/release/build_release.sh"],
-        ])
-      }
-    }
-
-    stage('openpilot tests') {
-      when {
-        not {
-          anyOf {
-            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-*'
-          }
-        }
-      }
-
-      parallel {
-
-        stage('simulator') {
-          agent {
-            dockerfile {
-              filename 'Dockerfile.sim_nvidia'
-              dir 'tools/sim'
-              args '--user=root'
-            }
-          }
-          steps {
-            sh "git config --global --add safe.directory ${WORKSPACE}"
-            sh "git lfs pull"
-            lock(resource: "", label: "simulator", inversePrecedence: true, quantity: 1) {
-              sh "${WORKSPACE}/tools/sim/build_container.sh"
-              sh "DETACH=1 ${WORKSPACE}/tools/sim/start_carla.sh"
-              sh "${WORKSPACE}/tools/sim/start_openpilot_docker.sh"
-            }
-          }
-
-          post {
-            always {
-              sh "docker kill carla_sim || true"
-              sh "rm -rf ${WORKSPACE}/* || true"
-              sh "rm -rf .* || true"
-            }
-          }
-        }
-
-        stage('build') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          environment {
-            R3_PUSH = "${env.BRANCH_NAME == 'master' ? '1' : ' '}"
-          }
-          steps {
-            phone_steps("tici", [
-              ["build master-ci", "cd $SOURCE_DIR/release && TARGET_DIR=$TEST_DIR EXTRA_FILES='tools/' ./build_devel.sh"],
-              ["build openpilot", "cd selfdrive/manager && ./build.py"],
-              ["check dirty", "release/check-dirty.sh"],
-              ["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('HW + Unit Tests') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici2", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["test power draw", "python system/hardware/tici/test_power_draw.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"],
-              ["test sensord", "python selfdrive/sensord/test/test_sensord.py"],
-            ])
-          }
-        }
-
-        stage('camerad') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici-party", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["test camerad", "python system/camerad/test/test_camerad.py"],
-              ["test exposure", "python system/camerad/test/test_exposure.py"],
-            ])
-          }
-        }
-
-        stage('replay') {
-          agent { docker { image 'ghcr.io/commaai/alpine-ssh'; args '--user=root' } }
-          steps {
-            phone_steps("tici3", [
-              ["build", "cd selfdrive/manager && ./build.py"],
-              ["model replay", "cd selfdrive/test/process_replay && ./model_replay.py"],
-            ])
-          }
-        }
-      }
-
-    }
-  }
-}

LICENSE.md

@@ -0,0 +1,21 @@
+# Custom MIT License
+
+Copyright (c) 2024, Haibin Wen, SUNNYPILOT LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to view and modify the Software, subject to the following conditions:
+
+1. **Permission Required**: Permission Required for Commercial, For-Profit, or Closed Source Use: Use of the Software, in whole or in part, for any commercial purposes, for-profit projects, or in closed source projects requires explicit written permission from the original author(s).
+
+2. **Redistribution**: Any redistribution of the Software, modified or unmodified, must retain this license notice and the following acknowledgment:
+   "This software is licensed under a custom license requiring permission for use."
+
+3. **Visibility**: Any project that uses the Software must visibly mention the following acknowledgment:
+   "This project uses software from Haibin Wen and SUNNYPILOT LLC and is licensed under a custom license requiring permission for use."
+
+4. **No Warranty**: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Contact sunnypilot Support <support@sunnypilot.ai> for permission requests.
+
+---
+
+Haibin Wen, SUNNYPILOT LLC

README.md

@@ -1,149 +1,130 @@
-![](https://i.imgur.com/b0ZyIx5.jpg)
+![](https://user-images.githubusercontent.com/47793918/233812617-beab2e71-57b9-479e-8bff-c3931347ca40.png)
 
-Table of Contents
-=======================
+## 🌞 What is sunnypilot?
+[sunnypilot](https://github.com/sunnyhaibin/sunnypilot) is a fork of comma.ai's openpilot, an open source driver assistance system. sunnypilot offers the user a unique driving experience for over 300+ supported car makes and models with modified behaviors of driving assist engagements. sunnypilot complies with comma.ai's safety rules as accurately as possible.
 
-* [What is openpilot?](#what-is-openpilot)
-* [Running in a car](#running-in-a-car)
-* [Running on PC](#running-on-pc)
-* [Community and Contributing](#community-and-contributing)
-* [User Data and comma Account](#user-data-and-comma-account)
-* [Safety and Testing](#safety-and-testing)
-* [Directory Structure](#directory-structure)
-* [Licensing](#licensing)
+## 💭 Join our Community Forum
+Join the official sunnypilot community forum to stay up to date with all the latest features and be a part of shaping the future of sunnypilot!
+* https://community.sunnypilot.ai/
 
----
+## Documentation
+https://docs.sunnypilot.ai/ is your one stop shop for everything from features to installation to FAQ about the sunnypilot
 
-What is openpilot?
-------
+## 🚘 Running on a dedicated device in a car
+* A supported device to run this software
+    * a [comma three](https://comma.ai/shop/products/three) or a [C3X](https://comma.ai/shop/comma-3x)
+* This software
+* One of [the 325+ supported cars](https://github.com/sunnypilot/sunnypilot/blob/master/docs/CARS.md). We support Honda, Toyota, Hyundai, Nissan, Kia, Chrysler, Lexus, Acura, Audi, VW, Ford, and more. If your car is not supported but has adaptive cruise control and lane-keeping assist, it's likely able to run sunnypilot.
+* A [car harness](https://comma.ai/shop/products/car-harness) to connect to your car
 
-[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).
+Detailed instructions for [how to mount the device in a car](https://comma.ai/setup).
 
-<table>
-  <tr>
-    <td><a href="https://youtu.be/NmBfgOanCyk" title="Video By Greer Viau"><img src="https://i.imgur.com/1w8c6d2.jpg"></a></td>
-    <td><a href="https://youtu.be/VHKyqZ7t8Gw" title="Video By Logan LeGrand"><img src="https://i.imgur.com/LnBucik.jpg"></a></td>
-    <td><a href="https://youtu.be/VxiR4iyBruo" title="Video By Charlie Kim"><img src="https://i.imgur.com/4Qoy48c.jpg"></a></td>
-    <td><a href="https://youtu.be/-IkImTe1NYE" title="Video By Aragon"><img src="https://i.imgur.com/04VNzPf.jpg"></a></td>
-  </tr>
-  <tr>
-    <td><a href="https://youtu.be/iIUICQkdwFQ" title="Video By Logan LeGrand"><img src="https://i.imgur.com/b1LHQTy.jpg"></a></td>
-    <td><a href="https://youtu.be/XOsa0FsVIsg" title="Video By PinoyDrives"><img src="https://i.imgur.com/6FG0Bd8.jpg"></a></td>
-    <td><a href="https://youtu.be/bCwcJ98R_Xw" title="Video By JS"><img src="https://i.imgur.com/zO18CbW.jpg"></a></td>
-    <td><a href="https://youtu.be/BQ0tF3MTyyc" title="Video By Tsai-Fi"><img src="https://i.imgur.com/eZzelq3.jpg"></a></td>
-  </tr>
-</table>
+## Installation
+Please refer to [Recommended Branches](#recommended-branches) to find your preferred/supported branch. This guide will assume you want to install the latest `staging` branch.
+
+### If you want to use our newest branches (our rewrite)
+> [!TIP]
+>You can see the rewrite state on our [rewrite project board](https://github.com/orgs/sunnypilot/projects/2), and to install the new branches, you can use the following links
+
+* sunnypilot not installed or you installed a version before 0.8.17?
+  1. [Factory reset/uninstall](https://github.com/commaai/openpilot/wiki/FAQ#how-can-i-reset-the-device) the previous software if you have another software/fork installed.
+  2. After factory reset/uninstall and upon reboot, select `Custom Software` when given the option.
+  3. Input the installation URL per [Recommended Branches](#recommended-branches). Example: ```https://staging.sunnypilot.ai```.
+  4. Complete the rest of the installation following the onscreen instructions.
+
+* sunnypilot already installed and you installed a version after 0.8.17?
+  1. On the comma three/3X, go to `Settings` ▶️ `Software`.
+  2. At the `Download` option, press `CHECK`. This will fetch the list of latest branches from sunnypilot.
+  3. At the `Target Branch` option, press `SELECT` to open the Target Branch selector.
+  4. Scroll to select the desired branch per  Recommended Branches (see below). Example: `staging`
+
+### Recommended Branches
+|      Branch     |                 Installation URL              |
+|:---------------:|:---------------------------------------------:|
+| `release`       | `https://release.sunnypilot.ai`               |
+| `staging`       | `https://staging.sunnypilot.ai`               |
+|   `dev`         | `https://dev.sunnypilot.ai`                   |
+| `custom-branch` | `https://install.sunnypilot.ai/{branch_name}` |
+
+> [!TIP]
+> You can use sunnypilot/targetbranch as an install URL. Example: 'sunnypilot/staging'.
+
+> [!NOTE]
+> Do you require further assistance with software installation? Join the [sunnypilot community forum](https://community.sunnypilot.ai/new-topic?category=general/qa) and create a topic in the General/Q&A Category channel.
 
 
-Running on a dedicated device in a car
-------
+<details>
 
-To use openpilot in a car, you need four things
-* A supported device to run this software: a [comma three](https://comma.ai/shop/products/three).
-* This software. The setup procedure of the comma three allows the user to enter a url for custom software.
-The url, openpilot.comma.ai will install the release version of openpilot. To install openpilot master, you can use installer.comma.ai/commaai/master, and replacing commaai with another github username can install a fork.
-* One of [the 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 [car harness](https://comma.ai/shop/products/car-harness) to connect to your car.
+<summary>Older legacy branches</summary>
 
-We have detailed instructions for [how to mount the device in a car](https://comma.ai/setup).
+### If you want to use our older legacy branches (*not recommended*)
 
-Running on PC
-------
+> [**IMPORTANT**]
+> It is recommended to [re-flash AGNOS](https://flash.comma.ai/) if you intend to downgrade from the new branches.
+> You can still restore the latest sunnylink backup made on the old branches.
 
-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.
+|    Branch    |         Installation URL         |
+|:------------:|:--------------------------------:|
+| `release-c3` | https://release-c3.sunnypilot.ai |
+| `staging-c3` | https://staging-c3.sunnypilot.ai |
+|   `dev-c3`   | https://dev-c3.sunnypilot.ai     |
 
-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.
+</details>
 
-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.
 
-A PC running openpilot can also control your vehicle if it is connected to a [a webcam](https://github.com/commaai/openpilot/tree/master/tools/webcam), a [black panda](https://comma.ai/shop/products/panda), and [a harness](https://comma.ai/shop/products/car-harness).
+## 🎆 Pull Requests
+We welcome both pull requests and issues on GitHub. Bug fixes are encouraged.
 
-Community and Contributing
-------
+Pull requests should be against the most current `master` branch.
 
-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).
+## 📊 User Data
 
-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).
+By default, sunnypilot uploads the driving data to comma servers. You can also access your data through [comma connect](https://connect.comma.ai/).
 
-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.
+sunnypilot is open source software. The user is free to disable data collection if they wish to do so.
 
-Want to get paid to work on openpilot? [comma is hiring](https://comma.ai/jobs/).
+sunnypilot logs the road-facing camera, CAN, GPS, IMU, magnetometer, thermal sensors, crashes, and operating system logs.
+The driver-facing camera and microphone are only logged if you explicitly opt-in in settings.
 
-And [follow us on Twitter](https://twitter.com/comma_ai).
+By using this software, you understand that use of this software or its related services will generate certain types of user data, which may be logged and stored at the sole discretion of comma. By accepting this agreement, you grant an irrevocable, perpetual, worldwide right to comma for the use of this data.
 
-User Data and comma Account
-------
+## Licensing
 
-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.
+sunnypilot is released under the [MIT License](LICENSE). This repository includes original work as well as significant portions of code derived from [openpilot by comma.ai](https://github.com/commaai/openpilot), which is also released under the MIT license with additional disclaimers.
 
-openpilot is open source software: the user is free to disable data collection if they wish to do so.
+The original openpilot license notice, including comma.ai’s indemnification and alpha software disclaimer, is reproduced below as required:
 
-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.
+> openpilot is released under the MIT license. Some parts of the software are released under other licenses as specified.
+>
+> Any user of this software shall indemnify and hold harmless Comma.ai, Inc. and its directors, officers, employees, agents, stockholders, affiliates, subcontractors and customers from and against all allegations, claims, actions, suits, demands, damages, liabilities, obligations, losses, settlements, judgments, costs and expenses (including without limitation attorneys’ fees and costs) which arise out of, relate to or result from any use of this software by user.
+>
+> **THIS IS ALPHA QUALITY SOFTWARE FOR RESEARCH PURPOSES ONLY. THIS IS NOT A PRODUCT.
+> YOU ARE RESPONSIBLE FOR COMPLYING WITH LOCAL LAWS AND REGULATIONS.
+> NO WARRANTY EXPRESSED OR IMPLIED.**
 
-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.
+For full license terms, please see the [`LICENSE`](LICENSE) file.
 
-Safety and Testing
-----
+## 💰 Support sunnypilot
+If you find any of the features useful, consider becoming a [sponsor on GitHub](https://github.com/sponsors/sunnyhaibin) to support future feature development and improvements.
 
-* openpilot observes ISO26262 guidelines, see [SAFETY.md](docs/SAFETY.md) for more details.
-* openpilot has software in the loop [tests](.github/workflows/selfdrive_tests.yaml) that run on every commit.
-* The code enforcing the safety model lives in panda and is written in C, see [code rigor](https://github.com/commaai/panda#code-rigor) for more details.
-* panda has software in the loop [safety tests](https://github.com/commaai/panda/tree/master/tests/safety).
-* Internally, we have a hardware in the loop Jenkins test suite that builds and unit tests the various processes.
-* panda has additional hardware in the loop [tests](https://github.com/commaai/panda/blob/master/Jenkinsfile).
-* We run the latest openpilot in a testing closet containing 10 comma devices continuously replaying routes.
 
-Directory Structure
-------
-    .
-    ├── cereal              # The messaging spec and libs used for all logs
-    ├── common              # Library like functionality we've developed here
-    ├── docs                # Documentation
-    ├── opendbc             # Files showing how to interpret data from cars
-    ├── panda               # Code used to communicate on CAN
-    ├── third_party         # External libraries
-    ├── pyextra             # Extra python packages
-    └── system              # Generic services
-        ├── camerad         # Driver to capture images from the camera sensors
-        ├── clocksd         # Broadcasts current time
-        ├── hardware        # Hardware abstraction classes
-        ├── logcatd         # systemd journal as a service
-        └── proclogd        # Logs information from /proc
-    └── selfdrive           # Code needed to drive the car
-        ├── assets          # Fonts, images, and sounds for UI
-        ├── athena          # Allows communication with the app
-        ├── boardd          # Daemon to talk to the board
-        ├── car             # Car specific code to read states and control actuators
-        ├── controls        # Planning and controls
-        ├── debug           # Tools to help you debug and do car ports
-        ├── locationd       # Precise localization and vehicle parameter estimation
-        ├── loggerd         # Logger and uploader of car data
-        ├── manager         # Deamon that starts/stops all other daemons as needed
-        ├── modeld          # Driving and monitoring model runners
-        ├── monitoring      # Daemon to determine driver attention
-        ├── navd            # Turn-by-turn navigation
-        ├── sensord         # IMU interface code
-        ├── test            # Unit tests, system tests, and a car simulator
-        └── ui              # The UI
+By becoming a sponsor, you will gain access to exclusive content, early access to new features, and the opportunity to directly influence the project's development.
 
-Licensing
-------
 
-openpilot is released under the MIT license. Some parts of the software are released under other licenses as specified.
+<h3>GitHub Sponsor</h3>
 
-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.
+<a href="https://github.com/sponsors/sunnyhaibin">
+  <img src="https://user-images.githubusercontent.com/47793918/244135584-9800acbd-69fd-4b2b-bec9-e5fa2d85c817.png" alt="Become a Sponsor" width="300" style="max-width: 100%; height: auto;">
+</a>
+<br>
 
-**THIS IS ALPHA QUALITY SOFTWARE FOR RESEARCH PURPOSES ONLY. THIS IS NOT A PRODUCT.
-YOU ARE RESPONSIBLE FOR COMPLYING WITH LOCAL LAWS AND REGULATIONS.
-NO WARRANTY EXPRESSED OR IMPLIED.**
+<h3>PayPal</h3>
 
----
+<a href="https://paypal.me/sunnyhaibin0850" target="_blank">
+<img src="https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif" alt="PayPal this" title="PayPal - The safer, easier way to pay online!" border="0" />
+</a>
+<br></br>
 
-<img src="https://d1qb2nb5cznatu.cloudfront.net/startups/i/1061157-bc7e9bf3b246ece7322e6ffe653f6af8-medium_jpg.jpg?buster=1458363130" width="75"></img> <img src="https://cdn-images-1.medium.com/max/1600/1*C87EjxGeMPrkTuVRVWVg4w.png" width="225"></img>
+Your continuous love and support are greatly appreciated! Enjoy 🥰
 
-[![openpilot tests](https://github.com/commaai/openpilot/workflows/openpilot%20tests/badge.svg?event=push)](https://github.com/commaai/openpilot/actions)
-[![Total alerts](https://img.shields.io/lgtm/alerts/g/commaai/openpilot.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/commaai/openpilot/alerts/)
-[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/commaai/openpilot.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/commaai/openpilot/context:python)
-[![Language grade: C/C++](https://img.shields.io/lgtm/grade/cpp/g/commaai/openpilot.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/commaai/openpilot/context:cpp)
-[![codecov](https://codecov.io/gh/commaai/openpilot/branch/master/graph/badge.svg)](https://codecov.io/gh/commaai/openpilot)
+<span>-</span> Jason, Founder of sunnypilot

RELEASES.md

@@ -1,3 +1,256 @@
+Version 0.10.3 (2025-12-17)
+========================
+* New driving model #36249
+  * New temporal policy architecture
+  * New on-policy training physics noise model
+* New driver monitoring model #36409
+  * Trained on a new dataset, including comma four data
+* Improved inter-process communication memory efficiency
+
+Version 0.10.2 (2025-11-19)
+========================
+* comma four support
+
+Version 0.10.1 (2025-09-08)
+========================
+* New driving model #36276
+  * World Model: removed global localization inputs
+  * World Model: 2x the number of parameters
+  * World Model: trained on 4x the number of segments
+  * VAE Compression Model: new architecture and training objective
+  * Driving Vision Model: trained on 4x the number of segments
+* New Driver Monitoring model #36198
+* Acura TLX 2021 support thanks to MVL!
+* Honda City 2023 support thanks to vanillagorillaa and drFritz!
+* Honda N-Box 2018 support thanks to miettal!
+* Honda Odyssey 2021-25 support thanks to csouers and MVL!
+* Honda Passport 2026 support thanks to vanillagorillaa and MVL!
+
+Version 0.10.0 (2025-08-05)
+========================
+* New driving model
+  * New training architecture
+     * Described in our CVPR paper: "Learning to Drive from a World Model"
+     * Longitudinal MPC replaced by E2E planning from World Model in Experimental Mode
+     * Action from lateral MPC as training objective replaced by E2E planning from World Model
+  * Low-speed lead car ground-truth fixes
+* Enable live-learned steering actuation delay
+* Opt-in audio recording for dashcam video
+* Acura MDX 2025 support thanks to vanillagorillaa and MVL!
+* Honda Accord 2023-25 support thanks to vanillagorillaa and MVL!
+* Honda CR-V 2023-25 support thanks to vanillagorillaa and MVL!
+* Honda Pilot 2023-25 support thanks to vanillagorillaa and MVL!
+
+Version 0.9.9 (2025-05-23)
+========================
+* New driving model
+  * New training architecture using parts from MLSIM
+* Steering actuation delay is now learned online
+* Ford Escape 2023-24 support thanks to incognitojam!
+* Ford Kuga 2024 support thanks to incognitojam!
+* Hyundai Nexo 2021 support thanks to sunnyhaibin!
+* Tesla Model 3 and Y support thanks to lukasloetkolben!
+* Lexus RC 2023 support thanks to nelsonjchen!
+
+Version 0.9.8 (2025-02-28)
+========================
+* New driving model
+  * Model now gates applying positive acceleration in Chill mode
+* New driver monitoring model
+  * Reduced false positives related to passengers
+* Image processing pipeline moved to the ISP
+  * More GPU time for bigger driving models
+  * Power draw reduced 0.5W, which means your device runs cooler
+* Added toggle to enable driver monitoring even when openpilot is not engaged
+* Localizer rewritten to remove GPS dependency at runtime
+* Firehose Mode for maximizing your training data uploads
+* Enable openpilot longitudinal control for Ford Q3 vehicles
+* New Toyota TSS2 longitudinal tune
+* Rivian R1S and R1T support thanks to lukasloetkolben!
+* Ford F-150, F-150 Hybrid, Mach-E, and Ranger support
+
+Version 0.9.7 (2024-06-13)
+========================
+* New driving model
+  * Inputs the past curvature for smoother and more accurate lateral control
+  * Simplified neural network architecture in the model's last layers
+  * Minor fixes to desire augmentation and weight decay
+* New driver monitoring model
+  * Improved end-to-end bit for phone detection
+* Adjust driving personality with the follow distance button
+* Support for hybrid variants of supported Ford models
+* Fingerprinting without the OBD-II port on all cars
+* Improved fuzzy fingerprinting for Ford and Volkswagen
+
+Version 0.9.6 (2024-02-27)
+========================
+* New driving model
+  * Vision model trained on more data
+  * Improved driving performance
+  * Directly outputs curvature for lateral control
+* New driver monitoring model
+  * Trained on larger dataset
+* Model path UI
+  * Shows where driving model wants to be
+  * Shows what model is seeing more clearly, but more jittery
+* AGNOS 9
+* comma body streaming and controls over WebRTC
+* Improved fuzzy fingerprinting for many makes and models
+* Alpha longitudinal support for new Toyota models
+* Chevrolet Equinox 2019-22 support thanks to JasonJShuler and nworb-cire!
+* Dodge Durango 2020-21 support
+* Hyundai Staria 2023 support thanks to sunnyhaibin!
+* Kia Niro Plug-in Hybrid 2022 support thanks to sunnyhaibin!
+* Lexus LC 2024 support thanks to nelsonjchen!
+* Toyota RAV4 2023-24 support
+* Toyota RAV4 Hybrid 2023-24 support
+
+Version 0.9.5 (2023-11-17)
+========================
+* New driving model
+  * Improved navigate on openpilot performance using navigation instructions as an additional model input
+  * Do lateral planning inside the model
+  * New vision transformer architecture
+* Cadillac Escalade ESV 2019 support thanks to twilsonco!
+* Hyundai Azera 2022 support thanks to sunnyhaibin!
+* Hyundai Azera Hybrid 2020 support thanks to chanhojung and haram-KONA!
+* Hyundai Custin 2023 support thanks to sunnyhaibin and Saber422!
+* Hyundai Ioniq 6 2023 support thanks to sunnyhaibin and alamo3!
+* Hyundai Kona Electric 2023 (Korean version) support thanks to sunnyhaibin and haram-KONA!
+* Kia K8 Hybrid (with HDA II) 2023 support thanks to sunnyhaibin!
+* Kia Optima Hybrid 2019 support
+* Kia Sorento Hybrid 2023 support thanks to sunnyhaibin!
+* Lexus GS F 2016 support thanks to snyperifle!
+* Lexus IS 2023 support thanks to L3R5!
+
+Version 0.9.4 (2023-07-27)
+========================
+* comma 3X support
+* Navigate on openpilot in Experimental mode
+  * When navigation has a destination, openpilot will input the map information into the model, which provides useful context to help the model understand the scene
+  * When navigating on openpilot, openpilot will keep left or right appropriately at forks and exits
+  * When navigating on openpilot, lane change behavior is unchanged and still activated by the driver
+  * When navigate on openpilot is active, the path on the map is green
+* UI updates
+  * Navigation settings moved to home screen and map
+  * Border color always shows engagement status. Blue means disengaged, green means engaged, and grey means engaged with human overriding
+  * Alerts are shown inside the border. Black means info, orange means warning, and red means critical alert
+* Bookmarked segments are preserved on the device's storage
+* Ford Focus 2018 support
+* Kia Carnival 2023 support thanks to sunnyhaibin!
+
+Version 0.9.3 (2023-06-29)
+========================
+* New driving model
+  * Improved height estimation and added height tracking in liveCalibration
+  * Model inputs refactor
+* New driving personality setting
+  * Three settings: aggressive, standard, and relaxed
+  * Standard is recommended and the default
+  * In aggressive mode, lead follow distance is shorter and acceleration response is quicker
+  * In relaxed mode, lead follow distance is longer
+* Improved fuzzy fingerprinting for Hyundai, Kia, and Genesis
+* Improved thermal management logic
+
+Version 0.9.2 (2023-05-22)
+========================
+* New driving model
+  * Reduced turn diving
+  * Trained on a new dataset
+* UI updates
+  * New experimental mode visualization
+  * Draw MPC path instead of model-predicted path
+* AGNOS 7
+  * Faster boot time
+  * Fixes rare no sounds bug
+  * Fixes bootsplash bug at extreme temperatures
+* Buick LaCrosse 2017-19 support thanks to koch-cf!
+* Chevrolet Trailblazer 2021-22 support thanks to TurboCE!
+* Ford Bronco Sport 2021-22 support
+* Ford Escape 2020-22 support
+* Ford Explorer 2020-22 support
+* Ford Kuga 2020-22 support
+* Ford Maverick 2022-23 support
+* Genesis GV80 2023 support thanks to JWingate80!
+* Honda HR-V 2023 support thanks to AlexandreSato and galegozi!
+* Kia Niro EV 2023 support thanks to JosselinLecocq!
+* Lexus ES 2017-18 support
+* Lincoln Aviator 2021 support
+* Škoda Fabia 2022-23 support thanks to jyoung8607!
+
+
+Version 0.9.1 (2023-02-28)
+========================
+* New driving model
+  * 30% improved height estimation resulting in better driving performance for tall cars
+* Driver monitoring: removed timer resetting on user interaction if distracted
+* UI updates
+  * Adjust alert volume using ambient noise level
+  * Driver monitoring icon shows driver's head pose
+  * German translation thanks to Vrabetz and CzokNorris!
+* Cadillac Escalade 2017 support thanks to rickygilleland!
+* Chevrolet Bolt EV 2022-23 support thanks to JasonJShuler!
+* Genesis GV60 2023 support thanks to sunnyhaibin!
+* Hyundai Tucson 2022-23 support
+* Kia K5 Hybrid 2020 support thanks to sunnyhaibin!
+* Kia Niro Hybrid 2023 support thanks to sunnyhaibin!
+* Kia Sorento 2022-23 support thanks to sunnyhaibin!
+* Kia Sorento Plug-in Hybrid 2022 support thanks to sunnyhaibin!
+* Toyota C-HR 2021 support thanks to eFiniLan!
+* Toyota C-HR Hybrid 2022 support thanks to Korben00!
+* Volkswagen Crafter and MAN TGE 2017-23 support thanks to jyoung8607!
+
+Version 0.9.0 (2022-11-21)
+========================
+* New driving model
+  * Internal feature space information content increased tenfold during training to ~700 bits, which makes the model dramatically more accurate
+  * Less reliance on previous frames makes model more reactive and snappy
+  * Trained in new reprojective simulator
+  * Trained in 36 hours from scratch, compared to one week for previous releases
+  * Training now simulates both lateral and longitudinal behavior, which allows openpilot to slow down for turns, stop at traffic lights, and more in experimental mode
+* Experimental driving mode
+  * End-to-end longitudinal control
+  * Stops for traffic lights and stop signs
+  * Slows down for turns
+  * openpilot defaults to chill mode, enable experimental mode in settings
+* Driver monitoring updates
+  * New bigger model with added end-to-end distracted trigger
+  * Reduced false positives during driver calibration
+* Self-tuning torque controller: learns parameters live for each car
+* Torque controller used on all Toyota, Lexus, Hyundai, Kia, and Genesis models
+* UI updates
+  * Matched speeds shown on car's dash
+  * Multi-language in navigation
+  * Improved update experience
+  * Border turns grey while overriding steering
+  * Bookmark events while driving; view them in comma connect
+  * New onroad visualization for experimental mode
+* tools: new and improved cabana thanks to deanlee!
+* Experimental longitudinal support for Volkswagen, CAN-FD Hyundai, and new GM models
+* Genesis GV70 2022-23 support thanks to zunichky and sunnyhaibin!
+* Hyundai Santa Cruz 2021-22 support thanks to sunnyhaibin!
+* Kia Sportage 2023 support thanks to sunnyhaibin!
+* Kia Sportage Hybrid 2023 support thanks to sunnyhaibin!
+* Kia Stinger 2022 support thanks to sunnyhaibin!
+
+Version 0.8.16 (2022-08-26)
+========================
+* New driving model
+  * Reduced turn cutting
+* Auto-detect right hand drive setting with driver monitoring model
+* Improved fan controller for comma three
+* New translations
+  * Japanese thanks to cydia2020!
+  * Brazilian Portuguese thanks to AlexandreSato!
+* Chevrolet Bolt EUV 2022-23 support thanks to JasonJShuler!
+* Chevrolet Silverado 1500 2020-21 support thanks to JasonJShuler!
+* GMC Sierra 1500 2020-21 support thanks to JasonJShuler!
+* Hyundai Ioniq 5 2022 support thanks to sunnyhaibin!
+* Hyundai Kona Electric 2022 support thanks to sunnyhaibin!
+* Hyundai Tucson Hybrid 2022 support thanks to sunnyhaibin!
+* Subaru Legacy 2020-22 support thanks to martinl!
+* Subaru Outback 2020-22 support
+
 Version 0.8.15 (2022-07-20)
 ========================
 * New driving model
@@ -55,7 +308,7 @@ Version 0.8.14 (2022-06-01)
 Version 0.8.13 (2022-02-18)
 ========================
  * Improved driver monitoring
-   * Retuned driver pose learner for relaxed driving positions
+   * Re-tuned 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
@@ -201,7 +454,7 @@ 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
+ * Re-tuned 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!
@@ -366,7 +619,7 @@ Version 0.7 (2019-12-13)
  * Improve GM longitudinal control: proper computations for 15Hz radar
  * Move GM port, Toyota with DSU removed, comma pedal in community features; toggle switch required
  * Remove upload over cellular toggle: only upload qlog and qcamera files if not on wifi
- * Refactor Panda code towards ISO26262 and SIL2 compliancy
+ * Refactor Panda code towards ISO26262 and SIL2 compliance
  * Forward stock FCW for Honda Nidec
  * Volkswagen port now standard: comma Harness intercepts stock camera
 
@@ -457,7 +710,7 @@ Version 0.5.13 (2019-05-31)
  * Reduce CPU utilization by 20% and improve stability
  * Temporarily remove mapd functionalities to improve stability
  * Add openpilot record-only mode for unsupported cars
- * Synchronize controlsd to boardd to reduce latency
+ * Synchronize controlsd to pandad to reduce latency
  * Remove panda support for Subaru giraffe
 
 Version 0.5.12 (2019-05-16)
@@ -793,7 +1046,7 @@ Version 0.2.8  (2017-02-27)
 Version 0.2.7  (2017-02-08)
 ===========================
  * Better performance and pictures at night
- * Fix ptr alignment issue in boardd
+ * Fix ptr alignment issue in pandad
  * Fix brake error light, fix crash if too cold
 
 Version 0.2.6  (2017-01-31)
@@ -825,7 +1078,7 @@ Version 0.2.2  (2017-01-10)
 Version 0.2.1  (2016-12-14)
 ===========================
  * Performance improvements, removal of more numpy
- * Fix boardd process priority
+ * Fix pandad process priority
  * Make counter timer reset on use of steering wheel
 
 Version 0.2  (2016-12-12)

SConstruct

@@ -1,426 +0,0 @@
-import os
-import subprocess
-import sys
-import sysconfig
-import platform
-import numpy as np
-
-TICI = os.path.isfile('/TICI')
-AGNOS = TICI
-
-Decider('MD5-timestamp')
-
-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')
-
-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":
-  arch = "Darwin"
-
-if arch == "aarch64" and AGNOS:
-  arch = "larch64"
-
-USE_WEBCAM = os.getenv("USE_WEBCAM") 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 == "larch64":
-  lenv["LD_LIBRARY_PATH"] += ['/data/data/com.termux/files/usr/lib']
-
-  cpppath = [
-    "#third_party/opencl/include",
-  ]
-
-  libpath = [
-    "/usr/local/lib",
-    "/usr/lib",
-    "/system/vendor/lib64",
-    f"#third_party/acados/{arch}/lib",
-  ]
-
-  libpath += [
-    "#third_party/snpe/larch64",
-    "#third_party/libyuv/larch64/lib",
-    "/usr/lib/aarch64-linux-gnu"
-  ]
-  cpppath += [
-    "#system/camerad/include",
-  ]
-  cflags = ["-DQCOM2", "-mcpu=cortex-a57"]
-  cxxflags = ["-DQCOM2", "-mcpu=cortex-a57"]
-  rpath += ["/usr/local/lib"]
-else:
-  cflags = []
-  cxxflags = []
-  cpppath = []
-
-  # 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 = [
-      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 = [
-      "#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",
-      "#common",
-      "/usr/lib",
-      "/usr/local/lib",
-    ]
-
-  rpath += [
-    Dir("#third_party/snpe/x86_64-linux-clang").abspath,
-    Dir("#cereal").abspath,
-    Dir("#common").abspath
-  ]
-
-if GetOption('asan'):
-  ccflags = ["-fsanitize=address", "-fno-omit-frame-pointer"]
-  ldflags = ["-fsanitize=address"]
-elif GetOption('ubsan'):
-  ccflags = ["-fsanitize=undefined"]
-  ldflags = ["-fsanitize=undefined"]
-else:
-  ccflags = []
-  ldflags = []
-
-# no --as-needed on mac linker
-if arch != "Darwin":
-  ldflags += ["-Wl,--as-needed", "-Wl,--no-undefined"]
-
-# Enable swaglog include in submodules
-cflags += ['-DSWAGLOG="\\"common/swaglog.h\\""']
-cxxflags += ['-DSWAGLOG="\\"common/swaglog.h\\""']
-
-env = Environment(
-  ENV=lenv,
-  CCFLAGS=[
-    "-g",
-    "-fPIC",
-    "-O2",
-    "-Wunused",
-    "-Werror",
-    "-Wshadow",
-    "-Wno-unknown-warning-option",
-    "-Wno-deprecated-register",
-    "-Wno-register",
-    "-Wno-inconsistent-missing-override",
-    "-Wno-c99-designator",
-    "-Wno-reorder-init-list",
-    "-Wno-error=unused-but-set-variable",
-  ] + cflags + ccflags,
-
-  CPPPATH=cpppath + [
-    "#",
-    "#third_party/acados/include",
-    "#third_party/acados/include/blasfeo/include",
-    "#third_party/acados/include/hpipm/include",
-    "#third_party/catch2/include",
-    "#third_party/libyuv/include",
-    "#third_party/json11",
-    "#third_party/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,
-
-  RPATH=rpath,
-
-  CFLAGS=["-std=gnu11"] + cflags,
-  CXXFLAGS=["-std=c++1z"] + cxxflags,
-  LIBPATH=libpath + [
-    "#cereal",
-    "#third_party",
-    "#opendbc/can",
-    "#selfdrive/boardd",
-    "#common",
-  ],
-  CYTHONCFILESUFFIX=".cpp",
-  COMPILATIONDB_USE_ABSPATH=True,
-  tools=["default", "cython", "compilation_db"],
-)
-
-if arch == "Darwin":
-  env['RPATHPREFIX'] = "-rpath "
-
-if GetOption('compile_db'):
-  env.CompilationDatabase('compile_commands.json')
-
-# Setup cache dir
-cache_dir = '/data/scons_cache' if AGNOS else '/tmp/scons_cache'
-CacheDir(cache_dir)
-Clean(["."], cache_dir)
-
-node_interval = 5
-node_count = 0
-def progress_function(node):
-  global node_count
-  node_count += node_interval
-  sys.stderr.write("progress: %d\n" % node_count)
-
-if os.environ.get('SCONS_PROGRESS'):
-  Progress(progress_function, interval=node_interval)
-
-SHARED = False
-
-# TODO: this can probably be removed
-def abspath(x):
-  if arch == 'aarch64':
-    pth = os.path.join("/data/pythonpath", x[0].path)
-    env.Depends(pth, x)
-    return File(pth)
-  else:
-    # rpath works elsewhere
-    return x[0].path.rsplit("/", 1)[1][:-3]
-
-# Cython build 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", "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"))
-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(['common/SConscript'])
-Import('_common', '_gpucommon')
-
-if SHARED:
-  common, gpucommon = abspath(common), abspath(gpucommon)
-else:
-  common = [_common, 'json11']
-  gpucommon = [_gpucommon]
-
-Export('common', 'gpucommon')
-
-# cereal and messaging are shared with the system
-SConscript(['cereal/SConscript'])
-if SHARED:
-  cereal = abspath([File('cereal/libcereal_shared.so')])
-  messaging = abspath([File('cereal/libmessaging_shared.so')])
-else:
-  cereal = [File('#cereal/libcereal.a')]
-  messaging = [File('#cereal/libmessaging.a')]
-  visionipc = [File('#cereal/libvisionipc.a')]
-
-Export('cereal', 'messaging', 'visionipc')
-
-# Build rednose library and ekf models
-
-rednose_deps = [
-  "#selfdrive/locationd/models/constants.py",
-  "#selfdrive/locationd/models/gnss_helpers.py",
-]
-
-rednose_config = {
-  'generated_folder': '#selfdrive/locationd/models/generated',
-  'to_build': {
-    'gnss': ('#selfdrive/locationd/models/gnss_kf.py', True, [], rednose_deps),
-    'live': ('#selfdrive/locationd/models/live_kf.py', True, ['live_kf_constants.h'], rednose_deps),
-    'car': ('#selfdrive/locationd/models/car_kf.py', True, [], rednose_deps),
-  },
-}
-
-if arch != "larch64":
-  rednose_config['to_build'].update({
-    'loc_4': ('#selfdrive/locationd/models/loc_kf.py', True, [], rednose_deps),
-    '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, [], rednose_deps),
-  })
-
-Export('rednose_config')
-SConscript(['rednose/SConscript'])
-
-# Build system services
-SConscript([
-  'system/camerad/SConscript',
-  'system/clocksd/SConscript',
-  'system/proclogd/SConscript',
-])
-if arch != "Darwin":
-  SConscript(['system/logcatd/SConscript'])
-
-# Build openpilot
-
-SConscript(['cereal/SConscript'])
-SConscript(['panda/board/SConscript'])
-SConscript(['opendbc/can/SConscript'])
-
-SConscript(['third_party/SConscript'])
-
-SConscript(['common/kalman/SConscript'])
-SConscript(['common/transformations/SConscript'])
-
-SConscript(['selfdrive/modeld/SConscript'])
-
-SConscript(['selfdrive/controls/lib/cluster/SConscript'])
-SConscript(['selfdrive/controls/lib/lateral_mpc_lib/SConscript'])
-SConscript(['selfdrive/controls/lib/longitudinal_mpc_lib/SConscript'])
-
-SConscript(['selfdrive/boardd/SConscript'])
-
-SConscript(['selfdrive/loggerd/SConscript'])
-
-SConscript(['selfdrive/locationd/SConscript'])
-SConscript(['selfdrive/sensord/SConscript'])
-SConscript(['selfdrive/ui/SConscript'])
-
-SConscript(['tools/replay/SConscript'])
-
-if GetOption('test'):
-  SConscript('panda/tests/safety/SConscript')
-
-external_sconscript = GetOption('external_sconscript')
-if external_sconscript:
-  SConscript([external_sconscript])

SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Suspected vulnerabilities can be reported to both `adeeb@comma.ai` and `security@comma.ai`.

cereal/.gitignore

@@ -1,21 +0,0 @@
-gen
-node_modules
-package-lock.json
-*.tmp
-*.pyc
-__pycache__
-.*.swp
-.*.swo
-*.os
-*.o
-*.a
-
-test_runner
-
-libmessaging.*
-libmessaging_shared.*
-services.h
-.sconsign.dblite
-libcereal_shared.*
-.mypy_cache/
-catch2/

cereal/README.md

@@ -0,0 +1,95 @@
+# What is cereal?
+
+cereal is the messaging system for openpilot. It uses [msgq](https://github.com/commaai/msgq) as a pub/sub backend, and [Cap'n proto](https://capnproto.org/capnp-tool.html) for serialization of the structs.
+
+
+## Messaging Spec
+
+You'll find the message types in [log.capnp](log.capnp). It uses [Cap'n proto](https://capnproto.org/capnp-tool.html) and defines one struct called `Event`.
+
+All `Events` have a `logMonoTime` and a `valid`. Then a big union defines the packet type.
+
+### Best Practices
+
+- **All fields must describe quantities in SI units**, unless otherwise specified in the field name.
+- In the context of the message they are in, field names should be completely unambiguous.
+- All values should be easy to plot and be human-readable with minimal parsing.
+
+### Maintaining backwards-compatibility
+
+When making changes to the messaging spec you want to maintain backwards-compatibility, such that old logs can
+be parsed with a new version of cereal. Adding structs and adding members to structs is generally safe, most other
+things are not. Read more details [here](https://capnproto.org/language.html).
+
+### Custom forks
+
+Forks of [openpilot](https://github.com/commaai/openpilot) might want to add things to the messaging
+spec, however this could conflict with future changes made in mainline cereal/openpilot. Rebasing against mainline openpilot
+then means breaking backwards-compatibility with all old logs of your fork. So we added reserved events in
+[custom.capnp](custom.capnp) that we will leave empty in mainline cereal/openpilot. **If you only modify those, you can ensure your
+fork will remain backwards-compatible with all versions of mainline openpilot and your fork.**
+
+An example of compatible changes:
+```diff
+diff --git a/cereal/custom.capnp b/cereal/custom.capnp
+index 3348e859e..3365c7b98 100644
+--- a/cereal/custom.capnp
++++ b/cereal/custom.capnp
+@@ -10,7 +10,11 @@ $Cxx.namespace("cereal");
+ # DO rename the structs
+ # DON'T change the identifier (e.g. @0x81c2f05a394cf4af)
+
+-struct CustomReserved0 @0x81c2f05a394cf4af {
++struct SteeringInfo @0x81c2f05a394cf4af {
++  active @0 :Bool;
++  steeringAngleDeg @1 :Float32;
++  steeringRateDeg @2 :Float32;
++  steeringAccelDeg @3 :Float32;
+ }
+
+ struct CustomReserved1 @0xaedffd8f31e7b55d {
+diff --git a/cereal/log.capnp b/cereal/log.capnp
+index 1209f3fd9..b189f58b6 100644
+--- a/cereal/log.capnp
++++ b/cereal/log.capnp
+@@ -2558,14 +2558,14 @@ struct Event {
+
+     # DO change the name of the field
+     # DON'T change anything after the "@"
+-    customReservedRawData0 @124 :Data;
++    rawCanData @124 :Data;
+     customReservedRawData1 @125 :Data;
+     customReservedRawData2 @126 :Data;
+
+     # DO change the name of the field and struct
+     # DON'T change the ID (e.g. @107)
+     # DON'T change which struct it points to
+-    customReserved0 @107 :Custom.CustomReserved0;
++    steeringInfo @107 :Custom.SteeringInfo;
+     customReserved1 @108 :Custom.CustomReserved1;
+     customReserved2 @109 :Custom.CustomReserved2;
+     customReserved3 @110 :Custom.CustomReserved3;
+```
+
+---
+
+Example
+---
+```python
+import cereal.messaging as messaging
+
+# in subscriber
+sm = messaging.SubMaster(['sensorEvents'])
+while 1:
+  sm.update()
+  print(sm['sensorEvents'])
+
+```
+
+```python
+# in publisher
+pm = messaging.PubMaster(['sensorEvents'])
+dat = messaging.new_message('sensorEvents', size=1)
+dat.sensorEvents[0] = {"gyro": {"v": [0.1, -0.1, 0.1]}}
+pm.send('sensorEvents', dat)
+```

cereal/SConscript

@@ -1,74 +0,0 @@
-Import('env', 'envCython', 'arch', 'common')
-
-import shutil
-
-cereal_dir = Dir('.')
-gen_dir = Dir('gen')
-messaging_dir = Dir('messaging')
-
-# Build cereal
-
-schema_files = ['log.capnp', 'car.capnp', 'legacy.capnp']
-env.Command(["gen/c/include/c++.capnp.h"], [], "mkdir -p " + gen_dir.path + "/c/include && touch $TARGETS")
-env.Command([f'gen/cpp/{s}.c++' for s in schema_files] + [f'gen/cpp/{s}.h' for s in schema_files],
-            schema_files,
-            f"capnpc --src-prefix={cereal_dir.path} $SOURCES -o c++:{gen_dir.path}/cpp/")
-
-# TODO: remove non shared cereal and messaging
-cereal_objects = env.SharedObject([f'gen/cpp/{s}.c++' for s in schema_files])
-
-env.Library('cereal', cereal_objects)
-env.SharedLibrary('cereal_shared', cereal_objects)
-
-# Build messaging
-
-services_h = env.Command(['services.h'], ['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)
-
-env.Program('messaging/bridge', ['messaging/bridge.cc'], LIBS=[messaging_lib, 'zmq', common])
-Depends('messaging/bridge.cc', services_h)
-
-envCython.Program('messaging/messaging_pyx.so', 'messaging/messaging_pyx.pyx', LIBS=envCython["LIBS"]+[messaging_lib, "zmq", common])
-
-
-# Build Vision IPC
-vipc_sources = [
-  'visionipc/ipc.cc',
-  'visionipc/visionipc_server.cc',
-  'visionipc/visionipc_client.cc',
-  'visionipc/visionbuf.cc',
-]
-
-if arch == "larch64":
-  vipc_sources += ['visionipc/visionbuf_ion.cc']
-else:
-  vipc_sources += ['visionipc/visionbuf_cl.cc']
-
-vipc_objects = env.SharedObject(vipc_sources)
-vipc = env.Library('visionipc', vipc_objects)
-
-
-vipc_frameworks = []
-vipc_libs = envCython["LIBS"] + [vipc, messaging_lib, common, "zmq"]
-if arch == "Darwin":
-  vipc_frameworks.append('OpenCL')
-else:
-  vipc_libs.append('OpenCL')
-envCython.Program('visionipc/visionipc_pyx.so', 'visionipc/visionipc_pyx.pyx',
-                  LIBS=vipc_libs, FRAMEWORKS=vipc_frameworks)
-
-if GetOption('test'):
-  env.Program('messaging/test_runner', ['messaging/test_runner.cc', 'messaging/msgq_tests.cc'], LIBS=[messaging_lib, common])
-
-  env.Program('visionipc/test_runner', ['visionipc/test_runner.cc', 'visionipc/visionipc_tests.cc'],
-              LIBS=['pthread'] + vipc_libs, FRAMEWORKS=vipc_frameworks)

cereal/__init__.py

@@ -1,9 +1,11 @@
-# pylint: skip-file
 import os
 import capnp
+from importlib.resources import as_file, files
 
-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"))
+with as_file(files("cereal")) as fspath:
+  CEREAL_PATH = fspath.as_posix()
+  log = capnp.load(os.path.join(CEREAL_PATH, "log.capnp"))
+  car = capnp.load(os.path.join(CEREAL_PATH, "car.capnp"))
+  custom = capnp.load(os.path.join(CEREAL_PATH, "custom.capnp"))

cereal/car.capnp

@@ -1,651 +0,0 @@
-using Cxx = import "./include/c++.capnp";
-$Cxx.namespace("cereal");
-
-@0x8e2af1e708af8b8d;
-
-# ******* events causing controls state machine transition *******
-
-struct CarEvent @0x9b1657f34caf3ad3 {
-  name @0 :EventName;
-
-  # event types
-  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
-  override @9 :Bool;
-
-  enum EventName @0xbaa8c5d505f727de {
-    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;  # exits active state
-    pedalPressedPreEnable @73;  # added during pre-enable state for either pedal
-    gasPressedOverride @108;  # added when user is pressing gas with no disengage on gas
-    cruiseDisabled @14;
-    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;
-    joystickDebug @34;
-    steerTempUnavailableSilent @35;
-    resumeRequired @36;
-    preDriverDistracted @37;
-    promptDriverDistracted @38;
-    driverDistracted @39;
-    preDriverUnresponsive @43;
-    promptDriverUnresponsive @44;
-    driverUnresponsive @45;
-    belowSteerSpeed @46;
-    lowBattery @48;
-    vehicleModelInvalid @50;
-    accFaulted @51;
-    sensorDataInvalid @52;
-    commIssue @53;
-    commIssueAvgFreq @109;
-    tooDistracted @54;
-    posenetInvalid @55;
-    soundsUnavailable @56;
-    preLaneChangeLeft @57;
-    preLaneChangeRight @58;
-    laneChange @59;
-    lowMemory @63;
-    stockAeb @64;
-    ldw @65;
-    carUnrecognized @66;
-    invalidLkasSetting @69;
-    speedTooHigh @70;
-    laneChangeBlocked @71;
-    relayMalfunction @72;
-    stockFcw @74;
-    startup @75;
-    startupNoCar @76;
-    startupNoControl @77;
-    startupMaster @78;
-    startupNoFw @104;
-    fcw @79;
-    steerSaturated @80;
-    belowEngageSpeed @84;
-    noGps @85;
-    wrongCruiseMode @87;
-    modeldLagging @89;
-    deviceFalling @90;
-    fanMalfunction @91;
-    cameraMalfunction @92;
-    cameraFrameRate @110;
-    gpsMalfunction @94;
-    processNotRunning @95;
-    dashcamMode @96;
-    controlsInitializing @98;
-    usbError @99;
-    roadCameraError @100;
-    driverCameraError @101;
-    wideRoadCameraError @102;
-    localizerMalfunction @103;
-    highCpuUsage @105;
-    cruiseMismatch @106;
-    lkasDisabled @107;
-    canBusMissing @111;
-    controlsdLagging @112;
-
-    radarCanErrorDEPRECATED @15;
-    communityFeatureDisallowedDEPRECATED @62;
-    radarCommIssueDEPRECATED @67;
-    driverMonitorLowAccDEPRECATED @68;
-    gasUnavailableDEPRECATED @3;
-    dataNeededDEPRECATED @16;
-    modelCommIssueDEPRECATED @27;
-    ipasOverrideDEPRECATED @33;
-    geofenceDEPRECATED @40;
-    driverMonitorOnDEPRECATED @41;
-    driverMonitorOffDEPRECATED @42;
-    calibrationProgressDEPRECATED @47;
-    invalidGiraffeHondaDEPRECATED @49;
-    invalidGiraffeToyotaDEPRECATED @60;
-    internetConnectivityNeededDEPRECATED @61;
-    whitePandaUnsupportedDEPRECATED @81;
-    commIssueWarningDEPRECATED @83;
-    focusRecoverActiveDEPRECATED @86;
-    neosUpdateRequiredDEPRECATED @88;
-    modelLagWarningDEPRECATED @93;
-    startupOneplusDEPRECATED @82;
-    startupFuzzyFingerprintDEPRECATED @97;
-  }
-}
-
-# ******* main car state @ 100hz *******
-# all speeds in m/s
-
-struct CarState {
-  events @13 :List(CarEvent);
-
-  # CAN health
-  canValid @26 :Bool;       # invalid counter/checksums
-  canTimeout @40 :Bool;     # CAN bus dropped out
-
-  # 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 pedal only
-  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
-  parkingBrake @39 :Bool;
-  brakeHoldActive @38 :Bool;
-
-  # steering wheel
-  steeringAngleDeg @7 :Float32;
-  steeringAngleOffsetDeg @37 :Float32; # Offset betweens sensors in case there multiple
-  steeringRateDeg @15 :Float32;
-  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
-  steerFaultTemporary @35 :Bool;   # temporary EPS fault
-  steerFaultPermanent @36 :Bool;   # permanent EPS fault
-  stockAeb @30 :Bool;
-  stockFcw @31 :Bool;
-  espDisabled @32 :Bool;
-  accFaulted @42 :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;
-
-  # 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
-
-  fuelGauge @41 :Float32; # battery or fuel tank level from 0.0 to 1.0
-  charging @43 :Bool;
-
-  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;
-    }
-  }
-
-  errorsDEPRECATED @0 :List(CarEvent.EventName);
-  brakeLightsDEPRECATED @19 :Bool;
-}
-
-# ******* 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;
-  latActive @11: Bool;
-  longActive @12: Bool;
-
-  # Actuator commands as computed by controlsd
-  actuators @6 :Actuators;
-
-  # Any car specific rate limits or quirks applied by
-  # the CarController are reflected in actuatorsOutput
-  # and matches what is sent to the car
-  actuatorsOutput @10 :Actuators;
-
-  orientationNED @13 :List(Float32);
-  angularVelocity @14 :List(Float32);
-
-  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;
-    steeringAngleDeg @3: Float32;
-
-    speed @6: Float32; # m/s
-    accel @4: Float32; # m/s^2
-    longControlState @5: LongControlState;
-
-    enum LongControlState @0xe40f3a917d908282{
-      off @0;
-      pid @1;
-      stopping @2;
-
-      startingDEPRECATED @3;
-    }
-
-  }
-
-  struct CruiseControl {
-    cancel @0: Bool;
-    resume @1: Bool;
-    speedOverrideDEPRECATED @2: Float32;
-    accelOverrideDEPRECATED @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 {
-      none @0;
-
-      engage @1;
-      disengage @2;
-      refuse @3;
-
-      warningSoft @4;
-      warningImmediate @5;
-
-      prompt @6;
-      promptRepeat @7;
-      promptDistracted @8;
-    }
-  }
-
-  gasDEPRECATED @1 :Float32;
-  brakeDEPRECATED @2 :Float32;
-  steeringTorqueDEPRECATED @3 :Float32;
-  activeDEPRECATED @7 :Bool;
-  rollDEPRECATED @8 :Float32;
-  pitchDEPRECATED @9 :Float32;
-}
-
-# ****** car param ******
-
-struct CarParams {
-  carName @0 :Text;
-  carFingerprint @1 :Text;
-  fuzzyFingerprint @55 :Bool;
-
-  notCar @66 :Bool;  # flag for non-car robotics platforms
-
-  enableGasInterceptor @2 :Bool;
-  pcmCruise @3 :Bool;        # is openpilot's state tied to the PCM's cruise state?
-  enableDsu @5 :Bool;        # driving support unit
-  enableApgs @6 :Bool;       # advanced parking guidance system
-  enableBsm @56 :Bool;       # blind spot monitoring
-  flags @64 :UInt32;         # flags for car specific quirks
-
-  minEnableSpeed @7 :Float32;
-  minSteerSpeed @8 :Float32;
-  maxSteeringAngleDeg @54 :Float32;
-  safetyConfigs @62 :List(SafetyConfig);
-  alternativeExperience @65 :Int16;      # panda flag for features like no disengage on gas
-  maxLateralAccel @68 :Float32;
-
-  steerMaxBPDEPRECATED @11 :List(Float32);
-  steerMaxVDEPRECATED @12 :List(Float32);
-  gasMaxBPDEPRECATED @13 :List(Float32);
-  gasMaxVDEPRECATED @14 :List(Float32);
-  brakeMaxBPDEPRECATED @15 :List(Float32);
-  brakeMaxVDEPRECATED @16 :List(Float32);
-
-  # things about the car in the manual
-  mass @17 :Float32;            # [kg] curb weight: all fluids no cargo
-  wheelbase @18 :Float32;       # [m] distance from rear axle to front axle
-  centerToFront @19 :Float32;   # [m] distance from center of mass to front axle
-  steerRatio @20 :Float32;      # [] ratio of steering wheel angle to front wheel angle
-  steerRatioRear @21 :Float32;  # [] ratio of steering wheel angle to rear wheel angle (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;
-    torque @67 :LateralTorqueTuning;
-  }
-
-  steerLimitAlert @28 :Bool;
-  steerLimitTimer @47 :Float32;  # time before steerLimitAlert is issued
-
-  vEgoStopping @29 :Float32; # Speed at which the car goes into stopping state
-  vEgoStarting @59 :Float32; # Speed at which the car goes into starting 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
-  stopAccel @60 :Float32; # Required acceleraton to keep vehicle stationary
-  steerControlType @34 :SteerControlType;
-  radarOffCan @35 :Bool; # True when radar objects aren't visible on CAN
-  stoppingDecelRate @52 :Float32; # m/s^2/s while trying to stop
-
-  steerActuatorDelay @36 :Float32; # Steering wheel actuator delay in seconds
-  longitudinalActuatorDelayLowerBound @61 :Float32; # Gas/Brake actuator delay in seconds, lower bound
-  longitudinalActuatorDelayUpperBound @58 :Float32; # Gas/Brake actuator delay in seconds, upper bound
-  openpilotLongitudinalControl @37 :Bool; # is openpilot doing the longitudinal control?
-  carVin @38 :Text; # VIN number queried during fingerprinting
-  dashcamOnly @41: Bool;
-  transmissionType @43 :TransmissionType;
-  carFw @44 :List(CarFw);
-
-  radarTimeStep @45: Float32 = 0.05;  # time delta between radar updates, 20Hz is very standard
-  fingerprintSource @49: FingerprintSource;
-  networkLocation @50 :NetworkLocation;  # Where Panda/C2 is integrated into the car's CAN network
-
-  wheelSpeedFactor @63 :Float32; # Multiplier on wheels speeds to computer actual speeds
-
-  struct SafetyConfig {
-    safetyModel @0 :SafetyModel;
-    safetyParam @3 :UInt16;
-    safetyParamDEPRECATED @1 :Int16;
-    safetyParam2DEPRECATED @2 :UInt32;
-  }
-
-  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 LateralTorqueTuning {
-    useSteeringAngle @0 :Bool;
-    kp @1 :Float32;
-    ki @2 :Float32;
-    friction @3 :Float32;
-    kf @4 :Float32;
-    steeringAngleDeadzoneDeg @5 :Float32;
-  }
-
-  struct LongitudinalPIDTuning {
-    kpBP @0 :List(Float32);
-    kpV @1 :List(Float32);
-    kiBP @2 :List(Float32);
-    kiV @3 :List(Float32);
-    kf @6 :Float32;
-    deadzoneBP @4 :List(Float32);
-    deadzoneV @5 :List(Float32);
-  }
-
-  struct LateralINDITuning {
-    outerLoopGainBP @4 :List(Float32);
-    outerLoopGainV @5 :List(Float32);
-    innerLoopGainBP @6 :List(Float32);
-    innerLoopGainV @7 :List(Float32);
-    timeConstantBP @8 :List(Float32);
-    timeConstantV @9 :List(Float32);
-    actuatorEffectivenessBP @10 :List(Float32);
-    actuatorEffectivenessV @11 :List(Float32);
-
-    outerLoopGainDEPRECATED @0 :Float32;
-    innerLoopGainDEPRECATED @1 :Float32;
-    timeConstantDEPRECATED @2 :Float32;
-    actuatorEffectivenessDEPRECATED @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
-    hondaBosch @20;
-    volkswagenPq @21;
-    subaruLegacy @22;  # pre-Global platform
-    hyundaiLegacy @23;
-    hyundaiCommunity @24;
-    stellantis @25;
-    faw @26;
-    body @27;
-    hyundaiHDA2 @28;
-  }
-
-  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
-    cvt @4;
-  }
-
-  struct CarFw {
-    ecu @0 :Ecu;
-    fwVersion @1 :Data;
-    address @2 :UInt32;
-    subAddress @3 :UInt8;
-    responseAddress @4 :UInt32;
-    request @5 :List(Data);
-    brand @6 :Text;
-  }
-
-  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;
-
-    debug @17;
-  }
-
-  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
-  }
-
-  enableCameraDEPRECATED @4 :Bool;
-  steerRateCostDEPRECATED @33 :Float32;
-  isPandaBlackDEPRECATED @39 :Bool;
-  hasStockCameraDEPRECATED @57 :Bool;
-  safetyParamDEPRECATED @10 :Int16;
-  safetyModelDEPRECATED @9 :SafetyModel;
-  safetyModelPassiveDEPRECATED @42 :SafetyModel = silent;
-  minSpeedCanDEPRECATED @51 :Float32;
-  startAccelDEPRECATED @32 :Float32;
-  communityFeatureDEPRECATED @46: Bool;
-  startingAccelRateDEPRECATED @53 :Float32;
-}

cereal/car.capnp

@@ -0,0 +1 @@
+../opendbc_repo/opendbc/car/car.capnp

cereal/custom.capnp

@@ -0,0 +1,485 @@
+using Cxx = import "./include/c++.capnp";
+$Cxx.namespace("cereal");
+
+@0xb526ba661d550a59;
+
+# custom.capnp: a home for empty structs reserved for custom forks
+# These structs are guaranteed to remain reserved and empty in mainline
+# cereal, so use these if you want custom events in your fork.
+
+# DO rename the structs
+# DON'T change the identifier (e.g. @0x81c2f05a394cf4af)
+
+struct ModularAssistiveDrivingSystem {
+  state @0 :ModularAssistiveDrivingSystemState;
+  enabled @1 :Bool;
+  active @2 :Bool;
+  available @3 :Bool;
+
+  enum ModularAssistiveDrivingSystemState {
+    disabled @0;
+    paused @1;
+    enabled @2;
+    softDisabling @3;
+    overriding @4;
+  }
+}
+
+struct IntelligentCruiseButtonManagement {
+  state @0 :IntelligentCruiseButtonManagementState;
+  sendButton @1 :SendButtonState;
+  vTarget @2 :Float32;
+
+  enum IntelligentCruiseButtonManagementState {
+    inactive @0;      # No button press or default state
+    preActive @1;     # Pre-active state before transitioning to increasing or decreasing
+    increasing @2;    # Increasing speed
+    decreasing @3;    # Decreasing speed
+    holding @4;       # Holding steady speed
+  }
+
+  enum SendButtonState {
+    none @0;
+    increase @1;
+    decrease @2;
+  }
+}
+
+# Same struct as Log.RadarState.LeadData
+struct LeadData {
+  dRel @0 :Float32;
+  yRel @1 :Float32;
+  vRel @2 :Float32;
+  aRel @3 :Float32;
+  vLead @4 :Float32;
+  dPath @6 :Float32;
+  vLat @7 :Float32;
+  vLeadK @8 :Float32;
+  aLeadK @9 :Float32;
+  fcw @10 :Bool;
+  status @11 :Bool;
+  aLeadTau @12 :Float32;
+  modelProb @13 :Float32;
+  radar @14 :Bool;
+  radarTrackId @15 :Int32 = -1;
+
+  aLeadDEPRECATED @5 :Float32;
+}
+
+struct SelfdriveStateSP @0x81c2f05a394cf4af {
+  mads @0 :ModularAssistiveDrivingSystem;
+  intelligentCruiseButtonManagement @1 :IntelligentCruiseButtonManagement;
+
+  enum AudibleAlert {
+    none @0;
+
+    engage @1;
+    disengage @2;
+    refuse @3;
+
+    warningSoft @4;
+    warningImmediate @5;
+
+    prompt @6;
+    promptRepeat @7;
+    promptDistracted @8;
+
+    # unused, these are reserved for upstream events so we don't collide
+    reserved9 @9;
+    reserved10 @10;
+    reserved11 @11;
+    reserved12 @12;
+    reserved13 @13;
+    reserved14 @14;
+    reserved15 @15;
+    reserved16 @16;
+    reserved17 @17;
+    reserved18 @18;
+    reserved19 @19;
+    reserved20 @20;
+    reserved21 @21;
+    reserved22 @22;
+    reserved23 @23;
+    reserved24 @24;
+    reserved25 @25;
+    reserved26 @26;
+    reserved27 @27;
+    reserved28 @28;
+    reserved29 @29;
+    reserved30 @30;
+
+    promptSingleLow @31;
+    promptSingleHigh @32;
+  }
+}
+
+struct ModelManagerSP @0xaedffd8f31e7b55d {
+  activeBundle @0 :ModelBundle;
+  selectedBundle @1 :ModelBundle;
+  availableBundles @2 :List(ModelBundle);
+
+  struct DownloadUri {
+    uri @0 :Text;
+    sha256 @1 :Text;
+  }
+
+  enum DownloadStatus {
+    notDownloading @0;
+    downloading @1;
+    downloaded @2;
+    cached @3;
+    failed @4;
+  }
+
+  struct DownloadProgress {
+    status @0 :DownloadStatus;
+    progress @1 :Float32;
+    eta @2 :UInt32;
+  }
+
+  struct Artifact {
+    fileName @0 :Text;
+    downloadUri @1 :DownloadUri;
+    downloadProgress @2 :DownloadProgress;
+  }
+
+  struct Model {
+    type @0 :Type;
+    artifact @1 :Artifact;  # Main artifact
+    metadata @2 :Artifact;  # Metadata artifact
+
+    enum Type {
+      supercombo @0;
+      navigation @1;
+      vision @2;
+      policy @3;
+    }
+  }
+
+  enum Runner {
+    snpe @0;
+    tinygrad @1;
+    stock @2;
+  }
+
+  struct Override {
+    key @0 :Text;
+    value @1 :Text;
+  }
+
+  struct ModelBundle {
+    index @0 :UInt32;
+    internalName @1 :Text;
+    displayName @2 :Text;
+    models @3 :List(Model);
+    status @4 :DownloadStatus;
+    generation @5 :UInt32;
+    environment @6 :Text;
+    runner @7 :Runner;
+    is20hz @8 :Bool;
+    ref @9 :Text;
+    minimumSelectorVersion @10 :UInt32;
+    overrides @11 :List(Override);
+  }
+}
+
+struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
+  dec @0 :DynamicExperimentalControl;
+  longitudinalPlanSource @1 :LongitudinalPlanSource;
+  smartCruiseControl @2 :SmartCruiseControl;
+  speedLimit @3 :SpeedLimit;
+  vTarget @4 :Float32;
+  aTarget @5 :Float32;
+  events @6 :List(OnroadEventSP.Event);
+  e2eAlerts @7 :E2eAlerts;
+
+  struct DynamicExperimentalControl {
+    state @0 :DynamicExperimentalControlState;
+    enabled @1 :Bool;
+    active @2 :Bool;
+
+    enum DynamicExperimentalControlState {
+      acc @0;
+      blended @1;
+    }
+  }
+
+  struct SmartCruiseControl {
+    vision @0 :Vision;
+    map @1 :Map;
+
+    struct Vision {
+      state @0 :VisionState;
+      vTarget @1 :Float32;
+      aTarget @2 :Float32;
+      currentLateralAccel @3 :Float32;
+      maxPredictedLateralAccel @4 :Float32;
+      enabled @5 :Bool;
+      active @6 :Bool;
+    }
+
+    struct Map {
+      state @0 :MapState;
+      vTarget @1 :Float32;
+      aTarget @2 :Float32;
+      enabled @3 :Bool;
+      active @4 :Bool;
+    }
+
+    enum VisionState {
+      disabled @0; # System disabled or inactive.
+      enabled @1; # No predicted substantial turn on vision range.
+      entering @2; # A substantial turn is predicted ahead, adapting speed to turn comfort levels.
+      turning @3; # Actively turning. Managing acceleration to provide a roll on turn feeling.
+      leaving @4; # Road ahead straightens. Start to allow positive acceleration.
+      overriding @5; # System overriding with manual control.
+    }
+
+    enum MapState {
+      disabled @0; # System disabled or inactive.
+      enabled @1; # No predicted substantial turn on map range.
+      turning @2; # Actively turning. Managing acceleration to provide a roll on turn feeling.
+      overriding @3; # System overriding with manual control.
+    }
+  }
+
+  struct SpeedLimit {
+    resolver @0 :Resolver;
+    assist @1 :Assist;
+
+    struct Resolver {
+      speedLimit @0 :Float32;
+      distToSpeedLimit @1 :Float32;
+      source @2 :Source;
+      speedLimitOffset @3 :Float32;
+      speedLimitLast @4 :Float32;
+      speedLimitFinal @5 :Float32;
+      speedLimitFinalLast @6 :Float32;
+      speedLimitValid @7 :Bool;
+      speedLimitLastValid @8 :Bool;
+    }
+
+    struct Assist {
+      state @0 :AssistState;
+      enabled @1 :Bool;
+      active @2 :Bool;
+      vTarget @3 :Float32;
+      aTarget @4 :Float32;
+    }
+
+    enum Source {
+      none @0;
+      car @1;
+      map @2;
+    }
+
+    enum AssistState {
+      disabled @0;
+      inactive @1; # No speed limit set or not enabled by parameter.
+      preActive @2;
+      pending @3; # Awaiting new speed limit.
+      adapting @4; # Reducing speed to match new speed limit.
+      active @5; # Cruising at speed limit.
+    }
+  }
+
+  enum LongitudinalPlanSource {
+    cruise @0;
+    sccVision @1;
+    sccMap @2;
+    speedLimitAssist @3;
+  }
+
+  struct E2eAlerts {
+    greenLightAlert @0 :Bool;
+    leadDepartAlert @1 :Bool;
+  }
+}
+
+struct OnroadEventSP @0xda96579883444c35 {
+  events @0 :List(Event);
+
+  struct Event {
+    name @0 :EventName;
+
+    # event types
+    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
+    overrideLateral @10 :Bool;
+    overrideLongitudinal @9 :Bool;
+  }
+
+  enum EventName {
+    lkasEnable @0;
+    lkasDisable @1;
+    manualSteeringRequired @2;
+    manualLongitudinalRequired @3;
+    silentLkasEnable @4;
+    silentLkasDisable @5;
+    silentBrakeHold @6;
+    silentWrongGear @7;
+    silentReverseGear @8;
+    silentDoorOpen @9;
+    silentSeatbeltNotLatched @10;
+    silentParkBrake @11;
+    controlsMismatchLateral @12;
+    hyundaiRadarTracksConfirmed @13;
+    experimentalModeSwitched @14;
+    wrongCarModeAlertOnly @15;
+    pedalPressedAlertOnly @16;
+    laneTurnLeft @17;
+    laneTurnRight @18;
+    speedLimitPreActive @19;
+    speedLimitActive @20;
+    speedLimitChanged @21;
+    speedLimitPending @22;
+    e2eChime @23;
+  }
+}
+
+struct CarParamsSP @0x80ae746ee2596b11 {
+  flags @0 :UInt32;        # flags for car specific quirks in sunnypilot
+  safetyParam @1 : Int16;  # flags for sunnypilot's custom safety flags
+  pcmCruiseSpeed @3 :Bool;
+  intelligentCruiseButtonManagementAvailable @4 :Bool;
+  enableGasInterceptor @5 :Bool;
+
+  neuralNetworkLateralControl @2 :NeuralNetworkLateralControl;
+
+  struct NeuralNetworkLateralControl {
+    model @0 :Model;
+    fuzzyFingerprint @1 :Bool;
+
+    struct Model {
+      path @0 :Text;
+      name @1 :Text;
+    }
+  }
+}
+
+struct CarControlSP @0xa5cd762cd951a455 {
+  mads @0 :ModularAssistiveDrivingSystem;
+  params @1 :List(Param);
+  leadOne @2 :LeadData;
+  leadTwo @3 :LeadData;
+  intelligentCruiseButtonManagement @4 :IntelligentCruiseButtonManagement;
+
+  struct Param {
+    key @0 :Text;
+    type @2 :ParamType;
+    value @3 :Data;
+
+    valueDEPRECATED @1 :Text; # The data type change may cause issues with backwards compatibility.
+  }
+
+  enum ParamType {
+    string @0;
+    bool @1;
+    int @2;
+    float @3;
+    time @4;
+    json @5;
+    bytes @6;
+  }
+}
+
+struct BackupManagerSP @0xf98d843bfd7004a3 {
+  backupStatus @0 :Status;
+  restoreStatus @1 :Status;
+  backupProgress @2 :Float32;
+  restoreProgress @3 :Float32;
+  lastError @4 :Text;
+  currentBackup @5 :BackupInfo;
+  backupHistory @6 :List(BackupInfo);
+
+  enum Status {
+    idle @0;
+    inProgress @1;
+    completed @2;
+    failed @3;
+  }
+
+  struct Version {
+    major @0 :UInt16;
+    minor @1 :UInt16;
+    patch @2 :UInt16;
+    build @3 :UInt16;
+    branch @4 :Text;
+  }
+
+  struct MetadataEntry {
+    key @0 :Text;
+    value @1 :Text;
+    tags @2 :List(Text);
+  }
+
+  struct BackupInfo {
+    deviceId @0 :Text;
+    version @1 :UInt32;
+    config @2 :Text;
+    isEncrypted @3 :Bool;
+    createdAt @4 :Text;  # ISO timestamp
+    updatedAt @5 :Text;  # ISO timestamp
+    sunnypilotVersion @6 :Version;
+    backupMetadata @7 :List(MetadataEntry);
+  }
+}
+
+struct CarStateSP @0xb86e6369214c01c8 {
+  speedLimit @0 :Float32;
+}
+
+struct LiveMapDataSP @0xf416ec09499d9d19 {
+  speedLimitValid @0 :Bool;
+  speedLimit @1 :Float32;
+  speedLimitAheadValid @2 :Bool;
+  speedLimitAhead @3 :Float32;
+  speedLimitAheadDistance @4 :Float32;
+  roadName @5 :Text;
+}
+
+struct ModelDataV2SP @0xa1680744031fdb2d {
+  laneTurnDirection @0 :TurnDirection;
+
+  enum TurnDirection {
+    none @0;
+    turnLeft @1;
+    turnRight @2;
+  }
+}
+
+struct CustomReserved10 @0xcb9fd56c7057593a {
+}
+
+struct CustomReserved11 @0xc2243c65e0340384 {
+}
+
+struct CustomReserved12 @0x9ccdc8676701b412 {
+}
+
+struct CustomReserved13 @0xcd96dafb67a082d0 {
+}
+
+struct CustomReserved14 @0xb057204d7deadf3f {
+}
+
+struct CustomReserved15 @0xbd443b539493bc68 {
+}
+
+struct CustomReserved16 @0xfc6241ed8877b611 {
+}
+
+struct CustomReserved17 @0xa30662f84033036c {
+}
+
+struct CustomReserved18 @0xc86a3d38d13eb3ef {
+}
+
+struct CustomReserved19 @0xa4f1eb3323f5f582 {
+}

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,39 +1,53 @@
-# 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
+# must be built with scons
+from msgq.ipc_pyx import Context, Poller, SubSocket, PubSocket, SocketEventHandle, toggle_fake_events, \
+                                set_fake_prefix, get_fake_prefix, delete_fake_prefix, wait_for_one_event
+from msgq.ipc_pyx import MultiplePublishersError, IpcError
+from msgq import fake_event_handle, drain_sock_raw
+import msgq
+
 import os
 import capnp
+import time
 
-from typing import Optional, List, Union
-from collections import deque
+from typing import Optional, List, Union, Dict
 
 from cereal import log
-from cereal.services import service_list
-
-assert MultiplePublishersError
-assert MessagingError
+from cereal.services import SERVICE_LIST
+from openpilot.common.util import MovingAverage
 
 NO_TRAVERSAL_LIMIT = 2**64-1
-AVG_FREQ_HISTORY = 100
-SIMULATION = "SIMULATION" in os.environ
 
-# 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 pub_sock(endpoint: str) -> PubSocket:
+  service = SERVICE_LIST.get(endpoint)
+  segment_size = service.queue_size if service else 0
+  return msgq.pub_sock(endpoint, segment_size)
 
-def log_from_bytes(dat: bytes) -> capnp.lib.capnp._DynamicStructReader:
-  return log.Event.from_bytes(dat, traversal_limit_in_words=NO_TRAVERSAL_LIMIT)
 
-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
+def sub_sock(endpoint: str, poller: Optional[Poller] = None, addr: str = "127.0.0.1",
+             conflate: bool = False, timeout: Optional[int] = None) -> SubSocket:
+  service = SERVICE_LIST.get(endpoint)
+  segment_size = service.queue_size if service else 0
+  return msgq.sub_sock(endpoint, poller=poller, addr=addr, conflate=conflate,
+                       timeout=timeout, segment_size=segment_size)
+
+
+def reset_context():
+  msgq.context = Context()
+
+
+def log_from_bytes(dat: bytes, struct: capnp.lib.capnp._StructModule = log.Event) -> capnp.lib.capnp._DynamicStructReader:
+  with struct.from_bytes(dat, traversal_limit_in_words=NO_TRAVERSAL_LIMIT) as msg:
+    return msg
+
+
+def new_message(service: Optional[str], size: Optional[int] = None, **kwargs) -> capnp.lib.capnp._DynamicStructBuilder:
+  args = {
+    'valid': False,
+    'logMonoTime': int(time.monotonic() * 1e9),
+    **kwargs
+  }
+  dat = log.Event.new_message(**args)
   if service is not None:
     if size is None:
       dat.init(service)
@@ -41,56 +55,11 @@ def new_message(service: Optional[str] = None, size: Optional[int] = None) -> ca
       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_from_bytes(dat)
-    ret.append(dat)
-
-  return ret
+  msgs = drain_sock_raw(sock, wait_for_one=wait_for_one)
+  return [log_from_bytes(m) for m in msgs]
 
 
 # TODO: print when we drop packets?
@@ -100,32 +69,35 @@ def recv_sock(sock: SubSocket, wait: bool = False) -> Optional[capnp.lib.capnp._
 
   while 1:
     if wait and dat is None:
-      rcv = sock.receive()
+      recv = sock.receive()
     else:
-      rcv = sock.receive(non_blocking=True)
+      recv = sock.receive(non_blocking=True)
 
-    if rcv is None:  # Timeout hit
+    if recv is None:  # Timeout hit
       break
 
-    dat = rcv
+    dat = recv
 
   if dat is not None:
     dat = log_from_bytes(dat)
 
   return dat
 
+
 def recv_one(sock: SubSocket) -> Optional[capnp.lib.capnp._DynamicStructReader]:
   dat = sock.receive()
   if dat is not None:
     dat = log_from_bytes(dat)
   return dat
 
+
 def recv_one_or_none(sock: SubSocket) -> Optional[capnp.lib.capnp._DynamicStructReader]:
   dat = sock.receive(non_blocking=True)
   if dat is not None:
     dat = log_from_bytes(dat)
   return dat
 
+
 def recv_one_retry(sock: SubSocket) -> capnp.lib.capnp._DynamicStructReader:
   """Keep receiving until we get a message"""
   while True:
@@ -133,49 +105,105 @@ def recv_one_retry(sock: SubSocket) -> capnp.lib.capnp._DynamicStructReader:
     if dat is not None:
       return log_from_bytes(dat)
 
-class SubMaster:
-  def __init__(self, services: List[str], poll: Optional[List[str]] = None,
-               ignore_alive: Optional[List[str]] = None, ignore_avg_freq: 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.freq_ok = {s: False for s in services}
-    self.recv_dts = {s: deque([0.0] * AVG_FREQ_HISTORY, maxlen=AVG_FREQ_HISTORY) for s in services}
-    self.sock = {}
-    self.freq = {}
-    self.data = {}
-    self.valid = {}
-    self.logMonoTime = {}
 
+class FrequencyTracker:
+  def __init__(self, service_freq: float, update_freq: float, is_poll: bool):
+    freq = max(min(service_freq, update_freq), 1.)
+    if is_poll:
+      min_freq = max_freq = freq
+    else:
+      max_freq = min(freq, update_freq)
+      if service_freq >= 2 * update_freq:
+        min_freq = update_freq
+      elif update_freq >= 2* service_freq:
+        min_freq = freq
+      else:
+        min_freq = min(freq, freq / 2.)
+
+    self.min_freq = min_freq * 0.8
+    self.max_freq = max_freq * 1.2
+    self.avg_dt = MovingAverage(int(10 * freq))
+    self.recent_avg_dt = MovingAverage(int(freq))
+    self.prev_time = 0.0
+
+  def record_recv_time(self, cur_time: float) -> None:
+    # TODO: Handle case where cur_time is less than prev_time
+    if self.prev_time > 1e-5:
+      dt = cur_time - self.prev_time
+
+      self.avg_dt.add_value(dt)
+      self.recent_avg_dt.add_value(dt)
+
+    self.prev_time = cur_time
+
+  @property
+  def valid(self) -> bool:
+    if self.avg_dt.count == 0:
+      return False
+
+    avg_freq = 1.0 / self.avg_dt.get_average()
+    if self.min_freq <= avg_freq <= self.max_freq:
+      return True
+
+    avg_freq_recent = 1.0 / self.recent_avg_dt.get_average()
+    return self.min_freq <= avg_freq_recent <= self.max_freq
+
+
+class SubMaster:
+  def __init__(self, services: List[str], poll: Optional[str] = None,
+               ignore_alive: Optional[List[str]] = None, ignore_avg_freq: Optional[List[str]] = None,
+               ignore_valid: Optional[List[str]] = None, addr: str = "127.0.0.1", frequency: Optional[float] = None):
+    self.frame = -1
+    self.services = services
+    self.seen = {s: False for s in services}
+    self.updated = {s: False for s in services}
+    self.recv_time = {s: 0. for s in services}
+    self.recv_frame = {s: 0 for s in services}
+    self.sock = {}
+    self.data = {}
+    self.logMonoTime = {s: 0 for s in services}
+
+    # zero-frequency / on-demand services are always alive and presumed valid; all others must pass checks
+    on_demand = {s: SERVICE_LIST[s].frequency <= 1e-5 for s in services}
+    self.static_freq_services = set(s for s in services if not on_demand[s])
+    self.alive = {s: on_demand[s] for s in services}
+    self.freq_ok = {s: on_demand[s] for s in services}
+    self.valid = {s: on_demand[s] for s in services}
+
+    self.freq_tracker: Dict[str, FrequencyTracker] = {}
     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]
+    polled_services = set([poll, ] if poll is not None else services)
+    self.non_polled_services = set(services) - polled_services
 
     self.ignore_average_freq = [] if ignore_avg_freq is None else ignore_avg_freq
     self.ignore_alive = [] if ignore_alive is None else ignore_alive
+    self.ignore_valid = [] if ignore_valid is None else ignore_valid
+
+    self.simulation = bool(int(os.getenv("SIMULATION", "0")))
+
+    # if freq and poll aren't specified, assume the max to be conservative
+    assert frequency is None or poll is None, "Do not specify 'frequency' - frequency of the polled service will be used."
+    self.update_freq = frequency or max([SERVICE_LIST[s].frequency for s in polled_services])
 
     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
+      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)
 
       try:
         data = new_message(s)
-      except capnp.lib.capnp.KjException:  # pylint: disable=c-extension-no-member
+      except capnp.lib.capnp.KjException:
         data = new_message(s, 0) # lists
 
-      self.data[s] = getattr(data, s)
-      self.logMonoTime[s] = 0
-      self.valid[s] = data.valid
+      self.data[s] = getattr(data.as_reader(), s)
+      self.freq_tracker[s] = FrequencyTracker(SERVICE_LIST[s].frequency, self.update_freq, s == poll)
 
   def __getitem__(self, s: str) -> capnp.lib.capnp._DynamicStructReader:
     return self.data[s]
 
-  def update(self, timeout: int = 1000) -> None:
+  def _check_avg_freq(self, s: str) -> bool:
+    return SERVICE_LIST[s].frequency > 0.99 and (s not in self.ignore_average_freq) and (s not in self.ignore_alive)
+
+  def update(self, timeout: int = 100) -> None:
     msgs = []
     for sock in self.poller.poll(timeout):
       msgs.append(recv_one_or_none(sock))
@@ -183,69 +211,43 @@ class SubMaster:
     # 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)
+    self.update_msgs(time.monotonic(), 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)
+    self.updated = dict.fromkeys(self.services, False)
     for msg in msgs:
       if msg is None:
         continue
 
       s = msg.which()
+      self.seen[s] = True
       self.updated[s] = True
 
-      if self.rcv_time[s] > 1e-5 and self.freq[s] > 1e-5 and (s not in self.non_polled_services) \
-        and (s not in self.ignore_average_freq):
-        self.recv_dts[s].append(cur_time - self.rcv_time[s])
-
-      self.rcv_time[s] = cur_time
-      self.rcv_frame[s] = self.frame
+      self.freq_tracker[s].record_recv_time(cur_time)
+      self.recv_time[s] = cur_time
+      self.recv_frame[s] = self.frame
       self.data[s] = getattr(msg, s)
       self.logMonoTime[s] = msg.logMonoTime
       self.valid[s] = msg.valid
 
-      if SIMULATION:
-        self.freq_ok[s] = True
-        self.alive[s] = True
+    for s in self.static_freq_services:
+      # alive if delay is within 10x the expected frequency; checks relaxed in simulator
+      self.alive[s] = (cur_time - self.recv_time[s]) < (10. / SERVICE_LIST[s].frequency) or (self.seen[s] and self.simulation)
+      self.freq_ok[s] = self.freq_tracker[s].valid or self.simulation
 
-    if not SIMULATION:
-      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])
+  def all_alive(self, service_list: Optional[List[str]] = None) -> bool:
+    return all(self.alive[s] for s in (service_list or self.services) if s not in self.ignore_alive)
 
-          # TODO: check if update frequency is high enough to not drop messages
-          # freq_ok if average frequency is higher than 90% of expected frequency
-          avg_dt = sum(self.recv_dts[s]) / AVG_FREQ_HISTORY
-          expected_dt = 1 / (self.freq[s] * 0.90)
-          self.freq_ok[s] = (avg_dt < expected_dt)
-        else:
-          self.freq_ok[s] = True
-          self.alive[s] = True
+  def all_freq_ok(self, service_list: Optional[List[str]] = None) -> bool:
+    return all(self.freq_ok[s] for s in (service_list or self.services) if self._check_avg_freq(s))
 
-  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: Optional[List[str]] = None) -> bool:
+    return all(self.valid[s] for s in (service_list or self.services) if s not in self.ignore_valid)
 
-  def all_freq_ok(self, service_list=None) -> bool:
-    if service_list is None:  # check all
-      service_list = self.alive.keys()
-    return all(self.freq_ok[s] for s in service_list if s not in self.ignore_alive)
+  def all_checks(self, service_list: Optional[List[str]] = None) -> bool:
+    return self.all_alive(service_list) and self.all_freq_ok(service_list) and self.all_valid(service_list)
 
-  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_checks(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_freq_ok(service_list=service_list) \
-           and self.all_valid(service_list=service_list)
 
 class PubMaster:
   def __init__(self, services: List[str]):
@@ -258,5 +260,12 @@ class PubMaster:
       dat = dat.to_bytes()
     self.sock[s].send(dat)
 
+  def wait_for_readers_to_update(self, s: str, timeout: int, dt: float = 0.05) -> bool:
+    for _ in range(int(timeout*(1./dt))):
+      if self.sock[s].all_readers_updated():
+        return True
+      time.sleep(dt)
+    return False
+
   def all_readers_updated(self, s: str) -> bool:
     return self.sock[s].all_readers_updated()  # type: ignore

cereal/messaging/bridge.cc

@@ -1,32 +1,17 @@
-#include <algorithm>
 #include <cassert>
-#include <csignal>
-#include <iostream>
-#include <map>
-#include <string>
 
-typedef void (*sighandler_t)(int sig);
+#include "cereal/messaging/msgq_to_zmq.h"
+#include "cereal/services.h"
+#include "common/util.h"
 
-#include "impl_msgq.h"
-#include "impl_zmq.h"
-#include "services.h"
+ExitHandler do_exit;
 
-std::atomic<bool> do_exit = false;
-static void set_do_exit(int sig) {
-  do_exit = true;
-}
-
-void sigpipe_handler(int sig) {
-  assert(sig == SIGPIPE);
-  std::cout << "SIGPIPE received" << std::endl;
-}
-
-static std::vector<std::string> get_services(std::string whitelist_str, bool zmq_to_msgq) {
+static std::vector<std::string> get_services(const std::string &whitelist_str, bool zmq_to_msgq) {
   std::vector<std::string> service_list;
   for (const auto& it : services) {
-    std::string name = it.name;
+    std::string name = it.second.name;
     bool in_whitelist = whitelist_str.find(name) != std::string::npos;
-    if (name == "plusFrame" || name == "uiLayoutState" || (zmq_to_msgq && !in_whitelist)) {
+    if (zmq_to_msgq && !in_whitelist) {
       continue;
     }
     service_list.push_back(name);
@@ -34,41 +19,22 @@ static std::vector<std::string> get_services(std::string whitelist_str, bool zmq
   return service_list;
 }
 
-int main(int argc, char** argv) {
-  signal(SIGPIPE, (sighandler_t)sigpipe_handler);
-  signal(SIGINT, (sighandler_t)set_do_exit);
-  signal(SIGTERM, (sighandler_t)set_do_exit);
+void msgq_to_zmq(const std::vector<std::string> &endpoints, const std::string &ip) {
+  MsgqToZmq bridge;
+  bridge.run(endpoints, ip);
+}
 
-  bool zmq_to_msgq = argc > 2;
-  std::string ip = zmq_to_msgq ? argv[1] : "127.0.0.1";
-  std::string whitelist_str = zmq_to_msgq ? std::string(argv[2]) : "";
+void zmq_to_msgq(const std::vector<std::string> &endpoints, const std::string &ip) {
+  auto poller = std::make_unique<ZMQPoller>();
+  auto pub_context = std::make_unique<MSGQContext>();
+  auto sub_context = std::make_unique<ZMQContext>();
+  std::map<SubSocket *, PubSocket *> sub2pub;
 
-  Poller *poller;
-  Context *pub_context;
-  Context *sub_context;
-  if (zmq_to_msgq) {  // republishes zmq debugging messages as msgq
-    poller = new ZMQPoller();
-    pub_context = new MSGQContext();
-    sub_context = new ZMQContext();
-  } else {
-    poller = new MSGQPoller();
-    pub_context = new ZMQContext();
-    sub_context = new MSGQContext();
-  }
-
-  std::map<SubSocket*, PubSocket*> sub2pub;
-  for (auto endpoint: get_services(whitelist_str, zmq_to_msgq)) {
-    PubSocket * pub_sock;
-    SubSocket * sub_sock;
-    if (zmq_to_msgq) {
-      pub_sock = new MSGQPubSocket();
-      sub_sock = new ZMQSubSocket();
-    } else {
-      pub_sock = new ZMQPubSocket();
-      sub_sock = new MSGQSubSocket();
-    }
-    pub_sock->connect(pub_context, endpoint);
-    sub_sock->connect(sub_context, endpoint, ip, false);
+  for (auto endpoint : endpoints) {
+    auto pub_sock = new MSGQPubSocket();
+    auto sub_sock = new ZMQSubSocket();
+    pub_sock->connect(pub_context.get(), endpoint);
+    sub_sock->connect(sub_context.get(), endpoint, ip, false);
 
     poller->registerSocket(sub_sock);
     sub2pub[sub_sock] = pub_sock;
@@ -76,17 +42,30 @@ int main(int argc, char** argv) {
 
   while (!do_exit) {
     for (auto sub_sock : poller->poll(100)) {
-      Message * msg = sub_sock->receive();
-      if (msg == NULL) continue;
-      int ret;
-      do {
-        ret = sub2pub[sub_sock]->sendMessage(msg);
-      } while (ret == -1 && errno == EINTR && !do_exit);
-      assert(ret >= 0 || do_exit);
-      delete msg;
-
-      if (do_exit) break;
+      std::unique_ptr<Message> msg(sub_sock->receive(true));
+      if (msg) {
+        sub2pub[sub_sock]->sendMessage(msg.get());
+      }
     }
   }
+
+  // Clean up allocated sockets
+  for (auto &[sub_sock, pub_sock] : sub2pub) {
+    delete sub_sock;
+    delete pub_sock;
+  }
+}
+
+int main(int argc, char **argv) {
+  bool is_zmq_to_msgq = argc > 2;
+  std::string ip = is_zmq_to_msgq ? argv[1] : "127.0.0.1";
+  std::string whitelist_str = is_zmq_to_msgq ? std::string(argv[2]) : "";
+  std::vector<std::string> endpoints = get_services(whitelist_str, is_zmq_to_msgq);
+
+  if (is_zmq_to_msgq) {
+    zmq_to_msgq(endpoints, ip);
+  } else {
+    msgq_to_zmq(endpoints, ip);
+  }
   return 0;
 }

cereal/messaging/impl_msgq.cc

@@ -1,230 +0,0 @@
-#include <cassert>
-#include <cstring>
-#include <iostream>
-#include <cstdlib>
-#include <csignal>
-#include <cerrno>
-
-#include "services.h"
-#include "impl_msgq.h"
-
-
-volatile sig_atomic_t msgq_do_exit = 0;
-
-void sig_handler(int signal) {
-  assert(signal == SIGINT || signal == SIGTERM);
-  msgq_do_exit = 1;
-}
-
-static bool service_exists(std::string path){
-  for (const auto& it : services) {
-    if (it.name == path) {
-      return true;
-    }
-  }
-  return false;
-}
-
-static size_t get_size(std::string endpoint){
-  size_t sz = DEFAULT_SEGMENT_SIZE;
-
-  if (endpoint == "roadCameraState" || endpoint == "driverCameraState" || endpoint == "wideRoadCameraState"){
-    sz *= 10;
-  }
-
-  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, bool check_endpoint){
-  assert(context);
-  assert(address == "127.0.0.1");
-
-  if (check_endpoint && !service_exists(std::string(endpoint))){
-    std::cout << "Warning, " << std::string(endpoint) << " is not in service list." << std::endl;
-  }
-
-  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, bool check_endpoint){
-  assert(context);
-
-  if (check_endpoint && !service_exists(std::string(endpoint))){
-    std::cout << "Warning, " << std::string(endpoint) << " is not in service list." << std::endl;
-  }
-
-  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);
-}
-
-bool MSGQPubSocket::all_readers_updated() {
-  return msgq_all_readers_updated(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_zmq.cc

@@ -1,168 +0,0 @@
-#include <cassert>
-#include <cstring>
-#include <iostream>
-#include <cstdlib>
-#include <cerrno>
-
-#include <zmq.h>
-
-#include "services.h"
-#include "impl_zmq.h"
-
-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, bool check_endpoint){
-  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 + ":";
-  if (check_endpoint){
-    full_endpoint += std::to_string(get_port(endpoint));
-  } else {
-    full_endpoint += 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, bool check_endpoint){
-  sock = zmq_socket(context->getRawContext(), ZMQ_PUB);
-  if (sock == NULL){
-    return -1;
-  }
-
-  full_endpoint = "tcp://*:";
-  if (check_endpoint){
-    full_endpoint += std::to_string(get_port(endpoint));
-  } else {
-    full_endpoint += 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);
-}
-
-bool ZMQPubSocket::all_readers_updated() {
-  assert(false); // TODO not implemented
-  return false;
-}
-
-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/messaging.cc

@@ -1,113 +0,0 @@
-#include <cassert>
-#include <iostream>
-
-#include "messaging.h"
-#include "impl_zmq.h"
-#include "impl_msgq.h"
-
-#ifdef __APPLE__
-const bool MUST_USE_ZMQ = true;
-#else
-const bool MUST_USE_ZMQ = false;
-#endif
-
-bool messaging_use_zmq(){
-  if (std::getenv("ZMQ") || MUST_USE_ZMQ) {
-    if (std::getenv("OPENPILOT_PREFIX")) {
-      std::cerr << "OPENPILOT_PREFIX not supported with ZMQ backend\n";
-      assert(false);
-    }
-    return true;
-  }
-  return false;
-}
-
-Context * Context::create(){
-  Context * c;
-  if (messaging_use_zmq()){
-    c = new ZMQContext();
-  } else {
-    c = new MSGQContext();
-  }
-  return c;
-}
-
-SubSocket * SubSocket::create(){
-  SubSocket * s;
-  if (messaging_use_zmq()){
-    s = new ZMQSubSocket();
-  } else {
-    s = new MSGQSubSocket();
-  }
-  return s;
-}
-
-SubSocket * SubSocket::create(Context * context, std::string endpoint, std::string address, bool conflate, bool check_endpoint){
-  SubSocket *s = SubSocket::create();
-  int r = s->connect(context, endpoint, address, conflate, check_endpoint);
-
-  if (r == 0) {
-    return s;
-  } else {
-    delete s;
-    return NULL;
-  }
-}
-
-PubSocket * PubSocket::create(){
-  PubSocket * s;
-  if (messaging_use_zmq()){
-    s = new ZMQPubSocket();
-  } else {
-    s = new MSGQPubSocket();
-  }
-  return s;
-}
-
-PubSocket * PubSocket::create(Context * context, std::string endpoint, bool check_endpoint){
-  PubSocket *s = PubSocket::create();
-  int r = s->connect(context, endpoint, check_endpoint);
-
-  if (r == 0) {
-    return s;
-  } else {
-    delete s;
-    return NULL;
-  }
-}
-
-Poller * Poller::create(){
-  Poller * p;
-  if (messaging_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.h

@@ -1,68 +1,16 @@
 #pragma once
+
 #include <cstddef>
 #include <map>
 #include <string>
 #include <vector>
+#include <utility>
+
 #include <capnp/serialize.h>
-#include "../gen/cpp/log.capnp.h"
 
-#ifdef __APPLE__
-#define CLOCK_BOOTTIME CLOCK_MONOTONIC
-#endif
-
-#define MSG_MULTIPLE_PUBLISHERS 100
-
-bool messaging_use_zmq();
-
-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, bool check_endpoint=true) = 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, std::string address="127.0.0.1", bool conflate=false, bool check_endpoint=true);
-  virtual ~SubSocket(){};
-};
-
-class PubSocket {
-public:
-  virtual int connect(Context *context, std::string endpoint, bool check_endpoint=true) = 0;
-  virtual int sendMessage(Message *message) = 0;
-  virtual int send(char *data, size_t size) = 0;
-  virtual bool all_readers_updated() = 0;
-  static PubSocket * create();
-  static PubSocket * create(Context * context, std::string endpoint, bool check_endpoint=true);
-  static PubSocket * create(Context * context, std::string endpoint, int port, bool check_endpoint=true);
-  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(){};
-};
+#include "cereal/gen/cpp/log.capnp.h"
+#include "common/timing.h"
+#include "msgq/ipc.h"
 
 class SubMaster {
 public:
@@ -98,10 +46,7 @@ public:
 
   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.setLogMonoTime(nanos_since_boot());
     event.setValid(valid);
     return event;
   }
@@ -111,6 +56,18 @@ public:
     return heapArray_.asBytes();
   }
 
+  size_t getSerializedSize() {
+    return capnp::computeSerializedSizeInWords(*this) * sizeof(capnp::word);
+  }
+
+  int serializeToBuffer(unsigned char *buffer, size_t buffer_size) {
+    size_t serialized_size = getSerializedSize();
+    if (serialized_size > buffer_size) { return -1; }
+    kj::ArrayOutputStream out(kj::ArrayPtr<capnp::byte>(buffer, buffer_size));
+    capnp::writeMessage(out, *this);
+    return serialized_size;
+  }
+
 private:
   kj::Array<capnp::word> heapArray_;
 };

cereal/messaging/messaging.pxd

@@ -1,40 +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.h":
-  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)
-    bool all_readers_updated()
-
-  cdef cppclass Poller:
-    @staticmethod
-    Poller * create()
-    void registerSocket(SubSocket *)
-    vector[SubSocket*] poll(int) nogil

cereal/messaging/messaging_pyx.pyx

@@ -1,154 +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
-
-  def all_readers_updated(self):
-    return self.socket.all_readers_updated()

cereal/messaging/msgq_to_zmq.cc

@@ -0,0 +1,144 @@
+#include "cereal/messaging/msgq_to_zmq.h"
+
+#include <cassert>
+
+#include "common/util.h"
+
+extern ExitHandler do_exit;
+
+// Max messages to process per socket per poll
+constexpr int MAX_MESSAGES_PER_SOCKET = 50;
+
+static std::string recv_zmq_msg(void *sock) {
+  zmq_msg_t msg;
+  zmq_msg_init(&msg);
+  std::string ret;
+  if (zmq_msg_recv(&msg, sock, 0) > 0) {
+    ret.assign((char *)zmq_msg_data(&msg), zmq_msg_size(&msg));
+  }
+  zmq_msg_close(&msg);
+  return ret;
+}
+
+void MsgqToZmq::run(const std::vector<std::string> &endpoints, const std::string &ip) {
+  zmq_context = std::make_unique<ZMQContext>();
+  msgq_context = std::make_unique<MSGQContext>();
+
+  // Create ZMQPubSockets for each endpoint
+  for (const auto &endpoint : endpoints) {
+    auto &socket_pair = socket_pairs.emplace_back();
+    socket_pair.endpoint = endpoint;
+    socket_pair.pub_sock = std::make_unique<ZMQPubSocket>();
+    int ret = socket_pair.pub_sock->connect(zmq_context.get(), endpoint);
+    if (ret != 0) {
+      printf("Failed to create ZMQ publisher for [%s]: %s\n", endpoint.c_str(), zmq_strerror(zmq_errno()));
+      return;
+    }
+  }
+
+  // Start ZMQ monitoring thread to monitor socket events
+  std::thread thread(&MsgqToZmq::zmqMonitorThread, this);
+
+  // Main loop for processing messages
+  while (!do_exit) {
+    {
+      std::unique_lock lk(mutex);
+      cv.wait(lk, [this]() { return do_exit || !sub2pub.empty(); });
+      if (do_exit) break;
+
+      for (auto sub_sock : msgq_poller->poll(100)) {
+        // Process messages for each socket
+        ZMQPubSocket *pub_sock = sub2pub.at(sub_sock);
+        for (int i = 0; i < MAX_MESSAGES_PER_SOCKET; ++i) {
+          auto msg = std::unique_ptr<Message>(sub_sock->receive(true));
+          if (!msg) break;
+
+          while (pub_sock->sendMessage(msg.get()) == -1) {
+            if (errno != EINTR) break;
+          }
+        }
+      }
+    }
+    util::sleep_for(1);  // Give zmqMonitorThread a chance to acquire the mutex
+  }
+
+  thread.join();
+}
+
+void MsgqToZmq::zmqMonitorThread() {
+  std::vector<zmq_pollitem_t> pollitems;
+
+  // Set up ZMQ monitor for each pub socket
+  for (int i = 0; i < socket_pairs.size(); ++i) {
+    std::string addr = "inproc://op-bridge-monitor-" + std::to_string(i);
+    zmq_socket_monitor(socket_pairs[i].pub_sock->sock, addr.c_str(), ZMQ_EVENT_ACCEPTED | ZMQ_EVENT_DISCONNECTED);
+
+    void *monitor_socket = zmq_socket(zmq_context->getRawContext(), ZMQ_PAIR);
+    zmq_connect(monitor_socket, addr.c_str());
+    pollitems.emplace_back(zmq_pollitem_t{.socket = monitor_socket, .events = ZMQ_POLLIN});
+  }
+
+  while (!do_exit) {
+    int ret = zmq_poll(pollitems.data(), pollitems.size(), 1000);
+    if (ret < 0) {
+      if (errno == EINTR) {
+        // Due to frequent EINTR signals from msgq, introduce a brief delay (200 ms)
+        // to reduce CPU usage during retry attempts.
+        util::sleep_for(200);
+      }
+      continue;
+    }
+
+    for (int i = 0; i < pollitems.size(); ++i) {
+      if (pollitems[i].revents & ZMQ_POLLIN) {
+        // First frame in message contains event number and value
+        std::string frame = recv_zmq_msg(pollitems[i].socket);
+        if (frame.empty()) continue;
+
+        uint16_t event_type = *(uint16_t *)(frame.data());
+
+        // Second frame in message contains event address
+        frame = recv_zmq_msg(pollitems[i].socket);
+        if (frame.empty()) continue;
+
+        std::unique_lock lk(mutex);
+        auto &pair = socket_pairs[i];
+        if (event_type & ZMQ_EVENT_ACCEPTED) {
+          printf("socket [%s] connected\n", pair.endpoint.c_str());
+          if (++pair.connected_clients == 1) {
+            // Create new MSGQ subscriber socket and map to ZMQ publisher
+            pair.sub_sock = std::make_unique<MSGQSubSocket>();
+            pair.sub_sock->connect(msgq_context.get(), pair.endpoint, "127.0.0.1");
+            sub2pub[pair.sub_sock.get()] = pair.pub_sock.get();
+            registerSockets();
+          }
+        } else if (event_type & ZMQ_EVENT_DISCONNECTED) {
+          printf("socket [%s] disconnected\n", pair.endpoint.c_str());
+          if (pair.connected_clients == 0 || --pair.connected_clients == 0) {
+            // Remove MSGQ subscriber socket from mapping and reset it
+            sub2pub.erase(pair.sub_sock.get());
+            pair.sub_sock.reset(nullptr);
+            registerSockets();
+          }
+        }
+        cv.notify_one();
+      }
+    }
+  }
+
+  // Clean up monitor sockets
+  for (int i = 0; i < pollitems.size(); ++i) {
+    zmq_socket_monitor(socket_pairs[i].pub_sock->sock, nullptr, 0);
+    zmq_close(pollitems[i].socket);
+  }
+  cv.notify_one();
+}
+
+void MsgqToZmq::registerSockets() {
+  msgq_poller = std::make_unique<MSGQPoller>();
+  for (const auto &socket_pair : socket_pairs) {
+    if (socket_pair.sub_sock) {
+      msgq_poller->registerSocket(socket_pair.sub_sock.get());
+    }
+  }
+}

cereal/messaging/msgq_to_zmq.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <condition_variable>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#define private public
+#include "msgq/impl_msgq.h"
+#include "msgq/impl_zmq.h"
+
+class MsgqToZmq {
+public:
+  MsgqToZmq() {}
+  void run(const std::vector<std::string> &endpoints, const std::string &ip);
+
+protected:
+  void registerSockets();
+  void zmqMonitorThread();
+
+  struct SocketPair {
+    std::string endpoint;
+    std::unique_ptr<ZMQPubSocket> pub_sock;
+    std::unique_ptr<MSGQSubSocket> sub_sock;
+    int connected_clients = 0;
+  };
+
+  std::unique_ptr<MSGQContext> msgq_context;
+  std::unique_ptr<ZMQContext> zmq_context;
+  std::mutex mutex;
+  std::condition_variable cv;
+  std::unique_ptr<MSGQPoller> msgq_poller;
+  std::map<SubSocket *, ZMQPubSocket *> sub2pub;
+  std::vector<SocketPair> socket_pairs;
+};

cereal/messaging/socketmaster.cc

@@ -1,27 +1,13 @@
-#include <time.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <string>
 #include <mutex>
 
-#include "services.h"
-#include "messaging.h"
+#include "cereal/services.h"
+#include "cereal/messaging/messaging.h"
 
 const bool SIMULATION = (getenv("SIMULATION") != nullptr) && (std::string(getenv("SIMULATION")) == "1");
 
-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::vector<const char *> &list, const char *value) {
   for (auto &v : list) {
     if (strcmp(value, v) == 0) return true;
@@ -31,7 +17,7 @@ static inline bool inList(const std::vector<const char *> &list, const char *val
 
 class MessageContext {
 public:
-  MessageContext() : ctx_(nullptr) {};
+  MessageContext() : ctx_(nullptr) {}
   ~MessageContext() { delete ctx_; }
   inline Context *context() {
     std::call_once(init_flag, [=]() { ctx_ = Context::create(); });
@@ -47,8 +33,8 @@ MessageContext message_context;
 struct SubMaster::SubMessage {
   std::string name;
   SubSocket *socket = nullptr;
-  int freq = 0;
-  bool updated = false, alive = false, valid = true, ignore_alive;
+  float freq = 0.0f;
+  bool updated = false, alive = false, valid = false, ignore_alive;
   uint64_t rcv_time = 0, rcv_frame = 0;
   void *allocated_msg_reader = nullptr;
   bool is_polled = false;
@@ -61,16 +47,17 @@ SubMaster::SubMaster(const std::vector<const char *> &service_list, const std::v
                      const char *address, const std::vector<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(message_context.context(), name, address ? address : "127.0.0.1", true);
+    assert(services.count(std::string(name)) > 0);
+
+    service serv = services.at(std::string(name));
+    SubSocket *socket = SubSocket::create(message_context.context(), name, address ? address : "127.0.0.1", true, true, serv.queue_size);
     assert(socket != 0);
     bool is_polled = inList(poll, name) || poll.empty();
     if (is_polled) poller_->registerSocket(socket);
     SubMessage *m = new SubMessage{
       .name = name,
       .socket = socket,
-      .freq = serv->frequency,
+      .freq = serv.frequency,
       .ignore_alive = inList(ignore_alive, name),
       .allocated_msg_reader = malloc(sizeof(capnp::FlatArrayMessageReader)),
       .is_polled = is_polled};
@@ -116,7 +103,7 @@ void SubMaster::update(int timeout) {
 void SubMaster::update_msgs(uint64_t current_time, const std::vector<std::pair<std::string, cereal::Event::Reader>> &messages){
   if (++frame == UINT64_MAX) frame = 1;
 
-  for(auto &kv : messages) {
+  for (auto &kv : messages) {
     auto m_find = services_.find(kv.first);
     if (m_find == services_.end()){
       continue;
@@ -184,7 +171,7 @@ uint64_t SubMaster::rcv_time(const char *name) const {
 
 cereal::Event::Reader &SubMaster::operator[](const char *name) const {
   return services_.at(name)->event;
-};
+}
 
 SubMaster::~SubMaster() {
   delete poller_;
@@ -199,8 +186,9 @@ SubMaster::~SubMaster() {
 
 PubMaster::PubMaster(const std::vector<const char *> &service_list) {
   for (auto name : service_list) {
-    assert(get_service(name) != nullptr);
-    PubSocket *socket = PubSocket::create(message_context.context(), name);
+    assert(services.count(name) > 0);
+    service serv = services.at(std::string(name));
+    PubSocket *socket = PubSocket::create(message_context.context(), name, true, serv.queue_size);
     assert(socket);
     sockets_[name] = socket;
   }

cereal/messaging/tests/test_messaging.py

@@ -0,0 +1,185 @@
+import os
+import capnp
+import multiprocessing
+import numbers
+import random
+import threading
+import time
+from parameterized import parameterized
+import pytest
+
+from cereal import log, car
+import cereal.messaging as messaging
+from cereal.services import SERVICE_LIST
+
+events = [evt for evt in log.Event.schema.union_fields if evt in SERVICE_LIST.keys()]
+
+def random_sock():
+  return random.choice(events)
+
+def random_socks(num_socks=10):
+  return list({random_sock() for _ in range(num_socks)})
+
+def random_bytes(length=1000):
+  return bytes([random.randrange(0xFF) for _ in range(length)])
+
+def zmq_sleep(t=1):
+  if "ZMQ" in os.environ:
+    time.sleep(t)
+
+
+# TODO: this should take any capnp struct and returrn a msg with random populated data
+def random_carstate():
+  fields = ["vEgo", "aEgo", "brake", "steeringAngleDeg"]
+  msg = messaging.new_message("carState")
+  cs = msg.carState
+  for f in fields:
+    setattr(cs, f, random.random() * 10)
+  return msg
+
+# TODO: this should compare any capnp structs
+def assert_carstate(cs1, cs2):
+  for f in car.CarState.schema.non_union_fields:
+    # TODO: check all types
+    val1, val2 = getattr(cs1, f), getattr(cs2, f)
+    if isinstance(val1, numbers.Number):
+      assert val1 == val2, f"{f}: sent '{val1}' vs recvd '{val2}'"
+
+def delayed_send(delay, sock, dat):
+  def send_func():
+    sock.send(dat)
+  threading.Timer(delay, send_func).start()
+
+
+class TestMessaging:
+  def setUp(self):
+    # TODO: ZMQ tests are too slow; all sleeps will need to be
+    # replaced with logic to block on the necessary condition
+    if "ZMQ" in os.environ:
+      pytest.skip()
+
+    # ZMQ pub socket takes too long to die
+    # sleep to prevent multiple publishers error between tests
+    zmq_sleep()
+
+  @parameterized.expand(events)
+  def test_new_message(self, evt):
+    try:
+      msg = messaging.new_message(evt)
+    except capnp.lib.capnp.KjException:
+      msg = messaging.new_message(evt, random.randrange(200))
+    assert (time.monotonic() - msg.logMonoTime) < 0.1
+    assert not msg.valid
+    assert evt == msg.which()
+
+  @parameterized.expand(events)
+  def test_pub_sock(self, evt):
+    messaging.pub_sock(evt)
+
+  @parameterized.expand(events)
+  def test_sub_sock(self, evt):
+    messaging.sub_sock(evt)
+
+  @parameterized.expand([
+    (messaging.drain_sock, capnp._DynamicStructReader),
+    (messaging.drain_sock_raw, bytes),
+  ])
+  def test_drain_sock(self, func, expected_type):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=1000)
+    zmq_sleep()
+
+    # no wait and no msgs in queue
+    msgs = func(sub_sock)
+    assert isinstance(msgs, list)
+    assert len(msgs) == 0
+
+    # no wait but msgs are queued up
+    num_msgs = random.randrange(3, 10)
+    for _ in range(num_msgs):
+      pub_sock.send(messaging.new_message(sock).to_bytes())
+    time.sleep(0.1)
+    msgs = func(sub_sock)
+    assert isinstance(msgs, list)
+    assert all(isinstance(msg, expected_type) for msg in msgs)
+    assert len(msgs) == num_msgs
+
+  def test_recv_sock(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=100)
+    zmq_sleep()
+
+    # no wait and no msg in queue, socket should timeout
+    recvd = messaging.recv_sock(sub_sock)
+    assert recvd is None
+
+    # no wait and one msg in queue
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    time.sleep(0.01)
+    recvd = messaging.recv_sock(sub_sock)
+    assert isinstance(recvd, capnp._DynamicStructReader)
+    # https://github.com/python/mypy/issues/13038
+    assert_carstate(msg.carState, recvd.carState)
+
+  def test_recv_one(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=1000)
+    zmq_sleep()
+
+    # no msg in queue, socket should timeout
+    recvd = messaging.recv_one(sub_sock)
+    assert recvd is None
+
+    # one msg in queue
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    recvd = messaging.recv_one(sub_sock)
+    assert isinstance(recvd, capnp._DynamicStructReader)
+    assert_carstate(msg.carState, recvd.carState)
+
+  @pytest.mark.xfail(condition="ZMQ" in os.environ, reason='ZMQ detected')
+  def test_recv_one_or_none(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock)
+    zmq_sleep()
+
+    # no msg in queue, socket shouldn't block
+    recvd = messaging.recv_one_or_none(sub_sock)
+    assert recvd is None
+
+    # one msg in queue
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    recvd = messaging.recv_one_or_none(sub_sock)
+    assert isinstance(recvd, capnp._DynamicStructReader)
+    assert_carstate(msg.carState, recvd.carState)
+
+  def test_recv_one_retry(self):
+    sock = "carState"
+    sock_timeout = 0.1
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=round(sock_timeout*1000))
+    zmq_sleep()
+
+    # this test doesn't work with ZMQ since multiprocessing interrupts it
+    if "ZMQ" not in os.environ:
+      # wait 5 socket timeouts and make sure it's still retrying
+      p = multiprocessing.Process(target=messaging.recv_one_retry, args=(sub_sock,))
+      p.start()
+      time.sleep(sock_timeout*5)
+      assert p.is_alive()
+      p.terminate()
+
+    # wait 5 socket timeouts before sending
+    msg = random_carstate()
+    start_time = time.monotonic()
+    delayed_send(sock_timeout*5, pub_sock, msg.to_bytes())
+    recvd = messaging.recv_one_retry(sub_sock)
+    assert (time.monotonic() - start_time) >= sock_timeout*5
+    assert isinstance(recvd, capnp._DynamicStructReader)
+    assert_carstate(msg.carState, recvd.carState)

cereal/messaging/tests/test_pub_sub_master.py

@@ -0,0 +1,160 @@
+import random
+import time
+from typing import Sized, cast
+
+import cereal.messaging as messaging
+from cereal.messaging.tests.test_messaging import events, random_sock, random_socks, \
+                                                  random_bytes, random_carstate, assert_carstate, \
+                                                  zmq_sleep
+from cereal.services import SERVICE_LIST
+
+
+class TestSubMaster:
+
+  def setup_method(self):
+    # ZMQ pub socket takes too long to die
+    # sleep to prevent multiple publishers error between tests
+    zmq_sleep(3)
+
+  def test_init(self):
+    sm = messaging.SubMaster(events)
+    for p in [sm.updated, sm.recv_time, sm.recv_frame, sm.alive,
+              sm.sock, sm.data, sm.logMonoTime, sm.valid]:
+      assert len(cast(Sized, p)) == len(events)
+
+  def test_init_state(self):
+    socks = random_socks()
+    sm = messaging.SubMaster(socks)
+    assert sm.frame == -1
+    assert not any(sm.updated.values())
+    assert not any(sm.seen.values())
+    on_demand = {s: SERVICE_LIST[s].frequency <= 1e-5 for s in sm.services}
+    assert all(sm.alive[s] == sm.valid[s] == sm.freq_ok[s] == on_demand[s] for s in sm.services)
+    assert all(t == 0. for t in sm.recv_time.values())
+    assert all(f == 0 for f in sm.recv_frame.values())
+    assert all(t == 0 for t in sm.logMonoTime.values())
+
+    for p in [sm.updated, sm.recv_time, sm.recv_frame, sm.alive,
+              sm.sock, sm.data, sm.logMonoTime, sm.valid]:
+      assert len(cast(Sized, p)) == len(socks)
+
+  def test_getitem(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sm = messaging.SubMaster([sock,])
+    zmq_sleep()
+
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    sm.update(1000)
+    assert_carstate(msg.carState, sm[sock])
+
+  # TODO: break this test up to individually test SubMaster.update and SubMaster.update_msgs
+  def test_update(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sm = messaging.SubMaster([sock,])
+    zmq_sleep()
+
+    for i in range(10):
+      msg = messaging.new_message(sock)
+      pub_sock.send(msg.to_bytes())
+      sm.update(1000)
+      assert sm.frame == i
+      assert all(sm.updated.values())
+
+  def test_update_timeout(self):
+    sock = random_sock()
+    sm = messaging.SubMaster([sock,])
+    timeout = random.randrange(1000, 3000)
+    start_time = time.monotonic()
+    sm.update(timeout)
+    t = time.monotonic() - start_time
+    assert t >= timeout/1000.
+    assert t < 3
+    assert not any(sm.updated.values())
+
+  def test_avg_frequency_checks(self):
+    for poll in (True, False):
+      sm = messaging.SubMaster(["modelV2", "carParams", "carState", "cameraOdometry", "liveCalibration"],
+                               poll=("modelV2" if poll else None),
+                               frequency=(20. if not poll else None))
+
+      checks = {
+        "carState": (20, 20),
+        "modelV2": (20, 20 if poll else 10),
+        "cameraOdometry": (20, 10),
+        "liveCalibration": (4, 4),
+        "carParams": (None, None),
+        "userBookmark": (None, None),
+      }
+
+      for service, (max_freq, min_freq) in checks.items():
+        if max_freq is not None:
+          assert sm._check_avg_freq(service)
+          assert sm.freq_tracker[service].max_freq == max_freq*1.2
+          assert sm.freq_tracker[service].min_freq == min_freq*0.8
+        else:
+          assert not sm._check_avg_freq(service)
+
+  def test_alive(self):
+    pass
+
+  def test_ignore_alive(self):
+    pass
+
+  def test_valid(self):
+    pass
+
+  # SubMaster should always conflate
+  def test_conflate(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sm = messaging.SubMaster([sock,])
+
+    n = 10
+    for i in range(n+1):
+      msg = messaging.new_message(sock)
+      msg.carState.vEgo = i
+      pub_sock.send(msg.to_bytes())
+      time.sleep(0.01)
+    sm.update(1000)
+    assert sm[sock].vEgo == n
+
+
+class TestPubMaster:
+
+  def setup_method(self):
+    # ZMQ pub socket takes too long to die
+    # sleep to prevent multiple publishers error between tests
+    zmq_sleep(3)
+
+  def test_init(self):
+    messaging.PubMaster(events)
+
+  def test_send(self):
+    socks = random_socks()
+    pm = messaging.PubMaster(socks)
+    sub_socks = {s: messaging.sub_sock(s, conflate=True, timeout=1000) for s in socks}
+    zmq_sleep()
+
+    # PubMaster accepts either a capnp msg builder or bytes
+    for capnp in [True, False]:
+      for i in range(100):
+        sock = socks[i % len(socks)]
+
+        if capnp:
+          try:
+            msg = messaging.new_message(sock)
+          except Exception:
+            msg = messaging.new_message(sock, random.randrange(50))
+        else:
+          msg = random_bytes()
+
+        pm.send(sock, msg)
+        recvd = sub_socks[sock].receive()
+
+        if capnp:
+          msg.clear_write_flag()
+          msg = msg.to_bytes()
+        assert msg == recvd, i

cereal/messaging/tests/test_services.py

@@ -0,0 +1,21 @@
+import os
+import tempfile
+from typing import Dict
+from parameterized import parameterized
+
+import cereal.services as services
+from cereal.services import SERVICE_LIST
+
+
+class TestServices:
+
+  @parameterized.expand(SERVICE_LIST.keys())
+  def test_services(self, s):
+    service = SERVICE_LIST[s]
+    assert service.frequency <= 104
+    assert service.decimation != 0
+
+  def test_generated_header(self):
+    with tempfile.NamedTemporaryFile(suffix=".h") as f:
+      ret = os.system(f"python3 {services.__file__} > {f.name} && clang++ {f.name} -std=c++11")
+      assert ret == 0, "generated services header is not valid C"

cereal/messaging/tests/validate_sp_cereal_upstream.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+from typing import Any, List, Tuple
+
+DEBUG = False
+
+
+def print_debug(string: str) -> None:
+  if DEBUG:
+    print(string)
+
+
+def create_schema_instance(struct: Any, prop: Tuple[str, Any]) -> Any:
+  """
+  Create a new instance of a schema type, handling different field types.
+
+  Args:
+      struct: The Cap'n Proto schema structure
+      prop: A tuple containing the field name and field metadata
+
+  Returns:
+      A new initialized schema instance
+  """
+  struct_instance = struct.new_message()
+  field_name, field_metadata = prop
+
+  try:
+    field_type = field_metadata.proto.slot.type.which()
+
+    # Initialize different types of fields
+    if field_type in ('list', 'text', 'data'):
+      struct_instance.init(field_name, 1)
+      print_debug(f"Initialized list/text/data field: {field_name}")
+    elif field_type in ('struct', 'object'):
+      struct_instance.init(field_name)
+      print_debug(f"Initialized struct/object field: {field_name}")
+
+    return struct_instance
+
+  except Exception as e:
+    print(f"Error creating instance for {field_name}: {e}")
+    return None
+
+
+def get_schema_fields(schema_struct: Any) -> List[Tuple[str, Any]]:
+  """
+  Retrieve all fields from a given schema structure.
+
+  Args:
+      schema_struct: The Cap'n Proto schema structure
+
+  Returns:
+      A list of field names and their metadata
+  """
+  try:
+    # Get all fields from the schema
+    schema_fields = list(schema_struct.schema.fields.items())
+
+    print_debug("Discovered schema fields:")
+    for field_name, field_metadata in schema_fields:
+      print_debug(f"- {field_name}")
+
+    return schema_fields
+
+  except Exception as e:
+    print(f"Error retrieving schema fields: {e}")
+    return []
+
+
+def generate_schema_instances(schema_struct: Any) -> List[Any]:
+  """
+  Generate instances for all fields in a given schema.
+
+  Args:
+      schema_struct: The Cap'n Proto schema structure
+
+  Returns:
+      A list of schema instances
+  """
+  schema_fields = get_schema_fields(schema_struct)
+  instances = []
+
+  for field_prop in schema_fields:
+    try:
+      instance = create_schema_instance(schema_struct, field_prop)
+      if instance is not None:
+        instances.append(instance)
+    except Exception as e:
+      print(f"Skipping field due to error: {e}")
+
+  print(f"Generated {len(instances)} schema instances")
+  return instances
+
+
+def persist_instances(instances: List[Any], filename: str) -> None:
+  """
+  Write schema instances to a binary file.
+
+  Args:
+      instances: List of schema instances
+      filename: Output file path
+  """
+  try:
+    with open(filename, 'wb') as f:
+      for instance in instances:
+        f.write(instance.to_bytes())
+
+    print(f"Successfully wrote {len(instances)} instances to {filename}")
+
+  except Exception as e:
+    print(f"Error persisting instances: {e}")
+    sys.exit(1)
+
+
+def read_instances(filename: str, schema_type: Any) -> List[Any]:
+  """
+  Read schema instances from a binary file.
+
+  Args:
+      filename: Input file path
+      schema_type: The schema type to use for reading
+
+  Returns:
+      A list of read schema instances
+  """
+  try:
+    with open(filename, 'rb') as f:
+      data = f.read()
+
+    instances = list(schema_type.read_multiple_bytes(data))
+
+    print(f"Read {len(instances)} instances from {filename}")
+    return instances
+
+  except Exception as e:
+    print(f"Error reading instances: {e}")
+    sys.exit(1)
+
+
+def compare_schemas(original_instances: List[Any], read_instances: List[Any]) -> bool:
+  """
+  Compare original and read-back instances to detect potential breaking changes.
+
+  Args:
+      original_instances: List of originally generated instances
+      read_instances: List of instances read back from file
+
+  Returns:
+      Boolean indicating whether schemas appear compatible
+  """
+  if len(original_instances) != len(read_instances):
+    print("❌ Schema Compatibility Warning: Instance count mismatch")
+    return False
+
+  compatible = True
+  for struct in read_instances:
+    try:
+      getattr(struct, struct.which())  # Attempting to access the field to validate readability
+    except Exception as e:
+      print(f"❌ Structural change detected: {struct.which()} is not readable.\nFull error: {e}")
+      compatible = False
+
+  return compatible
+
+
+def main():
+  """
+  CLI entry point for schema compatibility testing.
+  """
+  # Setup argument parser
+  parser = argparse.ArgumentParser(
+    description='Cap\'n Proto Schema Compatibility Testing Tool',
+    epilog='Test schema compatibility by generating and reading back instances.'
+  )
+
+  # Add mutually exclusive group for generation or reading mode
+  mode_group = parser.add_mutually_exclusive_group(required=True)
+  mode_group.add_argument('-g', '--generate', action='store_true',
+                          help='Generate schema instances')
+  mode_group.add_argument('-r', '--read', action='store_true',
+                          help='Read and validate schema instances')
+
+  # Common arguments
+  parser.add_argument('-f', '--file',
+                      default='schema_instances.bin',
+                      help='Output/input binary file (default: schema_instances.bin)')
+
+  # Parse arguments
+  args = parser.parse_args()
+
+  # Import the schema dynamically 
+  try:
+    from cereal import log
+    schema_type = log.Event
+  except ImportError:
+    print("Error: Unable to import schema. Ensure 'cereal' is installed.")
+    sys.exit(1)
+
+  # Execute based on mode
+  if args.generate:
+    print("🔧 Generating Schema Instances")
+    instances = generate_schema_instances(schema_type)
+    persist_instances(instances, args.file)
+    print("✅ Instance generation complete")
+
+  elif args.read:
+    print("🔍 Reading and Validating Schema Instances")
+    generated_instances = generate_schema_instances(schema_type)
+    read_back_instances = read_instances(args.file, schema_type)
+
+    # Compare schemas
+    if compare_schemas(generated_instances, read_back_instances):
+      print("✅ Schema Compatibility: No breaking changes detected")
+      sys.exit(0)
+    else:
+      print("❌ Potential Schema Breaking Changes Detected")
+      sys.exit(1)
+
+
+if __name__ == "__main__":
+  main()

cereal/services.h

@@ -0,0 +1,99 @@
+/* THIS IS AN AUTOGENERATED FILE, PLEASE EDIT services.py */
+#ifndef __SERVICES_H
+#define __SERVICES_H
+#include <map>
+#include <string>
+struct service { std::string name; bool should_log; float frequency; int decimation; size_t queue_size; };
+static std::map<std::string, service> services = {
+  { "gyroscope", {"gyroscope", true, 104.000000, 104, 256000}},
+  { "accelerometer", {"accelerometer", true, 104.000000, 104, 256000}},
+  { "magnetometer", {"magnetometer", true, 25.000000, -1, 256000}},
+  { "lightSensor", {"lightSensor", true, 100.000000, 100, 256000}},
+  { "temperatureSensor", {"temperatureSensor", true, 2.000000, 200, 256000}},
+  { "gpsNMEA", {"gpsNMEA", true, 9.000000, -1, 256000}},
+  { "deviceState", {"deviceState", true, 2.000000, 1, 256000}},
+  { "touch", {"touch", true, 20.000000, 1, 256000}},
+  { "can", {"can", true, 100.000000, 2053, 10485760}},
+  { "controlsState", {"controlsState", true, 100.000000, 10, 2097152}},
+  { "selfdriveState", {"selfdriveState", true, 100.000000, 10, 256000}},
+  { "pandaStates", {"pandaStates", true, 10.000000, 1, 256000}},
+  { "peripheralState", {"peripheralState", true, 2.000000, 1, 256000}},
+  { "radarState", {"radarState", true, 20.000000, 5, 256000}},
+  { "roadEncodeIdx", {"roadEncodeIdx", false, 20.000000, 1, 256000}},
+  { "liveTracks", {"liveTracks", true, 20.000000, -1, 256000}},
+  { "sendcan", {"sendcan", true, 100.000000, 139, 2097152}},
+  { "logMessage", {"logMessage", true, 0.000000, -1, 256000}},
+  { "errorLogMessage", {"errorLogMessage", true, 0.000000, 1, 256000}},
+  { "liveCalibration", {"liveCalibration", true, 4.000000, 4, 256000}},
+  { "liveTorqueParameters", {"liveTorqueParameters", true, 4.000000, 1, 256000}},
+  { "liveDelay", {"liveDelay", true, 4.000000, 1, 256000}},
+  { "androidLog", {"androidLog", true, 0.000000, -1, 256000}},
+  { "carState", {"carState", true, 100.000000, 10, 256000}},
+  { "carControl", {"carControl", true, 100.000000, 10, 256000}},
+  { "carOutput", {"carOutput", true, 100.000000, 10, 256000}},
+  { "longitudinalPlan", {"longitudinalPlan", true, 20.000000, 10, 256000}},
+  { "driverAssistance", {"driverAssistance", true, 20.000000, 20, 256000}},
+  { "procLog", {"procLog", true, 0.500000, 15, 10485760}},
+  { "gpsLocationExternal", {"gpsLocationExternal", true, 10.000000, 10, 256000}},
+  { "gpsLocation", {"gpsLocation", true, 1.000000, 1, 256000}},
+  { "ubloxGnss", {"ubloxGnss", true, 10.000000, -1, 256000}},
+  { "qcomGnss", {"qcomGnss", true, 2.000000, -1, 256000}},
+  { "gnssMeasurements", {"gnssMeasurements", true, 10.000000, 10, 256000}},
+  { "clocks", {"clocks", true, 0.100000, 1, 256000}},
+  { "ubloxRaw", {"ubloxRaw", true, 20.000000, -1, 256000}},
+  { "livePose", {"livePose", true, 20.000000, 4, 256000}},
+  { "liveParameters", {"liveParameters", true, 20.000000, 5, 256000}},
+  { "cameraOdometry", {"cameraOdometry", true, 20.000000, 10, 256000}},
+  { "thumbnail", {"thumbnail", true, 0.016667, 1, 256000}},
+  { "onroadEvents", {"onroadEvents", true, 1.000000, 1, 256000}},
+  { "carParams", {"carParams", true, 0.020000, 1, 256000}},
+  { "roadCameraState", {"roadCameraState", true, 20.000000, 20, 256000}},
+  { "driverCameraState", {"driverCameraState", true, 20.000000, 20, 256000}},
+  { "driverEncodeIdx", {"driverEncodeIdx", false, 20.000000, 1, 256000}},
+  { "driverStateV2", {"driverStateV2", true, 20.000000, 10, 256000}},
+  { "driverMonitoringState", {"driverMonitoringState", true, 20.000000, 10, 256000}},
+  { "wideRoadEncodeIdx", {"wideRoadEncodeIdx", false, 20.000000, 1, 256000}},
+  { "wideRoadCameraState", {"wideRoadCameraState", true, 20.000000, 20, 256000}},
+  { "drivingModelData", {"drivingModelData", true, 20.000000, 10, 256000}},
+  { "modelV2", {"modelV2", true, 20.000000, -1, 10485760}},
+  { "managerState", {"managerState", true, 2.000000, 1, 256000}},
+  { "uploaderState", {"uploaderState", true, 0.000000, 1, 256000}},
+  { "navInstruction", {"navInstruction", true, 1.000000, 10, 256000}},
+  { "navRoute", {"navRoute", true, 0.000000, -1, 256000}},
+  { "navThumbnail", {"navThumbnail", true, 0.000000, -1, 256000}},
+  { "qRoadEncodeIdx", {"qRoadEncodeIdx", false, 20.000000, -1, 256000}},
+  { "userBookmark", {"userBookmark", true, 0.000000, 1, 256000}},
+  { "soundPressure", {"soundPressure", true, 10.000000, 10, 256000}},
+  { "rawAudioData", {"rawAudioData", false, 20.000000, -1, 256000}},
+  { "bookmarkButton", {"bookmarkButton", true, 0.000000, 1, 256000}},
+  { "audioFeedback", {"audioFeedback", true, 0.000000, 1, 256000}},
+  { "roadEncodeData", {"roadEncodeData", false, 20.000000, -1, 10485760}},
+  { "driverEncodeData", {"driverEncodeData", false, 20.000000, -1, 10485760}},
+  { "wideRoadEncodeData", {"wideRoadEncodeData", false, 20.000000, -1, 10485760}},
+  { "qRoadEncodeData", {"qRoadEncodeData", false, 20.000000, -1, 10485760}},
+  { "modelManagerSP", {"modelManagerSP", false, 1.000000, 1, 10485760}},
+  { "backupManagerSP", {"backupManagerSP", false, 1.000000, 1, 10485760}},
+  { "selfdriveStateSP", {"selfdriveStateSP", true, 100.000000, 10, 256000}},
+  { "longitudinalPlanSP", {"longitudinalPlanSP", true, 20.000000, 10, 256000}},
+  { "onroadEventsSP", {"onroadEventsSP", true, 1.000000, 1, 256000}},
+  { "carParamsSP", {"carParamsSP", true, 0.020000, 1, 256000}},
+  { "carControlSP", {"carControlSP", true, 100.000000, 10, 256000}},
+  { "carStateSP", {"carStateSP", true, 100.000000, 10, 256000}},
+  { "liveMapDataSP", {"liveMapDataSP", true, 1.000000, 1, 256000}},
+  { "modelDataV2SP", {"modelDataV2SP", true, 20.000000, -1, 10485760}},
+  { "liveLocationKalman", {"liveLocationKalman", true, 20.000000, -1, 256000}},
+  { "uiDebug", {"uiDebug", true, 0.000000, 1, 256000}},
+  { "testJoystick", {"testJoystick", true, 0.000000, -1, 256000}},
+  { "alertDebug", {"alertDebug", true, 20.000000, 5, 256000}},
+  { "livestreamWideRoadEncodeIdx", {"livestreamWideRoadEncodeIdx", false, 20.000000, -1, 256000}},
+  { "livestreamRoadEncodeIdx", {"livestreamRoadEncodeIdx", false, 20.000000, -1, 256000}},
+  { "livestreamDriverEncodeIdx", {"livestreamDriverEncodeIdx", false, 20.000000, -1, 256000}},
+  { "livestreamWideRoadEncodeData", {"livestreamWideRoadEncodeData", false, 20.000000, -1, 2097152}},
+  { "livestreamRoadEncodeData", {"livestreamRoadEncodeData", false, 20.000000, -1, 2097152}},
+  { "livestreamDriverEncodeData", {"livestreamDriverEncodeData", false, 20.000000, -1, 2097152}},
+  { "customReservedRawData0", {"customReservedRawData0", true, 0.000000, -1, 256000}},
+  { "customReservedRawData1", {"customReservedRawData1", true, 0.000000, -1, 256000}},
+  { "customReservedRawData2", {"customReservedRawData2", true, 0.000000, -1, 256000}},
+};
+#endif
+

cereal/services.py

@@ -1,57 +1,68 @@
 #!/usr/bin/env python3
+from enum import IntEnum
 from typing import Optional
 
-RESERVED_PORT = 8022  # sshd
-STARTING_PORT = 8001
 
-
-def new_port(port: int):
-  port += STARTING_PORT
-  return port + 1 if port >= RESERVED_PORT else port
+# TODO: this should be automatically determined using the capnp schema
+class QueueSize(IntEnum):
+  BIG = 10 * 1024 * 1024      # 10MB - video frames, large AI outputs
+  MEDIUM = 2 * 1024 * 1024    # 2MB - high freq (CAN), livestream
+  SMALL = 250 * 1024          # 250KB - most services
 
 
 class Service:
-  def __init__(self, port: int, should_log: bool, frequency: float, decimation: Optional[int] = None):
-    self.port = port
+  def __init__(self, should_log: bool, frequency: float, decimation: Optional[int] = None,
+               queue_size: QueueSize = QueueSize.SMALL):
     self.should_log = should_log
     self.frequency = frequency
     self.decimation = decimation
+    self.queue_size = queue_size
 
 
-services = {
+_services: dict[str, tuple] = {
   # service: (should_log, frequency, qlog decimation (optional))
   # note: the "EncodeIdx" packets will still be in the log
-  "sensorEvents": (True, 100., 100),
+  "gyroscope": (True, 104., 104),
+  "accelerometer": (True, 104., 104),
+  "magnetometer": (True, 25.),
+  "lightSensor": (True, 100., 100),
+  "temperatureSensor": (True, 2., 200),
   "gpsNMEA": (True, 9.),
   "deviceState": (True, 2., 1),
-  "can": (True, 100.),
-  "controlsState": (True, 100., 10),
-  "pandaStates": (True, 2., 1),
+  "touch": (True, 20., 1),
+  "can": (True, 100., 2053, QueueSize.BIG),  # decimation gives ~3 msgs in a full segment
+  "controlsState": (True, 100., 10, QueueSize.MEDIUM),
+  "selfdriveState": (True, 100., 10),
+  "pandaStates": (True, 10., 1),
   "peripheralState": (True, 2., 1),
   "radarState": (True, 20., 5),
   "roadEncodeIdx": (False, 20., 1),
   "liveTracks": (True, 20.),
-  "sendcan": (True, 100., 139),
+  "sendcan": (True, 100., 139, QueueSize.MEDIUM),
   "logMessage": (True, 0.),
   "errorLogMessage": (True, 0., 1),
   "liveCalibration": (True, 4., 4),
+  "liveTorqueParameters": (True, 4., 1),
+  "liveDelay": (True, 4., 1),
   "androidLog": (True, 0.),
   "carState": (True, 100., 10),
   "carControl": (True, 100., 10),
-  "longitudinalPlan": (True, 20., 5),
-  "procLog": (True, 0.5),
+  "carOutput": (True, 100., 10),
+  "longitudinalPlan": (True, 20., 10),
+  "driverAssistance": (True, 20., 20),
+  "procLog": (True, 0.5, 15, QueueSize.BIG),
   "gpsLocationExternal": (True, 10., 10),
+  "gpsLocation": (True, 1., 1),
   "ubloxGnss": (True, 10.),
   "qcomGnss": (True, 2.),
   "gnssMeasurements": (True, 10., 10),
-  "clocks": (True, 1., 1),
+  "clocks": (True, 0.1, 1),
   "ubloxRaw": (True, 20.),
-  "liveLocationKalman": (True, 20., 5),
+  "livePose": (True, 20., 4),
   "liveParameters": (True, 20., 5),
-  "cameraOdometry": (True, 20., 5),
-  "lateralPlan": (True, 20., 5),
-  "thumbnail": (True, 0.2, 1),
-  "carEvents": (True, 1., 1),
+  "cameraOdometry": (True, 20., 10),
+  "thumbnail": (True, 1 / 60., 1),
+  "onroadEvents": (True, 1., 1),
   "carParams": (True, 0.02, 1),
   "roadCameraState": (True, 20., 20),
   "driverCameraState": (True, 20., 20),
@@ -60,23 +71,53 @@ services = {
   "driverMonitoringState": (True, 20., 10),
   "wideRoadEncodeIdx": (False, 20., 1),
   "wideRoadCameraState": (True, 20., 20),
-  "modelV2": (True, 20., 40),
+  "drivingModelData": (True, 20., 10),
+  "modelV2": (True, 20., None, QueueSize.BIG),
   "managerState": (True, 2., 1),
   "uploaderState": (True, 0., 1),
   "navInstruction": (True, 1., 10),
   "navRoute": (True, 0.),
   "navThumbnail": (True, 0.),
   "qRoadEncodeIdx": (False, 20.),
+  "userBookmark": (True, 0., 1),
+  "soundPressure": (True, 10., 10),
+  "rawAudioData": (False, 20.),
+  "bookmarkButton": (True, 0., 1),
+  "audioFeedback": (True, 0., 1),
+  "roadEncodeData": (False, 20., None, QueueSize.BIG),
+  "driverEncodeData": (False, 20., None, QueueSize.BIG),
+  "wideRoadEncodeData": (False, 20., None, QueueSize.BIG),
+  "qRoadEncodeData": (False, 20., None, QueueSize.BIG),
+
+  # sunnypilot
+  "modelManagerSP": (False, 1., 1, QueueSize.BIG),
+  "backupManagerSP": (False, 1., 1, QueueSize.BIG),
+  "selfdriveStateSP": (True, 100., 10),
+  "longitudinalPlanSP": (True, 20., 10),
+  "onroadEventsSP": (True, 1., 1),
+  "carParamsSP": (True, 0.02, 1),
+  "carControlSP": (True, 100., 10),
+  "carStateSP": (True, 100., 10),
+  "liveMapDataSP": (True, 1., 1),
+  "modelDataV2SP": (True, 20., None, QueueSize.BIG),
+  "liveLocationKalman": (True, 20.),
 
   # debug
+  "uiDebug": (True, 0., 1),
   "testJoystick": (True, 0.),
-  "roadEncodeData": (False, 20.),
-  "driverEncodeData": (False, 20.),
-  "wideRoadEncodeData": (False, 20.),
-  "qRoadEncodeData": (False, 20.),
+  "alertDebug": (True, 20., 5),
+  "livestreamWideRoadEncodeIdx": (False, 20.),
+  "livestreamRoadEncodeIdx": (False, 20.),
+  "livestreamDriverEncodeIdx": (False, 20.),
+  "livestreamWideRoadEncodeData": (False, 20., None, QueueSize.MEDIUM),
+  "livestreamRoadEncodeData": (False, 20., None, QueueSize.MEDIUM),
+  "livestreamDriverEncodeData": (False, 20., None, QueueSize.MEDIUM),
+  "customReservedRawData0": (True, 0.),
+  "customReservedRawData1": (True, 0.),
+  "customReservedRawData2": (True, 0.),
 }
-service_list = {name: Service(new_port(idx), *vals) for  # type: ignore
-                idx, (name, vals) in enumerate(services.items())}
+SERVICE_LIST = {name: Service(*vals) for
+                idx, (name, vals) in enumerate(_services.items())}
 
 
 def build_header():
@@ -84,14 +125,19 @@ def build_header():
   h += "/* THIS IS AN AUTOGENERATED FILE, PLEASE EDIT services.py */\n"
   h += "#ifndef __SERVICES_H\n"
   h += "#define __SERVICES_H\n"
-  h += "struct service { char name[0x100]; int port; bool should_log; int frequency; int decimation; };\n"
-  h += "static struct service services[] = {\n"
-  for k, v in service_list.items():
+
+  h += "#include <map>\n"
+  h += "#include <string>\n"
+
+  h += "struct service { std::string name; bool should_log; float frequency; int decimation; size_t queue_size; };\n"
+  h += "static std::map<std::string, service> services = {\n"
+  for k, v in SERVICE_LIST.items():
     should_log = "true" if v.should_log else "false"
     decimation = -1 if v.decimation is None else v.decimation
-    h += '  { "%s", %d, %s, %d, %d },\n' % \
-         (k, v.port, should_log, v.frequency, decimation)
+    h += '  { "%s", {"%s", %s, %f, %d, %d}},\n' % \
+         (k, k, should_log, v.frequency, decimation, v.queue_size)
   h += "};\n"
+
   h += "#endif\n"
   return h
 

cereal/visionipc/__init__.py

@@ -1,4 +0,0 @@
-from cereal.visionipc.visionipc_pyx import VisionIpcClient, VisionIpcServer, VisionStreamType  # pylint: disable=no-name-in-module, import-error
-assert VisionIpcClient
-assert VisionIpcServer
-assert VisionStreamType

cereal/visionipc/ipc.cc

@@ -1,121 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <assert.h>
-#include <errno.h>
-
-#include <sys/mman.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-
-#ifdef __APPLE__
-#define getsocket() socket(AF_UNIX, SOCK_STREAM, 0)
-#else
-#define getsocket() socket(AF_UNIX, SOCK_SEQPACKET, 0)
-#endif
-
-#include "ipc.h"
-
-int ipc_connect(const char* socket_path) {
-  int err;
-
-  int sock = getsocket();
-
-  if (sock < 0) return -1;
-  struct sockaddr_un addr = {
-    .sun_family = AF_UNIX,
-  };
-  snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
-  err = connect(sock, (struct sockaddr*)&addr, sizeof(addr));
-  if (err != 0) {
-    close(sock);
-    return -1;
-  }
-
-  return sock;
-}
-
-int ipc_bind(const char* socket_path) {
-  int err;
-
-  unlink(socket_path);
-
-  int sock = getsocket();
-
-  struct sockaddr_un addr = {
-    .sun_family = AF_UNIX,
-  };
-  snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
-  err = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
-  assert(err == 0);
-
-  err = listen(sock, 3);
-  assert(err == 0);
-
-  return sock;
-}
-
-
-int ipc_sendrecv_with_fds(bool send, int fd, void *buf, size_t buf_size, int* fds, int num_fds,
-                          int *out_num_fds) {
-  char control_buf[CMSG_SPACE(sizeof(int) * num_fds)];
-  memset(control_buf, 0, CMSG_SPACE(sizeof(int) * num_fds));
-
-  struct iovec iov = {
-    .iov_base = buf,
-    .iov_len = buf_size,
-  };
-  struct msghdr msg = {
-    .msg_iov = &iov,
-    .msg_iovlen = 1,
-  };
-
-  if (num_fds > 0) {
-    assert(fds);
-
-    msg.msg_control = control_buf;
-    msg.msg_controllen = CMSG_SPACE(sizeof(int) * num_fds);
-  }
-
-  if (send) {
-    if (num_fds) {
-      struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
-      assert(cmsg);
-      cmsg->cmsg_level = SOL_SOCKET;
-      cmsg->cmsg_type = SCM_RIGHTS;
-      cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
-      memcpy(CMSG_DATA(cmsg), fds, sizeof(int) * num_fds);
-    }
-    return sendmsg(fd, &msg, 0);
-  } else {
-    int r = recvmsg(fd, &msg, 0);
-    if (r < 0) return r;
-
-    int recv_fds = 0;
-    if (msg.msg_controllen > 0) {
-      struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
-      assert(cmsg);
-      assert(cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS);
-      recv_fds = (cmsg->cmsg_len - CMSG_LEN(0));
-      assert(recv_fds > 0 && (recv_fds % sizeof(int)) == 0);
-      recv_fds /= sizeof(int);
-
-      assert(fds && recv_fds <= num_fds);
-      memcpy(fds, CMSG_DATA(cmsg), sizeof(int) * recv_fds);
-    }
-
-    if (msg.msg_flags) {
-      for (int i=0; i<recv_fds; i++) {
-        close(fds[i]);
-      }
-      return -1;
-    }
-
-    if (fds) {
-      assert(out_num_fds);
-      *out_num_fds = recv_fds;
-    }
-    return r;
-  }
-}

cereal/visionipc/ipc.h

@@ -1,7 +0,0 @@
-#pragma once
-#include <cstddef>
-
-int ipc_connect(const char* socket_path);
-int ipc_bind(const char* socket_path);
-int ipc_sendrecv_with_fds(bool send, int fd, void *buf, size_t buf_size, int* fds, int num_fds,
-                          int *out_num_fds);

cereal/visionipc/visionbuf.cc

@@ -1,35 +0,0 @@
-#include "visionbuf.h"
-
-#define ALIGN(x, align) (((x) + (align)-1) & ~((align)-1))
-
-void visionbuf_compute_aligned_width_and_height(int width, int height, int *aligned_w, int *aligned_h) {
-  *aligned_w = width;
-  *aligned_h = height;
-}
-
-void VisionBuf::init_rgb(size_t init_width, size_t init_height, size_t init_stride) {
-  this->rgb = true;
-  this->width = init_width;
-  this->height = init_height;
-  this->stride = init_stride;
-}
-
-void VisionBuf::init_yuv(size_t init_width, size_t init_height, size_t init_stride, size_t init_uv_offset){
-  this->rgb = false;
-  this->width = init_width;
-  this->height = init_height;
-  this->stride = init_stride;
-  this->uv_offset = init_uv_offset;
-
-  this->y = (uint8_t *)this->addr;
-  this->uv = this->y + this->uv_offset;
-}
-
-
-uint64_t VisionBuf::get_frame_id() {
-  return *frame_id;
-}
-
-void VisionBuf::set_frame_id(uint64_t id) {
-  *frame_id = id;
-}

cereal/visionipc/visionipc.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cstddef>
-
-constexpr int VISIONIPC_MAX_FDS = 128;
-
-struct VisionIpcBufExtra {
-  uint32_t frame_id;
-  uint64_t timestamp_sof;
-  uint64_t timestamp_eof;
-};
-
-struct VisionIpcPacket {
-  uint64_t server_id;
-  size_t idx;
-  struct VisionIpcBufExtra extra;
-};

cereal/visionipc/visionipc.pxd

@@ -1,42 +0,0 @@
-# distutils: language = c++
-#cython: language_level=3
-
-from libcpp.string cimport string
-from libcpp.vector cimport vector
-from libc.stdint cimport uint32_t, uint64_t
-from libcpp cimport bool
-
-cdef extern from "visionbuf.h":
-  cdef enum VisionStreamType:
-    pass
-
-  cdef cppclass VisionBuf:
-    void * addr
-    size_t len
-    size_t width
-    size_t height
-    size_t stride
-    size_t uv_offset
-    void set_frame_id(uint64_t id)
-
-cdef extern from "visionipc.h":
-  struct VisionIpcBufExtra:
-    uint32_t frame_id
-    uint64_t timestamp_sof
-    uint64_t timestamp_eof
-
-cdef extern from "visionipc_server.h":
-  cdef cppclass VisionIpcServer:
-    VisionIpcServer(string, void*, void*)
-    void create_buffers(VisionStreamType, size_t, bool, size_t, size_t)
-    void create_buffers_with_sizes(VisionStreamType, size_t, bool, size_t, size_t, size_t, size_t, size_t)
-    VisionBuf * get_buffer(VisionStreamType)
-    void send(VisionBuf *, VisionIpcBufExtra *, bool)
-    void start_listener()
-
-cdef extern from "visionipc_client.h":
-  cdef cppclass VisionIpcClient:
-    VisionIpcClient(string, VisionStreamType, bool, void*, void*)
-    VisionBuf * recv(VisionIpcBufExtra *, int)
-    bool connect(bool)
-    bool is_connected()

cereal/visionipc/visionipc_client.cc

@@ -1,129 +0,0 @@
-#include <chrono>
-#include <cassert>
-#include <iostream>
-#include <thread>
-
-#include "visionipc/ipc.h"
-#include "visionipc/visionipc_client.h"
-#include "visionipc/visionipc_server.h"
-#include "logger/logger.h"
-
-VisionIpcClient::VisionIpcClient(std::string name, VisionStreamType type, bool conflate, cl_device_id device_id, cl_context ctx) : name(name), type(type), device_id(device_id), ctx(ctx) {
-  msg_ctx = Context::create();
-  sock = SubSocket::create(msg_ctx, get_endpoint_name(name, type), "127.0.0.1", conflate, false);
-
-  poller = Poller::create();
-  poller->registerSocket(sock);
-}
-
-// Connect is not thread safe. Do not use the buffers while calling connect
-bool VisionIpcClient::connect(bool blocking){
-  connected = false;
-
-  // Cleanup old buffers on reconnect
-  for (size_t i = 0; i < num_buffers; i++){
-    if (buffers[i].free() != 0) {
-      LOGE("Failed to free buffer %zu", i);
-    }
-  }
-
-  num_buffers = 0;
-
-  // Connect to server socket and ask for all FDs of type
-  std::string path = "/tmp/visionipc_" + name;
-
-  int socket_fd = -1;
-  while (socket_fd < 0) {
-    socket_fd = ipc_connect(path.c_str());
-
-    if (socket_fd < 0) {
-      if (blocking){
-        std::cout << "VisionIpcClient connecting" << std::endl;
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-      } else {
-        return false;
-      }
-    }
-  }
-
-  // Send stream type to server to request FDs
-  int r = ipc_sendrecv_with_fds(true, socket_fd, &type, sizeof(type), nullptr, 0, nullptr);
-  assert(r == sizeof(type));
-
-  // Get FDs
-  int fds[VISIONIPC_MAX_FDS];
-  VisionBuf bufs[VISIONIPC_MAX_FDS];
-  r = ipc_sendrecv_with_fds(false, socket_fd, &bufs, sizeof(bufs), fds, VISIONIPC_MAX_FDS, &num_buffers);
-
-  assert(num_buffers >= 0);
-  assert(r == sizeof(VisionBuf) * num_buffers);
-
-  // Import buffers
-  for (size_t i = 0; i < num_buffers; i++){
-    buffers[i] = bufs[i];
-    buffers[i].fd = fds[i];
-    buffers[i].import();
-    if (buffers[i].rgb) {
-      buffers[i].init_rgb(buffers[i].width, buffers[i].height, buffers[i].stride);
-    } else {
-      buffers[i].init_yuv(buffers[i].width, buffers[i].height, buffers[i].stride, buffers[i].uv_offset);
-    }
-
-    if (device_id) buffers[i].init_cl(device_id, ctx);
-  }
-
-  close(socket_fd);
-  connected = true;
-  return true;
-}
-
-VisionBuf * VisionIpcClient::recv(VisionIpcBufExtra * extra, const int timeout_ms){
-  auto p = poller->poll(timeout_ms);
-
-  if (!p.size()){
-    return nullptr;
-  }
-
-  Message * r = sock->receive(true);
-  if (r == nullptr){
-    return nullptr;
-  }
-
-  // Get buffer
-  assert(r->getSize() == sizeof(VisionIpcPacket));
-  VisionIpcPacket *packet = (VisionIpcPacket*)r->getData();
-
-  assert(packet->idx < num_buffers);
-  VisionBuf * buf = &buffers[packet->idx];
-
-  if (buf->server_id != packet->server_id){
-    connected = false;
-    delete r;
-    return nullptr;
-  }
-
-  if (extra) {
-    *extra = packet->extra;
-  }
-
-  if (buf->sync(VISIONBUF_SYNC_TO_DEVICE) != 0) {
-    LOGE("Failed to sync buffer");
-  }
-
-  delete r;
-  return buf;
-}
-
-
-
-VisionIpcClient::~VisionIpcClient(){
-  for (size_t i = 0; i < num_buffers; i++){
-    if (buffers[i].free() != 0) {
-      LOGE("Failed to free buffer %zu", i);
-    }
-  }
-
-  delete sock;
-  delete poller;
-  delete msg_ctx;
-}

cereal/visionipc/visionipc_pyx.pyx

@@ -1,102 +0,0 @@
-# distutils: language = c++
-# cython: c_string_encoding=ascii, language_level=3
-
-import sys
-import numpy as np
-cimport numpy as cnp
-from cython.view cimport array
-from libc.string cimport memcpy
-from libc.stdint cimport uint32_t, uint64_t
-from libcpp cimport bool
-from libcpp.string cimport string
-
-from .visionipc cimport VisionIpcServer as cppVisionIpcServer
-from .visionipc cimport VisionIpcClient as cppVisionIpcClient
-from .visionipc cimport VisionBuf as cppVisionBuf
-from .visionipc cimport VisionIpcBufExtra
-
-cpdef enum VisionStreamType:
-  VISION_STREAM_RGB_ROAD
-  VISION_STREAM_RGB_DRIVER
-  VISION_STREAM_RGB_WIDE_ROAD
-  VISION_STREAM_ROAD
-  VISION_STREAM_DRIVER
-  VISION_STREAM_WIDE_ROAD
-  VISION_STREAM_RGB_MAP
-
-
-cdef class VisionIpcServer:
-  cdef cppVisionIpcServer * server
-
-  def __init__(self, string name):
-    self.server = new cppVisionIpcServer(name, NULL, NULL)
-
-  def create_buffers(self, VisionStreamType tp, size_t num_buffers, bool rgb, size_t width, size_t height):
-    self.server.create_buffers(tp, num_buffers, rgb, width, height)
-
-  def create_buffers_with_sizes(self, VisionStreamType tp, size_t num_buffers, bool rgb, size_t width, size_t height, size_t size, size_t stride, size_t uv_offset):
-    self.server.create_buffers_with_sizes(tp, num_buffers, rgb, width, height, size, stride, uv_offset)
-
-  def send(self, VisionStreamType tp, const unsigned char[:] data, uint32_t frame_id=0, uint64_t timestamp_sof=0, uint64_t timestamp_eof=0):
-    cdef cppVisionBuf * buf = self.server.get_buffer(tp)
-
-    # Populate buffer
-    assert buf.len == len(data)
-    memcpy(buf.addr, &data[0], len(data))
-    buf.set_frame_id(frame_id)
-
-    cdef VisionIpcBufExtra extra
-    extra.frame_id = frame_id
-    extra.timestamp_sof = timestamp_sof
-    extra.timestamp_eof = timestamp_eof
-
-    self.server.send(buf, &extra, False)
-
-  def start_listener(self):
-    self.server.start_listener()
-
-  def __dealloc__(self):
-    del self.server
-
-
-cdef class VisionIpcClient:
-  cdef cppVisionBuf * buf
-  cdef cppVisionIpcClient * client
-
-  def __cinit__(self, string name, VisionStreamType stream, bool conflate):
-    self.client = new cppVisionIpcClient(name, stream, conflate, NULL, NULL)
-    self.buf = NULL
-
-  def __dealloc__(self):
-    del self.client
-
-  @property
-  def width(self):
-    return None if not self.buf else self.buf.width
-
-  @property
-  def height(self):
-    return None if not self.buf else self.buf.height
-
-  @property
-  def stride(self):
-    return None if not self.buf else self.buf.stride
-
-  @property
-  def uv_offset(self):
-    return None if not self.buf else self.buf.uv_offset
-
-  def recv(self, int timeout_ms=100):
-    self.buf = self.client.recv(NULL, timeout_ms)
-    if not self.buf:
-      return None
-    cdef cnp.ndarray dat = np.empty(self.buf.len, dtype=np.uint8)
-    cdef char[:] dat_view = dat
-    memcpy(&dat_view[0], self.buf.addr, self.buf.len)
-    return dat
-
-  def connect(self, bool blocking):
-    return self.client.connect(blocking)
-
-  def is_connected(self):
-    return self.client.is_connected()

cereal/visionipc/visionipc_server.cc

@@ -1,191 +0,0 @@
-#include <iostream>
-#include <chrono>
-#include <cassert>
-#include <random>
-
-#include <poll.h>
-#include <sys/socket.h>
-#include <unistd.h>
-
-#include "messaging/messaging.h"
-#include "visionipc/ipc.h"
-#include "visionipc/visionipc_server.h"
-#include "logger/logger.h"
-
-std::string get_endpoint_name(std::string name, VisionStreamType type){
-  if (messaging_use_zmq()){
-    assert(name == "camerad" || name == "navd");
-    return std::to_string(9000 + static_cast<int>(type));
-  } else {
-    return "visionipc_" + name + "_" + std::to_string(type);
-  }
-}
-
-VisionIpcServer::VisionIpcServer(std::string name, cl_device_id device_id, cl_context ctx) : name(name), device_id(device_id), ctx(ctx) {
-  msg_ctx = Context::create();
-
-  std::random_device rd("/dev/urandom");
-  std::uniform_int_distribution<uint64_t> distribution(0,std::numeric_limits<uint64_t>::max());
-  server_id = distribution(rd);
-}
-
-void VisionIpcServer::create_buffers(VisionStreamType type, size_t num_buffers, bool rgb, size_t width, size_t height){
-  // TODO: assert that this type is not created yet
-  assert(num_buffers < VISIONIPC_MAX_FDS);
-  int aligned_w = 0, aligned_h = 0;
-
-  size_t size = 0;
-  size_t stride = 0;
-  size_t uv_offset = 0;
-
-  if (rgb) {
-    visionbuf_compute_aligned_width_and_height(width, height, &aligned_w, &aligned_h);
-    size = (size_t)aligned_w * (size_t)aligned_h * 3;
-    stride = aligned_w * 3;
-  } else {
-    size = width * height * 3 / 2;
-    stride = width;
-    uv_offset = width * height;
-  }
-
-  create_buffers_with_sizes(type, num_buffers, rgb, width, height, size, stride, uv_offset);
-}
-
-void VisionIpcServer::create_buffers_with_sizes(VisionStreamType type, size_t num_buffers, bool rgb, size_t width, size_t height, size_t size, size_t stride, size_t uv_offset) {
-  // Create map + alloc requested buffers
-  for (size_t i = 0; i < num_buffers; i++){
-    VisionBuf* buf = new VisionBuf();
-    buf->allocate(size);
-    buf->idx = i;
-    buf->type = type;
-
-    if (device_id) buf->init_cl(device_id, ctx);
-
-    rgb ? buf->init_rgb(width, height, stride) : buf->init_yuv(width, height, stride, uv_offset);
-
-    buffers[type].push_back(buf);
-  }
-
-  cur_idx[type] = 0;
-
-  // Create msgq publisher for each of the `name` + type combos
-  // TODO: compute port number directly if using zmq
-  sockets[type] = PubSocket::create(msg_ctx, get_endpoint_name(name, type), false);
-}
-
-
-void VisionIpcServer::start_listener(){
-  listener_thread = std::thread(&VisionIpcServer::listener, this);
-}
-
-
-void VisionIpcServer::listener(){
-  std::cout << "Starting listener for: " << name << std::endl;
-
-  std::string path = "/tmp/visionipc_" + name;
-  int sock = ipc_bind(path.c_str());
-  assert(sock >= 0);
-
-  while (!should_exit){
-    // Wait for incoming connection
-    struct pollfd polls[1] = {{0}};
-    polls[0].fd = sock;
-    polls[0].events = POLLIN;
-
-    int ret = poll(polls, 1, 100);
-    if (ret < 0) {
-      if (errno == EINTR || errno == EAGAIN) continue;
-      std::cout << "poll failed, stopping listener" << std::endl;
-      break;
-    }
-
-    if (should_exit) break;
-    if (!polls[0].revents) {
-      continue;
-    }
-
-    // Handle incoming request
-    int fd = accept(sock, NULL, NULL);
-    assert(fd >= 0);
-
-    VisionStreamType type = VisionStreamType::VISION_STREAM_MAX;
-    int r = ipc_sendrecv_with_fds(false, fd, &type, sizeof(type), nullptr, 0, nullptr);
-    assert(r == sizeof(type));
-    if (buffers.count(type) <= 0) {
-      std::cout << "got request for invalid buffer type: " << type << std::endl;
-      close(fd);
-      continue;
-    }
-
-    int fds[VISIONIPC_MAX_FDS];
-    int num_fds = buffers[type].size();
-    VisionBuf bufs[VISIONIPC_MAX_FDS];
-
-    for (int i = 0; i < num_fds; i++){
-      fds[i] = buffers[type][i]->fd;
-      bufs[i] = *buffers[type][i];
-
-      // Remove some private openCL/ion metadata
-      bufs[i].buf_cl = 0;
-      bufs[i].copy_q = 0;
-      bufs[i].handle = 0;
-
-      bufs[i].server_id = server_id;
-    }
-
-    r = ipc_sendrecv_with_fds(true, fd, &bufs, sizeof(VisionBuf) * num_fds, fds, num_fds, nullptr);
-
-    close(fd);
-  }
-
-  std::cout << "Stopping listener for: " << name << std::endl;
-  close(sock);
-}
-
-
-
-VisionBuf * VisionIpcServer::get_buffer(VisionStreamType type){
-  // Do we want to keep track if the buffer has been sent out yet and warn user?
-  assert(buffers.count(type));
-  auto b = buffers[type];
-  return b[cur_idx[type]++ % b.size()];
-}
-
-void VisionIpcServer::send(VisionBuf * buf, VisionIpcBufExtra * extra, bool sync){
-  if (sync) {
-    if (buf->sync(VISIONBUF_SYNC_FROM_DEVICE) != 0) {
-      LOGE("Failed to sync buffer");
-    }
-  }
-  assert(buffers.count(buf->type));
-  assert(buf->idx < buffers[buf->type].size());
-
-  // Send over correct msgq socket
-  VisionIpcPacket packet = {0};
-  packet.server_id = server_id;
-  packet.idx = buf->idx;
-  packet.extra = *extra;
-
-  sockets[buf->type]->send((char*)&packet, sizeof(packet));
-}
-
-VisionIpcServer::~VisionIpcServer(){
-  should_exit = true;
-  listener_thread.join();
-
-  // VisionBuf cleanup
-  for( auto const& [type, buf] : buffers ) {
-    for (VisionBuf* b : buf){
-      if (b->free() != 0) {
-        LOGE("Failed to free buffer");
-      }
-      delete b;
-    }
-  }
-
-  // Messaging cleanup
-  for( auto const& [type, sock] : sockets ) {
-    delete sock;
-  }
-  delete msg_ctx;
-}

cereal/visionipc/visionipc_server.h

@@ -1,43 +0,0 @@
-#pragma once
-#include <vector>
-#include <string>
-#include <thread>
-#include <atomic>
-#include <map>
-
-#include "messaging/messaging.h"
-#include "visionipc/visionipc.h"
-#include "visionipc/visionbuf.h"
-
-std::string get_endpoint_name(std::string name, VisionStreamType type);
-
-class VisionIpcServer {
- private:
-  cl_device_id device_id = nullptr;
-  cl_context ctx = nullptr;
-  uint64_t server_id;
-
-  std::atomic<bool> should_exit = false;
-  std::string name;
-  std::thread listener_thread;
-
-  std::map<VisionStreamType, std::atomic<size_t> > cur_idx;
-  std::map<VisionStreamType, std::vector<VisionBuf*> > buffers;
-  std::map<VisionStreamType, std::map<VisionBuf*, size_t> > idxs;
-
-  Context * msg_ctx;
-  std::map<VisionStreamType, PubSocket*> sockets;
-
-  void listener(void);
-
- public:
-  VisionIpcServer(std::string name, cl_device_id device_id=nullptr, cl_context ctx=nullptr);
-  ~VisionIpcServer();
-
-  VisionBuf * get_buffer(VisionStreamType type);
-
-  void create_buffers(VisionStreamType type, size_t num_buffers, bool rgb, size_t width, size_t height);
-  void create_buffers_with_sizes(VisionStreamType type, size_t num_buffers, bool rgb, size_t width, size_t height, size_t size, size_t stride, size_t uv_offset);
-  void send(VisionBuf * buf, VisionIpcBufExtra * extra, bool sync=true);
-  void start_listener();
-};

common/SConscript

@@ -1,33 +0,0 @@
-Import('env', 'envCython', 'arch', 'SHARED')
-
-if SHARED:
-  fxn = env.SharedLibrary
-else:
-  fxn = env.Library
-
-common_libs = [
-  'params.cc',
-  'statlog.cc',
-  'swaglog.cc',
-  'util.cc',
-  'gpio.cc',
-  'i2c.cc',
-  'watchdog.cc',
-]
-
-_common = fxn('common', common_libs, LIBS="json11")
-
-files = [
-  'clutil.cc',
-]
-
-_gpucommon = fxn('gpucommon', files)
-Export('_common', '_gpucommon')
-
-if GetOption('test'):
-  env.Program('tests/test_util', ['tests/test_util.cc'], LIBS=[_common])
-  env.Program('tests/test_swaglog', ['tests/test_swaglog.cc'], LIBS=[_common, 'json11', 'zmq', 'pthread'])
-
-# Cython
-envCython.Program('clock.so', 'clock.pyx')
-envCython.Program('params_pyx.so', 'params_pyx.pyx', LIBS=envCython['LIBS'] + [_common, 'zmq', 'json11'])

common/api/__init__.py

@@ -1,46 +1,26 @@
-import jwt
-import os
-import requests
-from datetime import datetime, timedelta
-from common.basedir import PERSIST
-from system.version import get_version
+from openpilot.common.api.comma_connect import CommaConnectApi
 
-API_HOST = os.getenv('API_HOST', 'https://api.commadotai.com')
 
-class Api():
+class Api:
   def __init__(self, dongle_id):
-    self.dongle_id = dongle_id
-    with open(PERSIST+'/comma/id_rsa') as f:
-      self.private_key = f.read()
+    self.service = CommaConnectApi(dongle_id)
+
+  def request(self, method, endpoint, **params):
+    return self.service.request(method, endpoint, **params)
 
   def get(self, *args, **kwargs):
-    return self.request('GET', *args, **kwargs)
+    return self.service.get(*args, **kwargs)
 
   def post(self, *args, **kwargs):
-    return self.request('POST', *args, **kwargs)
+    return self.service.post(*args, **kwargs)
 
-  def request(self, method, endpoint, timeout=None, access_token=None, **params):
-    return api_get(endpoint, method=method, timeout=timeout, access_token=access_token, **params)
-
-  def get_token(self, expiry_hours=1):
-    now = datetime.utcnow()
-    payload = {
-      'identity': self.dongle_id,
-      'nbf': now,
-      'iat': now,
-      'exp': now + timedelta(hours=expiry_hours)
-    }
-    token = jwt.encode(payload, self.private_key, algorithm='RS256')
-    if isinstance(token, bytes):
-      token = token.decode('utf8')
-    return token
+  def get_token(self, payload_extra=None, expiry_hours=1):
+    return self.service.get_token(payload_extra, expiry_hours)
 
 
 def api_get(endpoint, method='GET', timeout=None, access_token=None, **params):
-  headers = {}
-  if access_token is not None:
-    headers['Authorization'] = "JWT " + access_token
+  return CommaConnectApi(None).api_get(endpoint, method, timeout, access_token, **params)
 
-  headers['User-Agent'] = "openpilot-" + get_version()
 
-  return requests.request(method, API_HOST + "/" + endpoint, timeout=timeout, headers=headers, params=params)
+def get_key_pair() -> tuple[str, str, str] | tuple[None, None, None]:
+  return CommaConnectApi(None).get_key_pair()

common/api/base.py

@@ -0,0 +1,70 @@
+import jwt
+import os
+import requests
+import unicodedata
+from datetime import datetime, timedelta, UTC
+from openpilot.system.hardware.hw import Paths
+from openpilot.system.version import get_version
+
+# name: jwt signature algorithm
+KEYS = {"id_rsa": "RS256",
+        "id_ecdsa": "ES256"}
+
+
+class BaseApi:
+  def __init__(self, dongle_id, api_host, user_agent="openpilot-"):
+    self.dongle_id = dongle_id
+    self.api_host = api_host
+    self.user_agent = user_agent
+    self.jwt_algorithm, self.private_key, _ = self.get_key_pair()
+
+  def get(self, *args, **kwargs):
+    return self.request('GET', *args, **kwargs)
+
+  def post(self, *args, **kwargs):
+    return self.request('POST', *args, **kwargs)
+
+  def request(self, method, endpoint, timeout=None, access_token=None, **params):
+    return self.api_get(endpoint, method=method, timeout=timeout, access_token=access_token, **params)
+
+  def _get_token(self, payload_extra=None, expiry_hours=1, **extra_payload):
+    now = datetime.now(UTC).replace(tzinfo=None)
+    payload = {
+      'identity': self.dongle_id,
+      'nbf': now,
+      'iat': now,
+      'exp': now + timedelta(hours=expiry_hours),
+      **extra_payload
+    }
+    if payload_extra is not None:
+      payload.update(payload_extra)
+    token = jwt.encode(payload, self.private_key, algorithm=self.jwt_algorithm)
+    if isinstance(token, bytes):
+      token = token.decode('utf8')
+    return token
+
+  def get_token(self, payload_extra=None, expiry_hours=1):
+    return self._get_token(payload_extra, expiry_hours)
+
+  def remove_non_ascii_chars(self, text):
+    normalized_text = unicodedata.normalize('NFD', text)
+    ascii_encoded_text = normalized_text.encode('ascii', 'ignore')
+    return ascii_encoded_text.decode()
+
+  def api_get(self, endpoint, method='GET', timeout=None, access_token=None, json=None, **params):
+    headers = {}
+    if access_token is not None:
+      headers['Authorization'] = "JWT " + access_token
+
+    version = self.remove_non_ascii_chars(get_version())
+    headers['User-Agent'] = self.user_agent + version
+
+    return requests.request(method, f"{self.api_host}/{endpoint}", timeout=timeout, headers=headers, json=json, params=params)
+
+  @staticmethod
+  def get_key_pair() -> tuple[str, str, str] | tuple[None, None, None]:
+    for key in KEYS:
+      if os.path.isfile(Paths.persist_root() + f'/comma/{key}') and os.path.isfile(Paths.persist_root() + f'/comma/{key}.pub'):
+        with open(Paths.persist_root() + f'/comma/{key}') as private, open(Paths.persist_root() + f'/comma/{key}.pub') as public:
+          return KEYS[key], private.read(), public.read()
+    return None, None, None

common/api/comma_connect.py

@@ -0,0 +1,11 @@
+import os
+
+from openpilot.common.api.base import BaseApi
+
+API_HOST = os.getenv('API_HOST', 'https://api.commadotai.com')
+
+
+class CommaConnectApi(BaseApi):
+  def __init__(self, dongle_id):
+    super().__init__(dongle_id, API_HOST)
+    self.user_agent = "openpilot-"

common/basedir.py

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

common/clock.pyx

@@ -1,24 +0,0 @@
-# distutils: language = c++
-# cython: language_level = 3
-from posix.time cimport clock_gettime, timespec, CLOCK_MONOTONIC_RAW, clockid_t
-
-IF UNAME_SYSNAME == "Darwin":
-  # Darwin doesn't have a CLOCK_BOOTTIME
-  CLOCK_BOOTTIME = CLOCK_MONOTONIC_RAW
-ELSE:
-  from posix.time cimport CLOCK_BOOTTIME
-
-cdef double readclock(clockid_t clock_id):
-  cdef timespec ts
-  cdef double current
-
-  clock_gettime(clock_id, &ts)
-  current = ts.tv_sec + (ts.tv_nsec / 1000000000.)
-  return current
-
-def monotonic_time():
-  return readclock(CLOCK_MONOTONIC_RAW)
-
-def sec_since_boot():
-  return readclock(CLOCK_BOOTTIME)
-

common/clutil.cc

@@ -5,6 +5,7 @@
 #include <memory>
 
 #include "common/util.h"
+#include "common/swaglog.h"
 
 namespace {  // helper functions
 
@@ -31,14 +32,14 @@ void cl_print_info(cl_platform_id platform, cl_device_id device) {
     case CL_DEVICE_TYPE_ACCELERATOR: type_str = "CL_DEVICE_TYPE_ACCELERATOR"; break;
   }
 
-  std::cout << "vendor: " << get_platform_info(platform, CL_PLATFORM_VENDOR) << std::endl
-            << "platform version: " << get_platform_info(platform, CL_PLATFORM_VERSION) << std::endl
-            << "profile: " << get_platform_info(platform, CL_PLATFORM_PROFILE) << std::endl
-            << "extensions: " << get_platform_info(platform, CL_PLATFORM_EXTENSIONS) << std::endl
-            << "name :" << get_device_info(device, CL_DEVICE_NAME) << std::endl
-            << "device version :" << get_device_info(device, CL_DEVICE_VERSION) << std::endl
-            << "max work group size :" << work_group_size << std::endl
-            << "type = " << device_type << " = " << type_str << std::endl;
+  LOGD("vendor: %s", get_platform_info(platform, CL_PLATFORM_VENDOR).c_str());
+  LOGD("platform version: %s", get_platform_info(platform, CL_PLATFORM_VERSION).c_str());
+  LOGD("profile: %s", get_platform_info(platform, CL_PLATFORM_PROFILE).c_str());
+  LOGD("extensions: %s", get_platform_info(platform, CL_PLATFORM_EXTENSIONS).c_str());
+  LOGD("name: %s", get_device_info(device, CL_DEVICE_NAME).c_str());
+  LOGD("device version: %s", get_device_info(device, CL_DEVICE_VERSION).c_str());
+  LOGD("max work group size: %zu", work_group_size);
+  LOGD("type = %d, %s", (int)device_type, type_str);
 }
 
 void cl_print_build_errors(cl_program program, cl_device_id device) {
@@ -49,7 +50,7 @@ void cl_print_build_errors(cl_program program, cl_device_id device) {
   std::string log(log_size, '\0');
   clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, log_size, &log[0], NULL);
 
-  std::cout << "build failed; status=" << status << ", log:" << std::endl << log << std::endl;
+  LOGE("build failed; status=%d, log: %s", status, log.c_str());
 }
 
 }  // namespace
@@ -61,133 +62,37 @@ cl_device_id cl_get_device_id(cl_device_type device_type) {
   CL_CHECK(clGetPlatformIDs(num_platforms, &platform_ids[0], NULL));
 
   for (size_t i = 0; i < num_platforms; ++i) {
-    std::cout << "platform[" << i << "] CL_PLATFORM_NAME: " << get_platform_info(platform_ids[i], CL_PLATFORM_NAME) << std::endl;
+    LOGD("platform[%zu] CL_PLATFORM_NAME: %s", i, get_platform_info(platform_ids[i], CL_PLATFORM_NAME).c_str());
+
     // Get first device
     if (cl_device_id device_id = NULL; clGetDeviceIDs(platform_ids[i], device_type, 1, &device_id, NULL) == 0 && device_id) {
       cl_print_info(platform_ids[i], device_id);
       return device_id;
     }
   }
-  std::cout << "No valid openCL platform found" << std::endl;
+  LOGE("No valid openCL platform found");
   assert(0);
   return nullptr;
 }
 
+cl_context cl_create_context(cl_device_id device_id) {
+  return CL_CHECK_ERR(clCreateContext(NULL, 1, &device_id, NULL, NULL, &err));
+}
+
+void cl_release_context(cl_context context) {
+  clReleaseContext(context);
+}
+
 cl_program cl_program_from_file(cl_context ctx, cl_device_id device_id, const char* path, const char* args) {
   return cl_program_from_source(ctx, device_id, util::read_file(path), args);
 }
 
 cl_program cl_program_from_source(cl_context ctx, cl_device_id device_id, const std::string& src, const char* args) {
-  cl_program prg = CL_CHECK_ERR(clCreateProgramWithSource(ctx, 1, (const char*[]){src.c_str()}, NULL, &err));
+  const char *csrc = src.c_str();
+  cl_program prg = CL_CHECK_ERR(clCreateProgramWithSource(ctx, 1, &csrc, NULL, &err));
   if (int err = clBuildProgram(prg, 1, &device_id, args, NULL, NULL); err != 0) {
     cl_print_build_errors(prg, device_id);
     assert(0);
   }
   return prg;
 }
-
-cl_program cl_program_from_binary(cl_context ctx, cl_device_id device_id, const uint8_t* binary, size_t length, const char* args) {
-  cl_program prg = CL_CHECK_ERR(clCreateProgramWithBinary(ctx, 1, &device_id, &length, (const uint8_t*[]){binary}, NULL, &err));
-  if (int err = clBuildProgram(prg, 1, &device_id, args, NULL, NULL); err != 0) {
-    cl_print_build_errors(prg, device_id);
-    assert(0);
-  }
-  return prg;
-}
-
-// Given a cl code and return a string representation
-#define CL_ERR_TO_STR(err) case err: return #err
-const char* cl_get_error_string(int err) {
-  switch (err) {
-    CL_ERR_TO_STR(CL_SUCCESS);
-    CL_ERR_TO_STR(CL_DEVICE_NOT_FOUND);
-    CL_ERR_TO_STR(CL_DEVICE_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_COMPILER_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_MEM_OBJECT_ALLOCATION_FAILURE);
-    CL_ERR_TO_STR(CL_OUT_OF_RESOURCES);
-    CL_ERR_TO_STR(CL_OUT_OF_HOST_MEMORY);
-    CL_ERR_TO_STR(CL_PROFILING_INFO_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_MEM_COPY_OVERLAP);
-    CL_ERR_TO_STR(CL_IMAGE_FORMAT_MISMATCH);
-    CL_ERR_TO_STR(CL_IMAGE_FORMAT_NOT_SUPPORTED);
-    CL_ERR_TO_STR(CL_MAP_FAILURE);
-    CL_ERR_TO_STR(CL_MISALIGNED_SUB_BUFFER_OFFSET);
-    CL_ERR_TO_STR(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST);
-    CL_ERR_TO_STR(CL_COMPILE_PROGRAM_FAILURE);
-    CL_ERR_TO_STR(CL_LINKER_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_LINK_PROGRAM_FAILURE);
-    CL_ERR_TO_STR(CL_DEVICE_PARTITION_FAILED);
-    CL_ERR_TO_STR(CL_KERNEL_ARG_INFO_NOT_AVAILABLE);
-    CL_ERR_TO_STR(CL_INVALID_VALUE);
-    CL_ERR_TO_STR(CL_INVALID_DEVICE_TYPE);
-    CL_ERR_TO_STR(CL_INVALID_PLATFORM);
-    CL_ERR_TO_STR(CL_INVALID_DEVICE);
-    CL_ERR_TO_STR(CL_INVALID_CONTEXT);
-    CL_ERR_TO_STR(CL_INVALID_QUEUE_PROPERTIES);
-    CL_ERR_TO_STR(CL_INVALID_COMMAND_QUEUE);
-    CL_ERR_TO_STR(CL_INVALID_HOST_PTR);
-    CL_ERR_TO_STR(CL_INVALID_MEM_OBJECT);
-    CL_ERR_TO_STR(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);
-    CL_ERR_TO_STR(CL_INVALID_IMAGE_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_SAMPLER);
-    CL_ERR_TO_STR(CL_INVALID_BINARY);
-    CL_ERR_TO_STR(CL_INVALID_BUILD_OPTIONS);
-    CL_ERR_TO_STR(CL_INVALID_PROGRAM);
-    CL_ERR_TO_STR(CL_INVALID_PROGRAM_EXECUTABLE);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL_NAME);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL_DEFINITION);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL);
-    CL_ERR_TO_STR(CL_INVALID_ARG_INDEX);
-    CL_ERR_TO_STR(CL_INVALID_ARG_VALUE);
-    CL_ERR_TO_STR(CL_INVALID_ARG_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_KERNEL_ARGS);
-    CL_ERR_TO_STR(CL_INVALID_WORK_DIMENSION);
-    CL_ERR_TO_STR(CL_INVALID_WORK_GROUP_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_WORK_ITEM_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_GLOBAL_OFFSET);
-    CL_ERR_TO_STR(CL_INVALID_EVENT_WAIT_LIST);
-    CL_ERR_TO_STR(CL_INVALID_EVENT);
-    CL_ERR_TO_STR(CL_INVALID_OPERATION);
-    CL_ERR_TO_STR(CL_INVALID_GL_OBJECT);
-    CL_ERR_TO_STR(CL_INVALID_BUFFER_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_MIP_LEVEL);
-    CL_ERR_TO_STR(CL_INVALID_GLOBAL_WORK_SIZE);
-    CL_ERR_TO_STR(CL_INVALID_PROPERTY);
-    CL_ERR_TO_STR(CL_INVALID_IMAGE_DESCRIPTOR);
-    CL_ERR_TO_STR(CL_INVALID_COMPILER_OPTIONS);
-    CL_ERR_TO_STR(CL_INVALID_LINKER_OPTIONS);
-    CL_ERR_TO_STR(CL_INVALID_DEVICE_PARTITION_COUNT);
-    case -69: return "CL_INVALID_PIPE_SIZE";
-    case -70: return "CL_INVALID_DEVICE_QUEUE";
-    case -71: return "CL_INVALID_SPEC_ID";
-    case -72: return "CL_MAX_SIZE_RESTRICTION_EXCEEDED";
-    case -1002: return "CL_INVALID_D3D10_DEVICE_KHR";
-    case -1003: return "CL_INVALID_D3D10_RESOURCE_KHR";
-    case -1004: return "CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR";
-    case -1005: return "CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR";
-    case -1006: return "CL_INVALID_D3D11_DEVICE_KHR";
-    case -1007: return "CL_INVALID_D3D11_RESOURCE_KHR";
-    case -1008: return "CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR";
-    case -1009: return "CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR";
-    case -1010: return "CL_INVALID_DX9_MEDIA_ADAPTER_KHR";
-    case -1011: return "CL_INVALID_DX9_MEDIA_SURFACE_KHR";
-    case -1012: return "CL_DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR";
-    case -1013: return "CL_DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR";
-    case -1093: return "CL_INVALID_EGL_OBJECT_KHR";
-    case -1092: return "CL_EGL_RESOURCE_NOT_ACQUIRED_KHR";
-    case -1001: return "CL_PLATFORM_NOT_FOUND_KHR";
-    case -1057: return "CL_DEVICE_PARTITION_FAILED_EXT";
-    case -1058: return "CL_INVALID_PARTITION_COUNT_EXT";
-    case -1059: return "CL_INVALID_PARTITION_NAME_EXT";
-    case -1094: return "CL_INVALID_ACCELERATOR_INTEL";
-    case -1095: return "CL_INVALID_ACCELERATOR_TYPE_INTEL";
-    case -1096: return "CL_INVALID_ACCELERATOR_DESCRIPTOR_INTEL";
-    case -1097: return "CL_ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL";
-    case -1000: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
-    case -1098: return "CL_INVALID_VA_API_MEDIA_ADAPTER_INTEL";
-    case -1099: return "CL_INVALID_VA_API_MEDIA_SURFACE_INTEL";
-    case -1100: return "CL_VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL";
-    case -1101: return "CL_VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL";
-    default: return "CL_UNKNOWN_ERROR";
-  }
-}

common/clutil.h

@@ -22,7 +22,7 @@
   })
 
 cl_device_id cl_get_device_id(cl_device_type device_type);
+cl_context cl_create_context(cl_device_id device_id);
+void cl_release_context(cl_context context);
 cl_program cl_program_from_source(cl_context ctx, cl_device_id device_id, const std::string& src, const char* args = nullptr);
-cl_program cl_program_from_binary(cl_context ctx, cl_device_id device_id, const uint8_t* binary, size_t length, const char* args = nullptr);
 cl_program cl_program_from_file(cl_context ctx, cl_device_id device_id, const char* path, const char* args);
-const char* cl_get_error_string(int err);

common/constants.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+# conversions
+class CV:
+  # 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
+
+
+ACCELERATION_DUE_TO_GRAVITY = 9.81  # m/s^2

common/dict_helpers.py

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

common/ffi_wrapper.py

@@ -1,55 +0,0 @@
-import os
-import sys
-import fcntl
-import hashlib
-import platform
-from cffi import FFI
-
-def suffix():
-  if platform.system() == "Darwin":
-    return ".dylib"
-  else:
-    return ".so"
-
-def ffi_wrap(name, c_code, c_header, tmpdir="/tmp/ccache", cflags="", libraries=None):
-  if libraries is None:
-    libraries = []
-
-  cache = name + "_" + hashlib.sha1(c_code.encode('utf-8')).hexdigest()
-  try:
-    os.mkdir(tmpdir)
-  except OSError:
-    pass
-
-  fd = os.open(tmpdir, 0)
-  fcntl.flock(fd, fcntl.LOCK_EX)
-  try:
-    sys.path.append(tmpdir)
-    try:
-      mod = __import__(cache)
-    except Exception:
-      print(f"cache miss {cache}")
-      compile_code(cache, c_code, c_header, tmpdir, cflags, libraries)
-      mod = __import__(cache)
-  finally:
-    os.close(fd)
-
-  return mod.ffi, mod.lib
-
-
-def compile_code(name, c_code, c_header, directory, cflags="", libraries=None):
-  if libraries is None:
-    libraries = []
-
-  ffibuilder = FFI()
-  ffibuilder.set_source(name, c_code, source_extension='.cpp', libraries=libraries)
-  ffibuilder.cdef(c_header)
-  os.environ['OPT'] = "-fwrapv -O2 -DNDEBUG -std=c++1z"
-  os.environ['CFLAGS'] = cflags
-  ffibuilder.compile(verbose=True, debug=False, tmpdir=directory)
-
-
-def wrap_compiled(name, directory):
-  sys.path.append(directory)
-  mod = __import__(name)
-  return mod.ffi, mod.lib

common/file_helpers.py

@@ -1,99 +0,0 @@
-import os
-import shutil
-import tempfile
-from atomicwrites import AtomicWriter
-
-
-def mkdirs_exists_ok(path):
-  if path.startswith('http://') or path.startswith('https://'):
-    raise ValueError('URL path')
-  try:
-    os.makedirs(path)
-  except OSError:
-    if not os.path.isdir(path):
-      raise
-
-
-def rm_not_exists_ok(path):
-  try:
-    os.remove(path)
-  except OSError:
-    if os.path.exists(path):
-      raise
-
-
-def rm_tree_or_link(path):
-  if os.path.islink(path):
-    os.unlink(path)
-  elif os.path.isdir(path):
-    shutil.rmtree(path)
-
-
-def get_tmpdir_on_same_filesystem(path):
-  normpath = os.path.normpath(path)
-  parts = normpath.split("/")
-  if len(parts) > 1 and parts[1] == "scratch":
-    return "/scratch/tmp"
-  elif len(parts) > 2 and parts[2] == "runner":
-    return f"/{parts[1]}/runner/tmp"
-  return "/tmp"
-
-
-class NamedTemporaryDir():
-  def __init__(self, temp_dir=None):
-    self._path = tempfile.mkdtemp(dir=temp_dir)
-
-  @property
-  def name(self):
-    return self._path
-
-  def close(self):
-    shutil.rmtree(self._path)
-
-  def __enter__(self):
-    return self
-
-  def __exit__(self, exc_type, exc_value, traceback):
-    self.close()
-
-
-class CallbackReader:
-  """Wraps a file, but overrides the read method to also
-  call a callback function with the number of bytes read so far."""
-  def __init__(self, f, callback, *args):
-    self.f = f
-    self.callback = callback
-    self.cb_args = args
-    self.total_read = 0
-
-  def __getattr__(self, attr):
-    return getattr(self.f, attr)
-
-  def read(self, *args, **kwargs):
-    chunk = self.f.read(*args, **kwargs)
-    self.total_read += len(chunk)
-    self.callback(*self.cb_args, self.total_read)
-    return chunk
-
-
-def _get_fileobject_func(writer, temp_dir):
-  def _get_fileobject():
-    return writer.get_fileobject(dir=temp_dir)
-  return _get_fileobject
-
-def atomic_write_on_fs_tmp(path, **kwargs):
-  """Creates an atomic writer using a temporary file in a temporary directory
-     on the same filesystem as path.
-  """
-  # TODO(mgraczyk): This use of AtomicWriter relies on implementation details to set the temp
-  #                 directory.
-  writer = AtomicWriter(path, **kwargs)
-  return writer._open(_get_fileobject_func(writer, get_tmpdir_on_same_filesystem(path)))
-
-
-def atomic_write_in_dir(path, **kwargs):
-  """Creates an atomic writer using a temporary file in the same directory
-     as the destination file.
-  """
-  writer = AtomicWriter(path, **kwargs)
-  return writer._open(_get_fileobject_func(writer, os.path.dirname(path)))

common/filter_simple.py

@@ -1,5 +1,4 @@
 class FirstOrderFilter:
-  # first order filter
   def __init__(self, x0, rc, dt, initialized=True):
     self.x = x0
     self.dt = dt
@@ -16,3 +15,20 @@ class FirstOrderFilter:
       self.initialized = True
       self.x = x
     return self.x
+
+
+class BounceFilter(FirstOrderFilter):
+  def __init__(self, x0, rc, dt, initialized=True, bounce=2):
+    self.velocity = FirstOrderFilter(0.0, 0.15, dt)
+    self.bounce = bounce
+    super().__init__(x0, rc, dt, initialized)
+
+  def update(self, x):
+    super().update(x)
+    scale = self.dt / (1.0 / 60.0)  # tuned at 60 fps
+    self.velocity.x += (x - self.x) * self.bounce * scale * self.dt
+    self.velocity.update(0.0)
+    if abs(self.velocity.x) < 1e-5:
+      self.velocity.x = 0.0
+    self.x += self.velocity.x
+    return self.x

common/git.py

@@ -0,0 +1,42 @@
+from functools import cache
+import subprocess
+from openpilot.common.utils import run_cmd, run_cmd_default
+
+
+@cache
+def get_commit(cwd: str = None, branch: str = "HEAD") -> str:
+  return run_cmd_default(["git", "rev-parse", branch], cwd=cwd)
+
+
+@cache
+def get_commit_date(cwd: str = None, commit: str = "HEAD") -> str:
+  return run_cmd_default(["git", "show", "--no-patch", "--format='%ct %ci'", commit], cwd=cwd)
+
+
+@cache
+def get_short_branch(cwd: str = None) -> str:
+  return run_cmd_default(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
+
+
+@cache
+def get_branch(cwd: str = None) -> str:
+  return run_cmd_default(["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd=cwd)
+
+
+@cache
+def get_origin(cwd: str = None) -> str:
+  try:
+    local_branch = run_cmd(["git", "name-rev", "--name-only", "HEAD"], cwd=cwd)
+    tracking_remote = run_cmd(["git", "config", "branch." + local_branch + ".remote"], cwd=cwd)
+    return run_cmd(["git", "config", "remote." + tracking_remote + ".url"], cwd=cwd)
+  except subprocess.CalledProcessError:  # Not on a branch, fallback
+    return run_cmd_default(["git", "config", "--get", "remote.origin.url"], cwd=cwd)
+
+
+@cache
+def get_normalized_origin(cwd: str = None) -> str:
+  return get_origin(cwd) \
+    .replace("git@", "", 1) \
+    .replace(".git", "", 1) \
+    .replace("https://", "", 1) \
+    .replace(":", "/", 1)

common/gpio.cc

@@ -1,32 +0,0 @@
-#include "common/gpio.h"
-
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <cstring>
-
-#include "common/util.h"
-
-// We assume that all pins have already been exported on boot,
-// and that we have permission to write to them.
-
-int gpio_init(int pin_nr, bool output) {
-  char pin_dir_path[50];
-  int pin_dir_path_len = snprintf(pin_dir_path, sizeof(pin_dir_path),
-                           "/sys/class/gpio/gpio%d/direction", pin_nr);
-  if(pin_dir_path_len <= 0) {
-    return -1;
-  }
-  const char *value = output ? "out" : "in";
-  return util::write_file(pin_dir_path, (void*)value, strlen(value));
-}
-
-int gpio_set(int pin_nr, bool high) {
-  char pin_val_path[50];
-  int pin_val_path_len = snprintf(pin_val_path, sizeof(pin_val_path),
-                           "/sys/class/gpio/gpio%d/value", pin_nr);
-  if(pin_val_path_len <= 0) {
-    return -1;
-  }
-  return util::write_file(pin_val_path, (void*)(high ? "1" : "0"), 1);
-}

common/gpio.h

@@ -1,21 +0,0 @@
-#pragma once
-
-// Pin definitions
-#ifdef QCOM2
-  #define GPIO_HUB_RST_N        30
-  #define GPIO_UBLOX_RST_N      32
-  #define GPIO_UBLOX_SAFEBOOT_N 33
-  #define GPIO_UBLOX_PWR_EN     34
-  #define GPIO_STM_RST_N        124
-  #define GPIO_STM_BOOT0        134
-#else
-  #define GPIO_HUB_RST_N        0
-  #define GPIO_UBLOX_RST_N      0
-  #define GPIO_UBLOX_SAFEBOOT_N 0
-  #define GPIO_UBLOX_PWR_EN     0
-  #define GPIO_STM_RST_N        0
-  #define GPIO_STM_BOOT0        0
-#endif
-
-int gpio_init(int pin_nr, bool output);
-int gpio_set(int pin_nr, bool high);

common/gpio.py

@@ -1,3 +1,8 @@
+import os
+import fcntl
+import ctypes
+from functools import cache
+
 def gpio_init(pin: int, output: bool) -> None:
   try:
     with open(f"/sys/class/gpio/gpio{pin}/direction", 'wb') as f:
@@ -5,10 +10,80 @@ def gpio_init(pin: int, output: bool) -> None:
   except Exception as e:
     print(f"Failed to set gpio {pin} direction: {e}")
 
-
 def gpio_set(pin: int, high: bool) -> None:
   try:
     with open(f"/sys/class/gpio/gpio{pin}/value", 'wb') as f:
       f.write(b"1" if high else b"0")
   except Exception as e:
     print(f"Failed to set gpio {pin} value: {e}")
+
+def gpio_read(pin: int) -> bool | None:
+  val = None
+  try:
+    with open(f"/sys/class/gpio/gpio{pin}/value", 'rb') as f:
+      val = bool(int(f.read().strip()))
+  except Exception as e:
+    print(f"Failed to set gpio {pin} value: {e}")
+
+  return val
+
+def gpio_export(pin: int) -> None:
+  if os.path.isdir(f"/sys/class/gpio/gpio{pin}"):
+    return
+
+  try:
+    with open("/sys/class/gpio/export", 'w') as f:
+      f.write(str(pin))
+  except Exception:
+    print(f"Failed to export gpio {pin}")
+
+@cache
+def get_irq_action(irq: int) -> list[str]:
+  try:
+    with open(f"/sys/kernel/irq/{irq}/actions") as f:
+      actions = f.read().strip().split(',')
+      return actions
+  except FileNotFoundError:
+    return []
+
+def get_irqs_for_action(action: str) -> list[str]:
+  ret = []
+  with open("/proc/interrupts") as f:
+    for l in f.readlines():
+      irq = l.split(':')[0].strip()
+      if irq.isdigit() and action in get_irq_action(irq):
+        ret.append(irq)
+  return ret
+
+# *** gpiochip ***
+
+class gpioevent_data(ctypes.Structure):
+  _fields_ = [
+    ("timestamp", ctypes.c_uint64),
+    ("id", ctypes.c_uint32),
+  ]
+
+class gpioevent_request(ctypes.Structure):
+  _fields_ = [
+    ("lineoffset", ctypes.c_uint32),
+    ("handleflags", ctypes.c_uint32),
+    ("eventflags", ctypes.c_uint32),
+    ("label", ctypes.c_char * 32),
+    ("fd", ctypes.c_int)
+  ]
+
+def gpiochip_get_ro_value_fd(label: str, gpiochip_id: int, pin: int) -> int:
+  GPIOEVENT_REQUEST_BOTH_EDGES = 0x3
+  GPIOHANDLE_REQUEST_INPUT = 0x1
+  GPIO_GET_LINEEVENT_IOCTL = 0xc030b404
+
+  rq = gpioevent_request()
+  rq.lineoffset = pin
+  rq.handleflags = GPIOHANDLE_REQUEST_INPUT
+  rq.eventflags = GPIOEVENT_REQUEST_BOTH_EDGES
+  rq.label = label.encode('utf-8')[:31] + b'\0'
+
+  fd = os.open(f"/dev/gpiochip{gpiochip_id}", os.O_RDONLY)
+  fcntl.ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, rq)
+  os.close(fd)
+  return int(rq.fd)

common/gps.py

@@ -0,0 +1,8 @@
+from openpilot.common.params import Params
+
+
+def get_gps_location_service(params: Params) -> str:
+  if params.get_bool("UbloxAvailable"):
+    return "gpsLocationExternal"
+  else:
+    return "gpsLocation"

common/i2c.cc

@@ -1,87 +0,0 @@
-#include "common/i2c.h"
-
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <unistd.h>
-
-#include <cassert>
-#include <cstdio>
-#include <stdexcept>
-
-#include "common/util.h"
-#include "common/swaglog.h"
-#include "common/util.h"
-
-#define UNUSED(x) (void)(x)
-
-#ifdef QCOM2
-// TODO: decide if we want to isntall libi2c-dev everywhere
-extern "C" {
-  #include <linux/i2c-dev.h>
-  #include <i2c/smbus.h>
-}
-
-I2CBus::I2CBus(uint8_t bus_id) {
-  char bus_name[20];
-  snprintf(bus_name, 20, "/dev/i2c-%d", bus_id);
-
-  i2c_fd = HANDLE_EINTR(open(bus_name, O_RDWR));
-  if(i2c_fd < 0) {
-    throw std::runtime_error("Failed to open I2C bus");
-  }
-}
-
-I2CBus::~I2CBus() {
-  if(i2c_fd >= 0) { close(i2c_fd); }
-}
-
-int I2CBus::read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len) {
-  int ret = 0;
-
-  ret = HANDLE_EINTR(ioctl(i2c_fd, I2C_SLAVE, device_address));
-  if(ret < 0) { goto fail; }
-
-  ret = i2c_smbus_read_i2c_block_data(i2c_fd, register_address, len, buffer);
-  if((ret < 0) || (ret != len)) { goto fail; }
-
-fail:
-  return ret;
-}
-
-int I2CBus::set_register(uint8_t device_address, uint register_address, uint8_t data) {
-  int ret = 0;
-
-  ret = HANDLE_EINTR(ioctl(i2c_fd, I2C_SLAVE, device_address));
-  if(ret < 0) { goto fail; }
-
-  ret = i2c_smbus_write_byte_data(i2c_fd, register_address, data);
-  if(ret < 0) { goto fail; }
-
-fail:
-  return ret;
-}
-
-#else
-
-I2CBus::I2CBus(uint8_t bus_id) {
-  UNUSED(bus_id);
-  i2c_fd = -1;
-}
-
-I2CBus::~I2CBus() {}
-
-int I2CBus::read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len) {
-  UNUSED(device_address);
-  UNUSED(register_address);
-  UNUSED(buffer);
-  UNUSED(len);
-  return -1;
-}
-
-int I2CBus::set_register(uint8_t device_address, uint register_address, uint8_t data) {
-  UNUSED(device_address);
-  UNUSED(register_address);
-  UNUSED(data);
-  return -1;
-}
-#endif

common/i2c.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-#include <sys/types.h>
-
-class I2CBus {
-  private:
-    int i2c_fd;
-
-  public:
-    I2CBus(uint8_t bus_id);
-    ~I2CBus();
-
-    int read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len);
-    int set_register(uint8_t device_address, uint register_address, uint8_t data);
-};

common/kalman/.gitignore

@@ -1 +0,0 @@
-simple_kalman_impl.c

common/kalman/SConscript

@@ -1,3 +0,0 @@
-Import('envCython')
-
-envCython.Program('simple_kalman_impl.so', 'simple_kalman_impl.pyx')

common/kalman/simple_kalman.py

@@ -1,3 +0,0 @@
-# pylint: skip-file
-from common.kalman.simple_kalman_impl import KF1D as KF1D
-assert KF1D

common/kalman/simple_kalman_impl.pxd

@@ -1,18 +0,0 @@
-# cython: language_level = 3
-
-cdef class KF1D:
-  cdef public:
-    double x0_0
-    double x1_0
-    double K0_0
-    double K1_0
-    double A0_0
-    double A0_1
-    double A1_0
-    double A1_1
-    double C0_0
-    double C0_1
-    double A_K_0
-    double A_K_1
-    double A_K_2
-    double A_K_3

common/kalman/simple_kalman_impl.pyx

@@ -1,37 +0,0 @@
-# distutils: language = c++
-# cython: language_level=3
-
-cdef class KF1D:
-  def __init__(self, x0, A, C, K):
-    self.x0_0 = x0[0][0]
-    self.x1_0 = x0[1][0]
-    self.A0_0 = A[0][0]
-    self.A0_1 = A[0][1]
-    self.A1_0 = A[1][0]
-    self.A1_1 = A[1][1]
-    self.C0_0 = C[0]
-    self.C0_1 = C[1]
-    self.K0_0 = K[0][0]
-    self.K1_0 = K[1][0]
-
-    self.A_K_0 = self.A0_0 - self.K0_0 * self.C0_0
-    self.A_K_1 = self.A0_1 - self.K0_0 * self.C0_1
-    self.A_K_2 = self.A1_0 - self.K1_0 * self.C0_0
-    self.A_K_3 = self.A1_1 - self.K1_0 * self.C0_1
-
-  def update(self, meas):
-    cdef double x0_0 = self.A_K_0 * self.x0_0 + self.A_K_1 * self.x1_0 + self.K0_0 * meas
-    cdef double x1_0 = self.A_K_2 * self.x0_0 + self.A_K_3 * self.x1_0 + self.K1_0 * meas
-    self.x0_0 = x0_0
-    self.x1_0 = x1_0
-
-    return [self.x0_0, self.x1_0]
-
-  @property
-  def x(self):
-    return [[self.x0_0], [self.x1_0]]
-
-  @x.setter
-  def x(self, x):
-    self.x0_0 = x[0][0]
-    self.x1_0 = x[1][0]

common/kalman/simple_kalman_old.py

@@ -1,23 +0,0 @@
-import numpy as np
-
-
-class KF1D:
-  # this EKF assumes constant covariance matrix, so calculations are much simpler
-  # the Kalman gain also needs to be precomputed using the control module
-
-  def __init__(self, x0, A, C, K):
-    self.x = x0
-    self.A = A
-    self.C = np.atleast_2d(C)
-    self.K = K
-
-    self.A_K = self.A - np.dot(self.K, self.C)
-
-    # K matrix needs to  be pre-computed as follow:
-    # import control
-    # (x, l, K) = control.dare(np.transpose(self.A), np.transpose(self.C), Q, R)
-    # self.K = np.transpose(K)
-
-  def update(self, meas):
-    self.x = np.dot(self.A_K, self.x) + np.dot(self.K, meas)
-    return self.x

common/kalman/tests/test_simple_kalman.py

@@ -1,87 +0,0 @@
-import unittest
-import random
-import timeit
-import numpy as np
-
-from common.kalman.simple_kalman import KF1D
-from common.kalman.simple_kalman_old import KF1D as KF1D_old
-
-
-class TestSimpleKalman(unittest.TestCase):
-  def setUp(self):
-    dt = 0.01
-    x0_0 = 0.0
-    x1_0 = 0.0
-    A0_0 = 1.0
-    A0_1 = dt
-    A1_0 = 0.0
-    A1_1 = 1.0
-    C0_0 = 1.0
-    C0_1 = 0.0
-    K0_0 = 0.12287673
-    K1_0 = 0.29666309
-
-    self.kf_old = KF1D_old(x0=np.array([[x0_0], [x1_0]]),
-                           A=np.array([[A0_0, A0_1], [A1_0, A1_1]]),
-                           C=np.array([C0_0, C0_1]),
-                           K=np.array([[K0_0], [K1_0]]))
-
-    self.kf = KF1D(x0=[[x0_0], [x1_0]],
-                   A=[[A0_0, A0_1], [A1_0, A1_1]],
-                   C=[C0_0, C0_1],
-                   K=[[K0_0], [K1_0]])
-
-  def test_getter_setter(self):
-    self.kf.x = [[1.0], [1.0]]
-    self.assertEqual(self.kf.x, [[1.0], [1.0]])
-
-  def update_returns_state(self):
-    x = self.kf.update(100)
-    self.assertEqual(x, self.kf.x)
-
-  def test_old_equal_new(self):
-    for _ in range(1000):
-      v_wheel = random.uniform(0, 200)
-
-      x_old = self.kf_old.update(v_wheel)
-      x = self.kf.update(v_wheel)
-
-      # Compare the output x, verify that the error is less than 1e-4
-      np.testing.assert_almost_equal(x_old[0], x[0])
-      np.testing.assert_almost_equal(x_old[1], x[1])
-
-  def test_new_is_faster(self):
-    setup = """
-import numpy as np
-
-from common.kalman.simple_kalman import KF1D
-from common.kalman.simple_kalman_old import KF1D as KF1D_old
-
-dt = 0.01
-x0_0 = 0.0
-x1_0 = 0.0
-A0_0 = 1.0
-A0_1 = dt
-A1_0 = 0.0
-A1_1 = 1.0
-C0_0 = 1.0
-C0_1 = 0.0
-K0_0 = 0.12287673
-K1_0 = 0.29666309
-
-kf_old = KF1D_old(x0=np.array([[x0_0], [x1_0]]),
-                  A=np.array([[A0_0, A0_1], [A1_0, A1_1]]),
-                  C=np.array([C0_0, C0_1]),
-                  K=np.array([[K0_0], [K1_0]]))
-
-kf = KF1D(x0=[[x0_0], [x1_0]],
-          A=[[A0_0, A0_1], [A1_0, A1_1]],
-          C=[C0_0, C0_1],
-          K=[[K0_0], [K1_0]])
-    """
-    kf_speed = timeit.timeit("kf.update(1234)", setup=setup, number=10000)
-    kf_old_speed = timeit.timeit("kf_old.update(1234)", setup=setup, number=10000)
-    self.assertTrue(kf_speed < kf_old_speed / 4)
-
-if __name__ == "__main__":
-  unittest.main()

common/logging_extra.py

@@ -8,6 +8,7 @@ import uuid
 import socket
 import logging
 import traceback
+import numpy as np
 from threading import local
 from collections import OrderedDict
 from contextlib import contextmanager
@@ -15,6 +16,8 @@ from contextlib import contextmanager
 LOG_TIMESTAMPS = "LOG_TIMESTAMPS" in os.environ
 
 def json_handler(obj):
+  if isinstance(obj, np.bool_):
+    return bool(obj)
   # if isinstance(obj, (datetime.date, datetime.time)):
   #   return obj.isoformat()
   return repr(obj)
@@ -153,9 +156,9 @@ class SwagLogger(logging.Logger):
   def bind_global(self, **kwargs):
     self.global_ctx.update(kwargs)
 
-  def event(self, event_name, *args, **kwargs):
+  def event(self, event, *args, **kwargs):
     evt = NiceOrderedDict()
-    evt['event'] = event_name
+    evt['event'] = event
     if args:
       evt['args'] = args
     evt.update(kwargs)
@@ -196,8 +199,7 @@ class SwagLogger(logging.Logger):
       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
+      if filename == _srcfile:
         f = f.f_back
         continue
       sinfo = None

common/markdown.py

@@ -0,0 +1,45 @@
+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/mat.h

@@ -1,7 +1,7 @@
 #pragma once
 
 typedef struct vec3 {
-	float v[3];
+  float v[3];
 } vec3;
 
 typedef struct vec4 {
@@ -9,7 +9,7 @@ typedef struct vec4 {
 } vec4;
 
 typedef struct mat3 {
-	float v[3*3];
+  float v[3*3];
 } mat3;
 
 typedef struct mat4 {

common/mock/__init__.py

@@ -0,0 +1,50 @@
+"""
+Utilities for generating mock messages for testing.
+example in common/tests/test_mock.py
+"""
+
+
+import functools
+import threading
+from cereal.messaging import PubMaster
+from cereal.services import SERVICE_LIST
+from openpilot.common.mock.generators import generate_livePose
+from openpilot.common.realtime import Ratekeeper
+
+
+MOCK_GENERATOR = {
+  "livePose": generate_livePose
+}
+
+
+def generate_messages_loop(services: list[str], done: threading.Event):
+  pm = PubMaster(services)
+  rk = Ratekeeper(100)
+  i = 0
+  while not done.is_set():
+    for s in services:
+      should_send = i % (100/SERVICE_LIST[s].frequency) == 0
+      if should_send:
+        message = MOCK_GENERATOR[s]()
+        pm.send(s, message)
+    i += 1
+    rk.keep_time()
+
+
+def mock_messages(services: list[str] | str):
+  if isinstance(services, str):
+    services = [services]
+
+  def decorator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      done = threading.Event()
+      t = threading.Thread(target=generate_messages_loop, args=(services, done))
+      t.start()
+      try:
+        return func(*args, **kwargs)
+      finally:
+        done.set()
+        t.join()
+    return wrapper
+  return decorator

common/mock/generators.py

@@ -0,0 +1,14 @@
+from cereal import messaging
+
+
+def generate_livePose():
+  msg = messaging.new_message('livePose')
+  meas = {'x': 0.0, 'y': 0.0, 'z': 0.0, 'xStd': 0.0, 'yStd': 0.0, 'zStd': 0.0, 'valid': True}
+  msg.livePose.orientationNED = meas
+  msg.livePose.velocityDevice = meas
+  msg.livePose.angularVelocityDevice = meas
+  msg.livePose.accelerationDevice = meas
+  msg.livePose.inputsOK = True
+  msg.livePose.posenetOK = True
+  msg.livePose.sensorsOK = True
+  return msg

common/model.h

@@ -0,0 +1 @@
+#define DEFAULT_MODEL "Dark Souls 2 (Default)"

common/modeldata.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <array>
-#include "common/mat.h"
-#include "system/hardware/hw.h"
-
-const int  TRAJECTORY_SIZE = 33;
-const int LAT_MPC_N = 16;
-const int LON_MPC_N = 32;
-const float MIN_DRAW_DISTANCE = 10.0;
-const float MAX_DRAW_DISTANCE = 100.0;
-
-template <typename T, size_t size>
-constexpr std::array<T, size> build_idxs(float max_val) {
-  std::array<T, size> result{};
-  for (int i = 0; i < size; ++i) {
-    result[i] = max_val * ((i / (double)(size - 1)) * (i / (double)(size - 1)));
-  }
-  return result;
-}
-
-constexpr auto T_IDXS = build_idxs<double, TRAJECTORY_SIZE>(10.0);
-constexpr auto T_IDXS_FLOAT = build_idxs<float, TRAJECTORY_SIZE>(10.0);
-constexpr auto X_IDXS = build_idxs<double, TRAJECTORY_SIZE>(192.0);
-constexpr auto X_IDXS_FLOAT = build_idxs<float, TRAJECTORY_SIZE>(192.0);
-
-const mat3 fcam_intrinsic_matrix = (mat3){{2648.0, 0.0, 1928.0 / 2,
-                                           0.0, 2648.0, 1208.0 / 2,
-                                           0.0, 0.0, 1.0}};
-
-// tici ecam focal probably wrong? magnification is not consistent across frame
-// Need to retrain model before this can be changed
-const mat3 ecam_intrinsic_matrix = (mat3){{567.0, 0.0, 1928.0 / 2,
-                                           0.0, 567.0, 1208.0 / 2,
-                                           0.0, 0.0, 1.0}};
-
-static inline mat3 get_model_yuv_transform(bool bayer = true) {
-  float db_s = 1.0;
-  const mat3 transform = (mat3){{
-    1.0, 0.0, 0.0,
-    0.0, 1.0, 0.0,
-    0.0, 0.0, 1.0
-  }};
-  return bayer ? transform_scale_buffer(transform, db_s) : transform;
-}

common/numpy_fast.py

@@ -1,19 +0,0 @@
-def clip(x, lo, hi):
-  return max(lo, min(hi, x))
-
-def interp(x, xp, fp):
-  N = len(xp)
-
-  def get_interp(xv):
-    hi = 0
-    while hi < N and xv > xp[hi]:
-      hi += 1
-    low = hi - 1
-    return fp[-1] if hi == N and xv > xp[low] else (
-      fp[0] if hi == 0 else
-      (xv - xp[low]) * (fp[hi] - fp[low]) / (xp[hi] - xp[low]) + fp[low])
-
-  return [get_interp(v) for v in x] if hasattr(x, '__iter__') else get_interp(x)
-
-def mean(x):
-  return sum(x) / len(x)

common/params.cc

@@ -3,9 +3,13 @@
 #include <dirent.h>
 #include <sys/file.h>
 
+#include <algorithm>
+#include <cassert>
 #include <csignal>
 #include <unordered_map>
 
+#include "common/params_keys.h"
+#include "common/queue.h"
 #include "common/swaglog.h"
 #include "common/util.h"
 #include "system/hardware/hw.h"
@@ -21,8 +25,8 @@ int fsync_dir(const std::string &path) {
   int result = -1;
   int fd = HANDLE_EINTR(open(path.c_str(), O_RDONLY, 0755));
   if (fd >= 0) {
-    result = fsync(fd);
-    close(fd);
+    result = HANDLE_EINTR(fsync(fd));
+    HANDLE_EINTR(close(fd));
   }
   return result;
 }
@@ -63,7 +67,9 @@ bool create_params_path(const std::string &param_path, const std::string &key_pa
 std::string ensure_params_path(const std::string &prefix, const std::string &path = {}) {
   std::string params_path = path.empty() ? Path::params() : path;
   if (!create_params_path(params_path, params_path + prefix)) {
-    throw std::runtime_error(util::string_format("Failed to ensure params path, errno=%d", errno));
+    throw std::runtime_error(util::string_format(
+        "Failed to ensure params path, errno=%d, path=%s, param_prefix=%s",
+        errno, params_path.c_str(), prefix.c_str()));
   }
   return params_path;
 }
@@ -82,119 +88,45 @@ private:
   int fd_ = -1;
 };
 
-std::unordered_map<std::string, uint32_t> keys = {
-    {"AccessToken", CLEAR_ON_MANAGER_START | DONT_LOG},
-    {"AthenadPid", PERSISTENT},
-    {"AthenadUploadQueue", PERSISTENT},
-    {"CalibrationParams", PERSISTENT},
-    {"CarBatteryCapacity", PERSISTENT},
-    {"CarParams", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON},
-    {"CarParamsCache", CLEAR_ON_MANAGER_START},
-    {"CarVin", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON},
-    {"CompletedTrainingVersion", PERSISTENT},
-    {"ControlsReady", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON},
-    {"CurrentRoute", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON},
-    {"DashcamOverride", PERSISTENT},
-    {"DisableLogging", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON},
-    {"DisablePowerDown", PERSISTENT},
-    {"DisableRadar_Allow", PERSISTENT},
-    {"DisableRadar", PERSISTENT}, // WARNING: THIS DISABLES AEB
-    {"DisableUpdates", PERSISTENT},
-    {"DisengageOnAccelerator", PERSISTENT},
-    {"DongleId", PERSISTENT},
-    {"DoReboot", CLEAR_ON_MANAGER_START},
-    {"DoShutdown", CLEAR_ON_MANAGER_START},
-    {"DoUninstall", CLEAR_ON_MANAGER_START},
-    {"ForcePowerDown", CLEAR_ON_MANAGER_START},
-    {"GitBranch", PERSISTENT},
-    {"GitCommit", PERSISTENT},
-    {"GitDiff", PERSISTENT},
-    {"GithubSshKeys", PERSISTENT},
-    {"GithubUsername", PERSISTENT},
-    {"GitRemote", PERSISTENT},
-    {"GsmApn", PERSISTENT},
-    {"GsmRoaming", PERSISTENT},
-    {"HardwareSerial", PERSISTENT},
-    {"HasAcceptedTerms", PERSISTENT},
-    {"IMEI", PERSISTENT},
-    {"InstallDate", PERSISTENT},
-    {"IsDriverViewEnabled", CLEAR_ON_MANAGER_START},
-    {"IsEngaged", PERSISTENT},
-    {"IsLdwEnabled", PERSISTENT},
-    {"IsMetric", PERSISTENT},
-    {"IsOffroad", CLEAR_ON_MANAGER_START},
-    {"IsOnroad", PERSISTENT},
-    {"IsRHD", PERSISTENT},
-    {"IsTakingSnapshot", CLEAR_ON_MANAGER_START},
-    {"IsUpdateAvailable", CLEAR_ON_MANAGER_START},
-    {"JoystickDebugMode", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_OFF},
-    {"LaikadEphemeris", PERSISTENT | DONT_LOG},
-    {"LanguageSetting", PERSISTENT},
-    {"LastAthenaPingTime", CLEAR_ON_MANAGER_START},
-    {"LastGPSPosition", PERSISTENT},
-    {"LastManagerExitReason", CLEAR_ON_MANAGER_START},
-    {"LastPowerDropDetected", CLEAR_ON_MANAGER_START},
-    {"LastSystemShutdown", CLEAR_ON_MANAGER_START},
-    {"LastUpdateException", CLEAR_ON_MANAGER_START},
-    {"LastUpdateTime", PERSISTENT},
-    {"LiveParameters", PERSISTENT},
-    {"NavDestination", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_OFF},
-    {"NavSettingTime24h", PERSISTENT},
-    {"NavdRender", PERSISTENT},
-    {"OpenpilotEnabledToggle", PERSISTENT},
-    {"PandaHeartbeatLost", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_OFF},
-    {"PandaSignatures", CLEAR_ON_MANAGER_START},
-    {"Passive", PERSISTENT},
-    {"PrimeType", PERSISTENT},
-    {"RecordFront", PERSISTENT},
-    {"RecordFrontLock", PERSISTENT},  // for the internal fleet
-    {"ReleaseNotes", PERSISTENT},
-    {"ShouldDoUpdate", CLEAR_ON_MANAGER_START},
-    {"SnoozeUpdate", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_OFF},
-    {"SshEnabled", PERSISTENT},
-    {"SubscriberInfo", PERSISTENT},
-    {"TermsVersion", PERSISTENT},
-    {"Timezone", PERSISTENT},
-    {"TrainingVersion", PERSISTENT},
-    {"UpdateAvailable", CLEAR_ON_MANAGER_START},
-    {"UpdateFailedCount", CLEAR_ON_MANAGER_START},
-    {"Version", PERSISTENT},
-    {"VisionRadarToggle", PERSISTENT},
-    {"WideCameraOnly", PERSISTENT},
-    {"ApiCache_Device", PERSISTENT},
-    {"ApiCache_DriveStats", PERSISTENT},
-    {"ApiCache_NavDestinations", PERSISTENT},
-    {"ApiCache_Owner", PERSISTENT},
-    {"Offroad_BadNvme", CLEAR_ON_MANAGER_START},
-    {"Offroad_CarUnrecognized", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON},
-    {"Offroad_ConnectivityNeeded", CLEAR_ON_MANAGER_START},
-    {"Offroad_ConnectivityNeededPrompt", CLEAR_ON_MANAGER_START},
-    {"Offroad_InvalidTime", CLEAR_ON_MANAGER_START},
-    {"Offroad_IsTakingSnapshot", CLEAR_ON_MANAGER_START},
-    {"Offroad_NeosUpdate", CLEAR_ON_MANAGER_START},
-    {"Offroad_NoFirmware", CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON},
-    {"Offroad_StorageMissing", CLEAR_ON_MANAGER_START},
-    {"Offroad_TemperatureTooHigh", CLEAR_ON_MANAGER_START},
-    {"Offroad_UnofficialHardware", CLEAR_ON_MANAGER_START},
-    {"Offroad_UpdateFailed", CLEAR_ON_MANAGER_START},
-};
-
 } // namespace
 
 
 Params::Params(const std::string &path) {
-  const char* env = std::getenv("OPENPILOT_PREFIX");
-  prefix = env ? "/" + std::string(env) : "/d";
-  std::string default_param_path = ensure_params_path(prefix);
-  params_path = path.empty() ? default_param_path : ensure_params_path(prefix, path);
+  params_prefix = "/" + util::getenv("OPENPILOT_PREFIX", "d");
+  params_path = ensure_params_path(params_prefix, path);
+}
+
+Params::~Params() {
+  if (future.valid()) {
+    future.wait();
+  }
+  assert(queue.empty());
+}
+
+std::vector<std::string> Params::allKeys(ParamKeyFlag flag) const {
+  std::vector<std::string> ret;
+  for (auto &p : keys) {
+    if (flag == ALL || (p.second.flags & flag)) {
+      ret.push_back(p.first);
+    }
+  }
+  return ret;
 }
 
 bool Params::checkKey(const std::string &key) {
   return keys.find(key) != keys.end();
 }
 
+ParamKeyFlag Params::getKeyFlag(const std::string &key) {
+  return static_cast<ParamKeyFlag>(keys[key].flags);
+}
+
 ParamKeyType Params::getKeyType(const std::string &key) {
-  return static_cast<ParamKeyType>(keys[key]);
+  return keys[key].type;
+}
+
+std::optional<std::string> Params::getKeyDefaultValue(const std::string &key) {
+  return keys[key].default_value;
 }
 
 int Params::put(const char* key, const char* value, size_t value_size) {
@@ -218,7 +150,7 @@ int Params::put(const char* key, const char* value, size_t value_size) {
     }
 
     // fsync to force persist the changes.
-    if ((result = fsync(tmp_fd)) < 0) break;
+    if ((result = HANDLE_EINTR(fsync(tmp_fd))) < 0) break;
 
     FileLock file_lock(params_path + "/.lock");
 
@@ -230,7 +162,9 @@ int Params::put(const char* key, const char* value, size_t value_size) {
   } while (false);
 
   close(tmp_fd);
-  ::unlink(tmp_path.c_str());
+  if (result != 0) {
+    ::unlink(tmp_path.c_str());
+  }
   return result;
 }
 
@@ -271,15 +205,40 @@ std::map<std::string, std::string> Params::readAll() {
   return util::read_files_in_dir(getParamPath());
 }
 
-void Params::clearAll(ParamKeyType key_type) {
+void Params::clearAll(ParamKeyFlag key_flag) {
   FileLock file_lock(params_path + "/.lock");
 
-  std::string path;
-  for (auto &[key, type] : keys) {
-    if (type & key_type) {
-      unlink(getParamPath(key).c_str());
+  // 1) delete params of key_flag
+  // 2) delete files that are not defined in the keys.
+  if (DIR *d = opendir(getParamPath().c_str())) {
+    struct dirent *de = NULL;
+    while ((de = readdir(d))) {
+      if (de->d_type != DT_DIR) {
+        auto it = keys.find(de->d_name);
+        if (it == keys.end() || (it->second.flags & key_flag)) {
+          unlink(getParamPath(de->d_name).c_str());
+        }
+      }
     }
+    closedir(d);
   }
 
   fsync_dir(getParamPath());
 }
+
+void Params::putNonBlocking(const std::string &key, const std::string &val) {
+   queue.push(std::make_pair(key, val));
+  // start thread on demand
+  if (!future.valid() || future.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready) {
+    future = std::async(std::launch::async, &Params::asyncWriteThread, this);
+  }
+}
+
+void Params::asyncWriteThread() {
+  // TODO: write the latest one if a key has multiple values in the queue.
+  std::pair<std::string, std::string> p;
+  while (queue.try_pop(p, 0)) {
+    // Params::put is Thread-Safe
+    put(p.first, p.second);
+  }
+}