DM: update escalation/lockout specs; softer sounds (#38244)

openpilot/cereal/log.capnp

@@ -791,6 +791,8 @@ struct SelfdriveState {
     prompt @6;
     promptRepeat @7;
     promptDistracted @8;
+
+    preAlert @9;
   }
 
   enum OpenpilotState @0xdbe58b96d2d1ac61 {
@@ -2139,8 +2141,10 @@ struct DriverMonitoringStateDEPRECATED @0xb83cda094a1da284 {
 
 struct DriverMonitoringState {
   lockout @0 :Bool;
-  alertCountLockoutPercent @1 :Int8;
-  alertTimeLockoutPercent @2 :Int8;
+  lockoutRecoveryPercent @11 :Int8;
+  alert3Count @12 :Int8;
+  noResponseCount @13 :Int8;
+  noResponseForceDecel @14 :Bool;
 
   alwaysOn @3 :Bool;
   alwaysOnLockout @4 :Bool;
@@ -2204,6 +2208,11 @@ struct DriverMonitoringState {
     calibratedPercent @0 :Int8;
     offset @1 :Float32;
   }
+
+  deprecated :group {
+    alertCountLockoutPercent @1 :Int8;
+    alertTimeLockoutPercent @2 :Int8;
+  }
 }
 
 struct Boot {

openpilot/selfdrive/assets/sounds/pre_alert.wav

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

openpilot/selfdrive/assets/sounds/prompt_distracted.wav

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1810ad0418ac234f02dec005883c8f0e1c3e0e5ece7a3157803c5a66cb8e5adc
-size 85662
+oid sha256:412ef25d2fb103c1ebd55c667313a5921493305fb4e1f4e1dafc08d3b95d86ab
+size 73026

openpilot/selfdrive/controls/controlsd.py

@@ -200,7 +200,7 @@ class Controls:
     cs.upAccelCmd = float(self.LoC.pid.p)
     cs.uiAccelCmd = float(self.LoC.pid.i)
     cs.ufAccelCmd = float(self.LoC.pid.f)
-    cs.forceDecel = bool((self.sm['driverMonitoringState'].alertLevel == log.DriverMonitoringState.AlertLevel.three) or
+    cs.forceDecel = bool(self.sm['driverMonitoringState'].noResponseForceDecel or
                          (self.sm['selfdriveState'].state == State.softDisabling))
 
     # trigger the car's stock driver monitoring escalation

openpilot/selfdrive/monitoring/policy.py

@@ -25,21 +25,27 @@ def to_percent(v):
 
 class DRIVER_MONITOR_SETTINGS:
   def __init__(self):
-    # https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:42018X1947&rid=2
-    self._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT = 15.
-    self._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT = 24.
-    self._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT = 30.
-    # https://cdn.euroncap.com/cars/assets/euro_ncap_protocol_safe_driving_driver_engagement_v11_a30e874152.pdf
-    self._VISION_POLICY_ALERT_1_TIMEOUT = 3.
-    self._VISION_POLICY_ALERT_2_TIMEOUT = 5.
-    self._VISION_POLICY_ALERT_3_TIMEOUT = 11.
+    # https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=OJ:L_202501899
+    self._ALERT_MIN_SPEED = 2.8  # 10 km/h
+
+    self._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT = 5.
+    self._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT = 15.
+    self._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT = 25.
+    self._VISION_POLICY_ALERT_1_TIMEOUT = 5.
+    self._VISION_POLICY_ALERT_2_TIMEOUT = 8.
+    self._VISION_POLICY_ALERT_3_TIMEOUT = 13.
+
+    # no response = alert_3 sustained for certain amount of time
+    self._NO_RESPONSE_TIMEOUT = 5.
+
+    # lockout specs
+    self._MAX_ALERT_3 = 2
+    self._MAX_NO_RESPONSE = 1
+    self._LOCKOUT_TIME = int(1800 / DT_DMON)
 
     self._TIMEOUT_RECOVERY_FACTOR_MAX = 5.
     self._TIMEOUT_RECOVERY_FACTOR_MIN = 1.25
 
-    self._MAX_TERMINAL_ALERTS = 3  # not allowed to engage after 3 terminal alerts
-    self._MAX_TERMINAL_DURATION = int(30 / DT_DMON)  # not allowed to engage after 30s of terminal alerts
-
     self._FACE_THRESHOLD = 0.7
     self._EYE_THRESHOLD = 0.65
     self._SG_THRESHOLD = 0.9
@@ -142,8 +148,11 @@ class DriverMonitoring:
     self.wheel_on_right_last = None
     self.wheel_on_right_default = rhd_saved
     self.face_detected = False
-    self.terminal_alert_cnt = 0
-    self.terminal_time = 0
+    self.alert_3_cnt = 0
+    self.cnt_since_alert_3 = 0
+    self.no_response_timeout = int(self.settings._NO_RESPONSE_TIMEOUT / DT_DMON)
+    self.no_response_cnt = 0
+    self.lockout_time = 0
     self.step_change = 0.
     self.active_policy = MonitoringPolicy.vision
     self.driver_interacting = False
@@ -230,7 +239,7 @@ class DriverMonitoring:
     self.distracted_types['eye'] = bool((self.blink.left + self.blink.right)*0.5 > self.settings._BLINK_THRESHOLD)
     self.distracted_types['phone'] = bool(self.phone_prob > self.settings._PHONE_THRESH)
 
-  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged, standstill, demo_mode=False, steering_angle_deg=0.):
+  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged, lowspeed, demo_mode=False, steering_angle_deg=0.):
     rhd_pred = driver_state.wheelOnRightProb
     # calibrates only when there's movement and either face detected
     if car_speed > self.settings._WHEELPOS_CALIB_MIN_SPEED and (driver_state.leftDriverData.faceProb > self.settings._FACE_THRESHOLD or
@@ -281,7 +290,7 @@ class DriverMonitoring:
 
     if self.face_detected and not self.driver_distracted:
       dcam_uncertain = self.model_std_max > self.settings._DCAM_UNCERTAIN_ALERT_THRESHOLD
-      if dcam_uncertain and not standstill:
+      if dcam_uncertain and not lowspeed:
         self.dcam_uncertain_cnt += 1
         self.dcam_reset_cnt = 0
       else:
@@ -296,14 +305,22 @@ class DriverMonitoring:
     elif self.face_detected and self.pose.low_std:
       self.hi_stds = 0
 
-  def _update_events(self, driver_engaged, op_engaged, standstill, wrong_gear):
+  def _update_events(self, driver_engaged, op_engaged, lowspeed, wrong_gear):
     self.alert_level = AlertLevel.none
     self.driver_interacting = driver_engaged
 
-    if self.terminal_alert_cnt >= self.settings._MAX_TERMINAL_ALERTS or \
-       self.terminal_time >= self.settings._MAX_TERMINAL_DURATION:
+    if self.alert_3_cnt >= self.settings._MAX_ALERT_3 or self.no_response_cnt >= self.settings._MAX_NO_RESPONSE:
       self.too_distracted = True
 
+    if self.too_distracted:
+      self.lockout_time += 1
+      if self.lockout_time > self.settings._LOCKOUT_TIME:
+        self.too_distracted = False
+        self.alert_3_cnt = 0
+        self.cnt_since_alert_3 = 0
+        self.no_response_cnt = 0
+        self.lockout_time = 0
+
     always_on_valid = self.always_on and not wrong_gear
     if (self.driver_interacting and self.awareness > 0 and self.active_policy == MonitoringPolicy.wheeltouch) or \
        (not always_on_valid and not op_engaged) or \
@@ -315,11 +332,11 @@ class DriverMonitoring:
     awareness_prev = self.awareness
     _reaching_alert_1 = self.awareness - self.step_change <= self.threshold_alert_1
     _reaching_alert_3 = self.awareness - self.step_change <= 0
-    standstill_exemption = standstill and _reaching_alert_1
+    lowspeed_exemption = lowspeed and _reaching_alert_1
     always_on_exemption = always_on_valid and not op_engaged and _reaching_alert_3
 
     if self.awareness > 0 and \
-       ((self.driver_distraction_filter.x < 0.37 and self.face_detected and self.pose.low_std) or standstill_exemption):
+       ((self.driver_distraction_filter.x < 0.37 and self.face_detected and self.pose.low_std) or lowspeed_exemption):
       if self.driver_interacting:
         self._reset_awareness()
         return
@@ -336,21 +353,26 @@ class DriverMonitoring:
     maybe_distracted = self.is_model_uncertain or not self.face_detected
 
     if certainly_distracted or maybe_distracted:
-      # should always be counting if distracted unless at standstill and reaching green
+      # should always be counting if distracted unless at low speed and reaching green
       # also will not be reaching 0 if DM is active when not engaged
-      if not (standstill_exemption or always_on_exemption):
+      if not (lowspeed_exemption or always_on_exemption):
         self.awareness = max(self.awareness - self.step_change, -0.1)
 
     if self.awareness <= 0.:
       # terminal alert: disengagement required
       self.alert_level = AlertLevel.three
-      self.terminal_time += 1
       if awareness_prev > 0.:
-        self.terminal_alert_cnt += 1
-    elif self.awareness <= self.threshold_alert_2:
-      self.alert_level = AlertLevel.two
-    elif self.awareness <= self.threshold_alert_1:
-      self.alert_level = AlertLevel.one
+        self.alert_3_cnt += 1
+        self.cnt_since_alert_3 = 0
+      else:
+        self.cnt_since_alert_3 += 1
+      if self.cnt_since_alert_3 == self.no_response_timeout:
+        self.no_response_cnt += 1
+    else:
+      if self.awareness <= self.threshold_alert_2:
+        self.alert_level = AlertLevel.two
+      elif self.awareness <= self.threshold_alert_1:
+        self.alert_level = AlertLevel.one
 
   def get_state_packet(self, valid=True):
     # build driverMonitoringState packet
@@ -358,8 +380,10 @@ class DriverMonitoring:
     dm = dat.driverMonitoringState
 
     dm.lockout = self.too_distracted
-    dm.alertCountLockoutPercent = to_percent(self.terminal_alert_cnt / self.settings._MAX_TERMINAL_ALERTS)
-    dm.alertTimeLockoutPercent = to_percent(self.terminal_time / self.settings._MAX_TERMINAL_DURATION)
+    dm.lockoutRecoveryPercent = to_percent(self.lockout_time / self.settings._LOCKOUT_TIME)
+    dm.alert3Count = self.alert_3_cnt
+    dm.noResponseCount = self.no_response_cnt
+    dm.noResponseForceDecel = self.alert_level == AlertLevel.three and self.cnt_since_alert_3 >= self.no_response_timeout
     dm.alwaysOn = self.always_on
     dm.alwaysOnLockout = self.always_on and self.awareness <= self.threshold_alert_2
     dm.alertLevel = self.alert_level
@@ -396,7 +420,7 @@ class DriverMonitoring:
       car_speed = 30
       enabled = True
       wrong_gear = False
-      standstill = False
+      lowspeed = False
       driver_engaged = False
       brake_disengage_prob = 1.0
       steering_angle_deg = 0.0
@@ -405,7 +429,7 @@ class DriverMonitoring:
       car_speed = sm['carState'].vEgo
       enabled = sm['selfdriveState'].enabled
       wrong_gear = sm['carState'].gearShifter not in (car.CarState.GearShifter.drive, car.CarState.GearShifter.low)
-      standstill = sm['carState'].standstill
+      lowspeed = car_speed < self.settings._ALERT_MIN_SPEED
       driver_engaged = sm['carState'].steeringPressed or sm['carState'].gasPressed
       brake_disengage_prob = sm['modelV2'].meta.disengagePredictions.brakeDisengageProbs[0] # brake disengage prob in next 2s
       steering_angle_deg = sm['carState'].steeringAngleDeg
@@ -422,7 +446,7 @@ class DriverMonitoring:
       cal_rpy=rpyCalib,
       car_speed=car_speed,
       op_engaged=enabled,
-      standstill=standstill,
+      lowspeed=lowspeed,
       demo_mode=demo,
       steering_angle_deg=steering_angle_deg,
     )
@@ -431,6 +455,6 @@ class DriverMonitoring:
     self._update_events(
       driver_engaged=driver_engaged,
       op_engaged=enabled,
-      standstill=standstill,
+      lowspeed=lowspeed,
       wrong_gear=wrong_gear,
     )

openpilot/selfdrive/monitoring/test_monitoring.py

@@ -1,5 +1,3 @@
-import numpy as np
-
 from openpilot.cereal import log
 from openpilot.common.realtime import DT_DMON
 from openpilot.selfdrive.monitoring.policy import DriverMonitoring, DRIVER_MONITOR_SETTINGS
@@ -49,15 +47,15 @@ always_true = [True] * int(TEST_TIMESPAN / DT_DMON)
 always_false = [False] * int(TEST_TIMESPAN / DT_DMON)
 
 class TestMonitoring:
-  def _run_seq(self, msgs, interaction, engaged, standstill):
+  def _run_seq(self, msgs, interaction, engaged, lowspeed):
     DM = DriverMonitoring()
     alert_lvls = []
     for idx in range(len(msgs)):
-      DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx], standstill[idx])
+      DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx], lowspeed[idx])
       # cal_rpy and car_speed don't matter here
 
       # evaluate events at 10Hz for tests
