Fix Mici UI replay auto-scroll hook

OnroadViewContainerSP nests a vertical scroller between the outer horizontal
scroller and road_view/info_panel. Stock click suppression relies on a child's
_touch_valid_callback being gated by its parent scroll panel — with the
container in the middle, children were only gated by the inner panel, so an
outer L→R drag never invalidated their touch and the click fired on release
(immediately popping to home).

- Chain children's touch_valid through the container's own touch_valid so
  outer-scroll state propagates to nested children.
- Add OnroadInfoPanel._handle_mouse_release mirroring AugmentedRoadView's
  bookmark guard, so an R→L bookmark drag on the info panel doesn't fire the
  click on release.

.dockerignore

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

.gitattributes

@@ -11,7 +11,4 @@
 *.wav filter=lfs diff=lfs merge=lfs -text
 
 selfdrive/car/tests/test_models_segs.txt filter=lfs diff=lfs merge=lfs -text
-common/hardware/tici/updater filter=lfs diff=lfs merge=lfs -text
-
-# Small vendored Leaflet UI icons are kept directly in Git.
-tools/clustermaps/web/vendor/leaflet/images/*.png -filter -diff -merge -text
+system/hardware/tici/updater filter=lfs diff=lfs merge=lfs -text

.github/workflows/cereal_validation.yaml

@@ -35,36 +35,18 @@ jobs:
       - name: Init sunnypilot opendbc submodule
         run: git submodule update --init --depth 1 opendbc_repo
 
-      - name: Checkout upstream openpilot
+      - name: Checkout upstream openpilot cereal
         uses: actions/checkout@v6
         with:
           repository: 'commaai/openpilot'
           path: upstream_openpilot
+          sparse-checkout: cereal
           ref: "refs/heads/master"
 
       - name: Init upstream opendbc submodule
         working-directory: upstream_openpilot
         run: git submodule update --init --depth 1 opendbc_repo
 
-      - name: Locate upstream capnp paths
-        id: locate-capnp
-        run: |
-          CEREAL_DIR=$(find upstream_openpilot -maxdepth 4 -name log.capnp -path '*/cereal/log.capnp' -printf '%h\n' -quit)
-          if [ -z "$CEREAL_DIR" ]; then
-            echo "::error::Could not locate cereal/log.capnp in upstream openpilot"
-            exit 1
-          fi
-          echo "cereal_dir=$CEREAL_DIR" >> "$GITHUB_OUTPUT"
-          echo "Found upstream cereal at: $CEREAL_DIR"
-
-          IMPORT_ARGS=""
-          CAR_CAPNP=$(find upstream_openpilot -maxdepth 5 -name car.capnp -path '*/opendbc/car/car.capnp' -printf '%h\n' -quit)
-          if [ -n "$CAR_CAPNP" ]; then
-            IMPORT_ARGS="-I $CAR_CAPNP"
-            echo "Found car.capnp at: $CAR_CAPNP"
-          fi
-          echo "import_args=$IMPORT_ARGS" >> "$GITHUB_OUTPUT"
-
       - name: Install uv
         run: pip install uv
 
@@ -80,5 +62,4 @@ jobs:
           PYCAPNP_VER=$(python3 -c "import re; m=re.search(r'name = \"pycapnp\"\nversion = \"([^\"]+)\"', open('uv.lock').read()); print(m.group(1))")
           uv run --isolated --with "pycapnp==${PYCAPNP_VER}" \
             python3 cereal/messaging/tests/validate_sp_cereal_upstream.py \
-            -r -f /tmp/sp_schema.json --cereal-dir ${{ steps.locate-capnp.outputs.cereal_dir }} \
-            ${{ steps.locate-capnp.outputs.import_args }}
+            -r -f /tmp/sp_schema.json --cereal-dir upstream_openpilot/cereal

.gitmodules

@@ -6,7 +6,7 @@
   url = https://github.com/sunnypilot/opendbc.git
 [submodule "msgq"]
   path = msgq_repo
-  url = https://github.com/sunnypilot/msgq.git
+  url = https://github.com/commaai/msgq.git
 [submodule "rednose_repo"]
   path = rednose_repo
   url = https://github.com/commaai/rednose.git

CHANGELOG.md

@@ -1,34 +1,5 @@
-sunnypilot Version 2026.002.000 (2026-06-28)
+sunnypilot Version 2026.002.000 (2026-xx-xx)
 ========================
-* What's Changed (sunnypilot/sunnypilot)
-  * ui: update gates for certain toggles by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1830
-  * release: ignore upstream IsReleaseBranch by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1831
-  * manager: disable DEVELOPMENT_ONLY reset by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1833
-  * sunnylink: fix max time offroad values by @nayan8teen in https://github.com/sunnypilot/sunnypilot/pull/1835
-  * ui: show default model name by @nayan8teen in https://github.com/sunnypilot/sunnypilot/pull/1837
-  * sunnylink: add CarParams fallback for brand-specific capabilities by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1839
-  * sunnylink SDUI: tweak DisableUpdate param for clarity by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1842
-  * Revert "DM: Lancia Delta HF Integrale model" by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1849
-  * modeld_v2: safe model validation by @Discountchubbs in https://github.com/sunnypilot/sunnypilot/pull/1855
-  * Revert "deprecate `carState.brake`" for Honda Gas Interceptor by @mvl-boston in https://github.com/sunnypilot/sunnypilot/pull/1860
-  * sunnylink: deprecate legacy params metadata by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1862
-  * ui: reset Enforce Torque Control and NNLC if both are enabled by @sunnyhaibin in https://github.com/sunnypilot/sunnypilot/pull/1863
-* What's Changed (sunnypilot/opendbc)
-  * Rivian: suppress ACM hold-the-wheel warning during MADS-only lateral by @lukasloetkolben in https://github.com/sunnypilot/opendbc/pull/465
-  * Sync: `commaai/opendbc:master` → `sunnypilot/opendbc:master` by @sunnyhaibin in https://github.com/sunnypilot/opendbc/pull/479
-  * safety: add option to ignore frequency check for RX checks by @sunnyhaibin in https://github.com/sunnypilot/opendbc/pull/480
-  * Revert "deprecate carState.brake" for Honda Gas Interceptor by @mvl-boston in https://github.com/sunnypilot/opendbc/pull/481
-* New Contributors (sunnypilot/sunnypilot)
-  * @mvl-boston made their first contribution in https://github.com/sunnypilot/sunnypilot/pull/1860
-* Full Changelog: https://github.com/sunnypilot/sunnypilot/compare/v2026.001.007...v2026.002.000
-************************
-* Synced with commaai's openpilot (v0.11.1)
-  * master commit 69e2c321e49760e52f7983eaa0a5f77cb95de637 (June 02, 2026)
-* New driver monitoring model
-* Improved image processing pipeline for driver camera
-* Improved thermal policy for comma four
-* Acura MDX 2022-24 support thanks to mvl-boston!
-* Rivian R1S and R1T 2025 support thanks to lukasloetkolben!
 
 sunnypilot Version 2026.001.000 (2026-05-06)
 ========================

Dockerfile.openpilot

