Efficiency batch 1

Wave A (pure refactors):

A2: nnff toggle moved to front of NNFF check — kills ~100 IPC reads/sec when NNFF disabled
A4: 3 filters now use update_alpha() instead of being recreated — ~60 allocs/sec eliminated
Wave B (write reduction):

B1: CEStatus only writes on state transitions (+ E3 folded in: extracted ce_write_value local at both sites). Reset path added in the manual-override branch. ~19 writes/sec saved during cruise
B2: GPS position only persists when compass is enabled AND bearing shifts >0.5° (+ E1 folded in: json.dumps inside the gate). ~95% of writes eliminated on highway
Wave C (polling throttles):

C1: Onscreen distance button reads at 10 Hz instead of 100 Hz — ~90 IPC reads/sec eliminated. Wheel button unaffected
C2: SpeedLimitAccepted IPC read throttled to 5 Hz via existing _slc_adopt_counter. Wheel accel still instant
C3: Lane width numpy calls at 5 Hz instead of 20 Hz — ~300 allocs/sec eliminated. Counter resets when speed drops below threshold so values are fresh on re-entry

starpilot/controls/lib/conditional_experimental_mode.py

@@ -100,6 +100,7 @@ class ConditionalExperimentalMode:
     self.prev_experimental_mode = False  # For hysteresis
     self.mode_hold_until = 0.0
     self.mode_false_since = 0.0
+    self._prev_ce_status = None
 
   def update(self, v_ego, sm, starpilot_toggles):
     now = time.monotonic()
@@ -125,7 +126,10 @@ class ConditionalExperimentalMode:
 
       self.experimental_mode = triggered or hold_active or transition_buffer_active
       self.prev_experimental_mode = self.experimental_mode
-      self.params_memory.put_int("CEStatus", self.status_value if self.experimental_mode else CEStatus["OFF"])
+      ce_write_value = self.status_value if self.experimental_mode else CEStatus["OFF"]
+      if ce_write_value != self._prev_ce_status:
+        self.params_memory.put_int("CEStatus", ce_write_value)
+        self._prev_ce_status = ce_write_value
     elif not is_manual_ce_status(self.status_value):
       self.mode_hold_until = 0.0
       self.mode_false_since = 0.0
@@ -139,10 +143,14 @@ class ConditionalExperimentalMode:
       self.experimental_mode = standstill_stop_hold
       self.prev_experimental_mode = self.experimental_mode
       self.status_value = CEStatus["STOP_LIGHT"] if self.experimental_mode else CEStatus["OFF"]
-      self.params_memory.put_int("CEStatus", self.status_value if self.experimental_mode else CEStatus["OFF"])
+      ce_write_value = self.status_value
+      if ce_write_value != self._prev_ce_status:
+        self.params_memory.put_int("CEStatus", ce_write_value)
+        self._prev_ce_status = ce_write_value
     else:
       self.mode_hold_until = 0.0
       self.mode_false_since = 0.0
+      self._prev_ce_status = None
       self.experimental_mode = self.status_value == CEStatus["USER_OVERRIDDEN"]
       self.prev_experimental_mode = self.experimental_mode
       self.stop_light_detected &= not is_manual_ce_status(self.status_value)
@@ -318,9 +326,9 @@ class ConditionalExperimentalMode:
       cap_factor = interp(speed_mph, bp, [low_cap_factor, low_cap_factor, tuned_cap_factor])
 
       # Update filter times with interp
-      self.curvature_filter = FirstOrderFilter(self.curvature_filter.x, filter_time_curves, DT_MDL)
-      self.slow_lead_filter = FirstOrderFilter(self.slow_lead_filter.x, filter_time_leads, DT_MDL)
-      self.stop_light_filter = FirstOrderFilter(self.stop_light_filter.x, filter_time_lights, DT_MDL)
+      self.curvature_filter.update_alpha(filter_time_curves)
+      self.slow_lead_filter.update_alpha(filter_time_leads)
+      self.stop_light_filter.update_alpha(filter_time_lights)
       self.lead_clear_filter.update_alpha(lead_clear_filter_time)
 
       # Disable stoplight detection at very high speeds to prevent false positives

starpilot/controls/lib/speed_limit_controller.py

@@ -257,7 +257,9 @@ class SpeedLimitController:
     had_override = self.override_active(v_ego, sm["carState"].gasPressed)
 
     long_active = sm["carControl"].longActive
-    speed_limit_accepted = (sm["starpilotCarState"].accelPressed and long_active) or self.starpilot_planner.params_memory.get_bool("SpeedLimitAccepted")
+    speed_limit_accepted = sm["starpilotCarState"].accelPressed and long_active
+    if not speed_limit_accepted and self._slc_adopt_counter % 4 == 0:
+      speed_limit_accepted = self.starpilot_planner.params_memory.get_bool("SpeedLimitAccepted")
     speed_limit_denied = sm["starpilotCarState"].decelPressed or (self.speed_limit_changed_timer >= 30 and long_active)
 
     if not long_active and not sm["selfdriveState"].enabled:

starpilot/controls/lib/starpilot_events.py

@@ -42,7 +42,8 @@ class StarPilotEvents:
     current_starpilot_alert = sm["selfdriveState"].alertType
     switchback_mode_enabled = self.starpilot_planner.params_memory.get_bool("SwitchbackModeEnabled")
 
-    alerts_empty = all(sm[state].alertText1 == "" and sm[state].alertText2 == "" for state in ["selfdriveState", "starpilotSelfdriveState"])
+    alerts_empty = (sm["selfdriveState"].alertText1 == "" and sm["selfdriveState"].alertText2 == "" and
+                    sm["starpilotSelfdriveState"].alertText1 == "" and sm["starpilotSelfdriveState"].alertText2 == "")
 
     self.events.clear()
 
@@ -89,7 +90,7 @@ class StarPilotEvents:
     else:
       self.tracked_lead_distance = 0
 
-    if "nnffLoaded" not in self.played_events and self.startup_seen and alerts_empty and len(self.events) == 0 and self.starpilot_planner.params.get("NNFFModelName") is not None and starpilot_toggles.nnff:
+    if starpilot_toggles.nnff and "nnffLoaded" not in self.played_events and self.startup_seen and alerts_empty and len(self.events) == 0 and self.starpilot_planner.params.get("NNFFModelName") is not None:
       self.events.add(StarPilotEventName.nnffLoaded)
 
     if self.random_event_playing:

starpilot/controls/starpilot_card.py

@@ -37,6 +37,8 @@ class StarPilotCard:
     self.traffic_mode_enabled = False
 
     self.gap_counter = 0
+    self._distance_poll_counter = 0
+    self._onroad_distance_pressed = False
 
     self.always_on_lateral_set = bool(FPCP.alternativeExperience & ALTERNATIVE_EXPERIENCE.ALWAYS_ON_LATERAL)
     self.frogs_go_moo = is_FrogsGoMoo()
@@ -126,7 +128,11 @@ class StarPilotCard:
     if sm.updated["starpilotPlan"] or any(be.type == ButtonType.decelCruise for be in carState.buttonEvents):
       self.decel_pressed = any(be.type == ButtonType.decelCruise for be in carState.buttonEvents)
 
-    starpilotCarState.distancePressed |= self.params_memory.get_bool("OnroadDistanceButtonPressed")
+    self._distance_poll_counter += 1
+    if self._distance_poll_counter >= 10:
+      self._distance_poll_counter = 0
+      self._onroad_distance_pressed = self.params_memory.get_bool("OnroadDistanceButtonPressed")
+    starpilotCarState.distancePressed |= self._onroad_distance_pressed
 
     if starpilotCarState.distancePressed:
       self.gap_counter += 1

starpilot/controls/starpilot_planner.py

@@ -55,9 +55,11 @@ class StarPilotPlanner:
     self.model_stopped = False
     self.road_curvature_detected = False
     self.tracking_lead = False
+    self._prev_gps_bearing = 0
 
     self.lane_width_left = 0
     self.lane_width_right = 0
+    self._lane_width_counter = 0
     self.lateral_acceleration = 0
     self.model_length = 0
     self.road_curvature = 0
@@ -98,12 +100,18 @@ class StarPilotPlanner:
       "bearing": gps_location.bearingDeg,
     }
     self.gps_valid = self.gps_position["latitude"] != 0 or self.gps_position["longitude"] != 0
-    self.params_memory.put("LastGPSPosition", json.dumps(self.gps_position))
+    bearing = self.gps_position["bearing"]
+    if starpilot_toggles.compass and abs(bearing - self._prev_gps_bearing) > 0.5:
+      self.params_memory.put("LastGPSPosition", json.dumps(self.gps_position))
+      self._prev_gps_bearing = bearing
 
     if v_ego >= starpilot_toggles.minimum_lane_change_speed:
-      self.lane_width_left = calculate_lane_width(sm["modelV2"].laneLines[0], sm["modelV2"].laneLines[1], sm["modelV2"].roadEdges[0])
-      self.lane_width_right = calculate_lane_width(sm["modelV2"].laneLines[3], sm["modelV2"].laneLines[2], sm["modelV2"].roadEdges[1])
+      self._lane_width_counter += 1
+      if self._lane_width_counter % 4 == 0:
+        self.lane_width_left = calculate_lane_width(sm["modelV2"].laneLines[0], sm["modelV2"].laneLines[1], sm["modelV2"].roadEdges[0])
+        self.lane_width_right = calculate_lane_width(sm["modelV2"].laneLines[3], sm["modelV2"].laneLines[2], sm["modelV2"].roadEdges[1])
     else:
+      self._lane_width_counter = 0
       self.lane_width_left = 0
       self.lane_width_right = 0