-      DM._update_events(interaction[idx], engaged[idx], standstill[idx], 0)
+      DM._update_events(interaction[idx], engaged[idx], lowspeed[idx], 0)
       alert_lvls.append(DM.alert_level)
     assert len(alert_lvls) == len(msgs), f"got {len(alert_lvls)} for {len(msgs)} driverState input msgs"
     return alert_lvls, DM
@@ -82,6 +80,25 @@ class TestMonitoring:
                     (TEST_TIMESPAN - 10 - s._VISION_POLICY_ALERT_3_TIMEOUT) / 2) / DT_DMON)] == 3
     assert isinstance(d_status.awareness, float)
 
+  # engaged, distracted past red and beyond the no-response window -> unavailability response + lockout
+  def test_distracted_lockout(self):
+    alert_lvls, d_status = self._run_seq(always_distracted, always_false, always_true, always_false)
+    s = d_status.settings
+    assert alert_lvls[int(DISTRACTED_SECONDS_TO_RED / DT_DMON)] == 3
+    assert d_status.alert_3_cnt == 1
+    assert d_status.no_response_cnt == s._MAX_NO_RESPONSE
+    assert d_status.too_distracted
+    assert d_status.lockout_time > 0
+
+  # no face -> wheeltouch red, sustained past the no-response timeout -> unavailability response + lockout
+  def test_invisible_lockout(self):
+    _, d_status = self._run_seq(always_no_face, always_false, always_true, always_false)
+    s = d_status.settings
+    assert d_status.active_policy == log.DriverMonitoringState.MonitoringPolicy.wheeltouch
+    assert d_status.alert_3_cnt == 1
+    assert d_status.no_response_cnt == s._MAX_NO_RESPONSE
+    assert d_status.too_distracted
+
   # engaged, no face detected the whole time, no action
   def test_fully_invisible_driver(self):
     alert_lvls, d_status = self._run_seq(always_no_face, always_false, always_true, always_false)
