diff --git a/selfdrive/car/tests/test_cruise_speed.py b/selfdrive/car/tests/test_cruise_speed.py index bdf21fecfe..69b0048236 100644 --- a/selfdrive/car/tests/test_cruise_speed.py +++ b/selfdrive/car/tests/test_cruise_speed.py @@ -118,14 +118,17 @@ class TestVCruiseHelper: ) assert pressed == (self.v_cruise_helper.v_cruise_kph == self.v_cruise_helper.v_cruise_kph_last) - def test_accel_stops_at_slc_target_before_crossing_it(self): + @pytest.mark.parametrize( + ("starting_kph", "waypoint_kph", "expected_speeds"), + [(30, 33, (33, 35, 40)), (65, 68, (68, 70, 75))], + ) + def test_accel_stops_at_slc_target_before_crossing_it(self, starting_kph, waypoint_kph, expected_speeds): self.starpilot_toggles.cruise_increase = 5 - self.v_cruise_helper.v_cruise_kph = 30 - self.v_cruise_helper.v_cruise_cluster_kph = 30 - slc_target_with_offset = 33 * CV.KPH_TO_MS + self.v_cruise_helper.v_cruise_kph = starting_kph + self.v_cruise_helper.v_cruise_cluster_kph = starting_kph + slc_target_with_offset = waypoint_kph * CV.KPH_TO_MS - # A 30 km/h limit with a +3 km/h SLC offset should be an intermediate stop. - for expected_kph in (33, 35, 40): + for expected_kph in expected_speeds: for pressed in (True, False): CS = car.CarState(cruiseState={"available": True}) CS.buttonEvents = [ButtonEvent(type=ButtonType.accelCruise, pressed=pressed)] diff --git a/selfdrive/controls/tests/test_speed_limit_controller.py b/selfdrive/controls/tests/test_speed_limit_controller.py index 319f3e8224..2e3d4f5fcc 100644 --- a/selfdrive/controls/tests/test_speed_limit_controller.py +++ b/selfdrive/controls/tests/test_speed_limit_controller.py @@ -1,16 +1,26 @@ -from datetime import UTC, datetime, timezone +from datetime import UTC, datetime +from concurrent.futures import Future from types import SimpleNamespace import pytest +from cereal import custom from openpilot.common.constants import CV from openpilot.common.realtime import DT_MDL -from openpilot.starpilot.controls.lib.speed_limit_controller import SpeedLimitController +from openpilot.starpilot.controls.lib.speed_limit_controller import ( + SOURCE_DASHBOARD, SOURCE_MAP, SOURCE_MAPBOX, SOURCE_NONE, SOURCE_VISION, SpeedLimitController, +) +from openpilot.starpilot.controls.lib.mapbox_speed_limit import MapboxSpeedLimit + + +def mph(speed): + return speed * CV.MPH_TO_MS class FakeParams: - def __init__(self, initial=None): - self.values = dict(initial or {}) + def __init__(self, values=None): + self.values = dict(values or {}) + self.writes = [] def get(self, key, encoding=None): return self.values.get(key) @@ -27,11 +37,9 @@ class FakeParams: def put_float(self, key, value): self.values[key] = value - def put_int(self, key, value): - self.values[key] = value - def put_nonblocking(self, key, value): self.values[key] = value + self.writes.append((key, value)) def remove(self, key): self.values.pop(key, None) @@ -42,1038 +50,601 @@ def make_toggles(**overrides): "is_metric": False, "map_speed_lookahead_higher": 0.0, "map_speed_lookahead_lower": 0.0, + "slc_fallback_experimental_mode": False, "slc_fallback_previous_speed_limit": False, "slc_fallback_set_speed": False, "slc_mapbox_filler": False, "speed_limit_confirmation_higher": False, "speed_limit_confirmation_lower": False, "redneck_cruise": False, - "speed_limit_filler": False, - "speed_limit_offset1": 0.0, - "speed_limit_offset2": 0.0, - "speed_limit_offset3": 0.0, - "speed_limit_offset4": 0.0, - "speed_limit_offset5": 0.0, - "speed_limit_offset6": 0.0, - "speed_limit_offset7": 0.0, - "speed_limit_priority1": "Dashboard", - "speed_limit_priority2": "Map Data", + "speed_limit_priority1": SOURCE_DASHBOARD, + "speed_limit_priority2": SOURCE_MAP, "speed_limit_priority_highest": False, "speed_limit_priority_lowest": False, "vision_speed_limit_detection": False, "vision_speed_limit_low_limit_filter": False, "vision_speed_limit_low_limit_threshold": mph(25), } + defaults.update({f"speed_limit_offset{i}": 0.0 for i in range(1, 8)}) defaults.update(overrides) return SimpleNamespace(**defaults) -def make_sm(*, gas_pressed, enabled=True, accel_pressed=False, decel_pressed=False, long_active=True, standstill=False, v_cruise_kph=255.0): - return { +@pytest.fixture +def controller_factory(): + controllers = [] + + def create(*, persisted=0.0, **toggles): + params = FakeParams({"PreviousSpeedLimit": persisted} if persisted else {}) + planner = SimpleNamespace( + gps_position={}, gps_valid=False, params=params, params_memory=FakeParams(), + ) + controller = SpeedLimitController(SimpleNamespace(starpilot_planner=planner)) + controller.starpilot_toggles = make_toggles(**toggles) + controllers.append(controller) + return controller + + yield create + for controller in controllers: + controller.shutdown() + + +def step(controller, *, dashboard=0.0, map_limit=0.0, way=custom.WaySelectionType.fail, + next_limit=0.0, next_distance=0.0, road="", cruise=None, ego=None, + enabled=True, long_active=True, accel=False, decel=False, gas=False, + standstill=False, active=True, display_only=False, vision=None, support_count=0, + support_speed=0.0, cruise_diff=0.0, ego_diff=0.0): + cruise = mph(60) if cruise is None else cruise + ego = mph(50) if ego is None else ego + memory = controller.starpilot_planner.params_memory + if vision is not None: + memory.put_float("VisionSpeedLimit", vision) + memory.values["VisionSpeedLimitSupportCount"] = support_count + memory.put_float("VisionSpeedLimitSupportSpeed", support_speed) + sm = { "carControl": SimpleNamespace(longActive=long_active), - "carState": SimpleNamespace(gasPressed=gas_pressed, steeringAngleDeg=0.0, standstill=standstill, vCruise=v_cruise_kph), + "carState": SimpleNamespace(gasPressed=gas, steeringAngleDeg=0.0, standstill=standstill, + vCruise=cruise / CV.KPH_TO_MS), "liveParameters": SimpleNamespace(angleOffsetDeg=0.0), - "mapdOut": SimpleNamespace(nextSpeedLimitDistance=0.0, nextSpeedLimit=0.0, speedLimit=0.0, waySelectionType=0, roadName=""), + "mapdOut": SimpleNamespace(nextSpeedLimitDistance=next_distance, nextSpeedLimit=next_limit, + speedLimit=map_limit, waySelectionType=way, roadName=road), "selfdriveState": SimpleNamespace(enabled=enabled), - "starpilotCarState": SimpleNamespace(accelPressed=accel_pressed, decelPressed=decel_pressed), + "starpilotCarState": SimpleNamespace(accelPressed=accel, decelPressed=decel), } + controller.update(dashboard, datetime.now(UTC), False, cruise, cruise_diff, ego, ego_diff, sm, + active=active, display_only=display_only) + return sm -def make_controller(**toggle_overrides): - params = FakeParams() - planner = SimpleNamespace( - gps_position={}, - gps_valid=False, - params=params, - params_memory=FakeParams(), - ) - controller = SpeedLimitController(SimpleNamespace(starpilot_planner=planner)) - controller.starpilot_toggles = make_toggles(**toggle_overrides) - return controller - - -def mph(value): - return value * CV.MPH_TO_MS - - -def update_dashboard_limit(controller, now, current_limit, desired_limit, *, accel_pressed=False, decel_pressed=False): - controller.update_limits( - mph(desired_limit), now, False, mph(current_limit), mph(current_limit), - make_sm(gas_pressed=False, accel_pressed=accel_pressed, decel_pressed=decel_pressed), - ) - - -def make_pending_limit(current_limit, desired_limit, confirmation_toggle): - controller = make_controller( - speed_limit_priority1="Dashboard", - **{confirmation_toggle: True}, - ) - controller.source = "Dashboard" - controller.target = mph(current_limit) - controller.previous_source = "Dashboard" - controller.previous_target = mph(current_limit) - controller.last_valid_limit = mph(current_limit) - - now = datetime.now(timezone.utc) - update_dashboard_limit(controller, now, current_limit, desired_limit) - assert controller.unconfirmed_speed_limit == pytest.approx(mph(desired_limit)) - return controller, now - - -def make_pending_lower_limit(current_limit, desired_limit): - return make_pending_limit(current_limit, desired_limit, "speed_limit_confirmation_lower") - - -@pytest.mark.parametrize("limit_mph", [15, 25]) -def test_low_vision_limit_filter_blocks_configured_boundary(limit_mph): - controller = make_controller( - speed_limit_priority1="Vision", +@pytest.mark.parametrize( + ("priority1", "priority2", "highest", "lowest", "expected_source", "expected_speed"), + [ + (SOURCE_DASHBOARD, SOURCE_MAP, False, False, SOURCE_DASHBOARD, 45), + (SOURCE_MAP, SOURCE_DASHBOARD, False, False, SOURCE_MAP, 55), + (SOURCE_DASHBOARD, SOURCE_MAP, True, False, SOURCE_MAP, 55), + (SOURCE_DASHBOARD, SOURCE_MAP, False, True, SOURCE_DASHBOARD, 45), + (SOURCE_VISION, SOURCE_DASHBOARD, False, False, SOURCE_VISION, 65), + ], +) +def test_source_selection(controller_factory, priority1, priority2, highest, lowest, expected_source, expected_speed): + controller = controller_factory( + speed_limit_priority1=priority1, speed_limit_priority2=priority2, + speed_limit_priority_highest=highest, speed_limit_priority_lowest=lowest, vision_speed_limit_detection=True, + ) + step(controller, dashboard=mph(45), map_limit=mph(55), way=custom.WaySelectionType.current, + vision=mph(65), cruise=mph(65)) + assert controller.source == expected_source + assert controller.target == pytest.approx(mph(expected_speed)) + + +def test_vision_only_participates_when_configured(controller_factory): + controller = controller_factory(vision_speed_limit_detection=True) + step(controller, vision=mph(45), cruise=mph(45)) + assert controller.source == SOURCE_NONE + controller.starpilot_toggles.speed_limit_priority2 = SOURCE_VISION + step(controller, vision=mph(45), cruise=mph(45)) + assert controller.source == SOURCE_VISION + + +def test_vision_filter_and_large_discrepancy_support(controller_factory): + controller = controller_factory( + speed_limit_priority1=SOURCE_VISION, vision_speed_limit_detection=True, vision_speed_limit_low_limit_filter=True, - vision_speed_limit_low_limit_threshold=mph(25), ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(limit_mph)) - sm = make_sm(gas_pressed=False, v_cruise_kph=25 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(25), mph(20), sm) - - assert controller.vision_limit == pytest.approx(mph(limit_mph)) - assert controller.target == 0 - assert controller.source == "None" - finally: - controller.shutdown() + step(controller, vision=mph(25), cruise=mph(25)) + assert controller.vision_limit == pytest.approx(mph(25)) + assert controller.source == SOURCE_NONE + step(controller, vision=mph(70), cruise=mph(30), ego=mph(30), support_count=2, support_speed=mph(70)) + assert controller.source == SOURCE_NONE + step(controller, vision=mph(70), cruise=mph(30), ego=mph(30), support_count=3, support_speed=mph(70)) + assert controller.source == SOURCE_VISION -def test_low_vision_limit_filter_allows_limit_above_threshold(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, +def test_display_only_keeps_raw_vision_but_clears_control_state(controller_factory): + controller = controller_factory( + speed_limit_priority1=SOURCE_VISION, vision_speed_limit_detection=True, vision_speed_limit_low_limit_filter=True, - vision_speed_limit_low_limit_threshold=mph(25), ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(30)) - sm = make_sm(gas_pressed=False, v_cruise_kph=30 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(30), mph(25), sm) - - assert controller.target == pytest.approx(mph(30)) - assert controller.source == "Vision" - finally: - controller.shutdown() + step(controller, vision=mph(15), cruise=mph(15), active=False, display_only=True) + assert controller.source == SOURCE_VISION + assert controller.target == pytest.approx(mph(15)) + assert controller.last_valid_limit == 0 + assert not controller.confirmation_pending + assert controller.overridden_speed == 0 -def test_low_vision_limit_filter_is_action_only_for_display(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - vision_speed_limit_low_limit_filter=True, - vision_speed_limit_low_limit_threshold=mph(25), +def test_map_lookahead_and_explicit_failure(controller_factory): + controller = controller_factory(map_speed_lookahead_lower=5.0) + step(controller, map_limit=mph(55), next_limit=mph(45), next_distance=100, + way=custom.WaySelectionType.current, ego=mph(50)) + assert controller.map_speed_limit == pytest.approx(mph(45)) + assert controller.next_speed_limit == pytest.approx(mph(45)) + assert controller.last_valid_limit == pytest.approx(mph(45)) + step(controller, way=custom.WaySelectionType.fail) + assert controller.map_speed_limit == 0 + assert controller.next_speed_limit == 0 + assert controller.source == SOURCE_NONE + assert controller.last_valid_limit == pytest.approx(mph(45)) + + +def test_predicted_map_retains_only_lower_candidate(controller_factory): + controller = controller_factory() + step(controller, map_limit=mph(55), way=custom.WaySelectionType.current) + step(controller, map_limit=mph(65), way=custom.WaySelectionType.predicted) + assert controller.map_speed_limit == pytest.approx(mph(55)) + step(controller, map_limit=mph(45), way=custom.WaySelectionType.possible) + assert controller.map_speed_limit == pytest.approx(mph(45)) + + +def test_mapbox_fills_absence_and_resets_for_primary_source(controller_factory): + controller = controller_factory(slc_mapbox_filler=True) + controller.starpilot_planner.gps_valid = True + controller.mapbox.token = "test" + step(controller, ego=0) + controller.mapbox.limit = mph(45) + controller.mapbox.segment_distance = 1000 + step(controller) + assert controller.source == SOURCE_MAPBOX + assert controller.last_valid_source == SOURCE_MAPBOX + step(controller, dashboard=mph(55)) + assert controller.source == SOURCE_DASHBOARD + assert controller.mapbox.limit == 0 + + +def test_real_source_invalidates_inflight_mapbox_result(controller_factory): + controller = controller_factory(slc_mapbox_filler=True) + controller.starpilot_planner.gps_valid = True + controller.mapbox.token = "test" + old = Future() + old.set_running_or_notify_cancel() + controller.mapbox.future = old + step(controller, dashboard=mph(45)) + assert controller.mapbox.future is None + old.set_result((mph(65), 100.0)) + step(controller, dashboard=mph(45)) + assert controller.mapbox.limit == 0 + assert controller.source == SOURCE_DASHBOARD + + +@pytest.mark.parametrize("first_display_only", [False, True]) +def test_mode_transition_invalidates_inflight_mapbox_result(controller_factory, first_display_only): + controller = controller_factory(slc_mapbox_filler=True) + controller.starpilot_planner.gps_valid = True + controller.mapbox.token = "test" + step(controller, ego=0, active=not first_display_only, display_only=first_display_only) + old = Future() + old.set_running_or_notify_cancel() + controller.mapbox.future = old + + step(controller, ego=0, active=first_display_only, display_only=not first_display_only) + assert controller.mapbox.future is None + old.set_result((mph(65), 100.0)) + step(controller, ego=0, active=first_display_only, display_only=not first_display_only) + assert controller.mapbox.limit == 0 + assert controller.source == SOURCE_NONE + + +def test_previous_fallback_keeps_real_history_and_session_source(controller_factory): + controller = controller_factory(slc_fallback_previous_speed_limit=True) + step(controller, dashboard=mph(45)) + writes = list(controller.starpilot_planner.params.writes) + step(controller) + assert controller.target == pytest.approx(mph(45)) + assert controller.source == SOURCE_DASHBOARD + assert controller.last_valid_limit == pytest.approx(mph(45)) + assert controller.starpilot_planner.params.writes == writes + + +def test_previous_fallback_startup_has_unknown_source(controller_factory): + controller = controller_factory(persisted=mph(45), slc_fallback_previous_speed_limit=True) + step(controller) + assert controller.target == pytest.approx(mph(45)) + assert controller.source == SOURCE_NONE + assert controller.last_valid_source == SOURCE_NONE + + +@pytest.mark.parametrize("fallback", ["set", "experimental"]) +def test_fallback_never_enters_accepted_history(controller_factory, fallback): + controller = controller_factory( + slc_fallback_set_speed=fallback == "set", + slc_fallback_experimental_mode=fallback == "experimental", ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(15)) - sm = make_sm(gas_pressed=False, v_cruise_kph=20 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(20), mph(15), sm, display_only=True) - - assert controller.target == pytest.approx(mph(15)) - assert controller.source == "Vision" - finally: - controller.shutdown() + step(controller, cruise=mph(60)) + assert controller.source == SOURCE_NONE + assert controller.target == (mph(60) if fallback == "set" else 0.0) + assert controller.experimental_mode == (fallback == "experimental") + assert controller.last_valid_limit == 0 + assert controller.starpilot_planner.params.writes == [] -def test_low_vision_limit_filter_does_not_filter_dashboard_source(): - controller = make_controller( - speed_limit_priority1="Vision", - speed_limit_priority2="Dashboard", - vision_speed_limit_detection=True, - vision_speed_limit_low_limit_filter=True, - vision_speed_limit_low_limit_threshold=mph(25), - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(15)) - sm = make_sm(gas_pressed=False, v_cruise_kph=20 * CV.MPH_TO_KPH) - - controller.update_limits(mph(15), datetime.now(timezone.utc), False, mph(20), mph(15), sm) - - assert controller.target == pytest.approx(mph(15)) - assert controller.source == "Dashboard" - finally: - controller.shutdown() +def test_adopt_uses_real_candidate_only(controller_factory): + controller = controller_factory(slc_fallback_set_speed=True) + memory = controller.starpilot_planner.params_memory + memory.values["SLCAdoptSpeedLimit"] = True + step(controller, cruise=mph(60)) + assert controller.last_valid_limit == 0 + assert "SLCForceCruiseSpeed" not in memory.values + assert "SLCAdoptSpeedLimit" not in memory.values + memory.values["SLCAdoptSpeedLimit"] = True + step(controller, dashboard=mph(45)) + assert controller.last_valid_limit == pytest.approx(mph(45)) + assert memory.get_float("SLCForceCruiseSpeed") == pytest.approx(mph(45)) -def test_low_vision_limit_filter_does_not_restore_filtered_vision_fallback(): - controller = make_controller( - speed_limit_priority1="Vision", - slc_fallback_previous_speed_limit=True, - vision_speed_limit_detection=True, - vision_speed_limit_low_limit_filter=True, - vision_speed_limit_low_limit_threshold=mph(25), - ) - try: - controller.previous_source = "Vision" - controller.previous_target = mph(15) - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(15)) - sm = make_sm(gas_pressed=False, v_cruise_kph=20 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(20), mph(15), sm) - - assert controller.target == 0 - assert controller.source == "None" - finally: - controller.shutdown() +def test_pending_candidate_changes_speed_and_source(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True, speed_limit_priority1=SOURCE_MAP, + speed_limit_priority2=SOURCE_DASHBOARD) + step(controller, dashboard=mph(65)) + step(controller, dashboard=mph(45)) + assert controller.confirmation_pending + assert controller.pending_source == SOURCE_DASHBOARD + assert controller.limit_change_started + first_time = controller.confirmation_time + step(controller, dashboard=mph(45)) + assert not controller.limit_change_started + assert controller.confirmation_time > first_time + step(controller, map_limit=mph(45), way=custom.WaySelectionType.current) + assert controller.pending_source == SOURCE_MAP + assert not controller.limit_change_started + assert controller.confirmation_time > first_time + step(controller, map_limit=mph(55), way=custom.WaySelectionType.current) + assert controller.pending_limit == pytest.approx(mph(55)) + assert controller.pending_source == SOURCE_MAP + assert controller.limit_change_started + assert controller.confirmation_time == pytest.approx(DT_MDL) -def test_large_vision_delta_requires_three_detector_frames(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(15)) - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimitSupportSpeed", mph(15)) - controller.starpilot_planner.params_memory.put_int("VisionSpeedLimitSupportCount", 2) - sm = make_sm(gas_pressed=False, v_cruise_kph=75 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(75), mph(70), sm) - assert controller.target == 0 - - controller.starpilot_planner.params_memory.put_int("VisionSpeedLimitSupportCount", 3) - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(75), mph(70), sm) - assert controller.target == pytest.approx(mph(15)) - assert controller.source == "Vision" - finally: - controller.shutdown() +def test_pending_disappearance_discards_stale_acceptance(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + step(controller, dashboard=mph(45)) + assert controller.confirmation_pending + step(controller) + assert not controller.confirmation_pending + assert controller.confirmation_time == 0 + controller.starpilot_planner.params_memory.values["SpeedLimitAccepted"] = True + step(controller) + assert controller.last_valid_limit == pytest.approx(mph(55)) + assert "SpeedLimitAccepted" not in controller.starpilot_planner.params_memory.values -def test_normal_vision_delta_keeps_fast_path(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(50)) - sm = make_sm(gas_pressed=False, v_cruise_kph=75 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(75), mph(70), sm) - assert controller.target == pytest.approx(mph(50)) - assert controller.source == "Vision" - finally: - controller.shutdown() +def test_ui_acceptance_only_accepts_stored_pending_candidate(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(65)) + step(controller, dashboard=mph(45)) + controller.starpilot_planner.params_memory.values["SpeedLimitAccepted"] = True + step(controller, dashboard=mph(55)) + assert controller.pending_limit == pytest.approx(mph(55)) + assert controller.last_valid_limit == pytest.approx(mph(65)) + step(controller, dashboard=mph(55)) + assert controller.confirmation_pending + controller.starpilot_planner.params_memory.values["SpeedLimitAccepted"] = True + step(controller, dashboard=mph(55)) + assert controller.target == pytest.approx(mph(55)) + assert controller.last_valid_limit == pytest.approx(mph(55)) -def test_inactive_valid_cruise_still_applies_large_delta_guard(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(20)) - sm = make_sm(gas_pressed=False, long_active=False, v_cruise_kph=60 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(60), mph(25), sm) - assert controller.target == 0 - assert controller.source == "None" - finally: - controller.shutdown() +def test_accel_on_replacement_frame_does_not_accept_unshown_speed(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(65)) + step(controller, dashboard=mph(45)) + step(controller, dashboard=mph(55), accel=True) + assert controller.pending_limit == pytest.approx(mph(55)) + assert controller.last_valid_limit == pytest.approx(mph(65)) + assert controller.confirmation_button_consumed + step(controller, dashboard=mph(55), accel=True) + assert controller.target == pytest.approx(mph(55)) + assert controller.last_valid_limit == pytest.approx(mph(55)) -def test_unset_active_cruise_uses_vehicle_speed(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(55)) - sm = make_sm(gas_pressed=False) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(90), mph(50), sm) - assert controller.target == pytest.approx(mph(55)) - assert controller.source == "Vision" - finally: - controller.shutdown() +def test_accel_confirmation_consumes_adjacent_set_speed_edge(controller_factory): + controller = controller_factory(speed_limit_confirmation_higher=True) + step(controller, dashboard=mph(45), cruise=mph(45)) + step(controller, dashboard=mph(50), cruise=mph(45)) + step(controller, dashboard=mph(50), cruise=mph(45), accel=True) + assert controller.target == pytest.approx(mph(50)) + assert controller.confirmation_button_consumed + step(controller, dashboard=mph(50), cruise=mph(55)) + assert controller.overridden_speed == 0 + step(controller, dashboard=mph(50), cruise=mph(60), accel=True) + assert controller.overridden_speed == pytest.approx(mph(60)) -def test_unset_cruise_applies_vehicle_speed_large_delta_guard(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(15)) - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimitSupportSpeed", mph(15)) - controller.starpilot_planner.params_memory.put_int("VisionSpeedLimitSupportCount", 2) - sm = make_sm(gas_pressed=False) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(90), mph(75), sm) - assert controller.target == 0 - assert controller.source == "None" - - controller.starpilot_planner.params_memory.put_int("VisionSpeedLimitSupportCount", 3) - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(90), mph(75), sm) - assert controller.target == pytest.approx(mph(15)) - assert controller.source == "Vision" - finally: - controller.shutdown() +def test_higher_confirmation_forces_cruise_only_when_needed(controller_factory): + controller = controller_factory(speed_limit_confirmation_higher=True, speed_limit_offset4=mph(5)) + step(controller, dashboard=mph(35), cruise=mph(40)) + step(controller, dashboard=mph(45), cruise=mph(40)) + controller.starpilot_planner.params_memory.values["SpeedLimitAccepted"] = True + step(controller, dashboard=mph(45), cruise=mph(40)) + assert controller.target == pytest.approx(mph(45)) + assert controller.starpilot_planner.params_memory.get_float("SLCForceCruiseSpeed") == pytest.approx(mph(50)) -def test_standstill_ignores_vehicle_speed_jitter_for_vision_limit_guard(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(35)) - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimitSupportSpeed", mph(35)) - controller.starpilot_planner.params_memory.put_int("VisionSpeedLimitSupportCount", 2) - sm = make_sm(gas_pressed=False, standstill=True) - - for v_ego in (-0.0067, 0.0005): - controller.update_limits(0.0, datetime.now(UTC), False, mph(35), v_ego, sm) - assert controller.target == pytest.approx(mph(35)) - assert controller.source == "Vision" - finally: - controller.shutdown() +def test_enabled_without_long_control_does_not_time_out_confirmation(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + for _ in range(int(30 / DT_MDL) + 1): + step(controller, dashboard=mph(45), long_active=False, enabled=True) + assert controller.confirmation_pending + assert controller.denied_limit == 0 -def test_display_only_applies_large_delta_guard(): - controller = make_controller( - speed_limit_priority1="Vision", - vision_speed_limit_detection=True, - ) - try: - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimit", mph(15)) - controller.starpilot_planner.params_memory.put_float("VisionSpeedLimitSupportSpeed", mph(15)) - controller.starpilot_planner.params_memory.put_int("VisionSpeedLimitSupportCount", 1) - sm = make_sm(gas_pressed=False, v_cruise_kph=75 * CV.MPH_TO_KPH) - - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(75), mph(70), sm, display_only=True) - assert controller.target == 0 - assert controller.source == "None" - - controller.starpilot_planner.params_memory.put_int("VisionSpeedLimitSupportCount", 3) - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(75), mph(70), sm, display_only=True) - assert controller.target == pytest.approx(mph(15)) - assert controller.source == "Vision" - finally: - controller.shutdown() +def test_rejection_and_timeout_do_not_change_history(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + writes = list(controller.starpilot_planner.params.writes) + step(controller, dashboard=mph(45)) + step(controller, dashboard=mph(45), decel=True) + assert controller.denied_limit == pytest.approx(mph(45)) + assert controller.last_valid_limit == pytest.approx(mph(55)) + assert controller.starpilot_planner.params.writes == writes + step(controller, dashboard=mph(45)) + assert not controller.confirmation_pending + step(controller, dashboard=mph(40)) + for _ in range(int(30 / DT_MDL) + 1): + step(controller, dashboard=mph(40)) + assert controller.denied_limit == pytest.approx(mph(40)) + assert controller.last_valid_limit == pytest.approx(mph(55)) -def test_set_speed_override_survives_source_changes_and_fallback_until_driver_clears(): - controller = make_controller( - speed_limit_priority1="Map Data", - speed_limit_priority2="Dashboard", - slc_fallback_set_speed=True, - ) - try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.previous_source = "Dashboard" - controller.previous_target = mph(45) - controller.last_valid_limit = mph(45) +def test_disabling_confirmation_accepts_a_previously_denied_limit(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + step(controller, dashboard=mph(45)) + step(controller, dashboard=mph(45), decel=True) + assert controller.denied_limit == pytest.approx(mph(45)) - controller.update_override(mph(45), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - - # Dashboard 45 -> Map Data 45 is not a new speed zone. - map_sm = make_sm(gas_pressed=False) - map_sm["mapdOut"].speedLimit = mph(45) - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(55), mph(50), map_sm) - controller.update_override(mph(55), 0.0, mph(50), 0.0, map_sm) - assert controller.source == "Map Data" - assert controller.overridden_speed == pytest.approx(mph(55)) - assert controller.override_slc - - # A temporary fallback, and even a complete source dropout, do not clear the override. - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(55), mph(50), make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - assert controller.source == "None" - assert controller.target == pytest.approx(mph(55)) - assert controller.overridden_speed == pytest.approx(mph(55)) - assert controller.override_slc - - controller.starpilot_toggles.slc_fallback_set_speed = False - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(55), mph(50), make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - assert controller.target == 0 - assert controller.overridden_speed == pytest.approx(mph(55)) - assert controller.override_slc - - controller.update_limits(mph(45), datetime.now(timezone.utc), False, mph(55), mph(50), make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - assert controller.source == "Dashboard" - assert controller.overridden_speed == pytest.approx(mph(55)) - assert controller.override_slc - - # Set-speed fallback does not clear passively, but a fresh - to the retained target does. - controller.starpilot_toggles.slc_fallback_set_speed = True - controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(55), mph(50), make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - controller.update_override(mph(45), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - assert not controller.override_slc - assert controller.overridden_speed == 0 - finally: - controller.shutdown() + controller.starpilot_toggles.speed_limit_confirmation_lower = False + step(controller, dashboard=mph(45)) + assert controller.source == SOURCE_DASHBOARD + assert controller.target == pytest.approx(mph(45)) + assert controller.denied_limit == 0 + assert not controller.limit_change_started -def test_unconfirmed_lower_limit_keeps_existing_override(): - # First, verify startup behavior where target is 0 and priority limit is detected - startup_controller = make_controller( - speed_limit_priority1="Dashboard", - slc_fallback_previous_speed_limit=True, - ) - try: - startup_controller.previous_target = mph(55) - startup_controller.previous_source = "Dashboard" - startup_controller.target = 0 +def test_road_change_clears_denial_before_comparison(controller_factory): + controller = controller_factory(speed_limit_priority1=SOURCE_MAP, speed_limit_confirmation_lower=True) + step(controller, map_limit=mph(55), way=custom.WaySelectionType.current, road="Road A") + step(controller, map_limit=mph(45), way=custom.WaySelectionType.current, road="Road A", decel=True) + assert controller.denied_limit == pytest.approx(mph(45)) + step(controller, map_limit=mph(45), way=custom.WaySelectionType.current, road="Road B") + assert controller.confirmation_pending + assert controller.pending_limit == pytest.approx(mph(45)) - sm = make_sm(gas_pressed=False) - startup_controller.update_limits(mph(45), datetime.now(timezone.utc), False, mph(75), mph(65), sm) - assert startup_controller.target == pytest.approx(mph(45)) - assert startup_controller.source == "Dashboard" - finally: - startup_controller.shutdown() +def test_same_speed_source_change_does_not_alert_or_disturb_override(controller_factory): + controller = controller_factory(speed_limit_priority1=SOURCE_MAP, speed_limit_priority2=SOURCE_DASHBOARD) + step(controller, dashboard=mph(45), cruise=mph(45)) + step(controller, dashboard=mph(45), cruise=mph(60)) + assert controller.set_speed_override == pytest.approx(mph(60)) + step(controller, map_limit=mph(45), way=custom.WaySelectionType.current, cruise=mph(60)) + assert controller.source == SOURCE_MAP + assert controller.last_valid_source == SOURCE_MAP + assert not controller.limit_change_started + assert controller.set_speed_override == pytest.approx(mph(60)) - # Verify Bug 3: Fallback transitions should bypass confirmation checks - fallback_confirm_controller = make_controller( - slc_fallback_set_speed=True, - speed_limit_confirmation_higher=True - ) - try: - fallback_confirm_controller.source = "Dashboard" - fallback_confirm_controller.target = mph(35) - fallback_confirm_controller.previous_target = mph(35) - sm = make_sm(gas_pressed=False) - fallback_confirm_controller.update_limits(0.0, datetime.now(timezone.utc), False, mph(60), mph(35), sm) +def test_equivalent_speed_churn_does_not_rewrite_persisted_limit(controller_factory): + controller = controller_factory() + step(controller, dashboard=mph(45)) + initial_writes = list(controller.starpilot_planner.params.writes) + for speed in (45.5, 45, 45.5, 45): + step(controller, dashboard=mph(speed)) + assert controller.starpilot_planner.params.writes == initial_writes + assert controller.last_valid_limit == pytest.approx(mph(45)) + step(controller, dashboard=mph(50)) + assert controller.starpilot_planner.params.writes[-1] == ("PreviousSpeedLimit", mph(50)) + assert len(controller.starpilot_planner.params.writes) == len(initial_writes) + 1 - assert fallback_confirm_controller.target == pytest.approx(mph(60)) - assert fallback_confirm_controller.source == "None" - assert fallback_confirm_controller.unconfirmed_speed_limit == 0 - finally: - fallback_confirm_controller.shutdown() - # Verify Bug 1: Boundaries are correctly mapped and not falling back to 0 - boundary_controller = make_controller() - boundary_controller.starpilot_toggles.speed_limit_offset1 = 1.0 - boundary_controller.starpilot_toggles.speed_limit_offset2 = 2.0 +def test_override_pedal_layers_over_persistent_and_new_lower_clears(controller_factory): + controller = controller_factory() + step(controller, dashboard=mph(45), cruise=mph(45), ego=mph(45)) + step(controller, dashboard=mph(45), cruise=mph(60), ego=mph(45)) + assert controller.overridden_speed == pytest.approx(mph(60)) + step(controller, dashboard=mph(45), cruise=mph(60), ego=mph(65), gas=True) + assert controller.overridden_speed == pytest.approx(mph(65)) + step(controller, dashboard=mph(45), cruise=mph(60), ego=mph(50)) + assert controller.overridden_speed == pytest.approx(mph(60)) + step(controller, dashboard=mph(40), cruise=mph(60)) + assert controller.set_speed_override == 0 + assert controller.overridden_speed == 0 - # Exact boundary speed: 11.2 m/s is the *start* of band 2 (25–34 mph range). - # With low <= target < high: 11.2 <= 11.2 < 15.2 → True → maps to offset2 (not 0). - offset = boundary_controller.get_offset(11.2) - assert offset != 0.0 - controller = make_controller(speed_limit_confirmation_lower=True) - try: - controller.source = "Dashboard" - controller.target = mph(55) - controller.previous_source = "Dashboard" - controller.previous_target = mph(55) - controller.overridden_speed = mph(65) +def test_higher_limit_clears_override_only_when_target_reaches_it(controller_factory): + controller = controller_factory() + step(controller, dashboard=mph(35), cruise=mph(35)) + step(controller, dashboard=mph(35), cruise=mph(55)) + step(controller, dashboard=mph(45), cruise=mph(55)) + assert controller.set_speed_override == pytest.approx(mph(55)) + step(controller, dashboard=mph(55), cruise=mph(55)) + assert controller.set_speed_override == 0 - sm = make_sm(gas_pressed=True) - controller.update_limits(mph(45), datetime.now(timezone.utc), False, mph(75), mph(65), sm) - controller.update_override(mph(75), 0.0, mph(65), 0.0, sm) - assert controller.target == pytest.approx(mph(55)) - assert controller.unconfirmed_speed_limit == pytest.approx(mph(45)) - assert controller.overridden_speed == pytest.approx(mph(65)) - assert controller.override_slc - finally: - controller.shutdown() +def test_higher_limit_with_offset_clears_reached_override(controller_factory): + controller = controller_factory(speed_limit_offset4=mph(5)) + step(controller, dashboard=mph(35), cruise=mph(35)) + step(controller, dashboard=mph(35), cruise=mph(50)) + assert controller.set_speed_override == pytest.approx(mph(50)) + step(controller, dashboard=mph(45), cruise=mph(50)) + assert controller.set_speed_override == 0 + + +def test_plus_after_automatic_acceptance_is_a_real_override_edge(controller_factory): + controller = controller_factory() + step(controller, dashboard=mph(45), cruise=mph(45)) + assert not controller.confirmation_pending + step(controller, dashboard=mph(45), cruise=mph(55), accel=True) + assert controller.set_speed_override == pytest.approx(mph(55)) + + +def test_redneck_override_can_move_below_target(controller_factory): + controller = controller_factory(redneck_cruise=True) + step(controller, dashboard=mph(45), cruise=mph(45)) + step(controller, dashboard=mph(45), cruise=mph(60)) + step(controller, dashboard=mph(45), cruise=mph(35)) + assert controller.overridden_speed == pytest.approx(mph(35)) @pytest.mark.parametrize( - ("current_limit", "desired_limit", "confirmation_toggle"), - [ - (65, 45, "speed_limit_confirmation_lower"), - (35, 45, "speed_limit_confirmation_higher"), - ], + ("manual_setting", "set_speed_setting"), + [(False, False), (True, False), (False, True)], ) -def test_rejected_confirmation_does_not_auto_apply_on_next_update( - current_limit, desired_limit, confirmation_toggle, +def test_legacy_slc_override_setting_does_not_change_current_override_policy( + controller_factory, manual_setting, set_speed_setting, ): - controller, now = make_pending_limit(current_limit, desired_limit, confirmation_toggle) - try: - update_dashboard_limit(controller, now, current_limit, desired_limit, decel_pressed=True) - assert controller.denied_target == pytest.approx(mph(desired_limit)) - - update_dashboard_limit(controller, now, current_limit, desired_limit) - - assert controller.source == "None" - assert controller.target == pytest.approx(mph(current_limit)) - assert controller.unconfirmed_speed_limit == 0 - finally: - controller.shutdown() - - -@pytest.mark.parametrize( - ("current_limit", "desired_limit", "confirmation_toggle"), - [ - (55, 45, "speed_limit_confirmation_lower"), - (35, 45, "speed_limit_confirmation_higher"), - ], -) -def test_timed_out_confirmation_does_not_auto_apply( - current_limit, desired_limit, confirmation_toggle, -): - controller, now = make_pending_limit(current_limit, desired_limit, confirmation_toggle) - try: - for _ in range(int(30 / DT_MDL)): - update_dashboard_limit(controller, now, current_limit, desired_limit) - - assert controller.denied_target == pytest.approx(mph(desired_limit)) - - update_dashboard_limit(controller, now, current_limit, desired_limit) - - assert controller.source == "None" - assert controller.target == pytest.approx(mph(current_limit)) - assert controller.unconfirmed_speed_limit == 0 - finally: - controller.shutdown() - - -def test_new_lower_limit_prompts_after_denial(): - controller, now = make_pending_lower_limit(65, 45) - try: - update_dashboard_limit(controller, now, 65, 45, decel_pressed=True) - update_dashboard_limit(controller, now, 65, 45) - - update_dashboard_limit(controller, now, 65, 40) - - assert controller.source == "None" - assert controller.target == pytest.approx(mph(65)) - assert controller.unconfirmed_speed_limit == pytest.approx(mph(40)) - assert controller.denied_target == 0 - finally: - controller.shutdown() - - -def test_denial_discards_stale_widget_acceptance(): - controller, now = make_pending_lower_limit(65, 45) - try: - controller.starpilot_planner.params_memory.values["SpeedLimitAccepted"] = True - update_dashboard_limit(controller, now, 65, 45, decel_pressed=True) - update_dashboard_limit(controller, now, 65, 45) - - update_dashboard_limit(controller, now, 65, 40) - update_dashboard_limit(controller, now, 65, 40) - - assert controller.target == pytest.approx(mph(65)) - assert controller.unconfirmed_speed_limit == pytest.approx(mph(40)) - finally: - controller.shutdown() - - -def test_set_speed_override_handles_higher_limit_changes(): - controller = make_controller() - try: - controller.source = "Dashboard" - controller.target = mph(35) - controller.previous_source = "Dashboard" - controller.previous_target = mph(35) - controller.last_valid_limit = mph(35) - - controller.update_override(mph(35), 0.0, mph(35), 0.0, make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(35), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(55)) - - # A higher limit below the selected override preserves it. - controller.update_limits(mph(45), datetime.now(timezone.utc), False, mph(55), mph(50), make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - - assert controller.target == pytest.approx(mph(45)) - assert controller.source == "Dashboard" - assert controller.overridden_speed == pytest.approx(mph(55)) - assert controller.override_slc - - # A higher effective target that reaches the override clears it without re-arming. - controller.update_limits(mph(55), datetime.now(timezone.utc), False, mph(55), mph(50), make_sm(gas_pressed=False)) - controller.update_override(mph(55), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - assert controller.target == pytest.approx(mph(55)) - assert controller.overridden_speed == 0 - assert not controller.override_slc - finally: - controller.shutdown() - - -def test_pedal_and_set_speed_overrides_are_independent(): - controller = make_controller() - try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.last_valid_limit = mph(45) - - # A pedal pass is temporary; a set-speed increase is the fixed persistent action. - controller.update_override(mph(45), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - controller.update_override(mph(45), 0.0, mph(55), 0.0, make_sm(gas_pressed=True)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(55)) - - controller.update_override(mph(45), 0.0, mph(55), 0.0, make_sm(gas_pressed=False)) - assert not controller.override_slc - assert controller.overridden_speed == 0 - - # A fresh + above the effective SLC target arms the override. - controller.update_override(mph(55), 0.0, mph(55), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(55)) - - # Pedaling temporarily takes priority, then returns to the selected set speed. - controller.update_override(mph(55), 0.0, mph(60), 0.0, make_sm(gas_pressed=True)) - assert controller.overridden_speed == pytest.approx(mph(60)) - - controller.update_override(mph(55), 0.0, mph(60), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(55)) - - controller.update_override(mph(60), 0.0, mph(58), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(60)) - - controller.update_override(mph(50), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(50)) - - # Returning to the effective SLC target ends the persistent override. - controller.update_override(mph(45), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - assert not controller.override_slc - assert controller.overridden_speed == 0 - finally: - controller.shutdown() - - -def test_persistent_override_waits_until_above_slc_target_with_offset(): - controller = make_controller( - is_metric=True, - speed_limit_offset2=3 * CV.KPH_TO_MS, + controller = controller_factory( + speed_limit_controller_override_manual=manual_setting, + speed_limit_controller_override_set_speed=set_speed_setting, ) + step(controller, dashboard=mph(45), cruise=mph(45)) + step(controller, dashboard=mph(45), cruise=mph(55)) + assert controller.set_speed_override == pytest.approx(mph(55)) + step(controller, dashboard=mph(45), cruise=mph(55), ego=mph(60), gas=True) + assert controller.pedal_override == pytest.approx(mph(60)) + + +@pytest.mark.parametrize("display_only", [False, True]) +def test_inactive_mode_clears_override_and_reseeds_set_speed(controller_factory, display_only): + controller = controller_factory() + step(controller, dashboard=mph(45), cruise=mph(45)) + step(controller, dashboard=mph(45), cruise=mph(60)) + assert controller.set_speed_override > 0 + step(controller, dashboard=mph(45), cruise=mph(70), active=False, display_only=display_only) + assert controller.set_speed_override == 0 + assert controller.previous_set_speed is None + step(controller, dashboard=mph(45), cruise=mph(70)) + assert controller.set_speed_override == 0 + assert controller.previous_set_speed == pytest.approx(mph(70)) + + +def test_inactive_mode_consumes_stale_one_shots(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + step(controller, dashboard=mph(45)) + memory = controller.starpilot_planner.params_memory + memory.values["SpeedLimitAccepted"] = True + memory.values["SLCAdoptSpeedLimit"] = True + step(controller, active=False) + assert not controller.confirmation_pending + assert "SpeedLimitAccepted" not in memory.values + assert "SLCAdoptSpeedLimit" not in memory.values + assert controller.last_valid_limit == pytest.approx(mph(55)) + + +def test_brief_disengage_keeps_override_then_sustained_disengage_clears_it(controller_factory): + controller = controller_factory() + step(controller, dashboard=mph(45), cruise=mph(45)) + step(controller, dashboard=mph(45), cruise=mph(60)) + for _ in range(int(0.5 / DT_MDL)): + step(controller, dashboard=mph(45), cruise=mph(60), enabled=False) + assert controller.set_speed_override == pytest.approx(mph(60)) + for _ in range(int(0.5 / DT_MDL) + 1): + step(controller, dashboard=mph(45), cruise=mph(60), enabled=False) + assert controller.set_speed_override == 0 + + +def test_disengaged_confirmation_auto_accepts_without_timing_out(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + step(controller, dashboard=mph(45), enabled=False, long_active=False) + assert controller.target == pytest.approx(mph(45)) + assert not controller.confirmation_pending + + +def test_fully_disengaged_auto_accept_takes_precedence_over_decel(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + step(controller, dashboard=mph(45), enabled=False, long_active=False, decel=True) + assert controller.target == pytest.approx(mph(45)) + assert controller.last_valid_limit == pytest.approx(mph(45)) + assert controller.denied_limit == 0 + + +def test_explicit_accept_takes_precedence_over_simultaneous_reject(controller_factory): + controller = controller_factory(speed_limit_confirmation_lower=True) + step(controller, dashboard=mph(55)) + step(controller, dashboard=mph(45)) + step(controller, dashboard=mph(45), accel=True, decel=True) + assert controller.target == pytest.approx(mph(45)) + assert controller.denied_limit == 0 + + +def test_offset_bucket_boundary(controller_factory): + controller = controller_factory(speed_limit_offset1=1.0, speed_limit_offset2=2.0) + assert controller.get_offset(11.2) == 2.0 + + +def test_mapbox_reset_discards_obsolete_future(): + helper = MapboxSpeedLimit(FakeParams({"MapboxSecretKey": "test"})) try: - controller.source = "Dashboard" - controller.target = 30 * CV.KPH_TO_MS - controller.last_valid_limit = controller.target + old = Future() + old.set_running_or_notify_cancel() + helper.future = old + helper.reset() + old.set_result((mph(45), 100.0)) + helper.update(datetime.now(UTC), False, 0.0, True, {}, 0.0, 0.0) + assert helper.limit == 0 - controller.update_override(30 * CV.KPH_TO_MS, 0.0, 30 * CV.KPH_TO_MS, 0.0, make_sm(gas_pressed=False)) - controller.update_override(33 * CV.KPH_TO_MS, 0.0, 30 * CV.KPH_TO_MS, 0.0, make_sm(gas_pressed=False)) - assert not controller.override_slc - - controller.update_override(35 * CV.KPH_TO_MS, 0.0, 30 * CV.KPH_TO_MS, 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(35 * CV.KPH_TO_MS) - - controller.update_override(33 * CV.KPH_TO_MS, 0.0, 30 * CV.KPH_TO_MS, 0.0, make_sm(gas_pressed=False)) - assert not controller.override_slc - assert controller.overridden_speed == 0 + newer = Future() + newer.set_result((mph(55), 100.0)) + helper.future = newer + helper.update(datetime.now(UTC), False, mph(40), True, {}, 0.0, 0.0) + assert helper.limit == pytest.approx(mph(55)) + helper.requests["total_requests"] = helper.requests["max_requests"] + helper.update(datetime.now(UTC), False, mph(40), True, {}, 0.0, 0.0) + assert helper.limit == 0 finally: - controller.shutdown() + helper.shutdown() -def test_set_speed_override_clears_on_new_speed_zone(): - # Entering a new (lower) posted limit clears the override; a steady high set speed must not - # re-arm it. Only a fresh +/- press re-arms. - controller = make_controller() +def test_mapbox_ping_failure_keeps_previous_retry_distance(monkeypatch): + import openpilot.starpilot.controls.lib.mapbox_speed_limit as mapbox_module + + helper = MapboxSpeedLimit(FakeParams({"MapboxSecretKey": "test"})) try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.previous_source = "Dashboard" - controller.previous_target = mph(45) - controller.last_valid_limit = mph(45) - - controller.update_override(mph(45), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - controller.update_override(mph(60), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - - # A 1 mph lower zone takes the same-limit fast path but still clears the override. - controller.update_limits(mph(44), datetime.now(timezone.utc), False, mph(60), mph(58), make_sm(gas_pressed=False)) - controller.update_override(mph(60), 0.0, mph(58), 0.0, make_sm(gas_pressed=False)) - assert controller.target == pytest.approx(mph(44)) - # Set speed unchanged at 60 -> no rising edge -> override stays cleared (car slows to 44). - assert not controller.override_slc - assert controller.overridden_speed == 0 - - # A fresh + press (60 -> 65) re-arms against the new limit. - controller.update_override(mph(65), 0.0, mph(44), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(65)) + monkeypatch.setattr(mapbox_module, "is_url_pingable", lambda _host: False) + assert helper._request({}, mph(45)) == (0.0, mph(45)) finally: - controller.shutdown() + helper.shutdown() -def test_confirmation_accel_press_does_not_arm_set_speed_override(): - controller = make_controller( - speed_limit_confirmation_higher=True, - ) +def test_mapbox_parses_first_segment_without_worker_state_mutation(monkeypatch): + import openpilot.starpilot.controls.lib.mapbox_speed_limit as mapbox_module + + helper = MapboxSpeedLimit(FakeParams({"MapboxSecretKey": "test"})) try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.previous_source = "Dashboard" - controller.previous_target = mph(45) - controller.last_valid_limit = mph(45) - - controller.update_override(mph(45), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - controller.update_limits(mph(50), datetime.now(timezone.utc), False, mph(45), mph(45), make_sm(gas_pressed=False)) - assert controller.source == "None" - assert controller.unconfirmed_speed_limit == pytest.approx(mph(50)) - - # The button arrives before the corresponding cruise-speed update. This + accepts the - # pending 50 mph limit, but its delayed 55 mph set-speed update must not arm an override. - confirm_sm = make_sm(gas_pressed=False, accel_pressed=True, v_cruise_kph=45 * CV.MPH_TO_KPH) - controller.update_limits(mph(50), datetime.now(timezone.utc), False, mph(45), mph(45), confirm_sm) - controller.update_override(mph(45), 0.0, mph(45), 0.0, confirm_sm) - assert controller.source == "Dashboard" - assert controller.target == pytest.approx(mph(50)) - assert not controller.override_slc - assert controller.overridden_speed == 0 - - delayed_speed_sm = make_sm(gas_pressed=False, v_cruise_kph=55 * CV.MPH_TO_KPH) - controller.update_limits(mph(50), datetime.now(timezone.utc), False, mph(55), mph(45), delayed_speed_sm) - controller.update_override(mph(55), 0.0, mph(45), 0.0, delayed_speed_sm) - assert not controller.override_slc - assert controller.overridden_speed == 0 - - # A second fresh + is allowed to establish the override. - second_press_sm = make_sm(gas_pressed=False, accel_pressed=True, v_cruise_kph=60 * CV.MPH_TO_KPH) - controller.update_limits(mph(50), datetime.now(timezone.utc), False, mph(60), mph(45), second_press_sm) - controller.update_override(mph(60), 0.0, mph(45), 0.0, second_press_sm) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(60)) - finally: - controller.shutdown() - - -@pytest.mark.parametrize( - ("current_limit", "desired_limit", "accel_pressed", "decel_pressed"), - [ - (65, 45, False, True), - (35, 45, True, False), - ], -) -def test_disabled_confirmation_does_not_consume_wheel_input( - current_limit, desired_limit, accel_pressed, decel_pressed, -): - controller = make_controller() - try: - controller.source = "Dashboard" - controller.target = mph(current_limit) - controller.previous_source = "Dashboard" - controller.previous_target = mph(current_limit) - controller.last_valid_limit = mph(current_limit) - controller._slc_adopt_counter = 1 - controller.starpilot_planner.params_memory.values["SpeedLimitAccepted"] = True - - controller.handle_limit_change( - "Dashboard", mph(desired_limit), "", mph(current_limit), - make_sm( - gas_pressed=False, - accel_pressed=accel_pressed, - decel_pressed=decel_pressed, - v_cruise_kph=current_limit * CV.MPH_TO_KPH, - ), + monkeypatch.setattr(mapbox_module, "is_url_pingable", lambda _host: True) + monkeypatch.setattr(mapbox_module, "calculate_bearing_offset", lambda *_args: (1.0, 2.0)) + response = SimpleNamespace( + raise_for_status=lambda: None, + json=lambda: {"matchings": [{"legs": [{"annotation": { + "distance": [150.0], "maxspeed": [{"speed": 45, "unit": "mph"}], + }}]}]}, ) - - assert controller.target == pytest.approx(mph(desired_limit)) - assert controller.denied_target == 0 - assert controller.unconfirmed_speed_limit == 0 - assert not controller._set_speed_override_input_consumed - assert "SpeedLimitAccepted" not in controller.starpilot_planner.params_memory.values - assert "SLCForceCruiseSpeed" not in controller.starpilot_planner.params_memory.values + monkeypatch.setattr(helper.session, "get", lambda *_args, **_kwargs: response) + assert helper._request({"bearing": 0, "latitude": 0, "longitude": 0}, mph(40)) == pytest.approx((mph(45), 150.0)) + assert helper.limit == 0 finally: - controller.shutdown() - - -@pytest.mark.parametrize( - ("current_limit", "desired_limit", "confirmation_toggle", "confirmation_enabled"), - [ - (65, 45, "speed_limit_confirmation_lower", True), - (35, 45, "speed_limit_confirmation_higher", True), - (65, 45, "speed_limit_confirmation_lower", False), - (35, 45, "speed_limit_confirmation_higher", False), - ], -) -def test_directional_limit_changes_follow_confirmation_mode( - current_limit, desired_limit, confirmation_toggle, confirmation_enabled, -): - controller = make_controller( - speed_limit_priority1="Dashboard", - **{confirmation_toggle: confirmation_enabled}, - ) - try: - controller.source = "Dashboard" - controller.target = mph(current_limit) - controller.previous_source = "Dashboard" - controller.previous_target = mph(current_limit) - controller.last_valid_limit = mph(current_limit) - - update_dashboard_limit(controller, datetime.now(timezone.utc), current_limit, desired_limit) - - if confirmation_enabled: - assert controller.source == "None" - assert controller.target == pytest.approx(mph(current_limit)) - assert controller.unconfirmed_speed_limit == pytest.approx(mph(desired_limit)) - else: - assert controller.source == "Dashboard" - assert controller.target == pytest.approx(mph(desired_limit)) - assert controller.unconfirmed_speed_limit == 0 - finally: - controller.shutdown() - - -@pytest.mark.parametrize( - ("current_limit", "desired_limit", "confirmation_toggle", "accel_pressed", "decel_pressed", "accepted"), - [ - (65, 45, "speed_limit_confirmation_lower", True, False, True), - (65, 45, "speed_limit_confirmation_lower", False, True, False), - (35, 45, "speed_limit_confirmation_higher", True, False, True), - (35, 45, "speed_limit_confirmation_higher", False, True, False), - ], -) -def test_confirmation_wheel_actions_accept_or_decline_pending_limit( - current_limit, desired_limit, confirmation_toggle, accel_pressed, decel_pressed, accepted, -): - controller, now = make_pending_limit(current_limit, desired_limit, confirmation_toggle) - try: - update_dashboard_limit( - controller, now, current_limit, desired_limit, - accel_pressed=accel_pressed, - decel_pressed=decel_pressed, - ) - - if accepted: - assert controller.source == "Dashboard" - assert controller.target == pytest.approx(mph(desired_limit)) - assert controller._set_speed_override_input_consumed - else: - assert controller.source == "None" - assert controller.target == pytest.approx(mph(current_limit)) - assert controller.denied_target == pytest.approx(mph(desired_limit)) - - # The following planner update clears the one-frame confirmation handoff state. - update_dashboard_limit(controller, now, current_limit, desired_limit) - assert controller.unconfirmed_speed_limit == 0 - finally: - controller.shutdown() - - -@pytest.mark.parametrize( - ("current_limit", "desired_limit", "confirmation_toggle", "accel_pressed", "decel_pressed"), - [ - (65, 45, "speed_limit_confirmation_lower", False, True), - (35, 45, "speed_limit_confirmation_higher", True, False), - ], -) -def test_disabling_confirmation_clears_pending_confirmation_immediately( - current_limit, desired_limit, confirmation_toggle, accel_pressed, decel_pressed, -): - controller = make_controller( - speed_limit_priority1="Dashboard", - **{confirmation_toggle: True}, - ) - try: - controller.source = "Dashboard" - controller.target = mph(current_limit) - controller.previous_source = "Dashboard" - controller.previous_target = mph(current_limit) - controller.last_valid_limit = mph(current_limit) - now = datetime.now(timezone.utc) - - update_dashboard_limit(controller, now, current_limit, desired_limit) - assert controller.unconfirmed_speed_limit == pytest.approx(mph(desired_limit)) - - setattr(controller.starpilot_toggles, confirmation_toggle, False) - - update_dashboard_limit( - controller, now, current_limit, desired_limit, - accel_pressed=accel_pressed, - decel_pressed=decel_pressed, - ) - - assert controller.target == pytest.approx(mph(desired_limit)) - assert controller.unconfirmed_speed_limit == 0 - assert controller.denied_target == 0 - assert not controller._set_speed_override_input_consumed - finally: - controller.shutdown() - - -@pytest.mark.parametrize("accepted_by_accel_button", [True, False]) -def test_higher_confirmation_raises_cruise_speed_to_target_with_offset(accepted_by_accel_button): - controller = make_controller( - speed_limit_confirmation_higher=True, - speed_limit_offset4=mph(5), - ) - try: - controller.source = "Dashboard" - controller.target = mph(35) - controller.previous_source = "Dashboard" - controller.previous_target = mph(35) - controller.last_valid_limit = mph(35) - if not accepted_by_accel_button: - controller.starpilot_planner.params_memory.values["SpeedLimitAccepted"] = True - - controller.handle_limit_change( - "Dashboard", mph(45), "", mph(40), - make_sm( - gas_pressed=False, - accel_pressed=accepted_by_accel_button, - v_cruise_kph=40 * CV.MPH_TO_KPH, - ), - ) - - assert controller.target == pytest.approx(mph(45)) - assert controller.starpilot_planner.params_memory.get_float("SLCForceCruiseSpeed") == pytest.approx(mph(50)) - finally: - controller.shutdown() - - -@pytest.mark.parametrize( - ("current_limit", "desired_limit", "set_speed", "toggle_overrides", "sm_overrides"), - [ - (45, 65, 75, {"speed_limit_confirmation_higher": True}, {"accel_pressed": True}), - (65, 45, 65, {"speed_limit_confirmation_lower": True}, {"accel_pressed": True}), - (35, 45, 40, {}, {}), - (35, 45, 40, {"speed_limit_confirmation_higher": True}, {"long_active": False, "enabled": False}), - ], -) -def test_limit_changes_that_do_not_raise_max_do_not_force_cruise_speed( - current_limit, desired_limit, set_speed, toggle_overrides, sm_overrides, -): - controller = make_controller(**toggle_overrides) - try: - controller.source = "Dashboard" - controller.target = mph(current_limit) - controller.previous_source = "Dashboard" - controller.previous_target = mph(current_limit) - controller.last_valid_limit = mph(current_limit) - - controller.handle_limit_change( - "Dashboard", mph(desired_limit), "", mph(set_speed), - make_sm( - gas_pressed=False, - v_cruise_kph=set_speed * CV.MPH_TO_KPH, - **sm_overrides, - ), - ) - - assert controller.target == pytest.approx(mph(desired_limit)) - assert "SLCForceCruiseSpeed" not in controller.starpilot_planner.params_memory.values - finally: - controller.shutdown() - - -def test_adopt_speed_limit_clears_complete_override_state(): - controller = make_controller() - try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.previous_source = "Dashboard" - controller.previous_target = mph(45) - controller.last_valid_limit = mph(45) - controller.override_slc = True - controller.overridden_speed = mph(55) - controller._slc_adopt_counter = 3 - controller.starpilot_planner.params_memory.values["SLCAdoptSpeedLimit"] = True - - controller.update_limits(mph(45), datetime.now(timezone.utc), False, mph(55), mph(50), make_sm(gas_pressed=False)) - - assert controller.overridden_speed == 0 - assert not controller.override_slc - finally: - controller.shutdown() - - -def test_redneck_set_speed_override_is_bidirectional(): - controller = make_controller( - redneck_cruise=True, - ) - try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.last_valid_limit = mph(45) - - controller.update_override(mph(45), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - controller.update_override(mph(60), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(60)) - - # A manual decrease below the posted limit must become the new redneck target. - controller.update_override(mph(35), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(35)) - finally: - controller.shutdown() - - -def test_manual_override_tracks_current_speed_and_ends_on_release(): - controller = make_controller() - try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.last_valid_limit = mph(45) - - controller.update_override(mph(60), 0.0, mph(45), 0.0, make_sm(gas_pressed=False)) - assert not controller.override_slc - assert controller.overridden_speed == 0 - - controller.update_override(mph(60), 0.0, mph(55), 0.0, make_sm(gas_pressed=True)) - assert controller.override_slc - assert controller.overridden_speed == pytest.approx(mph(55)) - - # The temporary override follows the current speed rather than a historical peak. - controller.update_override(mph(60), 0.0, mph(50), 0.0, make_sm(gas_pressed=True)) - assert controller.overridden_speed == pytest.approx(mph(50)) - - controller.update_override(mph(60), 0.0, mph(50), 0.0, make_sm(gas_pressed=False)) - assert not controller.override_slc - assert controller.overridden_speed == 0 - finally: - controller.shutdown() - - -def test_manual_override_survives_brief_enabled_flicker(): - controller = make_controller() - try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.previous_source = "Dashboard" - controller.previous_target = mph(45) - controller.last_valid_limit = mph(45) - controller.update_override(mph(60), 0.0, mph(55), 0.0, make_sm(gas_pressed=True)) - - disabled_sm = make_sm(gas_pressed=True, enabled=False) - for _ in range(int(0.5 / DT_MDL)): - controller.update_override(mph(60), 0.0, mph(55), 0.0, disabled_sm) - - assert controller.overridden_speed == pytest.approx(mph(55)) - assert controller.override_slc - - controller.update_override(mph(60), 0.0, mph(55), 0.0, make_sm(gas_pressed=True, enabled=True)) - - assert controller.overridden_speed == pytest.approx(mph(55)) - assert controller.override_slc - finally: - controller.shutdown() - - -def test_override_clears_after_sustained_disengage(): - controller = make_controller() - try: - controller.source = "Dashboard" - controller.target = mph(45) - controller.previous_source = "Dashboard" - controller.previous_target = mph(45) - controller.last_valid_limit = mph(45) - controller.overridden_speed = mph(55) - controller.override_slc = True - - disabled_sm = make_sm(gas_pressed=False, enabled=False) - for _ in range(int(1.0 / DT_MDL) + 1): - controller.update_override(mph(75), 0.0, mph(65), 0.0, disabled_sm) - - assert controller.overridden_speed == 0 - assert not controller.override_slc - finally: - controller.shutdown() + helper.shutdown() diff --git a/selfdrive/controls/tests/test_starpilot_acceleration.py b/selfdrive/controls/tests/test_starpilot_acceleration.py index 93ba5e68c9..8e1af1463f 100644 --- a/selfdrive/controls/tests/test_starpilot_acceleration.py +++ b/selfdrive/controls/tests/test_starpilot_acceleration.py @@ -64,6 +64,7 @@ def make_sm(*, set_speed_kph=100.0, lead_one=None, lead_two=None, standstill=Fal "carState": SimpleNamespace(vCruise=set_speed_kph, standstill=standstill, vEgoCluster=v_ego_cluster), "carControl": SimpleNamespace(orientationNED=[0.0, pitch, 0.0]), "controlsState": SimpleNamespace(forceDecel=force_decel), + "selfdriveState": SimpleNamespace(personality=1), "radarState": SimpleNamespace( leadOne=lead_one or make_lead(), leadTwo=lead_two or make_lead(), diff --git a/selfdrive/controls/tests/test_starpilot_vcruise.py b/selfdrive/controls/tests/test_starpilot_vcruise.py index 3e69d620a2..a1c5dd2c57 100644 --- a/selfdrive/controls/tests/test_starpilot_vcruise.py +++ b/selfdrive/controls/tests/test_starpilot_vcruise.py @@ -2,6 +2,7 @@ import datetime import pytest +from cereal import custom from openpilot.common.constants import CV from openpilot.common.realtime import DT_MDL from openpilot.starpilot.common.starpilot_variables import PLANNER_TIME @@ -36,15 +37,26 @@ class FakeParams: def get_float(self, *args, **kwargs): return 0.0 + def get_bool(self, key): + return bool(self.values.get(key, False)) + + def remove(self, key): + self.values.pop(key, None) + def put_nonblocking(self, key, value): self.values[key] = value self.writes.append((key, value)) + def put_float(self, key, value): + self.values[key] = value + def make_vcruise(*, red_light=False, raw_model_stopped=False, forcing_stop=False, nav_state=None, road_curvature=0.0): planner = SimpleNamespace( params=FakeParams(), params_memory=FakeParams({"NavInstructionState": nav_state or {}}), + gps_position={}, + gps_valid=False, lead_one=SimpleNamespace(status=False, dRel=float("inf"), vLead=0.0), starpilot_cem=SimpleNamespace(stop_light_detected=red_light), starpilot_following=SimpleNamespace(following_lead=False), @@ -77,9 +89,14 @@ def make_sm(*, standstill=True, min_steer_speed=0.0, car_fingerprint=""): leftBlinker=False, rightBlinker=False, steeringAngleDeg=0.0, + vCruise=72.0, ), + "liveParameters": SimpleNamespace(angleOffsetDeg=0.0), + "mapdOut": SimpleNamespace(nextSpeedLimitDistance=0.0, nextSpeedLimit=0.0, speedLimit=0.0, + waySelectionType=custom.WaySelectionType.fail, roadName=""), + "selfdriveState": SimpleNamespace(enabled=True), "carParams": SimpleNamespace(minSteerSpeed=min_steer_speed, carFingerprint=car_fingerprint), - "starpilotCarState": SimpleNamespace(accelPressed=False, dashboardStopSign=0, dashboardSpeedLimit=0), + "starpilotCarState": SimpleNamespace(accelPressed=False, decelPressed=False, dashboardStopSign=0, dashboardSpeedLimit=0), "onroadEvents": [], } @@ -105,6 +122,27 @@ def make_toggles(): nav_longitudinal_allowed=False, speed_limit_controller=False, show_speed_limits=False, + is_metric=False, + map_speed_lookahead_higher=0.0, + map_speed_lookahead_lower=0.0, + slc_fallback_previous_speed_limit=False, + slc_fallback_set_speed=False, + slc_fallback_experimental_mode=False, + slc_mapbox_filler=False, + speed_limit_confirmation_higher=False, + speed_limit_confirmation_lower=False, + speed_limit_priority1="Dashboard", + speed_limit_priority2="Map Data", + speed_limit_priority_highest=False, + speed_limit_priority_lowest=False, + vision_speed_limit_detection=False, + speed_limit_offset1=0.0, + speed_limit_offset2=0.0, + speed_limit_offset3=0.0, + speed_limit_offset4=0.0, + speed_limit_offset5=0.0, + speed_limit_offset6=0.0, + speed_limit_offset7=0.0, force_stop_distance_offset=0, ) @@ -112,7 +150,6 @@ def make_toggles(): def test_active_slc_control_target_does_not_require_set_speed_limit(): target = get_active_slc_control_target( speed_limit_controller=True, - set_speed_limit=False, slc_target=45.0 * CV.MPH_TO_MS, slc_offset=3.0 * CV.MPH_TO_MS, overridden_speed=0.0, @@ -145,8 +182,7 @@ def test_active_slc_target_constrains_vcruise_below_csc_minimum(slc_target_mph, vcruise.slc.target = slc_target_mph * CV.MPH_TO_MS vcruise.slc.source = "Dashboard" - vcruise.slc.update_limits = lambda *_args, **_kwargs: None - vcruise.slc.update_override = lambda *_args, **_kwargs: None + vcruise.slc.update = lambda *_args, **_kwargs: None result = update_vcruise( vcruise, @@ -417,6 +453,8 @@ def test_csc_res_press_defers_to_slc_confirmation(): sm = make_sm(standstill=False) toggles = make_toggles() toggles.curve_speed_controller = True + toggles.speed_limit_controller = True + toggles.speed_limit_confirmation_higher = True def set_curve_target(_v_ego, _v_cruise): vcruise.csc.target = 14.0 @@ -426,10 +464,12 @@ def test_csc_res_press_defers_to_slc_confirmation(): assert vcruise.csc_controlling_speed - vcruise.slc.speed_limit_changed_timer = 1.0 - vcruise.slc.unconfirmed_speed_limit = 25.0 + # The candidate and accel press arrive together. SLC consumes the press in + # this frame, even though accepting immediately clears the pending state. + sm["starpilotCarState"].dashboardSpeedLimit = 45.0 * CV.MPH_TO_MS sm["starpilotCarState"].accelPressed = True update_vcruise(vcruise, sm, toggles, now=80.05, v_ego=20.0) + assert vcruise.slc.confirmation_button_consumed assert not vcruise.csc_override sm["starpilotCarState"].accelPressed = False @@ -622,7 +662,6 @@ def test_curve_speed_controller_hysteresis_keeps_glow_off_for_marginal_targets() def test_active_slc_control_target_applies_offset_and_cluster_diff(): target = get_active_slc_control_target( speed_limit_controller=True, - set_speed_limit=True, slc_target=45.0 * CV.MPH_TO_MS, slc_offset=3.0 * CV.MPH_TO_MS, overridden_speed=0.0, @@ -635,7 +674,6 @@ def test_active_slc_control_target_applies_offset_and_cluster_diff(): def test_active_slc_control_target_allows_lower_redneck_override(): target = get_active_slc_control_target( speed_limit_controller=True, - set_speed_limit=False, slc_target=65.0 * CV.MPH_TO_MS, slc_offset=0.0, overridden_speed=35.0 * CV.MPH_TO_MS, diff --git a/starpilot/common/starpilot_variables.py b/starpilot/common/starpilot_variables.py index 23d3cd3334..6c9e9d83b1 100644 --- a/starpilot/common/starpilot_variables.py +++ b/starpilot/common/starpilot_variables.py @@ -1461,6 +1461,8 @@ class StarPilotVariables: speed_limit_confirmation = self.get_value("SLCConfirmation", condition=toggle.speed_limit_controller) toggle.speed_limit_confirmation_higher = self.get_value("SLCConfirmationHigher", condition=speed_limit_confirmation) toggle.speed_limit_confirmation_lower = self.get_value("SLCConfirmationLower", condition=speed_limit_confirmation) + # Legacy setting is hidden in the current UI. SLC's pedal and +/- overrides + # remain available regardless of its saved value; keep loading it for compatibility. slc_override_method = self.get_value("SLCOverride", cast=float, condition=toggle.speed_limit_controller) toggle.speed_limit_controller_override_manual = slc_override_method == 1 toggle.speed_limit_controller_override_set_speed = slc_override_method == 2 diff --git a/starpilot/controls/lib/mapbox_speed_limit.py b/starpilot/controls/lib/mapbox_speed_limit.py new file mode 100644 index 0000000000..2e9d586030 --- /dev/null +++ b/starpilot/controls/lib/mapbox_speed_limit.py @@ -0,0 +1,130 @@ +import calendar +import json +from concurrent.futures import ThreadPoolExecutor + +import requests + +from openpilot.common.constants import CV +from openpilot.common.realtime import DT_MDL +from openpilot.starpilot.common.starpilot_utilities import calculate_bearing_offset, is_url_pingable + + +FREE_MAPBOX_REQUESTS = 100_000 + + +class MapboxSpeedLimit: + def __init__(self, params): + self.params = params + try: + self.requests = json.loads(params.get("MapBoxRequests", encoding="utf-8") or "{}") + except (TypeError, ValueError): + self.requests = {} + self.requests.setdefault("total_requests", 0) + self.requests.setdefault("max_requests", FREE_MAPBOX_REQUESTS - 28 * 100) + + self.host = "https://api.mapbox.com" + self.token = params.get("MapboxSecretKey", encoding="utf-8") + self.limit = 0.0 + self.segment_distance = 0.0 + self.future = None + self.executor = ThreadPoolExecutor(max_workers=1) + self.session = requests.Session() + self.session.headers.update({"Accept-Language": "en"}) + self.session.headers.update({"User-Agent": "starpilot-mapbox-speed-limit-retriever/1.0 (https://github.com/FrogAi/StarPilot)"}) + + def reset(self): + # A discarded future may still finish, but only update() can publish its result. + if self.future is not None: + self.future.cancel() + self.future = None + self.limit = 0.0 + self.segment_distance = 0.0 + + def shutdown(self): + self.reset() + self.executor.shutdown(wait=False, cancel_futures=True) + self.session.close() + + def _request(self, position, v_ego): + if not is_url_pingable(self.host): + return 0.0, v_ego + + self.requests["total_requests"] += 1 + self.params.put_nonblocking("MapBoxRequests", json.dumps(self.requests)) + + bearing = position.get("bearing") + latitude = position.get("latitude") + longitude = position.get("longitude") + future_latitude, future_longitude = calculate_bearing_offset(latitude, longitude, bearing, v_ego) + url = f"{self.host}/matching/v5/mapbox/driving/{longitude},{latitude};{future_longitude},{future_latitude}.json" + params = { + "access_token": self.token, + "annotations": "maxspeed,distance", + "geometries": "polyline6", + "overview": "full", + "steps": "false", + "radiuses": "10;10", + "tidy": "true", + } + response = self.session.get(url, params=params, timeout=10) + response.raise_for_status() + matchings = response.json().get("matchings") or [] + if not matchings: + return 0.0, v_ego + legs = (matchings[0] or {}).get("legs") or [] + if not legs: + return 0.0, v_ego + + annotation = legs[0].get("annotation") or {} + distances = annotation.get("distance") or [v_ego] + speeds = annotation.get("maxspeed") or [] + if not speeds: + return 0.0, v_ego + first = speeds[0] + try: + speed = float(first.get("speed")) if first.get("speed") != "none" else 0.0 + except (TypeError, ValueError): + speed = 0.0 + if speed <= 0: + return 0.0, v_ego + conversion = CV.MPH_TO_MS if first.get("unit", "km/h") == "mph" else CV.KPH_TO_MS + return speed * conversion, distances[0] + + def update(self, now, time_validated, v_ego, gps_valid, position, steering_angle, angle_offset): + if not gps_valid or not self.token or abs(steering_angle - angle_offset) >= 45: + self.reset() + return + + if time_validated and now.month != self.requests.get("month"): + self.requests.update({ + "month": now.month, + "total_requests": 0, + "max_requests": FREE_MAPBOX_REQUESTS - calendar.monthrange(now.year, now.month)[1] * 100, + }) + if self.requests["total_requests"] >= self.requests["max_requests"]: + self.reset() + return + + if self.future is not None: + if not self.future.done(): + return + future = self.future + self.future = None + try: + self.limit, self.segment_distance = future.result() + except Exception as exception: + print(f"Unexpected error in Mapbox request: {exception}") + self.limit, self.segment_distance = 0.0, v_ego + return + + if v_ego < 1: + return + if self.segment_distance > 0: + self.segment_distance -= v_ego * DT_MDL + return + + try: + self.future = self.executor.submit(self._request, dict(position), v_ego) + except RuntimeError: + self.segment_distance = v_ego + return diff --git a/starpilot/controls/lib/speed_limit_controller.py b/starpilot/controls/lib/speed_limit_controller.py index 312fb3bff8..7984af21dd 100644 --- a/starpilot/controls/lib/speed_limit_controller.py +++ b/starpilot/controls/lib/speed_limit_controller.py @@ -1,19 +1,19 @@ #!/usr/bin/env python3 # PFEIFER - SLC - Modified by FrogAi -import calendar -import json -import requests - -from concurrent.futures import ThreadPoolExecutor - from openpilot.common.constants import CV from openpilot.common.realtime import DT_MDL from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET from cereal import custom -from openpilot.starpilot.common.starpilot_utilities import calculate_bearing_offset, calculate_distance_to_point, is_url_pingable +from openpilot.starpilot.controls.lib.mapbox_speed_limit import MapboxSpeedLimit -FREE_MAPBOX_REQUESTS = 100_000 + +SOURCE_NONE = "None" +SOURCE_DASHBOARD = "Dashboard" +SOURCE_MAP = "Map Data" +SOURCE_VISION = "Vision" +SOURCE_MAPBOX = "Mapbox" +REAL_SOURCES = (SOURCE_DASHBOARD, SOURCE_MAP, SOURCE_VISION, SOURCE_MAPBOX) OFFSET_MAP_IMPERIAL = [ (0, 11.2, "speed_limit_offset1"), # 0–24 mph @@ -36,83 +36,76 @@ OFFSET_MAP_METRIC = [ ] SLC_OVERRIDE_DISABLE_CLEAR_TIME = 0.75 -# Minimum set-speed increase (m/s) counted as a deliberate +/- press. Below the smallest -# real step (1 km/h ≈ 0.28 m/s), above cluster/float jitter. -SET_SPEED_RAISE_EPS = 0.1 +SET_SPEED_CHANGE_TOLERANCE_METERS_PER_SECOND = 0.1 +SAME_LIMIT_TOLERANCE = 1.0 VISION_LARGE_REFERENCE_SPEED_DELTA = 30 * CV.MPH_TO_MS VISION_LARGE_SET_SPEED_MIN_SUPPORT = 3 VISION_SUPPORT_SPEED_TOLERANCE = 0.5 * CV.MPH_TO_MS + class SpeedLimitController: def __init__(self, StarPilotVCruise): self.starpilot_planner = StarPilotVCruise.starpilot_planner self.starpilot_toggles = None + self.mapbox = MapboxSpeedLimit(self.starpilot_planner.params) - self.calling_mapbox = False - self.override_slc = False - self.override_disable_timer = 0.0 - self._prev_v_cruise = None - self._persistent_override_speed = 0.0 - self._set_speed_override_input_consumed = False + self.source = SOURCE_NONE + self.target = 0.0 + self.map_speed_limit = 0.0 + self.next_speed_limit = 0.0 + self.vision_limit = 0.0 + self.overridden_speed = 0.0 - self.denied_target = 0 - self.map_speed_limit = 0 - self.mapbox_limit = 0 - self.next_speed_limit = 0 - self.overridden_speed = 0 - self.segment_distance = 0 - self.speed_limit_changed_timer = 0 - self.target = 0 - self.unconfirmed_speed_limit = 0 - self.vision_limit = 0 - - self.previous_source = "None" - self.source = "None" + self.last_valid_limit = max(self.starpilot_planner.params.get_float("PreviousSpeedLimit"), 0.0) + self.last_valid_source = SOURCE_NONE # The persisted number has no known live source. + self.pending_limit = 0.0 + self.pending_source = SOURCE_NONE + self.confirmation_time = 0.0 + self.denied_limit = 0.0 self.previous_road_name = "" - self._slc_adopt_counter = 0 - - mapbox_requests_raw = self.starpilot_planner.params.get("MapBoxRequests", encoding="utf-8") - try: - self.mapbox_requests = json.loads(mapbox_requests_raw or "{}") - except (TypeError, ValueError): - self.mapbox_requests = {} - self.mapbox_requests.setdefault("total_requests", 0) - self.mapbox_requests.setdefault("max_requests", FREE_MAPBOX_REQUESTS - (28 * 100)) - - self.mapbox_host = "https://api.mapbox.com" - self.mapbox_token = self.starpilot_planner.params.get("MapboxSecretKey", encoding="utf-8") - - self.previous_target = self.starpilot_planner.params.get_float("PreviousSpeedLimit") - self.last_valid_limit = self.previous_target if self.previous_target > 0 else 0 - - self.executor = ThreadPoolExecutor(max_workers=1) - self.mapbox_future = None - - self.session = requests.Session() - self.session.headers.update({"Accept-Language": "en"}) - self.session.headers.update({"User-Agent": "starpilot-mapbox-speed-limit-retriever/1.0 (https://github.com/FrogAi/StarPilot)"}) + self.set_speed_override = 0.0 + self.pedal_override = 0.0 + self.previous_set_speed = None + self.consume_set_speed_change = False + self.override_disable_time = 0.0 + self.limit_change_started = False + self.confirmation_button_consumed = False + self._active_control = False + self._using_experimental_fallback = False + self._mode = "off" def shutdown(self): - self.executor.shutdown(wait=False, cancel_futures=True) - self.session.close() + self.mapbox.shutdown() + + @property + def mapbox_limit(self): + return self.mapbox.limit + + @property + def confirmation_pending(self): + return self.pending_limit >= 1 + + @property + def unconfirmed_speed_limit(self): + return self.pending_limit @property def experimental_mode(self): - return self.target == 0 and bool(getattr(self.starpilot_toggles, "slc_fallback_experimental_mode", False)) + return self._active_control and self._using_experimental_fallback @property def target_to_use(self): - if self.source == "None" and self.target > 0 and self.last_valid_limit > 0: - if self.target >= self.last_valid_limit: - return self.last_valid_limit + # Keep Set Speed fallback from arming an override against a higher fake limit. + if self.source == SOURCE_NONE and self.target > 0 and self.last_valid_limit > 0: + return min(self.target, self.last_valid_limit) return self.target - def get_offset(self, target_speed): + def get_offset(self, limit): if self.starpilot_toggles is None: - return 0 + return 0.0 offset_map = OFFSET_MAP_METRIC if self.starpilot_toggles.is_metric else OFFSET_MAP_IMPERIAL - return next((getattr(self.starpilot_toggles, offset) for low, high, offset in offset_map if low <= target_speed < high), 0) + return next((getattr(self.starpilot_toggles, name) for low, high, name in offset_map if low <= limit < high), 0.0) @property def offset(self): @@ -124,458 +117,300 @@ class SpeedLimitController: 0 < limit <= max(getattr(self.starpilot_toggles, "vision_speed_limit_low_limit_threshold", 0), 0) ) - def _confirmation_required(self, desired_source, desired_target): - return desired_source != "None" and ( - (desired_target < self.target and self.starpilot_toggles.speed_limit_confirmation_lower) or - (desired_target > self.target and self.starpilot_toggles.speed_limit_confirmation_higher) - ) + def reset_control_state(self): + self._clear_pending() + self.clear_override() + self.previous_set_speed = None + self.consume_set_speed_change = False + self.override_disable_time = 0.0 + self.limit_change_started = False + self.confirmation_button_consumed = False + self._active_control = False + self._using_experimental_fallback = False + self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") + self.starpilot_planner.params_memory.remove("SLCAdoptSpeedLimit") - def clear_override(self): - self.override_slc = False - self.overridden_speed = 0 - self._persistent_override_speed = 0.0 + def _get_vision_limit(self, v_ego, sm, display_only): + enabled = getattr(self.starpilot_toggles, "vision_speed_limit_detection", False) + self.vision_limit = self.starpilot_planner.params_memory.get_float("VisionSpeedLimit") if enabled else 0.0 + limit = self.vision_limit + if not display_only and self.low_vision_limit_filtered(limit): + return 0.0 - def clear_persistent_override(self): - self._persistent_override_speed = 0.0 - - def clear_persistent_override_for_limit_change(self, previous_limit, new_limit): - if self._persistent_override_speed <= 0: - return - if previous_limit <= 0 or new_limit <= 0 or abs(new_limit - previous_limit) < 0.1: - return - - new_target_with_offset = new_limit + self.get_offset(new_limit) - if new_limit < previous_limit or self._persistent_override_speed <= new_target_with_offset: - self.clear_persistent_override() - - def get_mapbox_speed_limit(self, now, time_validated, v_ego, sm): - if not self.starpilot_planner.gps_valid or not self.mapbox_token or abs(sm["carState"].steeringAngleDeg - sm["liveParameters"].angleOffsetDeg) >= 45: - self.mapbox_limit = 0 - self.segment_distance = 0 - return - - if v_ego < 1: - return - - if self.segment_distance > 0: - self.segment_distance -= v_ego * DT_MDL - return - - if self.calling_mapbox: - self.segment_distance = v_ego - return - - def make_request(): - successful = False - response_data = None - try: - if not is_url_pingable(self.mapbox_host): - self.segment_distance = 1000 - successful = True - return None - - if time_validated: - current_month = now.month - if current_month != self.mapbox_requests.get("month"): - self.mapbox_requests.update({ - "month": current_month, - "total_requests": 0, - "max_requests": FREE_MAPBOX_REQUESTS - calendar.monthrange(now.year, current_month)[1] * 100, - }) - - self.mapbox_requests["total_requests"] += 1 - self.starpilot_planner.params.put_nonblocking("MapBoxRequests", json.dumps(self.mapbox_requests)) - - current_bearing = self.starpilot_planner.gps_position.get("bearing") - current_latitude = self.starpilot_planner.gps_position.get("latitude") - current_longitude = self.starpilot_planner.gps_position.get("longitude") - - future_latitude, future_longitude = calculate_bearing_offset(current_latitude, current_longitude, current_bearing, v_ego) - - url = ( - f"{self.mapbox_host}/matching/v5/mapbox/driving/" - f"{current_longitude},{current_latitude};" - f"{future_longitude},{future_latitude}.json" - ) - - mapbox_params = { - "access_token": self.mapbox_token, - "annotations": "maxspeed,distance", - "geometries": "polyline6", - "overview": "full", - "steps": "false", - "radiuses": "10;10", - "tidy": "true", - } - - response = self.session.get(url, params=mapbox_params, timeout=10) - response.raise_for_status() - - successful = True - response_data = response.json() - except Exception as exception: - print(f"Unexpected error in Mapbox request: {exception}") - finally: - self.calling_mapbox = False - - if not successful: - self.mapbox_limit = 0 - self.segment_distance = v_ego - return response_data - - def complete_request(future): - try: - data = future.result() - if data: - matchings = data.get("matchings") or [] - if not matchings: - self.mapbox_limit = 0 - self.segment_distance = v_ego - return - - legs = (matchings[0] or {}).get("legs") or [] - if not legs: - self.mapbox_limit = 0 - self.segment_distance = v_ego - return - - annotation = legs[0].get("annotation") or {} - - distances = annotation.get("distance") or [v_ego] - segment_distance = distances[0] - - speed_data = annotation.get("maxspeed", []) - if speed_data: - first_segment_speed = speed_data[0] - try: - raw_speed = float(first_segment_speed.get("speed") if first_segment_speed.get("speed") != "none" else 0.0) - except (ValueError, TypeError): - raw_speed = 0.0 - unit = first_segment_speed.get("unit", "km/h") - if raw_speed > 0: - if unit == "mph": - self.mapbox_limit = raw_speed * CV.MPH_TO_MS - else: - self.mapbox_limit = raw_speed * CV.KPH_TO_MS - self.segment_distance = segment_distance - return - - self.mapbox_limit = 0 - self.segment_distance = v_ego - - except Exception as exception: - print(f"Mapbox Callback Error: {exception}") - self.mapbox_limit = 0 - self.segment_distance = v_ego - finally: - self.mapbox_future = None - - self.calling_mapbox = True - try: - future = self.executor.submit(make_request) - except RuntimeError: - self.calling_mapbox = False - self.segment_distance = v_ego - return - - self.mapbox_future = future - future.add_done_callback(complete_request) - - def handle_limit_change(self, desired_source, desired_target, current_road_name, v_ego, sm): - self.speed_limit_changed_timer += DT_MDL - previous_limit = self.last_valid_limit if self.last_valid_limit > 0 else self.target - - long_active = sm["carControl"].longActive - accepted_by_accel_button = sm["starpilotCarState"].accelPressed and long_active - confirmation_required = self._confirmation_required(desired_source, desired_target) - higher_confirmation = confirmation_required and desired_target > self.target - speed_limit_accepted = confirmation_required and accepted_by_accel_button - if confirmation_required and not speed_limit_accepted and self._slc_adopt_counter % 4 == 0: - speed_limit_accepted = self.starpilot_planner.params_memory.get_bool("SpeedLimitAccepted") - if not confirmation_required: - self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") - self.unconfirmed_speed_limit = 0 - speed_limit_denied = confirmation_required and ( - sm["starpilotCarState"].decelPressed or (self.speed_limit_changed_timer >= 30 and long_active) - ) - - if not long_active and not sm["selfdriveState"].enabled: - speed_limit_accepted = True - - if speed_limit_accepted: - self.source = desired_source - self.target = desired_target - self.clear_persistent_override_for_limit_change(previous_limit, desired_target) - set_speed_kph = float(sm["carState"].vCruise) - target_with_offset = self.target + self.offset - if ( - higher_confirmation - and long_active - and 0 < set_speed_kph < V_CRUISE_UNSET - and set_speed_kph * CV.KPH_TO_MS < target_with_offset - ): - self.starpilot_planner.params_memory.put_float("SLCForceCruiseSpeed", target_with_offset) - if accepted_by_accel_button and confirmation_required: - self._set_speed_override_input_consumed = True - - self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") - - elif speed_limit_denied: - self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") - self.denied_target = desired_target - - self.previous_source = desired_source - self.previous_target = desired_target - self.previous_road_name = current_road_name - - elif desired_target != self.target and not confirmation_required: - self.source = desired_source - self.target = desired_target - self.clear_persistent_override_for_limit_change(previous_limit, desired_target) - - elif desired_target == self.target: - self.source = desired_source - self.target = desired_target - - else: - self.source = "None" - self.unconfirmed_speed_limit = desired_target - - if (self.target != self.previous_target or self.previous_road_name != current_road_name) and self.target > 0 and not speed_limit_denied: - self.denied_target = 0 - - self.previous_source = self.source - self.previous_target = self.target - self.previous_road_name = current_road_name - - self.starpilot_planner.params.put_nonblocking("PreviousSpeedLimit", float(self.target)) - - def update_limits(self, dashboard_speed_limit, now, time_validated, v_cruise, v_ego, sm, display_only=False): - self.update_map_speed_limit(v_ego, sm) - vision_enabled = getattr(self.starpilot_toggles, "vision_speed_limit_detection", False) - self.vision_limit = self.starpilot_planner.params_memory.get_float("VisionSpeedLimit") if vision_enabled else 0 - usable_vision_limit = self.vision_limit - if not display_only and self.low_vision_limit_filtered(usable_vision_limit): - usable_vision_limit = 0 - # The planner clamps V_CRUISE_UNSET to V_CRUISE_MAX, so plausibility must use the raw selected speed. raw_set_speed_kph = float(sm["carState"].vCruise) - selected_set_speed = raw_set_speed_kph * CV.KPH_TO_MS if 0 < raw_set_speed_kph < V_CRUISE_UNSET else 0 - reference_speed = selected_set_speed if selected_set_speed > 0 else max(float(v_ego), 0) - # vEgo jitters around zero at standstill; do not let that switch the active source. - if ( - usable_vision_limit > 0 and reference_speed > 0 and not sm["carState"].standstill and - abs(usable_vision_limit - reference_speed) >= VISION_LARGE_REFERENCE_SPEED_DELTA - ): - support_count = self.starpilot_planner.params_memory.get_int("VisionSpeedLimitSupportCount") - support_speed = self.starpilot_planner.params_memory.get_float("VisionSpeedLimitSupportSpeed") - if support_count < VISION_LARGE_SET_SPEED_MIN_SUPPORT or abs(support_speed - usable_vision_limit) > VISION_SUPPORT_SPEED_TOLERANCE: - usable_vision_limit = 0 + selected_speed = raw_set_speed_kph * CV.KPH_TO_MS if 0 < raw_set_speed_kph < V_CRUISE_UNSET else 0.0 + reference_speed = selected_speed if selected_speed > 0 else max(float(v_ego), 0.0) + if (limit > 0 and reference_speed > 0 and not sm["carState"].standstill and + abs(limit - reference_speed) >= VISION_LARGE_REFERENCE_SPEED_DELTA): + memory = self.starpilot_planner.params_memory + count = memory.get_int("VisionSpeedLimitSupportCount") + support_speed = memory.get_float("VisionSpeedLimitSupportSpeed") + if count < VISION_LARGE_SET_SPEED_MIN_SUPPORT or abs(support_speed - limit) > VISION_SUPPORT_SPEED_TOLERANCE: + return 0.0 + return limit - configured_priorities = { - self.starpilot_toggles.speed_limit_priority1, - self.starpilot_toggles.speed_limit_priority2, - } - limits = { - "Dashboard": dashboard_speed_limit, - "Map Data": self.map_speed_limit, - } - if "Vision" in configured_priorities: - limits["Vision"] = usable_vision_limit - filtered_limits = {source: limit for source, limit in limits.items() if limit >= 1} - - if self.starpilot_toggles.speed_limit_priority_highest: - desired_source = max(filtered_limits, key=filtered_limits.get, default="None") - desired_target = filtered_limits.get(desired_source, 0) - - elif self.starpilot_toggles.speed_limit_priority_lowest: - desired_source = min(filtered_limits, key=filtered_limits.get, default="None") - desired_target = filtered_limits.get(desired_source, 0) - - elif filtered_limits: - for priority in [ - self.starpilot_toggles.speed_limit_priority1, - self.starpilot_toggles.speed_limit_priority2 - ]: - if priority in filtered_limits: - desired_source = priority - desired_target = filtered_limits[desired_source] - break - else: - desired_source = "None" - desired_target = 0 - - else: - desired_source = "None" - desired_target = 0 - - if desired_target == 0: - if self.mapbox_requests["total_requests"] < self.mapbox_requests["max_requests"] and self.starpilot_toggles.slc_mapbox_filler: - self.get_mapbox_speed_limit(now, time_validated, v_ego, sm) - - if self.mapbox_limit >= 1: - desired_source = "Mapbox" - desired_target = self.mapbox_limit - - if not display_only and desired_target == 0: - previous_vision_limit_filtered = self.previous_source == "Vision" and self.low_vision_limit_filtered(self.previous_target) - if self.previous_target > 0 and self.starpilot_toggles.slc_fallback_previous_speed_limit and not previous_vision_limit_filtered: - desired_source = self.previous_source - desired_target = self.previous_target - - self.target = desired_target - - elif sm["selfdriveState"].enabled and self.starpilot_toggles.slc_fallback_set_speed: - desired_source = "None" - desired_target = v_cruise - else: - self.mapbox_limit = 0 - self.segment_distance = 0 - - if display_only: - self.speed_limit_changed_timer = 0 - self.unconfirmed_speed_limit = 0 - self.clear_override() - - if desired_target >= 1: - self.source = desired_source - self.target = desired_target - else: - self.source = "None" - self.target = 0 - - return - - current_road_name = sm["mapdOut"].roadName if desired_source == "Map Data" else "" - current_speed = self.target if (self.source != "None" and self.target > 0) else self.last_valid_limit - - # Do not trigger alerts when shifting to fallback or when re-obtaining the same speed limit - is_fallback = desired_source == "None" or desired_target == 0 - same_speed = desired_target > 0 and current_speed > 0 and abs(desired_target - current_speed) < 1 - confirmation_required = self._confirmation_required(desired_source, desired_target) - denied_same_limit = ( - confirmation_required and self.denied_target > 0 and - abs(desired_target - self.denied_target) < 1 - ) - - if not denied_same_limit: - self.denied_target = 0 - - if denied_same_limit: - self.speed_limit_changed_timer = 0 - self.unconfirmed_speed_limit = 0 - elif not is_fallback and not same_speed and (abs(desired_target - self.previous_target) >= 1 or current_speed == 0): - self.handle_limit_change(desired_source, desired_target, current_road_name, v_ego, sm) - else: - self.speed_limit_changed_timer = 0 - self.unconfirmed_speed_limit = 0 - if desired_source != self.source or desired_target != self.target: - if not is_fallback: - self.clear_persistent_override_for_limit_change(current_speed, desired_target) - self.source = desired_source - self.target = desired_target - if desired_source != "None" and desired_target > 0: - self.previous_source = desired_source - self.previous_target = desired_target - if current_road_name != self.previous_road_name and current_road_name != "": - self.previous_road_name = current_road_name - self.denied_target = 0 - - if self.source != "None" and self.target > 0: - self.last_valid_limit = self.target - - self._slc_adopt_counter += 1 - if self._slc_adopt_counter % 4 == 0 and self.starpilot_planner.params_memory.get_bool("SLCAdoptSpeedLimit"): - self.starpilot_planner.params_memory.remove("SLCAdoptSpeedLimit") - if desired_target > 0: - self.clear_override() - self.denied_target = 0 - self.source = desired_source - self.target = desired_target - self.previous_source = desired_source - self.previous_target = desired_target - self.speed_limit_changed_timer = 0 - self.unconfirmed_speed_limit = 0 - self.starpilot_planner.params.put_nonblocking("PreviousSpeedLimit", float(self.target)) - self.starpilot_planner.params_memory.put_float("SLCForceCruiseSpeed", self.target + self.offset) - - def update_map_speed_limit(self, v_ego, sm): - next_speed_limit_distance = sm["mapdOut"].nextSpeedLimitDistance - - way_sel = sm["mapdOut"].waySelectionType - if way_sel in (custom.WaySelectionType.current, - custom.WaySelectionType.extended): - self.map_speed_limit = sm["mapdOut"].speedLimit - self.next_speed_limit = sm["mapdOut"].nextSpeedLimit - elif way_sel in (custom.WaySelectionType.predicted, - custom.WaySelectionType.possible): - speed = sm["mapdOut"].speedLimit + def _update_map_speed_limit(self, v_ego, sm): + map_data = sm["mapdOut"] + way_sel = map_data.waySelectionType + if way_sel in (custom.WaySelectionType.current, custom.WaySelectionType.extended): + self.map_speed_limit = map_data.speedLimit + self.next_speed_limit = map_data.nextSpeedLimit + elif way_sel in (custom.WaySelectionType.predicted, custom.WaySelectionType.possible): + speed = map_data.speedLimit if speed > 0 and (self.map_speed_limit == 0 or speed < self.map_speed_limit): self.map_speed_limit = speed - self.next_speed_limit = 0 + self.next_speed_limit = 0.0 else: - self.next_speed_limit = 0 + # Explicit selection failure means the old current limit is no longer live. + self.map_speed_limit = 0.0 + self.next_speed_limit = 0.0 if self.next_speed_limit > 0: if self.map_speed_limit < self.next_speed_limit: - max_lookahead = self.starpilot_toggles.map_speed_lookahead_higher * v_ego + lookahead = self.starpilot_toggles.map_speed_lookahead_higher * v_ego elif self.map_speed_limit > self.next_speed_limit: - max_lookahead = self.starpilot_toggles.map_speed_lookahead_lower * v_ego + lookahead = self.starpilot_toggles.map_speed_lookahead_lower * v_ego else: - max_lookahead = 0 - - if next_speed_limit_distance < max_lookahead: + lookahead = 0.0 + if map_data.nextSpeedLimitDistance < lookahead: self.map_speed_limit = self.next_speed_limit - def update_override(self, v_cruise, v_cruise_diff, v_ego, v_ego_diff, sm): - # Detect +/- changes on the raw set speed (button-driven, no cluster jitter). A fresh edge - # keeps a cleared override from re-arming while the selected speed stays high. - prev_v_cruise = self._prev_v_cruise - self._prev_v_cruise = v_cruise - set_speed_changed = prev_v_cruise is not None and abs(v_cruise - prev_v_cruise) > SET_SPEED_RAISE_EPS - set_speed_raised = prev_v_cruise is not None and v_cruise > prev_v_cruise + SET_SPEED_RAISE_EPS - set_speed_input_consumed = self._set_speed_override_input_consumed - # The button and its vCruise update can arrive in adjacent frames. Clear a consumed - # confirmation only after this frame has seen the speed change or button release. - if set_speed_input_consumed and (set_speed_changed or not sm["starpilotCarState"].accelPressed): - self._set_speed_override_input_consumed = False + def _select_limit(self, dashboard, map_limit, vision_limit): + priorities = (self.starpilot_toggles.speed_limit_priority1, self.starpilot_toggles.speed_limit_priority2) + limits = {SOURCE_DASHBOARD: dashboard, SOURCE_MAP: map_limit} + if SOURCE_VISION in priorities: + limits[SOURCE_VISION] = vision_limit + valid = {source: limit for source, limit in limits.items() if limit >= 1} + if not valid: + return SOURCE_NONE, 0.0 + if self.starpilot_toggles.speed_limit_priority_highest: + source = max(valid, key=valid.get) + elif self.starpilot_toggles.speed_limit_priority_lowest: + source = min(valid, key=valid.get) + else: + source = next((name for name in priorities if name in valid), SOURCE_NONE) + return source, valid.get(source, 0.0) - if not sm["selfdriveState"].enabled: - self.override_disable_timer += DT_MDL - if self.override_disable_timer >= SLC_OVERRIDE_DISABLE_CLEAR_TIME: - self.clear_override() + def _apply_mapbox_filler(self, source, limit, now, time_validated, v_ego, sm): + if source != SOURCE_NONE or not self.starpilot_toggles.slc_mapbox_filler: + self.mapbox.reset() + return source, limit + self.mapbox.update( + now, time_validated, v_ego, self.starpilot_planner.gps_valid, self.starpilot_planner.gps_position, + sm["carState"].steeringAngleDeg, sm["liveParameters"].angleOffsetDeg, + ) + if self.mapbox.limit >= 1: + return SOURCE_MAPBOX, self.mapbox.limit + return source, limit + + def _apply_fallback(self, v_cruise, enabled): + self._using_experimental_fallback = False + previous_vision_filtered = self.last_valid_source == SOURCE_VISION and self.low_vision_limit_filtered(self.last_valid_limit) + if self.starpilot_toggles.slc_fallback_previous_speed_limit and self.last_valid_limit > 0 and not previous_vision_filtered: + self.source = self.last_valid_source + self.target = self.last_valid_limit + elif enabled and self.starpilot_toggles.slc_fallback_set_speed: + self.source = SOURCE_NONE + self.target = v_cruise + else: + self.source = SOURCE_NONE + self.target = 0.0 + self._using_experimental_fallback = bool(self.starpilot_toggles.slc_fallback_experimental_mode) + + def _confirmation_required(self, limit): + current = self.last_valid_limit + return ((limit < current and self.starpilot_toggles.speed_limit_confirmation_lower) or + (limit > current and self.starpilot_toggles.speed_limit_confirmation_higher)) + + def _clear_pending(self): + self.pending_limit = 0.0 + self.pending_source = SOURCE_NONE + self.confirmation_time = 0.0 + + def _reconcile_set_speed_override(self, old_limit, new_limit): + if self.set_speed_override <= 0 or old_limit <= 0 or new_limit <= 0 or abs(new_limit - old_limit) < 0.1: + return + if (new_limit < old_limit or + self.set_speed_override <= new_limit + self.get_offset(new_limit) + SET_SPEED_CHANGE_TOLERANCE_METERS_PER_SECOND): + self.set_speed_override = 0.0 + self.overridden_speed = self.pedal_override + + def _accept_limit(self, source, limit, *, persist=True): + assert source in REAL_SOURCES and limit >= 1 + old_limit = self.last_valid_limit + self._reconcile_set_speed_override(old_limit, limit) + self.source = source + self.target = limit + self.last_valid_limit = limit + self.last_valid_source = source + self.denied_limit = 0.0 + self._clear_pending() + if persist and abs(limit - old_limit) >= 0.1: + self.starpilot_planner.params.put_nonblocking("PreviousSpeedLimit", float(limit)) + + def _reject_limit(self, limit): + self.denied_limit = limit + self.source = SOURCE_NONE + self._clear_pending() + self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") + + def _update_limit(self, source, limit, sm): + road_name = sm["mapdOut"].roadName if source == SOURCE_MAP else "" + if road_name and road_name != self.previous_road_name: + self.denied_limit = 0.0 + self.previous_road_name = road_name + + if source == SOURCE_NONE: + self._clear_pending() + self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") return - self.override_disable_timer = 0.0 + current = self.last_valid_limit + if current > 0 and abs(limit - current) < SAME_LIMIT_TOLERANCE: + self._accept_limit(source, limit, persist=False) + self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") + return - target_to_use = self.target_to_use - target_with_offset = target_to_use + self.get_offset(target_to_use) + confirmation_required = self._confirmation_required(limit) + if self.denied_limit > 0 and abs(limit - self.denied_limit) < SAME_LIMIT_TOLERANCE: + if confirmation_required: + self._clear_pending() + self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") + self.source = SOURCE_NONE + return + # Turning confirmation off applies the already-announced candidate. + self._accept_limit(source, limit) + self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") + return + self.denied_limit = 0.0 - set_speed = v_cruise + v_cruise_diff - bidirectional_set_speed = getattr(self.starpilot_toggles, "redneck_cruise", False) - - if self._persistent_override_speed > 0: - if bidirectional_set_speed: - if set_speed <= 0: - self.clear_persistent_override() - else: - self._persistent_override_speed = set_speed - elif set_speed <= 0 or (target_with_offset > 0 and set_speed <= target_with_offset and (self.source != "None" or set_speed_changed)): - self.clear_persistent_override() - else: - self._persistent_override_speed = set_speed - elif ( - target_with_offset > 0 - and set_speed > 0 - and not set_speed_input_consumed - and ((bidirectional_set_speed and set_speed_changed) or (not bidirectional_set_speed and set_speed_raised and set_speed > target_with_offset)) - ): - self._persistent_override_speed = set_speed - - if sm["carState"].gasPressed and v_ego > target_with_offset > 0: - self.override_slc = True - self.overridden_speed = v_ego + v_ego_diff - elif self._persistent_override_speed > 0: - self.override_slc = True - self.overridden_speed = self._persistent_override_speed + if self.pending_limit == 0 or abs(limit - self.pending_limit) >= SAME_LIMIT_TOLERANCE: + self.pending_limit = limit + self.pending_source = source + self.confirmation_time = 0.0 + self.limit_change_started = True + new_pending = True else: - self.clear_override() + self.pending_source = source + new_pending = False + + if not confirmation_required: + self._accept_limit(source, limit) + self.starpilot_planner.params_memory.remove("SpeedLimitAccepted") + return + + self.source = SOURCE_NONE + self.confirmation_time += DT_MDL + long_active = sm["carControl"].longActive + accel_accept = bool(sm["starpilotCarState"].accelPressed and long_active) + if new_pending and accel_accept: + # This press cannot confirm a candidate that was replaced on this frame. + self.confirmation_button_consumed = True + self.consume_set_speed_change = True + memory = self.starpilot_planner.params_memory + ui_accept = memory.get_bool("SpeedLimitAccepted") + if ui_accept: + memory.remove("SpeedLimitAccepted") + + fully_disengaged = not long_active and not sm["selfdriveState"].enabled + if ((accel_accept or ui_accept) and not new_pending) or fully_disengaged: + pending_limit, pending_source = self.pending_limit, self.pending_source + higher = pending_limit > current + self._accept_limit(pending_source, pending_limit) + if accel_accept: + self.consume_set_speed_change = True + self.confirmation_button_consumed = True + set_speed_kph = float(sm["carState"].vCruise) + target_with_offset = self.target + self.offset + if (higher and long_active and 0 < set_speed_kph < V_CRUISE_UNSET and + set_speed_kph * CV.KPH_TO_MS < target_with_offset): + memory.put_float("SLCForceCruiseSpeed", target_with_offset) + elif sm["starpilotCarState"].decelPressed or (self.confirmation_time >= 30 and long_active): + self._reject_limit(self.pending_limit) + + def _process_adopt_request(self, source, limit): + memory = self.starpilot_planner.params_memory + if not memory.get_bool("SLCAdoptSpeedLimit"): + return + memory.remove("SLCAdoptSpeedLimit") + if source not in REAL_SOURCES or limit < 1: + return + self.clear_override() + self.consume_set_speed_change = True + self._accept_limit(source, limit) + memory.put_float("SLCForceCruiseSpeed", self.target + self.offset) + + def clear_override(self): + self.set_speed_override = 0.0 + self.pedal_override = 0.0 + self.overridden_speed = 0.0 + + def _update_override(self, v_cruise, v_cruise_diff, v_ego, v_ego_diff, sm): + previous = self.previous_set_speed + self.previous_set_speed = v_cruise + changed = previous is not None and abs(v_cruise - previous) > SET_SPEED_CHANGE_TOLERANCE_METERS_PER_SECOND + raised = previous is not None and v_cruise > previous + SET_SPEED_CHANGE_TOLERANCE_METERS_PER_SECOND + consumed = self.consume_set_speed_change + if consumed and (changed or not sm["starpilotCarState"].accelPressed): + self.consume_set_speed_change = False + + if not sm["selfdriveState"].enabled: + self.override_disable_time += DT_MDL + if self.override_disable_time >= SLC_OVERRIDE_DISABLE_CLEAR_TIME: + self.clear_override() + return + self.override_disable_time = 0.0 + + target = self.target_to_use + target_with_offset = target + self.get_offset(target) + set_speed = v_cruise + v_cruise_diff + bidirectional = getattr(self.starpilot_toggles, "redneck_cruise", False) + if self.set_speed_override > 0: + if bidirectional: + self.set_speed_override = max(set_speed, 0.0) + elif set_speed <= 0 or (target_with_offset > 0 and set_speed <= target_with_offset and + (self.source != SOURCE_NONE or changed)): + self.set_speed_override = 0.0 + else: + self.set_speed_override = set_speed + elif (target_with_offset > 0 and set_speed > 0 and not consumed and + ((bidirectional and changed) or (not bidirectional and raised and set_speed > target_with_offset))): + self.set_speed_override = set_speed + + self.pedal_override = v_ego + v_ego_diff if sm["carState"].gasPressed and v_ego > target_with_offset > 0 else 0.0 + self.overridden_speed = self.pedal_override or self.set_speed_override + + def update(self, dashboard_speed_limit, now, time_validated, v_cruise, v_cruise_diff, v_ego, v_ego_diff, sm, + *, active=True, display_only=False): + self.limit_change_started = False + self.confirmation_button_consumed = False + self._using_experimental_fallback = False + mode = "display" if display_only else "active" if active else "off" + if mode != self._mode: + self.mapbox.reset() + self._mode = mode + if not active and not display_only: + self.reset_control_state() + self.mapbox.reset() + self.source, self.target = SOURCE_NONE, 0.0 + self.map_speed_limit = self.next_speed_limit = self.vision_limit = 0.0 + return + + self._update_map_speed_limit(v_ego, sm) + vision_limit = self._get_vision_limit(v_ego, sm, display_only) + source, limit = self._select_limit(dashboard_speed_limit, self.map_speed_limit, vision_limit) + source, limit = self._apply_mapbox_filler(source, limit, now, time_validated, v_ego, sm) + + if display_only: + self.reset_control_state() + self.source, self.target = (source, limit) if limit >= 1 else (SOURCE_NONE, 0.0) + return + + self._active_control = True + if source == SOURCE_NONE: + self._update_limit(source, limit, sm) + self._apply_fallback(v_cruise, sm["selfdriveState"].enabled) + else: + self._update_limit(source, limit, sm) + self._process_adopt_request(source, limit) + self._update_override(v_cruise, v_cruise_diff, v_ego, v_ego_diff, sm) diff --git a/starpilot/controls/lib/starpilot_acceleration.py b/starpilot/controls/lib/starpilot_acceleration.py index 6e0e963eb4..99549a7c65 100644 --- a/starpilot/controls/lib/starpilot_acceleration.py +++ b/starpilot/controls/lib/starpilot_acceleration.py @@ -216,7 +216,6 @@ class StarPilotAcceleration: effective_slc_target = get_active_slc_control_target( getattr(starpilot_toggles, "speed_limit_controller", False), - getattr(starpilot_toggles, "set_speed_limit", False), getattr(self.starpilot_planner.starpilot_vcruise, "slc_target", 0.0), getattr(self.starpilot_planner.starpilot_vcruise, "slc_offset", 0.0), getattr(getattr(self.starpilot_planner.starpilot_vcruise, "slc", None), "overridden_speed", 0.0), @@ -271,7 +270,6 @@ class StarPilotAcceleration: v_ego_diff = v_ego_cluster - v_ego effective_slc_target = get_active_slc_control_target( getattr(starpilot_toggles, "speed_limit_controller", False), - getattr(starpilot_toggles, "set_speed_limit", False), getattr(self.starpilot_planner.starpilot_vcruise, "slc_target", 0.0), getattr(self.starpilot_planner.starpilot_vcruise, "slc_offset", 0.0), getattr(getattr(self.starpilot_planner.starpilot_vcruise, "slc", None), "overridden_speed", 0.0), @@ -312,7 +310,6 @@ class StarPilotAcceleration: v_ego_cluster = v_ego effective_slc_target = get_active_slc_control_target( getattr(starpilot_toggles, "speed_limit_controller", False), - getattr(starpilot_toggles, "set_speed_limit", False), getattr(self.starpilot_planner.starpilot_vcruise, "slc_target", 0.0), getattr(self.starpilot_planner.starpilot_vcruise, "slc_offset", 0.0), getattr(getattr(self.starpilot_planner.starpilot_vcruise, "slc", None), "overridden_speed", 0.0), diff --git a/starpilot/controls/lib/starpilot_events.py b/starpilot/controls/lib/starpilot_events.py index 37a826250a..b0ffe6a7f8 100644 --- a/starpilot/controls/lib/starpilot_events.py +++ b/starpilot/controls/lib/starpilot_events.py @@ -189,7 +189,7 @@ class StarPilotEvents: else: self.events.add(StarPilotEventName.openpilotCrashed) - if self.starpilot_planner.starpilot_vcruise.slc.speed_limit_changed_timer == DT_MDL and starpilot_toggles.speed_limit_changed_alert: + if self.starpilot_planner.starpilot_vcruise.slc.limit_change_started and starpilot_toggles.speed_limit_changed_alert: self.events.add(StarPilotEventName.speedLimitChanged) self.startup_seen |= sm["starpilotSelfdriveState"].alertText1 == starpilot_toggles.startup_alert_top and sm["starpilotSelfdriveState"].alertText2 == starpilot_toggles.startup_alert_bottom diff --git a/starpilot/controls/lib/starpilot_vcruise.py b/starpilot/controls/lib/starpilot_vcruise.py index 7b3a39d52e..758c69215e 100644 --- a/starpilot/controls/lib/starpilot_vcruise.py +++ b/starpilot/controls/lib/starpilot_vcruise.py @@ -105,10 +105,9 @@ def get_lead_veto_distance(car_params): return LEAD_VETO_M_OVERRIDES.get(fingerprint, LEAD_VETO_M) -def get_active_slc_control_target(speed_limit_controller, set_speed_limit, slc_target, slc_offset, overridden_speed, +def get_active_slc_control_target(speed_limit_controller, slc_target, slc_offset, overridden_speed, v_ego_diff, allow_lower_override=False): - # `SetSpeedLimit` only controls engage-time set-speed initialization. Ongoing - # SLC speed matching must remain active whenever Speed Limit Controller is on. + # SetSpeedLimit controls engage-time initialization; SLC limits ongoing cruise. if not speed_limit_controller: return 0.0 @@ -568,6 +567,18 @@ class StarPilotVCruise: v_ego_cluster = max(sm["carState"].vEgoCluster, v_ego) v_ego_diff = v_ego_cluster - v_ego + # Resolve this frame's SLC confirmation before CSC can consume accel/+. + self.slc.starpilot_toggles = starpilot_toggles + slc_active = starpilot_toggles.speed_limit_controller + slc_display_only = not slc_active and starpilot_toggles.show_speed_limits + self.slc.update( + sm["starpilotCarState"].dashboardSpeedLimit, now, time_validated, + v_cruise, v_cruise_diff, v_ego, v_ego_diff, sm, + active=slc_active, display_only=slc_display_only, + ) + self.slc_offset = self.slc.offset if slc_active else 0 + self.slc_target = self.slc.target if (slc_active or slc_display_only) else 0 + # Curve Speed Controller following_lead = bool(getattr(self.starpilot_planner.starpilot_following, "following_lead", False)) manual_speed_control = is_manual_speed_control(sm) @@ -586,8 +597,9 @@ class StarPilotVCruise: not self.starpilot_planner.driving_in_curve) csc_was_controlling = self.csc_controlling_speed - slc_confirmation_pending = self.slc.speed_limit_changed_timer > DT_MDL and self.slc.unconfirmed_speed_limit >= 1 - csc_accel_button = bool(sm["starpilotCarState"].accelPressed) and not slc_confirmation_pending + csc_accel_button = (bool(sm["starpilotCarState"].accelPressed) and + not self.slc.confirmation_pending and + not self.slc.confirmation_button_consumed) @@ -637,24 +649,6 @@ class StarPilotVCruise: self.csc.handle_override(v_ego, csc_was_controlling, sm, accel_button=csc_accel_button) self.csc.log_data(v_ego, sm) - # Pfeiferj's Speed Limit Controller - self.slc.starpilot_toggles = starpilot_toggles - - if starpilot_toggles.speed_limit_controller: - self.slc.update_limits(sm["starpilotCarState"].dashboardSpeedLimit, now, time_validated, v_cruise, v_ego, sm) - self.slc.update_override(v_cruise, v_cruise_diff, v_ego, v_ego_diff, sm) - - self.slc_offset = self.slc.offset - self.slc_target = self.slc.target - elif starpilot_toggles.show_speed_limits: - self.slc.update_limits(sm["starpilotCarState"].dashboardSpeedLimit, now, time_validated, v_cruise, v_ego, sm, display_only=True) - - self.slc_offset = 0 - self.slc_target = self.slc.target - else: - self.slc_offset = 0 - self.slc_target = 0 - self.nav_turn_target = self._get_nav_turn_control_target(v_cruise, sm, starpilot_toggles) # Single tuning knob (signed feet -> meters). Defense clamp on top of UI bounds. @@ -750,7 +744,6 @@ class StarPilotVCruise: targets.append(self.csc_target) slc_control_target = get_active_slc_control_target( starpilot_toggles.speed_limit_controller, - getattr(starpilot_toggles, "set_speed_limit", False), self.slc_target, self.slc_offset, self.slc.overridden_speed, diff --git a/starpilot/controls/starpilot_card.py b/starpilot/controls/starpilot_card.py index 8a3d921a53..a05490f675 100644 --- a/starpilot/controls/starpilot_card.py +++ b/starpilot/controls/starpilot_card.py @@ -4,7 +4,7 @@ from opendbc.car.chrysler.values import pacifica_hybrid_aol_requires_set_press from opendbc.car.hyundai.values import CAR as HYUNDAI_CAR, HyundaiFlags from opendbc.safety import ALTERNATIVE_EXPERIENCE from openpilot.common.params import Params -from openpilot.selfdrive.car.cruise import CRUISE_LONG_PRESS, ButtonType +from openpilot.selfdrive.car.cruise import CRUISE_LONG_PRESS, ButtonType, is_speed_limit_confirmation_pending from openpilot.selfdrive.selfdrived.events import ET from openpilot.starpilot.common.experimental_state import ( @@ -57,6 +57,8 @@ class StarPilotCard: self.params_memory = Params(memory=True) self.accel_pressed = False + self.confirmation_button_suppressed = set() + self.pressed_accel_buttons = set() self.always_on_lateral_allowed = False self.controller_aol_override = None self.pacifica_aol_set_seen = False @@ -271,6 +273,23 @@ class StarPilotCard: ] button_event_types = [self._button_type_raw(be) for be in carState.buttonEvents] + accel_button_types = (int(ButtonType.accelCruise), int(ButtonType.resumeCruise)) + confirmation_pending = is_speed_limit_confirmation_pending(sm["starpilotPlan"]) + if confirmation_pending: + self.confirmation_button_suppressed.update(self.pressed_accel_buttons) + suppressed_releases = set() + for be, be_type in zip(carState.buttonEvents, button_event_types, strict=False): + if be_type not in accel_button_types: + continue + if be.pressed: + self.pressed_accel_buttons.add(be_type) + if confirmation_pending: + self.confirmation_button_suppressed.add(be_type) + else: + self.pressed_accel_buttons.discard(be_type) + if be_type in self.confirmation_button_suppressed: + self.confirmation_button_suppressed.remove(be_type) + suppressed_releases.add(be_type) button_aol_supported = self.always_on_lateral_supported and ( self.CP.brand == "hyundai" or starpilot_toggles.lkas_allowed_for_aol ) @@ -392,8 +411,11 @@ class StarPilotCard: if not self.always_on_lateral_supported: self.always_on_lateral_allowed = False - if sm.updated["starpilotPlan"] or any(be_type in (ButtonType.accelCruise, ButtonType.resumeCruise) for be_type in button_event_types): - self.accel_pressed = any(be_type in (ButtonType.accelCruise, ButtonType.resumeCruise) for be_type in button_event_types) + if sm.updated["starpilotPlan"] or any(be_type in accel_button_types for be_type in button_event_types): + self.accel_pressed = any( + be_type in accel_button_types and (be.pressed or be_type not in suppressed_releases) + for be, be_type in zip(carState.buttonEvents, button_event_types, strict=False) + ) if sm.updated["starpilotPlan"] or any(be_type == ButtonType.decelCruise for be_type in button_event_types): self.decel_pressed = any(be_type == ButtonType.decelCruise for be_type in button_event_types) diff --git a/starpilot/controls/starpilot_planner.py b/starpilot/controls/starpilot_planner.py index 7eda736be1..a8e21b506c 100644 --- a/starpilot/controls/starpilot_planner.py +++ b/starpilot/controls/starpilot_planner.py @@ -382,7 +382,7 @@ class StarPilotPlanner: starpilotPlan.slcSpeedLimit = self.starpilot_vcruise.slc_target starpilotPlan.slcSpeedLimitOffset = self.starpilot_vcruise.slc_offset starpilotPlan.slcSpeedLimitSource = self.starpilot_vcruise.slc.source - starpilotPlan.speedLimitChanged = self.starpilot_vcruise.slc.speed_limit_changed_timer > DT_MDL + starpilotPlan.speedLimitChanged = self.starpilot_vcruise.slc.confirmation_pending starpilotPlan.unconfirmedSlcSpeedLimit = self.starpilot_vcruise.slc.unconfirmed_speed_limit starpilotPlan.themeUpdated = theme_updated diff --git a/starpilot/controls/tests/test_personality_longitudinal_profiles.py b/starpilot/controls/tests/test_personality_longitudinal_profiles.py index 80ae7fcdc3..95f5816020 100644 --- a/starpilot/controls/tests/test_personality_longitudinal_profiles.py +++ b/starpilot/controls/tests/test_personality_longitudinal_profiles.py @@ -39,8 +39,8 @@ sys.modules["openpilot.selfdrive.controls.lib.longitudinal_planner"] = _module( ) sys.modules["openpilot.starpilot.controls.lib.starpilot_vcruise"] = _module( "openpilot.starpilot.controls.lib.starpilot_vcruise", - get_active_slc_control_target=lambda enabled, set_speed_limit, target, offset, overridden_speed, *_args, **_kwargs: ( - float(overridden_speed or target) + float(offset) if enabled and set_speed_limit else 0.0 + get_active_slc_control_target=lambda enabled, target, offset, overridden_speed, *_args, **_kwargs: ( + float(overridden_speed or target) + float(offset) if enabled else 0.0 ), ) diff --git a/starpilot/controls/tests/test_starpilot_card.py b/starpilot/controls/tests/test_starpilot_card.py index 70f579a0f4..25ee4db5d0 100644 --- a/starpilot/controls/tests/test_starpilot_card.py +++ b/starpilot/controls/tests/test_starpilot_card.py @@ -59,7 +59,7 @@ def make_sm(): "carControl": SimpleNamespace(longActive=False), "selfdriveState": SimpleNamespace(active=False, alertType=[], experimentalMode=False), "starpilotSelfdriveState": SimpleNamespace(alertType=[]), - "starpilotPlan": SimpleNamespace(lateralCheck=True), + "starpilotPlan": SimpleNamespace(lateralCheck=True, speedLimitChanged=False, unconfirmedSlcSpeedLimit=0.0), "liveCalibration": SimpleNamespace(calPerc=100), }, updated={"starpilotPlan": False}) @@ -295,6 +295,37 @@ def make_wrapped_button_event(button_type, pressed): return SimpleNamespace(type=SimpleNamespace(raw=int(button_type)), pressed=pressed) +@pytest.mark.parametrize("pending_before_press", [False, True]) +def test_slc_confirmation_release_does_not_republish_accel(monkeypatch, tmp_path, pending_before_press): + monkeypatch.setattr(spc, "Params", FakeParams) + monkeypatch.setattr(spc, "ERROR_LOGS_PATH", tmp_path) + card = spc.StarPilotCard(SimpleNamespace(brand="gm"), SimpleNamespace(alternativeExperience=0)) + sm = make_sm() + toggles = make_toggles(speed_limit_controller=True) + starpilot_car_state = SimpleNamespace(distancePressed=False) + button_type = spc.ButtonType.accelCruise + + if pending_before_press: + sm["starpilotPlan"].speedLimitChanged = True + sm["starpilotPlan"].unconfirmedSlcSpeedLimit = 20.0 + pressed = make_car_state(button_events=[make_wrapped_button_event(button_type, True)]) + assert card.update(pressed, starpilot_car_state, sm, toggles).accelPressed + + if not pending_before_press: + sm["starpilotPlan"].speedLimitChanged = True + sm["starpilotPlan"].unconfirmedSlcSpeedLimit = 20.0 + card.update(make_car_state(), starpilot_car_state, sm, toggles) + + sm["starpilotPlan"].speedLimitChanged = False + sm["starpilotPlan"].unconfirmedSlcSpeedLimit = 0.0 + released = make_car_state(button_events=[make_wrapped_button_event(button_type, False)]) + assert not card.update(released, starpilot_car_state, sm, toggles).accelPressed + assert not card.confirmation_button_suppressed + + assert card.update(pressed, starpilot_car_state, sm, toggles).accelPressed + assert card.update(released, starpilot_car_state, sm, toggles).accelPressed + + @pytest.mark.parametrize( ("car_fingerprint", "expect_normalized_release"), (