@@ -0,0 +1,38 @@
+FROM ubuntu:24.04
+
+ENV PYTHONUNBUFFERED=1
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends sudo tzdata locales && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && locale-gen
+ENV LANG=en_US.UTF-8
+ENV LANGUAGE=en_US:en
+ENV LC_ALL=en_US.UTF-8
+
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV NVIDIA_DRIVER_CAPABILITIES=graphics,utility,compute
+
+ARG USER=batman
+ARG USER_UID=1001
+RUN useradd -m -s /bin/bash -u $USER_UID $USER
+RUN usermod -aG sudo $USER
+RUN echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
+USER $USER
+
+ENV OPENPILOT_PATH=/home/$USER/openpilot
+RUN mkdir -p ${OPENPILOT_PATH}
+WORKDIR ${OPENPILOT_PATH}
+
+COPY --chown=$USER . ${OPENPILOT_PATH}/
+
+ENV UV_BIN="/home/$USER/.local/bin/"
+ENV VIRTUAL_ENV=${OPENPILOT_PATH}/.venv
+ENV PATH="$UV_BIN:$VIRTUAL_ENV/bin:$PATH"
+RUN tools/setup_dependencies.sh && \
+    sudo rm -rf /var/lib/apt/lists/*
+
+USER root
+RUN git config --global --add safe.directory '*'

Jenkinsfile

@@ -12,7 +12,7 @@ def retryWithDelay(int maxRetries, int delay, Closure body) {
 def device(String ip, String step_label, String cmd) {
   withCredentials([file(credentialsId: 'id_rsa', variable: 'key_file')]) {
     def ssh_cmd = """
-ssh -o ControlMaster=auto -o ControlPath=/tmp/ssh_control_%C -o ControlPersist=yes -o ConnectTimeout=5 -o ServerAliveInterval=5 -o ServerAliveCountMax=2 -o BatchMode=yes -o StrictHostKeyChecking=no -i ${key_file} 'comma@${ip}' exec /usr/bin/bash <<'END'
+ssh -o ConnectTimeout=5 -o ServerAliveInterval=5 -o ServerAliveCountMax=2 -o BatchMode=yes -o StrictHostKeyChecking=no -i ${key_file} 'comma@${ip}' exec /usr/bin/bash <<'END'
 
 set -e
 
@@ -210,7 +210,7 @@ node {
       'HW + Unit Tests': {
         deviceStage("tizi-hardware", "tizi-common", ["UNSAFE=1"], [
           step("build", "cd system/manager && ./build.py"),
-          step("test power draw", "pytest -s selfdrive/test//test_power_draw.py"),
+          step("test power draw", "pytest -s system/hardware/tici/tests/test_power_draw.py"),
           step("test encoder", "LD_LIBRARY_PATH=/usr/local/lib pytest system/loggerd/tests/test_encoder.py", [diffPaths: ["system/loggerd/"]]),
           step("test manager", "pytest system/manager/test/test_manager.py"),
         ])
@@ -246,7 +246,7 @@ node {
           step("build openpilot", "cd system/manager && ./build.py"),
           step("test pandad loopback", "pytest selfdrive/pandad/tests/test_pandad_loopback.py"),
           step("test pandad spi", "pytest selfdrive/pandad/tests/test_pandad_spi.py"),
-          step("test amp", "pytest common/hardware/tici/tests/test_amplifier.py"),
+          step("test amp", "pytest system/hardware/tici/tests/test_amplifier.py"),
         ])
       },
 

SConstruct

@@ -276,8 +276,6 @@ def count_scons_nodes(nodes):
     if node in seen:
       continue
     seen.add(node)
-    if hasattr(node, 'has_builder') and node.has_builder():
-      build_product_nodes.add(node)
     executor = node.get_executor()
     if executor is not None:
       stack += executor.get_all_prerequisites() + executor.get_all_children()
@@ -286,7 +284,6 @@ def count_scons_nodes(nodes):
 
 progress_interval = 5
 progress_count = 0
-build_product_nodes = set()
 progress_total = max(1, count_scons_nodes(env.arg2nodes(BUILD_TARGETS or [Dir('.')], env.fs.Entry)))
 
 def progress_function(node):
@@ -302,11 +299,3 @@ def progress_function(node):
 
 Progress(progress_function, interval=progress_interval)
 AddPostAction(BUILD_TARGETS or [Dir('.')], prune_cache_dir)
-
-def check_build_product_size(target, source, env):
-  limit = 50 * 1024 * 1024  # GitHub max size
-  for t in target:
-    if hasattr(t, 'isfile') and t.isfile() and (size := os.path.getsize(t.abspath)) > limit:
-      raise SCons.Errors.UserError(f"{t} is {size / (1024 * 1024):.1f} MiB, exceeding the {limit / (1024 * 1024):.1f} MiB limit")
-if not GetOption('extras'):
-  AddPostAction(list(build_product_nodes), Action(check_build_product_size, None))

cereal/deprecated.capnp

@@ -760,6 +760,18 @@ struct LateralLQRState @0x9024e2d790c82ade {
   steeringAngleDesiredDeg @6 :Float32;
 }
 
+struct LateralCurvatureState @0xad9d8095c06f7c61 {
+  active @0 :Bool;
+  actualCurvature @1 :Float32;
+  desiredCurvature @2 :Float32;
+  error @3 :Float32;
+  p @4 :Float32;
+  i @5 :Float32;
+  f @6 :Float32;
+  output @7 :Float32;
+  saturated @8 :Bool;
+}
+
 struct LateralPlannerSolution @0x84caeca5a6b4acfe {
   x @0 :List(Float32);
   y @1 :List(Float32);

cereal/log.capnp

@@ -818,7 +818,7 @@ struct ControlsState @0x97ff69c53601abf1 {
     debugState @59 :LateralDebugState;
     torqueState @60 :LateralTorqueState;
 
-    curvatureState @65 :LateralCurvatureState;
+    curvatureStateDEPRECATED @65 :Deprecated.LateralCurvatureState;
     lqrStateDEPRECATED @55 :Deprecated.LateralLQRState;
     indiStateDEPRECATED @52 :Deprecated.LateralINDIState;
   }
@@ -867,18 +867,6 @@ struct ControlsState @0x97ff69c53601abf1 {
     saturated @3 :Bool;
   }
 
-  struct LateralCurvatureState @0xad9d8095c06f7c61 {
-    active @0 :Bool;
-    actualCurvature @1 :Float32;
-    desiredCurvature @2 :Float32;
-    error @3 :Float32;
-    p @4 :Float32;
-    i @5 :Float32;
-    f @6 :Float32;
-    output @7 :Float32;
-    saturated @8 :Bool;
-  }
-
   deprecated :group {
     vEgo @0 :Float32;
     vEgoRaw @32 :Float32;
@@ -2259,7 +2247,6 @@ struct LiveDelayData {
   lateralDelayEstimateStd @5 :Float32;
   points @4 :List(Float32);
   calPerc @6 :Int8;
-  version @7 :Int32;
 
   enum Status {
     unestimated @0;

cereal/messaging/tests/validate_sp_cereal_upstream.py

@@ -1,13 +1,12 @@
 #!/usr/bin/env python3
-"""Validate sunnypilot routes are parseable by stock commaai/openpilot.
+"""Schema-level cereal compat check between sunnypilot and upstream openpilot.
 
-Cap'n Proto is wire-compatible across renames, type relocations, and
-additive fields. The only breaking change is a union variant that
-upstream doesn't recognize — an unknown discriminant makes the entire
-union unreadable.
-
-This script checks: for every struct with a union that exists in both
-schemas, does sunnypilot introduce union variants upstream doesn't have?
+Rules (per struct matched across sides by typeId):
+  R1  shared ordinal must reference the same type.
+  R2  sunnypilot-only ordinal in a union -> FAIL (unknown discriminant upstream).
+  R3  sunnypilot-only ordinal on a regular field -> OK (additive struct evolution).
+  R4  upstream-only ordinal -> OK.
+  R5  sunnypilot-only struct referenced via an upstream-shared field -> FAIL.
 """
 
 from __future__ import annotations
@@ -25,19 +24,46 @@ def hex_id(value: int) -> str:
   return f"0x{value:016x}"
 
 
+def encode_type(type_node: Any) -> dict:
+  which = type_node.which()
+  if which == "struct":
+    return {"kind": "struct", "typeId": hex_id(type_node.struct.typeId)}
+  if which == "enum":
+    return {"kind": "enum", "typeId": hex_id(type_node.enum.typeId)}
+  if which == "interface":
+    return {"kind": "interface", "typeId": hex_id(type_node.interface.typeId)}
+  if which == "list":
+    return {"kind": "list", "element": encode_type(type_node.list.elementType)}
+  if which == "anyPointer":
+    return {"kind": "anyPointer"}
+  return {"kind": which}
+
+
+def encode_field(name: str, field: Any) -> dict:
+  proto = field.proto
+  ordinal = proto.ordinal.explicit if proto.ordinal.which() == "explicit" else None
+  discriminant = proto.discriminantValue if proto.discriminantValue != NO_DISCRIMINANT else None
+
+  if proto.which() == "group":
+    type_desc = {"kind": "group", "typeId": hex_id(proto.group.typeId)}
+  else:
+    type_desc = encode_type(proto.slot.type)
+
+  return {
+    "name": name,
+    "ordinal": ordinal,
+    "discriminant": discriminant,
+    "type": type_desc,
+  }
+
+
 def encode_struct(schema: Any) -> dict:
   node = schema.node
-  fields = []
-  for name, field in schema.fields.items():
-    proto = field.proto
-    ordinal = proto.ordinal.explicit if proto.ordinal.which() == "explicit" else None
-    discriminant = proto.discriminantValue if proto.discriminantValue != NO_DISCRIMINANT else None
-    fields.append({"name": name, "ordinal": ordinal, "discriminant": discriminant})
   return {
     "typeId": hex_id(node.id),
     "displayName": node.displayName,
     "hasUnion": node.struct.discriminantCount > 0,
-    "fields": fields,
+    "fields": [encode_field(name, field) for name, field in schema.fields.items()],
   }
 
 
@@ -79,16 +105,15 @@ def collect_schema(root: Any) -> dict[str, dict]:
   return structs
 
 
-def load_log(cereal_dir: str, extra_imports: list[str] | None = None) -> Any:
+def load_log(cereal_dir: str) -> Any:
   import capnp
   cereal_dir = os.path.abspath(cereal_dir)
   capnp.remove_import_hook()
-  imports = [cereal_dir] + [os.path.abspath(p) for p in (extra_imports or [])]
-  return capnp.load(os.path.join(cereal_dir, "log.capnp"), imports=imports)
+  return capnp.load(os.path.join(cereal_dir, "log.capnp"), imports=[cereal_dir])
 
 
-def dump_schema(cereal_dir: str, path: str, extra_imports: list[str] | None = None) -> None:
-  log = load_log(cereal_dir, extra_imports)
+def dump_schema(cereal_dir: str, path: str) -> None:
+  log = load_log(cereal_dir)
   payload = {
     "root": hex_id(log.Event.schema.node.id),
     "structs": collect_schema(log.Event.schema),
@@ -98,37 +123,100 @@ def dump_schema(cereal_dir: str, path: str, extra_imports: list[str] | None = No
   print(f"wrote schema dump with {len(payload['structs'])} structs to {path}")
 
 
+def types_equal(a: dict, b: dict) -> bool:
+  if a.get("kind") != b.get("kind"):
+    return False
+  kind = a["kind"]
+  if kind in ("struct", "enum", "interface", "group"):
+    return a.get("typeId") == b.get("typeId")
+  if kind == "list":
+    return types_equal(a["element"], b["element"])
+  return True
+
+
+def type_repr(t: dict) -> str:
+  kind = t.get("kind", "?")
+  if kind in ("struct", "enum", "interface", "group"):
+    return f"{kind}({t.get('typeId')})"
+  if kind == "list":
+    return f"list<{type_repr(t['element'])}>"
+  return kind
+
+
+def field_is_union_variant(field: dict) -> bool:
+  return field.get("discriminant") is not None
+
+
+def index_fields_by_ordinal(struct: dict) -> dict[int, dict]:
+  indexed: dict[int, dict] = {}
+  for field in struct["fields"]:
+    ordinal = field.get("ordinal")
+    if ordinal is None:
+      continue
+    indexed[ordinal] = field
+  return indexed
+
+
 def compare(sunnypilot_dump: dict, upstream_dump: dict) -> list[str]:
   violations: list[str] = []
-  sunnypilot_structs = sunnypilot_dump["structs"]
-  upstream_structs = upstream_dump["structs"]
+  sunnypilot_structs: dict[str, dict] = sunnypilot_dump["structs"]
+  upstream_structs: dict[str, dict] = upstream_dump["structs"]
 
-  for type_id, sp_struct in sunnypilot_structs.items():
-    if not sp_struct["hasUnion"]:
-      continue
-    up_struct = upstream_structs.get(type_id)
-    if up_struct is None:
+  sunnypilot_struct_referenced_from_shared: set[str] = set()
+
+  for type_id, sunnypilot_struct in sunnypilot_structs.items():
+    upstream_struct = upstream_structs.get(type_id)
+    if upstream_struct is None:
       continue
 
-    up_ordinals = {f["ordinal"] for f in up_struct["fields"] if f.get("discriminant") is not None}
-    display = sp_struct["displayName"]
+    sunnypilot_fields = index_fields_by_ordinal(sunnypilot_struct)
+    upstream_fields = index_fields_by_ordinal(upstream_struct)
+    display = sunnypilot_struct["displayName"]
 
-    for field in sp_struct["fields"]:
-      if field.get("discriminant") is None:
+    for ordinal, sunnypilot_field in sunnypilot_fields.items():
+      upstream_field = upstream_fields.get(ordinal)
+      if upstream_field is None:
+        if field_is_union_variant(sunnypilot_field):
+          violations.append(
+            f"[R2] {display} @{ordinal} ('{sunnypilot_field['name']}', {type_repr(sunnypilot_field['type'])}): "
+            f"union variant not present upstream. upstream cannot parse this discriminant."
+          )
         continue
-      if field["ordinal"] not in up_ordinals:
+
+      if not types_equal(sunnypilot_field["type"], upstream_field["type"]):
         violations.append(
-          f"{display} @{field['ordinal']} '{field['name']}': "
-          f"union variant not present upstream (discriminant={field['discriminant']})"
+          f"[R1] {display} @{ordinal}: type mismatch. "
+          f"sunnypilot='{sunnypilot_field['name']}' {type_repr(sunnypilot_field['type'])} vs "
+          f"upstream='{upstream_field['name']}' {type_repr(upstream_field['type'])}."
         )
+        continue
+
+      cursor = sunnypilot_field["type"]
+      while cursor.get("kind") == "list":
+        cursor = cursor["element"]
+      if cursor.get("kind") in ("struct", "group", "interface") and cursor.get("typeId"):
+        sunnypilot_struct_referenced_from_shared.add(cursor["typeId"])
+
+  for type_id, sunnypilot_struct in sunnypilot_structs.items():
+    if type_id in upstream_structs:
+      continue
+    if type_id in sunnypilot_struct_referenced_from_shared:
+      violations.append(
+        f"[R5] struct {sunnypilot_struct['displayName']} ({type_id}) exists only on sunnypilot "
+        f"but is referenced from an upstream-shared field. upstream cannot resolve this type."
+      )
 
   return violations
 
 
-def run_read(cereal_dir: str, peer_path: str, extra_imports: list[str] | None = None) -> int:
-  log = load_log(cereal_dir, extra_imports)
-  with open(peer_path, "r", encoding="utf-8") as f:
-    peer_dump = json.load(f)
+def load_peer(path: str) -> dict:
+  with open(path, "r", encoding="utf-8") as handle:
+    return json.load(handle)
+
+
+def run_read(cereal_dir: str, peer_path: str) -> int:
+  log = load_log(cereal_dir)
+  peer_dump = load_peer(peer_path)
   local_dump = {
     "root": hex_id(log.Event.schema.node.id),
     "structs": collect_schema(log.Event.schema),
@@ -136,29 +224,32 @@ def run_read(cereal_dir: str, peer_path: str, extra_imports: list[str] | None =
   violations = compare(sunnypilot_dump=peer_dump, upstream_dump=local_dump)
 
   if not violations:
-    print("cereal compat OK: upstream can parse sunnypilot routes.")
+    print("cereal compat OK: upstream openpilot can parse sunnypilot routes "
+          "(no leaked structs, no ordinal collisions).")
     return 0
 
-  print(f"cereal compat FAIL ({len(violations)} leaked union variant(s)):")
+  print(f"cereal compat FAIL: upstream openpilot would misparse sunnypilot routes "
+        f"({len(violations)} violation(s)):")
   for v in violations:
     print(f"  {v}")
   return 1
 
 
 def main() -> int:
-  parser = argparse.ArgumentParser(description="sunnypilot cereal upstream compat check")
+  parser = argparse.ArgumentParser(
+    description="sunnypilot <-> upstream cereal compatibility validator (schema-level)."
+  )
   mode = parser.add_mutually_exclusive_group(required=True)
   mode.add_argument("-g", "--generate", action="store_true", help="dump local schema to JSON")
-  mode.add_argument("-r", "--read", action="store_true", help="validate against peer schema")
-  parser.add_argument("-f", "--file", default="schema.json", help="JSON file path")
-  parser.add_argument("--cereal-dir", required=True, help="path to cereal directory")
-  parser.add_argument("-I", "--import-path", action="append", default=[], help="extra capnp import paths")
+  mode.add_argument("-r", "--read", action="store_true", help="load peer JSON and diff against local")
+  parser.add_argument("-f", "--file", default="schema.json", help="JSON file path (default: schema.json)")
+  parser.add_argument("--cereal-dir", required=True, help="path to cereal directory containing log.capnp")
   args = parser.parse_args()
 
   if args.generate:
-    dump_schema(args.cereal_dir, args.file, args.import_path)
+    dump_schema(args.cereal_dir, args.file)
     return 0
-  return run_read(args.cereal_dir, args.file, args.import_path)
+  return run_read(args.cereal_dir, args.file)
 
 
 if __name__ == "__main__":

common/api/base.py

@@ -3,7 +3,7 @@ import os
 import requests
 import unicodedata
 from datetime import datetime, timedelta, UTC
-from openpilot.common.hardware.hw import Paths
+from openpilot.system.hardware.hw import Paths
 from openpilot.system.version import get_version
 
 # name: jwt signature algorithm

common/esim/__init__.py

@@ -1,3 +0,0 @@
-from openpilot.common.esim.base import LPABase, LPAError, LPAProfileNotFoundError, Profile
-
-__all__ = ["LPABase", "LPAError", "LPAProfileNotFoundError", "Profile"]

common/esim/base.py

@@ -1,55 +0,0 @@
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-
-
-class LPAError(RuntimeError):
-  pass
-
-
-class LPAProfileNotFoundError(LPAError):
-  pass
-
-
-@dataclass
-class Profile:
-  iccid: str
-  nickname: str
-  enabled: bool
-  provider: str
-
-  @property
-  def is_comma(self) -> bool:
-    return self.provider == 'Webbing' and self.iccid.startswith('8985235')
-
-
-class LPABase(ABC):
-  @abstractmethod
-  def list_profiles(self) -> list[Profile]:
-    pass
-
-  @abstractmethod
-  def get_active_profile(self) -> Profile | None:
-    pass
-
-  @abstractmethod
-  def delete_profile(self, iccid: str) -> None:
-    pass
-
-  @abstractmethod
-  def download_profile(self, qr: str, nickname: str | None = None) -> None:
-    pass
-
-  @abstractmethod
-  def nickname_profile(self, iccid: str, nickname: str) -> None:
-    pass
-
-  @abstractmethod
-  def switch_profile(self, iccid: str) -> None:
-    pass
-
-  def process_notifications(self) -> None:
-    pass
-
-  @abstractmethod
-  def is_euicc(self) -> bool:
-    pass

common/hardware/pc/hardware.py

@@ -1,10 +0,0 @@
-from cereal import log
-from openpilot.common.hardware.base import HardwareBase
-
-class Pc(HardwareBase):
-  def get_device_type(self):
-    return "pc"
-
-  def get_network_type(self):
-    # some stuff is gated on wifi, so just assume for now
-    return log.DeviceState.NetworkType.wifi

common/hardware/tici/__init__.py

@@ -1 +0,0 @@
-

common/hardware/tici/agnos.json

@@ -1,84 +0,0 @@
-[
-  {
-    "name": "xbl",
-    "url": "https://commadist.azureedge.net/agnosupdate/xbl-e8acf2a9cc7f0ce84cb803bfea9477f765c0d7b4daf26048e59651b9e6a7bfbb.img.xz",
-    "hash": "e8acf2a9cc7f0ce84cb803bfea9477f765c0d7b4daf26048e59651b9e6a7bfbb",
-    "hash_raw": "e8acf2a9cc7f0ce84cb803bfea9477f765c0d7b4daf26048e59651b9e6a7bfbb",
-    "size": 3282256,
-    "sparse": false,
-    "full_check": true,
-    "has_ab": true,
-    "ondevice_hash": "bea7f1a24428c3ededf672fa4fc78baf180cfbd8aafb77c974655b38517283e3"
-  },
-  {
-    "name": "xbl_config",
-    "url": "https://commadist.azureedge.net/agnosupdate/xbl_config-758552ecf92b5569677197783bf0ccb73d7f961685308e45d3276ac9dd974f85.img.xz",
-    "hash": "758552ecf92b5569677197783bf0ccb73d7f961685308e45d3276ac9dd974f85",
-    "hash_raw": "758552ecf92b5569677197783bf0ccb73d7f961685308e45d3276ac9dd974f85",
-    "size": 98124,
-    "sparse": false,
-    "full_check": true,
-    "has_ab": true,
-    "ondevice_hash": "fb18cde08a98a168961ecd357e92474823046752b94e112f59fe51a6acd7197d"
-  },
-  {
-    "name": "abl",
-    "url": "https://commadist.azureedge.net/agnosupdate/abl-b6fba807b9bcd66a31f2afb0eba5163ec239693ad32e2e4200f6c356adfe098c.img.xz",
-    "hash": "b6fba807b9bcd66a31f2afb0eba5163ec239693ad32e2e4200f6c356adfe098c",
-    "hash_raw": "b6fba807b9bcd66a31f2afb0eba5163ec239693ad32e2e4200f6c356adfe098c",
-    "size": 274432,
-    "sparse": false,
-    "full_check": true,
-    "has_ab": true,
-    "ondevice_hash": "b6fba807b9bcd66a31f2afb0eba5163ec239693ad32e2e4200f6c356adfe098c"
-  },
-  {
-    "name": "aop",
-    "url": "https://commadist.azureedge.net/agnosupdate/aop-78b2287ca219a0811b3004c523fa0f4749e4d1fd92be3aba61699305b7943ad1.img.xz",
-    "hash": "78b2287ca219a0811b3004c523fa0f4749e4d1fd92be3aba61699305b7943ad1",
-    "hash_raw": "78b2287ca219a0811b3004c523fa0f4749e4d1fd92be3aba61699305b7943ad1",
-    "size": 184364,
-    "sparse": false,
-    "full_check": true,
-    "has_ab": true,
-    "ondevice_hash": "6c9135446bd3fc075fcee59b887a12e49029ab1f98ed8d6d1e32c73569d47de3"
-  },
-  {
-    "name": "devcfg",
-    "url": "https://commadist.azureedge.net/agnosupdate/devcfg-f71df3a86958c093ba3969254c4db025187eef9385427f1ade946742939b43cc.img.xz",
-    "hash": "f71df3a86958c093ba3969254c4db025187eef9385427f1ade946742939b43cc",
-    "hash_raw": "f71df3a86958c093ba3969254c4db025187eef9385427f1ade946742939b43cc",
-    "size": 40336,
-    "sparse": false,
-    "full_check": true,
-    "has_ab": true,
-    "ondevice_hash": "2a67971602012c1b43544964709da13c322786b456a8e78568b117e8b1540ce3"
-  },
-  {
-    "name": "boot",
-    "url": "https://commadist.azureedge.net/agnosupdate/boot-8806802b195a5b1396a3ae8dd92a8b7711dc522f6aceafd820e871bae5c8a6d8.img.xz",
-    "hash": "8806802b195a5b1396a3ae8dd92a8b7711dc522f6aceafd820e871bae5c8a6d8",
-    "hash_raw": "8806802b195a5b1396a3ae8dd92a8b7711dc522f6aceafd820e871bae5c8a6d8",
-    "size": 17487872,
-    "sparse": false,
-    "full_check": true,
-    "has_ab": true,
-    "ondevice_hash": "edca8bee1531e66953d107eeceeed2dc7b3ca46417e49d55508f94e58bf95db8"
-  },
-  {
-    "name": "system",
-    "url": "https://commadist.azureedge.net/agnosupdate/system-ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f.img.xz",
-    "hash": "78acfe16a7b62a3a91fc7a81f40a693e4468cec1c69df7d0b1e550aacc646113",
-    "hash_raw": "ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f",
-    "size": 4718592000,
-    "sparse": true,
-    "full_check": false,
-    "has_ab": true,
-    "ondevice_hash": "743142c5a898f27b2a1029cca42c8a5d5d1fc0096414422b850fe84c8d0b8342",
-    "alt": {
-      "hash": "ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f",
-      "url": "https://commadist.azureedge.net/agnosupdate/system-ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f.img",
-      "size": 4718592000
-    }
-  }
-]

common/hardware/tici/tests/__init__.py

@@ -1 +0,0 @@
-

common/params.cc

@@ -12,7 +12,7 @@
 #include "common/queue.h"
 #include "common/swaglog.h"
 #include "common/util.h"
-#include "common/hardware/hw.h"
+#include "system/hardware/hw.h"
 
 namespace {
 

common/params_keys.h

@@ -58,7 +58,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"IsDriverViewEnabled", {CLEAR_ON_MANAGER_START, BOOL}},
     {"IsEngaged", {PERSISTENT, BOOL}},
     {"IsLdwEnabled", {PERSISTENT | BACKUP, BOOL}},
-    {"IsLiveStreaming", {CLEAR_ON_MANAGER_START, BOOL}},
     {"IsMetric", {PERSISTENT | BACKUP, BOOL}},
     {"IsOffroad", {CLEAR_ON_MANAGER_START, BOOL}},
     {"IsOnroad", {PERSISTENT, BOOL}},
@@ -82,7 +81,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"LiveParameters", {PERSISTENT, JSON}},
     {"LiveParametersV2", {PERSISTENT, BYTES}},
     {"LivestreamEncoderBitrate", {CLEAR_ON_MANAGER_START | DONT_LOG, INT}},
-    {"LivestreamRequestKeyframe", {CLEAR_ON_MANAGER_START | DONT_LOG, BOOL}},
     {"LiveTorqueParameters", {PERSISTENT | DONT_LOG, BYTES}},
     {"LocationFilterInitialState", {PERSISTENT, BYTES}},
     {"LateralManeuverMode", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},

common/prefix.h

@@ -5,7 +5,7 @@
 
 #include "common/params.h"
 #include "common/util.h"
-#include "common/hardware/hw.h"
+#include "system/hardware/hw.h"
 
 class OpenpilotPrefix {
 public:

common/prefix.py

@@ -5,9 +5,9 @@ import uuid
 
 
 from openpilot.common.params import Params
-from openpilot.common.hardware import PC
-from openpilot.common.hardware.hw import Paths
-from openpilot.common.hardware.hw import DEFAULT_DOWNLOAD_CACHE_ROOT
+from openpilot.system.hardware import PC
+from openpilot.system.hardware.hw import Paths
+from openpilot.system.hardware.hw import DEFAULT_DOWNLOAD_CACHE_ROOT
 
 class OpenpilotPrefix:
   def __init__(self, prefix: str | None = None, create_dirs_on_enter: bool = True, clean_dirs_on_exit: bool = True, shared_download_cache: bool = False):

common/realtime.py

@@ -7,7 +7,7 @@ import time
 from setproctitle import getproctitle
 
 from openpilot.common.utils import MovingAverage
-from openpilot.common.hardware import PC
+from openpilot.system.hardware import PC
 
 
 # time step for each process

common/swaglog.cc

@@ -13,7 +13,7 @@
 #include <stdarg.h>
 #include "json11/json11.hpp"
 #include "common/version.h"
-#include "common/hardware/hw.h"
+#include "system/hardware/hw.h"
 
 #include "sunnypilot/common/version.h"
 

common/swaglog.py

@@ -8,7 +8,7 @@ from logging.handlers import BaseRotatingHandler
 import zmq
 
 from openpilot.common.logging_extra import SwagLogger, SwagFormatter, SwagLogFileFormatter
-from openpilot.common.hardware.hw import Paths
+from openpilot.system.hardware.hw import Paths
 
 
 def get_file_handler():

common/tests/test_swaglog.cc

@@ -6,7 +6,7 @@
 #include "common/swaglog.h"
 #include "common/util.h"
 #include "common/version.h"
-#include "common/hardware/hw.h"
+#include "system/hardware/hw.h"
 #include "json11/json11.hpp"
 
 #include "sunnypilot/common/version.h"

conftest.py

@@ -5,7 +5,7 @@ import pytest
 
 from openpilot.common.prefix import OpenpilotPrefix
 from openpilot.system.manager import manager
-from openpilot.common.hardware import TICI, HARDWARE
+from openpilot.system.hardware import TICI, HARDWARE
 
 # these are heavy CI-only tests, invoked explicitly in .github/workflows/tests.yaml
 collect_ignore = [
@@ -15,12 +15,9 @@ collect_ignore = [
   # which corrupts JIT captures for test_warp.py in the same process. Run separately in CI.
   "sunnypilot/modeld_v2/tests/test_warp.py",
 ]
-
-
-def pytest_sessionstart(session):
-  # TODO: fix tests and enable test order randomization
-  if session.config.pluginmanager.hasplugin('randomly'):
-    session.config.option.randomly_reorganize = False
+collect_ignore_glob = [
+  "selfdrive/debug/*.py",
+]
 
 
 @pytest.hookimpl(hookwrapper=True, trylast=True)

launch_chffrplus.sh

@@ -19,12 +19,12 @@ function agnos_init {
 
   # Check if AGNOS update is required
   if [ $(< /VERSION) != "$AGNOS_VERSION" ]; then
-    AGNOS_PY="$DIR/common/hardware/tici/agnos.py"
+    AGNOS_PY="$DIR/system/hardware/tici/agnos.py"
     MANIFEST="$DIR/system/hardware/tici/agnos.json"
     if $AGNOS_PY --verify $MANIFEST; then
       sudo reboot
     fi
-    $DIR/common/hardware/tici/updater $AGNOS_PY $MANIFEST
+    $DIR/system/hardware/tici/updater $AGNOS_PY $MANIFEST
   fi
 }
 

pyproject.toml

@@ -68,7 +68,7 @@ dependencies = [
 
   # these should be removed
   "psutil",
-  "pycryptodome", # used in panda, body, and a test
+  "pycryptodome", # used in updated/casync, panda, body, and a test
   "setproctitle",
 
   # logreader
@@ -127,7 +127,7 @@ allow-direct-references = true
 
 [tool.pytest.ini_options]
 minversion = "6.0"
-addopts = "--ignore=openpilot/ --ignore=opendbc/ --ignore=panda/ --ignore=rednose_repo/ --ignore=tinygrad_repo/ --ignore=teleoprtc_repo/ --ignore=msgq/ --ignore=selfdrive/modeld -Werror --strict-config --strict-markers --durations=10 -n auto --dist=loadgroup"
+addopts = "--ignore=openpilot/ --ignore=opendbc/ --ignore=panda/ --ignore=rednose_repo/ --ignore=tinygrad_repo/ --ignore=teleoprtc_repo/ --ignore=msgq/ -Werror --strict-config --strict-markers --durations=10 -n auto --dist=loadgroup"
 cpp_files = "test_*"
 cpp_harness = "selfdrive/test/cpp_harness.py"
 python_files = "test_*.py"

scripts/cell.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+nmcli connection modify --temporary esim ipv4.route-metric 1 ipv6.route-metric 1
+nmcli con up esim

scripts/disable-powersave.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from openpilot.common.hardware import HARDWARE
+from openpilot.system.hardware import HARDWARE
 
 if __name__ == "__main__":
   HARDWARE.set_power_save(False)

scripts/manage-powersave.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import multiprocessing
-from openpilot.common.hardware import HARDWARE
+from openpilot.system.hardware import HARDWARE
 
 
 def main():

scripts/reporter.py

@@ -25,9 +25,7 @@ class MetadataOnnxPBParser(OnnxPBParser):
 def get_checkpoint(f):
   model = MetadataOnnxPBParser(f).parse()
   metadata = {prop["key"]: prop["value"] for prop in model["metadata_props"]}
-  # "<uuid>" or ".../<run_uuid>/<step>"; combined models list vision then policy
-  parts = metadata['model_checkpoint'].split('/')
-  return parts[-2] if len(parts) > 1 else parts[0]
+  return metadata['model_checkpoint'].split('/')[0]
 
 
 if __name__ == "__main__":
@@ -39,8 +37,8 @@ if __name__ == "__main__":
     master_path = MASTER_PATH + MODEL_PATH + fn
     if os.path.exists(master_path):
       master = get_checkpoint(master_path)
-      master_col = f"[{master}](https://reporter.comma.life/{master})"
+      master_col = f"[{master}](https://reporter.comma.life/experiment/{master})"
     else:
       master_col = "N/A (new model)"
     pr = get_checkpoint(BASEDIR + MODEL_PATH + fn)
-    print("|", fn, "|", master_col, "|", f"[{pr}](https://reporter.comma.life/{pr})", "|")
+    print("|", fn, "|", master_col, "|", f"[{pr}](https://reporter.comma.life/experiment/{pr})", "|")

scripts/stop_updater.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env sh
+
+# Stop updater
+pkill -2 -f system.updated.updated
+
+# Remove pending update
+rm -f /data/safe_staging/finalized/.overlay_consistent

scripts/usb.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+# testing the GPU box
+
+export XDG_CACHE_HOME=/data/tinycache
+mkdir -p $XDG_CACHE_HOME
+
+cd /data/openpilot/tinygrad_repo/examples
+while true; do
+  AMD=1 AMD_IFACE=usb python ./beautiful_cartpole.py
+  sleep 1
+done

scripts/usbgpu/benchmark.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -e
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
+cd $DIR/../../tinygrad_repo
+
+GREEN='\033[0;32m'
+NC='\033[0m'
+
+
+#export DEBUG=2
+export PYTHONPATH=.
+export AM_RESET=1
+export AMD=1
+export AMD_IFACE=USB
+export AMD_LLVM=1
+
+python3 -m unittest -q --buffer test.test_tiny.TestTiny.test_plus \
+  > /tmp/test_tiny.log 2>&1 || (cat /tmp/test_tiny.log; exit 1)
+printf "${GREEN}Booted in ${SECONDS}s${NC}\n"
+printf "${GREEN}=============${NC}\n"
+
+printf "\n\n"
+printf "${GREEN}Transfer speeds:${NC}\n"
+printf "${GREEN}================${NC}\n"
+python3 test/external/external_test_usb_asm24.py TestDevCopySpeeds

selfdrive/assets/icons_mici/settings/software.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c4c38772e6080aa4b8bf5212d3619e949775468c64f3edb88a1a426d767c38d2
-size 1579

selfdrive/car/tests/test_docs.py

@@ -1,5 +1,9 @@
+import os
 
+from openpilot.common.basedir import BASEDIR
 from opendbc.car.docs import generate_cars_md, get_all_car_docs
+from openpilot.selfdrive.debug.dump_car_docs import dump_car_docs
+from openpilot.selfdrive.debug.print_docs_diff import print_car_docs_diff
 from openpilot.selfdrive.car.docs import CARS_MD_TEMPLATE
 
 
@@ -10,3 +14,9 @@ class TestCarDocs:
 
   def test_generator(self):
     generate_cars_md(self.all_cars, CARS_MD_TEMPLATE)
+
+  def test_docs_diff(self):
+    dump_path = os.path.join(BASEDIR, "selfdrive", "car", "tests", "cars_dump")
+    dump_car_docs(dump_path)
+    print_car_docs_diff(dump_path)
+    os.remove(dump_path)

selfdrive/car/tests/test_models.py

@@ -21,7 +21,7 @@ from opendbc.safety.tests.libsafety import libsafety_py
 from openpilot.common.basedir import BASEDIR
 from openpilot.selfdrive.pandad import can_capnp_to_list
 from openpilot.selfdrive.test.helpers import read_segment_list
-from openpilot.common.hardware.hw import DEFAULT_DOWNLOAD_CACHE_ROOT
+from openpilot.system.hardware.hw import DEFAULT_DOWNLOAD_CACHE_ROOT
 from openpilot.tools.lib.logreader import LogReader, LogsUnavailable, openpilotci_source, internal_source, comma_api_source
 from openpilot.tools.lib.route import SegmentName
 
@@ -192,7 +192,7 @@ class TestCarModelBase(unittest.TestCase):
     # make sure car params are within a valid range
     self.assertGreater(self.CP.mass, 1)
 
-    if self.CP.steerControlType not in (SteerControlType.angle, SteerControlType.curvature):
+    if self.CP.steerControlType != SteerControlType.angle:
       tuning = self.CP.lateralTuning.which()
       if tuning == 'pid':
         self.assertTrue(len(self.CP.lateralTuning.pid.kpV))
@@ -442,9 +442,8 @@ class TestCarModelBase(unittest.TestCase):
                               v_ego_raw < (self.safety.get_vehicle_speed_min() - 1e-3))
 
       # check steering angle for angle control cars (panda stores angle_meas in CAN units)
-      # ford and VW MEB excluded since they track curvature, not steering angle
-      # TODO: add curvature check, standardize CAN units to rm brand specific ANGLE_DEG_TO_CAN
-      if self.CP.steerControlType == SteerControlType.angle and not self.CP.notCar and self.CP.brand not in ("ford", "volkswagen"):
+      # ford excluded since it tracks curvature, not steering angle
+      if self.CP.steerControlType == SteerControlType.angle and not self.CP.notCar and self.CP.brand != "ford":
         angle_can = (CS.steeringAngleDeg + CS.steeringAngleOffsetDeg) * ANGLE_DEG_TO_CAN[self.CP.brand]
         checks['steeringAngleDeg'] += (angle_can > (self.safety.get_angle_meas_max() + 1) or
                                        angle_can < (self.safety.get_angle_meas_min() - 1))

selfdrive/controls/controlsd.py

@@ -15,7 +15,6 @@ from openpilot.selfdrive.controls.lib.drive_helpers import clip_curvature
 from openpilot.selfdrive.controls.lib.latcontrol import LatControl
 from openpilot.selfdrive.controls.lib.latcontrol_pid import LatControlPID
 from openpilot.selfdrive.controls.lib.latcontrol_angle import LatControlAngle, STEER_ANGLE_SATURATION_THRESHOLD
-from openpilot.selfdrive.controls.lib.latcontrol_curvature import LatControlCurvature
 from openpilot.selfdrive.controls.lib.latcontrol_torque import LatControlTorque
 from openpilot.selfdrive.controls.lib.longcontrol import LongControl
 from openpilot.selfdrive.modeld.modeld import LAT_SMOOTH_SECONDS
@@ -60,8 +59,6 @@ class Controls(ControlsExt):
     self.LaC: LatControl
     if self.CP.steerControlType == car.CarParams.SteerControlType.angle:
       self.LaC = LatControlAngle(self.CP, self.CP_SP, self.CI, DT_CTRL)
-    elif self.CP.steerControlType == car.CarParams.SteerControlType.curvature:
-      self.LaC = LatControlCurvature(self.CP, self.CP_SP, self.CI, DT_CTRL)
     elif self.CP.lateralTuning.which() == 'pid':
       self.LaC = LatControlPID(self.CP, self.CP_SP, self.CI, DT_CTRL)
     elif self.CP.lateralTuning.which() == 'torque':
@@ -146,14 +143,11 @@ class Controls(ControlsExt):
     lat_delay = self.sm["liveDelay"].lateralDelay + LAT_SMOOTH_SECONDS
 
     actuators.curvature = self.desired_curvature
-    steer, lateral_output, lac_log = self.LaC.update(CC.latActive, CS, self.VM, lp,
-                                                     self.steer_limited_by_safety, self.desired_curvature,
-                                                     self.calibrated_pose, curvature_limited, lat_delay)
+    steer, steeringAngleDeg, lac_log = self.LaC.update(CC.latActive, CS, self.VM, lp,
+                                                       self.steer_limited_by_safety, self.desired_curvature,
+                                                       self.calibrated_pose, curvature_limited, lat_delay)
     actuators.torque = float(steer)
-    if self.CP.steerControlType == car.CarParams.SteerControlType.curvature:
-      actuators.curvature = float(lateral_output)
-    else:
-      actuators.steeringAngleDeg = float(lateral_output)
+    actuators.steeringAngleDeg = float(steeringAngleDeg)
     # Ensure no NaNs/Infs
     for p in ACTUATOR_FIELDS:
       attr = getattr(actuators, p)
@@ -221,14 +215,9 @@ class Controls(ControlsExt):
     cs.forceDecel = bool((self.sm['driverMonitoringState'].alertLevel == log.DriverMonitoringState.AlertLevel.three) or
                          (self.sm['selfdriveState'].state == State.softDisabling))
 
-    # trigger the car's stock driver monitoring escalation
-    CC.driverMonitoringEscalation = cs.forceDecel
-
     lat_tuning = self.CP.lateralTuning.which()
     if self.CP.steerControlType == car.CarParams.SteerControlType.angle:
       cs.lateralControlState.angleState = lac_log
-    elif self.CP.steerControlType == car.CarParams.SteerControlType.curvature:
-      cs.lateralControlState.curvatureState = lac_log
     elif lat_tuning == 'pid':
       cs.lateralControlState.pidState = lac_log
     elif lat_tuning == 'torque':

selfdrive/controls/lib/desire_helper.py

@@ -45,6 +45,7 @@ class DesireHelper:
     self.lane_change_direction = LaneChangeDirection.none
     self.lane_change_timer = 0.0
     self.lane_change_ll_prob = 1.0
+    self.keep_pulse_timer = 0.0
     self.prev_one_blinker = False
     self.desire = log.Desire.none
     self.alc = AutoLaneChangeController(self)
@@ -131,4 +132,14 @@ class DesireHelper:
     else:
       self.desire = DESIRES[self.lane_change_direction][self.lane_change_state]
 
+    # Send keep pulse once per second during LaneChangeStart.preLaneChange
+    if self.lane_change_state in (LaneChangeState.off, LaneChangeState.laneChangeStarting):
+      self.keep_pulse_timer = 0.0
+    elif self.lane_change_state == LaneChangeState.preLaneChange:
+      self.keep_pulse_timer += DT_MDL
+      if self.keep_pulse_timer > 1.0:
+        self.keep_pulse_timer = 0.0
+      elif self.desire in (log.Desire.keepLeft, log.Desire.keepRight):
+        self.desire = log.Desire.none
+
     self.alc.update_state()

selfdrive/controls/lib/latcontrol_curvature.py

@@ -1,58 +0,0 @@
-import math
-
-from cereal import log
-from openpilot.common.pid import PIDController
-from openpilot.selfdrive.controls.lib.latcontrol import LatControl
-from openpilot.selfdrive.controls.lib.drive_helpers import MAX_CURVATURE
-
-CURVATURE_SATURATION_THRESHOLD = 1e-3  # 1/m
-
-
-class LatControlCurvature(LatControl):
-  def __init__(self, CP, CP_SP, CI, dt):
-    super().__init__(CP, CP_SP, CI, dt)
-    self.sat_check_min_speed = 5.
-    if CP.lateralTuning.which() == 'pid':
-      ct = CP.lateralTuning.pid
-      self.pid = PIDController((ct.kpBP, ct.kpV), (ct.kiBP, ct.kiV),
-                               pos_limit=MAX_CURVATURE, neg_limit=-MAX_CURVATURE, rate=1 / dt)
-      self.kf = ct.kf
-    else:
-      self.pid = None
-      self.kf = 1.
-
-  def reset(self):
-    super().reset()
-    if self.pid is not None:
-      self.pid.reset()
-
-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited, lat_delay):
-    curvature_log = log.ControlsState.LateralCurvatureState.new_message()
-    actual_curvature = -VM.calc_curvature(math.radians(CS.steeringAngleDeg - params.angleOffsetDeg), CS.vEgo, params.roll)
-    error = desired_curvature - actual_curvature
-
-    if not active:
-      output_curvature = 0.0
-      curvature_log.active = False
-      if self.pid is not None:
-        self.pid.reset()
-    elif self.pid is None or CS.steeringPressed:
-      # no PID or override: feedforward only
-      if self.pid is not None:
-        self.pid.reset()
-      output_curvature = self.kf * desired_curvature
-      curvature_log.active = True
-    else:
-      output_curvature = self.pid.update(error, speed=CS.vEgo, feedforward=self.kf * desired_curvature)
-      curvature_log.p = float(self.pid.p)
-      curvature_log.i = float(self.pid.i)
-      curvature_log.f = float(self.pid.f)
-      curvature_log.active = True
-
-    curvature_log.error = float(error)
-    curvature_log.actualCurvature = float(actual_curvature)
-    curvature_log.desiredCurvature = float(desired_curvature)
-    curvature_log.output = float(output_curvature)
-    curvature_log.saturated = bool(self._check_saturation(abs(error) > CURVATURE_SATURATION_THRESHOLD, CS,
-                                                          False, curvature_limited))
-    return 0.0, float(output_curvature), curvature_log

selfdrive/debug/README.md

@@ -0,0 +1,59 @@
+# debug scripts
+
+## [can_printer.py](can_printer.py)
+
+```
+usage: can_printer.py [-h] [--bus BUS] [--max_msg MAX_MSG] [--addr ADDR]
+
+simple CAN data viewer
+
+optional arguments:
+  -h, --help         show this help message and exit
+  --bus BUS          CAN bus to print out (default: 0)
+  --max_msg MAX_MSG  max addr (default: None)
+  --addr ADDR
+```
+
+## [dump.py](dump.py)
+
+```
+usage: dump.py [-h] [--pipe] [--raw] [--json] [--dump-json] [--no-print] [--addr ADDR] [--values VALUES] [socket [socket ...]]
+
+Dump communication sockets. See cereal/services.py for a complete list of available sockets.
+
+positional arguments:
+  socket           socket names to dump. defaults to all services defined in cereal
+
+optional arguments:
+  -h, --help       show this help message and exit
+  --pipe
+  --raw
+  --json
+  --dump-json
+  --no-print
+  --addr ADDR
+  --values VALUES  values to monitor (instead of entire event)
+```
+
+## [vw_mqb_config.py](vw_mqb_config.py)
+
+```
+usage: vw_mqb_config.py [-h] [--debug] {enable,show,disable}
+
+Shows Volkswagen EPS software and coding info, and enables or disables Heading Control
+Assist (Lane Assist). Useful for enabling HCA on cars without factory Lane Assist that want
+to use openpilot integrated at the CAN gateway (J533).
+
+positional arguments:
+  {enable,show,disable}
+                        show or modify current EPS HCA config
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --debug               enable ISO-TP/UDS stack debugging output
+
+This tool is meant to run directly on a vehicle-installed comma three, with
+the openpilot/tmux processes stopped. It should also work on a separate PC with a USB-
+attached comma panda. Vehicle ignition must be on. Recommend engine not be running when
+making changes. Must turn ignition off and on again for any changes to take effect.
+```

selfdrive/debug/analyze-msg-size.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+import argparse
+from tqdm import tqdm
+
+from cereal.services import SERVICE_LIST, QueueSize
+from openpilot.tools.lib.logreader import LogReader
+
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser(description="Analyze message sizes from a log route")
+  parser.add_argument("route", nargs="?", default="98395b7c5b27882e/000000a8--f87e7cd255",
+                      help="Log route to analyze (default: 98395b7c5b27882e/000000a8--f87e7cd255)")
+  args = parser.parse_args()
+
+  lr = LogReader(args.route)
+
+  szs = {}
+  for msg in tqdm(lr):
+    sz = len(msg.as_builder().to_bytes())
+    msg_type = msg.which()
+    if msg_type not in szs:
+      szs[msg_type] = {'min': sz, 'max': sz, 'sum': sz, 'count': 1}
+    else:
+      szs[msg_type]['min'] = min(szs[msg_type]['min'], sz)
+      szs[msg_type]['max'] = max(szs[msg_type]['max'], sz)
+      szs[msg_type]['sum'] += sz
+      szs[msg_type]['count'] += 1
+
+  print()
+  print(f"{'Service':<36} {'Min (KB)':>12} {'Max (KB)':>12} {'Avg (KB)':>12} {'KB/min':>12} {'KB/sec':>12} {'Minutes in 10MB':>18} {'Seconds in Queue':>18}")
+  print("-" * 132)
+  def sort_key(x):
+    k, v = x
+    avg = v['sum'] / v['count']
+    freq = SERVICE_LIST.get(k, None)
+    freq_val = freq.frequency if freq else 0.0
+    kb_per_min = (avg * freq_val * 60) / 1024 if freq_val > 0 else 0.0
+    return kb_per_min
+  total_kb_per_min = 0.0
+  RINGBUFFER_SIZE_KB = 10 * 1024  # 10MB old default
+  for k, v in sorted(szs.items(), key=sort_key, reverse=True):
+    avg = v['sum'] / v['count']
+    service = SERVICE_LIST.get(k, None)
+    freq_val = service.frequency if service else 0.0
+    queue_size_kb = (service.queue_size / 1024) if service else 250  # default to SMALL
+    kb_per_min = (avg * freq_val * 60) / 1024 if freq_val > 0 else 0.0
+    kb_per_sec = kb_per_min / 60
+    minutes_in_buffer = RINGBUFFER_SIZE_KB / kb_per_min if kb_per_min > 0 else float('inf')
+    seconds_in_queue = (queue_size_kb / kb_per_sec) if kb_per_sec > 0 else float('inf')
+    total_kb_per_min += kb_per_min
+    min_str = f"{minutes_in_buffer:.2f}" if minutes_in_buffer != float('inf') else "inf"
+    sec_queue_str = f"{seconds_in_queue:.2f}" if seconds_in_queue != float('inf') else "inf"
+    print(f"{k:<36} {v['min']/1024:>12.2f} {v['max']/1024:>12.2f} {avg/1024:>12.2f} {kb_per_min:>12.2f} {kb_per_sec:>12.2f} {min_str:>18} {sec_queue_str:>18}")
+
+  # Summary section
+  print()
+  print(f"Total usage: {total_kb_per_min / 1024:.2f} MB/min")
+
+  # Calculate memory usage: old (10MB for all) vs new (from services.py)
+  OLD_SIZE = 10 * 1024 * 1024  # 10MB was the old default
+  old_total = len(SERVICE_LIST) * OLD_SIZE
+
+  new_total = sum(s.queue_size for s in SERVICE_LIST.values())
+
+  # Count by queue size
+  size_counts = {QueueSize.BIG: 0, QueueSize.MEDIUM: 0, QueueSize.SMALL: 0}
+  for s in SERVICE_LIST.values():
+    size_counts[s.queue_size] += 1
+
+  savings_pct = (1 - new_total / old_total) * 100
+
+  print()
+  print(f"{'Queue Size Comparison':<40}")
+  print("-" * 60)
+  print(f"{'Old (10MB default):':<30} {old_total / 1024 / 1024:>10.2f} MB")
+  print(f"{'New (from services.py):':<30} {new_total / 1024 / 1024:>10.2f} MB")
+  print(f"{'Savings:':<30} {savings_pct:>10.1f}%")
+  print()
+  print(f"{'Breakdown:':<30}")
+  print(f"  BIG (10MB):    {size_counts[QueueSize.BIG]:>3} services")
+  print(f"  MEDIUM (2MB):  {size_counts[QueueSize.MEDIUM]:>3} services")
+  print(f"  SMALL (250KB): {size_counts[QueueSize.SMALL]:>3} services")

selfdrive/debug/can_print_changes.py

@@ -5,7 +5,7 @@ import time
 from collections import defaultdict
 
 import cereal.messaging as messaging
-from openpilot.tools.scripts.can_table import can_table
+from openpilot.selfdrive.debug.can_table import can_table
 from openpilot.tools.lib.logreader import LogIterable, LogReader
 
 RED = '\033[91m'

selfdrive/debug/check_can_parser_performance.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+import numpy as np
+import time
+from tqdm import tqdm
+
+from cereal import car
+from opendbc.car.tests.routes import CarTestRoute
+from openpilot.selfdrive.car.tests.test_models import TestCarModelBase
+from openpilot.tools.plotjuggler.juggle import DEMO_ROUTE
+
+N_RUNS = 10
+
+
+class CarModelTestCase(TestCarModelBase):
+  test_route = CarTestRoute(DEMO_ROUTE, None)
+
+
+if __name__ == '__main__':
+  # Get CAN messages and parsers
+  tm = CarModelTestCase()
+  tm.setUpClass()
+  tm.setUp()
+
+  CC = car.CarControl.new_message()
+  ets = []
+  for _ in tqdm(range(N_RUNS)):
+    start_t = time.process_time_ns()
+    for msg in tm.can_msgs:
+      for cp in tm.CI.can_parsers.values():
+        if cp is not None:
+          cp.update_strings(msg)
+    ets.append((time.process_time_ns() - start_t) * 1e-6)
+
+  print(f'{len(tm.can_msgs)} CAN packets, {N_RUNS} runs')
+  print(f'{np.mean(ets):.2f} mean ms, {max(ets):.2f} max ms, {min(ets):.2f} min ms, {np.std(ets):.2f} std ms')
+  print(f'{np.mean(ets) / len(tm.can_msgs):.4f} mean ms / CAN packet')

selfdrive/debug/check_freq.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+import argparse
+import numpy as np
+import time
+from collections import defaultdict, deque
+from collections.abc import MutableSequence
+
+import cereal.messaging as messaging
+
+
+if __name__ == "__main__":
+  context = messaging.Context()
+  poller = messaging.Poller()
+
+  parser = argparse.ArgumentParser()
+  parser.add_argument("socket", type=str, nargs='*', help="socket name")
+  args = parser.parse_args()
+
+  socket_names = args.socket
+  sockets = {}
+
+  rcv_times: defaultdict[str, MutableSequence[float]] = defaultdict(lambda: deque(maxlen=100))
+  valids: defaultdict[str, deque[bool]] = defaultdict(lambda: deque(maxlen=100))
+
+  t = time.monotonic()
+  for name in socket_names:
+    sock = messaging.sub_sock(name, poller=poller)
+    sockets[sock] = name
+
+  prev_print = t
+  while True:
+    for socket in poller.poll(100):
+      msg = messaging.recv_one(socket)
+      if msg is None:
+        continue
+
+      name = msg.which()
+
+      t = time.monotonic()
+      rcv_times[name].append(msg.logMonoTime / 1e9)
+      valids[name].append(msg.valid)
+
+    if t - prev_print > 1:
+      print()
+      for name in socket_names:
+        dts = np.diff(rcv_times[name])
+        mean = np.mean(dts)
+        print(f"{name}: Freq {1.0 / mean:.2f} Hz, Min {np.min(dts) / mean * 100:.2f}%, Max {np.max(dts) / mean * 100:.2f}%, valid ", all(valids[name]))
+
+      prev_print = t

selfdrive/debug/check_lag.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+import cereal.messaging as messaging
+from cereal.services import SERVICE_LIST
+
+TO_CHECK = ['carState']
+
+
+if __name__ == "__main__":
+  sm = messaging.SubMaster(TO_CHECK)
+
+  prev_t: dict[str, float] = {}
+
+  while True:
+    sm.update()
+
+    for s in TO_CHECK:
+      if sm.updated[s]:
+        t = sm.logMonoTime[s] / 1e9
+
+        if s in prev_t:
+          expected = 1.0 / (SERVICE_LIST[s].frequency)
+          dt = t - prev_t[s]
+          if dt > 10 * expected:
+            print(t, s, dt)
+
+        prev_t[s] = t

selfdrive/debug/check_timings.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+import sys
+import time
+import numpy as np
+import datetime
+from collections.abc import MutableSequence
+from collections import defaultdict
+
+import cereal.messaging as messaging
+
+
+if __name__ == "__main__":
+  ts: defaultdict[str, MutableSequence[float]] = defaultdict(list)
+  socks = {s: messaging.sub_sock(s, conflate=False) for s in sys.argv[1:]}
+  try:
+    st = time.monotonic()
+    while True:
+      print()
+      for s, sock in socks.items():
+        msgs = messaging.drain_sock(sock)
+        for m in msgs:
+          ts[s].append(m.logMonoTime / 1e6)
+
+        if len(ts[s]) > 2:
+          d = np.diff(ts[s])[-100:]
+          print(f"{s:25} {np.mean(d):7.2f} {np.std(d):7.2f} {np.max(d):7.2f} {np.min(d):7.2f}")
+      time.sleep(1)
+  except KeyboardInterrupt:
+    print("\n")
+    print("="*5, "timing summary", "="*5)
+    for s, sock in socks.items():
+      msgs = messaging.drain_sock(sock)
+      if len(ts[s]) > 2:
+        d = np.diff(ts[s])
+        print(f"{s:25} {np.mean(d):7.2f} {np.std(d):7.2f} {np.max(d):7.2f} {np.min(d):7.2f}")
+    print("="*5, datetime.timedelta(seconds=time.monotonic()-st), "="*5)

selfdrive/debug/cpu_usage_stat.py

@@ -8,7 +8,7 @@ System tools like top/htop can only show current cpu usage values, so I write th
     Calculate minumium/maximum/accumulated_average cpu usage as long term inspections.
     Monitor multiple processes simuteneously.
   Sample usage:
-    root@localhost:/data/openpilot$ python tools/scripts/cpu_usage_stat.py pandad,ubloxd
+    root@localhost:/data/openpilot$ python selfdrive/debug/cpu_usage_stat.py pandad,ubloxd
     ('Add monitored proc:', './pandad')
     ('Add monitored proc:', 'python locationd/ubloxd.py')
     pandad: 1.96%, min: 1.96%, max: 1.96%, acc: 1.96%

selfdrive/debug/dump_car_docs.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+import argparse
+import pickle
+
+from opendbc.car.docs import get_all_car_docs
+
+
+def dump_car_docs(path):
+  with open(path, 'wb') as f:
+    pickle.dump(get_all_car_docs(), f)
+  print(f'Dumping car info to {path}')
+
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser()
+  parser.add_argument("--path", required=True)
+  args = parser.parse_args()
+  dump_car_docs(args.path)

selfdrive/debug/print_docs_diff.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+import argparse
+from collections import defaultdict
+import difflib
+import pickle
+
+from opendbc.car.docs import get_all_car_docs
+from opendbc.car.docs_definitions import Column
+
+FOOTNOTE_TAG = "<sup>{}</sup>"
+STAR_ICON = '<a href="##"><img valign="top" ' + \
+            'src="https://media.githubusercontent.com/media/commaai/openpilot/master/docs/assets/icon-star-{}.svg" width="22" /></a>'
+VIDEO_ICON = '<a href="{}" target="_blank">' + \
+             '<img height="18px" src="https://media.githubusercontent.com/media/commaai/openpilot/master/docs/assets/icon-youtube.svg" /></a>'
+COLUMNS = "|" + "|".join([column.value for column in Column]) + "|"
+COLUMN_HEADER = "|---|---|---|{}|".format("|".join([":---:"] * (len(Column) - 3)))
+ARROW_SYMBOL = "➡️"
+
+
+def load_base_car_docs(path):
+  with open(path, "rb") as f:
+    return pickle.load(f)
+
+
+def match_cars(base_cars, new_cars):
+  changes = []
+  additions = []
+  for new in new_cars:
+    # Addition if no close matches or close match already used
+    # Change if close match and not already used
+    matches = difflib.get_close_matches(new.name, [b.name for b in base_cars], cutoff=0.)
+    if not len(matches) or matches[0] in [c[1].name for c in changes]:
+      additions.append(new)
+    else:
+      changes.append((new, next(car for car in base_cars if car.name == matches[0])))
+
+  # Removal if base car not in changes
+  removals = [b for b in base_cars if b.name not in [c[1].name for c in changes]]
+  return changes, additions, removals
+
+
+def build_column_diff(base_car, new_car):
+  row_builder = []
+  for column in Column:
+    base_column = base_car.get_column(column, STAR_ICON, VIDEO_ICON, FOOTNOTE_TAG)
+    new_column = new_car.get_column(column, STAR_ICON, VIDEO_ICON, FOOTNOTE_TAG)
+
+    if base_column != new_column:
+      row_builder.append(f"{base_column} {ARROW_SYMBOL} {new_column}")
+    else:
+      row_builder.append(new_column)
+
+  return format_row(row_builder)
+
+
+def format_row(builder):
+  return "|" + "|".join(builder) + "|"
+
+
+def print_car_docs_diff(path):
+  base_car_docs = defaultdict(list)
+  new_car_docs = defaultdict(list)
+
+  for car in load_base_car_docs(path):
+    base_car_docs[car.car_fingerprint].append(car)
+  for car in get_all_car_docs():
+    new_car_docs[car.car_fingerprint].append(car)
+
+  # Add new platforms to base cars so we can detect additions and removals in one pass
+  base_car_docs.update({car: [] for car in new_car_docs if car not in base_car_docs})
+
+  changes = defaultdict(list)
+  for base_car_model, base_cars in base_car_docs.items():
+    # Match car info changes, and get additions and removals
+    new_cars = new_car_docs[base_car_model]
+    car_changes, car_additions, car_removals = match_cars(base_cars, new_cars)
+
+    # Removals
+    for car_docs in car_removals:
+      changes["removals"].append(format_row([car_docs.get_column(column, STAR_ICON, VIDEO_ICON, FOOTNOTE_TAG) for column in Column]))
+
+    # Additions
+    for car_docs in car_additions:
+      changes["additions"].append(format_row([car_docs.get_column(column, STAR_ICON, VIDEO_ICON, FOOTNOTE_TAG) for column in Column]))
+
+    for new_car, base_car in car_changes:
+      # Column changes
+      row_diff = build_column_diff(base_car, new_car)
+      if ARROW_SYMBOL in row_diff:
+        changes["column"].append(row_diff)
+
+      # Detail sentence changes
+      if base_car.detail_sentence != new_car.detail_sentence:
+        changes["detail"].append(f"- Sentence for {base_car.name} changed!\n" +
+                                 "  ```diff\n" +
+                                 f"  - {base_car.detail_sentence}\n" +
+                                 f"  + {new_car.detail_sentence}\n" +
+                                 "  ```")
+
+  # Print diff
+  if any(len(c) for c in changes.values()):
+    markdown_builder = ["### ⚠️ This PR makes changes to [CARS.md](../blob/master/docs/CARS.md) ⚠️"]
+
+    for title, category in (("## 🔀 Column Changes", "column"), ("## ❌ Removed", "removals"),
+                            ("## ➕ Added", "additions"), ("## 📖 Detail Sentence Changes", "detail")):
+      if len(changes[category]):
+        markdown_builder.append(title)
+        if category not in ("detail",):
+          markdown_builder.append(COLUMNS)
+          markdown_builder.append(COLUMN_HEADER)
+        markdown_builder.extend(changes[category])
+
+    print("\n".join(markdown_builder))
+
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser()
+  parser.add_argument("--path", required=True)
+  args = parser.parse_args()
+  print_car_docs_diff(args.path)

selfdrive/debug/touch_replay.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+import argparse
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from openpilot.tools.lib.logreader import LogReader
+
+if __name__ == '__main__':
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--width', default=2160, type=int)
+  parser.add_argument('--height', default=1080, type=int)
+  parser.add_argument('--route', default='rlog', type=str)
+  args = parser.parse_args()
+
+  w = args.width
+  h = args.height
+  route = args.route
+
+  fingers = [[-1, -1]] * 5
+  touch_points = []
+  current_slot = 0
+
+  lr = list(LogReader(route))
+  for msg in lr:
+    if msg.which() == 'touch':
+      for event in msg.touch:
+        if event.type == 3 and event.code == 47:
+          current_slot = event.value
+        elif event.type == 3 and event.code == 57 and event.value == -1:
+          fingers[current_slot] = [-1, -1]
+        elif event.type == 3 and event.code == 53:
+          fingers[current_slot][1] = event.value
+          if fingers[current_slot][0] != -1:
+            touch_points.append(fingers[current_slot].copy())
+        elif event.type == 3 and event.code == 54:
+          fingers[current_slot][0] = w - event.value
+          if fingers[current_slot][1] != -1:
+            touch_points.append(fingers[current_slot].copy())
+
+  if not touch_points:
+    print(f'No touch events found for {route}')
+    quit()
+
+  unique_points, counts = np.unique(touch_points, axis=0, return_counts=True)
+
+  plt.figure(figsize=(10, 3))
+  plt.scatter(unique_points[:, 0], unique_points[:, 1], c=counts, s=counts * 20, edgecolors='red')
+  plt.colorbar()
+  plt.title(f'Touches for {route}')
+  plt.xlim(0, w)
+  plt.ylim(0, h)
+  plt.grid(True)
+  plt.show()

selfdrive/debug/uiview.py

@@ -4,7 +4,7 @@ import time
 from cereal import car, log, messaging
 from openpilot.common.params import Params
 from openpilot.system.manager.process_config import managed_processes, is_tinygrad_model, is_stock_model
-from openpilot.common.hardware import HARDWARE
+from openpilot.system.hardware import HARDWARE
 
 if __name__ == "__main__":
   CP = car.CarParams(notCar=True, wheelbase=1, steerRatio=10)

selfdrive/locationd/calibrationd.py

@@ -13,7 +13,7 @@ from typing import NoReturn
 
 from cereal import log, car
 import cereal.messaging as messaging
-from openpilot.common.hardware import HARDWARE
+from openpilot.system.hardware import HARDWARE
 from openpilot.common.constants import CV
 from openpilot.common.params import Params
 from openpilot.common.realtime import config_realtime_process

selfdrive/locationd/lagd.py

@@ -8,7 +8,6 @@ from functools import partial
 import cereal.messaging as messaging
 from cereal import car, log
 from cereal.services import SERVICE_LIST
-from openpilot.common.constants import CV
 from openpilot.common.params import Params
 from openpilot.common.realtime import config_realtime_process
 from openpilot.common.swaglog import cloudlog
@@ -21,7 +20,7 @@ BLOCK_NUM_NEEDED = 5
 MOVING_WINDOW_SEC = 60.0
 MIN_OKAY_WINDOW_SEC = 25.0
 MIN_RECOVERY_BUFFER_SEC = 2.0
-MIN_VEGO = 50.0 * CV.MPH_TO_MS
+MIN_VEGO = 15.0
 MIN_ABS_YAW_RATE = 0.0
 MAX_YAW_RATE_SANITY_CHECK = 1.0
 MIN_NCC = 0.95
@@ -37,8 +36,6 @@ LAG_CANDIDATE_CORR_THRESHOLD = 0.9
 SMOOTH_K = 5
 SMOOTH_SIGMA = 1.0
 
-VERSION = 1  # bump this to invalidate old parameter caches
-
 
 def masked_symmetric_moving_average(x: np.ndarray, mask: np.ndarray, k: int, sigma: float) -> np.ndarray:
   assert k >= 1 and k % 2 == 1, "k must be positive and odd"
@@ -251,7 +248,6 @@ class LateralLagEstimator:
                             (self.min_valid_block_count * self.block_size), 100)
     if debug:
       liveDelay.points = self.block_avg.values.flatten().tolist()
-    liveDelay.version = VERSION
 
     return msg
 
@@ -372,10 +368,9 @@ def retrieve_initial_lag(params: Params, CP: car.CarParams):
         if last_CP.carFingerprint != CP.carFingerprint:
           raise Exception("Car model mismatch")
 
-        lag, valid_blocks, status, version = ld.lateralDelayEstimate, ld.validBlocks, ld.status, ld.version
+        lag, valid_blocks, status = ld.lateralDelayEstimate, ld.validBlocks, ld.status
         assert valid_blocks <= BLOCK_NUM, "Invalid number of valid blocks"
         assert status != log.LiveDelayData.Status.invalid, "Lag estimate is invalid"
-        assert version == VERSION, f"Lag estimate is from a different version (got {version}, expected {VERSION})"
         return lag, valid_blocks
     except Exception as e:
       cloudlog.error(f"Failed to retrieve initial lag: {e}")

selfdrive/locationd/locationd.py

@@ -206,11 +206,9 @@ class LocationEstimator:
       self._finite_check(t, new_x, new_P)
     return HandleLogResult.SUCCESS
 
-  def get_msg(self, sensors_valid: bool, inputs_valid: bool, filter_initialized: bool):
+  def get_msg(self, sensors_valid: bool, inputs_valid: bool, filter_valid: bool):
     state, cov = self.kf.x, self.kf.P
     std = np.sqrt(np.diag(cov))
-    filter_time_valid = bool(np.isfinite(self.kf.t))
-    filter_valid = filter_initialized and filter_time_valid
 
     orientation_ned, orientation_ned_std = state[States.NED_ORIENTATION], std[States.NED_ORIENTATION]
     velocity_device, velocity_device_std = state[States.DEVICE_VELOCITY], std[States.DEVICE_VELOCITY]

selfdrive/locationd/test/test_lagd.py

@@ -5,18 +5,18 @@ import pytest
 
 from cereal import messaging, log, car
 from openpilot.selfdrive.locationd.lagd import LateralLagEstimator, retrieve_initial_lag, masked_normalized_cross_correlation, \
-                                               BLOCK_NUM_NEEDED, BLOCK_SIZE, MIN_OKAY_WINDOW_SEC, VERSION
+                                               BLOCK_NUM_NEEDED, BLOCK_SIZE, MIN_OKAY_WINDOW_SEC
 from openpilot.selfdrive.test.process_replay.migration import migrate, migrate_carParams
 from openpilot.selfdrive.locationd.test.test_locationd_scenarios import TEST_ROUTE
 from openpilot.common.params import Params
 from openpilot.tools.lib.logreader import LogReader
-from openpilot.common.hardware import PC
+from openpilot.system.hardware import PC
 
 MAX_ERR_FRAMES = 1
 DT = 0.05
 
 
-def process_messages(estimator, lag_frames, n_frames, vego=25.0, rejection_threshold=0.0):
+def process_messages(estimator, lag_frames, n_frames, vego=20.0, rejection_threshold=0.0):
   for i in range(n_frames):
     t = i * estimator.dt
     desired_la = np.cos(10 * t) * 0.3
@@ -53,7 +53,6 @@ class TestLagd:
     msg = messaging.new_message('liveDelay')
     msg.liveDelay.lateralDelayEstimate = random.random()
     msg.liveDelay.validBlocks = random.randint(1, 10)
-    msg.liveDelay.version = VERSION
     params.put("LiveDelay", msg.to_bytes(), block=True)
     params.put("CarParamsPrevRoute", CP.as_builder().to_bytes(), block=True)
 
@@ -64,20 +63,6 @@ class TestLagd:
     assert lag == msg.liveDelay.lateralDelayEstimate
     assert valid_blocks == msg.liveDelay.validBlocks
 
-  def test_read_invalid_saved_params(self, subtests):
-    params = Params()
-
-    lr = migrate(LogReader(TEST_ROUTE), [migrate_carParams])
-    CP = next(m for m in lr if m.which() == "carParams").carParams
-
-    for msg_dict in [{'version': 0}, {'status': 'invalid'}, {'validBlocks': 100}]:
-      with subtests.test(msg=f"liveDelay={msg_dict}"):
-        msg = messaging.new_message('liveDelay')
-        msg.liveDelay = msg_dict
-        params.put("LiveDelay", msg.to_bytes(), block=True)
-        params.put("CarParamsPrevRoute", CP.as_builder().to_bytes(), block=True)
-        assert retrieve_initial_lag(params, CP) is None
-
   def test_ncc(self):
     lag_frames = random.randint(1, 19)
 

selfdrive/modeld/SConscript

@@ -79,21 +79,22 @@ compile_modeld_script = [
   File(f"{modeld_dir}/compile_modeld.py"),
   File(f"{modeld_dir}/get_model_metadata.py"),
   File("#system/camerad/cameras/nv12_info.py"),
-  File("#common/hardware/hw.py"),
+  File("#system/hardware/hw.py"),
 ]
 model_w, model_h = MEDMODEL_INPUT_SIZE
 frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
 
 for usbgpu in [False, True] if USBGPU else [False]:
   target_pkl_path = File(modeld_pkl_path(usbgpu)).abspath
-  # BIG_INTO_SMALL=1 builds the default target from the big model, e.g. to test it without a USB GPU
-  file_prefix, cmd_flags = ('big_', usbgpu_tg_flags) if usbgpu else ('big_' if os.getenv('BIG_INTO_SMALL') else '', tg_flags)
-  driving_onnx_deps = get_existing_chunks(File(f"models/{file_prefix}driving_supercombo.onnx").abspath)
+  file_prefix, cmd_flags = ('big_', usbgpu_tg_flags) if usbgpu else ('', tg_flags)
+  driving_onnx_deps = [p for m in [f'{file_prefix}driving_vision', f'{file_prefix}driving_on_policy']
+                       for p in get_existing_chunks(File(f"models/{m}.onnx").abspath)]
   camera_res_args = ' '.join(f'{cw}x{ch}' for cw, ch in CAMERA_CONFIGS)
   cmd = (f'{cmd_flags} {mac_brew_string} python3 {modeld_dir}/compile_modeld.py '
         f'--model-size {model_w}x{model_h} '
         f'--camera-resolutions {camera_res_args} '
-        f'--onnx {File(f"models/{file_prefix}driving_supercombo.onnx").abspath} '
+        f'--vision-onnx {File(f"models/{file_prefix}driving_vision.onnx").abspath} '
+        f'--on-policy-onnx {File(f"models/{file_prefix}driving_on_policy.onnx").abspath} '
         f'--output {target_pkl_path} --frame-skip {frame_skip}')
   onnx_sizes_sum = sum(os.path.getsize(f) for f in driving_onnx_deps)
   chunk_targets = get_chunk_targets(target_pkl_path, estimate_pickle_max_size(onnx_sizes_sum))

selfdrive/modeld/compile_modeld.py

@@ -1,13 +1,11 @@
 #!/usr/bin/env python3
 import argparse
 import atexit
-import math
 import os
 import pickle
-import tempfile
 import time
 from functools import partial
-from collections import namedtuple
+from collections import namedtuple, defaultdict
 
 import numpy as np
 
@@ -35,7 +33,7 @@ from tinygrad.engine.jit import TinyJit
 
 NV12Frame = namedtuple("NV12Frame", ['width', 'height', 'stride', 'y_height', 'uv_height', 'size'])
 WARP_INPUTS = ['img_q', 'big_img_q', 'tfm', 'big_tfm']
-POLICY_INPUTS = ['feat_q', 'desire_q', 'packed_npy_inputs']
+POLICY_INPUTS = ['feat_q', 'desire_q', 'desire', 'traffic_convention', 'action_t']
 
 UV_SCALE_MATRIX = np.array([[0.5, 0, 0], [0, 0.5, 0], [0, 0, 1]], dtype=np.float32)
 UV_SCALE_MATRIX_INV = np.linalg.inv(UV_SCALE_MATRIX)
@@ -51,8 +49,8 @@ def warp_perspective_tinygrad(src_flat, M_inv, dst_shape, src_shape, stride_pad,
   w_dst, h_dst = dst_shape
   h_src, w_src = src_shape
 
-  x = Tensor.arange(w_dst).reshape(1, w_dst).expand(h_dst, w_dst).reshape(-1)
-  y = Tensor.arange(h_dst).reshape(h_dst, 1).expand(h_dst, w_dst).reshape(-1)
+  x = Tensor.arange(w_dst, device=WARP_DEV).reshape(1, w_dst).expand(h_dst, w_dst).reshape(-1)
+  y = Tensor.arange(h_dst, device=WARP_DEV).reshape(h_dst, 1).expand(h_dst, w_dst).reshape(-1)
 
   # inline 3x3 matmul as elementwise to avoid reduce op (enables fusion with gather)
   src_x = M_inv[0, 0] * x + M_inv[0, 1] * y + M_inv[0, 2]
@@ -115,51 +113,34 @@ def make_frame_prepare(nv12: NV12Frame, model_w, model_h):
   return frame_prepare_tinygrad
 
 
-def make_warp_input_queues(vision_input_shapes, frame_skip, device):
+def make_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, device):
   img = vision_input_shapes['img']  # (1, 12, 128, 256)
   n_frames = img[1] // 6
   img_buf_shape = (frame_skip * (n_frames - 1) + 1, 6, img[2], img[3])
 
+  fb = policy_input_shapes['features_buffer']  # (1, 25, 512)
+  dp = policy_input_shapes['desire_pulse']  # (1, 25, 8)
+  tc = policy_input_shapes['traffic_convention']  # (1, 2)
+  #TODO action_t is hardcoded to match tc for future compatibility
+  at = tc
+
   npy = {
+    'desire': np.zeros(dp[2], dtype=np.float32),
+    'traffic_convention': np.zeros(tc, dtype=np.float32),
     'tfm': np.zeros((3, 3), dtype=np.float32),
     'big_tfm': np.zeros((3, 3), dtype=np.float32),
+    'action_t': np.zeros(at, dtype=np.float32),
   }
   input_queues = {
     'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
     'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'feat_q': Tensor(np.zeros((frame_skip * (fb[1] - 1) + 1, fb[0], fb[2]), dtype=np.float32), device=device).contiguous().realize(),
+    'desire_q': Tensor(np.zeros((frame_skip * dp[1], dp[0], dp[2]), dtype=np.float32), device=device).contiguous().realize(),
     **{k: Tensor(v, device='NPY').realize() for k, v in npy.items()},
   }
   return input_queues, npy
 
 
-def get_policy_npy_shapes(input_shapes):
-  dp = input_shapes['desire_pulse']  # (1, 25, 8)
-  tc = input_shapes['traffic_convention']  # (1, 2)
-  at = input_shapes['action_t']  # (1, 2)
-  fb = input_shapes['features_buffer']  # (1, 24, 512)
-  # TODO prev_feat shouldn't exist and be handled inside the JIT, but corrupt on QCOM for now
-  shapes = {'desire': (dp[2],), 'traffic_convention': tuple(tc), 'action_t': tuple(at), 'prev_feat': (fb[0], fb[2])}
-  return shapes, [math.prod(s) for s in shapes.values()]
-
-
-def make_input_queues(input_shapes, frame_skip, device):
-  input_queues, npy = make_warp_input_queues(input_shapes, frame_skip, device)
-
-  fb = input_shapes['features_buffer']  # (1, 24, 512), past features only; the model appends the current frame's feature
-  dp = input_shapes['desire_pulse']  # (1, 25, 8)
-
-  shapes, sizes = get_policy_npy_shapes(input_shapes)
-  packed_npy_inputs = np.zeros(sum(sizes), dtype=np.float32)
-  # views into the packed inputs, to be refilled at runtime
-  npy.update({k: v.reshape(s) for (k, s), v in zip(shapes.items(), np.split(packed_npy_inputs, np.cumsum(sizes[:-1])), strict=True)})
-  input_queues.update({
-    'feat_q': Tensor(np.zeros((frame_skip * fb[1], fb[0], fb[2]), dtype=np.float32), device=device).contiguous().realize(),
-    'desire_q': Tensor(np.zeros((frame_skip * dp[1], dp[0], dp[2]), dtype=np.float32), device=device).contiguous().realize(),
-    'packed_npy_inputs': Tensor(packed_npy_inputs, device='NPY').realize(),
-  })
-  return input_queues, npy
-
-
 def shift_and_sample(buf, new_val, sample_fn):
   buf.assign(buf[1:].cat(new_val, dim=0).contiguous())
   return sample_fn(buf)
@@ -182,43 +163,49 @@ def make_warp(nv12, model_w, model_h, frame_skip):
     big_tfm = big_tfm.to(WARP_DEV)
     Tensor.realize(tfm, big_tfm)
 
-    warped_frame = frame_prepare(frame, tfm).unsqueeze(0)
-    warped_big_frame = frame_prepare(big_frame, big_tfm).unsqueeze(0)
-    warped = Tensor.cat(warped_frame, warped_big_frame).to(Device.DEFAULT)
-    img = shift_and_sample(img_q, warped[0:1], sample_skip_fn)
-    big_img = shift_and_sample(big_img_q, warped[1:2], sample_skip_fn)
+    warped_frame = frame_prepare(frame, tfm).unsqueeze(0).to(Device.DEFAULT)
+    warped_big_frame = frame_prepare(big_frame, big_tfm).unsqueeze(0).to(Device.DEFAULT)
+    img = shift_and_sample(img_q, warped_frame, sample_skip_fn)
+    big_img = shift_and_sample(big_img_q, warped_big_frame, sample_skip_fn)
     return img, big_img
   return warp_enqueue
 
 
-def make_run_policy(model_runner, model_metadata, frame_skip):
+def make_run_policy(vision_runner, on_policy_runner, vision_features_slice, frame_skip):
   sample_desire_fn = partial(sample_desire, frame_skip=frame_skip)
   sample_skip_fn = partial(sample_skip, frame_skip=frame_skip)
-  npy_shapes, npy_sizes = get_policy_npy_shapes(model_metadata['input_shapes'])
 
-  def run_policy(img, big_img, feat_q, desire_q, packed_npy_inputs):
-    packed_npy_inputs = packed_npy_inputs.to(Device.DEFAULT).realize()
-    desire, traffic_convention, action_t, prev_feat = (t.reshape(s) for t, s in zip(packed_npy_inputs.split(npy_sizes), npy_shapes.values(), strict=True))
+  def run_policy(img, big_img, feat_q, desire_q, desire, traffic_convention, action_t):
+    desire = desire.to(Device.DEFAULT)
+    traffic_convention = traffic_convention.to(Device.DEFAULT)
+    action_t = action_t.to(Device.DEFAULT)
+    Tensor.realize(desire, traffic_convention, action_t)
     desire_buf = shift_and_sample(desire_q, desire.reshape(1, 1, -1), sample_desire_fn)
-    feat_buf = shift_and_sample(feat_q, prev_feat.reshape(1, 1, -1), sample_skip_fn)
+    vision_out = next(iter(vision_runner({'img': img, 'big_img': big_img}).values())).cast('float32')
+
+    new_feat = vision_out[:, vision_features_slice].reshape(1, -1).unsqueeze(0)
+    feat_buf = shift_and_sample(feat_q, new_feat, sample_skip_fn)
 
     inputs = {
-      'img': img,
-      'big_img': big_img,
       'features_buffer': feat_buf,
       'desire_pulse': desire_buf,
       'traffic_convention': traffic_convention,
       'action_t': action_t,
     }
-    out = next(iter(model_runner(inputs).values())).cast('float32')
-    return out,
+    on_policy_out = next(iter(on_policy_runner(inputs).values())).cast('float32')
+    #off_policy_out = next(iter(off_policy_runner(inputs).values())).cast('float32')
+    return vision_out, on_policy_out
+
   return run_policy
 
 
-def compile_jit(jit, make_random_inputs, input_keys, make_queues):
+def compile_jit(jit, make_random_inputs, input_keys, frame_skip, vision_metadata, policy_metadata):
+  vision_input_shapes = vision_metadata['input_shapes']
+  policy_input_shapes = policy_metadata['input_shapes']
+
   SEED = 42
   def random_inputs_run(fn, seed, test_val=None, test_buffers=None, expect_match=True):
-    input_queues, npy = make_queues(Device.DEFAULT)
+    input_queues, npy = make_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, Device.DEFAULT)
     np.random.seed(seed)
     Tensor.manual_seed(seed)
 
@@ -265,12 +252,12 @@ def _parse_size(s):
 
 def read_file_chunked_to_shm(path):
   from openpilot.common.file_chunker import read_file_chunked
-  from openpilot.common.hardware.hw import Paths
-  with tempfile.NamedTemporaryFile(prefix='compile_modeld_', dir=Paths.shm_path(), delete=False) as f:
+  from openpilot.system.hardware.hw import Paths
+  shm_path = os.path.join(Paths.shm_path(), os.path.basename(path))
+  atexit.register(lambda: os.path.exists(shm_path) and os.remove(shm_path))
+  with open(shm_path, 'wb') as f:
     f.write(read_file_chunked(path))
-    tmp_path = f.name
-  atexit.register(lambda: os.path.exists(tmp_path) and os.remove(tmp_path))
-  return tmp_path
+  return shm_path
 
 
 if __name__ == "__main__":
@@ -281,30 +268,31 @@ if __name__ == "__main__":
   p.add_argument('--model-size', type=_parse_size, required=True, help='model input WxH')
   p.add_argument('--camera-resolutions', type=_parse_size, nargs='+', required=True,
                  help='camera resolutions WxH (one or more)')
-  p.add_argument('--onnx', required=True)
+  p.add_argument('--vision-onnx', required=True)
+  p.add_argument('--on-policy-onnx', required=True)
   p.add_argument('--output', required=True)
   p.add_argument('--frame-skip', type=int, required=True)
   args = p.parse_args()
 
-  model_path = read_file_chunked_to_shm(args.onnx)
+  out = defaultdict(dict)
+  vision_path, on_policy_path = read_file_chunked_to_shm(args.vision_onnx), read_file_chunked_to_shm(args.on_policy_onnx)
   model_w, model_h = args.model_size
 
-  model_runner = OnnxRunner(model_path)
-  out = {'metadata': make_metadata_dict(model_path)}
+  vision_runner = OnnxRunner(vision_path)
+  on_policy_runner = OnnxRunner(on_policy_path)
+  vision_metadata, on_policy_metadata = make_metadata_dict(vision_path), make_metadata_dict(on_policy_path)
 
-  run_policy_jit = TinyJit(make_run_policy(model_runner, out['metadata'], args.frame_skip), prune=True)
+  run_policy_jit = TinyJit(make_run_policy(vision_runner, on_policy_runner, vision_metadata['output_slices']['hidden_state'], args.frame_skip), prune=True)
+  out['metadata']['vision'], out['metadata']['on_policy'] = vision_metadata, on_policy_metadata
 
-  make_policy_queues = partial(make_input_queues, out['metadata']['input_shapes'], args.frame_skip)
-  make_random_model_inputs = partial(make_random_images, keys=['img', 'big_img'], shape=out['metadata']['input_shapes']['img'])
-  out['run_policy'] = compile_jit(run_policy_jit, make_random_model_inputs, POLICY_INPUTS,
-                                  make_policy_queues)
+  make_random_model_inputs = partial(make_random_images, keys=['img', 'big_img'], shape=vision_metadata['input_shapes']['img'])
+  out['run_policy'] = compile_jit(run_policy_jit, make_random_model_inputs, POLICY_INPUTS, args.frame_skip, vision_metadata, on_policy_metadata)
 
   for cam_w, cam_h in args.camera_resolutions:
     nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
     make_random_warp_inputs = partial(make_random_images, keys=['frame', 'big_frame'], shape=nv12.size, device=WARP_DEV)
     warp_enqueue = TinyJit(make_warp(nv12, model_w, model_h, args.frame_skip), prune=True)
-    make_warp_queues = partial(make_warp_input_queues, out['metadata']['input_shapes'], args.frame_skip)
-    out[(cam_w,cam_h)] = compile_jit(warp_enqueue, make_random_warp_inputs, WARP_INPUTS, make_warp_queues)
+    out[(cam_w,cam_h)] = compile_jit(warp_enqueue, make_random_warp_inputs, WARP_INPUTS, args.frame_skip, vision_metadata, on_policy_metadata)
 
   with open(args.output, "wb") as f:
     pickle.dump(out, f)

selfdrive/modeld/fill_model_msg.py

@@ -56,29 +56,26 @@ def fill_lane_line_meta(builder, lane_lines, lane_line_probs):
   builder.rightY = lane_lines[2].y[0]
   builder.rightProb = lane_line_probs[2]
 
-def fill_driving_model_data(msg: capnp._DynamicStructBuilder, modelv2_send: capnp._DynamicStructBuilder) -> None:
-  msg.valid = modelv2_send.valid
-  modelV2 = modelv2_send.modelV2
-  driving_model_data = msg.drivingModelData
-  driving_model_data.frameId = modelV2.frameId
-  driving_model_data.frameIdExtra = modelV2.frameIdExtra
-  driving_model_data.frameDropPerc = modelV2.frameDropPerc
-  driving_model_data.modelExecutionTime = modelV2.modelExecutionTime
-  driving_model_data.action = modelV2.action
-  driving_model_data.meta.laneChangeState = modelV2.meta.laneChangeState
-  driving_model_data.meta.laneChangeDirection = modelV2.meta.laneChangeDirection
-  fill_lane_line_meta(driving_model_data.laneLineMeta, modelV2.laneLines, modelV2.laneLineProbs)
-  fill_xyz_poly(driving_model_data.path, ModelConstants.POLY_PATH_DEGREE, modelV2.position.x, modelV2.position.y, modelV2.position.z)
-
-def fill_model_msg(msg: capnp._DynamicStructBuilder, net_output_data: dict[str, np.ndarray], action: log.ModelDataV2.Action,
+def fill_model_msg(base_msg: capnp._DynamicStructBuilder, extended_msg: capnp._DynamicStructBuilder,
+                   net_output_data: dict[str, np.ndarray], action: log.ModelDataV2.Action,
                    publish_state: PublishState, vipc_frame_id: int, vipc_frame_id_extra: int,
                    frame_id: int, frame_drop: float, timestamp_eof: int, model_execution_time: float,
                    valid: bool) -> None:
   frame_age = frame_id - vipc_frame_id if frame_id > vipc_frame_id else 0
   frame_drop_perc = frame_drop * 100
-  msg.valid = valid
+  extended_msg.valid = valid
+  base_msg.valid = valid
 
-  modelV2 = msg.modelV2
+  driving_model_data = base_msg.drivingModelData
+
+  driving_model_data.frameId = vipc_frame_id
+  driving_model_data.frameIdExtra = vipc_frame_id_extra
+  driving_model_data.frameDropPerc = frame_drop_perc
+  driving_model_data.modelExecutionTime = model_execution_time
+
+  driving_model_data.action = action
+
+  modelV2 = extended_msg.modelV2
   modelV2.frameId = vipc_frame_id
   modelV2.frameIdExtra = vipc_frame_id_extra
   modelV2.frameAge = frame_age
@@ -93,6 +90,9 @@ def fill_model_msg(msg: capnp._DynamicStructBuilder, net_output_data: dict[str,
   fill_xyzt(modelV2.orientation, ModelConstants.T_IDXS, *net_output_data['plan'][0,:,Plan.T_FROM_CURRENT_EULER].T)
   fill_xyzt(modelV2.orientationRate, ModelConstants.T_IDXS, *net_output_data['plan'][0,:,Plan.ORIENTATION_RATE].T)
 
+  # poly path
+  fill_xyz_poly(driving_model_data.path, ModelConstants.POLY_PATH_DEGREE, *net_output_data['plan'][0,:,Plan.POSITION].T)
+
   # action
   modelV2.action = action
 
@@ -107,6 +107,8 @@ def fill_model_msg(msg: capnp._DynamicStructBuilder, net_output_data: dict[str,
   modelV2.laneLineStds = net_output_data['lane_lines_stds'][0,:,0,0].tolist()
   modelV2.laneLineProbs = net_output_data['lane_lines_prob'][0,1::2].tolist()
 
+  fill_lane_line_meta(driving_model_data.laneLineMeta, modelV2.laneLines, modelV2.laneLineProbs)
+
   # road edges
   modelV2.init('roadEdges', 2)
   for i in range(2):

selfdrive/modeld/modeld.py

@@ -21,7 +21,7 @@ from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, smooth_value, get_curvature_from_plan
 from openpilot.selfdrive.modeld.parse_model_outputs import Parser
 from openpilot.selfdrive.modeld.compile_modeld import make_input_queues, WARP_INPUTS, POLICY_INPUTS
-from openpilot.selfdrive.modeld.fill_model_msg import fill_model_msg, fill_driving_model_data, fill_pose_msg, PublishState
+from openpilot.selfdrive.modeld.fill_model_msg import fill_model_msg, fill_pose_msg, PublishState
 from openpilot.common.file_chunker import read_file_chunked, get_manifest_path
 from openpilot.selfdrive.modeld.constants import ModelConstants, Plan
 from openpilot.selfdrive.modeld.helpers import usbgpu_present, modeld_pkl_path, get_tg_input_devices
@@ -84,15 +84,19 @@ class ModelState(ModelStateBase):
     input_devices = get_tg_input_devices(PROCESS_NAME, usbgpu)
     self.WARP_DEV, self.QUEUE_DEV = input_devices['WARP_DEV'], input_devices['QUEUE_DEV']
     jits = pickle.loads(read_file_chunked(modeld_pkl_path(usbgpu)))
-    metadata = jits['metadata']
-    self.input_shapes = metadata['input_shapes']
-    self.vision_input_names = [k for k in self.input_shapes if 'img' in k]
-    self.output_slices = metadata['output_slices']
+    vision_metadata = jits['metadata']['vision']
+    self.vision_input_shapes = vision_metadata['input_shapes']
+    self.vision_input_names = list(self.vision_input_shapes.keys())
+    self.vision_output_slices = vision_metadata['output_slices']
+
+    policy_metadata = jits['metadata']['on_policy']
+    self.policy_input_shapes = policy_metadata['input_shapes']
+    self.policy_output_slices = policy_metadata['output_slices']
 
     self.prev_desire = np.zeros(ModelConstants.DESIRE_LEN, dtype=np.float32)
 
     self.frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
-    self.input_queues, self.npy = make_input_queues(self.input_shapes, self.frame_skip, device=self.QUEUE_DEV)
+    self.input_queues, self.npy = make_input_queues(self.vision_input_shapes, self.policy_input_shapes, self.frame_skip, device=self.QUEUE_DEV)
     self.full_frames: dict[str, Tensor] = {}
     self._blob_cache: dict[int, Tensor] = {}
     self.parser = Parser()
@@ -129,16 +133,19 @@ class ModelState(ModelStateBase):
     if prepare_only:
       return None
 
-    outs, = self.run_policy(
-      **{k: self.input_queues[k] for k in POLICY_INPUTS if k in self.input_queues}, img=img, big_img=big_img
+    vision_output, on_policy_output = self.run_policy(
+      **{k: self.input_queues[k] for k in POLICY_INPUTS}, img=img, big_img=big_img
     )
-    model_output = outs.numpy()[0]
-    outputs_dict = self.parser.parse_outputs(self.slice_outputs(model_output, self.output_slices))
-    self.npy['prev_feat'][:] = model_output[self.output_slices['hidden_state']]
+
+    vision_output = vision_output.numpy().flatten()
+    on_policy_output = on_policy_output.numpy().flatten()
+    vision_outputs_dict = self.parser.parse_vision_outputs(self.slice_outputs(vision_output, self.vision_output_slices))
+    policy_outputs_dict = self.parser.parse_policy_outputs(self.slice_outputs(on_policy_output, self.policy_output_slices))
+    combined_outputs_dict = {**vision_outputs_dict, **policy_outputs_dict}
 
     if SEND_RAW_PRED:
-      outputs_dict['raw_pred'] = model_output.copy()
-    return outputs_dict
+      combined_outputs_dict['raw_pred'] = np.concatenate([vision_output.copy(), on_policy_output.copy()])
+    return combined_outputs_dict
 
 
 def main(demo=False):
@@ -151,7 +158,10 @@ def main(demo=False):
   params.put_bool("UsbGpuPresent", _present)
   params.put_bool("UsbGpuCompiled", _compiled)
 
-  config_realtime_process(7, 54)
+  if not USBGPU:
+    # USB GPU currently saturates a core so can't do this yet,
+    # also need to move the aux USB interrupts for good timings
+    config_realtime_process(7, 54)
 
   # visionipc clients
   while True:
@@ -307,7 +317,7 @@ def main(demo=False):
 
       action = get_action_from_model(model_output, prev_action, lat_action_t, long_action_t, v_ego)
       prev_action = action
-      fill_model_msg(modelv2_send, model_output, action,
+      fill_model_msg(drivingdata_send, modelv2_send, model_output, action,
                      publish_state, meta_main.frame_id, meta_extra.frame_id, frame_id,
                      frame_drop_ratio, meta_main.timestamp_eof, model_execution_time, live_calib_seen)
 
@@ -319,8 +329,9 @@ def main(demo=False):
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction
+      drivingdata_send.drivingModelData.meta.laneChangeState = DH.lane_change_state
+      drivingdata_send.drivingModelData.meta.laneChangeDirection = DH.lane_change_direction
 
-      fill_driving_model_data(drivingdata_send, modelv2_send)
       fill_pose_msg(posenet_send, model_output, meta_main.frame_id, vipc_dropped_frames, meta_main.timestamp_eof, live_calib_seen)
       pm.send('modelV2', modelv2_send)
       pm.send('drivingModelData', drivingdata_send)

selfdrive/modeld/models/big_driving_on_policy.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:565e53c38dcd64c50dd3fe4d5ee1530213aeefd66c3f6b67ea6a72a32612a6bf
+size 14061419

selfdrive/modeld/models/big_driving_supercombo.onnx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:471f372751d5931e939320c211e35b7255f8fa8015125b3b3fd48ef43020257e
-size 195490097

selfdrive/modeld/models/big_driving_vision.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f0cab5033fe9e3bc5e174a2e790fa277f7d9fc44c65822d734064d2f899a9a0
+size 296203378

selfdrive/modeld/models/driving_on_policy.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78477124cbf3ffe30fa951ebada8410b43c4242c6054584d656f1d329b067e15
+size 14060847

selfdrive/modeld/models/driving_supercombo.onnx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:659727c4d4839adc4992a254409a54259a8756a743f2d567bf5fdc6579f8009b
-size 60881999

selfdrive/modeld/models/driving_vision.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee29ee5bce84d1ce23e9ff381280de9b4e4d96d2934cd751740354884e112c66
+size 46877473

selfdrive/pandad/main.cc

@@ -3,7 +3,7 @@
 #include "selfdrive/pandad/pandad.h"
 #include "common/swaglog.h"
 #include "common/util.h"
-#include "common/hardware/hw.h"
+#include "system/hardware/hw.h"
 
 int main(int argc, char *argv[]) {
   LOGW("starting pandad");