@@ -137,22 +154,22 @@ class TestMonitoring:
   # engaged, invisible driver, down to orange, driver touches wheel; then down to orange again, driver appears
   #  - both actions should clear the alert, but momentary appearance should not
   def test_sometimes_transparent_commuter(self):
-    _visible_time = np.random.choice([0.5, 10])
-    ds_vector = always_no_face[:]*2
-    interaction_vector = always_false[:]*2
-    ds_vector[int((2*INVISIBLE_SECONDS_TO_ORANGE+1)/DT_DMON):int((2*INVISIBLE_SECONDS_TO_ORANGE+1+_visible_time)/DT_DMON)] = \
-                                                                                             [msg_ATTENTIVE] * int(_visible_time/DT_DMON)
-    interaction_vector[int((INVISIBLE_SECONDS_TO_ORANGE)/DT_DMON):int((INVISIBLE_SECONDS_TO_ORANGE+1)/DT_DMON)] = [True] * int(1/DT_DMON)
-    alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, 2*always_true, 2*always_false)
-    assert alert_lvls[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)] == 0
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)] == 2
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE+0.1)/DT_DMON)] == 0
-    if _visible_time == 0.5:
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)] == 2
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)] == 1
-    elif _visible_time == 10:
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)] == 2
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)] == 0
+    for _visible_time in (0.5, 10):
+      ds_vector = always_no_face[:]*2
+      interaction_vector = always_false[:]*2
+      ds_vector[int((2*INVISIBLE_SECONDS_TO_ORANGE+1)/DT_DMON):int((2*INVISIBLE_SECONDS_TO_ORANGE+1+_visible_time)/DT_DMON)] = \
+                                                                                               [msg_ATTENTIVE] * int(_visible_time/DT_DMON)
+      interaction_vector[int((INVISIBLE_SECONDS_TO_ORANGE)/DT_DMON):int((INVISIBLE_SECONDS_TO_ORANGE+1)/DT_DMON)] = [True] * int(1/DT_DMON)
+      alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, 2*always_true, 2*always_false)
+      assert alert_lvls[int(dm_settings._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT/2/DT_DMON)] == 0
+      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)] == 2
+      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE+0.1)/DT_DMON)] == 0
+      if _visible_time == 0.5:
+        assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)] == 2
+        assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)] == 2
+      elif _visible_time == 10:
+        assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)] == 2
+        assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)] == 0
 
   # engaged, invisible driver, down to red, driver appears and then touches wheel, then disengages/reengages
   #  - only disengage will clear the alert
