diff --git a/.github/labeler.yaml b/.github/labeler.yaml
new file mode 100644
index 0000000000..9b71460ed1
--- /dev/null
+++ b/.github/labeler.yaml
@@ -0,0 +1,68 @@
+CI / testing:
+ - changed-files:
+ - any-glob-to-any-file: '.github/**'
+
+car:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/**'
+
+can:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/can/**'
+
+DBC signals:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/dbc/**'
+
+
+body:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/body/**'
+
+chrysler:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/chrysler/**'
+
+ford:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/ford/**'
+
+gm:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/gm/**'
+
+honda:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/honda/**'
+
+hyundai:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/hyundai/**'
+
+mazda:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/mazda/**'
+
+nissan:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/nissan/**'
+
+subaru:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/subaru/**'
+
+tesla:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/tesla/**'
+
+toyota:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/toyota/**'
+
+volkswagen:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/volkswagen/**'
+
+fingerprint:
+ - changed-files:
+ - any-glob-to-any-file: 'opendbc/car/*/fingerprints.py'
diff --git a/.github/workflows/auto_pr_review.yaml b/.github/workflows/auto_pr_review.yaml
new file mode 100644
index 0000000000..4585b98244
--- /dev/null
+++ b/.github/workflows/auto_pr_review.yaml
@@ -0,0 +1,49 @@
+name: "PR review"
+on:
+ pull_request_target:
+ types: [opened, reopened, synchronize, edited, edited]
+
+jobs:
+ labeler:
+ name: review
+ permissions:
+ contents: read
+ pull-requests: write
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+
+ # Label PRs
+ - uses: actions/labeler@v5.0.0
+ with:
+ dot: true
+ configuration-path: .github/labeler.yaml
+
+ # Check PR target branch
+ - name: check branch
+ uses: Vankka/pr-target-branch-action@def32ec9d93514138d6ac0132ee62e120a72aed5
+ if: github.repository == 'commaai/opendbc'
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ with:
+ target: /^(?!master$).*/
+ exclude: /commaai:.*/
+ change-to: ${{ github.base_ref }}
+ already-exists-action: close_this
+ already-exists-comment: "Your PR should be made against the `master` branch"
+
+ # Welcome comment
+ - name: "First timers PR"
+ uses: actions/first-interaction@v1
+ if: github.event.pull_request.head.repo.full_name != 'commaai/opendbc'
+ with:
+ repo-token: ${{ secrets.GITHUB_TOKEN }}
+ pr-message: |
+
+ Thanks for contributing to opendbc! In order for us to review your PR as quickly as possible, check the following:
+ * Convert your PR to a draft unless it's ready to review
+ * Read the [contributing docs](https://github.com/commaai/openpilot/blob/master/docs/CONTRIBUTING.md)
+ * Before marking as "ready for review", ensure:
+ * the goal is clearly stated in the description
+ * all the tests are passing
+ * include a route or your device' dongle ID if relevant
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 711059405b..493a5de0ec 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -1,48 +1,52 @@
name: tests
-on: [push, pull_request]
+on:
+ push:
+ branches:
+ - master
+ pull_request:
-env:
- RUN: docker run -e PYTHONWARNINGS="error,default::DeprecationWarning" --shm-size 1G --rm opendbc /bin/bash -c
- BUILD: docker buildx build --pull --load --cache-to type=inline --cache-from type=registry,ref=ghcr.io/commaai/opendbc:latest -t opendbc -f Dockerfile .
- PYTHONWARNINGS: error
+# TODO: enable this
+#env:
+# PYTHONWARNINGS: error,default::DeprecationWarning
jobs:
unit-tests:
name: unit tests
- runs-on: ubuntu-latest
+ runs-on: ubuntu-24.04
+ timeout-minutes: 1
#strategy:
# fail-fast: false
# matrix:
# run: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
steps:
- uses: actions/checkout@v4
- - name: Build Docker image
- run: eval "$BUILD"
- - name: Unit tests
- run: ${{ env.RUN }} "pytest -n logical --durations=0"
+ - name: setup python
+ run: |
+ curl -LsSf https://astral.sh/uv/install.sh | sh
+ uv venv
+ # TODO: remove setuptools once https://github.com/cython/cython/issues/5751 is fixed
+ uv pip install -e .[testing,docs] setuptools
+ - run: uv run scons -j$(nproc)
+ - run: uv run pytest .
static-analysis:
name: static analysis
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v4
- - name: Build Docker image
- run: eval "$BUILD"
- - name: pre-commit
- # TODO: a package pre-commit installs has a warning, remove the unset once that's fixed
- run: ${{ env.RUN }} "git init && git add -A && unset PYTHONWARNINGS && pre-commit run --all"
-
- docker-push:
- name: docker push
- runs-on: ubuntu-latest
- if: github.ref == 'refs/heads/master' && github.event_name != 'pull_request' && github.repository == 'commaai/opendbc'
+ runs-on: ubuntu-24.04
+ timeout-minutes: 1
steps:
- uses: actions/checkout@v4
- - name: Build Docker image
- run: eval "$BUILD"
- - name: Push to dockerhub
+ - run: sudo apt install --no-install-recommends -y cppcheck
+ - name: setup python
run: |
- docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
- docker tag opendbc ghcr.io/commaai/opendbc:latest
- docker push ghcr.io/commaai/opendbc:latest
+ curl -LsSf https://astral.sh/uv/install.sh | sh
+ uv venv
+ uv pip install -e . pre-commit
+ - name: cache pre-commit environments
+ uses: actions/cache@v4
+ with:
+ path: ~/.cache/pre-commit
+ key: ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+ restore-keys: |
+ ${{ runner.os }}-pre-commit-
+ - run: uv run pre-commit run --all
diff --git a/.gitignore b/.gitignore
index 3b68262069..d66bd7dcb5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+/build/
.mypy_cache/
*.pyc
*.os
@@ -7,6 +8,10 @@
.*.swp
.DS_Store
.sconsign.dblite
+.hypothesis
+*.egg-info/
+*.html
+uv.lock
opendbc/can/*.so
opendbc/can/*.a
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 4d0e67ec84..df68399b4f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -9,19 +9,16 @@ repos:
- id: check-executables-have-shebangs
- id: check-shebang-scripts-are-executable
- repo: https://github.com/codespell-project/codespell
- rev: v2.2.6
+ rev: v2.3.0
hooks:
- id: codespell
exclude: '\.dbc$'
- args:
- - --check-hidden
- - --builtins clear,rare,informal,usage,code,names,en-GB_to_en-US
- repo: https://github.com/pre-commit/mirrors-mypy
- rev: v1.9.0
+ rev: v1.11.1
hooks:
- id: mypy
- repo: https://github.com/astral-sh/ruff-pre-commit
- rev: v0.3.2
+ rev: v0.5.7
hooks:
- id: ruff
- repo: https://github.com/MarcoGorelli/cython-lint
diff --git a/Dockerfile b/Dockerfile
deleted file mode 100644
index 7cbf7c522d..0000000000
--- a/Dockerfile
+++ /dev/null
@@ -1,47 +0,0 @@
-FROM ubuntu:24.04
-
-ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && apt-get install -y --no-install-recommends \
- autoconf \
- build-essential \
- ca-certificates \
- capnproto \
- clang \
- cppcheck \
- curl \
- git \
- libtool \
- make \
- libbz2-dev \
- libffi-dev \
- libcapnp-dev \
- liblzma-dev \
- libncurses5-dev \
- libncursesw5-dev \
- libreadline-dev \
- libssl-dev \
- libsqlite3-dev \
- libzmq3-dev \
- llvm \
- ocl-icd-opencl-dev \
- opencl-headers \
- tk-dev \
- python3-pip \
- python3-dev \
- python3-openssl \
- python-is-python3 \
- xz-utils \
- zlib1g-dev \
- cmake \
- && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt /tmp/
-RUN pip3 install --break-system-packages --no-cache-dir -r /tmp/requirements.txt
-RUN pip3 install --break-system-packages --no-cache-dir pre-commit==2.15.0 pylint==2.17.4
-
-WORKDIR /project/opendbc
-ENV PYTHONPATH=/project/opendbc
-
-COPY . .
-RUN ls && rm -rf .git && \
- scons -c && scons -j$(nproc) \
diff --git a/README.md b/README.md
index 20e31a9034..1aa116fa09 100644
--- a/README.md
+++ b/README.md
@@ -1,49 +1,28 @@
-## DBC file basics
-
-A DBC file encodes, in a humanly readable way, the information needed to understand a vehicle's CAN bus traffic. A vehicle might have multiple CAN buses and every CAN bus is represented by its own dbc file.
-Wondering what's the DBC file format? [Here](http://www.socialledge.com/sjsu/index.php?title=DBC_Format) and [Here](https://github.com/stefanhoelzl/CANpy/blob/master/docs/DBC_Specification.md) a couple of good overviews.
-
-## How to start reverse engineering cars
-
-[opendbc](https://github.com/commaai/opendbc) is integrated with [cabana](https://github.com/commaai/openpilot/tree/master/tools/cabana).
-
-Use [panda](https://github.com/commaai/panda) to connect your car to a computer.
-
-## How to use reverse engineered DBC
-To create custom CAN simulations or send reverse engineered signals back to the car you can use [CANdevStudio](https://github.com/GENIVI/CANdevStudio) project.
-
-## DBC file preprocessor
-
-DBC files for different models of the same brand have a lot of overlap. Therefore, we wrote a preprocessor to create DBC files from a brand DBC file and a model specific DBC file. The source DBC files can be found in the generator folder. After changing one of the files run the generator.py script to regenerate the output files. These output files will be placed in the root of the opendbc repository and are suffixed by _generated.
-
-## Good practices for contributing to opendbc
-
-- Comments: the best way to store comments is to add them directly to the DBC files. For example:
- ```
- CM_ SG_ 490 LONG_ACCEL "wheel speed derivative, noisy and zero snapping";
- ```
- is a comment that refers to signal `LONG_ACCEL` in message `490`. Using comments is highly recommended, especially for doubts and uncertainties. [cabana](https://community.comma.ai/cabana/) can easily display/add/edit comments to signals and messages.
-
-- Units: when applicable, it's recommended to convert signals into physical units, by using a proper signal factor. Using a SI unit is preferred, unless a non-SI unit rounds the signal factor much better.
-For example:
- ```
- SG_ VEHICLE_SPEED : 7|15@0+ (0.00278,0) [0|70] "m/s" PCM
- ```
- is better than:
- ```
- SG_ VEHICLE_SPEED : 7|15@0+ (0.00620,0) [0|115] "mph" PCM
- ```
- However, the cleanest option is really:
- ```
- SG_ VEHICLE_SPEED : 7|15@0+ (0.01,0) [0|250] "kph" PCM
- ```
-
-- Signal size: always use the smallest amount of bits possible. For example, let's say I'm reverse engineering the gas pedal position and I've determined that it's in a 3 bytes message. For 0% pedal position I read a message value of `0x00 0x00 0x00`, while for 100% of pedal position I read `0x64 0x00 0x00`: clearly, the gas pedal position is within the first byte of the message and I might be tempted to define the signal `GAS_POS` as:
- ```
- SG_ GAS_POS : 7|8@0+ (1,0) [0|100] "%" PCM
- ```
- However, I can't be sure that the very first bit of the message is referred to the pedal position: I haven't seen it changing! Therefore, a safer way of defining the signal is:
- ```
- SG_ GAS_POS : 6|7@0+ (1,0) [0|100] "%" PCM
- ```
- which leaves the first bit unallocated. This prevents from very erroneous reading of the gas pedal position, in case the first bit is indeed used for something else.
+# opendbc
+
+opendbc is a Python API for your car. Read the speed, steering angle, and more. Send gas, braking, and steering commands.
+
+## Structure
+* [`opendbc/dbc/`](opendbc/dbc/) is a repository of [DBC](https://en.wikipedia.org/wiki/CAN_bus#DBC) files
+* [`opendbc/can/`](opendbc/can/) is a library for parsing and building CAN messages from DBC files
+* [`opendbc/car/`](opendbc/car/) is a high-level library for interfacing with cars using Python
+
+## Quick start
+
+```bash
+git clone https://github.com/commaai/opendbc.git
+
+cd opendbc
+
+# Install the dependencies
+pip3 install -e .[testing,docs]
+
+# Build
+scons -j8
+
+# Run the tests
+pytest .
+
+# Run the linter
+pre-commit run --all-files
+```
diff --git a/SConstruct b/SConstruct
index 2401720f17..932ff26e8b 100644
--- a/SConstruct
+++ b/SConstruct
@@ -3,7 +3,6 @@ import subprocess
import sysconfig
import numpy as np
-zmq = 'zmq'
arch = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()
python_path = sysconfig.get_paths()['include']
@@ -28,8 +27,8 @@ ldflags_asan = ["-fsanitize=address"] if GetOption('asan') else []
env = Environment(
ENV=os.environ,
- CC='clang',
- CXX='clang++',
+ CC='gcc',
+ CXX='g++',
CCFLAGS=[
"-g",
"-fPIC",
@@ -38,6 +37,7 @@ env = Environment(
"-Werror",
"-Wshadow",
"-Wno-vla-cxx-extension",
+ "-Wno-unknown-warning-option", # for compatibility across compiler versions
] + ccflags_asan,
LDFLAGS=ldflags_asan,
LINKFLAGS=ldflags_asan,
@@ -52,7 +52,7 @@ env = Environment(
)
common = ''
-Export('env', 'zmq', 'arch', 'common')
+Export('env', 'arch', 'common')
envCython = env.Clone()
envCython["CPPPATH"] += [np.get_include()]
diff --git a/examples/joystick.py b/examples/joystick.py
new file mode 100755
index 0000000000..9a2e1c08be
--- /dev/null
+++ b/examples/joystick.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+import time
+import threading
+import argparse
+import numpy as np
+from inputs import get_gamepad
+
+from kbhit import KBHit
+
+from opendbc.car.structs import CarControl
+from opendbc.car.panda_runner import PandaRunner
+from opendbc.car.can_definitions import CanData
+
+class Keyboard:
+ def __init__(self):
+ self.kb = KBHit()
+ self.axis_increment = 0.05 # 5% of full actuation each key press
+ self.axes_map = {'w': 'gb', 's': 'gb',
+ 'a': 'steer', 'd': 'steer'}
+ self.axes_values = {'gb': 0., 'steer': 0.}
+ self.axes_order = ['gb', 'steer']
+ self.cancel = False
+
+ def update(self):
+ key = self.kb.getch().lower()
+ print(key)
+ self.cancel = False
+ if key == 'r':
+ self.axes_values = {ax: 0. for ax in self.axes_values}
+ elif key == 'c':
+ self.cancel = True
+ elif key in self.axes_map:
+ axis = self.axes_map[key]
+ incr = self.axis_increment if key in ['w', 'a'] else -self.axis_increment
+ self.axes_values[axis] = float(np.clip(self.axes_values[axis] + incr, -1, 1))
+ else:
+ return False
+ return True
+
+class Joystick:
+ def __init__(self, gamepad=False):
+ # TODO: find a way to get this from API, perhaps "inputs" doesn't support it
+ if gamepad:
+ self.cancel_button = 'BTN_NORTH' # (BTN_NORTH=X, ABS_RZ=Right Trigger)
+ accel_axis = 'ABS_Y'
+ steer_axis = 'ABS_RX'
+ else:
+ self.cancel_button = 'BTN_TRIGGER'
+ accel_axis = 'ABS_Y'
+ steer_axis = 'ABS_RX'
+ self.min_axis_value = {accel_axis: 0., steer_axis: 0.}
+ self.max_axis_value = {accel_axis: 255., steer_axis: 255.}
+ self.axes_values = {accel_axis: 0., steer_axis: 0.}
+ self.axes_order = [accel_axis, steer_axis]
+ self.cancel = False
+
+ def update(self):
+ joystick_event = get_gamepad()[0]
+ event = (joystick_event.code, joystick_event.state)
+ if event[0] == self.cancel_button:
+ if event[1] == 1:
+ self.cancel = True
+ elif event[1] == 0: # state 0 is falling edge
+ self.cancel = False
+ elif event[0] in self.axes_values:
+ self.max_axis_value[event[0]] = max(event[1], self.max_axis_value[event[0]])
+ self.min_axis_value[event[0]] = min(event[1], self.min_axis_value[event[0]])
+
+ norm = -float(np.interp(event[1], [self.min_axis_value[event[0]], self.max_axis_value[event[0]]], [-1., 1.]))
+ self.axes_values[event[0]] = norm if abs(norm) > 0.05 else 0. # center can be noisy, deadzone of 5%
+ else:
+ return False
+ return True
+
+def joystick_thread(joystick):
+ while True:
+ joystick.update()
+
+def main(joystick):
+ threading.Thread(target=joystick_thread, args=(joystick,), daemon=True).start()
+ with PandaRunner() as (p, CI):
+ CC = CarControl(enabled=False)
+ while True:
+ cd = [CanData(addr, dat, bus) for addr, dat, bus in p.can_recv()]
+ CI.update([0, cd])
+
+ CC.actuators.accel = float(4.0*np.clip(joystick.axes_values['gb'], -1, 1))
+ CC.actuators.steer = float(np.clip(joystick.axes_values['steer'], -1, 1))
+
+ from pprint import pprint
+ pprint(CC)
+
+ _, can_sends = CI.apply(CC)
+ p.can_send_many(can_sends, timeout=1000)
+
+ # 100Hz
+ time.sleep(0.01)
+
+
+if __name__ == '__main__':
+ parser = argparse.ArgumentParser(description='Test the car interface with a joystick. Uses keyboard by default.',
+ formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+ parser.add_argument('--mode', choices=['keyboard', 'gamepad', 'joystick'], default='keyboard')
+ args = parser.parse_args()
+
+ print()
+ joystick: Keyboard | Joystick
+ if args.mode == 'keyboard':
+ print('Gas/brake control: `W` and `S` keys')
+ print('Steering control: `A` and `D` keys')
+ print('Buttons')
+ print('- `R`: Resets axes')
+ print('- `C`: Cancel cruise control')
+ joystick = Keyboard()
+ else:
+ joystick = Joystick(gamepad=(args.mode == 'gamepad'))
+ main(joystick)
\ No newline at end of file
diff --git a/examples/kbhit.py b/examples/kbhit.py
new file mode 100755
index 0000000000..35f67b4771
--- /dev/null
+++ b/examples/kbhit.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+import sys
+import termios
+import atexit
+from select import select
+
+STDIN_FD = sys.stdin.fileno()
+
+class KBHit:
+ def __init__(self) -> None:
+ self.set_kbhit_terminal()
+
+ def set_kbhit_terminal(self) -> None:
+ # Save the terminal settings
+ self.old_term = termios.tcgetattr(STDIN_FD)
+ self.new_term = self.old_term.copy()
+
+ # New terminal setting unbuffered
+ self.new_term[3] &= ~(termios.ICANON | termios.ECHO)
+ termios.tcsetattr(STDIN_FD, termios.TCSAFLUSH, self.new_term)
+
+ # Support normal-terminal reset at exit
+ atexit.register(self.set_normal_term)
+
+ def set_normal_term(self) -> None:
+ termios.tcsetattr(STDIN_FD, termios.TCSAFLUSH, self.old_term)
+
+ @staticmethod
+ def getch() -> str:
+ return sys.stdin.read(1)
+
+ @staticmethod
+ def getarrow() -> int:
+ c = sys.stdin.read(3)[2]
+ vals = [65, 67, 66, 68]
+ return vals.index(ord(c))
+
+ @staticmethod
+ def kbhit():
+ ''' Returns True if keyboard character was hit, False otherwise.
+ '''
+ return select([sys.stdin], [], [], 0)[0] != []
+
+
+if __name__ == "__main__":
+
+ kb = KBHit()
+
+ print('Hit any key, or ESC to exit')
+
+ while True:
+
+ if kb.kbhit():
+ c = kb.getch()
+ if c == '\x1b': # ESC
+ break
+ print(c)
+
+ kb.set_normal_term()
diff --git a/examples/longitudinal-profiles.py b/examples/longitudinal-profiles.py
new file mode 100755
index 0000000000..e7a366d1e2
--- /dev/null
+++ b/examples/longitudinal-profiles.py
@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+import io
+import os
+import time
+import base64
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+from collections import defaultdict
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+from opendbc.car.structs import CarControl
+from opendbc.car.panda_runner import PandaRunner
+from opendbc.car.common.conversions import Conversions
+
+DT = 0.01 # step time (s)
+
+# TODOs
+# - support lateral maneuvers
+# - setup: show countdown?
+
+
+class Ratekeeper:
+ def __init__(self, rate: float) -> None:
+ self.interval = 1. / rate
+ self.next_frame_time = time.monotonic() + self.interval
+
+ def keep_time(self) -> bool:
+ lagged = False
+ remaining = self.next_frame_time - time.monotonic()
+ self.next_frame_time += self.interval
+ if remaining < -0.1:
+ print(f"lagging by {-remaining * 1000:.2f} ms")
+ lagged = True
+
+ if remaining > 0:
+ time.sleep(remaining)
+ return lagged
+
+@dataclass
+class Action:
+ accel: float # m/s^2
+ duration: float # seconds
+ longControlState: CarControl.Actuators.LongControlState = CarControl.Actuators.LongControlState.pid
+
+ def get_msgs(self):
+ return [
+ (t, CarControl(
+ enabled=True,
+ longActive=True,
+ actuators=CarControl.Actuators(
+ accel=self.accel,
+ longControlState=self.longControlState,
+ ),
+ ))
+ for t in np.linspace(0, self.duration, int(self.duration/DT))
+ ]
+
+@dataclass
+class Maneuver:
+ description: str
+ actions: list[Action]
+ repeat: int = 1
+ initial_speed: float = 0. # m/s
+
+ def get_msgs(self):
+ t0 = 0
+ for action in self.actions:
+ for lt, msg in action.get_msgs():
+ yield lt + t0, msg
+ t0 += lt
+
+MANEUVERS = [
+ Maneuver(
+ "creep: alternate between +1m/ss and -1m/ss",
+ [
+ Action(1, 2), Action(-1, 2),
+ Action(1, 2), Action(-1, 2),
+ Action(1, 2), Action(-1, 2),
+ ],
+ repeat=2,
+ initial_speed=0.,
+ ),
+ Maneuver(
+ "brake step response: -1m/ss from 20mph",
+ [Action(0, 2), Action(-1, 3)],
+ repeat=3,
+ initial_speed=20. * Conversions.MPH_TO_MS,
+ ),
+ Maneuver(
+ "brake step response: -4m/ss from 20mph",
+ [Action(0, 2), Action(-4, 3)],
+ repeat=3,
+ initial_speed=20. * Conversions.MPH_TO_MS,
+ ),
+ Maneuver(
+ "gas step response: +1m/ss from 20mph",
+ [Action(0, 2), Action(1, 3)],
+ repeat=3,
+ initial_speed=20. * Conversions.MPH_TO_MS,
+ ),
+ Maneuver(
+ "gas step response: +4m/ss from 20mph",
+ [Action(0, 2), Action(4, 3)],
+ repeat=3,
+ initial_speed=20. * Conversions.MPH_TO_MS,
+ ),
+]
+
+def report(args, logs, fp):
+ output_path = Path(__file__).resolve().parent / "longitudinal_reports"
+ output_fn = args.output or output_path / f"{fp}_{time.strftime('%Y%m%d-%H_%M_%S')}.html"
+ output_path.mkdir(exist_ok=True)
+ with open(output_fn, "w") as f:
+ f.write("Longitudinal maneuver report
\n")
+ f.write(f"{fp}
\n")
+ if args.desc:
+ f.write(f"{args.desc}
")
+ for description, runs in logs.items():
+ f.write("\n")
+ f.write(f"{description}
\n")
+ for run, log in runs.items():
+ f.write(f"Run #{int(run)+1}
\n")
+ plt.rcParams['font.size'] = 40
+ fig = plt.figure(figsize=(30, 25))
+ ax = fig.subplots(4, 1, sharex=True, gridspec_kw={'hspace': 0, 'height_ratios': [5, 3, 1, 1]})
+
+ ax[0].grid(linewidth=4)
+ ax[0].plot(log["t"], log["carControl.actuators.accel"], label='accel command', linewidth=6)
+ ax[0].plot(log["t"], log["carState.aEgo"], label='aEgo', linewidth=6)
+ ax[0].set_ylabel('Acceleration (m/s^2)')
+ #ax[0].set_ylim(-6.5, 6.5)
+ ax[0].legend()
+
+ ax[1].grid(linewidth=4)
+ ax[1].plot(log["t"], log["carState.vEgo"], 'g', label='vEgo', linewidth=6)
+ ax[1].set_ylabel('Velocity (m/s)')
+ ax[1].legend()
+
+ ax[2].plot(log["t"], log["carControl.enabled"], label='enabled', linewidth=6)
+ ax[3].plot(log["t"], log["carState.gasPressed"], label='gasPressed', linewidth=6)
+ ax[3].plot(log["t"], log["carState.brakePressed"], label='brakePressed', linewidth=6)
+ for i in (2, 3):
+ ax[i].set_yticks([0, 1], minor=False)
+ ax[i].set_ylim(-1, 2)
+ ax[i].legend()
+
+ ax[-1].set_xlabel("Time (s)")
+ fig.tight_layout()
+
+ buffer = io.BytesIO()
+ fig.savefig(buffer, format='png')
+ buffer.seek(0)
+ f.write(f").decode()})
\n")
+
+ import json
+ f.write(f"{json.dumps(logs)}
")
+ print(f"\nReport written to {output_fn}\n")
+
+def main(args):
+ with PandaRunner() as p:
+ print("\n\n")
+
+ maneuvers = MANEUVERS
+ if len(args.maneuvers):
+ maneuvers = [MANEUVERS[i-1] for i in set(args.maneuvers)]
+
+ logs = {}
+ rk = Ratekeeper(int(1./DT))
+ for i, m in enumerate(maneuvers):
+ logs[m.description] = {}
+ print(f"Running {i+1}/{len(MANEUVERS)} '{m.description}'")
+ for run in range(m.repeat):
+ print(f"- run #{run}")
+ print("- setting up, engage cruise")
+ ready_cnt = 0
+ for _ in range(int(2*60./DT)):
+ cs = p.read(strict=False)
+ cc = CarControl(
+ enabled=True,
+ longActive=True,
+ actuators=CarControl.Actuators(
+ accel=(m.initial_speed - cs.vEgo)*0.8,
+ longControlState=CarControl.Actuators.LongControlState.pid,
+ ),
+ )
+ if m.initial_speed < 0.1:
+ cc.actuators.accel = -2
+ cc.actuators.longControlState = CarControl.Actuators.LongControlState.stopping
+ p.write(cc)
+
+ ready = cs.cruiseState.enabled and not cs.cruiseState.standstill and ((m.initial_speed - 0.6) < cs.vEgo < (m.initial_speed + 0.6))
+ ready_cnt = (ready_cnt+1) if ready else 0
+ if ready_cnt > (2./DT):
+ break
+ rk.keep_time()
+ else:
+ print("ERROR: failed to setup")
+ continue
+
+ print("- executing maneuver")
+ logs[m.description][run] = defaultdict(list)
+ for t, cc in m.get_msgs():
+ cs = p.read()
+ p.write(cc)
+
+ logs[m.description][run]["t"].append(t)
+ to_log = {"carControl": cc, "carState": cs, "carControl.actuators": cc.actuators,
+ "carControl.cruiseControl": cc.cruiseControl, "carState.cruiseState": cs.cruiseState}
+ for k, v in to_log.items():
+ for k2, v2 in asdict(v).items():
+ logs[m.description][run][f"{k}.{k2}"].append(v2)
+
+ rk.keep_time()
+
+ print("writing out report")
+ with open('/tmp/logs.json', 'w') as f:
+ import json
+ json.dump(logs, f, indent=2)
+ report(args, logs, p.CI.CP.carFingerprint)
+
+
+if __name__ == "__main__":
+ maneuver_help = "\n".join([f"{i+1}. {m.description}" for i, m in enumerate(MANEUVERS)])
+ parser = argparse.ArgumentParser(description="A tool for longitudinal control testing.",
+ formatter_class=argparse.RawTextHelpFormatter)
+ parser.add_argument('--desc', help="Extra description to include in report.")
+ parser.add_argument('--output', help="Write out report to this file.", default=None)
+ parser.add_argument('maneuvers', nargs='*', type=int, default=None, help=f'Deafult is all.\n{maneuver_help}')
+ args = parser.parse_args()
+ print(args)
+
+ if "REPORT_TEST" in os.environ:
+ with open(os.environ["REPORT_TEST"]) as f:
+ import json
+ logs = json.loads(f.read().split("none'>")[1].split('')[0])
+ report(args, logs, "testing")
+ exit()
+
+ assert args.output is None or args.output.endswith(".html"), "Output filename must end with '.html'"
+
+ main(args)
diff --git a/opendbc/can/SConscript b/opendbc/can/SConscript
index 1c1629d584..9f6825a93f 100644
--- a/opendbc/can/SConscript
+++ b/opendbc/can/SConscript
@@ -1,30 +1,22 @@
Import('env', 'envCython', 'common', 'arch')
-import os
-
envDBC = env.Clone()
dbc_file_path = '-DDBC_FILE_PATH=\'"%s"\'' % (envDBC.Dir("../dbc").abspath)
envDBC['CXXFLAGS'] += [dbc_file_path]
src = ["dbc.cc", "parser.cc", "packer.cc", "common.cc"]
-libs = [common, "zmq"]
# shared library for openpilot
LINKFLAGS = envDBC["LINKFLAGS"]
if arch == "Darwin":
LINKFLAGS += ["-Wl,-install_name,@loader_path/libdbc.dylib"]
-libdbc = envDBC.SharedLibrary('libdbc', src, LIBS=libs, LINKFLAGS=LINKFLAGS)
-
-# static library for tools like cabana
-envDBC.Library('libdbc_static', src, LIBS=libs)
+libdbc = envDBC.SharedLibrary('libdbc', src, LIBS=[common, ], LINKFLAGS=LINKFLAGS)
# Build packer and parser
lenv = envCython.Clone()
-lenv["LINKFLAGS"] += [libdbc[0].get_labspath()]
-parser = lenv.Program('parser_pyx.so', 'parser_pyx.pyx')
-packer = lenv.Program('packer_pyx.so', 'packer_pyx.pyx')
-
-lenv.Depends(parser, libdbc)
-lenv.Depends(packer, libdbc)
+lenv["LIBPATH"].append(Dir("."))
+lenv["RPATH"] = [libdbc[0].dir.abspath, ]
+parser = lenv.Program('parser_pyx.so', 'parser_pyx.pyx', LIBS=[common, libdbc[0].name])
+packer = lenv.Program('packer_pyx.so', 'packer_pyx.pyx', LIBS=[common, libdbc[0].name])
opendbc_python = Alias("opendbc_python", [parser, packer])
diff --git a/opendbc/can/packer_pyx.pyx b/opendbc/can/packer_pyx.pyx
index 84a7e4544e..4e8ae7d564 100644
--- a/opendbc/can/packer_pyx.pyx
+++ b/opendbc/can/packer_pyx.pyx
@@ -50,4 +50,4 @@ cdef class CANPacker:
pass
cdef vector[uint8_t] val = self.pack(addr, values)
- return [addr, (&val[0])[:val.size()], bus]
+ return addr, (&val[0])[:val.size()], bus
diff --git a/opendbc/can/tests/test_checksums.py b/opendbc/can/tests/test_checksums.py
index c347f3a68b..e584ba30a5 100644
--- a/opendbc/can/tests/test_checksums.py
+++ b/opendbc/can/tests/test_checksums.py
@@ -22,7 +22,7 @@ def test_honda_checksum(self):
checksum_std = [11, 10, 9, 8]
checksum_ext = [4, 3, 2, 1]
- for std, ext in zip(checksum_std, checksum_ext):
+ for std, ext in zip(checksum_std, checksum_ext, strict=True):
msgs = [
packer.make_can_msg("LKAS_HUD", 0, values),
packer.make_can_msg("LKAS_HUD_A", 0, values),
diff --git a/opendbc/can/tests/test_packer_parser.py b/opendbc/can/tests/test_packer_parser.py
index acb5acebe9..2abb8f0578 100644
--- a/opendbc/can/tests/test_packer_parser.py
+++ b/opendbc/can/tests/test_packer_parser.py
@@ -107,8 +107,9 @@ def rx_steering_msg(values, bad_checksum=False):
msg = packer.make_can_msg("STEERING_CONTROL", 0, values)
if bad_checksum:
# add 1 to checksum
- msg[1] = bytearray(msg[1])
- msg[1][4] = (msg[1][4] & 0xF0) | ((msg[1][4] & 0x0F) + 1)
+ dat = bytearray(msg[1])
+ dat[4] = (dat[4] & 0xF0) | ((dat[4] & 0x0F) + 1)
+ msg = (msg[0], bytes(dat), msg[2])
parser.update_strings([0, [msg]])
@@ -350,6 +351,6 @@ def test_allow_undefined_msgs(self):
# discovery tests in openpilot first
packer = CANPacker("toyota_nodsu_pt_generated")
- assert packer.make_can_msg("ACC_CONTROL", 0, {"UNKNOWN_SIGNAL": 0}) == [835, b'\x00\x00\x00\x00\x00\x00\x00N', 0]
- assert packer.make_can_msg("UNKNOWN_MESSAGE", 0, {"UNKNOWN_SIGNAL": 0}) == [0, b'', 0]
- assert packer.make_can_msg(0, 0, {"UNKNOWN_SIGNAL": 0}) == [0, b'', 0]
+ assert packer.make_can_msg("ACC_CONTROL", 0, {"UNKNOWN_SIGNAL": 0}) == (835, b'\x00\x00\x00\x00\x00\x00\x00N', 0)
+ assert packer.make_can_msg("UNKNOWN_MESSAGE", 0, {"UNKNOWN_SIGNAL": 0}) == (0, b'', 0)
+ assert packer.make_can_msg(0, 0, {"UNKNOWN_SIGNAL": 0}) == (0, b'', 0)
diff --git a/opendbc/car/__init__.py b/opendbc/car/__init__.py
new file mode 100644
index 0000000000..455d8c3803
--- /dev/null
+++ b/opendbc/car/__init__.py
@@ -0,0 +1,323 @@
+# functions common among cars
+import logging
+from collections import namedtuple
+from dataclasses import dataclass
+from enum import IntFlag, ReprEnum, EnumType
+from dataclasses import replace
+
+from panda import uds
+from opendbc.car import structs
+from opendbc.car.can_definitions import CanData
+from opendbc.car.docs_definitions import CarDocs
+from opendbc.car.common.numpy_fast import clip, interp
+
+# set up logging
+carlog = logging.getLogger('carlog')
+carlog.setLevel(logging.INFO)
+carlog.propagate = False
+
+DT_CTRL = 0.01 # car state and control loop timestep (s)
+
+# kg of standard extra cargo to count for drive, gas, etc...
+STD_CARGO_KG = 136.
+
+ButtonType = structs.CarState.ButtonEvent.Type
+AngleRateLimit = namedtuple('AngleRateLimit', ['speed_bp', 'angle_v'])
+
+
+def apply_hysteresis(val: float, val_steady: float, hyst_gap: float) -> float:
+ if val > val_steady + hyst_gap:
+ val_steady = val - hyst_gap
+ elif val < val_steady - hyst_gap:
+ val_steady = val + hyst_gap
+ return val_steady
+
+
+def create_button_events(cur_btn: int, prev_btn: int, buttons_dict: dict[int, structs.CarState.ButtonEvent.Type],
+ unpressed_btn: int = 0) -> list[structs.CarState.ButtonEvent]:
+ events: list[structs.CarState.ButtonEvent] = []
+
+ if cur_btn == prev_btn:
+ return events
+
+ # Add events for button presses, multiple when a button switches without going to unpressed
+ for pressed, btn in ((False, prev_btn), (True, cur_btn)):
+ if btn != unpressed_btn:
+ events.append(structs.CarState.ButtonEvent(pressed=pressed,
+ type=buttons_dict.get(btn, ButtonType.unknown)))
+ return events
+
+
+def gen_empty_fingerprint():
+ return {i: {} for i in range(8)}
+
+
+# these params were derived for the Civic and used to calculate params for other cars
+class VehicleDynamicsParams:
+ MASS = 1326. + STD_CARGO_KG
+ WHEELBASE = 2.70
+ CENTER_TO_FRONT = WHEELBASE * 0.4
+ CENTER_TO_REAR = WHEELBASE - CENTER_TO_FRONT
+ ROTATIONAL_INERTIA = 2500
+ TIRE_STIFFNESS_FRONT = 192150
+ TIRE_STIFFNESS_REAR = 202500
+
+
+# TODO: get actual value, for now starting with reasonable value for
+# civic and scaling by mass and wheelbase
+def scale_rot_inertia(mass, wheelbase):
+ return VehicleDynamicsParams.ROTATIONAL_INERTIA * mass * wheelbase ** 2 / (VehicleDynamicsParams.MASS * VehicleDynamicsParams.WHEELBASE ** 2)
+
+
+# TODO: start from empirically derived lateral slip stiffness for the civic and scale by
+# mass and CG position, so all cars will have approximately similar dyn behaviors
+def scale_tire_stiffness(mass, wheelbase, center_to_front, tire_stiffness_factor):
+ center_to_rear = wheelbase - center_to_front
+ tire_stiffness_front = (VehicleDynamicsParams.TIRE_STIFFNESS_FRONT * tire_stiffness_factor) * mass / VehicleDynamicsParams.MASS * \
+ (center_to_rear / wheelbase) / (VehicleDynamicsParams.CENTER_TO_REAR / VehicleDynamicsParams.WHEELBASE)
+
+ tire_stiffness_rear = (VehicleDynamicsParams.TIRE_STIFFNESS_REAR * tire_stiffness_factor) * mass / VehicleDynamicsParams.MASS * \
+ (center_to_front / wheelbase) / (VehicleDynamicsParams.CENTER_TO_FRONT / VehicleDynamicsParams.WHEELBASE)
+
+ return tire_stiffness_front, tire_stiffness_rear
+
+
+DbcDict = dict[str, str]
+
+
+def dbc_dict(pt_dbc, radar_dbc, chassis_dbc=None, body_dbc=None) -> DbcDict:
+ return {'pt': pt_dbc, 'radar': radar_dbc, 'chassis': chassis_dbc, 'body': body_dbc}
+
+
+def apply_driver_steer_torque_limits(apply_torque, apply_torque_last, driver_torque, LIMITS):
+
+ # limits due to driver torque
+ driver_max_torque = LIMITS.STEER_MAX + (LIMITS.STEER_DRIVER_ALLOWANCE + driver_torque * LIMITS.STEER_DRIVER_FACTOR) * LIMITS.STEER_DRIVER_MULTIPLIER
+ driver_min_torque = -LIMITS.STEER_MAX + (-LIMITS.STEER_DRIVER_ALLOWANCE + driver_torque * LIMITS.STEER_DRIVER_FACTOR) * LIMITS.STEER_DRIVER_MULTIPLIER
+ max_steer_allowed = max(min(LIMITS.STEER_MAX, driver_max_torque), 0)
+ min_steer_allowed = min(max(-LIMITS.STEER_MAX, driver_min_torque), 0)
+ apply_torque = clip(apply_torque, min_steer_allowed, max_steer_allowed)
+
+ # slow rate if steer torque increases in magnitude
+ if apply_torque_last > 0:
+ apply_torque = clip(apply_torque, max(apply_torque_last - LIMITS.STEER_DELTA_DOWN, -LIMITS.STEER_DELTA_UP),
+ apply_torque_last + LIMITS.STEER_DELTA_UP)
+ else:
+ apply_torque = clip(apply_torque, apply_torque_last - LIMITS.STEER_DELTA_UP,
+ min(apply_torque_last + LIMITS.STEER_DELTA_DOWN, LIMITS.STEER_DELTA_UP))
+
+ return int(round(float(apply_torque)))
+
+
+def apply_dist_to_meas_limits(val, val_last, val_meas,
+ STEER_DELTA_UP, STEER_DELTA_DOWN,
+ STEER_ERROR_MAX, STEER_MAX):
+ # limits due to comparison of commanded val VS measured val (torque/angle/curvature)
+ max_lim = min(max(val_meas + STEER_ERROR_MAX, STEER_ERROR_MAX), STEER_MAX)
+ min_lim = max(min(val_meas - STEER_ERROR_MAX, -STEER_ERROR_MAX), -STEER_MAX)
+
+ val = clip(val, min_lim, max_lim)
+
+ # slow rate if val increases in magnitude
+ if val_last > 0:
+ val = clip(val,
+ max(val_last - STEER_DELTA_DOWN, -STEER_DELTA_UP),
+ val_last + STEER_DELTA_UP)
+ else:
+ val = clip(val,
+ val_last - STEER_DELTA_UP,
+ min(val_last + STEER_DELTA_DOWN, STEER_DELTA_UP))
+
+ return float(val)
+
+
+def apply_meas_steer_torque_limits(apply_torque, apply_torque_last, motor_torque, LIMITS):
+ return int(round(apply_dist_to_meas_limits(apply_torque, apply_torque_last, motor_torque,
+ LIMITS.STEER_DELTA_UP, LIMITS.STEER_DELTA_DOWN,
+ LIMITS.STEER_ERROR_MAX, LIMITS.STEER_MAX)))
+
+
+def apply_std_steer_angle_limits(apply_angle, apply_angle_last, v_ego, LIMITS):
+ # pick angle rate limits based on wind up/down
+ steer_up = apply_angle_last * apply_angle >= 0. and abs(apply_angle) > abs(apply_angle_last)
+ rate_limits = LIMITS.ANGLE_RATE_LIMIT_UP if steer_up else LIMITS.ANGLE_RATE_LIMIT_DOWN
+
+ angle_rate_lim = interp(v_ego, rate_limits.speed_bp, rate_limits.angle_v)
+ return clip(apply_angle, apply_angle_last - angle_rate_lim, apply_angle_last + angle_rate_lim)
+
+
+def common_fault_avoidance(fault_condition: bool, request: bool, above_limit_frames: int,
+ max_above_limit_frames: int, max_mismatching_frames: int = 1):
+ """
+ Several cars have the ability to work around their EPS limits by cutting the
+ request bit of their LKAS message after a certain number of frames above the limit.
+ """
+
+ # Count up to max_above_limit_frames, at which point we need to cut the request for above_limit_frames to avoid a fault
+ if request and fault_condition:
+ above_limit_frames += 1
+ else:
+ above_limit_frames = 0
+
+ # Once we cut the request bit, count additionally to max_mismatching_frames before setting the request bit high again.
+ # Some brands do not respect our workaround without multiple messages on the bus, for example
+ if above_limit_frames > max_above_limit_frames:
+ request = False
+
+ if above_limit_frames >= max_above_limit_frames + max_mismatching_frames:
+ above_limit_frames = 0
+
+ return above_limit_frames, request
+
+
+def apply_center_deadzone(error, deadzone):
+ if (error > - deadzone) and (error < deadzone):
+ error = 0.
+ return error
+
+
+def rate_limit(new_value, last_value, dw_step, up_step):
+ return clip(new_value, last_value + dw_step, last_value + up_step)
+
+
+def get_friction(lateral_accel_error: float, lateral_accel_deadzone: float, friction_threshold: float,
+ torque_params: structs.CarParams.LateralTorqueTuning, friction_compensation: bool) -> float:
+ friction_interp = interp(
+ apply_center_deadzone(lateral_accel_error, lateral_accel_deadzone),
+ [-friction_threshold, friction_threshold],
+ [-torque_params.friction, torque_params.friction]
+ )
+ friction = float(friction_interp) if friction_compensation else 0.0
+ return friction
+
+
+def make_tester_present_msg(addr, bus, subaddr=None, suppress_response=False):
+ dat = [0x02, uds.SERVICE_TYPE.TESTER_PRESENT]
+ if subaddr is not None:
+ dat.insert(0, subaddr)
+ dat.append(0x80 if suppress_response else 0x0) # sub-function
+
+ dat.extend([0x0] * (8 - len(dat)))
+ return CanData(addr, bytes(dat), bus)
+
+
+def get_safety_config(safety_model: structs.CarParams.SafetyModel, safety_param: int = None) -> structs.CarParams.SafetyConfig:
+ ret = structs.CarParams.SafetyConfig()
+ ret.safetyModel = safety_model
+ if safety_param is not None:
+ ret.safetyParam = safety_param
+ return ret
+
+
+class CanBusBase:
+ offset: int
+
+ def __init__(self, CP, fingerprint: dict[int, dict[int, int]] | None) -> None:
+ if CP is None:
+ assert fingerprint is not None
+ num = max([k for k, v in fingerprint.items() if len(v)], default=0) // 4 + 1
+ else:
+ num = len(CP.safetyConfigs)
+ self.offset = 4 * (num - 1)
+
+
+class CanSignalRateCalculator:
+ """
+ Calculates the instantaneous rate of a CAN signal by using the counter
+ variable and the known frequency of the CAN message that contains it.
+ """
+ def __init__(self, frequency):
+ self.frequency = frequency
+ self.previous_counter = 0
+ self.previous_value = 0
+ self.rate = 0
+
+ def update(self, current_value, current_counter):
+ if current_counter != self.previous_counter:
+ self.rate = (current_value - self.previous_value) * self.frequency
+
+ self.previous_counter = current_counter
+ self.previous_value = current_value
+
+ return self.rate
+
+
+@dataclass(frozen=True, kw_only=True)
+class CarSpecs:
+ mass: float # kg, curb weight
+ wheelbase: float # meters
+ steerRatio: float
+ centerToFrontRatio: float = 0.5
+ minSteerSpeed: float = 0.0 # m/s
+ minEnableSpeed: float = -1.0 # m/s
+ tireStiffnessFactor: float = 1.0
+
+ def override(self, **kwargs):
+ return replace(self, **kwargs)
+
+
+class Freezable:
+ _frozen: bool = False
+
+ def freeze(self):
+ if not self._frozen:
+ self._frozen = True
+
+ def __setattr__(self, *args, **kwargs):
+ if self._frozen:
+ raise Exception("cannot modify frozen object")
+ super().__setattr__(*args, **kwargs)
+
+
+@dataclass(order=True)
+class PlatformConfig(Freezable):
+ car_docs: list[CarDocs]
+ specs: CarSpecs
+
+ dbc_dict: DbcDict
+
+ flags: int = 0
+
+ platform_str: str | None = None
+
+ def __hash__(self) -> int:
+ return hash(self.platform_str)
+
+ def override(self, **kwargs):
+ return replace(self, **kwargs)
+
+ def init(self):
+ pass
+
+ def __post_init__(self):
+ self.init()
+
+
+class PlatformsType(EnumType):
+ def __new__(metacls, cls, bases, classdict, *, boundary=None, _simple=False, **kwds):
+ for key in classdict._member_names.keys():
+ cfg: PlatformConfig = classdict[key]
+ cfg.platform_str = key
+ cfg.freeze()
+ return super().__new__(metacls, cls, bases, classdict, boundary=boundary, _simple=_simple, **kwds)
+
+
+class Platforms(str, ReprEnum, metaclass=PlatformsType):
+ config: PlatformConfig
+
+ def __new__(cls, platform_config: PlatformConfig):
+ member = str.__new__(cls, platform_config.platform_str)
+ member.config = platform_config
+ member._value_ = platform_config.platform_str
+ return member
+
+ def __repr__(self):
+ return f"<{self.__class__.__name__}.{self.name}>"
+
+ @classmethod
+ def create_dbc_map(cls) -> dict[str, DbcDict]:
+ return {p: p.config.dbc_dict for p in cls}
+
+ @classmethod
+ def with_flags(cls, flags: IntFlag) -> set['Platforms']:
+ return {p for p in cls if p.config.flags & flags}
diff --git a/opendbc/car/body/__init__.py b/opendbc/car/body/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/opendbc/car/body/bodycan.py b/opendbc/car/body/bodycan.py
new file mode 100644
index 0000000000..580e5025ad
--- /dev/null
+++ b/opendbc/car/body/bodycan.py
@@ -0,0 +1,7 @@
+def create_control(packer, torque_l, torque_r):
+ values = {
+ "TORQUE_L": torque_l,
+ "TORQUE_R": torque_r,
+ }
+
+ return packer.make_can_msg("TORQUE_CMD", 0, values)
diff --git a/opendbc/car/body/carcontroller.py b/opendbc/car/body/carcontroller.py
new file mode 100644
index 0000000000..a311304ed0
--- /dev/null
+++ b/opendbc/car/body/carcontroller.py
@@ -0,0 +1,142 @@
+import copy
+import numpy as np
+from numbers import Number
+
+from opendbc.can.packer import CANPacker
+from opendbc.car import DT_CTRL
+from opendbc.car.common.numpy_fast import clip, interp
+from opendbc.car.body import bodycan
+from opendbc.car.body.values import SPEED_FROM_RPM
+from opendbc.car.interfaces import CarControllerBase
+
+
+class PIController:
+ def __init__(self, k_p, k_i, pos_limit=1e308, neg_limit=-1e308, rate=100):
+ self._k_p = k_p
+ self._k_i = k_i
+ if isinstance(self._k_p, Number):
+ self._k_p = [[0], [self._k_p]]
+ if isinstance(self._k_i, Number):
+ self._k_i = [[0], [self._k_i]]
+
+ self.pos_limit = pos_limit
+ self.neg_limit = neg_limit
+
+ self.i_unwind_rate = 0.3 / rate
+ self.i_rate = 1.0 / rate
+ self.speed = 0.0
+
+ self.reset()
+
+ @property
+ def k_p(self):
+ return interp(self.speed, self._k_p[0], self._k_p[1])
+
+ @property
+ def k_i(self):
+ return interp(self.speed, self._k_i[0], self._k_i[1])
+
+ @property
+ def error_integral(self):
+ return self.i/self.k_i
+
+ def reset(self):
+ self.p = 0.0
+ self.i = 0.0
+ self.control = 0
+
+ def update(self, error, speed=0.0, freeze_integrator=False):
+ self.speed = speed
+
+ self.p = float(error) * self.k_p
+
+ i = self.i + error * self.k_i * self.i_rate
+ control = self.p + i
+
+ # Update when changing i will move the control away from the limits
+ # or when i will move towards the sign of the error
+ if ((error >= 0 and (control <= self.pos_limit or i < 0.0)) or
+ (error <= 0 and (control >= self.neg_limit or i > 0.0))) and \
+ not freeze_integrator:
+ self.i = i
+
+ control = self.p + self.i
+
+ self.control = clip(control, self.neg_limit, self.pos_limit)
+ return self.control
+
+
+MAX_TORQUE = 500
+MAX_TORQUE_RATE = 50
+MAX_ANGLE_ERROR = np.radians(7)
+MAX_POS_INTEGRATOR = 0.2 # meters
+MAX_TURN_INTEGRATOR = 0.1 # meters
+
+
+class CarController(CarControllerBase):
+ def __init__(self, dbc_name, CP):
+ super().__init__(dbc_name, CP)
+ self.packer = CANPacker(dbc_name)
+
+ # PIDs
+ self.turn_pid = PIController(110, k_i=11.5, rate=1/DT_CTRL)
+ self.wheeled_speed_pid = PIController(110, k_i=11.5, rate=1/DT_CTRL)
+
+ self.torque_r_filtered = 0.
+ self.torque_l_filtered = 0.
+
+ @staticmethod
+ def deadband_filter(torque, deadband):
+ if torque > 0:
+ torque += deadband
+ else:
+ torque -= deadband
+ return torque
+
+ def update(self, CC, CS, now_nanos):
+
+ torque_l = 0
+ torque_r = 0
+
+ llk_valid = len(CC.orientationNED) > 1 and len(CC.angularVelocity) > 1
+ if CC.enabled and llk_valid:
+ # Read these from the joystick
+ # TODO: this isn't acceleration, okay?
+ speed_desired = CC.actuators.accel / 5.
+ speed_diff_desired = -CC.actuators.steer / 2.
+
+ speed_measured = SPEED_FROM_RPM * (CS.out.wheelSpeeds.fl + CS.out.wheelSpeeds.fr) / 2.
+ speed_error = speed_desired - speed_measured
+
+ torque = self.wheeled_speed_pid.update(speed_error, freeze_integrator=False)
+
+ speed_diff_measured = SPEED_FROM_RPM * (CS.out.wheelSpeeds.fl - CS.out.wheelSpeeds.fr)
+ turn_error = speed_diff_measured - speed_diff_desired
+ freeze_integrator = ((turn_error < 0 and self.turn_pid.error_integral <= -MAX_TURN_INTEGRATOR) or
+ (turn_error > 0 and self.turn_pid.error_integral >= MAX_TURN_INTEGRATOR))
+ torque_diff = self.turn_pid.update(turn_error, freeze_integrator=freeze_integrator)
+
+ # Combine 2 PIDs outputs
+ torque_r = torque + torque_diff
+ torque_l = torque - torque_diff
+
+ # Torque rate limits
+ self.torque_r_filtered = np.clip(self.deadband_filter(torque_r, 10),
+ self.torque_r_filtered - MAX_TORQUE_RATE,
+ self.torque_r_filtered + MAX_TORQUE_RATE)
+ self.torque_l_filtered = np.clip(self.deadband_filter(torque_l, 10),
+ self.torque_l_filtered - MAX_TORQUE_RATE,
+ self.torque_l_filtered + MAX_TORQUE_RATE)
+ torque_r = int(np.clip(self.torque_r_filtered, -MAX_TORQUE, MAX_TORQUE))
+ torque_l = int(np.clip(self.torque_l_filtered, -MAX_TORQUE, MAX_TORQUE))
+
+ can_sends = []
+ can_sends.append(bodycan.create_control(self.packer, torque_l, torque_r))
+
+ new_actuators = copy.copy(CC.actuators)
+ new_actuators.accel = torque_l
+ new_actuators.steer = torque_r
+ new_actuators.steerOutputCan = torque_r
+
+ self.frame += 1
+ return new_actuators, can_sends
diff --git a/opendbc/car/body/carstate.py b/opendbc/car/body/carstate.py
new file mode 100644
index 0000000000..68cfb2072f
--- /dev/null
+++ b/opendbc/car/body/carstate.py
@@ -0,0 +1,39 @@
+from opendbc.can.parser import CANParser
+from opendbc.car import structs
+from opendbc.car.interfaces import CarStateBase
+from opendbc.car.body.values import DBC
+
+
+class CarState(CarStateBase):
+ def update(self, cp, *_) -> structs.CarState:
+ ret = structs.CarState()
+
+ ret.wheelSpeeds.fl = cp.vl['MOTORS_DATA']['SPEED_L']
+ ret.wheelSpeeds.fr = cp.vl['MOTORS_DATA']['SPEED_R']
+
+ ret.vEgoRaw = ((ret.wheelSpeeds.fl + ret.wheelSpeeds.fr) / 2.) * self.CP.wheelSpeedFactor
+
+ ret.vEgo, ret.aEgo = self.update_speed_kf(ret.vEgoRaw)
+ ret.standstill = False
+
+ ret.steerFaultPermanent = any([cp.vl['VAR_VALUES']['MOTOR_ERR_L'], cp.vl['VAR_VALUES']['MOTOR_ERR_R'],
+ cp.vl['VAR_VALUES']['FAULT']])
+
+ ret.charging = cp.vl["BODY_DATA"]["CHARGER_CONNECTED"] == 1
+ ret.fuelGauge = cp.vl["BODY_DATA"]["BATT_PERCENTAGE"] / 100
+
+ # irrelevant for non-car
+ ret.gearShifter = structs.CarState.GearShifter.drive
+ ret.cruiseState.enabled = True
+ ret.cruiseState.available = True
+
+ return ret
+
+ @staticmethod
+ def get_can_parser(CP):
+ messages = [
+ ("MOTORS_DATA", 100),
+ ("VAR_VALUES", 10),
+ ("BODY_DATA", 1),
+ ]
+ return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
diff --git a/opendbc/car/body/fingerprints.py b/opendbc/car/body/fingerprints.py
new file mode 100644
index 0000000000..3f5665029b
--- /dev/null
+++ b/opendbc/car/body/fingerprints.py
@@ -0,0 +1,28 @@
+# ruff: noqa: E501
+from opendbc.car.structs import CarParams
+from opendbc.car.body.values import CAR
+
+Ecu = CarParams.Ecu
+
+# debug ecu fw version is the git hash of the firmware
+
+
+FINGERPRINTS = {
+ CAR.COMMA_BODY: [{
+ 513: 8, 516: 8, 514: 3, 515: 4
+ }],
+}
+
+FW_VERSIONS = {
+ CAR.COMMA_BODY: {
+ (Ecu.engine, 0x720, None): [
+ b'0.0.01',
+ b'0.3.00a',
+ b'02/27/2022',
+ ],
+ (Ecu.debug, 0x721, None): [
+ b'166bd860',
+ b'dc780f85',
+ ],
+ },
+}
diff --git a/opendbc/car/body/interface.py b/opendbc/car/body/interface.py
new file mode 100644
index 0000000000..f720c4a7d6
--- /dev/null
+++ b/opendbc/car/body/interface.py
@@ -0,0 +1,25 @@
+import math
+from opendbc.car import get_safety_config, structs
+from opendbc.car.interfaces import CarInterfaceBase
+from opendbc.car.body.values import SPEED_FROM_RPM
+
+
+class CarInterface(CarInterfaceBase):
+ @staticmethod
+ def _get_params(ret: structs.CarParams, candidate, fingerprint, car_fw, experimental_long, docs) -> structs.CarParams:
+ ret.notCar = True
+ ret.carName = "body"
+ ret.safetyConfigs = [get_safety_config(structs.CarParams.SafetyModel.body)]
+
+ ret.minSteerSpeed = -math.inf
+ ret.maxLateralAccel = math.inf # TODO: set to a reasonable value
+ ret.steerLimitTimer = 1.0
+ ret.steerActuatorDelay = 0.
+
+ ret.wheelSpeedFactor = SPEED_FROM_RPM
+
+ ret.radarUnavailable = True
+ ret.openpilotLongitudinalControl = True
+ ret.steerControlType = structs.CarParams.SteerControlType.angle
+
+ return ret
diff --git a/opendbc/car/body/radar_interface.py b/opendbc/car/body/radar_interface.py
new file mode 100644
index 0000000000..6e552bf618
--- /dev/null
+++ b/opendbc/car/body/radar_interface.py
@@ -0,0 +1,4 @@
+from opendbc.car.interfaces import RadarInterfaceBase
+
+class RadarInterface(RadarInterfaceBase):
+ pass
diff --git a/opendbc/car/body/values.py b/opendbc/car/body/values.py
new file mode 100644
index 0000000000..3c221548c3
--- /dev/null
+++ b/opendbc/car/body/values.py
@@ -0,0 +1,40 @@
+from opendbc.car import CarSpecs, PlatformConfig, Platforms, dbc_dict
+from opendbc.car.structs import CarParams
+from opendbc.car.docs_definitions import CarDocs
+from opendbc.car.fw_query_definitions import FwQueryConfig, Request, StdQueries
+
+Ecu = CarParams.Ecu
+
+SPEED_FROM_RPM = 0.008587
+
+
+class CarControllerParams:
+ ANGLE_DELTA_BP = [0., 5., 15.]
+ ANGLE_DELTA_V = [5., .8, .15] # windup limit
+ ANGLE_DELTA_VU = [5., 3.5, 0.4] # unwind limit
+ LKAS_MAX_TORQUE = 1 # A value of 1 is easy to overpower
+ STEER_THRESHOLD = 1.0
+
+ def __init__(self, CP):
+ pass
+
+
+class CAR(Platforms):
+ COMMA_BODY = PlatformConfig(
+ [CarDocs("comma body", package="All")],
+ CarSpecs(mass=9, wheelbase=0.406, steerRatio=0.5, centerToFrontRatio=0.44),
+ dbc_dict('comma_body', None),
+ )
+
+
+FW_QUERY_CONFIG = FwQueryConfig(
+ requests=[
+ Request(
+ [StdQueries.TESTER_PRESENT_REQUEST, StdQueries.UDS_VERSION_REQUEST],
+ [StdQueries.TESTER_PRESENT_RESPONSE, StdQueries.UDS_VERSION_RESPONSE],
+ bus=0,
+ ),
+ ],
+)
+
+DBC = CAR.create_dbc_map()
diff --git a/opendbc/car/can_definitions.py b/opendbc/car/can_definitions.py
new file mode 100644
index 0000000000..2dba7f26a8
--- /dev/null
+++ b/opendbc/car/can_definitions.py
@@ -0,0 +1,15 @@
+from collections.abc import Callable
+from typing import NamedTuple, Protocol
+
+
+class CanData(NamedTuple):
+ address: int
+ dat: bytes
+ src: int
+
+
+CanSendCallable = Callable[[list[CanData]], None]
+
+
+class CanRecvCallable(Protocol):
+ def __call__(self, wait_for_one: bool = False) -> list[list[CanData]]: ...
diff --git a/opendbc/car/car_helpers.py b/opendbc/car/car_helpers.py
new file mode 100644
index 0000000000..f94c88ba8e
--- /dev/null
+++ b/opendbc/car/car_helpers.py
@@ -0,0 +1,178 @@
+import os
+import time
+
+from opendbc.car import carlog, gen_empty_fingerprint
+from opendbc.car.can_definitions import CanRecvCallable, CanSendCallable
+from opendbc.car.structs import CarParams
+from opendbc.car.fingerprints import eliminate_incompatible_cars, all_legacy_fingerprint_cars
+from opendbc.car.fw_versions import ObdCallback, get_fw_versions_ordered, get_present_ecus, match_fw_to_car
+from opendbc.car.interfaces import get_interface_attr
+from opendbc.car.mock.values import CAR as MOCK
+from opendbc.car.vin import get_vin, is_valid_vin, VIN_UNKNOWN
+
+FRAME_FINGERPRINT = 100 # 1s
+
+
+def load_interfaces(brand_names):
+ ret = {}
+ for brand_name in brand_names:
+ path = f'opendbc.car.{brand_name}'
+ CarInterface = __import__(path + '.interface', fromlist=['CarInterface']).CarInterface
+ CarState = __import__(path + '.carstate', fromlist=['CarState']).CarState
+ CarController = __import__(path + '.carcontroller', fromlist=['CarController']).CarController
+ for model_name in brand_names[brand_name]:
+ ret[model_name] = (CarInterface, CarController, CarState)
+ return ret
+
+
+def _get_interface_names() -> dict[str, list[str]]:
+ # returns a dict of brand name and its respective models
+ brand_names = {}
+ for brand_name, brand_models in get_interface_attr("CAR").items():
+ brand_names[brand_name] = [model.value for model in brand_models]
+
+ return brand_names
+
+
+# imports from directory opendbc/car//
+interface_names = _get_interface_names()
+interfaces = load_interfaces(interface_names)
+
+
+def can_fingerprint(can_recv: CanRecvCallable) -> tuple[str | None, dict[int, dict]]:
+ finger = gen_empty_fingerprint()
+ candidate_cars = {i: all_legacy_fingerprint_cars() for i in [0, 1]} # attempt fingerprint on both bus 0 and 1
+ frame = 0
+ car_fingerprint = None
+ done = False
+
+ while not done:
+ # can_recv(wait_for_one=True) may return zero or multiple packets, so we increment frame for each one we receive
+ can_packets = can_recv(wait_for_one=True)
+ for can_packet in can_packets:
+ for can in can_packet:
+ # The fingerprint dict is generated for all buses, this way the car interface
+ # can use it to detect a (valid) multipanda setup and initialize accordingly
+ if can.src < 128:
+ if can.src not in finger:
+ finger[can.src] = {}
+ finger[can.src][can.address] = len(can.dat)
+
+ for b in candidate_cars:
+ # Ignore extended messages and VIN query response.
+ if can.src == b and can.address < 0x800 and can.address not in (0x7df, 0x7e0, 0x7e8):
+ candidate_cars[b] = eliminate_incompatible_cars(can, candidate_cars[b])
+
+ # if we only have one car choice and the time since we got our first
+ # message has elapsed, exit
+ for b in candidate_cars:
+ if len(candidate_cars[b]) == 1 and frame > FRAME_FINGERPRINT:
+ # fingerprint done
+ car_fingerprint = candidate_cars[b][0]
+
+ # bail if no cars left or we've been waiting for more than 2s
+ failed = (all(len(cc) == 0 for cc in candidate_cars.values()) and frame > FRAME_FINGERPRINT) or frame > 200
+ succeeded = car_fingerprint is not None
+ done = failed or succeeded
+
+ frame += 1
+
+ return car_fingerprint, finger
+
+
+# **** for use live only ****
+def fingerprint(can_recv: CanRecvCallable, can_send: CanSendCallable, set_obd_multiplexing: ObdCallback, num_pandas: int,
+ cached_params: CarParams | None) -> tuple[str | None, dict, str, list[CarParams.CarFw], CarParams.FingerprintSource, bool]:
+ fixed_fingerprint = os.environ.get('FINGERPRINT', "")
+ skip_fw_query = os.environ.get('SKIP_FW_QUERY', False)
+ disable_fw_cache = os.environ.get('DISABLE_FW_CACHE', False)
+ ecu_rx_addrs = set()
+
+ start_time = time.monotonic()
+ if not skip_fw_query:
+ if cached_params is not None and cached_params.carName != "mock" and len(cached_params.carFw) > 0 and \
+ cached_params.carVin is not VIN_UNKNOWN and not disable_fw_cache:
+ carlog.warning("Using cached CarParams")
+ vin_rx_addr, vin_rx_bus, vin = -1, -1, cached_params.carVin
+ car_fw = list(cached_params.carFw)
+ cached = True
+ else:
+ carlog.warning("Getting VIN & FW versions")
+ # enable OBD multiplexing for VIN query
+ # NOTE: this takes ~0.1s and is relied on to allow sendcan subscriber to connect in time
+ set_obd_multiplexing(True)
+ # VIN query only reliably works through OBDII
+ vin_rx_addr, vin_rx_bus, vin = get_vin(can_recv, can_send, (0, 1))
+ ecu_rx_addrs = get_present_ecus(can_recv, can_send, set_obd_multiplexing, num_pandas=num_pandas)
+ car_fw = get_fw_versions_ordered(can_recv, can_send, set_obd_multiplexing, vin, ecu_rx_addrs, num_pandas=num_pandas)
+ cached = False
+
+ exact_fw_match, fw_candidates = match_fw_to_car(car_fw, vin)
+ else:
+ vin_rx_addr, vin_rx_bus, vin = -1, -1, VIN_UNKNOWN
+ exact_fw_match, fw_candidates, car_fw = True, set(), []
+ cached = False
+
+ if not is_valid_vin(vin):
+ carlog.error({"event": "Malformed VIN", "vin": vin})
+ vin = VIN_UNKNOWN
+ carlog.warning("VIN %s", vin)
+
+ # disable OBD multiplexing for CAN fingerprinting and potential ECU knockouts
+ set_obd_multiplexing(False)
+
+ fw_query_time = time.monotonic() - start_time
+
+ # CAN fingerprint
+ # drain CAN socket so we get the latest messages
+ can_recv()
+ car_fingerprint, finger = can_fingerprint(can_recv)
+
+ exact_match = True
+ source = CarParams.FingerprintSource.can
+
+ # If FW query returns exactly 1 candidate, use it
+ if len(fw_candidates) == 1:
+ car_fingerprint = list(fw_candidates)[0]
+ source = CarParams.FingerprintSource.fw
+ exact_match = exact_fw_match
+
+ if fixed_fingerprint:
+ car_fingerprint = fixed_fingerprint
+ source = CarParams.FingerprintSource.fixed
+
+ carlog.error({"event": "fingerprinted", "car_fingerprint": str(car_fingerprint), "source": source, "fuzzy": not exact_match,
+ "cached": cached, "fw_count": len(car_fw), "ecu_responses": list(ecu_rx_addrs), "vin_rx_addr": vin_rx_addr,
+ "vin_rx_bus": vin_rx_bus, "fingerprints": repr(finger), "fw_query_time": fw_query_time})
+
+ return car_fingerprint, finger, vin, car_fw, source, exact_match
+
+
+def get_car_interface(CP: CarParams):
+ CarInterface, CarController, CarState = interfaces[CP.carFingerprint]
+ return CarInterface(CP, CarController, CarState)
+
+
+def get_car(can_recv: CanRecvCallable, can_send: CanSendCallable, set_obd_multiplexing: ObdCallback, experimental_long_allowed: bool,
+ num_pandas: int = 1, cached_params: CarParams | None = None):
+ candidate, fingerprints, vin, car_fw, source, exact_match = fingerprint(can_recv, can_send, set_obd_multiplexing, num_pandas, cached_params)
+
+ if candidate is None:
+ carlog.error({"event": "car doesn't match any fingerprints", "fingerprints": repr(fingerprints)})
+ candidate = "MOCK"
+
+ CarInterface, _, _ = interfaces[candidate]
+ CP: CarParams = CarInterface.get_params(candidate, fingerprints, car_fw, experimental_long_allowed, docs=False)
+ CP.carVin = vin
+ CP.carFw = car_fw
+ CP.fingerprintSource = source
+ CP.fuzzyFingerprint = not exact_match
+
+ return get_car_interface(CP)
+
+
+def get_demo_car_params():
+ platform = MOCK.MOCK
+ CarInterface, _, _ = interfaces[platform]
+ CP = CarInterface.get_non_essential_params(platform)
+ return CP
diff --git a/opendbc/car/chrysler/__init__.py b/opendbc/car/chrysler/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/opendbc/car/chrysler/carcontroller.py b/opendbc/car/chrysler/carcontroller.py
new file mode 100644
index 0000000000..4bc35d3397
--- /dev/null
+++ b/opendbc/car/chrysler/carcontroller.py
@@ -0,0 +1,84 @@
+import copy
+from opendbc.can.packer import CANPacker
+from opendbc.car import DT_CTRL, apply_meas_steer_torque_limits
+from opendbc.car.chrysler import chryslercan
+from opendbc.car.chrysler.values import RAM_CARS, CarControllerParams, ChryslerFlags
+from opendbc.car.interfaces import CarControllerBase
+
+
+class CarController(CarControllerBase):
+ def __init__(self, dbc_name, CP):
+ super().__init__(dbc_name, CP)
+ self.apply_steer_last = 0
+
+ self.hud_count = 0
+ self.last_lkas_falling_edge = 0
+ self.lkas_control_bit_prev = False
+ self.last_button_frame = 0
+
+ self.packer = CANPacker(dbc_name)
+ self.params = CarControllerParams(CP)
+
+ def update(self, CC, CS, now_nanos):
+ can_sends = []
+
+ lkas_active = CC.latActive and self.lkas_control_bit_prev
+
+ # cruise buttons
+ if (self.frame - self.last_button_frame)*DT_CTRL > 0.05:
+ das_bus = 2 if self.CP.carFingerprint in RAM_CARS else 0
+
+ # ACC cancellation
+ if CC.cruiseControl.cancel:
+ self.last_button_frame = self.frame
+ can_sends.append(chryslercan.create_cruise_buttons(self.packer, CS.button_counter + 1, das_bus, cancel=True))
+
+ # ACC resume from standstill
+ elif CC.cruiseControl.resume:
+ self.last_button_frame = self.frame
+ can_sends.append(chryslercan.create_cruise_buttons(self.packer, CS.button_counter + 1, das_bus, resume=True))
+
+ # HUD alerts
+ if self.frame % 25 == 0:
+ if CS.lkas_car_model != -1:
+ can_sends.append(chryslercan.create_lkas_hud(self.packer, self.CP, lkas_active, CC.hudControl.visualAlert,
+ self.hud_count, CS.lkas_car_model, CS.auto_high_beam))
+ self.hud_count += 1
+
+ # steering
+ if self.frame % self.params.STEER_STEP == 0:
+
+ # TODO: can we make this more sane? why is it different for all the cars?
+ lkas_control_bit = self.lkas_control_bit_prev
+ if CS.out.vEgo > self.CP.minSteerSpeed:
+ lkas_control_bit = True
+ elif self.CP.flags & ChryslerFlags.HIGHER_MIN_STEERING_SPEED:
+ if CS.out.vEgo < (self.CP.minSteerSpeed - 3.0):
+ lkas_control_bit = False
+ elif self.CP.carFingerprint in RAM_CARS:
+ if CS.out.vEgo < (self.CP.minSteerSpeed - 0.5):
+ lkas_control_bit = False
+
+ # EPS faults if LKAS re-enables too quickly
+ lkas_control_bit = lkas_control_bit and (self.frame - self.last_lkas_falling_edge > 200)
+
+ if not lkas_control_bit and self.lkas_control_bit_prev:
+ self.last_lkas_falling_edge = self.frame
+ self.lkas_control_bit_prev = lkas_control_bit
+
+ # steer torque
+ new_steer = int(round(CC.actuators.steer * self.params.STEER_MAX))
+ apply_steer = apply_meas_steer_torque_limits(new_steer, self.apply_steer_last, CS.out.steeringTorqueEps, self.params)
+ if not lkas_active or not lkas_control_bit:
+ apply_steer = 0
+ self.apply_steer_last = apply_steer
+
+ can_sends.append(chryslercan.create_lkas_command(self.packer, self.CP, int(apply_steer), lkas_control_bit))
+
+ self.frame += 1
+
+ new_actuators = copy.copy(CC.actuators)
+ new_actuators.steer = self.apply_steer_last / self.params.STEER_MAX
+ new_actuators.steerOutputCan = self.apply_steer_last
+
+ return new_actuators, can_sends
diff --git a/opendbc/car/chrysler/carstate.py b/opendbc/car/chrysler/carstate.py
new file mode 100644
index 0000000000..ab37008204
--- /dev/null
+++ b/opendbc/car/chrysler/carstate.py
@@ -0,0 +1,159 @@
+from opendbc.can.parser import CANParser
+from opendbc.can.can_define import CANDefine
+from opendbc.car import create_button_events, structs
+from opendbc.car.chrysler.values import DBC, STEER_THRESHOLD, RAM_CARS
+from opendbc.car.common.conversions import Conversions as CV
+from opendbc.car.interfaces import CarStateBase
+
+ButtonType = structs.CarState.ButtonEvent.Type
+
+
+class CarState(CarStateBase):
+ def __init__(self, CP):
+ super().__init__(CP)
+ self.CP = CP
+ can_define = CANDefine(DBC[CP.carFingerprint]["pt"])
+
+ self.auto_high_beam = 0
+ self.button_counter = 0
+ self.lkas_car_model = -1
+
+ if CP.carFingerprint in RAM_CARS:
+ self.shifter_values = can_define.dv["Transmission_Status"]["Gear_State"]
+ else:
+ self.shifter_values = can_define.dv["GEAR"]["PRNDL"]
+
+ self.distance_button = 0
+
+ def update(self, cp, cp_cam, *_) -> structs.CarState:
+
+ ret = structs.CarState()
+
+ prev_distance_button = self.distance_button
+ self.distance_button = cp.vl["CRUISE_BUTTONS"]["ACC_Distance_Dec"]
+
+ # lock info
+ ret.doorOpen = any([cp.vl["BCM_1"]["DOOR_OPEN_FL"],
+ cp.vl["BCM_1"]["DOOR_OPEN_FR"],
+ cp.vl["BCM_1"]["DOOR_OPEN_RL"],
+ cp.vl["BCM_1"]["DOOR_OPEN_RR"]])
+ ret.seatbeltUnlatched = cp.vl["ORC_1"]["SEATBELT_DRIVER_UNLATCHED"] == 1
+
+ # brake pedal
+ ret.brake = 0
+ ret.brakePressed = cp.vl["ESP_1"]['Brake_Pedal_State'] == 1 # Physical brake pedal switch
+
+ # gas pedal
+ ret.gas = cp.vl["ECM_5"]["Accelerator_Position"]
+ ret.gasPressed = ret.gas > 1e-5
+
+ # car speed
+ if self.CP.carFingerprint in RAM_CARS:
+ ret.vEgoRaw = cp.vl["ESP_8"]["Vehicle_Speed"] * CV.KPH_TO_MS
+ ret.gearShifter = self.parse_gear_shifter(self.shifter_values.get(cp.vl["Transmission_Status"]["Gear_State"], None))
+ else:
+ ret.vEgoRaw = (cp.vl["SPEED_1"]["SPEED_LEFT"] + cp.vl["SPEED_1"]["SPEED_RIGHT"]) / 2.
+ ret.gearShifter = self.parse_gear_shifter(self.shifter_values.get(cp.vl["GEAR"]["PRNDL"], None))
+ ret.vEgo, ret.aEgo = self.update_speed_kf(ret.vEgoRaw)
+ ret.standstill = not ret.vEgoRaw > 0.001
+ ret.wheelSpeeds = self.get_wheel_speeds(
+ cp.vl["ESP_6"]["WHEEL_SPEED_FL"],
+ cp.vl["ESP_6"]["WHEEL_SPEED_FR"],
+ cp.vl["ESP_6"]["WHEEL_SPEED_RL"],
+ cp.vl["ESP_6"]["WHEEL_SPEED_RR"],
+ unit=1,
+ )
+
+ # button presses
+ ret.leftBlinker, ret.rightBlinker = self.update_blinker_from_stalk(200, cp.vl["STEERING_LEVERS"]["TURN_SIGNALS"] == 1,
+ cp.vl["STEERING_LEVERS"]["TURN_SIGNALS"] == 2)
+ ret.genericToggle = cp.vl["STEERING_LEVERS"]["HIGH_BEAM_PRESSED"] == 1
+
+ # steering wheel
+ ret.steeringAngleDeg = cp.vl["STEERING"]["STEERING_ANGLE"] + cp.vl["STEERING"]["STEERING_ANGLE_HP"]
+ ret.steeringRateDeg = cp.vl["STEERING"]["STEERING_RATE"]
+ ret.steeringTorque = cp.vl["EPS_2"]["COLUMN_TORQUE"]
+ ret.steeringTorqueEps = cp.vl["EPS_2"]["EPS_TORQUE_MOTOR"]
+ ret.steeringPressed = abs(ret.steeringTorque) > STEER_THRESHOLD
+
+ # cruise state
+ cp_cruise = cp_cam if self.CP.carFingerprint in RAM_CARS else cp
+
+ ret.cruiseState.available = cp_cruise.vl["DAS_3"]["ACC_AVAILABLE"] == 1
+ ret.cruiseState.enabled = cp_cruise.vl["DAS_3"]["ACC_ACTIVE"] == 1
+ ret.cruiseState.speed = cp_cruise.vl["DAS_4"]["ACC_SET_SPEED_KPH"] * CV.KPH_TO_MS
+ ret.cruiseState.nonAdaptive = cp_cruise.vl["DAS_4"]["ACC_STATE"] in (1, 2) # 1 NormalCCOn and 2 NormalCCSet
+ ret.cruiseState.standstill = cp_cruise.vl["DAS_3"]["ACC_STANDSTILL"] == 1
+ ret.accFaulted = cp_cruise.vl["DAS_3"]["ACC_FAULTED"] != 0
+
+ if self.CP.carFingerprint in RAM_CARS:
+ # Auto High Beam isn't Located in this message on chrysler or jeep currently located in 729 message
+ self.auto_high_beam = cp_cam.vl["DAS_6"]['AUTO_HIGH_BEAM_ON']
+ ret.steerFaultTemporary = cp.vl["EPS_3"]["DASM_FAULT"] == 1
+ else:
+ ret.steerFaultTemporary = cp.vl["EPS_2"]["LKAS_TEMPORARY_FAULT"] == 1
+ ret.steerFaultPermanent = cp.vl["EPS_2"]["LKAS_STATE"] == 4
+
+ # blindspot sensors
+ if self.CP.enableBsm:
+ ret.leftBlindspot = cp.vl["BSM_1"]["LEFT_STATUS"] == 1
+ ret.rightBlindspot = cp.vl["BSM_1"]["RIGHT_STATUS"] == 1
+
+ self.lkas_car_model = cp_cam.vl["DAS_6"]["CAR_MODEL"]
+ self.button_counter = cp.vl["CRUISE_BUTTONS"]["COUNTER"]
+
+ ret.buttonEvents = create_button_events(self.distance_button, prev_distance_button, {1: ButtonType.gapAdjustCruise})
+
+ return ret
+
+ @staticmethod
+ def get_cruise_messages():
+ messages = [
+ ("DAS_3", 50),
+ ("DAS_4", 50),
+ ]
+ return messages
+
+ @staticmethod
+ def get_can_parser(CP):
+ messages = [
+ # sig_address, frequency
+ ("ESP_1", 50),
+ ("EPS_2", 100),
+ ("ESP_6", 50),
+ ("STEERING", 100),
+ ("ECM_5", 50),
+ ("CRUISE_BUTTONS", 50),
+ ("STEERING_LEVERS", 10),
+ ("ORC_1", 2),
+ ("BCM_1", 1),
+ ]
+
+ if CP.enableBsm:
+ messages.append(("BSM_1", 2))
+
+ if CP.carFingerprint in RAM_CARS:
+ messages += [
+ ("ESP_8", 50),
+ ("EPS_3", 50),
+ ("Transmission_Status", 50),
+ ]
+ else:
+ messages += [
+ ("GEAR", 50),
+ ("SPEED_1", 100),
+ ]
+ messages += CarState.get_cruise_messages()
+
+ return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
+
+ @staticmethod
+ def get_cam_can_parser(CP):
+ messages = [
+ ("DAS_6", 4),
+ ]
+
+ if CP.carFingerprint in RAM_CARS:
+ messages += CarState.get_cruise_messages()
+
+ return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)
diff --git a/opendbc/car/chrysler/chryslercan.py b/opendbc/car/chrysler/chryslercan.py
new file mode 100644
index 0000000000..8a0755ac5d
--- /dev/null
+++ b/opendbc/car/chrysler/chryslercan.py
@@ -0,0 +1,71 @@
+from opendbc.car import structs
+from opendbc.car.chrysler.values import RAM_CARS
+
+GearShifter = structs.CarState.GearShifter
+VisualAlert = structs.CarControl.HUDControl.VisualAlert
+
+def create_lkas_hud(packer, CP, lkas_active, hud_alert, hud_count, car_model, auto_high_beam):
+ # LKAS_HUD - Controls what lane-keeping icon is displayed
+
+ # == Color ==
+ # 0 hidden?
+ # 1 white
+ # 2 green
+ # 3 ldw
+
+ # == Lines ==
+ # 03 white Lines
+ # 04 grey lines
+ # 09 left lane close
+ # 0A right lane close
+ # 0B left Lane very close
+ # 0C right Lane very close
+ # 0D left cross cross
+ # 0E right lane cross
+
+ # == Alerts ==
+ # 7 Normal
+ # 6 lane departure place hands on wheel
+
+ color = 2 if lkas_active else 1
+ lines = 3 if lkas_active else 0
+ alerts = 7 if lkas_active else 0
+
+ if hud_count < (1 * 4): # first 3 seconds, 4Hz
+ alerts = 1
+
+ if hud_alert in (VisualAlert.ldw, VisualAlert.steerRequired):
+ color = 4
+ lines = 0
+ alerts = 6
+
+ values = {
+ "LKAS_ICON_COLOR": color,
+ "CAR_MODEL": car_model,
+ "LKAS_LANE_LINES": lines,
+ "LKAS_ALERTS": alerts,
+ }
+
+ if CP.carFingerprint in RAM_CARS:
+ values['AUTO_HIGH_BEAM_ON'] = auto_high_beam
+
+ return packer.make_can_msg("DAS_6", 0, values)
+
+
+def create_lkas_command(packer, CP, apply_steer, lkas_control_bit):
+ # LKAS_COMMAND Lane-keeping signal to turn the wheel
+ enabled_val = 2 if CP.carFingerprint in RAM_CARS else 1
+ values = {
+ "STEERING_TORQUE": apply_steer,
+ "LKAS_CONTROL_BIT": enabled_val if lkas_control_bit else 0,
+ }
+ return packer.make_can_msg("LKAS_COMMAND", 0, values)
+
+
+def create_cruise_buttons(packer, frame, bus, cancel=False, resume=False):
+ values = {
+ "ACC_Cancel": cancel,
+ "ACC_Resume": resume,
+ "COUNTER": frame % 0x10,
+ }
+ return packer.make_can_msg("CRUISE_BUTTONS", bus, values)
diff --git a/opendbc/car/chrysler/fingerprints.py b/opendbc/car/chrysler/fingerprints.py
new file mode 100644
index 0000000000..072eafb1d0
--- /dev/null
+++ b/opendbc/car/chrysler/fingerprints.py
@@ -0,0 +1,716 @@
+from opendbc.car.structs import CarParams
+from opendbc.car.chrysler.values import CAR
+
+Ecu = CarParams.Ecu
+
+FW_VERSIONS = {
+ CAR.CHRYSLER_PACIFICA_2018: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68227902AF',
+ b'68227902AG',
+ b'68227902AH',
+ b'68227905AG',
+ b'68360252AC',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68211617AF',
+ b'68211617AG',
+ b'68358974AC',
+ b'68405937AA',
+ ],
+ (Ecu.abs, 0x747, None): [
+ b'68222747AG',
+ b'68330876AA',
+ b'68330876AB',
+ b'68352227AA',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672758AA',
+ b'04672758AB',
+ b'68226356AF',
+ b'68226356AH',
+ b'68226356AI',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'68288891AE',
+ b'68378884AA',
+ b'68525338AA',
+ b'68525338AB',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'68267018AO ',
+ b'68267020AJ ',
+ b'68303534AG ',
+ b'68303534AJ ',
+ b'68340762AD ',
+ b'68340764AD ',
+ b'68352652AE ',
+ b'68352654AE ',
+ b'68366851AH ',
+ b'68366853AE ',
+ b'68366853AG ',
+ b'68372861AF ',
+ ],
+ (Ecu.transmission, 0x7e1, None): [
+ b'68277370AJ',
+ b'68277370AM',
+ b'68277372AD',
+ b'68277372AE',
+ b'68277372AN',
+ b'68277374AA',
+ b'68277374AB',
+ b'68277374AD',
+ b'68277374AN',
+ b'68367471AC',
+ b'68367471AD',
+ b'68380571AB',
+ ],
+ },
+ CAR.CHRYSLER_PACIFICA_2020: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68405327AC',
+ b'68436233AB',
+ b'68436233AC',
+ b'68436234AB',
+ b'68436250AE',
+ b'68529067AA',
+ b'68594993AB',
+ b'68594994AB',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68405565AB',
+ b'68405565AC',
+ b'68444299AC',
+ b'68480707AC',
+ b'68480708AC',
+ b'68526663AB',
+ ],
+ (Ecu.abs, 0x747, None): [
+ b'68397394AA',
+ b'68433480AB',
+ b'68453575AF',
+ b'68577676AA',
+ b'68593395AA',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672758AA',
+ b'04672758AB',
+ b'68417813AF',
+ b'68540436AA',
+ b'68540436AC',
+ b'68540436AD',
+ b'68598670AB',
+ b'68598670AC',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'68416742AA',
+ b'68460393AA',
+ b'68460393AB',
+ b'68494461AB',
+ b'68494461AC',
+ b'68524936AA',
+ b'68524936AB',
+ b'68525338AB',
+ b'68594337AB',
+ b'68594340AB',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'68413871AD ',
+ b'68413871AE ',
+ b'68413871AH ',
+ b'68413871AI ',
+ b'68413873AH ',
+ b'68413873AI ',
+ b'68443120AE ',
+ b'68443123AC ',
+ b'68443125AC ',
+ b'68496647AI ',
+ b'68496647AJ ',
+ b'68496650AH ',
+ b'68496650AI ',
+ b'68496652AH ',
+ b'68526752AD ',
+ b'68526752AE ',
+ b'68526754AE ',
+ b'68536264AE ',
+ b'68700304AB ',
+ b'68700306AB ',
+ ],
+ (Ecu.transmission, 0x7e1, None): [
+ b'68414271AC',
+ b'68414271AD',
+ b'68414275AC',
+ b'68414275AD',
+ b'68443154AB',
+ b'68443155AC',
+ b'68443158AB',
+ b'68501050AD',
+ b'68501051AD',
+ b'68501055AD',
+ b'68527221AB',
+ b'68527223AB',
+ b'68586231AD',
+ b'68586233AD',
+ ],
+ },
+ CAR.CHRYSLER_PACIFICA_2018_HYBRID: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68239262AH',
+ b'68239262AI',
+ b'68239262AJ',
+ b'68239263AH',
+ b'68239263AJ',
+ b'68358439AE',
+ b'68358439AG',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68238840AH',
+ b'68358990AC',
+ b'68405939AA',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672758AA',
+ b'68226356AI',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'68288309AC',
+ b'68288309AD',
+ b'68525339AA',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'68277480AV ',
+ b'68277480AX ',
+ b'68277480AZ ',
+ b'68366580AI ',
+ b'68366580AK ',
+ b'68366580AM ',
+ ],
+ (Ecu.hybrid, 0x7e2, None): [
+ b'05190175BF',
+ b'05190175BH',
+ b'05190226AI',
+ b'05190226AK',
+ b'05190226AM',
+ ],
+ },
+ CAR.CHRYSLER_PACIFICA_2019_HYBRID: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68405292AC',
+ b'68434956AC',
+ b'68434956AD',
+ b'68434960AE',
+ b'68434960AF',
+ b'68529064AB',
+ b'68594990AB',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68405567AB',
+ b'68405567AC',
+ b'68453076AD',
+ b'68480710AC',
+ b'68526665AB',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672758AB',
+ b'68417813AF',
+ b'68540436AA',
+ b'68540436AB',
+ b'68540436AC',
+ b'68540436AD',
+ b'68598670AB',
+ b'68598670AC',
+ b'68645752AA',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'68416741AA',
+ b'68460392AA',
+ b'68525339AA',
+ b'68525339AB',
+ b'68594341AB',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'68416680AE ',
+ b'68416680AF ',
+ b'68416680AG ',
+ b'68444228AC ',
+ b'68444228AD ',
+ b'68444228AE ',
+ b'68444228AF ',
+ b'68499122AD ',
+ b'68499122AE ',
+ b'68499122AF ',
+ b'68526772AD ',
+ b'68526772AH ',
+ b'68599493AC ',
+ b'68657433AA ',
+ ],
+ (Ecu.hybrid, 0x7e2, None): [
+ b'05185116AF',
+ b'05185116AJ',
+ b'05185116AK',
+ b'05190240AP',
+ b'05190240AQ',
+ b'05190240AR',
+ b'05190265AG',
+ b'05190265AH',
+ b'05190289AE',
+ b'68540977AH',
+ b'68540977AK',
+ b'68597647AE',
+ b'68632416AB',
+ ],
+ },
+ CAR.JEEP_GRAND_CHEROKEE: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68243549AG',
+ b'68302211AC',
+ b'68302212AD',
+ b'68302223AC',
+ b'68302246AC',
+ b'68331511AC',
+ b'68331574AC',
+ b'68331687AC',
+ b'68331690AC',
+ b'68340272AD',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68309533AA',
+ b'68316742AB',
+ b'68355363AB',
+ ],
+ (Ecu.abs, 0x747, None): [
+ b'68252642AG',
+ b'68306178AD',
+ b'68336275AB',
+ b'68336276AB',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672627AB',
+ b'68251506AF',
+ b'68332015AB',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'68276201AG',
+ b'68321644AB',
+ b'68321644AC',
+ b'68321646AC',
+ b'68321648AC',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'05035920AE ',
+ b'68252272AG ',
+ b'68284455AI ',
+ b'68284456AI ',
+ b'68284477AF ',
+ b'68325564AH ',
+ b'68325564AI ',
+ b'68325565AH ',
+ b'68325565AI ',
+ b'68325618AD ',
+ ],
+ (Ecu.transmission, 0x7e1, None): [
+ b'05035517AH',
+ b'68253222AF',
+ b'68311218AC',
+ b'68311223AF',
+ b'68311223AG',
+ b'68361911AE',
+ b'68361911AF',
+ b'68361911AH',
+ b'68361916AD',
+ ],
+ },
+ CAR.JEEP_GRAND_CHEROKEE_2019: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68402703AB',
+ b'68402704AB',
+ b'68402708AB',
+ b'68402971AD',
+ b'68454144AD',
+ b'68454145AB',
+ b'68454152AB',
+ b'68454156AB',
+ b'68516650AB',
+ b'68516651AB',
+ b'68516669AB',
+ b'68516671AB',
+ b'68516683AB',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68355363AB',
+ b'68355364AB',
+ ],
+ (Ecu.abs, 0x747, None): [
+ b'68408639AC',
+ b'68408639AD',
+ b'68499978AB',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672788AA',
+ b'68456722AC',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'68417279AA',
+ b'68417280AA',
+ b'68417281AA',
+ b'68453431AA',
+ b'68453433AA',
+ b'68453435AA',
+ b'68499171AA',
+ b'68499171AB',
+ b'68501183AA',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'05035674AB ',
+ b'68412635AG ',
+ b'68412660AD ',
+ b'68422860AB',
+ b'68449435AE ',
+ b'68496223AA ',
+ b'68504959AD ',
+ b'68504959AE ',
+ b'68504960AD ',
+ b'68504993AC ',
+ ],
+ (Ecu.transmission, 0x7e1, None): [
+ b'05035707AA',
+ b'68419672AC',
+ b'68419678AB',
+ b'68423905AB',
+ b'68449258AC',
+ b'68495807AA',
+ b'68495807AB',
+ b'68503641AC',
+ b'68503664AC',
+ ],
+ },
+ CAR.RAM_1500_5TH_GEN: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68294051AG',
+ b'68294051AI',
+ b'68294052AG',
+ b'68294052AH',
+ b'68294059AI',
+ b'68294063AG',
+ b'68294063AH',
+ b'68294063AI',
+ b'68434846AC',
+ b'68434847AC',
+ b'68434849AC',
+ b'68434856AC',
+ b'68434858AC',
+ b'68434859AC',
+ b'68434860AC',
+ b'68453471AD',
+ b'68453483AC',
+ b'68453483AD',
+ b'68453487AD',
+ b'68453491AC',
+ b'68453491AD',
+ b'68453499AD',
+ b'68453503AC',
+ b'68453503AD',
+ b'68453505AC',
+ b'68453505AD',
+ b'68453511AC',
+ b'68453513AC',
+ b'68453513AD',
+ b'68453514AD',
+ b'68505633AB',
+ b'68510277AG',
+ b'68510277AH',
+ b'68510280AG',
+ b'68510282AG',
+ b'68510282AH',
+ b'68510283AG',
+ b'68527346AE',
+ b'68527361AD',
+ b'68527375AD',
+ b'68527381AD',
+ b'68527381AE',
+ b'68527382AE',
+ b'68527383AD',
+ b'68527383AE',
+ b'68527387AE',
+ b'68527397AD',
+ b'68527403AC',
+ b'68527403AD',
+ b'68546047AF',
+ b'68631938AA',
+ b'68631939AA',
+ b'68631940AA',
+ b'68631940AB',
+ b'68631942AA',
+ b'68631943AB',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68428609AB',
+ b'68441329AB',
+ b'68473844AB',
+ b'68490898AA',
+ b'68500728AA',
+ b'68615033AA',
+ b'68615034AA',
+ ],
+ (Ecu.abs, 0x747, None): [
+ b'68292406AG',
+ b'68292406AH',
+ b'68432418AB',
+ b'68432418AC',
+ b'68432418AD',
+ b'68436004AD',
+ b'68436004AE',
+ b'68438454AC',
+ b'68438454AD',
+ b'68438456AE',
+ b'68438456AF',
+ b'68535469AB',
+ b'68535470AC',
+ b'68548900AB',
+ b'68586307AB',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672892AB',
+ b'04672932AB',
+ b'04672932AC',
+ b'22DTRHD_AA',
+ b'68320950AH',
+ b'68320950AI',
+ b'68320950AJ',
+ b'68320950AL',
+ b'68320950AM',
+ b'68454268AB',
+ b'68475160AE',
+ b'68475160AF',
+ b'68475160AG',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'21590101AA',
+ b'21590101AB',
+ b'68273275AF',
+ b'68273275AG',
+ b'68273275AH',
+ b'68312176AE',
+ b'68312176AF',
+ b'68312176AG',
+ b'68440789AC',
+ b'68466110AA',
+ b'68466110AB',
+ b'68466113AA',
+ b'68469901AA',
+ b'68469907AA',
+ b'68522583AA',
+ b'68522583AB',
+ b'68522584AA',
+ b'68522585AB',
+ b'68552788AA',
+ b'68552789AA',
+ b'68552790AA',
+ b'68552791AB',
+ b'68552794AA',
+ b'68552794AD',
+ b'68585106AB',
+ b'68585107AB',
+ b'68585108AB',
+ b'68585109AB',
+ b'68585112AB',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'05035699AG ',
+ b'05035841AC ',
+ b'05035841AD ',
+ b'05036026AB ',
+ b'05036065AE ',
+ b'05036066AE ',
+ b'05036067AE ',
+ b'05036193AA ',
+ b'05149368AA ',
+ b'05149374AA ',
+ b'05149591AD ',
+ b'05149591AE ',
+ b'05149592AE ',
+ b'05149599AE ',
+ b'05149600AD ',
+ b'05149600AE ',
+ b'05149605AE ',
+ b'05149846AA ',
+ b'05149848AA ',
+ b'05149848AC ',
+ b'05190341AD',
+ b'68378695AJ ',
+ b'68378696AJ ',
+ b'68378696AK ',
+ b'68378701AI ',
+ b'68378702AI ',
+ b'68378710AL ',
+ b'68378742AI ',
+ b'68378742AK ',
+ b'68378743AM ',
+ b'68378748AL ',
+ b'68378758AM ',
+ b'68448163AJ',
+ b'68448163AK',
+ b'68448163AL',
+ b'68448165AG',
+ b'68448165AK',
+ b'68455111AC ',
+ b'68455119AC ',
+ b'68455145AC ',
+ b'68455145AE ',
+ b'68455146AC ',
+ b'68460927AA ',
+ b'68467915AC ',
+ b'68467916AC ',
+ b'68467936AC ',
+ b'68500630AD',
+ b'68500630AE',
+ b'68500631AE',
+ b'68502719AC ',
+ b'68502722AC ',
+ b'68502733AC ',
+ b'68502734AF ',
+ b'68502740AF ',
+ b'68502741AF ',
+ b'68502742AC ',
+ b'68502742AF ',
+ b'68539650AD',
+ b'68539650AF',
+ b'68539651AD',
+ b'68586101AA ',
+ b'68586102AA ',
+ b'68586105AB ',
+ b'68629919AC ',
+ b'68629922AC ',
+ b'68629925AC ',
+ b'68629926AC ',
+ ],
+ (Ecu.transmission, 0x7e1, None): [
+ b'05035706AD',
+ b'05035842AB',
+ b'05036069AA',
+ b'05036181AA',
+ b'05149536AC',
+ b'05149537AC',
+ b'05149543AC',
+ b'68360078AL',
+ b'68360080AL',
+ b'68360080AM',
+ b'68360081AM',
+ b'68360085AJ',
+ b'68360085AL',
+ b'68360086AH',
+ b'68360086AK',
+ b'68360086AN',
+ b'68384328AD',
+ b'68384332AD',
+ b'68445531AC',
+ b'68445533AB',
+ b'68445536AB',
+ b'68445537AB',
+ b'68466081AB',
+ b'68466087AB',
+ b'68484466AC',
+ b'68484467AC',
+ b'68484471AC',
+ b'68502994AD',
+ b'68502996AD',
+ b'68520867AE',
+ b'68520867AF',
+ b'68520870AC',
+ b'68520871AC',
+ b'68528325AE',
+ b'68540431AB',
+ b'68540433AB',
+ b'68551676AA',
+ b'68629935AB',
+ b'68629936AC',
+ ],
+ },
+ CAR.RAM_HD_5TH_GEN: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68361606AH',
+ b'68437735AC',
+ b'68492693AD',
+ b'68525485AB',
+ b'68525487AB',
+ b'68525498AB',
+ b'68528791AF',
+ b'68628474AB',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68399794AC',
+ b'68428503AA',
+ b'68428505AA',
+ b'68428507AA',
+ ],
+ (Ecu.abs, 0x747, None): [
+ b'68334977AH',
+ b'68455481AC',
+ b'68504022AA',
+ b'68504022AB',
+ b'68504022AC',
+ b'68530686AB',
+ b'68530686AC',
+ b'68544596AC',
+ b'68641704AA',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'04672895AB',
+ b'04672934AB',
+ b'56029827AG',
+ b'56029827AH',
+ b'68462657AE',
+ b'68484694AD',
+ b'68484694AE',
+ b'68615489AB',
+ ],
+ (Ecu.eps, 0x761, None): [
+ b'68421036AC',
+ b'68507906AB',
+ b'68534023AC',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'52370131AF',
+ b'52370231AF',
+ b'52370231AG',
+ b'52370491AA',
+ b'52370931CT',
+ b'52401032AE',
+ b'52421132AF',
+ b'52421332AF',
+ b'68527616AD ',
+ b'M2370131MB',
+ b'M2421132MB',
+ ],
+ },
+ CAR.DODGE_DURANGO: {
+ (Ecu.combinationMeter, 0x742, None): [
+ b'68454261AD',
+ b'68471535AE',
+ ],
+ (Ecu.srs, 0x744, None): [
+ b'68355362AB',
+ b'68492238AD',
+ ],
+ (Ecu.abs, 0x747, None): [
+ b'68408639AD',
+ b'68499978AB',
+ ],
+ (Ecu.fwdRadar, 0x753, None): [
+ b'68440581AE',
+ b'68456722AC',
+ ],
+ (Ecu.eps, 0x75a, None): [
+ b'68453435AA',
+ b'68498477AA',
+ ],
+ (Ecu.engine, 0x7e0, None): [
+ b'05035786AE ',
+ b'68449476AE ',
+ ],
+ (Ecu.transmission, 0x7e1, None): [
+ b'05035826AC',
+ b'68449265AC',
+ ],
+ },
+}
diff --git a/opendbc/car/chrysler/interface.py b/opendbc/car/chrysler/interface.py
new file mode 100755
index 0000000000..a5c7f5bd2c
--- /dev/null
+++ b/opendbc/car/chrysler/interface.py
@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+from panda import Panda
+from opendbc.car import get_safety_config, structs
+from opendbc.car.chrysler.values import CAR, RAM_HD, RAM_DT, RAM_CARS, ChryslerFlags
+from opendbc.car.interfaces import CarInterfaceBase
+
+
+class CarInterface(CarInterfaceBase):
+ @staticmethod
+ def _get_params(ret: structs.CarParams, candidate, fingerprint, car_fw, experimental_long, docs) -> structs.CarParams:
+ ret.carName = "chrysler"
+ ret.dashcamOnly = candidate in RAM_HD
+
+ # radar parsing needs some work, see https://github.com/commaai/openpilot/issues/26842
+ ret.radarUnavailable = True # DBC[candidate]['radar'] is None
+ ret.steerActuatorDelay = 0.1
+ ret.steerLimitTimer = 0.4
+
+ # safety config
+ ret.safetyConfigs = [get_safety_config(structs.CarParams.SafetyModel.chrysler)]
+ if candidate in RAM_HD:
+ ret.safetyConfigs[0].safetyParam |= Panda.FLAG_CHRYSLER_RAM_HD
+ elif candidate in RAM_DT:
+ ret.safetyConfigs[0].safetyParam |= Panda.FLAG_CHRYSLER_RAM_DT
+
+ CarInterfaceBase.configure_torque_tune(candidate, ret.lateralTuning)
+ if candidate not in RAM_CARS:
+ # Newer FW versions standard on the following platforms, or flashed by a dealer onto older platforms have a higher minimum steering speed.
+ new_eps_platform = candidate in (CAR.CHRYSLER_PACIFICA_2019_HYBRID, CAR.CHRYSLER_PACIFICA_2020, CAR.JEEP_GRAND_CHEROKEE_2019, CAR.DODGE_DURANGO)
+ new_eps_firmware = any(fw.ecu == 'eps' and fw.fwVersion[:4] >= b"6841" for fw in car_fw)
+ if new_eps_platform or new_eps_firmware:
+ ret.flags |= ChryslerFlags.HIGHER_MIN_STEERING_SPEED.value
+
+ # Chrysler
+ if candidate in (CAR.CHRYSLER_PACIFICA_2018, CAR.CHRYSLER_PACIFICA_2018_HYBRID, CAR.CHRYSLER_PACIFICA_2019_HYBRID,
+ CAR.CHRYSLER_PACIFICA_2020, CAR.DODGE_DURANGO):
+ ret.lateralTuning.init('pid')
+ ret.lateralTuning.pid.kpBP, ret.lateralTuning.pid.kiBP = [[9., 20.], [9., 20.]]
+ ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.15, 0.30], [0.03, 0.05]]
+ ret.lateralTuning.pid.kf = 0.00006
+
+ # Jeep
+ elif candidate in (CAR.JEEP_GRAND_CHEROKEE, CAR.JEEP_GRAND_CHEROKEE_2019):
+ ret.steerActuatorDelay = 0.2
+
+ ret.lateralTuning.init('pid')
+ ret.lateralTuning.pid.kpBP, ret.lateralTuning.pid.kiBP = [[9., 20.], [9., 20.]]
+ ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.15, 0.30], [0.03, 0.05]]
+ ret.lateralTuning.pid.kf = 0.00006
+
+ # Ram
+ elif candidate == CAR.RAM_1500_5TH_GEN:
+ ret.steerActuatorDelay = 0.2
+ ret.wheelbase = 3.88
+ # Older EPS FW allow steer to zero
+ if any(fw.ecu == 'eps' and b"68" < fw.fwVersion[:4] <= b"6831" for fw in car_fw):
+ ret.minSteerSpeed = 0.
+
+ elif candidate == CAR.RAM_HD_5TH_GEN:
+ ret.steerActuatorDelay = 0.2
+ CarInterfaceBase.configure_torque_tune(candidate, ret.lateralTuning, 1.0, False)
+
+ else:
+ raise ValueError(f"Unsupported car: {candidate}")
+
+ if ret.flags & ChryslerFlags.HIGHER_MIN_STEERING_SPEED:
+ # TODO: allow these cars to steer down to 13 m/s if already engaged.
+ # TODO: Durango 2020 may be able to steer to zero once above 38 kph
+ ret.minSteerSpeed = 17.5 # m/s 17 on the way up, 13 on the way down once engaged.
+
+ ret.centerToFront = ret.wheelbase * 0.44
+ ret.enableBsm = 720 in fingerprint[0]
+
+ return ret
diff --git a/opendbc/car/chrysler/radar_interface.py b/opendbc/car/chrysler/radar_interface.py
new file mode 100755
index 0000000000..3528373f8d
--- /dev/null
+++ b/opendbc/car/chrysler/radar_interface.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+from opendbc.can.parser import CANParser
+from opendbc.car import structs
+from opendbc.car.interfaces import RadarInterfaceBase
+from opendbc.car.chrysler.values import DBC
+
+RADAR_MSGS_C = list(range(0x2c2, 0x2d4+2, 2)) # c_ messages 706,...,724
+RADAR_MSGS_D = list(range(0x2a2, 0x2b4+2, 2)) # d_ messages
+LAST_MSG = max(RADAR_MSGS_C + RADAR_MSGS_D)
+NUMBER_MSGS = len(RADAR_MSGS_C) + len(RADAR_MSGS_D)
+
+def _create_radar_can_parser(car_fingerprint):
+ dbc = DBC[car_fingerprint]['radar']
+ if dbc is None:
+ return None
+
+ msg_n = len(RADAR_MSGS_C)
+ # list of [(signal name, message name or number), (...)]
+ # [('RADAR_STATE', 1024),
+ # ('LONG_DIST', 1072),
+ # ('LONG_DIST', 1073),
+ # ('LONG_DIST', 1074),
+ # ('LONG_DIST', 1075),
+
+ messages = list(zip(RADAR_MSGS_C +
+ RADAR_MSGS_D,
+ [20] * msg_n + # 20Hz (0.05s)
+ [20] * msg_n, strict=True)) # 20Hz (0.05s)
+
+ return CANParser(DBC[car_fingerprint]['radar'], messages, 1)
+
+def _address_to_track(address):
+ if address in RADAR_MSGS_C:
+ return (address - RADAR_MSGS_C[0]) // 2
+ if address in RADAR_MSGS_D:
+ return (address - RADAR_MSGS_D[0]) // 2
+ raise ValueError("radar received unexpected address %d" % address)
+
+class RadarInterface(RadarInterfaceBase):
+ def __init__(self, CP):
+ super().__init__(CP)
+ self.rcp = _create_radar_can_parser(CP.carFingerprint)
+ self.updated_messages = set()
+ self.trigger_msg = LAST_MSG
+
+ def update(self, can_strings):
+ if self.rcp is None or self.CP.radarUnavailable:
+ return super().update(None)
+
+ vls = self.rcp.update_strings(can_strings)
+ self.updated_messages.update(vls)
+
+ if self.trigger_msg not in self.updated_messages:
+ return None
+
+ ret = structs.RadarData()
+ errors = []
+ if not self.rcp.can_valid:
+ errors.append("canError")
+ ret.errors = errors
+
+ for ii in self.updated_messages: # ii should be the message ID as a number
+ cpt = self.rcp.vl[ii]
+ trackId = _address_to_track(ii)
+
+ if trackId not in self.pts:
+ self.pts[trackId] = structs.RadarData.RadarPoint()
+ self.pts[trackId].trackId = trackId
+ self.pts[trackId].aRel = float('nan')
+ self.pts[trackId].yvRel = float('nan')
+ self.pts[trackId].measured = True
+
+ if 'LONG_DIST' in cpt: # c_* message
+ self.pts[trackId].dRel = cpt['LONG_DIST'] # from front of car
+ # our lat_dist is positive to the right in car's frame.
+ # TODO what does yRel want?
+ self.pts[trackId].yRel = cpt['LAT_DIST'] # in car frame's y axis, left is positive
+ else: # d_* message
+ self.pts[trackId].vRel = cpt['REL_SPEED']
+
+ # We want a list, not a dictionary. Filter out LONG_DIST==0 because that means it's not valid.
+ ret.points = [x for x in self.pts.values() if x.dRel != 0]
+
+ self.updated_messages.clear()
+ return ret
diff --git a/opendbc/car/chrysler/values.py b/opendbc/car/chrysler/values.py
new file mode 100644
index 0000000000..472b707f9d
--- /dev/null
+++ b/opendbc/car/chrysler/values.py
@@ -0,0 +1,152 @@
+from enum import IntFlag
+from dataclasses import dataclass, field
+
+from panda import uds
+from opendbc.car import CarSpecs, DbcDict, PlatformConfig, Platforms, dbc_dict
+from opendbc.car.structs import CarParams
+from opendbc.car.docs_definitions import CarHarness, CarDocs, CarParts
+from opendbc.car.fw_query_definitions import FwQueryConfig, Request, p16
+
+Ecu = CarParams.Ecu
+
+
+class ChryslerFlags(IntFlag):
+ # Detected flags
+ HIGHER_MIN_STEERING_SPEED = 1
+
+@dataclass
+class ChryslerCarDocs(CarDocs):
+ package: str = "Adaptive Cruise Control (ACC)"
+ car_parts: CarParts = field(default_factory=CarParts.common([CarHarness.fca]))
+
+
+@dataclass
+class ChryslerPlatformConfig(PlatformConfig):
+ dbc_dict: DbcDict = field(default_factory=lambda: dbc_dict('chrysler_pacifica_2017_hybrid_generated', 'chrysler_pacifica_2017_hybrid_private_fusion'))
+
+
+@dataclass(frozen=True)
+class ChryslerCarSpecs(CarSpecs):
+ minSteerSpeed: float = 3.8 # m/s
+
+
+class CAR(Platforms):
+ # Chrysler
+ CHRYSLER_PACIFICA_2018_HYBRID = ChryslerPlatformConfig(
+ [ChryslerCarDocs("Chrysler Pacifica Hybrid 2017-18")],
+ ChryslerCarSpecs(mass=2242., wheelbase=3.089, steerRatio=16.2),
+ )
+ CHRYSLER_PACIFICA_2019_HYBRID = ChryslerPlatformConfig(
+ [ChryslerCarDocs("Chrysler Pacifica Hybrid 2019-24")],
+ CHRYSLER_PACIFICA_2018_HYBRID.specs,
+ )
+ CHRYSLER_PACIFICA_2018 = ChryslerPlatformConfig(
+ [ChryslerCarDocs("Chrysler Pacifica 2017-18")],
+ CHRYSLER_PACIFICA_2018_HYBRID.specs,
+ )
+ CHRYSLER_PACIFICA_2020 = ChryslerPlatformConfig(
+ [
+ ChryslerCarDocs("Chrysler Pacifica 2019-20"),
+ ChryslerCarDocs("Chrysler Pacifica 2021-23", package="All"),
+ ],
+ CHRYSLER_PACIFICA_2018_HYBRID.specs,
+ )
+
+ # Dodge
+ DODGE_DURANGO = ChryslerPlatformConfig(
+ [ChryslerCarDocs("Dodge Durango 2020-21")],
+ CHRYSLER_PACIFICA_2018_HYBRID.specs,
+ )
+
+ # Jeep
+ JEEP_GRAND_CHEROKEE = ChryslerPlatformConfig( # includes 2017 Trailhawk
+ [ChryslerCarDocs("Jeep Grand Cherokee 2016-18", video_link="https://www.youtube.com/watch?v=eLR9o2JkuRk")],
+ ChryslerCarSpecs(mass=1778., wheelbase=2.71, steerRatio=16.7),
+ )
+
+ JEEP_GRAND_CHEROKEE_2019 = ChryslerPlatformConfig( # includes 2020 Trailhawk
+ [ChryslerCarDocs("Jeep Grand Cherokee 2019-21", video_link="https://www.youtube.com/watch?v=jBe4lWnRSu4")],
+ JEEP_GRAND_CHEROKEE.specs,
+ )
+
+ # Ram
+ RAM_1500_5TH_GEN = ChryslerPlatformConfig(
+ [ChryslerCarDocs("Ram 1500 2019-24", car_parts=CarParts.common([CarHarness.ram]))],
+ ChryslerCarSpecs(mass=2493., wheelbase=3.88, steerRatio=16.3, minSteerSpeed=14.5),
+ dbc_dict('chrysler_ram_dt_generated', None),
+ )
+ RAM_HD_5TH_GEN = ChryslerPlatformConfig(
+ [
+ ChryslerCarDocs("Ram 2500 2020-24", car_parts=CarParts.common([CarHarness.ram])),
+ ChryslerCarDocs("Ram 3500 2019-22", car_parts=CarParts.common([CarHarness.ram])),
+ ],
+ ChryslerCarSpecs(mass=3405., wheelbase=3.785, steerRatio=15.61, minSteerSpeed=16.),
+ dbc_dict('chrysler_ram_hd_generated', None),
+ )
+
+
+class CarControllerParams:
+ def __init__(self, CP):
+ self.STEER_STEP = 2 # 50 Hz
+ self.STEER_ERROR_MAX = 80
+ if CP.carFingerprint in RAM_HD:
+ self.STEER_DELTA_UP = 14
+ self.STEER_DELTA_DOWN = 14
+ self.STEER_MAX = 361 # higher than this faults the EPS
+ elif CP.carFingerprint in RAM_DT:
+ self.STEER_DELTA_UP = 6
+ self.STEER_DELTA_DOWN = 6
+ self.STEER_MAX = 261 # EPS allows more, up to 350?
+ else:
+ self.STEER_DELTA_UP = 3
+ self.STEER_DELTA_DOWN = 3
+ self.STEER_MAX = 261 # higher than this faults the EPS
+
+
+STEER_THRESHOLD = 120
+
+RAM_DT = {CAR.RAM_1500_5TH_GEN, }
+RAM_HD = {CAR.RAM_HD_5TH_GEN, }
+RAM_CARS = RAM_DT | RAM_HD
+
+
+CHRYSLER_VERSION_REQUEST = bytes([uds.SERVICE_TYPE.READ_DATA_BY_IDENTIFIER]) + \
+ p16(0xf132)
+CHRYSLER_VERSION_RESPONSE = bytes([uds.SERVICE_TYPE.READ_DATA_BY_IDENTIFIER + 0x40]) + \
+ p16(0xf132)
+
+CHRYSLER_SOFTWARE_VERSION_REQUEST = bytes([uds.SERVICE_TYPE.READ_DATA_BY_IDENTIFIER]) + \
+ p16(uds.DATA_IDENTIFIER_TYPE.SYSTEM_SUPPLIER_ECU_SOFTWARE_NUMBER)
+CHRYSLER_SOFTWARE_VERSION_RESPONSE = bytes([uds.SERVICE_TYPE.READ_DATA_BY_IDENTIFIER + 0x40]) + \
+ p16(uds.DATA_IDENTIFIER_TYPE.SYSTEM_SUPPLIER_ECU_SOFTWARE_NUMBER)
+
+CHRYSLER_RX_OFFSET = -0x280
+
+FW_QUERY_CONFIG = FwQueryConfig(
+ requests=[
+ Request(
+ [CHRYSLER_VERSION_REQUEST],
+ [CHRYSLER_VERSION_RESPONSE],
+ whitelist_ecus=[Ecu.abs, Ecu.eps, Ecu.srs, Ecu.fwdRadar, Ecu.fwdCamera, Ecu.combinationMeter],
+ rx_offset=CHRYSLER_RX_OFFSET,
+ bus=0,
+ ),
+ Request(
+ [CHRYSLER_VERSION_REQUEST],
+ [CHRYSLER_VERSION_RESPONSE],
+ whitelist_ecus=[Ecu.abs, Ecu.hybrid, Ecu.engine, Ecu.transmission],
+ bus=0,
+ ),
+ Request(
+ [CHRYSLER_SOFTWARE_VERSION_REQUEST],
+ [CHRYSLER_SOFTWARE_VERSION_RESPONSE],
+ whitelist_ecus=[Ecu.engine, Ecu.transmission],
+ bus=0,
+ ),
+ ],
+ extra_ecus=[
+ (Ecu.abs, 0x7e4, None), # alt address for abs on hybrids, NOTE: not on all hybrid platforms
+ ],
+)
+
+DBC = CAR.create_dbc_map()
diff --git a/opendbc/car/common/__init__.py b/opendbc/car/common/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/opendbc/car/common/basedir.py b/opendbc/car/common/basedir.py
new file mode 100644
index 0000000000..6b4811e53c
--- /dev/null
+++ b/opendbc/car/common/basedir.py
@@ -0,0 +1,4 @@
+import os
+
+
+BASEDIR = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../"))
diff --git a/opendbc/car/common/conversions.py b/opendbc/car/common/conversions.py
new file mode 100644
index 0000000000..b02b33c625
--- /dev/null
+++ b/opendbc/car/common/conversions.py
@@ -0,0 +1,19 @@
+import numpy as np
+
+class Conversions:
+ # Speed
+ MPH_TO_KPH = 1.609344
+ KPH_TO_MPH = 1. / MPH_TO_KPH
+ MS_TO_KPH = 3.6
+ KPH_TO_MS = 1. / MS_TO_KPH
+ MS_TO_MPH = MS_TO_KPH * KPH_TO_MPH
+ MPH_TO_MS = MPH_TO_KPH * KPH_TO_MS
+ MS_TO_KNOTS = 1.9438
+ KNOTS_TO_MS = 1. / MS_TO_KNOTS
+
+ # Angle
+ DEG_TO_RAD = np.pi / 180.
+ RAD_TO_DEG = 1. / DEG_TO_RAD
+
+ # Mass
+ LB_TO_KG = 0.453592
diff --git a/opendbc/car/common/filter_simple.py b/opendbc/car/common/filter_simple.py
new file mode 100644
index 0000000000..0ec7a51562
--- /dev/null
+++ b/opendbc/car/common/filter_simple.py
@@ -0,0 +1,18 @@
+class FirstOrderFilter:
+ # first order filter
+ def __init__(self, x0, rc, dt, initialized=True):
+ self.x = x0
+ self.dt = dt
+ self.update_alpha(rc)
+ self.initialized = initialized
+
+ def update_alpha(self, rc):
+ self.alpha = self.dt / (rc + self.dt)
+
+ def update(self, x):
+ if self.initialized:
+ self.x = (1. - self.alpha) * self.x + self.alpha * x
+ else:
+ self.initialized = True
+ self.x = x
+ return self.x
diff --git a/opendbc/car/common/numpy_fast.py b/opendbc/car/common/numpy_fast.py
new file mode 100644
index 0000000000..81f6d6a6bc
--- /dev/null
+++ b/opendbc/car/common/numpy_fast.py
@@ -0,0 +1,22 @@
+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)
+
diff --git a/opendbc/car/common/simple_kalman.py b/opendbc/car/common/simple_kalman.py
new file mode 100644
index 0000000000..194b27204b
--- /dev/null
+++ b/opendbc/car/common/simple_kalman.py
@@ -0,0 +1,54 @@
+import numpy as np
+
+
+def get_kalman_gain(dt, A, C, Q, R, iterations=100):
+ P = np.zeros_like(Q)
+ for _ in range(iterations):
+ P = A.dot(P).dot(A.T) + dt * Q
+ S = C.dot(P).dot(C.T) + R
+ K = P.dot(C.T).dot(np.linalg.inv(S))
+ P = (np.eye(len(P)) - K.dot(C)).dot(P)
+ return K
+
+
+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.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
+
+ # 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)
+ x0_0 = self.A_K_0 * self.x0_0 + self.A_K_1 * self.x1_0 + self.K0_0 * meas
+ 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]]
+
+ def set_x(self, x):
+ self.x0_0 = x[0][0]
+ self.x1_0 = x[1][0]
diff --git a/opendbc/car/disable_ecu.py b/opendbc/car/disable_ecu.py
new file mode 100644
index 0000000000..1e3f412449
--- /dev/null
+++ b/opendbc/car/disable_ecu.py
@@ -0,0 +1,36 @@
+from opendbc.car import carlog
+from opendbc.car.isotp_parallel_query import IsoTpParallelQuery
+
+EXT_DIAG_REQUEST = b'\x10\x03'
+EXT_DIAG_RESPONSE = b'\x50\x03'
+
+COM_CONT_RESPONSE = b''
+
+
+def disable_ecu(can_recv, can_send, bus=0, addr=0x7d0, sub_addr=None, com_cont_req=b'\x28\x83\x01', timeout=0.1, retry=10, debug=False):
+ """Silence an ECU by disabling sending and receiving messages using UDS 0x28.
+ The ECU will stay silent as long as openpilot keeps sending Tester Present.
+
+ This is used to disable the radar in some cars. Openpilot will emulate the radar.
+ WARNING: THIS DISABLES AEB!"""
+ carlog.warning(f"ecu disable {hex(addr), sub_addr} ...")
+
+ for i in range(retry):
+ try:
+ query = IsoTpParallelQuery(can_send, can_recv, bus, [(addr, sub_addr)], [EXT_DIAG_REQUEST], [EXT_DIAG_RESPONSE], debug=debug)
+
+ for _, _ in query.get_data(timeout).items():
+ carlog.warning("communication control disable tx/rx ...")
+
+ query = IsoTpParallelQuery(can_send, can_recv, bus, [(addr, sub_addr)], [com_cont_req], [COM_CONT_RESPONSE], debug=debug)
+ query.get_data(0)
+
+ carlog.warning("ecu disabled")
+ return True
+
+ except Exception:
+ carlog.exception("ecu disable exception")
+
+ carlog.error(f"ecu disable retry ({i + 1}) ...")
+ carlog.error("ecu disable failed")
+ return False
diff --git a/opendbc/car/docs.py b/opendbc/car/docs.py
new file mode 100644
index 0000000000..b44c873c3c
--- /dev/null
+++ b/opendbc/car/docs.py
@@ -0,0 +1,59 @@
+from collections import defaultdict
+import jinja2
+from enum import Enum
+from natsort import natsorted
+
+from opendbc.car import gen_empty_fingerprint
+from opendbc.car.structs import CarParams
+from opendbc.car.docs_definitions import CarDocs, Column, CommonFootnote, PartType
+from opendbc.car.car_helpers import interfaces, get_interface_attr
+from opendbc.car.values import PLATFORMS
+
+
+def get_all_footnotes() -> dict[Enum, int]:
+ all_footnotes = list(CommonFootnote)
+ for footnotes in get_interface_attr("Footnote", ignore_none=True).values():
+ all_footnotes.extend(footnotes)
+ return {fn: idx + 1 for idx, fn in enumerate(all_footnotes)}
+
+
+def get_all_car_docs() -> list[CarDocs]:
+ all_car_docs: list[CarDocs] = []
+ footnotes = get_all_footnotes()
+ for model, platform in PLATFORMS.items():
+ car_docs = platform.config.car_docs
+ # If available, uses experimental longitudinal limits for the docs
+ CP = interfaces[model][0].get_params(platform, fingerprint=gen_empty_fingerprint(),
+ car_fw=[CarParams.CarFw(ecu=CarParams.Ecu.unknown)], experimental_long=True, docs=True)
+
+ if CP.dashcamOnly or not len(car_docs):
+ continue
+
+ # A platform can include multiple car models
+ for _car_docs in car_docs:
+ if not hasattr(_car_docs, "row"):
+ _car_docs.init_make(CP)
+ _car_docs.init(CP, footnotes)
+ all_car_docs.append(_car_docs)
+
+ # Sort cars by make and model + year
+ sorted_cars: list[CarDocs] = natsorted(all_car_docs, key=lambda car: car.name.lower())
+ return sorted_cars
+
+
+def group_by_make(all_car_docs: list[CarDocs]) -> dict[str, list[CarDocs]]:
+ sorted_car_docs = defaultdict(list)
+ for car_docs in all_car_docs:
+ sorted_car_docs[car_docs.make].append(car_docs)
+ return dict(sorted_car_docs)
+
+
+def generate_cars_md(all_car_docs: list[CarDocs], template_fn: str) -> str:
+ with open(template_fn) as f:
+ template = jinja2.Template(f.read(), trim_blocks=True, lstrip_blocks=True)
+
+ footnotes = [fn.value.text for fn in get_all_footnotes()]
+ cars_md: str = template.render(all_car_docs=all_car_docs, PartType=PartType,
+ group_by_make=group_by_make, footnotes=footnotes,
+ Column=Column)
+ return cars_md
diff --git a/opendbc/car/docs_definitions.py b/opendbc/car/docs_definitions.py
new file mode 100644
index 0000000000..5e0fa28a00
--- /dev/null
+++ b/opendbc/car/docs_definitions.py
@@ -0,0 +1,370 @@
+import re
+from collections import namedtuple
+import copy
+from dataclasses import dataclass, field
+from enum import Enum
+
+from opendbc.car.common.conversions import Conversions as CV
+from opendbc.car.structs import CarParams
+
+GOOD_TORQUE_THRESHOLD = 1.0 # m/s^2
+MODEL_YEARS_RE = r"(?<= )((\d{4}-\d{2})|(\d{4}))(,|$)"
+
+
+class Column(Enum):
+ MAKE = "Make"
+ MODEL = "Model"
+ PACKAGE = "Supported Package"
+ LONGITUDINAL = "ACC"
+ FSR_LONGITUDINAL = "No ACC accel below"
+ FSR_STEERING = "No ALC below"
+ STEERING_TORQUE = "Steering Torque"
+ AUTO_RESUME = "Resume from stop"
+ HARDWARE = "Hardware Needed"
+ VIDEO = "Video"
+
+
+class Star(Enum):
+ FULL = "full"
+ HALF = "half"
+ EMPTY = "empty"
+
+
+# A part + its comprised parts
+@dataclass
+class BasePart:
+ name: str
+ parts: list[Enum] = field(default_factory=list)
+
+ def all_parts(self):
+ # Recursively get all parts
+ _parts = 'parts'
+ parts = []
+ parts.extend(getattr(self, _parts))
+ for part in getattr(self, _parts):
+ parts.extend(part.value.all_parts())
+
+ return parts
+
+
+class EnumBase(Enum):
+ @property
+ def part_type(self):
+ return PartType(self.__class__)
+
+
+class Mount(EnumBase):
+ mount = BasePart("mount")
+ angled_mount_8_degrees = BasePart("angled mount (8 degrees)")
+
+
+class Cable(EnumBase):
+ rj45_cable_7ft = BasePart("RJ45 cable (7 ft)")
+ long_obdc_cable = BasePart("long OBD-C cable")
+ usb_a_2_a_cable = BasePart("USB A-A cable")
+ usbc_otg_cable = BasePart("USB C OTG cable")
+ usbc_coupler = BasePart("USB-C coupler")
+ obd_c_cable_1_5ft = BasePart("OBD-C cable (1.5 ft)")
+ right_angle_obd_c_cable_1_5ft = BasePart("right angle OBD-C cable (1.5 ft)")
+
+
+class Accessory(EnumBase):
+ harness_box = BasePart("harness box")
+ comma_power_v2 = BasePart("comma power v2")
+
+
+@dataclass
+class BaseCarHarness(BasePart):
+ parts: list[Enum] = field(default_factory=lambda: [Accessory.harness_box, Accessory.comma_power_v2, Cable.rj45_cable_7ft])
+ has_connector: bool = True # without are hidden on the harness connector page
+
+
+class CarHarness(EnumBase):
+ nidec = BaseCarHarness("Honda Nidec connector")
+ bosch_a = BaseCarHarness("Honda Bosch A connector")
+ bosch_b = BaseCarHarness("Honda Bosch B connector")
+ toyota_a = BaseCarHarness("Toyota A connector")
+ toyota_b = BaseCarHarness("Toyota B connector")
+ subaru_a = BaseCarHarness("Subaru A connector")
+ subaru_b = BaseCarHarness("Subaru B connector")
+ subaru_c = BaseCarHarness("Subaru C connector")
+ subaru_d = BaseCarHarness("Subaru D connector")
+ fca = BaseCarHarness("FCA connector")
+ ram = BaseCarHarness("Ram connector")
+ vw_a = BaseCarHarness("VW A connector")
+ vw_j533 = BaseCarHarness("VW J533 connector", parts=[Accessory.harness_box, Cable.long_obdc_cable, Cable.usbc_coupler])
+ hyundai_a = BaseCarHarness("Hyundai A connector")
+ hyundai_b = BaseCarHarness("Hyundai B connector")
+ hyundai_c = BaseCarHarness("Hyundai C connector")
+ hyundai_d = BaseCarHarness("Hyundai D connector")
+ hyundai_e = BaseCarHarness("Hyundai E connector")
+ hyundai_f = BaseCarHarness("Hyundai F connector")
+ hyundai_g = BaseCarHarness("Hyundai G connector")
+ hyundai_h = BaseCarHarness("Hyundai H connector")
+ hyundai_i = BaseCarHarness("Hyundai I connector")
+ hyundai_j = BaseCarHarness("Hyundai J connector")
+ hyundai_k = BaseCarHarness("Hyundai K connector")
+ hyundai_l = BaseCarHarness("Hyundai L connector")
+ hyundai_m = BaseCarHarness("Hyundai M connector")
+ hyundai_n = BaseCarHarness("Hyundai N connector")
+ hyundai_o = BaseCarHarness("Hyundai O connector")
+ hyundai_p = BaseCarHarness("Hyundai P connector")
+ hyundai_q = BaseCarHarness("Hyundai Q connector")
+ hyundai_r = BaseCarHarness("Hyundai R connector")
+ custom = BaseCarHarness("Developer connector")
+ obd_ii = BaseCarHarness("OBD-II connector", parts=[Cable.long_obdc_cable, Cable.long_obdc_cable], has_connector=False)
+ gm = BaseCarHarness("GM connector", parts=[Accessory.harness_box])
+ gmsdgm = BaseCarHarness("GM SDGM connector", parts=[Accessory.harness_box, Cable.rj45_cable_7ft, Cable.long_obdc_cable,
+ Cable.usbc_coupler, Accessory.comma_power_v2])
+ nissan_a = BaseCarHarness("Nissan A connector", parts=[Accessory.harness_box, Cable.rj45_cable_7ft, Cable.long_obdc_cable, Cable.usbc_coupler])
+ nissan_b = BaseCarHarness("Nissan B connector", parts=[Accessory.harness_box, Cable.rj45_cable_7ft, Cable.long_obdc_cable, Cable.usbc_coupler])
+ mazda = BaseCarHarness("Mazda connector")
+ ford_q3 = BaseCarHarness("Ford Q3 connector")
+ ford_q4 = BaseCarHarness("Ford Q4 connector", parts=[Accessory.harness_box, Accessory.comma_power_v2, Cable.rj45_cable_7ft, Cable.long_obdc_cable,
+ Cable.usbc_coupler])
+
+
+class Device(EnumBase):
+ threex = BasePart("comma 3X", parts=[Mount.mount, Cable.right_angle_obd_c_cable_1_5ft])
+ # variant of comma 3X with angled mounts
+ threex_angled_mount = BasePart("comma 3X", parts=[Mount.angled_mount_8_degrees, Cable.right_angle_obd_c_cable_1_5ft])
+ red_panda = BasePart("red panda")
+
+
+class Kit(EnumBase):
+ red_panda_kit = BasePart("CAN FD panda kit", parts=[Device.red_panda, Accessory.harness_box,
+ Cable.usb_a_2_a_cable, Cable.usbc_otg_cable, Cable.obd_c_cable_1_5ft])
+
+
+class Tool(EnumBase):
+ socket_8mm_deep = BasePart("Socket Wrench 8mm or 5/16\" (deep)")
+ pry_tool = BasePart("Pry Tool")
+
+
+class PartType(Enum):
+ accessory = Accessory
+ cable = Cable
+ connector = CarHarness
+ device = Device
+ kit = Kit
+ mount = Mount
+ tool = Tool
+
+
+DEFAULT_CAR_PARTS: list[EnumBase] = [Device.threex]
+
+
+@dataclass
+class CarParts:
+ parts: list[EnumBase] = field(default_factory=list)
+
+ def __call__(self):
+ return copy.deepcopy(self)
+
+ @classmethod
+ def common(cls, add: list[EnumBase] = None, remove: list[EnumBase] = None):
+ p = [part for part in (add or []) + DEFAULT_CAR_PARTS if part not in (remove or [])]
+ return cls(p)
+
+ def all_parts(self):
+ parts = []
+ for part in self.parts:
+ parts.extend(part.value.all_parts())
+ return self.parts + parts
+
+
+CarFootnote = namedtuple("CarFootnote", ["text", "column", "docs_only", "shop_footnote"], defaults=(False, False))
+
+
+class CommonFootnote(Enum):
+ EXP_LONG_AVAIL = CarFootnote(
+ "openpilot Longitudinal Control (Alpha) is available behind a toggle; " +
+ "the toggle is only available in non-release branches such as `devel` or `master-ci`.",
+ Column.LONGITUDINAL, docs_only=True)
+ EXP_LONG_DSU = CarFootnote(
+ "By default, this car will use the stock Adaptive Cruise Control (ACC) for longitudinal control. " +
+ "If the Driver Support Unit (DSU) is disconnected, openpilot ACC will replace " +
+ "stock ACC. NOTE: disconnecting the DSU disables Automatic Emergency Braking (AEB).",
+ Column.LONGITUDINAL)
+
+
+def get_footnotes(footnotes: list[Enum], column: Column) -> list[Enum]:
+ # Returns applicable footnotes given current column
+ return [fn for fn in footnotes if fn.value.column == column]
+
+
+# TODO: store years as a list
+def get_year_list(years):
+ years_list = []
+ if len(years) == 0:
+ return years_list
+
+ for year in years.split(','):
+ year = year.strip()
+ if len(year) == 4:
+ years_list.append(str(year))
+ elif "-" in year and len(year) == 7:
+ start, end = year.split("-")
+ years_list.extend(map(str, range(int(start), int(f"20{end}") + 1)))
+ else:
+ raise Exception(f"Malformed year string: {years}")
+ return years_list
+
+
+def split_name(name: str) -> tuple[str, str, str]:
+ make, model = name.split(" ", 1)
+ years = ""
+ match = re.search(MODEL_YEARS_RE, model)
+ if match is not None:
+ years = model[match.start():]
+ model = model[:match.start() - 1]
+ return make, model, years
+
+
+@dataclass
+class CarDocs:
+ # make + model + model years
+ name: str
+
+ # Example for Toyota Corolla MY20
+ # requirements: Lane Tracing Assist (LTA) and Dynamic Radar Cruise Control (DRCC)
+ # US Market reference: "All", since all Corolla in the US come standard with LTA and DRCC
+
+ # the simplest description of the requirements for the US market
+ package: str
+
+ # the minimum compatibility requirements for this model, regardless
+ # of market. can be a package, trim, or list of features
+ requirements: str | None = None
+
+ video_link: str | None = None
+ footnotes: list[Enum] = field(default_factory=list)
+ min_steer_speed: float | None = None
+ min_enable_speed: float | None = None
+ auto_resume: bool | None = None
+
+ # all the parts needed for the supported car
+ car_parts: CarParts = field(default_factory=CarParts)
+
+ def __post_init__(self):
+ self.make, self.model, self.years = split_name(self.name)
+ self.year_list = get_year_list(self.years)
+
+ def init(self, CP: CarParams, all_footnotes: dict[Enum, int]):
+ self.car_name = CP.carName
+ self.car_fingerprint = CP.carFingerprint
+
+ # longitudinal column
+ op_long = "Stock"
+ if CP.experimentalLongitudinalAvailable or CP.enableDsu:
+ op_long = "openpilot available"
+ if CP.enableDsu:
+ self.footnotes.append(CommonFootnote.EXP_LONG_DSU)
+ else:
+ self.footnotes.append(CommonFootnote.EXP_LONG_AVAIL)
+ elif CP.openpilotLongitudinalControl and not CP.enableDsu:
+ op_long = "openpilot"
+
+ # min steer & enable speed columns
+ # TODO: set all the min steer speeds in carParams and remove this
+ if self.min_steer_speed is not None:
+ assert CP.minSteerSpeed < 0.5, f"{CP.carFingerprint}: Minimum steer speed set in both CarDocs and CarParams"
+ else:
+ self.min_steer_speed = CP.minSteerSpeed
+
+ # TODO: set all the min enable speeds in carParams correctly and remove this
+ if self.min_enable_speed is None:
+ self.min_enable_speed = CP.minEnableSpeed
+
+ if self.auto_resume is None:
+ self.auto_resume = CP.autoResumeSng and self.min_enable_speed <= 0
+
+ # hardware column
+ hardware_col = "None"
+ if self.car_parts.parts:
+ model_years = self.model + (' ' + self.years if self.years else '')
+ buy_link = f'Buy Here'
+
+ tools_docs = [part for part in self.car_parts.all_parts() if isinstance(part, Tool)]
+ parts_docs = [part for part in self.car_parts.all_parts() if not isinstance(part, Tool)]
+
+ def display_func(parts):
+ return '
'.join([f"- {parts.count(part)} {part.value.name}" for part in sorted(set(parts), key=lambda part: str(part.value.name))])
+
+ hardware_col = f'Parts
{display_func(parts_docs)}
{buy_link}Tools
{display_func(tools_docs)}