sunnypilot v2026.002.000

version: sunnypilot v2026.002.000 (staging)
date: 2026-07-21T07:44:02
master commit: 2c334ede443d7391d27575af8c854a095ba702a8
This commit is contained in:
github-actions[bot] committed 2026-07-21 07:44:02 +00:00
commit de77c89cf6
3995 files changed
+1260688

No files matched your search

@@ -0,0 +1,81 @@
"""
Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
This file is part of sunnypilot and is licensed under the MIT License.
See the LICENSE.md file in the root directory for more details.
"""
from collections.abc import Callable
import pyray as rl
from openpilot.selfdrive.ui.ui_state import ui_state
from openpilot.system.ui.lib.multilang import tr
from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp, option_item_sp, LineSeparatorSP
from openpilot.system.ui.widgets.network import NavButton
from openpilot.system.ui.widgets.scroller_tici import Scroller
from openpilot.system.ui.widgets import Widget
from openpilot.sunnypilot.selfdrive.controls.lib.auto_lane_change import AutoLaneChangeMode
class LaneChangeSettingsLayout(Widget):
def __init__(self, back_btn_callback: Callable):
super().__init__()
self._back_button = NavButton(tr("Back"))
self._back_button.set_click_callback(back_btn_callback)
items = self._initialize_items()
self._scroller = Scroller(items, line_separator=False, spacing=0)
def _initialize_items(self):
self._lane_change_timer = option_item_sp(
title=lambda: tr("Auto Lane Change by Blinker"),
param="AutoLaneChangeTimer",
description=lambda: tr("Set a timer to delay the auto lane change operation when the blinker is used. " +
"No nudge on the steering wheel is required to auto lane change if a timer is set. Default is Nudge.<br>" +
"Please use caution when using this feature. Only use the blinker when traffic and road conditions permit."),
min_value=-1,
max_value=5,
value_change_step=1,
label_callback=(lambda x:
tr("Off") if x == -1 else
tr("Nudge") if x == 0 else
tr("Nudgeless") if x == 1 else
f"0.5 {tr('s')}" if x == 2 else
f"1 {tr('s')}" if x == 3 else
f"2 {tr('s')}" if x == 4 else
f"3 {tr('s')}")
)
self._bsm_delay = toggle_item_sp(
param="AutoLaneChangeBsmDelay",
title=lambda: tr("Auto Lane Change: Delay with Blind Spot"),
description=lambda: tr("Toggle to enable a delay timer for seamless lane changes when blind spot monitoring " +
"(BSM) detects a obstructing vehicle, ensuring safe maneuvering."),
)
items = [
self._lane_change_timer,
LineSeparatorSP(40),
self._bsm_delay,
]
return items
def _update_state(self):
super()._update_state()
self._update_toggles()
def _render(self, rect):
self._back_button.set_position(self._rect.x, self._rect.y + 20)
self._back_button.render()
# subtract button
content_rect = rl.Rectangle(rect.x, rect.y + self._back_button.rect.height + 40, rect.width, rect.height - self._back_button.rect.height - 40)
self._scroller.render(content_rect)
def show_event(self):
self._scroller.show_event()
def _update_toggles(self):
enable_bsm = ui_state.CP is not None and ui_state.CP.enableBsm
if not enable_bsm and ui_state.params.get_bool("AutoLaneChangeBsmDelay"):
ui_state.params.remove("AutoLaneChangeBsmDelay")
self._bsm_delay.action_item.set_enabled(enable_bsm and ui_state.params.get("AutoLaneChangeTimer", return_default=True) > AutoLaneChangeMode.NUDGE)
@@ -0,0 +1,137 @@
"""
Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
This file is part of sunnypilot and is licensed under the MIT License.
See the LICENSE.md file in the root directory for more details.
"""
from collections.abc import Callable
import pyray as rl
from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP
from openpilot.selfdrive.ui.ui_state import ui_state
from openpilot.sunnypilot.mads.helpers import MadsSteeringModeOnBrake
from openpilot.system.ui.lib.multilang import tr, tr_noop
from openpilot.system.ui.widgets import Widget
from openpilot.system.ui.widgets.network import NavButton
from openpilot.system.ui.widgets.scroller_tici import Scroller
from openpilot.system.ui.sunnypilot.widgets.list_view import multiple_button_item_sp, toggle_item_sp
MADS_STEERING_MODE_OPTIONS = [
(tr("Remain Active"), tr_noop("Remain Active: ALC will remain active when the brake pedal is pressed.")),
(tr("Pause"), tr_noop("Pause: ALC will pause when the brake pedal is pressed.")),
(tr("Disengage"), tr_noop("Disengage: ALC will disengage when the brake pedal is pressed.")),
]
MADS_MAIN_CRUISE_BASE_DESC = tr("Note: For vehicles without LFA/LKAS button, disabling this will prevent lateral control engagement.")
MADS_UNIFIED_ENGAGEMENT_MODE_BASE_DESC = "{engage}<br><h4>{note}</h4>".format(
engage=tr("Engage lateral and longitudinal control with cruise control engagement."),
note=tr("Note: Once lateral control is engaged via UEM, it will remain engaged until it is manually disabled via the MADS button or car shut off."),
)
STATUS_CHECK_COMPATIBILITY = tr("Start the vehicle to check vehicle compatibility.")
DEFAULT_TO_OFF = tr("This feature defaults to OFF, and does not allow selection due to vehicle limitations.")
DEFAULT_TO_ON = tr("This feature defaults to ON, and does not allow selection due to vehicle limitations.")
STATUS_DISENGAGE_ONLY = tr("This platform only supports Disengage mode due to vehicle limitations.")
class MadsSettingsLayout(Widget):
def __init__(self, back_btn_callback: Callable):
super().__init__()
self._back_button = NavButton(tr("Back"))
self._back_button.set_click_callback(back_btn_callback)
self._initialize_items()
self._scroller = Scroller(self.items, line_separator=True, spacing=0)
def _initialize_items(self):
self._main_cruise_toggle = toggle_item_sp(
title=lambda: tr("Toggle with Main Cruise"),
description=MADS_MAIN_CRUISE_BASE_DESC,
param="MadsMainCruiseAllowed",
)
self._unified_engagement_toggle = toggle_item_sp(
title=lambda: tr("Unified Engagement Mode (UEM)"),
description=MADS_UNIFIED_ENGAGEMENT_MODE_BASE_DESC,
param="MadsUnifiedEngagementMode"
)
self._steering_mode = multiple_button_item_sp(
param="MadsSteeringMode",
title=lambda: tr("Steering Mode on Brake Pedal"),
description="",
buttons=[opt[0] for opt in MADS_STEERING_MODE_OPTIONS],
inline=False,
button_width=350,
callback=self._update_steering_mode_description,
)
self.items = [
self._main_cruise_toggle,
self._unified_engagement_toggle,
self._steering_mode,
]
def _update_state(self):
super()._update_state()
self._update_toggles()
def _render(self, rect):
self._back_button.set_position(self._rect.x, self._rect.y + 20)
self._back_button.render()
# subtract button
content_rect = rl.Rectangle(rect.x, rect.y + self._back_button.rect.height + 40, rect.width, rect.height - self._back_button.rect.height - 40)
self._scroller.render(content_rect)
def show_event(self):
self._scroller.show_event()
@staticmethod
def _mads_limited_settings() -> bool:
brand = ""
if ui_state.is_offroad():
bundle = ui_state.params.get("CarPlatformBundle")
if bundle:
brand = bundle.get("brand", "")
if not brand:
brand = ui_state.CP.brand if ui_state.CP is not None else ""
if brand == "rivian":
return True
elif brand == "tesla":
return not (ui_state.CP_SP is not None and ui_state.CP_SP.flags & TeslaFlagsSP.HAS_VEHICLE_BUS)
return False
def _update_steering_mode_description(self, button_index: int):
base_desc = tr("Choose how Automatic Lane Centering (ALC) behaves after the brake pedal is manually pressed in sunnypilot.")
result = base_desc + "<br><br>"
for opt in MADS_STEERING_MODE_OPTIONS:
desc = "<b>" + opt[1] + "</b>" if button_index == MADS_STEERING_MODE_OPTIONS.index(opt) else opt[1]
result += desc + "<br>"
self._steering_mode.set_description(result)
self._steering_mode.show_description(True)
def _update_toggles(self):
self._update_steering_mode_description(self._steering_mode.action_item.get_selected_button())
if self._mads_limited_settings():
ui_state.params.remove("MadsMainCruiseAllowed")
ui_state.params.put_bool("MadsUnifiedEngagementMode", True)
ui_state.params.put("MadsSteeringMode", MadsSteeringModeOnBrake.DISENGAGE)
self._main_cruise_toggle.action_item.set_enabled(False)
self._main_cruise_toggle.action_item.set_state(False)
self._main_cruise_toggle.set_description("<b>" + DEFAULT_TO_OFF + "</b><br>" + MADS_MAIN_CRUISE_BASE_DESC)
self._unified_engagement_toggle.action_item.set_enabled(False)
self._unified_engagement_toggle.action_item.set_state(True)
self._unified_engagement_toggle.set_description("<b>" + DEFAULT_TO_ON + "</b><br>" + MADS_UNIFIED_ENGAGEMENT_MODE_BASE_DESC)
self._steering_mode.set_description(STATUS_DISENGAGE_ONLY)
self._steering_mode.action_item.set_selected_button(MadsSteeringModeOnBrake.DISENGAGE)
self._steering_mode.action_item.set_enabled_buttons({MadsSteeringModeOnBrake.DISENGAGE})
else:
self._main_cruise_toggle.action_item.set_enabled(True)
self._main_cruise_toggle.set_description(MADS_MAIN_CRUISE_BASE_DESC)
self._unified_engagement_toggle.action_item.set_enabled(True)
self._unified_engagement_toggle.set_description(MADS_UNIFIED_ENGAGEMENT_MODE_BASE_DESC)
self._steering_mode.action_item.set_enabled(True)
self._steering_mode.action_item.set_enabled_buttons(None)
@@ -0,0 +1,191 @@
"""
Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
This file is part of sunnypilot and is licensed under the MIT License.
See the LICENSE.md file in the root directory for more details.
"""
import json
import math
import os
from collections.abc import Callable
import pyray as rl
from openpilot.common.basedir import BASEDIR
from openpilot.selfdrive.ui.ui_state import ui_state
from openpilot.system.ui.lib.application import gui_app, FontWeight
from openpilot.system.ui.lib.multilang import tr
from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction
from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP, toggle_item_sp, option_item_sp
from openpilot.system.ui.sunnypilot.widgets.tree_dialog import TreeOptionDialog, TreeFolder, TreeNode
from openpilot.system.ui.widgets import Widget, DialogResult
from openpilot.system.ui.widgets.network import NavButton
from openpilot.system.ui.widgets.scroller_tici import Scroller
TORQUE_VERSIONS_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "selfdrive", "controls", "lib", "latcontrol_torque_versions.json")
class TorqueSettingsLayout(Widget):
def __init__(self, back_btn_callback: Callable):
super().__init__()
self._back_button = NavButton(tr("Back"))
self._back_button.set_click_callback(back_btn_callback)
self._torque_version_dialog: TreeOptionDialog | None = None
self.cached_torque_versions = {}
self._load_versions()
items = self._initialize_items()
self._scroller = Scroller(items, line_separator=True, spacing=0)
def _load_versions(self):
with open(TORQUE_VERSIONS_PATH) as f:
self.cached_torque_versions = json.load(f)
def _initialize_items(self):
self._torque_control_versions = ListItemSP(
title=tr("Torque Control Tune Version"),
description="Select the version of Torque Control Tune to use.",
action_item=NoElideButtonAction(tr("SELECT")),
callback=self._show_torque_version_dialog,
)
self._self_tune_toggle = toggle_item_sp(
param="LiveTorqueParamsToggle",
title=lambda: tr("Self-Tune"),
description=lambda: tr("Enables self-tune for Torque lateral control for platforms that do not use " +
"Torque lateral control by default."),
)
self._relaxed_tune_toggle = toggle_item_sp(
param="LiveTorqueParamsRelaxedToggle",
title=lambda: tr("Less Restrict Settings for Self-Tune (Beta)"),
description=lambda: tr("Less strict settings when using Self-Tune. This allows torqued to be more " +
"forgiving when learning values."),
)
self._custom_tune_toggle = toggle_item_sp(
param="CustomTorqueParams",
title=lambda: tr("Enable Custom Tuning"),
description=lambda: tr("Enables custom tuning for Torque lateral control. " +
"Modifying Lateral Acceleration Factor and Friction below will override the offline values " +
"indicated in the YAML files within \"opendbc/car/torque_data\". " +
"The values will also be used live when \"Manual Real-Time Tuning\" toggle is enabled."),
)
self._torque_prams_override_toggle = toggle_item_sp(
param="TorqueParamsOverrideEnabled",
title=lambda: tr("Manual Real-Time Tuning"),
description=lambda: tr("Enforces the torque lateral controller to use the fixed values instead of the learned " +
"values from Self-Tune. Enabling this toggle overrides Self-Tune values."),
)
self._torque_lat_accel_factor = option_item_sp(
title=lambda: tr("Lateral Acceleration Factor"),
param="TorqueParamsOverrideLatAccelFactor",
description="",
min_value=1,
max_value=500,
value_change_step=1,
label_callback=(lambda x: f"{x/100} m/s^2"),
use_float_scaling=True
)
self._torque_friction = option_item_sp(
title=lambda: tr("Friction"),
param="TorqueParamsOverrideFriction",
description="",
min_value=1,
max_value=100,
value_change_step=1,
label_callback=(lambda x: f"{x/100}"),
use_float_scaling=True
)
items = [
self._torque_control_versions,
self._self_tune_toggle,
self._relaxed_tune_toggle,
self._custom_tune_toggle,
self._torque_prams_override_toggle,
self._torque_lat_accel_factor,
self._torque_friction,
]
return items
def _update_state(self):
super()._update_state()
if not ui_state.params.get_bool("LiveTorqueParamsToggle"):
ui_state.params.remove("LiveTorqueParamsRelaxedToggle")
self._relaxed_tune_toggle.action_item.set_state(False)
self._self_tune_toggle.action_item.set_enabled(ui_state.is_offroad())
self._relaxed_tune_toggle.action_item.set_enabled(ui_state.is_offroad() and self._self_tune_toggle.action_item.get_state())
self._custom_tune_toggle.action_item.set_enabled(ui_state.is_offroad())
custom_tune_enabled = self._custom_tune_toggle.action_item.get_state()
self._torque_prams_override_toggle.set_visible(custom_tune_enabled)
self._torque_lat_accel_factor.set_visible(custom_tune_enabled)
self._torque_friction.set_visible(custom_tune_enabled)
self._torque_prams_override_toggle.action_item.set_enabled(ui_state.is_offroad())
sliders_enabled = self._torque_prams_override_toggle.action_item.get_state() or ui_state.is_offroad()
self._torque_lat_accel_factor.action_item.set_enabled(sliders_enabled)
self._torque_friction.action_item.set_enabled(sliders_enabled)
title_text = tr("Real-Time & Offline") if ui_state.params.get("TorqueParamsOverrideEnabled") else tr("Offline Only")
self._torque_lat_accel_factor.set_title(lambda: tr("Lateral Acceleration Factor") + " (" + title_text + ")")
self._torque_friction.set_title(lambda: tr("Friction") + " (" + title_text + ")")
self._torque_control_versions.action_item.set_value(self._get_current_torque_version_label())
def _render(self, rect):
self._back_button.set_position(self._rect.x, self._rect.y + 20)
self._back_button.render()
# subtract button
content_rect = rl.Rectangle(rect.x, rect.y + self._back_button.rect.height + 40, rect.width, rect.height - self._back_button.rect.height - 40)
self._scroller.render(content_rect)
def show_event(self):
self._scroller.show_event()
def _get_current_torque_version_label(self):
current_val_bytes = ui_state.params.get("TorqueControlTune")
if current_val_bytes is None:
return tr("Default")
try:
current_val = float(current_val_bytes)
for label, info in self.cached_torque_versions.items():
if math.isclose(float(info["version"]), current_val, rel_tol=1e-5):
return label
except (ValueError, KeyError):
pass
return tr("Default")
def _show_torque_version_dialog(self):
options_map = {}
for label, info in self.cached_torque_versions.items():
try:
options_map[label] = float(info["version"])
except (ValueError, KeyError):
pass
# Sort options by label in descending order
sorted_labels = sorted(options_map.keys(), key=lambda k: options_map[k], reverse=True)
nodes = [TreeNode(tr("Default"))]
for label in sorted_labels:
nodes.append(TreeNode(label))
folders = [TreeFolder("", nodes)]
current_label = self._get_current_torque_version_label()
def handle_selection(result: int):
if result == DialogResult.CONFIRM and self._torque_version_dialog:
selected_ref = self._torque_version_dialog.selection_ref
if selected_ref == tr("Default"):
ui_state.params.remove("TorqueControlTune")
elif selected_ref in options_map:
ui_state.params.put("TorqueControlTune", options_map[selected_ref])
self._torque_version_dialog = None
self._torque_version_dialog = TreeOptionDialog(
tr("Select Torque Control Tune Version"),
folders,
current_ref=current_label,
option_font_weight=FontWeight.UNIFONT,
on_exit=handle_selection,
)
gui_app.push_widget(self._torque_version_dialog)