@@ -165,7 +182,7 @@ class TestMonitoring:
     interaction_vector[int((INVISIBLE_SECONDS_TO_RED+_visible_time)/DT_DMON):int((INVISIBLE_SECONDS_TO_RED+_visible_time+1)/DT_DMON)] = [True] * int(1/DT_DMON)
     op_vector[int((INVISIBLE_SECONDS_TO_RED+_visible_time+1)/DT_DMON):int((INVISIBLE_SECONDS_TO_RED+_visible_time+0.5)/DT_DMON)] = [False] * int(0.5/DT_DMON)
     alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, op_vector, always_false)
-    assert alert_lvls[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)] == 0
+    assert alert_lvls[int(dm_settings._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT/2/DT_DMON)] == 0
     assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)] == 2
     assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED-0.1)/DT_DMON)] == 3
     assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED+0.5*_visible_time)/DT_DMON)] == 3
@@ -182,9 +199,9 @@ class TestMonitoring:
   #  - should only reach green when stopped, but continues counting down on launch
   def test_long_traffic_light_victim(self):
     _redlight_time = 60  # seconds
-    standstill_vector = always_true[:]
-    standstill_vector[int(_redlight_time/DT_DMON):] = [False] * int((TEST_TIMESPAN-_redlight_time)/DT_DMON)
-    alert_lvls, d_status = self._run_seq(always_distracted, always_false, always_true, standstill_vector)
+    lowspeed_vector = always_true[:]
+    lowspeed_vector[int(_redlight_time/DT_DMON):] = [False] * int((TEST_TIMESPAN-_redlight_time)/DT_DMON)
+    alert_lvls, d_status = self._run_seq(always_distracted, always_false, always_true, lowspeed_vector)
     s = d_status.settings
     assert alert_lvls[int((_redlight_time-0.1)/DT_DMON)] == 0
     _alert_1_to_2 = s._VISION_POLICY_ALERT_2_TIMEOUT - s._VISION_POLICY_ALERT_1_TIMEOUT
@@ -192,12 +209,12 @@ class TestMonitoring:
     assert alert_lvls[int((_redlight_time+_alert_1_to_2+0.5)/DT_DMON)] == 2
 
   # engaged, distracted while moving, then car stops after reaching orange
-  #  - should reset timer to pre green at standstill
+  #  - should reset timer to pre green at low speed
   def test_distracted_then_stops(self):
     _stop_time = DISTRACTED_SECONDS_TO_ORANGE + 1  # stop 1 second after reaching orange
-    standstill_vector = always_false[:]
-    standstill_vector[int(_stop_time/DT_DMON):] = [True] * int((TEST_TIMESPAN-_stop_time)/DT_DMON)
-    alert_lvls, _ = self._run_seq(always_distracted, always_false, always_true, standstill_vector)
+    lowspeed_vector = always_false[:]
+    lowspeed_vector[int(_stop_time/DT_DMON):] = [True] * int((TEST_TIMESPAN-_stop_time)/DT_DMON)
+    alert_lvls, _ = self._run_seq(always_distracted, always_false, always_true, lowspeed_vector)
     # just before and briefly after stopping: orange alert; goes away quickly after stopped
     assert alert_lvls[int((_stop_time+0.1)/DT_DMON)] == 2
     assert alert_lvls[int((_stop_time+0.5)/DT_DMON)] == 0

openpilot/selfdrive/selfdrived/events.py

@@ -10,8 +10,9 @@ from opendbc.car.structs import car
 import openpilot.cereal.messaging as messaging
 from openpilot.common.constants import CV
 from openpilot.common.git import get_short_branch
-from openpilot.common.realtime import DT_CTRL
+from openpilot.common.realtime import DT_CTRL, DT_DMON
 from openpilot.selfdrive.locationd.calibrationd import MIN_SPEED_FILTER
+from openpilot.selfdrive.monitoring.policy import DRIVER_MONITOR_SETTINGS
 from openpilot.system.micd import SAMPLE_RATE, SAMPLE_BUFFER
 from openpilot.selfdrive.ui.feedback.feedbackd import FEEDBACK_MAX_DURATION
 from openpilot.common.hardware import HARDWARE
@@ -22,6 +23,7 @@ VisualAlert = car.CarControl.HUDControl.VisualAlert
 AudibleAlert = log.SelfdriveState.AudibleAlert
 EventName = log.OnroadEvent.EventName
 
+DMON_LOCKOUT_TIME = DRIVER_MONITOR_SETTINGS()._LOCKOUT_TIME
 
 # Alert priorities
 class Priority(IntEnum):
@@ -264,6 +266,13 @@ def calibration_incomplete_alert(CP: car.CarParams, CS: car.CarState, sm: messag
     Priority.LOWEST, VisualAlert.none, AudibleAlert.none, .2)
 
 
+def too_distracted_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  if sm['driverMonitoringState'].lockout:
+    mins_left = max(1, round((100 - sm['driverMonitoringState'].lockoutRecoveryPercent) / 100 * DMON_LOCKOUT_TIME * DT_DMON / 60.))
+    return NoEntryAlert("Too Distracted", f"{mins_left} minute{'s' if mins_left != 1 else ''} Left")
+  return NoEntryAlert("Pay Attention to Engage")
+
+
 def audio_feedback_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
   duration = FEEDBACK_MAX_DURATION - ((sm['audioFeedback'].blockNum + 1) * SAMPLE_BUFFER / SAMPLE_RATE)
   return NormalPermanentAlert(
@@ -518,7 +527,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
       "Pay Attention",
       "",
       AlertStatus.normal, AlertSize.small,
-      Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+      Priority.LOW, VisualAlert.none, AudibleAlert.preAlert, .1),
   },
 
   EventName.driverDistracted2: {
@@ -785,7 +794,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
   },
 
   EventName.tooDistracted: {
-    ET.NO_ENTRY: NoEntryAlert("Distraction Level Too High"),
+    ET.NO_ENTRY: too_distracted_alert,
   },
 
   EventName.excessiveActuation: {
@@ -1038,7 +1047,7 @@ if HARDWARE.get_device_type() == 'mici':
         "Pay Attention",
         "",
         AlertStatus.normal, AlertSize.small,
-        Priority.LOW, VisualAlert.none, AudibleAlert.none, 2),
+        Priority.LOW, VisualAlert.none, AudibleAlert.preAlert, 2),
     },
     EventName.driverDistracted2: {
       ET.PERMANENT: Alert(

openpilot/selfdrive/selfdrived/selfdrived.py

@@ -189,10 +189,13 @@ class SelfdriveD:
 
     # Handle DM
     if not self.CP.notCar:
-      # Block engaging until ignition cycle after max number or time of distractions
+      # Block engaging until lockout times out or ignition reset
       if self.sm['driverMonitoringState'].lockout and not self.dm_lockout_set:
         self.params.put_bool("DriverTooDistracted", True)
         self.dm_lockout_set = True
+      elif not self.sm['driverMonitoringState'].lockout and self.dm_lockout_set:
+        self.params.remove("DriverTooDistracted")
+        self.dm_lockout_set = False
       # No entry conditions
       if self.sm['driverMonitoringState'].lockout or self.sm['driverMonitoringState'].alwaysOnLockout:
         self.events.add(EventName.tooDistracted)

openpilot/selfdrive/ui/mici/onroad/driver_camera_dialog.py

@@ -106,6 +106,7 @@ class BaseDriverCameraDialog(Widget):
 
     AudibleAlert = log.SelfdriveState.AudibleAlert
     ALERT_SOUNDS = {
+      'one': AudibleAlert.preAlert,
       'two': AudibleAlert.promptDistracted,
       'three': AudibleAlert.warningImmediate,
     }

openpilot/selfdrive/ui/soundd.py

@@ -43,6 +43,8 @@ sound_list: dict[int, tuple[str, int | None, float]] = {
   AudibleAlert.promptRepeat: ("prompt.wav", None, MAX_VOLUME),
   AudibleAlert.promptDistracted: ("prompt_distracted.wav", None, MAX_VOLUME),
 
+  AudibleAlert.preAlert: ("pre_alert.wav", 1, MAX_VOLUME),
+
   AudibleAlert.warningSoft: ("warning_soft.wav", None, MAX_VOLUME),
   AudibleAlert.warningImmediate: ("warning_immediate.wav", None, MAX_VOLUME),
 }

openpilot/selfdrive/ui/tests/test_soundd.py

@@ -1,5 +1,4 @@
-from openpilot.cereal import log
-from openpilot.cereal import messaging
+from openpilot.cereal import log, messaging
 from openpilot.cereal.messaging import SubMaster, PubMaster
 from openpilot.selfdrive.ui.soundd import SELFDRIVE_STATE_TIMEOUT, check_selfdrive_timeout_alert